summaryrefslogtreecommitdiff
path: root/src/misc
diff options
context:
space:
mode:
Diffstat (limited to 'src/misc')
-rw-r--r--src/misc/array.hpp20
-rw-r--r--src/misc/binaryheap.hpp26
-rw-r--r--src/misc/blob.hpp78
-rw-r--r--src/misc/countedptr.hpp38
-rw-r--r--src/misc/fixedsizearray.hpp24
-rw-r--r--src/misc/hashtable.hpp24
-rw-r--r--src/misc/str.hpp18
7 files changed, 114 insertions, 114 deletions
diff --git a/src/misc/array.hpp b/src/misc/array.hpp
index 5eae3e488..a3f243e10 100644
--- a/src/misc/array.hpp
+++ b/src/misc/array.hpp
@@ -30,7 +30,7 @@ protected:
SuperArray data; ///< array of arrays of items
/** return first sub-array with free space for new item */
- FORCEINLINE SubArray& FirstFreeSubArray()
+ inline SubArray& FirstFreeSubArray()
{
uint super_size = data.Length();
if (super_size > 0) {
@@ -42,11 +42,11 @@ protected:
public:
/** implicit constructor */
- FORCEINLINE SmallArray() { }
+ inline SmallArray() { }
/** Clear (destroy) all items */
- FORCEINLINE void Clear() {data.Clear();}
+ inline void Clear() {data.Clear();}
/** Return actual number of items */
- FORCEINLINE uint Length() const
+ inline uint Length() const
{
uint super_size = data.Length();
if (super_size == 0) return 0;
@@ -54,22 +54,22 @@ public:
return (super_size - 1) * B + sub_size;
}
/** return true if array is empty */
- FORCEINLINE bool IsEmpty() { return data.IsEmpty(); }
+ inline bool IsEmpty() { return data.IsEmpty(); }
/** return true if array is full */
- FORCEINLINE 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 */
- FORCEINLINE T *Append() { return FirstFreeSubArray().Append(); }
+ inline T *Append() { return FirstFreeSubArray().Append(); }
/** allocate and construct new item */
- FORCEINLINE T *AppendC() { return FirstFreeSubArray().AppendC(); }
+ inline T *AppendC() { return FirstFreeSubArray().AppendC(); }
/** indexed access (non-const) */
- FORCEINLINE T& operator [] (uint index)
+ inline T& operator [] (uint index)
{
const SubArray& s = data[index / B];
T& item = s[index % B];
return item;
}
/** indexed access (const) */
- FORCEINLINE 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];
diff --git a/src/misc/binaryheap.hpp b/src/misc/binaryheap.hpp
index 55730a2ce..0a2e02ed0 100644
--- a/src/misc/binaryheap.hpp
+++ b/src/misc/binaryheap.hpp
@@ -85,7 +85,7 @@ protected:
* @param item The proposed item for filling the gap
* @return The (gap)position where the item fits
*/
- FORCEINLINE uint HeapifyDown(uint gap, T *item)
+ inline uint HeapifyDown(uint gap, T *item)
{
assert(gap != 0);
@@ -121,7 +121,7 @@ protected:
* @param item The proposed item for filling the gap
* @return The (gap)position where the item fits
*/
- FORCEINLINE uint HeapifyUp(uint gap, T *item)
+ inline uint HeapifyUp(uint gap, T *item)
{
assert(gap != 0);
@@ -142,7 +142,7 @@ protected:
#if BINARYHEAP_CHECK
/** Verify the heap consistency */
- FORCEINLINE void CheckConsistency()
+ inline void CheckConsistency()
{
for (uint child = 2; child <= this->items; child++) {
uint parent = child / 2;
@@ -157,28 +157,28 @@ public:
*
* @return The number of items in the queue
*/
- FORCEINLINE uint Length() const { return this->items; }
+ inline uint Length() const { return this->items; }
/**
* Test if the priority queue is empty.
*
* @return True if empty
*/
- FORCEINLINE 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.
*/
- FORCEINLINE 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.
*
* @return The smallest item, or throw assert if empty.
*/
- FORCEINLINE T *Begin()
+ inline T *Begin()
{
assert(!this->IsEmpty());
return this->data[1];
@@ -191,7 +191,7 @@ public:
*
* @return The last item
*/
- FORCEINLINE T *End()
+ inline T *End()
{
return this->data[1 + this->items];
}
@@ -201,7 +201,7 @@ public:
*
* @param new_item The pointer to the new item
*/
- FORCEINLINE void Include(T *new_item)
+ inline void Include(T *new_item)
{
if (this->IsFull()) {
assert(this->capacity < UINT_MAX / 2);
@@ -222,7 +222,7 @@ public:
*
* @return The pointer to the removed item
*/
- FORCEINLINE T *Shift()
+ inline T *Shift()
{
assert(!this->IsEmpty());
@@ -244,7 +244,7 @@ public:
*
* @param index The position of the item in the heap
*/
- FORCEINLINE void Remove(uint index)
+ inline void Remove(uint index)
{
if (index < this->items) {
assert(index != 0);
@@ -272,7 +272,7 @@ public:
* @param item The reference to the item
* @return The index of the item or zero if not found
*/
- FORCEINLINE uint FindIndex(const T &item) const
+ inline uint FindIndex(const T &item) const
{
if (this->IsEmpty()) return 0;
for (T **ppI = this->data + 1, **ppLast = ppI + this->items; ppI <= ppLast; ppI++) {
@@ -287,7 +287,7 @@ public:
* Make the priority queue empty.
* All remaining items will remain untouched.
*/
- FORCEINLINE 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 94459a365..0b14a7eae 100644
--- a/src/misc/blob.hpp
+++ b/src/misc/blob.hpp
@@ -71,17 +71,17 @@ public:
static const size_t header_size = sizeof(BlobHeader);
/** default constructor - initializes empty blob */
- FORCEINLINE ByteBlob() { InitEmpty(); }
+ inline ByteBlob() { InitEmpty(); }
/** copy constructor */
- FORCEINLINE ByteBlob(const ByteBlob &src)
+ inline ByteBlob(const ByteBlob &src)
{
InitEmpty();
AppendRaw(src);
}
/** move constructor - take ownership of blob data */
- FORCEINLINE ByteBlob(BlobHeader * const & src)
+ inline ByteBlob(BlobHeader * const & src)
{
assert(src != NULL);
header = src;
@@ -89,14 +89,14 @@ public:
}
/** destructor */
- FORCEINLINE ~ByteBlob()
+ inline ~ByteBlob()
{
Free();
}
protected:
/** all allocation should happen here */
- static FORCEINLINE BlobHeader *RawAlloc(size_t num_bytes)
+ static inline BlobHeader *RawAlloc(size_t num_bytes)
{
return (BlobHeader*)MallocT<byte>(num_bytes);
}
@@ -105,13 +105,13 @@ protected:
* Return header pointer to the static BlobHeader with
* both items and capacity containing zero
*/
- static FORCEINLINE BlobHeader *Zero()
+ static inline BlobHeader *Zero()
{
return const_cast<BlobHeader *>(&ByteBlob::hdrEmpty[1]);
}
/** simple allocation policy - can be optimized later */
- static FORCEINLINE size_t AllocPolicy(size_t min_alloc)
+ static inline size_t AllocPolicy(size_t min_alloc)
{
if (min_alloc < (1 << 9)) {
if (min_alloc < (1 << 5)) return (1 << 5);
@@ -130,7 +130,7 @@ protected:
}
/** all deallocations should happen here */
- static FORCEINLINE void RawFree(BlobHeader *p)
+ static inline void RawFree(BlobHeader *p)
{
/* Just to silence an unsilencable GCC 4.4+ warning. */
assert(p != ByteBlob::hdrEmpty);
@@ -140,74 +140,74 @@ protected:
}
/** initialize the empty blob */
- FORCEINLINE void InitEmpty()
+ inline void InitEmpty()
{
header = Zero();
}
/** initialize blob by attaching it to the given header followed by data */
- FORCEINLINE void Init(BlobHeader *src)
+ inline void Init(BlobHeader *src)
{
header = &src[1];
}
/** blob header accessor - use it rather than using the pointer arithmetics directly - non-const version */
- FORCEINLINE BlobHeader& Hdr()
+ inline BlobHeader& Hdr()
{
return *(header - 1);
}
/** blob header accessor - use it rather than using the pointer arithmetics directly - const version */
- FORCEINLINE const BlobHeader& Hdr() const
+ inline const BlobHeader& Hdr() const
{
return *(header - 1);
}
/** return reference to the actual blob size - used when the size needs to be modified */
- FORCEINLINE size_t& LengthRef()
+ inline size_t& LengthRef()
{
return Hdr().items;
}
public:
/** return true if blob doesn't contain valid data */
- FORCEINLINE bool IsEmpty() const
+ inline bool IsEmpty() const
{
return Length() == 0;
}
/** return the number of valid data bytes in the blob */
- FORCEINLINE size_t Length() const
+ inline size_t Length() const
{
return Hdr().items;
}
/** return the current blob capacity in bytes */
- FORCEINLINE size_t Capacity() const
+ inline size_t Capacity() const
{
return Hdr().capacity;
}
/** return pointer to the first byte of data - non-const version */
- FORCEINLINE byte *Begin()
+ inline byte *Begin()
{
return data;
}
/** return pointer to the first byte of data - const version */
- FORCEINLINE const byte *Begin() const
+ inline const byte *Begin() const
{
return data;
}
/** invalidate blob's data - doesn't free buffer */
- FORCEINLINE void Clear()
+ inline void Clear()
{
LengthRef() = 0;
}
/** free the blob's memory */
- FORCEINLINE void Free()
+ inline void Free()
{
if (Capacity() > 0) {
RawFree(&Hdr());
@@ -216,7 +216,7 @@ public:
}
/** append new bytes at the end of existing data bytes - reallocates if necessary */
- FORCEINLINE void AppendRaw(const void *p, size_t num_bytes)
+ inline void AppendRaw(const void *p, size_t num_bytes)
{
assert(p != NULL);
if (num_bytes > 0) {
@@ -225,7 +225,7 @@ public:
}
/** append bytes from given source blob to the end of existing data bytes - reallocates if necessary */
- FORCEINLINE void AppendRaw(const ByteBlob& src)
+ inline void AppendRaw(const ByteBlob& src)
{
if (!src.IsEmpty()) {
memcpy(Append(src.Length()), src.Begin(), src.Length());
@@ -236,7 +236,7 @@ public:
* Reallocate if there is no free space for num_bytes bytes.
* @return pointer to the new data to be added
*/
- FORCEINLINE byte *Prepare(size_t num_bytes)
+ inline byte *Prepare(size_t num_bytes)
{
size_t new_size = Length() + num_bytes;
if (new_size > Capacity()) SmartAlloc(new_size);
@@ -247,7 +247,7 @@ public:
* Increase Length() by num_bytes.
* @return pointer to the new data added
*/
- FORCEINLINE byte *Append(size_t num_bytes)
+ inline byte *Append(size_t num_bytes)
{
byte *pNewData = Prepare(num_bytes);
LengthRef() += num_bytes;
@@ -281,7 +281,7 @@ public:
}
/** fixing the four bytes at the end of blob data - useful when blob is used to hold string */
- FORCEINLINE void FixTail() const
+ inline void FixTail() const
{
if (Capacity() > 0) {
byte *p = &data[Length()];
@@ -317,73 +317,73 @@ public:
};
/** Default constructor - makes new Blob ready to accept any data */
- FORCEINLINE CBlobT()
+ inline CBlobT()
: base()
{}
/** Take ownership constructor */
- FORCEINLINE CBlobT(const OnTransfer& ot)
+ inline CBlobT(const OnTransfer& ot)
: base(ot.header)
{}
/** Destructor - ensures that allocated memory (if any) is freed */
- FORCEINLINE ~CBlobT()
+ inline ~CBlobT()
{
Free();
}
/** Check the validity of item index (only in debug mode) */
- FORCEINLINE void CheckIdx(size_t index) const
+ inline void CheckIdx(size_t index) const
{
assert(index < Size());
}
/** Return pointer to the first data item - non-const version */
- FORCEINLINE T *Data()
+ inline T *Data()
{
return (T*)base::Begin();
}
/** Return pointer to the first data item - const version */
- FORCEINLINE const T *Data() const
+ inline const T *Data() const
{
return (const T*)base::Begin();
}
/** Return pointer to the index-th data item - non-const version */
- FORCEINLINE T *Data(size_t index)
+ inline T *Data(size_t index)
{
CheckIdx(index);
return (Data() + index);
}
/** Return pointer to the index-th data item - const version */
- FORCEINLINE const T *Data(size_t index) const
+ inline const T *Data(size_t index) const
{
CheckIdx(index);
return (Data() + index);
}
/** Return number of items in the Blob */
- FORCEINLINE size_t Size() const
+ inline size_t Size() const
{
return (base::Length() / type_size);
}
/** Return total number of items that can fit in the Blob without buffer reallocation */
- FORCEINLINE size_t MaxSize() const
+ inline size_t MaxSize() const
{
return (base::Capacity() / type_size);
}
/** Return number of additional items that can fit in the Blob without buffer reallocation */
- FORCEINLINE size_t GetReserve() const
+ inline size_t GetReserve() const
{
return ((base::Capacity() - base::Length()) / type_size);
}
/** Grow number of data items in Blob by given number - doesn't construct items */
- FORCEINLINE T *GrowSizeNC(size_t num_items)
+ inline T *GrowSizeNC(size_t num_items)
{
return (T*)base::Append(num_items * type_size);
}
@@ -392,12 +392,12 @@ public:
* Ensures that given number of items can be added to the end of Blob. Returns pointer to the
* first free (unused) item
*/
- FORCEINLINE T *MakeFreeSpace(size_t num_items)
+ inline T *MakeFreeSpace(size_t num_items)
{
return (T*)base::Prepare(num_items * type_size);
}
- FORCEINLINE OnTransfer Transfer()
+ inline OnTransfer Transfer()
{
return OnTransfer(*this);
}
diff --git a/src/misc/countedptr.hpp b/src/misc/countedptr.hpp
index fbf2a40df..0187422df 100644
--- a/src/misc/countedptr.hpp
+++ b/src/misc/countedptr.hpp
@@ -35,64 +35,64 @@ protected:
public:
/** default (NULL) construct or construct from a raw pointer */
- FORCEINLINE 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) */
- FORCEINLINE 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 */
- FORCEINLINE ~CCountedPtr() {Release();}
+ inline ~CCountedPtr() {Release();}
protected:
/** add one ref to the underlaying object */
- FORCEINLINE 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 */
- FORCEINLINE 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 */
- FORCEINLINE 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 */
- FORCEINLINE 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 */
- FORCEINLINE 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 */
- FORCEINLINE operator Tcls*() {return m_pT;}
+ inline operator Tcls*() {return m_pT;}
/** operator & to support output arguments */
- FORCEINLINE Tcls** operator &() {assert(m_pT == NULL); return &m_pT;}
+ inline Tcls** operator &() {assert(m_pT == NULL); return &m_pT;}
/** assignment operator from raw ptr */
- FORCEINLINE CCountedPtr& operator = (Tcls *pT) {Assign(pT); return *this;}
+ inline CCountedPtr& operator = (Tcls *pT) {Assign(pT); return *this;}
/** assignment operator from another smart ptr */
- FORCEINLINE 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 */
- FORCEINLINE void Assign(Tcls *pT);
+ inline void Assign(Tcls *pT);
/** one way how to test for NULL value */
- FORCEINLINE bool IsNull() const {return m_pT == NULL;}
+ inline bool IsNull() const {return m_pT == NULL;}
/** another way how to test for NULL value */
- //FORCEINLINE 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 */
- //FORCEINLINE 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 */
- FORCEINLINE void Attach(Tcls *pT) {Release(); m_pT = pT;}
+ inline void Attach(Tcls *pT) {Release(); m_pT = pT;}
/** detach pointer w/o decrementing ref count */
- FORCEINLINE Tcls *Detach() {Tcls *pT = m_pT; m_pT = NULL; return pT;}
+ inline Tcls *Detach() {Tcls *pT = m_pT; m_pT = NULL; return pT;}
};
template <class Tcls_>
-FORCEINLINE void CCountedPtr<Tcls_>::Assign(Tcls *pT)
+inline void CCountedPtr<Tcls_>::Assign(Tcls *pT)
{
/* if they are the same, we do nothing */
if (pT != m_pT) {
diff --git a/src/misc/fixedsizearray.hpp b/src/misc/fixedsizearray.hpp
index a6f4d0c42..4216570b8 100644
--- a/src/misc/fixedsizearray.hpp
+++ b/src/misc/fixedsizearray.hpp
@@ -41,13 +41,13 @@ protected:
T *data;
/** return reference to the array header (non-const) */
- FORCEINLINE ArrayHeader& Hdr() { return *(ArrayHeader*)(((byte*)data) - HeaderSize); }
+ inline ArrayHeader& Hdr() { return *(ArrayHeader*)(((byte*)data) - HeaderSize); }
/** return reference to the array header (const) */
- FORCEINLINE 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 */
- FORCEINLINE uint& RefCnt() { return Hdr().reference_count; }
+ inline uint& RefCnt() { return Hdr().reference_count; }
/** return reference to number of used items */
- FORCEINLINE uint& SizeRef() { return Hdr().items; }
+ inline uint& SizeRef() { return Hdr().items; }
public:
/** Default constructor. Preallocate space for items and header, then initialize header. */
@@ -83,7 +83,7 @@ public:
}
/** Clear (destroy) all items */
- FORCEINLINE void Clear()
+ inline void Clear()
{
/* Walk through all allocated items backward and destroy them
* Note: this->Length() can be zero. In that case data[this->Length() - 1] is evaluated unsigned
@@ -96,19 +96,19 @@ public:
}
/** return number of used items */
- FORCEINLINE uint Length() const { return Hdr().items; }
+ inline uint Length() const { return Hdr().items; }
/** return true if array is full */
- FORCEINLINE bool IsFull() const { return Length() >= C; }
+ inline bool IsFull() const { return Length() >= C; }
/** return true if array is empty */
- FORCEINLINE bool IsEmpty() const { return Length() <= 0; }
+ inline bool IsEmpty() const { return Length() <= 0; }
/** add (allocate), but don't construct item */
- FORCEINLINE T *Append() { assert(!IsFull()); return &data[SizeRef()++]; }
+ inline T *Append() { assert(!IsFull()); return &data[SizeRef()++]; }
/** add and construct item using default constructor */
- FORCEINLINE 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) */
- FORCEINLINE 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) */
- FORCEINLINE 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 c59187f4e..60bdcec25 100644
--- a/src/misc/hashtable.hpp
+++ b/src/misc/hashtable.hpp
@@ -21,13 +21,13 @@ struct CHashTableSlotT
Titem_ *m_pFirst;
- FORCEINLINE CHashTableSlotT() : m_pFirst(NULL) {}
+ inline CHashTableSlotT() : m_pFirst(NULL) {}
/** hash table slot helper - clears the slot by simple forgetting its items */
- FORCEINLINE 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 */
- FORCEINLINE 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 */
- FORCEINLINE 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 */
- FORCEINLINE 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 */
- FORCEINLINE 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 */
- FORCEINLINE Titem_ *Detach(const Key& key)
+ inline Titem_ *Detach(const Key& key)
{
/* do we have any items? */
if (m_pFirst == NULL) {
@@ -150,13 +150,13 @@ protected:
public:
/* default constructor */
- FORCEINLINE CHashTableT() : m_num_items(0)
+ inline CHashTableT() : m_num_items(0)
{
}
protected:
/** static helper - return hash for the given key modulo number of slots */
- FORCEINLINE 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,14 +168,14 @@ protected:
}
/** static helper - return hash for the given item modulo number of slots */
- FORCEINLINE static int CalcHash(const Titem_& item) {return CalcHash(item.GetKey());}
+ inline static int CalcHash(const Titem_& item) {return CalcHash(item.GetKey());}
public:
/** item count */
- FORCEINLINE int Count() const {return m_num_items;}
+ inline int Count() const {return m_num_items;}
/** simple clear - forget all items - used by CSegmentCostCacheT.Flush() */
- FORCEINLINE 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/misc/str.hpp b/src/misc/str.hpp
index 1d58b63ae..b109b4e82 100644
--- a/src/misc/str.hpp
+++ b/src/misc/str.hpp
@@ -24,24 +24,24 @@ struct CStrA : public CBlobT<char>
typedef CBlobT<char> base; ///< base class
/** Create an empty CStrT */
- FORCEINLINE CStrA()
+ inline CStrA()
{
}
/** Copy constructor */
- FORCEINLINE CStrA(const CStrA &src) : base(src)
+ inline CStrA(const CStrA &src) : base(src)
{
base::FixTail();
}
/** Take over ownership constructor */
- FORCEINLINE CStrA(const OnTransfer& ot)
+ inline CStrA(const OnTransfer& ot)
: base(ot)
{
}
/** Grow the actual buffer and fix the trailing zero at the end. */
- FORCEINLINE char *GrowSizeNC(uint count)
+ inline char *GrowSizeNC(uint count)
{
char *ret = base::GrowSizeNC(count);
base::FixTail();
@@ -49,7 +49,7 @@ struct CStrA : public CBlobT<char>
}
/** Append zero-ended C string. */
- FORCEINLINE void AppendStr(const char *str)
+ inline void AppendStr(const char *str)
{
if (!StrEmpty(str)) {
base::AppendRaw(str, strlen(str));
@@ -58,7 +58,7 @@ struct CStrA : public CBlobT<char>
}
/** Append another CStrA. */
- FORCEINLINE void Append(const CStrA &src)
+ inline void Append(const CStrA &src)
{
if (src.Length() > 0) {
base::AppendRaw(src);
@@ -67,7 +67,7 @@ struct CStrA : public CBlobT<char>
}
/** Assignment from C string. */
- FORCEINLINE 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. */
- FORCEINLINE 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) */
- FORCEINLINE bool operator < (const CStrA &other) const
+ inline bool operator < (const CStrA &other) const
{
return strcmp(base::Data(), other.Data()) < 0;
}