openttd-mini: comparison yapf/yapf

equal deleted inserted replaced

-:6165e12570bf
+:106ed18a7675
 #ifndef  YAPF_COSTCACHE_HPP
 #define  YAPF_COSTCACHE_HPP
 /** CYapfSegmentCostCacheNoneT - the formal only yapf cost cache provider that implements
-PfNodeCacheFetch() and PfNodeCacheFlush() callbacks. Used when nodes don't have CachedData
+* PfNodeCacheFetch() and PfNodeCacheFlush() callbacks. Used when nodes don't have CachedData
-defined (they don't count with any segment cost caching).
+* defined (they don't count with any segment cost caching).
 */
 template <class Types>
 class CYapfSegmentCostCacheNoneT
 {
 public:
 	typedef typename Types::Tpf Tpf;              ///< the pathfinder class (derived from THIS class)
 	typedef typename Types::NodeList::Titem Node; ///< this will be our node type
 	/** Called by YAPF to attach cached or local segment cost data to the given node.
-	*   @return true if globally cached data were used or false if local data was used */
+	 *  @return true if globally cached data were used or false if local data was used */
 	FORCEINLINE bool PfNodeCacheFetch(Node& n)
 	{
 		return false;
 	};
 	/** Called by YAPF to flush the cached segment cost data back into cache storage.
-	*   Current cache implementation doesn't use that. */
+	 *  Current cache implementation doesn't use that. */
 	FORCEINLINE void PfNodeCacheFlush(Node& n)
 	{
 	};
 };
 /** CYapfSegmentCostCacheLocalT - the yapf cost cache provider that implements fake segment
-cost caching functionality for yapf. Used when node needs caching, but you don't want to
+* cost caching functionality for yapf. Used when node needs caching, but you don't want to
-cache the segment costs.
+* cache the segment costs.
 */
 template <class Types>
 class CYapfSegmentCostCacheLocalT
 {
 public:
 	typedef typename Types::Tpf Tpf;              ///< the pathfinder class (derived from THIS class)
 	/// to access inherited path finder
 	FORCEINLINE Tpf& Yapf() {return *static_cast<Tpf*>(this);}
 public:
 	/** Called by YAPF to attach cached or local segment cost data to the given node.
-	*   @return true if globally cached data were used or false if local data was used */
+	 *  @return true if globally cached data were used or false if local data was used */
 	FORCEINLINE bool PfNodeCacheFetch(Node& n)
 	{
 		CacheKey key(n.GetKey());
 		Yapf().ConnectNodeToCachedData(n, *new (&m_local_cache.AddNC()) CachedData(key));
 		return false;
 	};
 	/** Called by YAPF to flush the cached segment cost data back into cache storage.
-	*   Current cache implementation doesn't use that. */
+	 *  Current cache implementation doesn't use that. */
 	FORCEINLINE void PfNodeCacheFlush(Node& n)
 	{
 	};
 };
 /** Base class for segment cost cache providers. Contains global counter
-*   of track layout changes and static notification function called whenever
+*  of track layout changes and static notification function called whenever
-*   the track layout changes. It is implemented as base class because it needs
+*  the track layout changes. It is implemented as base class because it needs
-*   to be shared between all rail YAPF types (one shared counter, one notification
+*  to be shared between all rail YAPF types (one shared counter, one notification
-*   function. */
+*  function. */
 struct CSegmentCostCacheBase
 {
 	static int   s_rail_change_counter;
 	static void NotifyTrackLayoutChange(TileIndex tile, Track track) {s_rail_change_counter++;}
 };
 /** CSegmentCostCacheT - template class providing hash-map and storage (heap)
-of Tsegment structures. Each rail node contains pointer to the segment
+*  of Tsegment structures. Each rail node contains pointer to the segment
-that contains cached (or non-cached) segment cost information. Nodes can
+*  that contains cached (or non-cached) segment cost information. Nodes can
-differ by key type, but they use the same segment type. Segment key should
+*  differ by key type, but they use the same segment type. Segment key should
-be always the same (TileIndex + DiagDirection) that represent the beginning
+*  be always the same (TileIndex + DiagDirection) that represent the beginning
-of the segment (origin tile and exit-dir from this tile).
+*  of the segment (origin tile and exit-dir from this tile).
-Different CYapfCachedCostT types can share the same type of CSegmentCostCacheT.
+*  Different CYapfCachedCostT types can share the same type of CSegmentCostCacheT.
-Look at CYapfRailSegment (yapf_node_rail.hpp) for the segment example */
+*  Look at CYapfRailSegment (yapf_node_rail.hpp) for the segment example */
 template <class Tsegment>
 struct CSegmentCostCacheT
 	: public CSegmentCostCacheBase
 {
 	enum {c_hash_bits = 14};
 		return *item;
 	}
 };
 /** CYapfSegmentCostCacheGlobalT - the yapf cost cache provider that adds the segment cost
-caching functionality to yapf. Using this class as base of your will provide the global
+*  caching functionality to yapf. Using this class as base of your will provide the global
-		segment cost caching services for your Nodes.
+*  segment cost caching services for your Nodes.
 */
 template <class Types>
 class CYapfSegmentCostCacheGlobalT
 	: public CYapfSegmentCostCacheLocalT<Types>
 {
 		return *pC;
 	}
 public:
 	/** Called by YAPF to attach cached or local segment cost data to the given node.
-	*   @return true if globally cached data were used or false if local data was used */
+	 *  @return true if globally cached data were used or false if local data was used */
 	FORCEINLINE bool PfNodeCacheFetch(Node& n)
 	{
 		if (!Yapf().CanUseGlobalCache(n)) {
 			return Tlocal::PfNodeCacheFetch(n);
 		}
 		Yapf().ConnectNodeToCachedData(n, item);
 		return found;
 	};
 	/** Called by YAPF to flush the cached segment cost data back into cache storage.
-	*   Current cache implementation doesn't use that. */
+	 *  Current cache implementation doesn't use that. */
 	FORCEINLINE void PfNodeCacheFlush(Node& n)
 	{
 	};
 };

changeset 4549	106ed18a7675
parent 4297	d0311b62255c
child 5015	63f05008fabe