cptrarray.hpp

bt848,bt878 a采集卡的探测

/*
 * An array of pointers
 */

#ifndef _CPTRARRAY_HPP
#define _CPTRARRAY_HPP

#include "CMemory.hpp"

// Be careful, there's no copy on write, so all users will see mods!
template<class T,bool DeleteOnKill> class CPtrArray {
protected:

	CMemory blk;	// memory block that holds array
	
public:

	CPtrArray() {}
	CPtrArray(CPtrArray& ary) : blk(ary) {}
	CPtrArray& operator=(CPtrArray& ary) { blk=ary; return *this; }

	// Add an object to the end 
	bool Add(T* Obj);
	// Insert an object before
	bool Insert(T* Obj,const UINT Idx);
	// Delete the given object (by index)
	bool Delete(const UINT Idx);
	// Delete the given object (by object)
	bool Delete(T* Obj);
	// To replace a given object
	bool Replace(T* Obj,const UINT Idx);
	// To get count of elements
	UINT Count() const {return blk.Size() / sizeof(T*); }
	// To access the Idx element 
	T* operator[](const UINT El) const { return ((T**)blk.Ptr())[El]; }
	// To empty the array
	bool Flush();
	// Destructor
	~CPtrArray();

};

template<class T,bool DeleteOnKill> bool CPtrArray<T,DeleteOnKill>::Add(T* Obj)
{
	// Resize array
	UINT Elems = Count();
	if (!blk.ReSize( (Elems + 1) * sizeof(T*) )) { return false; }
	// Add our element
	((T**)blk.Ptr()) [Elems] = Obj;
	return true;
}

template<class T,bool DeleteOnKill> bool CPtrArray<T,DeleteOnKill>::Insert(T* Obj,const UINT Idx)
{
	UINT Elems = Count();
	if (Idx > Elems) return false;
	// Resize array
	if (!blk.ReSize( (Elems + 1) * sizeof(T*) )) { return false; }
	// Make room ...
	memmove( ((T**)blk.Ptr()) + Idx + 1, ((T**)blk.Ptr()) + Idx, sizeof( T* ) * ( Elems - Idx) );
	// Add our element
	((T**)blk.Ptr())[Idx] = Obj;
	return true;	
}
	
template<class T,bool DeleteOnKill> bool CPtrArray<T,DeleteOnKill>::Delete(const UINT Idx)
{
	UINT Elems = Count();
	if (Idx >= Elems) return false;
	
	// Get pointer to object to delete
	T* Ptr = ((T**)blk.Ptr())[Idx];
	
	// Take out the ptr from the array
	memmove( ((T**)blk.Ptr()) + Idx, ((T**)blk.Ptr()) +Idx +1,sizeof( T* ) * (Elems-Idx-1));
	blk.ReSize(sizeof( T* ) * (Elems-1));

	// Destroy object if we own it
	if (DeleteOnKill && Ptr) delete Ptr; 

	return TRUE;
}

template<class T,bool DeleteOnKill> bool CPtrArray<T,DeleteOnKill>::Delete(T* Obj)
{
	// Find the object!
	UINT Elems = Count();
	for (UINT i = 0; i < Elems ; i++) {
		if (((T**)blk.Ptr())[i] == Obj) {
			return Delete(i);
		}
	}
	return false;
}
	
template<class T,bool DeleteOnKill> bool CPtrArray<T,DeleteOnKill>::Replace(T* Obj,const UINT Idx)
{
	// Check bounds
	UINT Elems = Count();
	if (Idx >= Elems) return false;

	// Get pointer to object to replace
	T* Ptr = ((T**)blk.Ptr())[Idx];
	
	// Replace it!
	((T**)blk.Ptr())[Idx] = Obj;

	// Destroy object if we own it
	if (DeleteOnKill && Ptr) delete Ptr; 
	
	return true;
}
	
template<class T,bool DeleteOnKill> bool CPtrArray<T,DeleteOnKill>::Flush(void)
{

	if (DeleteOnKill) {
		UINT Elems = Count();
		while (Elems) {
			Elems--;
			T* Ptr = ((T**)blk.Ptr())[Elems];
			if (Ptr) delete Ptr;
		};
	}
	blk.ReSize(0);
	return true;
}

template<class T,bool DeleteOnKill> CPtrArray<T,DeleteOnKill>::~CPtrArray()
{
	Flush();
}
		
#endif