|
1 /* $Id$ */ |
|
2 |
|
3 #ifndef FIXEDSIZEARRAY_HPP |
|
4 #define FIXEDSIZEARRAY_HPP |
|
5 |
|
6 |
|
7 /** fixed size array |
|
8 Upon construction it preallocates fixed size block of memory |
|
9 for all items, but doesn't construct them. Item's construction |
|
10 is delayed. */ |
|
11 template <class Titem_, int Tcapacity_> |
|
12 struct CFixedSizeArrayT { |
|
13 /** the only member of fixed size array is pointer to the block |
|
14 of C array of items. Header can be found on the offset -sizeof(CHdr). */ |
|
15 Titem_ *m_items; |
|
16 |
|
17 /** header for fixed size array */ |
|
18 struct CHdr |
|
19 { |
|
20 int m_num_items; ///< number of items in the array |
|
21 int m_ref_cnt; ///< block reference counter (used by copy constructor and by destructor) |
|
22 }; |
|
23 |
|
24 // make types and constants visible from outside |
|
25 typedef Titem_ Titem; // type of array item |
|
26 |
|
27 ST_CONST(int, Tcapacity = Tcapacity_); // the array capacity (maximum size) |
|
28 ST_CONST(int, TitemSize = sizeof(Titem_)); // size of item |
|
29 ST_CONST(int, ThdrSize = sizeof(CHdr)); // size of header |
|
30 |
|
31 /** Default constructor. Preallocate space for items and header, then initialize header. */ |
|
32 CFixedSizeArrayT() |
|
33 { |
|
34 // allocate block for header + items (don't construct items) |
|
35 m_items = (Titem*)(((int8*)malloc(ThdrSize + Tcapacity * sizeof(Titem))) + ThdrSize); |
|
36 SizeRef() = 0; // initial number of items |
|
37 RefCnt() = 1; // initial reference counter |
|
38 } |
|
39 |
|
40 /** Copy constructor. Preallocate space for items and header, then initialize header. */ |
|
41 CFixedSizeArrayT(const CFixedSizeArrayT<Titem_, Tcapacity_>& src) |
|
42 { |
|
43 // share block (header + items) with the source array |
|
44 m_items = const_cast<Titem*>(src.m_items); // here we break the 'const' modifier |
|
45 RefCnt()++; // now we share block with the source |
|
46 } |
|
47 |
|
48 /** destroy remaining items and free the memory block */ |
|
49 ~CFixedSizeArrayT() |
|
50 { |
|
51 // release one reference to the shared block |
|
52 if ((--RefCnt()) > 0) return; // and return if there is still some owner |
|
53 |
|
54 // walk through all allocated items backward and destroy them |
|
55 for (Titem* pItem = &m_items[Size() - 1]; pItem >= m_items; pItem--) { |
|
56 pItem->~Titem_(); |
|
57 } |
|
58 free(((int8*)m_items) - ThdrSize); |
|
59 m_items = NULL; |
|
60 } |
|
61 |
|
62 protected: |
|
63 /** return reference to the array header (non-const) */ |
|
64 FORCEINLINE CHdr& Hdr() { return *(CHdr*)(((int8*)m_items) - ThdrSize); } |
|
65 /** return reference to the array header (const) */ |
|
66 FORCEINLINE const CHdr& Hdr() const { return *(CHdr*)(((int8*)m_items) - ThdrSize); } |
|
67 /** return reference to the block reference counter */ |
|
68 FORCEINLINE int& RefCnt() { return Hdr().m_ref_cnt; } |
|
69 /** return reference to number of used items */ |
|
70 FORCEINLINE int& SizeRef() { return Hdr().m_num_items; } |
|
71 public: |
|
72 /** return number of used items */ |
|
73 FORCEINLINE int Size() const { return Hdr().m_num_items; } |
|
74 /** return true if array is full */ |
|
75 FORCEINLINE bool IsFull() const { return Size() >= Tcapacity; }; |
|
76 /** return true if array is empty */ |
|
77 FORCEINLINE bool IsEmpty() const { return Size() <= 0; }; |
|
78 /** index validation */ |
|
79 FORCEINLINE void CheckIdx(int idx) const { assert(idx >= 0); assert(idx < Size()); } |
|
80 /** add (allocate), but don't construct item */ |
|
81 FORCEINLINE Titem& AddNC() { assert(!IsFull()); return m_items[SizeRef()++]; } |
|
82 /** add and construct item using default constructor */ |
|
83 FORCEINLINE Titem& Add() { Titem& item = AddNC(); new(&item)Titem; return item; } |
|
84 /** return item by index (non-const version) */ |
|
85 FORCEINLINE Titem& operator [] (int idx) { CheckIdx(idx); return m_items[idx]; } |
|
86 /** return item by index (const version) */ |
|
87 FORCEINLINE const Titem& operator [] (int idx) const { CheckIdx(idx); return m_items[idx]; } |
|
88 }; |
|
89 |
|
90 #endif /* FIXEDSIZEARRAY_HPP */ |