DOUBLE_ARRAY< _CT > Class Template Reference

#include <mi32/doublear.h>

Inheritance diagram for DOUBLE_ARRAY< _CT >:

Public Member Functions
	DOUBLE_ARRAY (const DOUBLE_ARRAY< _CT > &rhs)
	DOUBLE_ARRAY ()
	~DOUBLE_ARRAY ()
void	AddRef ()
ERRVALUE	Append (const _CT *items, unsigned numitems)
ERRVALUE	Append (const _CT &item)
ERRVALUE	Assign (const _CT *items, int numitems)
void	Attach (MIDOUBLEARRAY &items, int numitems)
void	Clear ()
void	ClearItems (int start=0, int end=-1)
ERRVALUE	Copy (const DOUBLE_ARRAY< _CT > &rhs)
void	DeleteItem (int index)
	operator _CT * ()
	operator const _CT * () const
bool	operator!= (const DOUBLE_ARRAY< _CT > &rhs) const
DOUBLE_ARRAY< _CT > &	operator= (const DOUBLE_ARRAY< _CT > &rhs)
bool	operator== (const DOUBLE_ARRAY< _CT > &rhs) const
template<typename _IDXTYPE >
_CT &	operator[] (_IDXTYPE index)
template<typename _IDXTYPE >
const _CT &	operator[] (_IDXTYPE index) const


void	Detach (MIDOUBLEARRAY &items)
void	Free ()
void	GetItems (_CT *items, int numitems, int firstitem=0) const
const _CT &	GetLast () const
int	GetMaxItems () const
int	GetNumItems () const
UINT32	GetRefCount () const
int	GetSizeInBytes () const
bool	IsEmpty () const
void	Release ()
void	RemoveItem (INT32 item)
ERRVALUE	Reserve (int newmaxitems, bool clear=false)
void	ReserveExc (int newmaxitems, bool clear=false)
ERRVALUE	Resize (int numitems, bool keepold=true, bool clear=false)
void	ResizeExc (int numitems, bool keepold=true, bool clear=false)
void	Reverse ()
ERRVALUE	SetItems (int firstitem, const _CT *items, int numitems)
void	Sort (int(CompFunc)(_CT , _CT , void ), void *data=0)
void	Swap (DOUBLE_ARRAY< _CT > &rhs)
void	SwapBytes ()
void	TransferOwnerFrom (DOUBLE_ARRAY< _CT > &rhs)
template<class _T2 >
void	TransferOwnerFromExt (DOUBLE_ARRAY< _T2 > &rhs)

Detailed Description

template<class _CT>
class DOUBLE_ARRAY< _CT >

For MIDOUBLEARRAY defn.

For SwapBytes() defn For memset/memcpy Double array template.

This template is designed to contain an array of items which can be allocated using MmAlloc/MmRealloc. The primary purpose of this template is to replace allocated arrays where direct access to both array elements and the ability to access a pointer to the first element (as for a C array) is required.

For maximum efficiency, only minimal validation of access to array elements is performed. No initialization of array items is performed by the template.

This class is also designed to handle the 4 byte off alignment issue in regards to systems that have a 4 byte allocation granularity.

Best if used as DOUBLE_ARRAY<double>, DOUBLE_ARRAY<DPOINT2D>, DOUBLE_ARRAY<DPOINT3D>, DOUBLE_ARRAY<DRECT2D>, and DOUBLE_ARRAY<DRECT3D>

Constructor & Destructor Documentation

template<class _CT>

DOUBLE_ARRAY< _CT >::DOUBLE_ARRAY ( ) [inline]

Default constructor.

template<class _CT>

DOUBLE_ARRAY< _CT >::DOUBLE_ARRAY ( const DOUBLE_ARRAY< _CT > & rhs ) [inline]

Copy constructor.

template<class _CT>

DOUBLE_ARRAY< _CT >::~DOUBLE_ARRAY ( ) [inline]

Member Function Documentation

template<class _CT>

void DOUBLE_ARRAY< _CT >::AddRef ( ) [inline]

Increment reference count.

template<class _CT>

ERRVALUE DOUBLE_ARRAY< _CT >::Append	(	const _CT *	items,
		unsigned	numitems
	)			`[inline]`

Append items from C array.

Parameters:

	items	Items to append
	numitems	Number of items to append

template<class _CT>

ERRVALUE DOUBLE_ARRAY< _CT >::Append ( const _CT & item ) [inline]

Append item to end of array, extending if necessary.

template<class _CT>

ERRVALUE DOUBLE_ARRAY< _CT >::Assign	(	const _CT *	items,
		int	numitems
	)			`[inline]`

Assign from C array, reserving space if needed.

Resizes the array to the specified number of items.

Parameters:

	items	Items to copy to array
	numitems	Number of items to copy

template<class _CT>

void DOUBLE_ARRAY< _CT >::Attach	(	MIDOUBLEARRAY &	items,
		int	numitems
	)			`[inline]`

Attach a buffer to the DOUBLE_ARRAY.

After passing a buffer to Attach(), the DOUBLE_ARRAY "<b>owns</b>" the buffer and will free it in its destructor.

Parameters:

	items	Reference to a pointer to the templated data type.
	numitems	The number of items being attached

The reason it's a reference is that after recording the pointer, Attach() will set your pointer to 0. This will prevent you from accidently freeing a pointer you no longer own. If you want it back, call the Detach() method

template<class _CT>

void DOUBLE_ARRAY< _CT >::Clear ( ) [inline]

Clear the array, does not free resources.

template<class _CT>

void DOUBLE_ARRAY< _CT >::ClearItems	(	int	start = `0`,
		int	end = `-1`
	)			`[inline]`

Clear items in the array.

Parameters:

end

Default -1, use number of items

template<class _CT>

ERRVALUE DOUBLE_ARRAY< _CT >::Copy ( const DOUBLE_ARRAY< _CT > & rhs ) [inline]

Copy the contents of another DOUBLE_ARRAY.

Same as assignment, but returns an error code instead of throwing an exception.

template<class _CT>

void DOUBLE_ARRAY< _CT >::DeleteItem ( int index ) [inline]

Delete item in the array.

Use with care as this is not efficient for large arrays.

template<class _CT>

void DOUBLE_ARRAY< _CT >::Detach ( MIDOUBLEARRAY & items ) [inline]

Detach the buffer from the DOUBLE_ARRAY.

This turns ownership of the buffer over to the caller, who is then responsibile for seeing that it gets disposed of. After calling Detach(), the DOUBLE_ARRAY will behave as if it had just been constructed. In other words, it will be a NULL pointer pointing to 0 items. This means that if you want to know how many items are in the array returned, you'd better find out before} you call Detach()!

template<class _CT>

void DOUBLE_ARRAY< _CT >::Free ( ) [inline]

Free the array.

template<class _CT>

void DOUBLE_ARRAY< _CT >::GetItems	(	_CT *	items,
		int	numitems,
		int	firstitem = `0`
	)			const `[inline]`

Get items from array.

Parameters:

	items	Buffer to hold items
	numitems	Number of items to copy
	firstitem	First array item to retrieve

template<class _CT>

const _CT& DOUBLE_ARRAY< _CT >::GetLast ( ) const [inline]

Get last item in array.

Does not verify that array is non-empty.

template<class _CT>

int DOUBLE_ARRAY< _CT >::GetMaxItems ( ) const [inline]

Get maximum number of items in array.

template<class _CT>

int DOUBLE_ARRAY< _CT >::GetNumItems ( ) const [inline]

Get number of items in array.

template<class _CT>

UINT32 DOUBLE_ARRAY< _CT >::GetRefCount ( ) const [inline]

Get current reference count.

template<class _CT>

int DOUBLE_ARRAY< _CT >::GetSizeInBytes ( ) const [inline]

Get size of array required to hold current number of items in bytes.

template<class _CT>

bool DOUBLE_ARRAY< _CT >::IsEmpty ( ) const [inline]

Determine if array is empty.

template<class _CT>

DOUBLE_ARRAY< _CT >::operator _CT * ( ) [inline]

Cast to array of template type.

template<class _CT>

DOUBLE_ARRAY< _CT >::operator const _CT * ( ) const [inline]

Cast to const array of template type.

template<class _CT>

bool DOUBLE_ARRAY< _CT >::operator!= ( const DOUBLE_ARRAY< _CT > & rhs ) const [inline]

Inequality operator.

template<class _CT>

DOUBLE_ARRAY<_CT>& DOUBLE_ARRAY< _CT >::operator= ( const DOUBLE_ARRAY< _CT > & rhs ) [inline]

Assignment.

template<class _CT>

bool DOUBLE_ARRAY< _CT >::operator== ( const DOUBLE_ARRAY< _CT > & rhs ) const [inline]

Equality operator.

template<class _CT>

template<typename _IDXTYPE >

_CT& DOUBLE_ARRAY< _CT >::operator[] ( _IDXTYPE index ) [inline]

Write (non-const) access to array element.

Note:: Does not verify that index is within valid range.

template<class _CT>

template<typename _IDXTYPE >

const _CT& DOUBLE_ARRAY< _CT >::operator[] ( _IDXTYPE index ) const [inline]

Read (const) access to array element.

Note:: Does not verify that index is within valid range.

template<class _CT>

void DOUBLE_ARRAY< _CT >::Release ( ) [inline]

Decrement reference count, delete if zero.

template<class _CT>

void DOUBLE_ARRAY< _CT >::RemoveItem ( INT32 item ) [inline]

Remove item at specified index, maintaining order.

Note that this is inefficient for large arrays.

template<class _CT>

ERRVALUE DOUBLE_ARRAY< _CT >::Reserve	(	int	newmaxitems,
		bool	clear = `false`
	)			`[inline]`

Reserve space in array for up to specified number of items.

Parameters:

	newmaxitems	New maximum number of items
	clear	Clear the array by resetting number of items to 0

template<class _CT>

void DOUBLE_ARRAY< _CT >::ReserveExc	(	int	newmaxitems,
		bool	clear = `false`
	)			`[inline]`

Reserve space in array for up to specified number of items, throw exception on failure.

Parameters:

	newmaxitems	New maximum number of items
	clear	Clear the array by resetting number of items to 0

template<class _CT>

ERRVALUE DOUBLE_ARRAY< _CT >::Resize	(	int	numitems,
		bool	keepold = `true`,
		bool	clear = `false`
	)			`[inline]`

Resize array to specified number of items.

If the new size is larger than the previous size and the array is not cleared the new array entries will have indeterminant values.

Parameters:

	numitems	New number of items desired
	keepold	Keep old array entries
	clear	Clear new entries to zeros, will clear all if keepold is false

template<class _CT>

void DOUBLE_ARRAY< _CT >::ResizeExc	(	int	numitems,
		bool	keepold = `true`,
		bool	clear = `false`
	)			`[inline]`

Resize array to specified number of items, throw exception on failure.

If the new size is larger than the previous size and the array is not cleared the new array entries will have indeterminant values.

Parameters:

	numitems	New number of items desired
	keepold	Keep old array entries
	clear	Clear new entries to zeros, will clear all if keepold is false

template<class _CT>

void DOUBLE_ARRAY< _CT >::Reverse ( ) [inline]

Reverse order of items in array.

template<class _CT>

ERRVALUE DOUBLE_ARRAY< _CT >::SetItems	(	int	firstitem,
		const _CT *	items,
		int	numitems
	)			`[inline]`

Set array items from C array, expanding if needed.

Will not reduce the number of items in the array.

Parameters:

	firstitem	First array item to replace
	items	Items to copy to array
	numitems	Number of items to copy

template<class _CT>

void DOUBLE_ARRAY< _CT >::Sort	(	int()(_CT , _CT , void )	CompFunc,
		void *	data = `0`
	)			`[inline]`

Sort the items in the array.

CompFunc should return 1 if the first item sorts before the 2nd item Otherwise, return 0.

Parameters:

CompFunc

Compare function cannot return 'bool', must be 'int'.

template<class _CT>

void DOUBLE_ARRAY< _CT >::Swap ( DOUBLE_ARRAY< _CT > & rhs ) [inline]

Swap two DOUBLE_ARRAYs.

template<class _CT>

void DOUBLE_ARRAY< _CT >::SwapBytes ( ) [inline]

Swap bytes in a DOUBLE_ARRAY, assume that there is an overload to swap a _CT.

template<class _CT>

void DOUBLE_ARRAY< _CT >::TransferOwnerFrom ( DOUBLE_ARRAY< _CT > & rhs ) [inline]

Transfer data ownership from 'rhs' to 'this'.

template<class _CT>

template<class _T2 >

void DOUBLE_ARRAY< _CT >::TransferOwnerFromExt ( DOUBLE_ARRAY< _T2 > & rhs ) [inline]

Transfer data ownership from 'rhs' to 'this'.

The documentation for this class was generated from the following file:

mi32/doublear.h

DOUBLE_ARRAY< _CT > Class Template Reference

Public Member Functions

Detailed Description

template<class _CT> class DOUBLE_ARRAY< _CT >

Constructor & Destructor Documentation

Member Function Documentation

template<class _CT>
class DOUBLE_ARRAY< _CT >