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

	static const int Tcapacity = Tcapacity_;     // the array capacity (maximum size)

    28

	static const int TitemSize = sizeof(Titem_); // size of item

    29

	static 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 = src.m_items;

    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

		Clear();

    55

		// free the memory block occupied by items

    56

		free(((int8*)m_items) - ThdrSize);

    57

		m_items = NULL;

    58

	}

    59

    60

	/** Clear (destroy) all items */

    61

	FORCEINLINE void Clear()

    62

	{

    63

		// walk through all allocated items backward and destroy them

    64

		for (Titem* pItem = &m_items[Size() - 1]; pItem >= m_items; pItem--) {

    65

			pItem->~Titem_();

    66

		}

    67

		// number of items become zero

    68

		SizeRef() = 0;

    69

	}

    70

    71

protected:

    72

	/** return reference to the array header (non-const) */

    73

	FORCEINLINE CHdr& Hdr() { return *(CHdr*)(((int8*)m_items) - ThdrSize); }

    74

	/** return reference to the array header (const) */

    75

	FORCEINLINE const CHdr& Hdr() const { return *(CHdr*)(((int8*)m_items) - ThdrSize); }

    76

	/** return reference to the block reference counter */

    77

	FORCEINLINE int& RefCnt() { return Hdr().m_ref_cnt; }

    78

	/** return reference to number of used items */

    79

	FORCEINLINE int& SizeRef() { return Hdr().m_num_items; }

    80

public:

    81

	/** return number of used items */

    82

	FORCEINLINE int Size() const { return Hdr().m_num_items; }

    83

	/** return true if array is full */

    84

	FORCEINLINE bool IsFull() const { return Size() >= Tcapacity; };

    85

	/** return true if array is empty */

    86

	FORCEINLINE bool IsEmpty() const { return Size() <= 0; };

    87

	/** index validation */

    88

	FORCEINLINE void CheckIdx(int idx) const { assert(idx >= 0); assert(idx < Size()); }

    89

	/** add (allocate), but don't construct item */

    90

	FORCEINLINE Titem& AddNC() { assert(!IsFull()); return m_items[SizeRef()++]; }

    91

	/** add and construct item using default constructor */

    92

	FORCEINLINE Titem& Add() { Titem& item = AddNC(); new(&item)Titem; return item; }

    93

	/** return item by index (non-const version) */

    94

	FORCEINLINE Titem& operator [] (int idx) { CheckIdx(idx); return m_items[idx]; }

    95

	/** return item by index (const version) */

    96

	FORCEINLINE const Titem& operator [] (int idx) const { CheckIdx(idx); return m_items[idx]; }

    97

};

    98

    99

#endif /* FIXEDSIZEARRAY_HPP */