From 1105b4d2c99e99750f42b7a39443bb03b40f4afa Mon Sep 17 00:00:00 2001 From: alberth Date: Sat, 8 Aug 2015 13:19:38 +0000 Subject: (svn r27363) -Codechange: Fix codestyle of one-line methods and header codestyle of derived structs. --- src/misc/array.hpp | 35 ++++++++++--- src/misc/binaryheap.hpp | 20 ++++++-- src/misc/blob.hpp | 24 +++++++-- src/misc/countedptr.hpp | 92 +++++++++++++++++++++++++++------- src/misc/fixedsizearray.hpp | 68 +++++++++++++++++++++---- src/misc/hashtable.hpp | 20 ++++++-- src/pathfinder/yapf/nodelist.hpp | 48 ++++++++---------- src/pathfinder/yapf/yapf_costcache.hpp | 8 +-- src/pathfinder/yapf/yapf_costrail.hpp | 9 +--- src/pathfinder/yapf/yapf_destrail.hpp | 15 ++---- src/pathfinder/yapf/yapf_node.hpp | 69 ++++++++++++++++++++----- src/pathfinder/yapf/yapf_node_road.hpp | 8 ++- src/pathfinder/yapf/yapf_node_ship.hpp | 7 +-- 13 files changed, 302 insertions(+), 121 deletions(-) (limited to 'src') diff --git a/src/misc/array.hpp b/src/misc/array.hpp index 9796f18ea..c49f2afc4 100644 --- a/src/misc/array.hpp +++ b/src/misc/array.hpp @@ -42,9 +42,16 @@ protected: public: /** implicit constructor */ - inline SmallArray() { } + inline SmallArray() + { + } + /** Clear (destroy) all items */ - inline void Clear() {data.Clear();} + inline void Clear() + { + data.Clear(); + } + /** Return actual number of items */ inline uint Length() const { @@ -54,13 +61,29 @@ public: return (super_size - 1) * B + sub_size; } /** return true if array is empty */ - inline bool IsEmpty() { return data.IsEmpty(); } + inline bool IsEmpty() + { + return data.IsEmpty(); + } + /** return true if array is full */ - inline bool IsFull() { return data.IsFull() && data[N - 1].IsFull(); } + inline bool IsFull() + { + return data.IsFull() && data[N - 1].IsFull(); + } + /** allocate but not construct new item */ - inline T *Append() { return FirstFreeSubArray().Append(); } + inline T *Append() + { + return FirstFreeSubArray().Append(); + } + /** allocate and construct new item */ - inline T *AppendC() { return FirstFreeSubArray().AppendC(); } + inline T *AppendC() + { + return FirstFreeSubArray().AppendC(); + } + /** indexed access (non-const) */ inline T& operator[](uint index) { diff --git a/src/misc/binaryheap.hpp b/src/misc/binaryheap.hpp index 092ab720b..5bd2b794a 100644 --- a/src/misc/binaryheap.hpp +++ b/src/misc/binaryheap.hpp @@ -157,21 +157,30 @@ public: * * @return The number of items in the queue */ - inline uint Length() const { return this->items; } + inline uint Length() const + { + return this->items; + } /** * Test if the priority queue is empty. * * @return True if empty */ - inline bool IsEmpty() const { return this->items == 0; } + inline bool IsEmpty() const + { + return this->items == 0; + } /** * Test if the priority queue is full. * * @return True if full. */ - inline bool IsFull() const { return this->items >= this->capacity; } + inline bool IsFull() const + { + return this->items >= this->capacity; + } /** * Get the smallest item in the binary tree. @@ -287,7 +296,10 @@ public: * Make the priority queue empty. * All remaining items will remain untouched. */ - inline void Clear() { this->items = 0; } + inline void Clear() + { + this->items = 0; + } }; #endif /* BINARYHEAP_HPP */ diff --git a/src/misc/blob.hpp b/src/misc/blob.hpp index bf936934b..b1a5b667d 100644 --- a/src/misc/blob.hpp +++ b/src/misc/blob.hpp @@ -71,7 +71,10 @@ public: static const size_t header_size = sizeof(BlobHeader); /** default constructor - initializes empty blob */ - inline ByteBlob() { InitEmpty(); } + inline ByteBlob() + { + InitEmpty(); + } /** copy constructor */ inline ByteBlob(const ByteBlob &src) @@ -311,9 +314,22 @@ public: struct OnTransfer { typename base::BlobHeader *header; - OnTransfer(const OnTransfer& src) : header(src.header) {assert(src.header != NULL); *const_cast(&src.header) = NULL;} - OnTransfer(CBlobT& src) : header(src.header) {src.InitEmpty();} - ~OnTransfer() {assert(header == NULL);} + + OnTransfer(const OnTransfer& src) : header(src.header) + { + assert(src.header != NULL); + *const_cast(&src.header) = NULL; + } + + OnTransfer(CBlobT& src) : header(src.header) + { + src.InitEmpty(); + } + + ~OnTransfer() + { + assert(header == NULL); + } }; /** Default constructor - makes new Blob ready to accept any data */ diff --git a/src/misc/countedptr.hpp b/src/misc/countedptr.hpp index 1a783cf3e..e7b28a626 100644 --- a/src/misc/countedptr.hpp +++ b/src/misc/countedptr.hpp @@ -35,48 +35,97 @@ protected: public: /** default (NULL) construct or construct from a raw pointer */ - inline CCountedPtr(Tcls *pObj = NULL) : m_pT(pObj) {AddRef();} + 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();} + inline ~CCountedPtr() + { + Release(); + } protected: /** add one ref to the underlaying object */ - inline void AddRef() {if (m_pT != NULL) m_pT->AddRef();} + inline void AddRef() + { + if (m_pT != NULL) m_pT->AddRef(); + } public: /** release smart pointer (and decrement ref count) if not null */ - inline void Release() {if (m_pT != NULL) {Tcls *pT = m_pT; m_pT = NULL; pT->Release();}} + 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;} + inline operator const Tcls*() const + { + assert(m_pT == NULL); + return m_pT; + } /** raw pointer casting operator - non-const way */ - inline operator Tcls*() {return m_pT;} + 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); /** one way how to test for NULL value */ - inline bool IsNull() const {return m_pT == NULL;} + 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;} @@ -85,10 +134,19 @@ public: //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;} + inline void Attach(Tcls *pT) + { + Release(); + m_pT = pT; + } /** detach pointer w/o decrementing ref count */ - inline Tcls *Detach() {Tcls *pT = m_pT; m_pT = NULL; return pT;} + inline Tcls *Detach() + { + Tcls *pT = m_pT; + m_pT = NULL; + return pT; + } }; template @@ -136,7 +194,6 @@ template struct AdaptT { } }; - /** * Simple counted object. Use it as base of your struct/class if you want to use * basic reference counting. Your struct/class will destroy and free itself when @@ -161,7 +218,4 @@ struct SimpleCountedObject { virtual void FinalRelease() {}; }; - - - #endif /* COUNTEDPTR_HPP */ diff --git a/src/misc/fixedsizearray.hpp b/src/misc/fixedsizearray.hpp index bf0f3acdd..c694ff7a1 100644 --- a/src/misc/fixedsizearray.hpp +++ b/src/misc/fixedsizearray.hpp @@ -41,13 +41,28 @@ protected: T *data; /** return reference to the array header (non-const) */ - inline ArrayHeader& Hdr() { return *(ArrayHeader*)(((byte*)data) - HeaderSize); } + inline ArrayHeader& Hdr() + { + return *(ArrayHeader*)(((byte*)data) - HeaderSize); + } + /** return reference to the array header (const) */ - inline const ArrayHeader& Hdr() const { return *(ArrayHeader*)(((byte*)data) - HeaderSize); } + inline const ArrayHeader& Hdr() const + { + return *(ArrayHeader*)(((byte*)data) - HeaderSize); + } + /** return reference to the block reference counter */ - inline uint& RefCnt() { return Hdr().reference_count; } + inline uint& RefCnt() + { + return Hdr().reference_count; + } + /** return reference to number of used items */ - inline uint& SizeRef() { return Hdr().items; } + inline uint& SizeRef() + { + return Hdr().items; + } public: /** Default constructor. Preallocate space for items and header, then initialize header. */ @@ -96,19 +111,50 @@ public: } /** return number of used items */ - inline uint Length() const { return Hdr().items; } + inline uint Length() const + { + return Hdr().items; + } + /** return true if array is full */ - inline bool IsFull() const { return Length() >= C; } + inline bool IsFull() const + { + return Length() >= C; + } + /** return true if array is empty */ - inline bool IsEmpty() const { return Length() <= 0; } + inline bool IsEmpty() const + { + return Length() <= 0; + } + /** add (allocate), but don't construct item */ - inline T *Append() { assert(!IsFull()); return &data[SizeRef()++]; } + inline T *Append() + { + assert(!IsFull()); + return &data[SizeRef()++]; + } + /** add and construct item using default constructor */ - inline T *AppendC() { T *item = Append(); new(item)T; return item; } + 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 */ diff --git a/src/misc/hashtable.hpp b/src/misc/hashtable.hpp index e754a7d7b..1afe58cac 100644 --- a/src/misc/hashtable.hpp +++ b/src/misc/hashtable.hpp @@ -24,7 +24,10 @@ struct CHashTableSlotT inline CHashTableSlotT() : m_pFirst(NULL) {} /** hash table slot helper - clears the slot by simple forgetting its items */ - inline void Clear() {m_pFirst = NULL;} + 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 @@ -168,14 +171,23 @@ 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 */ - inline int Count() const {return m_num_items;} + inline int Count() const + { + return m_num_items; + } /** simple clear - forget all items - used by CSegmentCostCacheT.Flush() */ - inline void Clear() {for (int i = 0; i < Tcapacity; i++) m_slots[i].Clear();} + inline void Clear() + { + for (int i = 0; i < Tcapacity; i++) m_slots[i].Clear(); + } /** const item search */ const Titem_ *Find(const Tkey &key) const diff --git a/src/pathfinder/yapf/nodelist.hpp b/src/pathfinder/yapf/nodelist.hpp index ce0a7ba90..e82f869f1 100644 --- a/src/pathfinder/yapf/nodelist.hpp +++ b/src/pathfinder/yapf/nodelist.hpp @@ -24,34 +24,23 @@ template class CNodeList_HashTableT { public: - /** make Titem_ visible from outside of class */ - typedef Titem_ Titem; - /** make Titem_::Key a property of HashTable */ - typedef typename Titem_::Key Key; - /** type that we will use as item container */ - typedef SmallArray CItemArray; - /** how pointers to open nodes will be stored */ - typedef CHashTableT COpenList; - /** how pointers to closed nodes will be stored */ - typedef CHashTableT CClosedList; - /** how the priority queue will be managed */ - typedef CBinaryHeapT CPriorityQueue; + typedef Titem_ Titem; ///< Make #Titem_ visible from outside of class. + typedef typename Titem_::Key Key; ///< Make Titem_::Key a property of #HashTable. + typedef SmallArray CItemArray; ///< Type that we will use as item container. + typedef CHashTableT COpenList; ///< How pointers to open nodes will be stored. + typedef CHashTableT CClosedList; ///< How pointers to closed nodes will be stored. + typedef CBinaryHeapT CPriorityQueue; ///< How the priority queue will be managed. protected: - /** here we store full item data (Titem_) */ - CItemArray m_arr; - /** hash table of pointers to open item data */ - COpenList m_open; - /** hash table of pointers to closed item data */ - CClosedList m_closed; - /** priority queue of pointers to open item data */ - CPriorityQueue m_open_queue; - /** new open node under construction */ - Titem *m_new_node; + CItemArray m_arr; ///< Here we store full item data (Titem_). + COpenList m_open; ///< Hash table of pointers to open item data. + CClosedList m_closed; ///< Hash table of pointers to closed item data. + CPriorityQueue m_open_queue; ///< Priority queue of pointers to open item data. + Titem *m_new_node; ///< New open node under construction. + public: /** default constructor */ - CNodeList_HashTableT() - : m_open_queue(2048) + CNodeList_HashTableT() : m_open_queue(2048) { m_new_node = NULL; } @@ -152,9 +141,16 @@ public: } /** The number of items. */ - inline int TotalCount() {return m_arr.Length();} + inline int TotalCount() + { + return m_arr.Length(); + } + /** Get a particular item. */ - inline Titem_& ItemAt(int idx) {return m_arr[idx];} + inline Titem_& ItemAt(int idx) + { + return m_arr[idx]; + } /** Helper for creating output of this array. */ template void Dump(D &dmp) const diff --git a/src/pathfinder/yapf/yapf_costcache.hpp b/src/pathfinder/yapf/yapf_costcache.hpp index a3e40d13e..f16d4054c 100644 --- a/src/pathfinder/yapf/yapf_costcache.hpp +++ b/src/pathfinder/yapf/yapf_costcache.hpp @@ -121,9 +121,7 @@ struct CSegmentCostCacheBase * Look at CYapfRailSegment (yapf_node_rail.hpp) for the segment example */ template -struct CSegmentCostCacheT - : public CSegmentCostCacheBase -{ +struct CSegmentCostCacheT : public CSegmentCostCacheBase { static const int C_HASH_BITS = 14; typedef CHashTableT HashTable; @@ -162,9 +160,7 @@ struct CSegmentCostCacheT * segment cost caching services for your Nodes. */ template -class CYapfSegmentCostCacheGlobalT - : public CYapfSegmentCostCacheLocalT -{ +class CYapfSegmentCostCacheGlobalT : public CYapfSegmentCostCacheLocalT { public: typedef CYapfSegmentCostCacheLocalT Tlocal; typedef typename Types::Tpf Tpf; ///< the pathfinder class (derived from THIS class) diff --git a/src/pathfinder/yapf/yapf_costrail.hpp b/src/pathfinder/yapf/yapf_costrail.hpp index 80cbd529d..64cf96380 100644 --- a/src/pathfinder/yapf/yapf_costrail.hpp +++ b/src/pathfinder/yapf/yapf_costrail.hpp @@ -15,9 +15,7 @@ #include "../../pbs.h" template -class CYapfCostRailT - : public CYapfCostBase -{ +class CYapfCostRailT : public CYapfCostBase { public: typedef typename Types::Tpf Tpf; ///< the pathfinder class (derived from THIS class) typedef typename Types::TrackFollower TrackFollower; @@ -74,10 +72,7 @@ protected: static const int s_max_segment_cost = 10000; - CYapfCostRailT() - : m_max_cost(0) - , m_disable_cache(false) - , m_stopped_on_first_two_way_signal(false) + CYapfCostRailT() : m_max_cost(0), m_disable_cache(false), m_stopped_on_first_two_way_signal(false) { /* pre-compute look-ahead penalties into array */ int p0 = Yapf().PfGetSettings().rail_look_ahead_signal_p0; diff --git a/src/pathfinder/yapf/yapf_destrail.hpp b/src/pathfinder/yapf/yapf_destrail.hpp index 37525bfa2..681034a2f 100644 --- a/src/pathfinder/yapf/yapf_destrail.hpp +++ b/src/pathfinder/yapf/yapf_destrail.hpp @@ -12,8 +12,7 @@ #ifndef YAPF_DESTRAIL_HPP #define YAPF_DESTRAIL_HPP -class CYapfDestinationRailBase -{ +class CYapfDestinationRailBase { protected: RailTypes m_compatible_railtypes; @@ -36,9 +35,7 @@ public: }; template -class CYapfDestinationAnyDepotRailT - : public CYapfDestinationRailBase -{ +class CYapfDestinationAnyDepotRailT : public CYapfDestinationRailBase { 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 @@ -75,9 +72,7 @@ public: }; template -class CYapfDestinationAnySafeTileRailT - : public CYapfDestinationRailBase -{ +class CYapfDestinationAnySafeTileRailT : public CYapfDestinationRailBase { 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 @@ -115,9 +110,7 @@ public: }; template -class CYapfDestinationTileOrStationRailT - : public CYapfDestinationRailBase -{ +class CYapfDestinationTileOrStationRailT : public CYapfDestinationRailBase { 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 diff --git a/src/pathfinder/yapf/yapf_node.hpp b/src/pathfinder/yapf/yapf_node.hpp index c305fd996..b3021096b 100644 --- a/src/pathfinder/yapf/yapf_node.hpp +++ b/src/pathfinder/yapf/yapf_node.hpp @@ -25,8 +25,15 @@ struct CYapfNodeKeyExitDir { m_exitdir = (m_td == INVALID_TRACKDIR) ? INVALID_DIAGDIR : TrackdirToExitdir(m_td); } - 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 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; + } void Dump(DumpTarget &dmp) const { @@ -38,8 +45,15 @@ 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 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; + } }; /** Yapf Node base */ @@ -63,14 +77,45 @@ struct CYapfNodeT { m_estimate = 0; } - inline Node *GetHashNext() {return m_hash_next;} - inline void SetHashNext(Node *pNext) {m_hash_next = pNext;} - inline TileIndex GetTile() const {return m_key.m_tile;} - inline Trackdir GetTrackdir() const {return m_key.m_td;} - 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 Node *GetHashNext() + { + return m_hash_next; + } + + inline void SetHashNext(Node *pNext) + { + m_hash_next = pNext; + } + + inline TileIndex GetTile() const + { + return m_key.m_tile; + } + + inline Trackdir GetTrackdir() const + { + return m_key.m_td; + } + + 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; + } void Dump(DumpTarget &dmp) const { diff --git a/src/pathfinder/yapf/yapf_node_road.hpp b/src/pathfinder/yapf/yapf_node_road.hpp index 5cc2d5539..9a392f088 100644 --- a/src/pathfinder/yapf/yapf_node_road.hpp +++ b/src/pathfinder/yapf/yapf_node_road.hpp @@ -14,13 +14,11 @@ /** Yapf Node for road YAPF */ template -struct CYapfRoadNodeT - : CYapfNodeT > -{ +struct CYapfRoadNodeT : CYapfNodeT > { typedef CYapfNodeT > base; - TileIndex m_segment_last_tile; - Trackdir m_segment_last_td; + TileIndex m_segment_last_tile; + Trackdir m_segment_last_td; void Set(CYapfRoadNodeT *parent, TileIndex tile, Trackdir td, bool is_choice) { diff --git a/src/pathfinder/yapf/yapf_node_ship.hpp b/src/pathfinder/yapf/yapf_node_ship.hpp index 7a1358af6..df4254fd9 100644 --- a/src/pathfinder/yapf/yapf_node_ship.hpp +++ b/src/pathfinder/yapf/yapf_node_ship.hpp @@ -14,11 +14,7 @@ /** Yapf Node for ships */ template -struct CYapfShipNodeT - : CYapfNodeT > -{ - -}; +struct CYapfShipNodeT : CYapfNodeT > { }; /* now define two major node types (that differ by key type) */ typedef CYapfShipNodeT CYapfShipNodeExitDir; @@ -28,5 +24,4 @@ typedef CYapfShipNodeT CYapfShipNodeTrackDir; typedef CNodeList_HashTableT CShipNodeListExitDir; typedef CNodeList_HashTableT CShipNodeListTrackDir; - #endif /* YAPF_NODE_SHIP_HPP */ -- cgit v1.2.3-70-g09d2