INodeTab Class Reference

#include <INodeTab.h>

Class Description

Class representing a dynamic array of INodes.

Inheritance diagram for INodeTab:

Public Member Functions
void	DisposeTemporary ()
	Deletes all temporary nodes, such as those of type INodeTransformed, from the array. More...
int	IndexOf (INode *node)
	Finds the specified node in the array and returns its index. More...
bool	Contains (INode *node)
	Checks whether the specified node is in the array. More...
int	AppendNode (INode *node, bool allowDups=false, int allocExtra=0)
	Adds a node to the end of the array. More...
int	InsertNode (INode *node, int at, bool allowDups=false)
	Inserts a node into the array at the specified position. More...
bool	RemoveNode (INode *n)
	Removes the supplied node from the array. More...
Public Member Functions inherited from Tab< INode * >
	Tab ()
	Default constructor. More...
	Tab (const Tab &tb)
	Copy constructor. More...
virtual	~Tab ()
	Destructor. More...
void	Init ()
	Initializes a Tab instance. More...
int	Count () const
	Retrieves the number of items in the Tab. More...
void	ZeroCount ()
	Resets the number of used items to zero. More...
void	SetCount (int n, BOOL resize=TRUE)
	Sets the number of used items. More...
INode * *	Addr (const INT_PTR i) const
	Returns the address of the i-th item. More...
int	Insert (int at, int num, INode * *el)
	Inserts items in the Tab at a specified position. More...
int	Append (int num, INode * *el, int allocExtra=0)
	Appends items at the end of the Tab. More...
int	Delete (int start, int num)
	Deletes items from the Tab. More...
int	Resize (int num)
	Changes the number of items allocated in memory. More...
void	Shrink ()
	Frees unused Tab items to reduce memory footprint. More...
void	Sort (CompareFnc cmp)
	Sorts the array using the compare function. More...
Tab &	operator= (const Tab &tb)
	Assignment operator. More...
INode * &	operator[] (const INT_PTR i) const
	Accesses the i-th Tab item. More...

Additional Inherited Members
Static Public Member Functions inherited from MaxHeapOperators
static UtilExport void *	operator new (size_t size)
	Standard new operator used to allocate objects If there is insufficient memory, an exception will be thrown. More...
static UtilExport void *	operator new (size_t size, const std::nothrow_t &e)
	Standard new operator used to allocate objects if there is insufficient memory, NULL will be returned. More...
static UtilExport void *	operator new (size_t size, const char *filename, int line)
	New operator used to allocate objects that takes the filename and line number where the new was called If there is insufficient memory, an exception will be thrown. More...
static UtilExport void *	operator new (size_t size, int block_type, const char *filename, int line)
	New operator used to allocate objects that takes the type of memory, filename and line number where the new was called If there is insufficient memory, an exception will be thrown. More...
static UtilExport void *	operator new (size_t size, const std::nothrow_t &e, const char *filename, int line)
	New operator used to allocate objects that takes the filename and line number where the new was called If there is insufficient memory, NULL will be returned. More...
static UtilExport void *	operator new (size_t size, unsigned long flags)
	New operator used to allocate objects that takes extra flags to specify special operations If there is insufficient memory, an exception will be thrown. More...
static UtilExport void *	operator new (size_t size, const std::nothrow_t &e, unsigned long flags)
	New operator used to allocate objects that takes extra flags to specify special operations If there is insufficient memory, NULL will be returned. More...
static UtilExport void *	operator new[] (size_t size)
	New operator used to allocate arrays of objects If there is insufficient memory, an exception will be thrown. More...
static UtilExport void *	operator new[] (size_t size, const std::nothrow_t &e)
	New operator used to allocate arrays of objects If there is insufficient memory, NULL will be returned. More...
static UtilExport void *	operator new[] (size_t size, const char *filename, int line)
	New operator used to allocate arrays of objects If there is insufficient memory, an exception will be thrown. More...
static UtilExport void *	operator new[] (size_t size, int block_type, const char *filename, int line)
	New operator used to allocate arrays of objects. More...
static UtilExport void *	operator new[] (size_t size, const std::nothrow_t &e, const char *filename, int line)
	New operator used to allocate arrays of objects If there is insufficient memory, NULL will be returned. More...
static UtilExport void *	operator new[] (size_t size, unsigned long flags)
	New operator used to allocate arrays of objects If there is insufficient memory, an exception will be thrown. More...
static UtilExport void *	operator new[] (size_t size, const std::nothrow_t &e, unsigned long flags)
	New operator used to allocate arrays of objects If there is insufficient memory, NULL will be returned. More...
static UtilExport void	operator delete (void *ptr)
	Standard delete operator used to deallocate an object If the pointer is invalid, an exception will be thrown. More...
static UtilExport void	operator delete (void *ptr, const std::nothrow_t &e)
	Standard delete operator used to deallocate an object If the pointer is invalid, nothing will happen. More...
static UtilExport void	operator delete (void *ptr, const char *filename, int line)
	Delete operator used to deallocate an object that takes the filename and line number where the delete was called If the pointer is invalid, an exception will be thrown. More...
static UtilExport void	operator delete (void *ptr, int block_type, const char *filename, int line)
	Delete operator used to deallocate an object that takes the type of memory, filename and line number where the delete was called If the pointer is invalid, an exception will be thrown. More...
static UtilExport void	operator delete (void *ptr, const std::nothrow_t &e, const char *filename, int line)
	Delete operator used to deallocate an object that takes the filename and line number where the delete was called If the pointer is invalid, nothing will happen. More...
static UtilExport void	operator delete (void *ptr, unsigned long flags)
	Delete operator used to deallocate an object that takes extra flags to specify special operations If the pointer is invalid, an exception will be thrown. More...
static UtilExport void	operator delete (void *ptr, const std::nothrow_t &e, unsigned long flags)
	Delete operator used to deallocate an object that takes extra flags to specify special operations If the pointer is invalid, nothing will happen. More...
static UtilExport void	operator delete[] (void *ptr)
	Standard delete operator used to deallocate an array of objects If the pointer is invalid, an exception will be thrown. More...
static UtilExport void	operator delete[] (void *ptr, const std::nothrow_t &e)
	Standard delete operator used to deallocate an array of objects If the pointer is invalid, nothing will happen. More...
static UtilExport void	operator delete[] (void *ptr, const char *filename, int line)
	Delete operator used to deallocate an array of objects that takes the filename and line number where the delete was called If the pointer is invalid, an exception will be thrown. More...
static UtilExport void	operator delete[] (void *ptr, int block_type, const char *filename, int line)
	Delete operator used to deallocate an array of objects that takes the type of memory, filename and line number where the delete was called If the pointer is invalid, an exception will be thrown. More...
static UtilExport void	operator delete[] (void *ptr, const std::nothrow_t &e, const char *filename, int line)
	Delete operator used to deallocate an array of objects that takes the filename and line number where the delete was called If the pointer is invalid, nothing will happen. More...
static UtilExport void	operator delete[] (void *ptr, unsigned long flags)
	Delete operator used to deallocate an array of objects that takes extra flags to specify special operations If the pointer is invalid, an exception will be thrown. More...
static UtilExport void	operator delete[] (void *ptr, const std::nothrow_t &e, unsigned long flags)
	Delete operator used to deallocate an array of objects that takes extra flags to specify special operations If the pointer is invalid, an exception will be thrown. More...
static UtilExport void *	operator new (size_t size, void *placement_ptr)
	Placement new operator. More...
static UtilExport void	operator delete (void *ptr, void *placement_ptr)
	Placement delete operator. More...
static UtilExport void *	aligned_malloc (size_t size, size_t alignment)
	Allocates memory on a specified alignment boundary. More...
static UtilExport void *	aligned_realloc (void *ptr, size_t size, size_t alignment)
	Reallocates memory on a specified alignment boundary. More...
static UtilExport void	aligned_free (void *ptr)
	Frees a block of memory that was allocated with aligned_malloc/aligned_realloc. More...

Member Function Documentation

void DisposeTemporary ( )

inline

Deletes all temporary nodes, such as those of type INodeTransformed, from the array.

See also

INodeTransformed

                            {
        for (int i=0; i<Count(); i++) {
            if ((*this)[i] != NULL) {
                (*this)[i]->DisposeTemporary();
            }
        }
    }

int IndexOf ( INode *  node )

inline

Finds the specified node in the array and returns its index.

Parameters

node	- The node to find

Returns

int - The index of the node in this array, or -1 if the node is not found

    {
        for (int i=0; i<Count(); i++) {
            if ((*this)[i] == node) {
                return i;
            }
        }
        return -1;
    }

bool Contains ( INode *  node )

inline

Checks whether the specified node is in the array.

Parameters

node	- The node to find

Returns

bool - true if the node is in the array, otherwise false

    {
        return (IndexOf(node) >= 0);
    }

int AppendNode ( INode *  node, bool  allowDups = false, int  allocExtra = 0  )

inline

Adds a node to the end of the array.

Parameters

node	- The node to add to the array
allowDups	- If true, the specified node is added to the array without checking whether it's contained already in it. If false, the node is added to the array only if it doesn't exist in it yet.
allocExtra	- The number of extra items by which the array should be enlarged if all its items have been filled with nodes.

Returns

- The number of nodes in the array prior to adding the specified node

                                                                            {
        if (!allowDups && Contains(node)) {
            return Count();
        }
        return Append(1, &node, allocExtra); 
    }

int InsertNode ( INode *  node, int  at, bool  allowDups = false  )

inline

Inserts a node into the array at the specified position.

Parameters

node	- The node to add to the array
at	- Array index where to insert the specified node. If a negative value is specified, the node will be appended to the array.
allowDups	- If true, the specified node is added to the array without checking whether it's contained already in it. If false, the node is added to the array only if it doesn't exist in it yet.

Returns

- The array index at which the node was inserted, or -1 if the node was not inserted into the array

                                                                {
        if (at < 0) {
            AppendNode(node, allowDups);
            return Count();
        }
        else if (allowDups || !Contains(node)) {
            return Insert(at, 1, &node);
        }
        return -1;
    } 

bool RemoveNode ( INode *  n )

inline

Removes the supplied node from the array.

Parameters

n	Node to remove

Returns

true if the node was found and removed, false otherwise

    {
        int i = IndexOf(n);
        bool arrayContainsNode = (i >= 0);
        int arraySizeBeforeRemoval = Count();
        int arraySizeAfterRemoval = arraySizeBeforeRemoval;
        if (arrayContainsNode)
        {
            arraySizeAfterRemoval = Delete(i, 1);
        }
        DbgAssert(arraySizeAfterRemoval < arraySizeBeforeRemoval);
        return (arraySizeAfterRemoval < arraySizeBeforeRemoval);
    }