(svn r8092) -Codechange: header files with miscellaneous template classes (smart pointers, blob, array, hashtable, etc.) moved from src/yapf to src/misc as they can now be used anywhere.

8 files changed, 1225 insertions, 0 deletions

diff --git a/src/misc/array.hpp b/src/misc/array.hpp
new file mode 100644
index 000000000..e8eff1c8c
--- /dev/null
+++ b/src/misc/array.hpp
@@ -0,0 +1,71 @@
+/* $Id$ */
+
+#ifndef  ARRAY_HPP
+#define  ARRAY_HPP
+
+#include "fixedsizearray.hpp"
+
+/** Flexible array with size limit. Implemented as fixed size
+ *  array of fixed size arrays */
+template <class Titem_, int Tblock_size_ = 1024, int Tnum_blocks_ = Tblock_size_>
+class CArrayT {
+public:
+	typedef Titem_ Titem; ///< Titem is now visible from outside
+	typedef CFixedSizeArrayT<Titem_, Tblock_size_> CSubArray; ///< inner array
+	typedef CFixedSizeArrayT<CSubArray, Tnum_blocks_> CSuperArray; ///< outer array
+
+protected:
+	CSuperArray     m_a; ///< 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
+
+	/** implicit constructor */
+	FORCEINLINE CArrayT() { }
+	/** Clear (destroy) all items */
+	FORCEINLINE void Clear() {m_a.Clear();}
+	/** Return actual number of items */
+	FORCEINLINE int Size() const
+	{
+		int super_size = m_a.Size();
+		if (super_size == 0) return 0;
+		int sub_size = m_a[super_size - 1].Size();
+		return (super_size - 1) * Tblock_size + sub_size;
+	}
+	/** return true if array is empty */
+	FORCEINLINE bool IsEmpty() { return m_a.IsEmpty(); }
+	/** return true if array is full */
+	FORCEINLINE bool IsFull() { return m_a.IsFull() && m_a[Tnum_blocks - 1].IsFull(); }
+	/** return first sub-array with free space for new item */
+	FORCEINLINE CSubArray& FirstFreeSubArray()
+	{
+		int super_size = m_a.Size();
+		if (super_size > 0) {
+			CSubArray& sa = m_a[super_size - 1];
+			if (!sa.IsFull()) return sa;
+		}
+		return m_a.Add();
+	}
+	/** allocate but not construct new item */
+	FORCEINLINE Titem_& AddNC() { return FirstFreeSubArray().AddNC(); }
+	/** allocate and construct new item */
+	FORCEINLINE Titem_& Add()   { return FirstFreeSubArray().Add(); }
+	/** indexed access (non-const) */
+	FORCEINLINE Titem& operator [] (int idx)
+	{
+		CSubArray& sa = m_a[idx / Tblock_size];
+		Titem& item   = sa [idx % Tblock_size];
+		return item;
+	}
+	/** indexed access (const) */
+	FORCEINLINE const Titem& operator [] (int idx) const
+	{
+		CSubArray& sa = m_a[idx / Tblock_size];
+		Titem& item   = sa [idx % Tblock_size];
+		return item;
+	}
+};
+
+#endif /* ARRAY_HPP */
diff --git a/src/misc/autocopyptr.hpp b/src/misc/autocopyptr.hpp
new file mode 100644
index 000000000..fb6bfa028
--- /dev/null
+++ b/src/misc/autocopyptr.hpp
@@ -0,0 +1,83 @@
+/* $Id$ */
+
+#ifndef  AUTOCOPYPTR_HPP
+#define  AUTOCOPYPTR_HPP
+
+#if 0 // reenable when needed
+/** CAutoCopyPtrT - kind of CoW (Copy on Write) pointer.
+ *  It is non-invasive smart pointer (reference counter is held outside
+ *  of Tdata).
+ *  When copied, its new copy shares the same underlaying structure Tdata.
+ *  When dereferenced, its behavior depends on 2 factors:
+ *     - whether the data is shared (used by more than one pointer)
+ *     - type of access (read/write)
+ *    When shared pointer is dereferenced for write, new clone of Tdata
+ *  is made first.
+ *  Can't be used for polymorphic data types (interfaces).
+ */
+template <class Tdata_>
+class CAutoCopyPtrT {
+protected:
+	typedef Tdata_ Tdata;
+
+	struct CItem {
+		int     m_ref_cnt;  ///< reference counter
+		Tdata   m_data;     ///< custom data itself
+
+		FORCEINLINE CItem()                  : m_ref_cnt(1)                     {};
+		FORCEINLINE CItem(const Tdata& data) : m_ref_cnt(1), m_data(data)       {};
+		FORCEINLINE CItem(const CItem& src)  : m_ref_cnt(1), m_data(src.m_data) {};
+	};
+
+	mutable CItem* m_pI; ///< points to the ref-counted data
+
+public:
+	FORCEINLINE CAutoCopyPtrT() : m_pI(NULL) {};
+	FORCEINLINE CAutoCopyPtrT(const Tdata& data) : m_pI(new CItem(data)) {};
+	FORCEINLINE CAutoCopyPtrT(const CAutoCopyPtrT& src) : m_pI(src.m_pI) {if (m_pI != NULL) m_pI->m_ref_cnt++;}
+	FORCEINLINE ~CAutoCopyPtrT() {if (m_pI == NULL || (--m_pI->m_ref_cnt) > 0) return; delete m_pI; m_pI = NULL;}
+
+	/** data accessor (read only) */
+	FORCEINLINE const Tdata& GetDataRO() const {if (m_pI == NULL) m_pI = new CItem(); return m_pI->m_data;}
+	/** data accessor (read / write) */
+	FORCEINLINE Tdata& GetDataRW() {CloneIfShared(); if (m_pI == NULL) m_pI = new CItem(); return m_pI->m_data;}
+
+	/** clone data if it is shared */
+	FORCEINLINE void CloneIfShared()
+	{
+		if (m_pI != NULL && m_pI->m_ref_cnt > 1) {
+			// we share data item with somebody, clone it to become an exclusive owner
+			CItem* pNewI = new CItem(*m_pI);
+			m_pI->m_ref_cnt--;
+			m_pI = pNewI;
+		}
+	}
+
+	/** assign pointer from the other one (maintaining ref counts) */
+	FORCEINLINE void Assign(const CAutoCopyPtrT& src)
+	{
+		if (m_pI == src.m_pI) return;
+		if (m_pI != NULL && (--m_pI->m_ref_cnt) <= 0) delete m_pI;
+		m_pI = src.m_pI;
+		if (m_pI != NULL) m_pI->m_ref_cnt++;
+	}
+
+	/** dereference operator (read only) */
+	FORCEINLINE const Tdata* operator -> () const {return &GetDataRO();}
+	/** dereference operator (read / write) */
+	FORCEINLINE Tdata* operator -> () {return &GetDataRW();}
+
+	/** assignment operator */
+	FORCEINLINE CAutoCopyPtrT& operator = (const CAutoCopyPtrT& src) {Assign(src); return *this;}
+
+	/** forwarding 'lower then' operator to the underlaying items */
+	FORCEINLINE bool operator < (const CAutoCopyPtrT& other) const
+	{
+		assert(m_pI != NULL);
+		assert(other.m_pI != NULL);
+		return (m_pI->m_data) < (other.m_pI->m_data);
+	}
+};
+
+#endif /* 0 */
+#endif /* AUTOCOPYPTR_HPP */
diff --git a/src/misc/binaryheap.hpp b/src/misc/binaryheap.hpp
new file mode 100644
index 000000000..7b72a25af
--- /dev/null
+++ b/src/misc/binaryheap.hpp
@@ -0,0 +1,225 @@
+/* $Id$ */
+
+#ifndef  BINARYHEAP_HPP
+#define  BINARYHEAP_HPP
+
+//void* operator new (size_t size, void* p) {return p;}
+#if defined(_MSC_VER) && (_MSC_VER >= 1400)
+//void operator delete (void* p, void* p2) {}
+#endif
+
+
+/**
+ * Binary Heap as C++ template.
+ *
+ * For information about Binary Heap algotithm,
+ *   see: http://www.policyalmanac.org/games/binaryHeaps.htm
+ *
+ * Implementation specific notes:
+ *
+ * 1) It allocates space for item pointers (array). Items are allocated elsewhere.
+ *
+ * 2) ItemPtr [0] is never used. Total array size is max_items + 1, because we
+ *    use indices 1..max_items instead of zero based C indexing.
+ *
+ * 3) Item of the binary heap should support these public members:
+ *    - 'lower-then' operator '<' - used for comparing items before moving
+ *
+ */
+
+template <class Titem_>
+class CBinaryHeapT {
+public:
+	typedef Titem_ *ItemPtr;
+private:
+	int                     m_size;     ///< Number of items in the heap
+	int                     m_max_size; ///< Maximum number of items the heap can hold
+	ItemPtr*                m_items;    ///< The heap item pointers
+
+public:
+	explicit CBinaryHeapT(int max_items = 102400)
+		: m_size(0)
+		, m_max_size(max_items)
+	{
+		m_items = new ItemPtr[max_items + 1];
+	}
+
+	~CBinaryHeapT()
+	{
+		Clear();
+		delete [] m_items;
+		m_items = NULL;
+	}
+
+public:
+	/** Return the number of items stored in the priority queue.
+	 *  @return number of items in the queue */
+	FORCEINLINE int Size() const {return m_size;};
+
+	/** Test if the priority queue is empty.
+	 *  @return true if empty */
+	FORCEINLINE bool IsEmpty() const {return (m_size == 0);};
+
+	/** Test if the priority queue is full.
+	 *  @return true if full. */
+	FORCEINLINE bool IsFull() const {return (m_size >= m_max_size);};
+
+	/** Find the smallest item in the priority queue.
+	 *  Return the smallest item, or throw assert if empty. */
+	FORCEINLINE Titem_& GetHead() {assert(!IsEmpty()); return *m_items[1];}
+
+	/** Insert new item into the priority queue, maintaining heap order.
+	 *  @return false if the queue is full. */
+	bool Push(Titem_& new_item);
+
+	/** Remove and return the smallest item from the priority queue. */
+	FORCEINLINE Titem_& PopHead() {Titem_& ret = GetHead(); RemoveHead(); return ret;};
+
+	/** Remove the smallest item from the priority queue. */
+	void RemoveHead();
+
+	/** Remove item specified by index */
+	void RemoveByIdx(int idx);
+
+	/** return index of the item that matches (using &item1 == &item2) the given item. */
+	int FindLinear(const Titem_& item) const;
+
+	/** Make the priority queue empty.
+	 * All remaining items will remain untouched. */
+	void Clear() {m_size = 0;};
+
+	/** verifies the heap consistency (added during first YAPF debug phase) */
+	void CheckConsistency();
+};
+
+
+template <class Titem_>
+FORCEINLINE bool CBinaryHeapT<Titem_>::Push(Titem_& new_item)
+{
+	if (IsFull()) return false;
+
+	// make place for new item
+	int gap = ++m_size;
+	// Heapify up
+	for (int parent = gap / 2; (parent > 0) && (new_item < *m_items[parent]); gap = parent, parent /= 2)
+		m_items[gap] = m_items[parent];
+	m_items[gap] = &new_item;
+	CheckConsistency();
+	return true;
+}
+
+template <class Titem_>
+FORCEINLINE void CBinaryHeapT<Titem_>::RemoveHead()
+{
+	assert(!IsEmpty());
+
+	// at index 1 we have a gap now
+	int gap = 1;
+
+	// Heapify down:
+	//   last item becomes a candidate for the head. Call it new_item.
+	Titem_& new_item = *m_items[m_size--];
+
+	// now we must maintain relation between parent and its children:
+	//   parent <= any child
+	// from head down to the tail
+	int child  = 2; // first child is at [parent * 2]
+
+	// while children are valid
+	while (child <= m_size) {
+		// choose the smaller child
+		if (child < m_size && *m_items[child + 1] < *m_items[child])
+			child++;
+		// is it smaller than our parent?
+		if (!(*m_items[child] < new_item)) {
+			// the smaller child is still bigger or same as parent => we are done
+			break;
+		}
+		// if smaller child is smaller than parent, it will become new parent
+		m_items[gap] = m_items[child];
+		gap = child;
+		// where do we have our new children?
+		child = gap * 2;
+	}
+	// move last item to the proper place
+	if (m_size > 0) m_items[gap] = &new_item;
+	CheckConsistency();
+}
+
+template <class Titem_>
+inline void CBinaryHeapT<Titem_>::RemoveByIdx(int idx)
+{
+	// at position idx we have a gap now
+	int gap = idx;
+	Titem_& last = *m_items[m_size];
+	if (idx < m_size) {
+		assert(idx >= 1);
+		m_size--;
+		// and the candidate item for fixing this gap is our last item 'last'
+		// Move gap / last item up:
+		while (gap > 1)
+		{
+			// compare [gap] with its parent
+			int parent = gap / 2;
+			if (last < *m_items[parent]) {
+				m_items[gap] = m_items[parent];
+				gap = parent;
+			} else {
+				// we don't need to continue upstairs
+				break;
+			}
+		}
+
+		// Heapify (move gap) down:
+		while (true) {
+			// where we do have our children?
+			int child  = gap * 2; // first child is at [parent * 2]
+			if (child > m_size) break;
+			// choose the smaller child
+			if (child < m_size && *m_items[child + 1] < *m_items[child])
+				child++;
+			// is it smaller than our parent?
+			if (!(*m_items[child] < last)) {
+				// the smaller child is still bigger or same as parent => we are done
+				break;
+			}
+			// if smaller child is smaller than parent, it will become new parent
+			m_items[gap] = m_items[child];
+			gap = child;
+		}
+		// move parent to the proper place
+		if (m_size > 0) m_items[gap] = &last;
+	}
+	else {
+		assert(idx == m_size);
+		m_size--;
+	}
+	CheckConsistency();
+}
+
+template <class Titem_>
+inline int CBinaryHeapT<Titem_>::FindLinear(const Titem_& item) const
+{
+	if (IsEmpty()) return 0;
+	for (ItemPtr *ppI = m_items + 1, *ppLast = ppI + m_size; ppI <= ppLast; ppI++) {
+		if (*ppI == &item) {
+			return ppI - m_items;
+		}
+	}
+	return 0;
+}
+
+template <class Titem_>
+FORCEINLINE void CBinaryHeapT<Titem_>::CheckConsistency()
+{
+	// enable it if you suspect binary heap doesn't work well
+#if 0
+	for (int child = 2; child <= m_size; child++) {
+		int parent = child / 2;
+		assert(!(m_items[child] < m_items[parent]));
+	}
+#endif
+}
+
+
+#endif /* BINARYHEAP_HPP */
diff --git a/src/misc/blob.hpp b/src/misc/blob.hpp
new file mode 100644
index 000000000..1a20f3ac2
--- /dev/null
+++ b/src/misc/blob.hpp
@@ -0,0 +1,342 @@
+/* $Id$ */
+
+#ifndef  BLOB_HPP
+#define  BLOB_HPP
+
+/** Type-safe version of memcpy().
+ * @param d destination buffer
+ * @param s source buffer
+ * @param num_items number of items to be copied (!not number of bytes!) */
+template <class Titem_>
+FORCEINLINE void MemCpyT(Titem_* d, const Titem_* s, int num_items = 1)
+{
+	memcpy(d, s, num_items * sizeof(Titem_));
+}
+
+
+/** Base class for simple binary blobs.
+ *  Item is byte.
+ *  The word 'simple' means:
+ *    - no configurable allocator type (always made from heap)
+ *    - no smart deallocation - deallocation must be called from the same
+ *        module (DLL) where the blob was allocated
+ *    - no configurable allocation policy (how big blocks should be allocated)
+ *    - no extra ownership policy (i.e. 'copy on write') when blob is copied
+ *    - no thread synchronization at all
+ *
+ *  Internal member layout:
+ *  1. The only class member is pointer to the first item (see union ptr_u).
+ *  2. Allocated block contains the blob header (see CHdr) followed by the raw byte data.
+ *     Always, when it allocates memory the allocated size is:
+ *                                                      sizeof(CHdr) + <data capacity>
+ *  3. Two 'virtual' members (m_size and m_max_size) are stored in the CHdr at beginning
+ *     of the alloated block.
+ *  4. The pointer (in ptr_u) points behind the header (to the first data byte).
+ *     When memory block is allocated, the sizeof(CHdr) it added to it.
+ *  5. Benefits of this layout:
+ *     - items are accessed in the simplest possible way - just dereferencing the pointer,
+ *       which is good for performance (assuming that data are accessed most often).
+ *     - sizeof(blob) is the same as the size of any other pointer
+ *  6. Drawbacks of this layout:
+ *     - the fact, that pointer to the alocated block is adjusted by sizeof(CHdr) before
+ *       it is stored can lead to several confusions:
+ *         - it is not common pattern so the implementation code is bit harder to read
+ *         - valgrind can generate warning that allocated block is lost (not accessible)
+ * */
+class CBlobBaseSimple {
+protected:
+	/** header of the allocated memory block */
+	struct CHdr {
+		int    m_size;      ///< actual blob size in bytes
+		int    m_max_size;  ///< maximum (allocated) size in bytes
+	};
+
+	/** type used as class member */
+	union {
+		int8   *m_pData;    ///< pointer to the first byte of data
+		CHdr   *m_pHdr_1;   ///< pointer just after the CHdr holding m_size and m_max_size
+	} ptr_u;
+
+public:
+	static const int Ttail_reserve = 4; ///< four extra bytes will be always allocated and zeroed at the end
+
+	/** default constructor - initializes empty blob */
+	FORCEINLINE CBlobBaseSimple() { InitEmpty(); }
+	/** copy constructor */
+	FORCEINLINE CBlobBaseSimple(const CBlobBaseSimple& src)
+	{
+		InitEmpty();
+		AppendRaw(src);
+	}
+	/** destructor */
+	FORCEINLINE ~CBlobBaseSimple() { Free(); }
+protected:
+	/** initialize the empty blob by setting the ptr_u.m_pHdr_1 pointer to the static CHdr with
+	 *  both m_size and m_max_size containing zero */
+	FORCEINLINE void InitEmpty() { static CHdr hdrEmpty[] = {{0, 0}, {0, 0}}; ptr_u.m_pHdr_1 = &hdrEmpty[1]; }
+	/** initialize blob by attaching it to the given header followed by data */
+	FORCEINLINE void Init(CHdr* hdr) { ptr_u.m_pHdr_1 = &hdr[1]; }
+	/** blob header accessor - use it rather than using the pointer arithmetics directly - non-const version */
+	FORCEINLINE CHdr& Hdr() { return ptr_u.m_pHdr_1[-1]; }
+	/** blob header accessor - use it rather than using the pointer arithmetics directly - const version */
+	FORCEINLINE const CHdr& Hdr() const { return ptr_u.m_pHdr_1[-1]; }
+	/** return reference to the actual blob size - used when the size needs to be modified */
+	FORCEINLINE int& RawSizeRef() { return Hdr().m_size; };
+
+public:
+	/** return true if blob doesn't contain valid data */
+	FORCEINLINE bool IsEmpty() const { return RawSize() == 0; }
+	/** return the number of valid data bytes in the blob */
+	FORCEINLINE int RawSize() const { return Hdr().m_size; };
+	/** return the current blob capacity in bytes */
+	FORCEINLINE int MaxRawSize() const { return Hdr().m_max_size; };
+	/** return pointer to the first byte of data - non-const version */
+	FORCEINLINE int8* RawData() { return ptr_u.m_pData; }
+	/** return pointer to the first byte of data - const version */
+	FORCEINLINE const int8* RawData() const { return ptr_u.m_pData; }
+#if 0 // reenable when needed
+	/** return the 32 bit CRC of valid data in the blob */
+	FORCEINLINE uint32 Crc32() const {return CCrc32::Calc(RawData(), RawSize());}
+#endif //0
+	/** invalidate blob's data - doesn't free buffer */
+	FORCEINLINE void Clear() { RawSizeRef() = 0; }
+	/** free the blob's memory */
+	FORCEINLINE void Free() { if (MaxRawSize() > 0) {RawFree(&Hdr()); InitEmpty();} }
+	/** copy data from another blob - replaces any existing blob's data */
+	FORCEINLINE void CopyFrom(const CBlobBaseSimple& src) { Clear(); AppendRaw(src); }
+	/** overtake ownership of data buffer from the source blob - source blob will become empty */
+	FORCEINLINE void MoveFrom(CBlobBaseSimple& src) { Free(); ptr_u.m_pData = src.ptr_u.m_pData; src.InitEmpty(); }
+	/** swap buffers (with data) between two blobs (this and source blob) */
+	FORCEINLINE void Swap(CBlobBaseSimple& src) { int8 *tmp = ptr_u.m_pData; ptr_u.m_pData = src.ptr_u.m_pData; src.ptr_u.m_pData = tmp; }
+
+	/** append new bytes at the end of existing data bytes - reallocates if necessary */
+	FORCEINLINE void AppendRaw(int8 *p, int num_bytes)
+	{
+		assert(p != NULL);
+		if (num_bytes > 0) {
+			memcpy(GrowRawSize(num_bytes), p, num_bytes);
+		} else {
+			assert(num_bytes >= 0);
+		}
+	}
+
+	/** append bytes from given source blob to the end of existing data bytes - reallocates if necessary */
+	FORCEINLINE void AppendRaw(const CBlobBaseSimple& src)
+	{
+		if (!src.IsEmpty())
+			memcpy(GrowRawSize(src.RawSize()), src.RawData(), src.RawSize());
+	}
+
+	/** Reallocate if there is no free space for num_bytes bytes.
+	 *  @return pointer to the new data to be added */
+	FORCEINLINE int8* MakeRawFreeSpace(int num_bytes)
+	{
+		assert(num_bytes >= 0);
+		int new_size = RawSize() + num_bytes;
+		if (new_size > MaxRawSize()) SmartAlloc(new_size);
+		FixTail();
+		return ptr_u.m_pData + RawSize();
+	}
+
+	/** Increase RawSize() by num_bytes.
+	 *  @return pointer to the new data added */
+	FORCEINLINE int8* GrowRawSize(int num_bytes)
+	{
+		int8* pNewData = MakeRawFreeSpace(num_bytes);
+		RawSizeRef() += num_bytes;
+		return pNewData;
+	}
+
+	/** Decrease RawSize() by num_bytes. */
+	FORCEINLINE void ReduceRawSize(int num_bytes)
+	{
+		if (MaxRawSize() > 0 && num_bytes > 0) {
+			assert(num_bytes <= RawSize());
+			if (num_bytes < RawSize()) RawSizeRef() -= num_bytes;
+			else RawSizeRef() = 0;
+		}
+	}
+	/** reallocate blob data if needed */
+	void SmartAlloc(int new_size)
+	{
+		int old_max_size = MaxRawSize();
+		if (old_max_size >= new_size) return;
+		// calculate minimum block size we need to allocate
+		int min_alloc_size = sizeof(CHdr) + new_size + Ttail_reserve;
+		// ask allocation policy for some reasonable block size
+		int alloc_size = AllocPolicy(min_alloc_size);
+		// allocate new block
+		CHdr* pNewHdr = RawAlloc(alloc_size);
+		// setup header
+		pNewHdr->m_size = RawSize();
+		pNewHdr->m_max_size = alloc_size - (sizeof(CHdr) + Ttail_reserve);
+		// copy existing data
+		if (RawSize() > 0)
+			memcpy(pNewHdr + 1, ptr_u.m_pData, pNewHdr->m_size);
+		// replace our block with new one
+		CHdr* pOldHdr = &Hdr();
+		Init(pNewHdr);
+		if (old_max_size > 0)
+			RawFree(pOldHdr);
+	}
+	/** simple allocation policy - can be optimized later */
+	FORCEINLINE static int AllocPolicy(int min_alloc)
+	{
+		if (min_alloc < (1 << 9)) {
+			if (min_alloc < (1 << 5)) return (1 << 5);
+			return (min_alloc < (1 << 7)) ? (1 << 7) : (1 << 9);
+		}
+		if (min_alloc < (1 << 15)) {
+			if (min_alloc < (1 << 11)) return (1 << 11);
+			return (min_alloc < (1 << 13)) ? (1 << 13) : (1 << 15);
+		}
+		if (min_alloc < (1 << 20)) {
+			if (min_alloc < (1 << 17)) return (1 << 17);
+			return (min_alloc < (1 << 19)) ? (1 << 19) : (1 << 20);
+		}
+		min_alloc = (min_alloc | ((1 << 20) - 1)) + 1;
+		return min_alloc;
+	}
+
+	/** all allocation should happen here */
+	static FORCEINLINE CHdr* RawAlloc(int num_bytes) { return (CHdr*)malloc(num_bytes); }
+	/** all deallocations should happen here */
+	static FORCEINLINE void RawFree(CHdr* p) { free(p); }
+	/** fixing the four bytes at the end of blob data - useful when blob is used to hold string */
+	FORCEINLINE void FixTail()
+	{
+		if (MaxRawSize() > 0) {
+			int8 *p = &ptr_u.m_pData[RawSize()];
+			for (int i = 0; i < Ttail_reserve; i++) p[i] = 0;
+		}
+	}
+};
+
+/** Blob - simple dynamic Titem_ array. Titem_ (template argument) is a placeholder for any type.
+ *  Titem_ can be any integral type, pointer, or structure. Using Blob instead of just plain C array
+ *  simplifies the resource management in several ways:
+ *  1. When adding new item(s) it automatically grows capacity if needed.
+ *  2. When variable of type Blob comes out of scope it automatically frees the data buffer.
+ *  3. Takes care about the actual data size (number of used items).
+ *  4. Dynamically constructs only used items (as opposite of static array which constructs all items) */
+template <class Titem_, class Tbase_ = CBlobBaseSimple>
+class CBlobT : public CBlobBaseSimple {
+	// make template arguments public:
+public:
+	typedef Titem_ Titem;
+	typedef Tbase_ Tbase;
+
+	static const int Titem_size = sizeof(Titem);
+
+	/** Default constructor - makes new Blob ready to accept any data */
+	FORCEINLINE CBlobT() : Tbase() {}
+	/** Copy constructor - make new blob to become copy of the original (source) blob */
+	FORCEINLINE CBlobT(const Tbase& src) : Tbase(src) {assert((RawSize() % Titem_size) == 0);}
+	/** Destructor - ensures that allocated memory (if any) is freed */
+	FORCEINLINE ~CBlobT() { Free(); }
+	/** Check the validity of item index (only in debug mode) */
+	FORCEINLINE void CheckIdx(int idx) { assert(idx >= 0); assert(idx < Size()); }
+	/** Return pointer to the first data item - non-const version */
+	FORCEINLINE Titem* Data() { return (Titem*)RawData(); }
+	/** Return pointer to the first data item - const version */
+	FORCEINLINE const Titem* Data() const { return (const Titem*)RawData(); }
+	/** Return pointer to the idx-th data item - non-const version */
+	FORCEINLINE Titem* Data(int idx) { CheckIdx(idx); return (Data() + idx); }
+	/** Return pointer to the idx-th data item - const version */
+	FORCEINLINE const Titem* Data(int idx) const { CheckIdx(idx); return (Data() + idx); }
+	/** Return number of items in the Blob */
+	FORCEINLINE int Size() const { return (RawSize() / Titem_size); }
+	/** Free the memory occupied by Blob destroying all items */
+	FORCEINLINE void Free()
+	{
+		assert((RawSize() % Titem_size) == 0);
+		int old_size = Size();
+		if (old_size > 0) {
+			// destroy removed items;
+			Titem* pI_last_to_destroy = Data(0);
+			for (Titem* pI = Data(old_size - 1); pI >= pI_last_to_destroy; pI--) pI->~Titem_();
+		}
+		Tbase::Free();
+	}
+	/** Grow number of data items in Blob by given number - doesn't construct items */
+	FORCEINLINE Titem* GrowSizeNC(int num_items) { return (Titem*)GrowRawSize(num_items * Titem_size); }
+	/** Grow number of data items in Blob by given number - constructs new items (using Titem_'s default constructor) */
+	FORCEINLINE Titem* GrowSizeC(int num_items)
+	{
+		Titem* pI = GrowSizeNC(num_items);
+		for (int i = num_items; i > 0; i--, pI++) new (pI) Titem();
+	}
+	/** Destroy given number of items and reduce the Blob's data size */
+	FORCEINLINE void ReduceSize(int num_items)
+	{
+		assert((RawSize() % Titem_size) == 0);
+		int old_size = Size();
+		assert(num_items <= old_size);
+		int new_size = (num_items <= old_size) ? (old_size - num_items) : 0;
+		// destroy removed items;
+		Titem* pI_last_to_destroy = Data(new_size);
+		for (Titem* pI = Data(old_size - 1); pI >= pI_last_to_destroy; pI--) pI->~Titem();
+		// remove them
+		ReduceRawSize(num_items * Titem_size);
+	}
+	/** Append one data item at the end (calls Titem_'s default constructor) */
+	FORCEINLINE Titem* AppendNew()
+	{
+		Titem& dst = *GrowSizeNC(1); // Grow size by one item
+		Titem* pNewItem = new (&dst) Titem(); // construct the new item by calling in-place new operator
+		return pNewItem;
+	}
+	/** Append the copy of given item at the end of Blob (using copy constructor) */
+	FORCEINLINE Titem* Append(const Titem& src)
+	{
+		Titem& dst = *GrowSizeNC(1); // Grow size by one item
+		Titem* pNewItem = new (&dst) Titem(src); // construct the new item by calling in-place new operator with copy ctor()
+		return pNewItem;
+	}
+	/** Add given items (ptr + number of items) at the end of blob */
+	FORCEINLINE Titem* Append(const Titem* pSrc, int num_items)
+	{
+		Titem* pDst = GrowSizeNC(num_items);
+		Titem* pDstOrg = pDst;
+		Titem* pDstEnd = pDst + num_items;
+		while (pDst < pDstEnd) new (pDst++) Titem(*(pSrc++));
+		return pDstOrg;
+	}
+	/** Remove item with the given index by replacing it by the last item and reducing the size by one */
+	FORCEINLINE void RemoveBySwap(int idx)
+	{
+		CheckIdx(idx);
+		// destroy removed item
+		Titem* pRemoved = Data(idx);
+		RemoveBySwap(pRemoved);
+	}
+	/** Remove item given by pointer replacing it by the last item and reducing the size by one */
+	FORCEINLINE void RemoveBySwap(Titem* pItem)
+	{
+		Titem* pLast = Data(Size() - 1);
+		assert(pItem >= Data() && pItem <= pLast);
+		// move last item to its new place
+		if (pItem != pLast) {
+			pItem->~Titem_();
+			new (pItem) Titem_(*pLast);
+		}
+		// destroy the last item
+		pLast->~Titem_();
+		// and reduce the raw blob size
+		ReduceRawSize(Titem_size);
+	}
+	/** Ensures that given number of items can be added to the end of Blob. Returns pointer to the
+	 *  first free (unused) item */
+	FORCEINLINE Titem* MakeFreeSpace(int num_items) { return (Titem*)MakeRawFreeSpace(num_items * Titem_size); }
+};
+
+// simple string implementation
+struct CStrA : public CBlobT<char>
+{
+	typedef CBlobT<char> base;
+	CStrA(const char* str = NULL) {Append(str);}
+	FORCEINLINE CStrA(const CBlobBaseSimple& src) : base(src) {}
+	void Append(const char* str) {if (str != NULL && str[0] != '\0') base::Append(str, (int)strlen(str));}
+};
+
+#endif /* BLOB_HPP */
diff --git a/src/misc/countedptr.hpp b/src/misc/countedptr.hpp
new file mode 100644
index 000000000..e63e47fb5
--- /dev/null
+++ b/src/misc/countedptr.hpp
@@ -0,0 +1,100 @@
+/* $Id$ */
+
+#ifndef COUNTEDPTR_HPP
+#define COUNTEDPTR_HPP
+
+#if 0 // reenable when needed
+/** @file CCountedPtr - smart pointer implementation */
+
+/** CCountedPtr - simple reference counting smart pointer.
+ *
+ *     One of the standard ways how to maintain object's lifetime.
+ *
+ *     See http://ootips.org/yonat/4dev/smart-pointers.html for more
+ *   general info about smart pointers.
+ *
+ *     This class implements ref-counted pointer for objects/interfaces that
+ *   support AddRef() and Release() methods.
+ */
+template <class Tcls_>
+class CCountedPtr {
+	/** redefine the template argument to make it visible for derived classes */
+public:
+	typedef Tcls_ Tcls;
+
+protected:
+	/** here we hold our pointer to the target */
+	Tcls* m_pT;
+
+public:
+	/** default (NULL) construct or construct from a raw pointer */
+	FORCEINLINE 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();};
+
+	/** destructor releasing the reference */
+	FORCEINLINE ~CCountedPtr() {Release();};
+
+protected:
+	/** add one ref to the underlaying object */
+	FORCEINLINE 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) {m_pT->Release(); m_pT = NULL;}}
+
+	/** dereference of smart pointer - const way */
+	FORCEINLINE 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;};
+
+	/** raw pointer casting operator - const way */
+	FORCEINLINE operator const Tcls*() const {assert(m_pT == NULL); return m_pT;}
+
+	/** raw pointer casting operator - non-const way */
+	FORCEINLINE operator Tcls*() {assert(m_pT == NULL); return m_pT;}
+
+	/** operator & to support output arguments */
+	FORCEINLINE Tcls** operator &() {assert(m_pT == NULL); return &m_pT;}
+
+	/** assignment operator from raw ptr */
+	FORCEINLINE CCountedPtr& operator = (Tcls* pT) {Assign(pT); return *this;}
+
+	/** assignment operator from another smart ptr */
+	FORCEINLINE CCountedPtr& operator = (CCountedPtr& src) {Assign(src.m_pT); return *this;}
+
+	/** assignment operator helper */
+	FORCEINLINE void Assign(Tcls* pT);
+
+	/** one way how to test for NULL value */
+	FORCEINLINE 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;}
+
+	/** yet another way how to test for NULL value */
+	FORCEINLINE 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;}
+
+	/** detach pointer w/o decrementing ref count */
+	FORCEINLINE Tcls* Detach() {Tcls* pT = m_pT; m_pT = NULL; return pT;}
+};
+
+template <class Tcls_>
+FORCEINLINE void CCountedPtr<Tcls_>::Assign(Tcls* pT)
+{
+	// if they are the same, we do nothing
+	if (pT != m_pT) {
+		if (pT) pT->AddRef();        // AddRef new pointer if any
+		Tcls* pTold = m_pT;          // save original ptr
+		m_pT = pT;                   // update m_pT to new value
+		if (pTold) pTold->Release(); // release old ptr if any
+	}
+}
+
+#endif /* 0 */
+#endif /* COUNTEDPTR_HPP */
diff --git a/src/misc/crc32.hpp b/src/misc/crc32.hpp
new file mode 100644
index 000000000..10e9a7ac4
--- /dev/null
+++ b/src/misc/crc32.hpp
@@ -0,0 +1,65 @@
+/* $Id$ */
+
+#ifndef  CRC32_HPP
+#define  CRC32_HPP
+
+#if 0 // reenable when needed
+struct CCrc32
+{
+	static uint32 Calc(const void *pBuffer, int nCount)
+	{
+		uint32 crc = 0xffffffff;
+		const uint32* pTable = CrcTable();
+
+		uint8* begin = (uint8*)pBuffer;
+		uint8* end = begin + nCount;
+		for(uint8* cur = begin; cur < end; cur++)
+			crc = (crc >> 8) ^ pTable[cur[0] ^ (uint8)(crc & 0xff)];
+		crc ^= 0xffffffff;
+
+		return crc;
+	}
+
+	static const uint32* CrcTable()
+	{
+		static const uint32 Table[256] =
+		{
+			0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
+			0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
+			0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
+			0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
+			0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
+			0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
+			0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
+			0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
+			0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
+			0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
+			0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
+			0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
+			0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
+			0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
+			0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+			0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
+			0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
+			0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
+			0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
+			0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
+			0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
+			0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
+			0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
+			0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
+			0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
+			0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
+			0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
+			0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
+			0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
+			0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+			0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
+			0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+		};
+		return Table;
+	}
+};
+#endif // 0
+
+#endif /* CRC32_HPP */
diff --git a/src/misc/fixedsizearray.hpp b/src/misc/fixedsizearray.hpp
new file mode 100644
index 000000000..48b177f3c
--- /dev/null
+++ b/src/misc/fixedsizearray.hpp
@@ -0,0 +1,99 @@
+/* $Id$ */
+
+#ifndef  FIXEDSIZEARRAY_HPP
+#define  FIXEDSIZEARRAY_HPP
+
+
+/** fixed size array
+ *  Upon construction it preallocates fixed size block of memory
+ *  for all items, but doesn't construct them. Item's construction
+ *  is delayed. */
+template <class Titem_, int Tcapacity_>
+struct CFixedSizeArrayT {
+	/** 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;
+
+	/** header for fixed size array */
+	struct CHdr
+	{
+		int    m_num_items; ///< number of items in the array
+		int    m_ref_cnt;   ///< block reference counter (used by copy constructor and by destructor)
+	};
+
+	// make types and constants visible from outside
+	typedef Titem_ 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
+
+	/** Default constructor. Preallocate space for items and header, then initialize header. */
+	CFixedSizeArrayT()
+	{
+		// allocate block for header + items (don't construct items)
+		m_items = (Titem*)(((int8*)malloc(ThdrSize + Tcapacity * sizeof(Titem))) + ThdrSize);
+		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<Titem_, Tcapacity_>& src)
+	{
+		// share block (header + items) with the source array
+		m_items = src.m_items;
+		RefCnt()++; // now we share block with the source
+	}
+
+	/** destroy remaining items and free the memory block */
+	~CFixedSizeArrayT()
+	{
+		// 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;
+	}
+
+	/** 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_();
+		}
+		// number of items become zero
+		SizeRef() = 0;
+	}
+
+protected:
+	/** return reference to the array header (non-const) */
+	FORCEINLINE CHdr& Hdr() { return *(CHdr*)(((int8*)m_items) - ThdrSize); }
+	/** return reference to the array header (const) */
+	FORCEINLINE const CHdr& Hdr() const { return *(CHdr*)(((int8*)m_items) - ThdrSize); }
+	/** return reference to the block reference counter */
+	FORCEINLINE int& RefCnt() { return Hdr().m_ref_cnt; }
+	/** return reference to number of used items */
+	FORCEINLINE int& SizeRef() { return Hdr().m_num_items; }
+public:
+	/** return number of used items */
+	FORCEINLINE int Size() const { return Hdr().m_num_items; }
+	/** return true if array is full */
+	FORCEINLINE bool IsFull() const { return Size() >= Tcapacity; };
+	/** return true if array is empty */
+	FORCEINLINE bool IsEmpty() const { return Size() <= 0; };
+	/** index validation */
+	FORCEINLINE void CheckIdx(int idx) const { assert(idx >= 0); assert(idx < Size()); }
+	/** add (allocate), but don't construct item */
+	FORCEINLINE Titem& AddNC() { assert(!IsFull()); return m_items[SizeRef()++]; }
+	/** add and construct item using default constructor */
+	FORCEINLINE Titem& Add() { Titem& item = AddNC(); new(&item)Titem; return item; }
+	/** return item by index (non-const version) */
+	FORCEINLINE Titem& operator [] (int idx) { CheckIdx(idx); return m_items[idx]; }
+	/** return item by index (const version) */
+	FORCEINLINE const Titem& operator [] (int idx) const { CheckIdx(idx); return m_items[idx]; }
+};
+
+#endif /* FIXEDSIZEARRAY_HPP */
diff --git a/src/misc/hashtable.hpp b/src/misc/hashtable.hpp
new file mode 100644
index 000000000..c6b52e50a
--- /dev/null
+++ b/src/misc/hashtable.hpp
@@ -0,0 +1,240 @@
+/* $Id$ */
+
+#ifndef  HASHTABLE_HPP
+#define  HASHTABLE_HPP
+
+template <class Titem_>
+struct CHashTableSlotT
+{
+	typedef typename Titem_::Key Key;          // make Titem_::Key a property of HashTable
+
+	Titem_*    m_pFirst;
+
+	CHashTableSlotT() : m_pFirst(NULL) {}
+
+	/** hash table slot helper - clears the slot by simple forgetting its items */
+	FORCEINLINE 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
+	{
+		for (const Titem_* pItem = m_pFirst; pItem != NULL; pItem = pItem->GetHashNext()) {
+			if (pItem->GetKey() == key) {
+				// we have found the item, return it
+				return pItem;
+			}
+		}
+		return NULL;
+	}
+
+	/** hash table slot helper - linear search for item with given key through the given blob - non-const version */
+	FORCEINLINE Titem_* Find(const Key& key)
+	{
+		for (Titem_* pItem = m_pFirst; pItem != NULL; pItem = pItem->GetHashNext()) {
+			if (pItem->GetKey() == key) {
+				// we have found the item, return it
+				return pItem;
+			}
+		}
+		return NULL;
+	}
+
+	/** hash table slot helper - add new item to the slot */
+	FORCEINLINE void Attach(Titem_& new_item)
+	{
+		assert(new_item.GetHashNext() == NULL);
+		new_item.SetHashNext(m_pFirst);
+		m_pFirst = &new_item;
+	}
+
+	/** hash table slot helper - remove item from a slot */
+	FORCEINLINE bool Detach(Titem_& item_to_remove)
+	{
+		if (m_pFirst == &item_to_remove) {
+			m_pFirst = item_to_remove.GetHashNext();
+			item_to_remove.SetHashNext(NULL);
+			return true;
+		}
+		Titem_* pItem = m_pFirst;
+		while (true) {
+			if (pItem == NULL) {
+				return false;
+			}
+			Titem_* pNextItem = pItem->GetHashNext();
+			if (pNextItem == &item_to_remove) break;
+			pItem = pNextItem;
+		}
+		pItem->SetHashNext(item_to_remove.GetHashNext());
+		item_to_remove.SetHashNext(NULL);
+		return true;
+	}
+
+	/** hash table slot helper - remove and return item from a slot */
+	FORCEINLINE Titem_* Detach(const Key& key)
+	{
+		// do we have any items?
+		if (m_pFirst == NULL) {
+			return NULL;
+		}
+		// is it our first item?
+		if (m_pFirst->GetKey() == key) {
+			Titem_& ret_item = *m_pFirst;
+			m_pFirst = m_pFirst->GetHashNext();
+			ret_item.SetHashNext(NULL);
+			return &ret_item;
+		}
+		// find it in the following items
+		Titem_* pPrev = m_pFirst;
+		for (Titem_* pItem = m_pFirst->GetHashNext(); pItem != NULL; pPrev = pItem, pItem = pItem->GetHashNext()) {
+			if (pItem->GetKey() == key) {
+				// we have found the item, unlink and return it
+				pPrev->SetHashNext(pItem->GetHashNext());
+				pItem->SetHashNext(NULL);
+				return pItem;
+			}
+		}
+		return NULL;
+	}
+};
+
+/** @class CHashTableT<Titem, Thash_bits> - simple hash table
+ *  of pointers allocated elsewhere.
+ *
+ *  Supports: Add/Find/Remove of Titems.
+ *
+ *  Your Titem must meet some extra requirements to be CHashTableT
+ *  compliant:
+ *    - its constructor/destructor (if any) must be public
+ *    - if the copying of item requires an extra resource management,
+ *        you must define also copy constructor
+ *    - must support nested type (struct, class or typedef) Titem::Key
+ *        that defines the type of key class for that item
+ *    - must support public method:
+ *        const Key& GetKey() const; // return the item's key object
+ *
+ *  In addition, the Titem::Key class must support:
+ *    - 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;
+ */
+template <class Titem_, int Thash_bits_>
+class CHashTableT {
+public:
+	typedef Titem_ Titem;                         // make Titem_ visible from outside of class
+	typedef typename Titem_::Key Tkey;            // make Titem_::Key a property of HashTable
+	static const int Thash_bits = Thash_bits_;    // publish num of hash bits
+	static const int Tcapacity = 1 << Thash_bits; // and num of slots 2^bits
+
+protected:
+	/** each slot contains pointer to the first item in the list,
+	 *  Titem contains pointer to the next item - GetHashNext(), SetHashNext() */
+	typedef CHashTableSlotT<Titem_> Slot;
+
+	Slot*  m_slots;     // here we store our data (array of blobs)
+	int    m_num_items; // item counter
+
+public:
+	// default constructor
+	FORCEINLINE CHashTableT()
+	{
+		// construct all slots
+		m_slots = new Slot[Tcapacity];
+		m_num_items = 0;
+	}
+
+	~CHashTableT() {delete [] m_slots; m_num_items = 0; m_slots = NULL;}
+
+protected:
+	/** static helper - return hash for the given key modulo number of slots */
+	FORCEINLINE static int CalcHash(const Tkey& key)
+	{
+		int32 hash = key.CalcHash();
+		if ((8 * Thash_bits) < 32) hash ^= hash >> (min(8 * Thash_bits, 31));
+		if ((4 * Thash_bits) < 32) hash ^= hash >> (min(4 * Thash_bits, 31));
+		if ((2 * Thash_bits) < 32) hash ^= hash >> (min(2 * Thash_bits, 31));
+		if ((1 * Thash_bits) < 32) hash ^= hash >> (min(1 * Thash_bits, 31));
+		hash &= (1 << Thash_bits) - 1;
+		return hash;
+	}
+
+	/** static helper - return hash for the given item modulo number of slots */
+	FORCEINLINE static int CalcHash(const Titem_& item) {return CalcHash(item.GetKey());}
+
+public:
+	/** item count */
+	FORCEINLINE int Count() const {return m_num_items;}
+
+	/** simple clear - forget all items - used by CSegmentCostCacheT.Flush() */
+	FORCEINLINE void Clear() const {for (int i = 0; i < Tcapacity; i++) m_slots[i].Clear();}
+
+	/** const item search */
+	const Titem_* Find(const Tkey& key) const
+	{
+		int hash = CalcHash(key);
+		const Slot& slot = m_slots[hash];
+		const Titem_* item = slot.Find(key);
+		return item;
+	}
+
+	/** non-const item search */
+	Titem_* Find(const Tkey& key)
+	{
+		int hash = CalcHash(key);
+		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)
+	{
+		int hash = CalcHash(key);
+		Slot& slot = m_slots[hash];
+		Titem_* item = slot.Detach(key);
+		if (item != NULL) {
+			m_num_items--;
+		}
+		return item;
+	}
+
+	/** non-const item search & removal */
+	Titem_& Pop(const Tkey& key)
+	{
+		Titem_* item = TryPop(key);
+		assert(item != NULL);
+		return *item;
+	}
+
+	/** non-const item search & optional removal (if found) */
+	bool TryPop(Titem_& item)
+	{
+		const Tkey& key = item.GetKey();
+		int hash = CalcHash(key);
+		Slot& slot = m_slots[hash];
+		bool ret = slot.Detach(item);
+		if (ret) {
+			m_num_items--;
+		}
+		return ret;
+	}
+
+	/** non-const item search & removal */
+	void Pop(Titem_& item)
+	{
+		bool ret = TryPop(item);
+		assert(ret);
+	}
+
+	/** add one item - copy it from the given item */
+	void Push(Titem_& new_item)
+	{
+		int hash = CalcHash(new_item);
+		Slot& slot = m_slots[hash];
+		assert(slot.Find(new_item.GetKey()) == NULL);
+		slot.Attach(new_item);
+		m_num_items++;
+	}
+};
+
+#endif /* HASHTABLE_HPP */