3ds Max C++ API Reference
Loading...
Searching...
No Matches
INodeTab Class Reference

Class representing a dynamic array of INodes. More...

#include <INodeTab.h>

+ Inheritance diagram for INodeTab:

Public Member Functions

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

Additional Inherited Members

- Static Public Member Functions inherited from MaxHeapOperators
static UtilExport voidoperator new (size_t size)
 Standard new operator used to allocate objects If there is insufficient memory, an exception will be thrown.
 
static UtilExport voidoperator 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.
 
static UtilExport voidoperator 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.
 
static UtilExport voidoperator 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.
 
static UtilExport voidoperator 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.
 
static UtilExport voidoperator 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.
 
static UtilExport voidoperator 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.
 
static UtilExport voidoperator new[] (size_t size)
 New operator used to allocate arrays of objects If there is insufficient memory, an exception will be thrown.
 
static UtilExport voidoperator 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.
 
static UtilExport voidoperator 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.
 
static UtilExport voidoperator new[] (size_t size, int block_type, const char *filename, int line)
 New operator used to allocate arrays of objects.
 
static UtilExport voidoperator 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.
 
static UtilExport voidoperator 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.
 
static UtilExport voidoperator 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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
static UtilExport voidoperator new (size_t size, void *placement_ptr)
 Placement new operator.
 
static UtilExport void operator delete (void *ptr, void *placement_ptr)
 Placement delete operator.
 
static UtilExport voidaligned_malloc (size_t size, size_t alignment)
 Allocates memory on a specified alignment boundary.
 
static UtilExport voidaligned_realloc (void *ptr, size_t size, size_t alignment)
 Reallocates memory on a specified alignment boundary.
 
static UtilExport void aligned_free (void *ptr)
 Frees a block of memory that was allocated with aligned_malloc/aligned_realloc.
 

Detailed Description

Class representing a dynamic array of INodes.

Member Function Documentation

◆ DisposeTemporary()

void DisposeTemporary ( )
inline

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

See also
INodeTransformed
13 {
14 for (int i=0; i<Count(); i++) {
15 if ((*this)[i] != NULL) {
16 (*this)[i]->DisposeTemporary();
17 }
18 }
19 }
#define NULL
Definition: autoptr.h:18
int Count() const
Retrieves the number of items in the Tab.
Definition: tab.h:219

◆ IndexOf()

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
26 {
27 for (int i=0; i<Count(); i++) {
28 if ((*this)[i] == node) {
29 return i;
30 }
31 }
32 return -1;
33 }

◆ Contains()

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
39 {
40 return (IndexOf(node) >= 0);
41 }
int IndexOf(INode *node)
Finds the specified node in the array and returns its index.
Definition: INodeTab.h:25

◆ AppendNode()

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
52 {
53 if (!allowDups && Contains(node)) {
54 return Count();
55 }
56 return Append(1, &node, allocExtra);
57 }
bool Contains(INode *node)
Checks whether the specified node is in the array.
Definition: INodeTab.h:38
int Append(int num, INode * *el, int allocExtra=0)
Appends items at the end of the Tab.
Definition: tab.h:313

◆ InsertNode()

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
69 {
70 if (at < 0) {
71 AppendNode(node, allowDups);
72 return Count();
73 }
74 else if (allowDups || !Contains(node)) {
75 return Insert(at, 1, &node);
76 }
77 return -1;
78 }
int AppendNode(INode *node, bool allowDups=false, int allocExtra=0)
Adds a node to the end of the array.
Definition: INodeTab.h:52
int Insert(int at, int num, INode * *el)
Inserts items in the Tab at a specified position.
Definition: tab.h:302

◆ RemoveNode()

bool RemoveNode ( INode n)
inline

Removes the supplied node from the array.

Parameters
nNode to remove
Returns
true if the node was found and removed, false otherwise
85 {
86 int i = IndexOf(n);
87 bool arrayContainsNode = (i >= 0);
88 int arraySizeBeforeRemoval = Count();
89 int arraySizeAfterRemoval = arraySizeBeforeRemoval;
90 if (arrayContainsNode)
91 {
92 arraySizeAfterRemoval = Delete(i, 1);
93 }
94 DbgAssert(arraySizeAfterRemoval < arraySizeBeforeRemoval);
95 return (arraySizeAfterRemoval < arraySizeBeforeRemoval);
96 }
int Delete(int start, int num)
Deletes items from the Tab.
Definition: tab.h:322
#define DbgAssert(expr)
Definition: assert1.h:83