(svn r27362) -Codechange: Codestyle fixes for reference var declarations, static cast type, operator methods.

src/misc/array.hpp

@@ -34,7 +34,7 @@ protected:
 	{
 		uint super_size = data.Length();
 		if (super_size > 0) {
-			SubArray& s = data[super_size - 1];
+			SubArray &s = data[super_size - 1];
 			if (!s.IsFull()) return s;
 		}
 		return *data.AppendC();
@@ -62,17 +62,17 @@ public:
 	/** allocate and construct new item */
 	inline T *AppendC() { return FirstFreeSubArray().AppendC(); }
 	/** indexed access (non-const) */
-	inline T& operator [] (uint index)
+	inline T& operator[](uint index)
 	{
-		const SubArray& s = data[index / B];
+		const SubArray &s = data[index / B];
-		T& item = s[index % B];
+		T &item = s[index % B];
 		return item;
 	}
 	/** indexed access (const) */
-	inline const T& operator [] (uint index) const
+	inline const T& operator[](uint index) const
 	{
-		const SubArray& s = data[index / B];
+		const SubArray &s = data[index / B];
-		const T& item = s[index % B];
+		const T &item = s[index % B];
 		return item;
 	}
 
@@ -87,7 +87,7 @@ public:
 		dmp.WriteLine("num_items = %d", num_items);
 		CStrA name;
 		for (uint i = 0; i < num_items; i++) {
-			const T& item = (*this)[i];
+			const T &item = (*this)[i];
 			name.Format("item[%d]", i);
 			dmp.WriteStructT(name.Data(), &item);
 		}

src/misc/countedptr.hpp

@@ -38,7 +38,7 @@ public:
 	inline CCountedPtr(Tcls *pObj = NULL) : m_pT(pObj) {AddRef();}
 
 	/** copy constructor (invoked also when initializing from another smart ptr) */
-	inline CCountedPtr(const CCountedPtr& src) : m_pT(src.m_pT) {AddRef();}
+	inline CCountedPtr(const CCountedPtr &src) : m_pT(src.m_pT) {AddRef();}
 
 	/** destructor releasing the reference */
 	inline ~CCountedPtr() {Release();}
@@ -52,10 +52,10 @@ public:
 	inline void Release() {if (m_pT != NULL) {Tcls *pT = m_pT; m_pT = NULL; pT->Release();}}
 
 	/** dereference of smart pointer - const way */
-	inline const Tcls *operator -> () const {assert(m_pT != NULL); return m_pT;}
+	inline const Tcls *operator->() const {assert(m_pT != NULL); return m_pT;}
 
 	/** dereference of smart pointer - non const way */
-	inline Tcls *operator -> () {assert(m_pT != NULL); return m_pT;}
+	inline Tcls *operator->() {assert(m_pT != NULL); return m_pT;}
 
 	/** raw pointer casting operator - const way */
 	inline operator const Tcls*() const {assert(m_pT == NULL); return m_pT;}
@@ -64,13 +64,13 @@ public:
 	inline operator Tcls*() {return m_pT;}
 
 	/** operator & to support output arguments */
-	inline Tcls** operator &() {assert(m_pT == NULL); return &m_pT;}
+	inline Tcls** operator&() {assert(m_pT == NULL); return &m_pT;}
 
 	/** assignment operator from raw ptr */
-	inline CCountedPtr& operator = (Tcls *pT) {Assign(pT); return *this;}
+	inline CCountedPtr& operator=(Tcls *pT) {Assign(pT); return *this;}
 
 	/** assignment operator from another smart ptr */
-	inline CCountedPtr& operator = (const CCountedPtr& src) {Assign(src.m_pT); return *this;}
+	inline CCountedPtr& operator=(const CCountedPtr &src) {Assign(src.m_pT); return *this;}
 
 	/** assignment operator helper */
 	inline void Assign(Tcls *pT);
@@ -79,10 +79,10 @@ public:
 	inline bool IsNull() const {return m_pT == NULL;}
 
 	/** another way how to test for NULL value */
-	//inline bool operator == (const CCountedPtr& sp) const {return m_pT == sp.m_pT;}
+	//inline bool operator == (const CCountedPtr &sp) const {return m_pT == sp.m_pT;}
 
 	/** yet another way how to test for NULL value */
-	//inline bool operator != (const CCountedPtr& sp) const {return m_pT != sp.m_pT;}
+	//inline bool operator != (const CCountedPtr &sp) const {return m_pT != sp.m_pT;}
 
 	/** assign pointer w/o incrementing ref count */
 	inline void Attach(Tcls *pT) {Release(); m_pT = pT;}

src/misc/dbg_helpers.h

@@ -111,7 +111,7 @@ struct DumpTarget {
 			m_ptr = src.m_ptr;
 		}
 
-		bool operator < (const KnownStructKey &other) const
+		bool operator<(const KnownStructKey &other) const
 		{
 			if ((size_t)m_ptr < (size_t)other.m_ptr) return true;
 			if ((size_t)m_ptr > (size_t)other.m_ptr) return false;

src/misc/fixedsizearray.hpp

@@ -63,7 +63,7 @@ public:
 	}
 
 	/** Copy constructor. Preallocate space for items and header, then initialize header. */
-	FixedSizeArray(const FixedSizeArray<T, C>& src)
+	FixedSizeArray(const FixedSizeArray<T, C> &src)
 	{
 		/* share block (header + items) with the source array */
 		data = src.data;
@@ -106,9 +106,9 @@ public:
 	/** add and construct item using default constructor */
 	inline T *AppendC() { T *item = Append(); new(item)T; return item; }
 	/** return item by index (non-const version) */
-	inline T& operator [] (uint index) { assert(index < Length()); return data[index]; }
+	inline T& operator[](uint index) { assert(index < Length()); return data[index]; }
 	/** return item by index (const version) */
-	inline const T& operator [] (uint index) const { assert(index < Length()); return data[index]; }
+	inline const T& operator[](uint index) const { assert(index < Length()); return data[index]; }
 };
 
 #endif /* FIXEDSIZEARRAY_HPP */

src/misc/hashtable.hpp

@@ -27,7 +27,7 @@ struct CHashTableSlotT
 	inline void Clear() {m_pFirst = NULL;}
 
 	/** hash table slot helper - linear search for item with given key through the given blob - const version */
-	inline const Titem_ *Find(const Key& key) const
+	inline const Titem_ *Find(const Key &key) const
 	{
 		for (const Titem_ *pItem = m_pFirst; pItem != NULL; pItem = pItem->GetHashNext()) {
 			if (pItem->GetKey() == key) {
@@ -39,7 +39,7 @@ struct CHashTableSlotT
 	}
 
 	/** hash table slot helper - linear search for item with given key through the given blob - non-const version */
-	inline Titem_ *Find(const Key& key)
+	inline Titem_ *Find(const Key &key)
 	{
 		for (Titem_ *pItem = m_pFirst; pItem != NULL; pItem = pItem->GetHashNext()) {
 			if (pItem->GetKey() == key) {
@@ -51,7 +51,7 @@ struct CHashTableSlotT
 	}
 
 	/** hash table slot helper - add new item to the slot */
-	inline void Attach(Titem_& new_item)
+	inline void Attach(Titem_ &new_item)
 	{
 		assert(new_item.GetHashNext() == NULL);
 		new_item.SetHashNext(m_pFirst);
@@ -59,7 +59,7 @@ struct CHashTableSlotT
 	}
 
 	/** hash table slot helper - remove item from a slot */
-	inline bool Detach(Titem_& item_to_remove)
+	inline bool Detach(Titem_ &item_to_remove)
 	{
 		if (m_pFirst == &item_to_remove) {
 			m_pFirst = item_to_remove.GetHashNext();
@@ -81,7 +81,7 @@ struct CHashTableSlotT
 	}
 
 	/** hash table slot helper - remove and return item from a slot */
-	inline Titem_ *Detach(const Key& key)
+	inline Titem_ *Detach(const Key &key)
 	{
 		/* do we have any items? */
 		if (m_pFirst == NULL) {
@@ -89,7 +89,7 @@ struct CHashTableSlotT
 		}
 		/* is it our first item? */
 		if (m_pFirst->GetKey() == key) {
-			Titem_& ret_item = *m_pFirst;
+			Titem_ &ret_item = *m_pFirst;
 			m_pFirst = m_pFirst->GetHashNext();
 			ret_item.SetHashNext(NULL);
 			return &ret_item;
@@ -128,7 +128,7 @@ struct CHashTableSlotT
  *    - public method that calculates key's hash:
  *        int CalcHash() const;
  *    - public 'equality' operator to compare the key with another one
- *        bool operator == (const Key& other) const;
+ *        bool operator==(const Key &other) const;
  */
 template <class Titem_, int Thash_bits_>
 class CHashTableT {
@@ -156,7 +156,7 @@ public:
 
 protected:
 	/** static helper - return hash for the given key modulo number of slots */
-	inline static int CalcHash(const Tkey& key)
+	inline static int CalcHash(const Tkey &key)
 	{
 		int32 hash = key.CalcHash();
 		if ((8 * Thash_bits) < 32) hash ^= hash >> (min(8 * Thash_bits, 31));
@@ -168,7 +168,7 @@ protected:
 	}
 
 	/** static helper - return hash for the given item modulo number of slots */
-	inline static int CalcHash(const Titem_& item) {return CalcHash(item.GetKey());}
+	inline static int CalcHash(const Titem_ &item) {return CalcHash(item.GetKey());}
 
 public:
 	/** item count */
@@ -178,28 +178,28 @@ public:
 	inline void Clear() {for (int i = 0; i < Tcapacity; i++) m_slots[i].Clear();}
 
 	/** const item search */
-	const Titem_ *Find(const Tkey& key) const
+	const Titem_ *Find(const Tkey &key) const
 	{
 		int hash = CalcHash(key);
-		const Slot& slot = m_slots[hash];
+		const Slot &slot = m_slots[hash];
 		const Titem_ *item = slot.Find(key);
 		return item;
 	}
 
 	/** non-const item search */
-	Titem_ *Find(const Tkey& key)
+	Titem_ *Find(const Tkey &key)
 	{
 		int hash = CalcHash(key);
-		Slot& slot = m_slots[hash];
+		Slot &slot = m_slots[hash];
 		Titem_ *item = slot.Find(key);
 		return item;
 	}
 
 	/** non-const item search & optional removal (if found) */
-	Titem_ *TryPop(const Tkey& key)
+	Titem_ *TryPop(const Tkey &key)
 	{
 		int hash = CalcHash(key);
-		Slot& slot = m_slots[hash];
+		Slot &slot = m_slots[hash];
 		Titem_ *item = slot.Detach(key);
 		if (item != NULL) {
 			m_num_items--;
@@ -208,7 +208,7 @@ public:
 	}
 
 	/** non-const item search & removal */
-	Titem_& Pop(const Tkey& key)
+	Titem_& Pop(const Tkey &key)
 	{
 		Titem_ *item = TryPop(key);
 		assert(item != NULL);
@@ -216,11 +216,11 @@ public:
 	}
 
 	/** non-const item search & optional removal (if found) */
-	bool TryPop(Titem_& item)
+	bool TryPop(Titem_ &item)
 	{
-		const Tkey& key = item.GetKey();
+		const Tkey &key = item.GetKey();
 		int hash = CalcHash(key);
-		Slot& slot = m_slots[hash];
+		Slot &slot = m_slots[hash];
 		bool ret = slot.Detach(item);
 		if (ret) {
 			m_num_items--;
@@ -229,17 +229,17 @@ public:
 	}
 
 	/** non-const item search & removal */
-	void Pop(Titem_& item)
+	void Pop(Titem_ &item)
 	{
 		bool ret = TryPop(item);
 		assert(ret);
 	}
 
 	/** add one item - copy it from the given item */
-	void Push(Titem_& new_item)
+	void Push(Titem_ &new_item)
 	{
 		int hash = CalcHash(new_item);
-		Slot& slot = m_slots[hash];
+		Slot &slot = m_slots[hash];
 		assert(slot.Find(new_item.GetKey()) == NULL);
 		slot.Attach(new_item);
 		m_num_items++;

src/misc/str.hpp

@@ -35,7 +35,7 @@ struct CStrA : public CBlobT<char>
 	}
 
 	/** Take over ownership constructor */
-	inline CStrA(const OnTransfer& ot)
+	inline CStrA(const OnTransfer &ot)
 		: base(ot)
 	{
 	}
@@ -67,7 +67,7 @@ struct CStrA : public CBlobT<char>
 	}
 
 	/** Assignment from C string. */
-	inline CStrA &operator = (const char *src)
+	inline CStrA &operator=(const char *src)
 	{
 		base::Clear();
 		AppendStr(src);
@@ -75,7 +75,7 @@ struct CStrA : public CBlobT<char>
 	}
 
 	/** Assignment from another CStrA. */
-	inline CStrA &operator = (const CStrA &src)
+	inline CStrA &operator=(const CStrA &src)
 	{
 		if (&src != this) {
 			base::Clear();
@@ -86,7 +86,7 @@ struct CStrA : public CBlobT<char>
 	}
 
 	/** Lower-than operator (to support stl collections) */
-	inline bool operator < (const CStrA &other) const
+	inline bool operator<(const CStrA &other) const
 	{
 		return strcmp(base::Data(), other.Data()) < 0;
 	}

src/pathfinder/yapf/nodelist.hpp

@@ -81,7 +81,7 @@ public:
 	}
 
 	/** Notify the nodelist that we don't want to discard the given node. */
-	inline void FoundBestNode(Titem_& item)
+	inline void FoundBestNode(Titem_ &item)
 	{
 		/* for now it is enough to invalidate m_new_node if it is our given node */
 		if (&item == m_new_node) {
@@ -91,7 +91,7 @@ public:
 	}
 
 	/** insert given item as open node (into m_open and m_open_queue) */
-	inline void InsertOpenNode(Titem_& item)
+	inline void InsertOpenNode(Titem_ &item)
 	{
 		assert(m_closed.Find(item.GetKey()) == NULL);
 		m_open.Push(item);
@@ -122,30 +122,30 @@ public:
 	}
 
 	/** return the open node specified by a key or NULL if not found */
-	inline Titem_ *FindOpenNode(const Key& key)
+	inline Titem_ *FindOpenNode(const Key &key)
 	{
 		Titem_ *item = m_open.Find(key);
 		return item;
 	}
 
 	/** remove and return the open node specified by a key */
-	inline Titem_& PopOpenNode(const Key& key)
+	inline Titem_& PopOpenNode(const Key &key)
 	{
-		Titem_& item = m_open.Pop(key);
+		Titem_ &item = m_open.Pop(key);
 		uint idxPop = m_open_queue.FindIndex(item);
 		m_open_queue.Remove(idxPop);
 		return item;
 	}
 
 	/** close node */
-	inline void InsertClosedNode(Titem_& item)
+	inline void InsertClosedNode(Titem_ &item)
 	{
 		assert(m_open.Find(item.GetKey()) == NULL);
 		m_closed.Push(item);
 	}
 
 	/** return the closed node specified by a key or NULL if not found */
-	inline Titem_ *FindClosedNode(const Key& key)
+	inline Titem_ *FindClosedNode(const Key &key)
 	{
 		Titem_ *item = m_closed.Find(key);
 		return item;

src/pathfinder/yapf/yapf_base.hpp

@@ -38,10 +38,10 @@ extern int _total_pf_time_us;
  *  --------------------------------------------------------------
  *  Your pathfinder derived class needs to implement following methods:
  *    inline void PfSetStartupNodes()
- *    inline void PfFollowNode(Node& org)
+ *    inline void PfFollowNode(Node &org)
- *    inline bool PfCalcCost(Node& n)
+ *    inline bool PfCalcCost(Node &n)
- *    inline bool PfCalcEstimate(Node& n)
+ *    inline bool PfCalcEstimate(Node &n)
- *    inline bool PfDetectDestination(Node& n)
+ *    inline bool PfDetectDestination(Node &n)
  *
  *  For more details about those methods, look at the end of CYapfBaseT
  *  declaration. There are some examples. For another example look at
@@ -99,7 +99,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -193,12 +193,12 @@ public:
 	 */
 	inline Node& CreateNewNode()
 	{
-		Node& node = *m_nodes.CreateNewNode();
+		Node &node = *m_nodes.CreateNewNode();
 		return node;
 	}
 
 	/** Add new node (created by CreateNewNode and filled with data) into open list */
-	inline void AddStartupNode(Node& n)
+	inline void AddStartupNode(Node &n)
 	{
 		Yapf().PfNodeCacheFetch(n);
 		/* insert the new node only if it is not there */
@@ -217,7 +217,7 @@ public:
 		bool is_choice = (KillFirstBit(tf.m_new_td_bits) != TRACKDIR_BIT_NONE);
 		for (TrackdirBits rtds = tf.m_new_td_bits; rtds != TRACKDIR_BIT_NONE; rtds = KillFirstBit(rtds)) {
 			Trackdir td = (Trackdir)FindFirstBit2x64(rtds);
-			Node& n = Yapf().CreateNewNode();
+			Node &n = Yapf().CreateNewNode();
 			n.Set(parent, tf.m_new_tile, td, is_choice);
 			Yapf().AddNewNode(n, tf);
 		}
@@ -333,7 +333,7 @@ public:
 	inline void PfSetStartupNodes()
 	{
 		/* example: */
-		Node& n1 = *base::m_nodes.CreateNewNode();
+		Node &n1 = *base::m_nodes.CreateNewNode();
 		.
 		. // setup node members here
 		.
@@ -341,10 +341,10 @@ public:
 	}
 
 	/** Example: PfFollowNode() - set following (child) nodes of the given node */
-	inline void PfFollowNode(Node& org)
+	inline void PfFollowNode(Node &org)
 	{
 		for (each follower of node org) {
-			Node& n = *base::m_nodes.CreateNewNode();
+			Node &n = *base::m_nodes.CreateNewNode();
 			.
 			. // setup node members here
 			.
@@ -354,7 +354,7 @@ public:
 	}
 
 	/** Example: PfCalcCost() - set path cost from origin to the given node */
-	inline bool PfCalcCost(Node& n)
+	inline bool PfCalcCost(Node &n)
 	{
 		/* evaluate last step cost */
 		int cost = ...;
@@ -364,7 +364,7 @@ public:
 	}
 
 	/** Example: PfCalcEstimate() - set path cost estimate from origin to the target through given node */
-	inline bool PfCalcEstimate(Node& n)
+	inline bool PfCalcEstimate(Node &n)
 	{
 		/* evaluate the distance to our destination */
 		int distance = ...;
@@ -374,7 +374,7 @@ public:
 	}
 
 	/** Example: PfDetectDestination() - return true if the given node is our destination */
-	inline bool PfDetectDestination(Node& n)
+	inline bool PfDetectDestination(Node &n)
 	{
 		bool bDest = (n.m_key.m_x == m_x2) && (n.m_key.m_y == m_y2);
 		return bDest;

src/pathfinder/yapf/yapf_common.hpp

@@ -28,7 +28,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -45,7 +45,7 @@ public:
 		bool is_choice = (KillFirstBit(m_orgTrackdirs) != TRACKDIR_BIT_NONE);
 		for (TrackdirBits tdb = m_orgTrackdirs; tdb != TRACKDIR_BIT_NONE; tdb = KillFirstBit(tdb)) {
 			Trackdir td = (Trackdir)FindFirstBit2x64(tdb);
-			Node& n1 = Yapf().CreateNewNode();
+			Node &n1 = Yapf().CreateNewNode();
 			n1.Set(NULL, m_orgTile, td, is_choice);
 			Yapf().AddStartupNode(n1);
 		}
@@ -72,7 +72,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -91,12 +91,12 @@ public:
 	void PfSetStartupNodes()
 	{
 		if (m_orgTile != INVALID_TILE && m_orgTd != INVALID_TRACKDIR) {
-			Node& n1 = Yapf().CreateNewNode();
+			Node &n1 = Yapf().CreateNewNode();
 			n1.Set(NULL, m_orgTile, m_orgTd, false);
 			Yapf().AddStartupNode(n1);
 		}
 		if (m_revTile != INVALID_TILE && m_revTd != INVALID_TRACKDIR) {
-			Node& n2 = Yapf().CreateNewNode();
+			Node &n2 = Yapf().CreateNewNode();
 			n2.Set(NULL, m_revTile, m_revTd, false);
 			n2.m_cost = m_reverse_penalty;
 			Yapf().AddStartupNode(n2);
@@ -135,12 +135,12 @@ protected:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
 	/** Called by YAPF to detect if node ends in the desired destination */
-	inline bool PfDetectDestination(Node& n)
+	inline bool PfDetectDestination(Node &n)
 	{
 		bool bDest = (n.m_key.m_tile == m_destTile) && ((m_destTrackdirs & TrackdirToTrackdirBits(n.GetTrackdir())) != TRACKDIR_BIT_NONE);
 		return bDest;
@@ -150,7 +150,7 @@ public:
 	 * Called by YAPF to calculate cost estimate. Calculates distance to the destination
 	 *  adds it to the actual cost from origin and stores the sum to the Node::m_estimate
 	 */
-	inline bool PfCalcEstimate(Node& n)
+	inline bool PfCalcEstimate(Node &n)
 	{
 		static const int dg_dir_to_x_offs[] = {-1, 0, 1, 0};
 		static const int dg_dir_to_y_offs[] = {0, 1, 0, -1};

src/pathfinder/yapf/yapf_costcache.hpp

@@ -30,7 +30,7 @@ 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
 	 */
-	inline bool PfNodeCacheFetch(Node& n)
+	inline bool PfNodeCacheFetch(Node &n)
 	{
 		return false;
 	}
@@ -39,7 +39,7 @@ public:
 	 * Called by YAPF to flush the cached segment cost data back into cache storage.
 	 *  Current cache implementation doesn't use that.
 	 */
-	inline void PfNodeCacheFlush(Node& n)
+	inline void PfNodeCacheFlush(Node &n)
 	{
 	}
 };
@@ -67,7 +67,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -75,7 +75,7 @@ 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
 	 */
-	inline bool PfNodeCacheFetch(Node& n)
+	inline bool PfNodeCacheFetch(Node &n)
 	{
 		CacheKey key(n.GetKey());
 		Yapf().ConnectNodeToCachedData(n, *new (m_local_cache.Append()) CachedData(key));
@@ -86,7 +86,7 @@ public:
 	 * Called by YAPF to flush the cached segment cost data back into cache storage.
 	 *  Current cache implementation doesn't use that.
 	 */
-	inline void PfNodeCacheFlush(Node& n)
+	inline void PfNodeCacheFlush(Node &n)
 	{
 	}
 };
@@ -142,7 +142,7 @@ struct CSegmentCostCacheT
 		m_heap.Clear();
 	}
 
-	inline Tsegment& Get(Key& key, bool *found)
+	inline Tsegment& Get(Key &key, bool *found)
 	{
 		Tsegment *item = m_map.Find(key);
 		if (item == NULL) {
@@ -175,14 +175,14 @@ public:
 	typedef CSegmentCostCacheT<CachedData> Cache;
 
 protected:
-	Cache&      m_global_cache;
+	Cache &m_global_cache;
 
 	inline CYapfSegmentCostCacheGlobalT() : m_global_cache(stGetGlobalCache()) {};
 
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 	inline static Cache& stGetGlobalCache()
@@ -211,14 +211,14 @@ 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
 	 */
-	inline bool PfNodeCacheFetch(Node& n)
+	inline bool PfNodeCacheFetch(Node &n)
 	{
 		if (!Yapf().CanUseGlobalCache(n)) {
 			return Tlocal::PfNodeCacheFetch(n);
 		}
 		CacheKey key(n.GetKey());
 		bool found;
-		CachedData& item = m_global_cache.Get(key, &found);
+		CachedData &item = m_global_cache.Get(key, &found);
 		Yapf().ConnectNodeToCachedData(n, item);
 		return found;
 	}
@@ -227,7 +227,7 @@ public:
 	 * Called by YAPF to flush the cached segment cost data back into cache storage.
 	 *  Current cache implementation doesn't use that.
 	 */
-	inline void PfNodeCacheFlush(Node& n)
+	inline void PfNodeCacheFlush(Node &n)
 	{
 	}
 };

src/pathfinder/yapf/yapf_costrail.hpp

@@ -92,7 +92,7 @@ protected:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -130,7 +130,7 @@ public:
 	}
 
 	/** Return one tile cost (base cost + level crossing penalty). */
-	inline int OneTileCost(TileIndex& tile, Trackdir trackdir)
+	inline int OneTileCost(TileIndex &tile, Trackdir trackdir)
 	{
 		int cost = 0;
 		/* set base cost */
@@ -165,7 +165,7 @@ public:
 	}
 
 	/** The cost for reserved tiles, including skipped ones. */
-	inline int ReservationCost(Node& n, TileIndex tile, Trackdir trackdir, int skipped)
+	inline int ReservationCost(Node &n, TileIndex tile, Trackdir trackdir, int skipped)
 	{
 		if (n.m_num_signals_passed >= m_sig_look_ahead_costs.Size() / 2) return 0;
 		if (!IsPbsSignal(n.m_last_signal_type)) return 0;
@@ -180,7 +180,7 @@ public:
 		return 0;
 	}
 
-	int SignalCost(Node& n, TileIndex tile, Trackdir trackdir)
+	int SignalCost(Node &n, TileIndex tile, Trackdir trackdir)
 	{
 		int cost = 0;
 		/* if there is one-way signal in the opposite direction, then it is not our way */
@@ -614,14 +614,14 @@ no_entry_cost: // jump here at the beginning if the node has no parent (it is th
 		return true;
 	}
 
-	inline bool CanUseGlobalCache(Node& n) const
+	inline bool CanUseGlobalCache(Node &n) const
 	{
 		return !m_disable_cache
 			&& (n.m_parent != NULL)
 			&& (n.m_parent->m_num_signals_passed >= m_sig_look_ahead_costs.Size());
 	}
 
-	inline void ConnectNodeToCachedData(Node& n, CachedData& ci)
+	inline void ConnectNodeToCachedData(Node &n, CachedData &ci)
 	{
 		n.m_segment = &ci;
 		if (n.m_segment->m_cost < 0) {

src/pathfinder/yapf/yapf_destrail.hpp

@@ -47,11 +47,11 @@ public:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 	/** Called by YAPF to detect if node ends in the desired destination */
-	inline bool PfDetectDestination(Node& n)
+	inline bool PfDetectDestination(Node &n)
 	{
 		return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
 	}
@@ -67,7 +67,7 @@ public:
 	 * Called by YAPF to calculate cost estimate. Calculates distance to the destination
 	 *  adds it to the actual cost from origin and stores the sum to the Node::m_estimate
 	 */
-	inline bool PfCalcEstimate(Node& n)
+	inline bool PfCalcEstimate(Node &n)
 	{
 		n.m_estimate = n.m_cost;
 		return true;
@@ -87,11 +87,11 @@ public:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 	/** Called by YAPF to detect if node ends in the desired destination */
-	inline bool PfDetectDestination(Node& n)
+	inline bool PfDetectDestination(Node &n)
 	{
 		return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
 	}
@@ -107,7 +107,7 @@ public:
 	 * Called by YAPF to calculate cost estimate. Calculates distance to the destination
 	 *  adds it to the actual cost from origin and stores the sum to the Node::m_estimate.
 	 */
-	inline bool PfCalcEstimate(Node& n)
+	inline bool PfCalcEstimate(Node &n)
 	{
 		n.m_estimate = n.m_cost;
 		return true;
@@ -131,7 +131,7 @@ protected:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -164,7 +164,7 @@ public:
 	}
 
 	/** Called by YAPF to detect if node ends in the desired destination */
-	inline bool PfDetectDestination(Node& n)
+	inline bool PfDetectDestination(Node &n)
 	{
 		return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
 	}
@@ -188,7 +188,7 @@ public:
 	 * Called by YAPF to calculate cost estimate. Calculates distance to the destination
 	 *  adds it to the actual cost from origin and stores the sum to the Node::m_estimate
 	 */
-	inline bool PfCalcEstimate(Node& n)
+	inline bool PfCalcEstimate(Node &n)
 	{
 		static const int dg_dir_to_x_offs[] = {-1, 0, 1, 0};
 		static const int dg_dir_to_y_offs[] = {0, 1, 0, -1};

src/pathfinder/yapf/yapf_node.hpp

@@ -26,7 +26,7 @@ struct CYapfNodeKeyExitDir {
 	}
 
 	inline int CalcHash() const {return m_exitdir | (m_tile << 2);}
-	inline bool operator == (const CYapfNodeKeyExitDir& other) const {return (m_tile == other.m_tile) && (m_exitdir == other.m_exitdir);}
+	inline bool operator==(const CYapfNodeKeyExitDir &other) const {return (m_tile == other.m_tile) && (m_exitdir == other.m_exitdir);}
 
 	void Dump(DumpTarget &dmp) const
 	{
@@ -39,7 +39,7 @@ struct CYapfNodeKeyExitDir {
 struct CYapfNodeKeyTrackDir : public CYapfNodeKeyExitDir
 {
 	inline int CalcHash() const {return m_td | (m_tile << 4);}
-	inline bool operator == (const CYapfNodeKeyTrackDir& other) const {return (m_tile == other.m_tile) && (m_td == other.m_td);}
+	inline bool operator==(const CYapfNodeKeyTrackDir &other) const {return (m_tile == other.m_tile) && (m_td == other.m_td);}
 };
 
 /** Yapf Node base */
@@ -70,7 +70,7 @@ struct CYapfNodeT {
 	inline const Tkey_& GetKey() const {return m_key;}
 	inline int GetCost() const {return m_cost;}
 	inline int GetCostEstimate() const {return m_estimate;}
-	inline bool operator < (const Node& other) const {return m_estimate < other.m_estimate;}
+	inline bool operator<(const Node &other) const {return m_estimate < other.m_estimate;}
 
 	void Dump(DumpTarget &dmp) const
 	{

src/pathfinder/yapf/yapf_node_rail.hpp

@@ -17,19 +17,19 @@ struct CYapfRailSegmentKey
 {
 	uint32    m_value;
 
-	inline CYapfRailSegmentKey(const CYapfRailSegmentKey& src) : m_value(src.m_value) {}
+	inline CYapfRailSegmentKey(const CYapfRailSegmentKey &src) : m_value(src.m_value) {}
 
-	inline CYapfRailSegmentKey(const CYapfNodeKeyTrackDir& node_key)
+	inline CYapfRailSegmentKey(const CYapfNodeKeyTrackDir &node_key)
 	{
 		Set(node_key);
 	}
 
-	inline void Set(const CYapfRailSegmentKey& src)
+	inline void Set(const CYapfRailSegmentKey &src)
 	{
 		m_value = src.m_value;
 	}
 
-	inline void Set(const CYapfNodeKeyTrackDir& node_key)
+	inline void Set(const CYapfNodeKeyTrackDir &node_key)
 	{
 		m_value = (((int)node_key.m_tile) << 4) | node_key.m_td;
 	}
@@ -49,7 +49,7 @@ struct CYapfRailSegmentKey
 		return (Trackdir)(m_value & 0x0F);
 	}
 
-	inline bool operator == (const CYapfRailSegmentKey& other) const
+	inline bool operator==(const CYapfRailSegmentKey &other) const
 	{
 		return m_value == other.m_value;
 	}
@@ -75,7 +75,7 @@ struct CYapfRailSegment
 	EndSegmentReasonBits   m_end_segment_reason;
 	CYapfRailSegment      *m_hash_next;
 
-	inline CYapfRailSegment(const CYapfRailSegmentKey& key)
+	inline CYapfRailSegment(const CYapfRailSegmentKey &key)
 		: m_key(key)
 		, m_last_tile(INVALID_TILE)
 		, m_last_td(INVALID_TRACKDIR)

src/pathfinder/yapf/yapf_rail.cpp

@@ -48,7 +48,7 @@ protected:
 	/** to access inherited pathfinder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 private:
@@ -200,7 +200,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -209,7 +209,7 @@ public:
 	 *  reachable trackdir on the new tile creates new node, initializes it
 	 *  and adds it to the open list by calling Yapf().AddNewNode(n)
 	 */
-	inline void PfFollowNode(Node& old_node)
+	inline void PfFollowNode(Node &old_node)
 	{
 		TrackFollower F(Yapf().GetVehicle());
 		if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir())) {
@@ -296,7 +296,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -305,7 +305,7 @@ public:
 	 *  reachable trackdir on the new tile creates new node, initializes it
 	 *  and adds it to the open list by calling Yapf().AddNewNode(n)
 	 */
-	inline void PfFollowNode(Node& old_node)
+	inline void PfFollowNode(Node &old_node)
 	{
 		TrackFollower F(Yapf().GetVehicle(), Yapf().GetCompatibleRailTypes());
 		if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir()) && F.MaskReservedTracks()) {
@@ -379,7 +379,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -388,7 +388,7 @@ public:
 	 *  reachable trackdir on the new tile creates new node, initializes it
 	 *  and adds it to the open list by calling Yapf().AddNewNode(n)
 	 */
-	inline void PfFollowNode(Node& old_node)
+	inline void PfFollowNode(Node &old_node)
 	{
 		TrackFollower F(Yapf().GetVehicle());
 		if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir())) {
@@ -453,7 +453,7 @@ public:
 				this->FindSafePositionOnNode(pPrev);
 			}
 			/* return trackdir from the best origin node (one of start nodes) */
-			Node& best_next_node = *pPrev;
+			Node &best_next_node = *pPrev;
 			next_trackdir = best_next_node.GetTrackdir();
 
 			if (reserve_track && path_found) this->TryReservePath(target, pNode->GetLastTile());
@@ -502,7 +502,7 @@ public:
 		}
 
 		/* check if it was reversed origin */
-		Node& best_org_node = *pNode;
+		Node &best_org_node = *pNode;
 		bool reversed = (best_org_node.m_cost != 0);
 		return reversed;
 	}

src/pathfinder/yapf/yapf_road.cpp

@@ -30,7 +30,7 @@ protected:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 	int SlopeCost(TileIndex tile, TileIndex next_tile, Trackdir trackdir)
@@ -102,7 +102,7 @@ public:
 	 *  Calculates only the cost of given node, adds it to the parent node cost
 	 *  and stores the result into Node::m_cost member
 	 */
-	inline bool PfCalcCost(Node& n, const TrackFollower *tf)
+	inline bool PfCalcCost(Node &n, const TrackFollower *tf)
 	{
 		int segment_cost = 0;
 		uint tiles = 0;
@@ -179,11 +179,11 @@ public:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 	/** Called by YAPF to detect if node ends in the desired destination */
-	inline bool PfDetectDestination(Node& n)
+	inline bool PfDetectDestination(Node &n)
 	{
 		bool bDest = IsRoadDepotTile(n.m_segment_last_tile);
 		return bDest;
@@ -198,7 +198,7 @@ public:
 	 * Called by YAPF to calculate cost estimate. Calculates distance to the destination
 	 *  adds it to the actual cost from origin and stores the sum to the Node::m_estimate
 	 */
-	inline bool PfCalcEstimate(Node& n)
+	inline bool PfCalcEstimate(Node &n)
 	{
 		n.m_estimate = n.m_cost;
 		return true;
@@ -242,12 +242,12 @@ protected:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
 	/** Called by YAPF to detect if node ends in the desired destination */
-	inline bool PfDetectDestination(Node& n)
+	inline bool PfDetectDestination(Node &n)
 	{
 		return PfDetectDestinationTile(n.m_segment_last_tile, n.m_segment_last_td);
 	}
@@ -268,7 +268,7 @@ public:
 	 * Called by YAPF to calculate cost estimate. Calculates distance to the destination
 	 *  adds it to the actual cost from origin and stores the sum to the Node::m_estimate
 	 */
-	inline bool PfCalcEstimate(Node& n)
+	inline bool PfCalcEstimate(Node &n)
 	{
 		static const int dg_dir_to_x_offs[] = {-1, 0, 1, 0};
 		static const int dg_dir_to_y_offs[] = {0, 1, 0, -1};
@@ -309,7 +309,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -319,7 +319,7 @@ public:
 	 *  reachable trackdir on the new tile creates new node, initializes it
 	 *  and adds it to the open list by calling Yapf().AddNewNode(n)
 	 */
-	inline void PfFollowNode(Node& old_node)
+	inline void PfFollowNode(Node &old_node)
 	{
 		TrackFollower F(Yapf().GetVehicle());
 		if (F.Follow(old_node.m_segment_last_tile, old_node.m_segment_last_td)) {
@@ -373,7 +373,7 @@ public:
 				pNode = pNode->m_parent;
 			}
 			/* return trackdir from the best origin node (one of start nodes) */
-			Node& best_next_node = *pNode;
+			Node &best_next_node = *pNode;
 			assert(best_next_node.GetTile() == tile);
 			next_trackdir = best_next_node.GetTrackdir();
 		}

src/pathfinder/yapf/yapf_ship.cpp

@@ -31,7 +31,7 @@ protected:
 	/** to access inherited path finder */
 	inline Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -40,7 +40,7 @@ public:
 	 *  reachable trackdir on the new tile creates new node, initializes it
 	 *  and adds it to the open list by calling Yapf().AddNewNode(n)
 	 */
-	inline void PfFollowNode(Node& old_node)
+	inline void PfFollowNode(Node &old_node)
 	{
 		TrackFollower F(Yapf().GetVehicle());
 		if (F.Follow(old_node.m_key.m_tile, old_node.m_key.m_td)) {
@@ -97,7 +97,7 @@ public:
 				pNode = pNode->m_parent;
 			}
 			/* return trackdir from the best next node (direct child of origin) */
-			Node& best_next_node = *pPrevNode;
+			Node &best_next_node = *pPrevNode;
 			assert(best_next_node.GetTile() == tile);
 			next_trackdir = best_next_node.GetTrackdir();
 		}
@@ -155,7 +155,7 @@ protected:
 	/** to access inherited path finder */
 	Tpf& Yapf()
 	{
-		return *static_cast<Tpf*>(this);
+		return *static_cast<Tpf *>(this);
 	}
 
 public:
@@ -164,7 +164,7 @@ public:
 	 *  Calculates only the cost of given node, adds it to the parent node cost
 	 *  and stores the result into Node::m_cost member
 	 */
-	inline bool PfCalcCost(Node& n, const TrackFollower *tf)
+	inline bool PfCalcCost(Node &n, const TrackFollower *tf)
 	{
 		/* base tile cost depending on distance */
 		int c = IsDiagonalTrackdir(n.GetTrackdir()) ? YAPF_TILE_LENGTH : YAPF_TILE_CORNER_LENGTH;