From c7dafb9a26e355621a8f99b5fb470ceb97ce1fd0 Mon Sep 17 00:00:00 2001 From: frosch Date: Sat, 16 Jan 2010 13:52:24 +0000 Subject: (svn r18822) -Codechange: Rename YAPF-related container classes and their members to better fit other container classes. (skidd13) --- src/misc/array.hpp | 60 +++++++++++++++++++++--------------------- src/misc/fixedsizearray.hpp | 64 ++++++++++++++++++++++----------------------- 2 files changed, 62 insertions(+), 62 deletions(-) (limited to 'src/misc') diff --git a/src/misc/array.hpp b/src/misc/array.hpp index f5a602155..737877c75 100644 --- a/src/misc/array.hpp +++ b/src/misc/array.hpp @@ -17,70 +17,70 @@ /** Flexible array with size limit. Implemented as fixed size * array of fixed size arrays */ -template -class CArrayT { +template +class SmallArray { public: - typedef Titem_ Titem; ///< Titem is now visible from outside - typedef CFixedSizeArrayT CSubArray; ///< inner array - typedef CFixedSizeArrayT CSuperArray; ///< outer array + typedef T Titem; ///< Titem is now visible from outside + typedef FixedSizeArray SubArray; ///< inner array + typedef FixedSizeArray SuperArray; ///< outer array protected: - CSuperArray m_a; ///< array of arrays of items + SuperArray data; ///< array of arrays of items public: - static const int Tblock_size = Tblock_size_; ///< block size is now visible from outside - static const int Tnum_blocks = Tnum_blocks_; ///< number of blocks is now visible from outside - static const int Tcapacity = Tblock_size * Tnum_blocks; ///< total max number of items + static const int Tblock_size = B; ///< block size is now visible from outside + static const int Tnum_blocks = N; ///< number of blocks is now visible from outside + static const int Tcapacity = B * N; ///< total max number of items /** implicit constructor */ - FORCEINLINE CArrayT() { } + FORCEINLINE SmallArray() { } /** Clear (destroy) all items */ - FORCEINLINE void Clear() {m_a.Clear();} + FORCEINLINE void Clear() {data.Clear();} /** Return actual number of items */ - FORCEINLINE int Size() const + FORCEINLINE int Length() const { - int super_size = m_a.Size(); + int super_size = data.Length(); if (super_size == 0) return 0; - int sub_size = m_a[super_size - 1].Size(); + int sub_size = data[super_size - 1].Length(); return (super_size - 1) * Tblock_size + sub_size; } /** return true if array is empty */ - FORCEINLINE bool IsEmpty() { return m_a.IsEmpty(); } + FORCEINLINE bool IsEmpty() { return data.IsEmpty(); } /** return true if array is full */ - FORCEINLINE bool IsFull() { return m_a.IsFull() && m_a[Tnum_blocks - 1].IsFull(); } + FORCEINLINE bool IsFull() { return data.IsFull() && data[Tnum_blocks - 1].IsFull(); } /** return first sub-array with free space for new item */ - FORCEINLINE CSubArray& FirstFreeSubArray() + FORCEINLINE SubArray& FirstFreeSubArray() { - int super_size = m_a.Size(); + int super_size = data.Length(); if (super_size > 0) { - CSubArray& sa = m_a[super_size - 1]; - if (!sa.IsFull()) return sa; + SubArray& s = data[super_size - 1]; + if (!s.IsFull()) return s; } - return m_a.Add(); + return data.AppendC(); } /** allocate but not construct new item */ - FORCEINLINE Titem_& AddNC() { return FirstFreeSubArray().AddNC(); } + FORCEINLINE T& Append() { return FirstFreeSubArray().Append(); } /** allocate and construct new item */ - FORCEINLINE Titem_& Add() { return FirstFreeSubArray().Add(); } + FORCEINLINE T& AppendC() { return FirstFreeSubArray().AppendC(); } /** indexed access (non-const) */ - FORCEINLINE Titem& operator [] (int idx) + FORCEINLINE Titem& operator [] (int index) { - CSubArray& sa = m_a[idx / Tblock_size]; - Titem& item = sa [idx % Tblock_size]; + SubArray& s = data[index / Tblock_size]; + Titem& item = s[index % Tblock_size]; return item; } /** indexed access (const) */ - FORCEINLINE const Titem& operator [] (int idx) const + FORCEINLINE const Titem& operator [] (int index) const { - const CSubArray& sa = m_a[idx / Tblock_size]; - const Titem& item = sa [idx % Tblock_size]; + const SubArray& s = data[index / Tblock_size]; + const Titem& item = s[index % Tblock_size]; return item; } template void Dump(D &dmp) const { dmp.WriteLine("capacity = %d", Tcapacity); - int num_items = Size(); + int num_items = Length(); dmp.WriteLine("num_items = %d", num_items); CStrA name; for (int i = 0; i < num_items; i++) { diff --git a/src/misc/fixedsizearray.hpp b/src/misc/fixedsizearray.hpp index 3e39cc4d9..d6c1242f3 100644 --- a/src/misc/fixedsizearray.hpp +++ b/src/misc/fixedsizearray.hpp @@ -18,61 +18,61 @@ * Upon construction it preallocates fixed size block of memory * for all items, but doesn't construct them. Item's construction * is delayed. */ -template -struct CFixedSizeArrayT { +template +struct FixedSizeArray { /** the only member of fixed size array is pointer to the block - * of C array of items. Header can be found on the offset -sizeof(CHdr). */ - Titem_ *m_items; + * of C array of items. Header can be found on the offset -sizeof(ArrayHeader). */ + T *data; /** header for fixed size array */ - struct CHdr + struct ArrayHeader { - int m_num_items; ///< number of items in the array - int m_ref_cnt; ///< block reference counter (used by copy constructor and by destructor) + int items; ///< number of items in the array + int reference_count; ///< block reference counter (used by copy constructor and by destructor) }; /* make types and constants visible from outside */ - typedef Titem_ Titem; // type of array item + typedef T Titem; // type of array item - static const int Tcapacity = Tcapacity_; // the array capacity (maximum size) - static const int TitemSize = sizeof(Titem_); // size of item - static const int ThdrSize = sizeof(CHdr); // size of header + static const int Tcapacity = C; // the array capacity (maximum size) + static const int Tsize = sizeof(T); // size of item + static const int HeaderSize = sizeof(ArrayHeader); // size of header /** Default constructor. Preallocate space for items and header, then initialize header. */ - CFixedSizeArrayT() + FixedSizeArray() { /* allocate block for header + items (don't construct items) */ - m_items = (Titem*)((MallocT(ThdrSize + Tcapacity * sizeof(Titem))) + ThdrSize); + data = (Titem*)((MallocT(HeaderSize + Tcapacity * Tsize)) + HeaderSize); SizeRef() = 0; // initial number of items RefCnt() = 1; // initial reference counter } /** Copy constructor. Preallocate space for items and header, then initialize header. */ - CFixedSizeArrayT(const CFixedSizeArrayT& src) + FixedSizeArray(const FixedSizeArray& src) { /* share block (header + items) with the source array */ - m_items = src.m_items; + data = src.data; RefCnt()++; // now we share block with the source } /** destroy remaining items and free the memory block */ - ~CFixedSizeArrayT() + ~FixedSizeArray() { /* release one reference to the shared block */ if ((--RefCnt()) > 0) return; // and return if there is still some owner Clear(); /* free the memory block occupied by items */ - free(((int8*)m_items) - ThdrSize); - m_items = NULL; + free(((int8*)data) - HeaderSize); + data = NULL; } /** Clear (destroy) all items */ FORCEINLINE void Clear() { /* walk through all allocated items backward and destroy them */ - for (Titem *pItem = &m_items[Size() - 1]; pItem >= m_items; pItem--) { - pItem->~Titem_(); + for (Titem *pItem = &data[Length() - 1]; pItem >= data; pItem--) { + pItem->~T(); } /* number of items become zero */ SizeRef() = 0; @@ -80,30 +80,30 @@ struct CFixedSizeArrayT { protected: /** return reference to the array header (non-const) */ - FORCEINLINE CHdr& Hdr() { return *(CHdr*)(((int8*)m_items) - ThdrSize); } + FORCEINLINE ArrayHeader& Hdr() { return *(ArrayHeader*)(((int8*)data) - HeaderSize); } /** return reference to the array header (const) */ - FORCEINLINE const CHdr& Hdr() const { return *(CHdr*)(((int8*)m_items) - ThdrSize); } + FORCEINLINE const ArrayHeader& Hdr() const { return *(ArrayHeader*)(((int8*)data) - HeaderSize); } /** return reference to the block reference counter */ - FORCEINLINE int& RefCnt() { return Hdr().m_ref_cnt; } + FORCEINLINE int& RefCnt() { return Hdr().reference_count; } /** return reference to number of used items */ - FORCEINLINE int& SizeRef() { return Hdr().m_num_items; } + FORCEINLINE int& SizeRef() { return Hdr().items; } public: /** return number of used items */ - FORCEINLINE int Size() const { return Hdr().m_num_items; } + FORCEINLINE int Length() const { return Hdr().items; } /** return true if array is full */ - FORCEINLINE bool IsFull() const { return Size() >= Tcapacity; }; + FORCEINLINE bool IsFull() const { return Length() >= Tcapacity; }; /** return true if array is empty */ - FORCEINLINE bool IsEmpty() const { return Size() <= 0; }; + FORCEINLINE bool IsEmpty() const { return Length() <= 0; }; /** index validation */ - FORCEINLINE void CheckIdx(int idx) const { assert(idx >= 0); assert(idx < Size()); } + FORCEINLINE void CheckIdx(int index) const { assert(index >= 0); assert(index < Length()); } /** add (allocate), but don't construct item */ - FORCEINLINE Titem& AddNC() { assert(!IsFull()); return m_items[SizeRef()++]; } + FORCEINLINE Titem& Append() { assert(!IsFull()); return data[SizeRef()++]; } /** add and construct item using default constructor */ - FORCEINLINE Titem& Add() { Titem& item = AddNC(); new(&item)Titem; return item; } + FORCEINLINE Titem& AppendC() { Titem& item = Append(); new(&item)Titem; return item; } /** return item by index (non-const version) */ - FORCEINLINE Titem& operator [] (int idx) { CheckIdx(idx); return m_items[idx]; } + FORCEINLINE Titem& operator [] (int index) { CheckIdx(index); return data[index]; } /** return item by index (const version) */ - FORCEINLINE const Titem& operator [] (int idx) const { CheckIdx(idx); return m_items[idx]; } + FORCEINLINE const Titem& operator [] (int index) const { CheckIdx(index); return data[index]; } }; #endif /* FIXEDSIZEARRAY_HPP */ -- cgit v1.2.3-54-g00ecf