From b885d79f506bde93b4ab278b3f84b8ca6254f3b9 Mon Sep 17 00:00:00 2001 From: alberth Date: Sat, 8 Aug 2015 10:06:24 +0000 Subject: (svn r27362) -Codechange: Codestyle fixes for reference var declarations, static cast type, operator methods. --- src/misc/array.hpp | 16 ++++++++-------- src/misc/countedptr.hpp | 16 ++++++++-------- src/misc/dbg_helpers.h | 2 +- src/misc/fixedsizearray.hpp | 6 +++--- src/misc/hashtable.hpp | 44 ++++++++++++++++++++++---------------------- src/misc/str.hpp | 8 ++++---- 6 files changed, 46 insertions(+), 46 deletions(-) (limited to 'src/misc') diff --git a/src/misc/array.hpp b/src/misc/array.hpp index a3f243e10..9796f18ea 100644 --- a/src/misc/array.hpp +++ b/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]; - T& item = s[index % B]; + const SubArray &s = data[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 T& item = s[index % B]; + const SubArray &s = data[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); } diff --git a/src/misc/countedptr.hpp b/src/misc/countedptr.hpp index 5dfc9a74c..1a783cf3e 100644 --- a/src/misc/countedptr.hpp +++ b/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;} diff --git a/src/misc/dbg_helpers.h b/src/misc/dbg_helpers.h index c83086f2a..acc1437d0 100644 --- a/src/misc/dbg_helpers.h +++ b/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; diff --git a/src/misc/fixedsizearray.hpp b/src/misc/fixedsizearray.hpp index 4216570b8..bf0f3acdd 100644 --- a/src/misc/fixedsizearray.hpp +++ b/src/misc/fixedsizearray.hpp @@ -63,7 +63,7 @@ public: } /** Copy constructor. Preallocate space for items and header, then initialize header. */ - FixedSizeArray(const FixedSizeArray& src) + FixedSizeArray(const FixedSizeArray &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 */ diff --git a/src/misc/hashtable.hpp b/src/misc/hashtable.hpp index 60bdcec25..e754a7d7b 100644 --- a/src/misc/hashtable.hpp +++ b/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 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++; diff --git a/src/misc/str.hpp b/src/misc/str.hpp index b982913fc..1d9802288 100644 --- a/src/misc/str.hpp +++ b/src/misc/str.hpp @@ -35,7 +35,7 @@ struct CStrA : public CBlobT } /** Take over ownership constructor */ - inline CStrA(const OnTransfer& ot) + inline CStrA(const OnTransfer &ot) : base(ot) { } @@ -67,7 +67,7 @@ struct CStrA : public CBlobT } /** 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 } /** 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 } /** 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; } -- cgit v1.2.3-70-g09d2