gentable.c File Reference

#include <nt.h>
#include <ntrtl.h>

Go to the source code of this file.

Classes
struct	_TABLE_ENTRY_HEADER
Typedefs
typedef _TABLE_ENTRY_HEADER	TABLE_ENTRY_HEADER
typedef _TABLE_ENTRY_HEADER *	PTABLE_ENTRY_HEADER
Functions
TABLE_SEARCH_RESULT	FindNodeOrParent (IN PRTL_GENERIC_TABLE Table, IN PVOID Buffer, OUT PRTL_SPLAY_LINKS *NodeOrParent)
VOID	RtlInitializeGenericTable (IN PRTL_GENERIC_TABLE Table, IN PRTL_GENERIC_COMPARE_ROUTINE CompareRoutine, IN PRTL_GENERIC_ALLOCATE_ROUTINE AllocateRoutine, IN PRTL_GENERIC_FREE_ROUTINE FreeRoutine, IN PVOID TableContext)
PVOID	RtlInsertElementGenericTable (IN PRTL_GENERIC_TABLE Table, IN PVOID Buffer, IN CLONG BufferSize, OUT PBOOLEAN NewElement OPTIONAL)
PVOID	RtlInsertElementGenericTableFull (IN PRTL_GENERIC_TABLE Table, IN PVOID Buffer, IN CLONG BufferSize, OUT PBOOLEAN NewElement OPTIONAL, PVOID NodeOrParent, TABLE_SEARCH_RESULT SearchResult)
BOOLEAN	RtlDeleteElementGenericTable (IN PRTL_GENERIC_TABLE Table, IN PVOID Buffer)
PVOID	RtlLookupElementGenericTable (IN PRTL_GENERIC_TABLE Table, IN PVOID Buffer)
PVOID NTAPI	RtlLookupElementGenericTableFull (PRTL_GENERIC_TABLE Table, PVOID Buffer, OUT PVOID *NodeOrParent, OUT TABLE_SEARCH_RESULT *SearchResult)
PVOID	RtlEnumerateGenericTable (IN PRTL_GENERIC_TABLE Table, IN BOOLEAN Restart)
BOOLEAN	RtlIsGenericTableEmpty (IN PRTL_GENERIC_TABLE Table)
PVOID	RtlGetElementGenericTable (IN PRTL_GENERIC_TABLE Table, IN ULONG I)
ULONG	RtlNumberGenericTableElements (IN PRTL_GENERIC_TABLE Table)
PVOID	RtlEnumerateGenericTableWithoutSplaying (IN PRTL_GENERIC_TABLE Table, IN PVOID *RestartKey)

---

Typedef Documentation

typedef struct _TABLE_ENTRY_HEADER * PTABLE_ENTRY_HEADER

Referenced by FindNodeOrParent(), RtlDeleteElementGenericTable(), RtlEnumerateGenericTable(), RtlEnumerateGenericTableWithoutSplaying(), RtlGetElementGenericTable(), RtlInsertElementGenericTableFull(), and RtlLookupElementGenericTableFull().

typedef struct _TABLE_ENTRY_HEADER TABLE_ENTRY_HEADER

---

Function Documentation

TABLE_SEARCH_RESULT FindNodeOrParent (  IN PRTL_GENERIC_TABLE  Table, IN PVOID  Buffer, OUT PRTL_SPLAY_LINKS *  NodeOrParent )  [static]

Definition at line 64 of file gentable.c. References ASSERT, Buffer, PTABLE_ENTRY_HEADER, RtlIsGenericTableEmpty(), and TRUE. Referenced by RtlDeleteElementGenericTable(), RtlInsertElementGenericTable(), and RtlLookupElementGenericTableFull(). 00072 : 00073 00074 This routine is used by all of the routines of the generic 00075 table package to locate the a node in the tree. It will 00076 find and return (via the NodeOrParent parameter) the node 00077 with the given key, or if that node is not in the tree it 00078 will return (via the NodeOrParent parameter) a pointer to 00079 the parent. 00080 00081 Arguments: 00082 00083 Table - The generic table to search for the key. 00084 00085 Buffer - Pointer to a buffer holding the key. The table 00086 package doesn't examine the key itself. It leaves 00087 this up to the user supplied compare routine. 00088 00089 NodeOrParent - Will be set to point to the node containing the 00090 the key or what should be the parent of the node 00091 if it were in the tree. Note that this will *NOT* 00092 be set if the search result is TableEmptyTree. 00093 00094 Return Value: 00095 00096 TABLE_SEARCH_RESULT - TableEmptyTree: The tree was empty. NodeOrParent 00097 is *not* altered. 00098 00099 TableFoundNode: A node with the key is in the tree. 00100 NodeOrParent points to that node. 00101 00102 TableInsertAsLeft: Node with key was not found. 00103 NodeOrParent points to what would be 00104 parent. The node would be the left 00105 child. 00106 00107 TableInsertAsRight: Node with key was not found. 00108 NodeOrParent points to what would be 00109 parent. The node would be the right 00110 child. 00111 00112 --*/ 00113 00114 00115 00116 { 00117 00118 if (RtlIsGenericTableEmpty(Table)) { 00119 00120 return TableEmptyTree; 00121 00122 } else { 00123 00124 // 00125 // Used as the iteration variable while stepping through 00126 // the generic table. 00127 // 00128 PRTL_SPLAY_LINKS NodeToExamine = Table->TableRoot; 00129 00130 // 00131 // Just a temporary. Hopefully a good compiler will get 00132 // rid of it. 00133 // 00134 PRTL_SPLAY_LINKS Child; 00135 00136 // 00137 // Holds the value of the comparasion. 00138 // 00139 RTL_GENERIC_COMPARE_RESULTS Result; 00140 00141 while (TRUE) { 00142 00143 // 00144 // Compare the buffer with the key in the tree element. 00145 // 00146 00147 Result = Table->CompareRoutine( 00148 Table, 00149 Buffer, 00150 &((PTABLE_ENTRY_HEADER) NodeToExamine)->UserData 00151 ); 00152 00153 if (Result == GenericLessThan) { 00154 00155 if (Child = RtlLeftChild(NodeToExamine)) { 00156 00157 NodeToExamine = Child; 00158 00159 } else { 00160 00161 // 00162 // Node is not in the tree. Set the output 00163 // parameter to point to what would be its 00164 // parent and return which child it would be. 00165 // 00166 00167 *NodeOrParent = NodeToExamine; 00168 return TableInsertAsLeft; 00169 00170 } 00171 00172 } else if (Result == GenericGreaterThan) { 00173 00174 if (Child = RtlRightChild(NodeToExamine)) { 00175 00176 NodeToExamine = Child; 00177 00178 } else { 00179 00180 // 00181 // Node is not in the tree. Set the output 00182 // parameter to point to what would be its 00183 // parent and return which child it would be. 00184 // 00185 00186 *NodeOrParent = NodeToExamine; 00187 return TableInsertAsRight; 00188 00189 } 00190 00191 00192 } else { 00193 00194 // 00195 // Node is in the tree (or it better be because of the 00196 // assert). Set the output parameter to point to 00197 // the node and tell the caller that we found the node. 00198 // 00199 00200 ASSERT(Result == GenericEqual); 00201 *NodeOrParent = NodeToExamine; 00202 return TableFoundNode; 00203 00204 } 00205 00206 } 00207 00208 } 00209 00210 }

BOOLEAN RtlDeleteElementGenericTable (  IN PRTL_GENERIC_TABLE  Table, IN PVOID  Buffer )

Definition at line 532 of file gentable.c. References Buffer, FALSE, FindNodeOrParent(), PTABLE_ENTRY_HEADER, RtlDelete(), and TRUE. : The function DeleteElementGenericTable will find and delete an element from a generic table. If the element is located and deleted the return value is TRUE, otherwise if the element is not located the return value is FALSE. The user supplied input buffer is only used as a key in locating the element in the table. Arguments: Table - Pointer to the table in which to (possibly) delete the memory accessed by the key buffer. Buffer - Passed to the user comparasion routine. Its contents are up to the user but one could imagine that it contains some sort of key value. Return Value: BOOLEAN - If the table contained the key then true, otherwise false. --*/ { // // Holds a pointer to the node in the table or what would be the // parent of the node. // PRTL_SPLAY_LINKS NodeOrParent; // // Holds the result of the table lookup. // TABLE_SEARCH_RESULT Lookup; Lookup = FindNodeOrParent( Table, Buffer, &NodeOrParent ); if ((Lookup == TableEmptyTree) || (Lookup != TableFoundNode)) { return FALSE; } else { // // Delete the node from the splay tree. // Table->TableRoot = RtlDelete(NodeOrParent); // // Delete the element from the linked list. // RemoveEntryList(&((PTABLE_ENTRY_HEADER) NodeOrParent)->ListEntry); Table->NumberGenericTableElements--; Table->WhichOrderedElement = 0; Table->OrderedPointer = &Table->InsertOrderList; // // The node has been deleted from the splay table. // Now give the node to the user deletion routine. // NOTE: We are giving the deletion routine a pointer // to the splay links rather then the user data. It // is assumed that the deallocation is rather stupid. // Table->FreeRoutine(Table,NodeOrParent); return TRUE; } }

PVOID RtlEnumerateGenericTable (  IN PRTL_GENERIC_TABLE  Table, IN BOOLEAN  Restart )

Definition at line 738 of file gentable.c. References NULL, PTABLE_ENTRY_HEADER, RtlIsGenericTableEmpty(), RtlRealSuccessor(), and RtlSplay(). : The function EnumerateGenericTable will return to the caller one-by-one the elements of of a table. The return value is a pointer to the user defined structure associated with the element. The input parameter Restart indicates if the enumeration should start from the beginning or should return the next element. If the are no more new elements to return the return value is NULL. As an example of its use, to enumerate all of the elements in a table the user would write: for (ptr = EnumerateGenericTable(Table,TRUE); ptr != NULL; ptr = EnumerateGenericTable(Table, FALSE)) { : } Arguments: Table - Pointer to the generic table to enumerate. Restart - Flag that if true we should start with the least element in the tree otherwise, return we return a pointer to the user data for the root and make the real successor to the root the new root. Return Value: PVOID - Pointer to the user data. --*/ { if (RtlIsGenericTableEmpty(Table)) { // // Nothing to do if the table is empty. // return NULL; } else { // // Will be used as the "iteration" through the tree. // PRTL_SPLAY_LINKS NodeToReturn; // // If the restart flag is true then go to the least element // in the tree. // if (Restart) { // // We just loop until we find the leftmost child of the root. // for ( NodeToReturn = Table->TableRoot; RtlLeftChild(NodeToReturn); NodeToReturn = RtlLeftChild(NodeToReturn) ) { ; } Table->TableRoot = RtlSplay(NodeToReturn); } else { // // The assumption here is that the root of the // tree is the last node that we returned. We // find the real successor to the root and return // it as next element of the enumeration. The // node that is to be returned is splayed (thereby // making it the root of the tree). Note that we // need to take care when there are no more elements. // NodeToReturn = RtlRealSuccessor(Table->TableRoot); if (NodeToReturn) { Table->TableRoot = RtlSplay(NodeToReturn); } } // // If there actually is a next element in the enumeration // then the pointer to return is right after the list links. // return ((NodeToReturn)? ((PVOID)&((PTABLE_ENTRY_HEADER)NodeToReturn)->UserData) :((PVOID)(NULL))); } }

PVOID RtlEnumerateGenericTableWithoutSplaying (  IN PRTL_GENERIC_TABLE  Table, IN PVOID *  RestartKey )

Definition at line 1110 of file gentable.c. References NULL, PTABLE_ENTRY_HEADER, RtlIsGenericTableEmpty(), and RtlRealSuccessor(). Referenced by UdfGetNextFcb(). : The function EnumerateGenericTableWithoutSplaying will return to the caller one-by-one the elements of of a table. The return value is a pointer to the user defined structure associated with the element. The input parameter RestartKey indicates if the enumeration should start from the beginning or should return the next element. If the are no more new elements to return the return value is NULL. As an example of its use, to enumerate all of the elements in a table the user would write: *RestartKey = NULL; for (ptr = EnumerateGenericTableWithoutSplaying(Table, &RestartKey); ptr != NULL; ptr = EnumerateGenericTableWithoutSplaying(Table, &RestartKey)) { : } Arguments: Table - Pointer to the generic table to enumerate. RestartKey - Pointer that indicates if we should restart or return the next element. If the contents of RestartKey is NULL, the search will be started from the beginning. Return Value: PVOID - Pointer to the user data. --*/ { if (RtlIsGenericTableEmpty(Table)) { // // Nothing to do if the table is empty. // return NULL; } else { // // Will be used as the "iteration" through the tree. // PRTL_SPLAY_LINKS NodeToReturn; // // If the restart flag is true then go to the least element // in the tree. // if (*RestartKey == NULL) { // // We just loop until we find the leftmost child of the root. // for ( NodeToReturn = Table->TableRoot; RtlLeftChild(NodeToReturn); NodeToReturn = RtlLeftChild(NodeToReturn) ) { ; } *RestartKey = NodeToReturn; } else { // // The caller has passed in the previous entry found // in the table to enable us to continue the search. We call // RtlRealSuccessor to step to the next element in the tree. // NodeToReturn = RtlRealSuccessor(*RestartKey); if (NodeToReturn) { *RestartKey = NodeToReturn; } } // // If there actually is a next element in the enumeration // then the pointer to return is right after the list links. // return ((NodeToReturn)? ((PVOID)&((PTABLE_ENTRY_HEADER)NodeToReturn)->UserData) :((PVOID)(NULL))); } }

PVOID RtlGetElementGenericTable (  IN PRTL_GENERIC_TABLE  Table, IN ULONG  I )

Definition at line 884 of file gentable.c. References NULL, and PTABLE_ENTRY_HEADER. : The function GetElementGenericTable will return the i'th element inserted in the generic table. I = 0 implies the first element, I = (RtlNumberGenericTableElements(Table)-1) will return the last element inserted into the generic table. The type of I is ULONG. Values of I > than (NumberGenericTableElements(Table)-1) will return NULL. If an arbitrary element is deleted from the generic table it will cause all elements inserted after the deleted element to "move up". Arguments: Table - Pointer to the generic table from which to get the ith element. I - Which element to get. Return Value: PVOID - Pointer to the user data. --*/ { // // Current location in the table. // ULONG CurrentLocation = Table->WhichOrderedElement; // // Hold the number of elements in the table. // ULONG NumberInTable = Table->NumberGenericTableElements; // // Holds the value of I+1. // // Note that we don't care if this value overflows. // If we end up accessing it we know that it didn't. // ULONG NormalizedI = I + 1; // // Will hold distances to travel to the desired node; // ULONG ForwardDistance,BackwardDistance; // // Will point to the current element in the linked list. // PLIST_ENTRY CurrentNode = Table->OrderedPointer; // // If it's out of bounds get out quick. // if ((I == MAXULONG) || (NormalizedI > NumberInTable)) return NULL; // // If we're already at the node then return it. // if (NormalizedI == CurrentLocation) { return &((PTABLE_ENTRY_HEADER) CONTAINING_RECORD(CurrentNode, TABLE_ENTRY_HEADER, ListEntry))->UserData; } // // Calculate the forward and backward distance to the node. // if (CurrentLocation > NormalizedI) { // // When CurrentLocation is greater than where we want to go, // if moving forward gets us there quicker than moving backward // then it follows that moving forward from the listhead is // going to take fewer steps. (This is because, moving forward // in this case must move *through* the listhead.) // // The work here is to figure out if moving backward would be quicker. // // Moving backward would be quicker only if the location we wish to // go to is more than half way between the listhead and where we // currently are. // if (NormalizedI > (CurrentLocation/2)) { // // Where we want to go is more than half way from the listhead // We can traval backwards from our current location. // for ( BackwardDistance = CurrentLocation - NormalizedI; BackwardDistance; BackwardDistance-- ) { CurrentNode = CurrentNode->Blink; } } else { // // Where we want to go is less than halfway between the start // and where we currently are. Start from the listhead. // for ( CurrentNode = &Table->InsertOrderList; NormalizedI; NormalizedI-- ) { CurrentNode = CurrentNode->Flink; } } } else { // // When CurrentLocation is less than where we want to go, // if moving backwards gets us there quicker than moving forwards // then it follows that moving backwards from the listhead is // going to take fewer steps. (This is because, moving backwards // in this case must move *through* the listhead.) // ForwardDistance = NormalizedI - CurrentLocation; // // Do the backwards calculation as if we are starting from the // listhead. // BackwardDistance = (NumberInTable - NormalizedI) + 1; if (ForwardDistance <= BackwardDistance) { for ( ; ForwardDistance; ForwardDistance-- ) { CurrentNode = CurrentNode->Flink; } } else { for ( CurrentNode = &Table->InsertOrderList; BackwardDistance; BackwardDistance-- ) { CurrentNode = CurrentNode->Blink; } } } // // We're where we want to be. Save our current location and return // a pointer to the data to the user. // Table->OrderedPointer = CurrentNode; Table->WhichOrderedElement = I+1; return &((PTABLE_ENTRY_HEADER) CONTAINING_RECORD(CurrentNode, TABLE_ENTRY_HEADER, ListEntry))->UserData; }

VOID RtlInitializeGenericTable (  IN PRTL_GENERIC_TABLE  Table, IN PRTL_GENERIC_COMPARE_ROUTINE  CompareRoutine, IN PRTL_GENERIC_ALLOCATE_ROUTINE  AllocateRoutine, IN PRTL_GENERIC_FREE_ROUTINE  FreeRoutine, IN PVOID  TableContext )

Definition at line 213 of file gentable.c. References NULL. Referenced by UdfInitializeVcb(), and UdfInitializeVmcb(). : The procedure InitializeGenericTable takes as input an uninitialized generic table variable and pointers to the three user supplied routines. This must be called for every individual generic table variable before it can be used. Arguments: Table - Pointer to the generic table to be initialized. CompareRoutine - User routine to be used to compare to keys in the table. AllocateRoutine - User routine to call to allocate memory for a new node in the generic table. FreeRoutine - User routine to call to deallocate memory for a node in the generic table. TableContext - Supplies user supplied context for the table. Return Value: None. --*/ { // // Initialize each field of the Table parameter. // Table->TableRoot = NULL; InitializeListHead(&Table->InsertOrderList); Table->NumberGenericTableElements = 0; Table->OrderedPointer = &Table->InsertOrderList; Table->WhichOrderedElement = 0; Table->CompareRoutine = CompareRoutine; Table->AllocateRoutine = AllocateRoutine; Table->FreeRoutine = FreeRoutine; Table->TableContext = TableContext; }

PVOID RtlInsertElementGenericTable (  IN PRTL_GENERIC_TABLE  Table, IN PVOID  Buffer, IN CLONG  BufferSize, OUT PBOOLEAN NewElement  OPTIONAL )

Definition at line 271 of file gentable.c. References Buffer, BufferSize, FindNodeOrParent(), and RtlInsertElementGenericTableFull(). : The function InsertElementGenericTable will insert a new element in a table. It does this by allocating space for the new element (this includes splay links), inserting the element in the table, and then returning to the user a pointer to the new element (which is the first available space after the splay links). If an element with the same key already exists in the table the return value is a pointer to the old element. The optional output parameter NewElement is used to indicate if the element previously existed in the table. Note: the user supplied Buffer is only used for searching the table, upon insertion its contents are copied to the newly created element. This means that pointer to the input buffer will not point to the new element. Arguments: Table - Pointer to the table in which to (possibly) insert the key buffer. Buffer - Passed to the user comparasion routine. Its contents are up to the user but one could imagine that it contains some sort of key value. BufferSize - The amount of space to allocate when the (possible) insertion is made. Note that if we actually do not find the node and we do allocate space then we will add the size of the SPLAY_LINKS to this buffer size. The user should really take care not to depend on anything in the first sizeof(SPLAY_LINKS) bytes of the memory allocated via the memory allocation routine. NewElement - Optional Flag. If present then it will be set to TRUE if the buffer was not "found" in the generic table. Return Value: PVOID - Pointer to the user defined data. --*/ { // // Holds a pointer to the node in the table or what would be the // parent of the node. // PRTL_SPLAY_LINKS NodeOrParent; // // Holds the result of the table lookup. // TABLE_SEARCH_RESULT Lookup; Lookup = FindNodeOrParent( Table, Buffer, &NodeOrParent ); // // Call the full routine to do the real work. // return RtlInsertElementGenericTableFull( Table, Buffer, BufferSize, NewElement, NodeOrParent, Lookup ); }

PVOID RtlInsertElementGenericTableFull (  IN PRTL_GENERIC_TABLE  Table, IN PVOID  Buffer, IN CLONG  BufferSize, OUT PBOOLEAN NewElement  OPTIONAL, PVOID  NodeOrParent, TABLE_SEARCH_RESULT  SearchResult )

Definition at line 357 of file gentable.c. References ASSERT, Buffer, BufferSize, FALSE, NULL, PTABLE_ENTRY_HEADER, RtlSplay(), and TRUE. Referenced by RtlInsertElementGenericTable(). : The function InsertElementGenericTableFull will insert a new element in a table. It does this by allocating space for the new element (this includes splay links), inserting the element in the table, and then returning to the user a pointer to the new element. If an element with the same key already exists in the table the return value is a pointer to the old element. The optional output parameter NewElement is used to indicate if the element previously existed in the table. Note: the user supplied Buffer is only used for searching the table, upon insertion its contents are copied to the newly created element. This means that pointer to the input buffer will not point to the new element. This routine is passed the NodeOrParent and SearchResult from a previous RtlLookupElementGenericTableFull. Arguments: Table - Pointer to the table in which to (possibly) insert the key buffer. Buffer - Passed to the user comparasion routine. Its contents are up to the user but one could imagine that it contains some sort of key value. BufferSize - The amount of space to allocate when the (possible) insertion is made. Note that if we actually do not find the node and we do allocate space then we will add the size of the SPLAY_LINKS to this buffer size. The user should really take care not to depend on anything in the first sizeof(SPLAY_LINKS) bytes of the memory allocated via the memory allocation routine. NewElement - Optional Flag. If present then it will be set to TRUE if the buffer was not "found" in the generic table. NodeOrParent - Result of prior RtlLookupElementGenericTableFull. SearchResult - Result of prior RtlLookupElementGenericTableFull. Return Value: PVOID - Pointer to the user defined data. --*/ { // // Node will point to the splay links of what // will be returned to the user. // PRTL_SPLAY_LINKS NodeToReturn; if (SearchResult != TableFoundNode) { // // We just check that the table isn't getting // too big. // ASSERT(Table->NumberGenericTableElements != (MAXULONG-1)); // // The node wasn't in the (possibly empty) tree. // Call the user allocation routine to get space // for the new node. // NodeToReturn = Table->AllocateRoutine( Table, BufferSize+FIELD_OFFSET( TABLE_ENTRY_HEADER, UserData ) ); // // If the return is NULL, return NULL from here to indicate that // the entry could not be added. // if (NodeToReturn == NULL) { if (ARGUMENT_PRESENT(NewElement)) { *NewElement = FALSE; } return(NULL); } RtlInitializeSplayLinks(NodeToReturn); // // Insert the new node at the end of the ordered linked list. // InsertTailList( &Table->InsertOrderList, &((PTABLE_ENTRY_HEADER) NodeToReturn)->ListEntry ); Table->NumberGenericTableElements++; // // Insert the new node in the tree. // if (SearchResult == TableEmptyTree) { Table->TableRoot = NodeToReturn; } else { if (SearchResult == TableInsertAsLeft) { RtlInsertAsLeftChild( NodeOrParent, NodeToReturn ); } else { RtlInsertAsRightChild( NodeOrParent, NodeToReturn ); } } // // Copy the users buffer into the user data area of the table. // RtlCopyMemory( &((PTABLE_ENTRY_HEADER) NodeToReturn)->UserData, Buffer, BufferSize ); } else { NodeToReturn = NodeOrParent; } // // Always splay the (possibly) new node. // Table->TableRoot = RtlSplay(NodeToReturn); if (ARGUMENT_PRESENT(NewElement)) { *NewElement = ((SearchResult == TableFoundNode)?(FALSE):(TRUE)); } // // Insert the element on the ordered list; // return &((PTABLE_ENTRY_HEADER) NodeToReturn)->UserData; }

BOOLEAN RtlIsGenericTableEmpty (  IN PRTL_GENERIC_TABLE  Table  )

Definition at line 851 of file gentable.c. References FALSE, and TRUE. Referenced by FindNodeOrParent(), RtlEnumerateGenericTable(), and RtlEnumerateGenericTableWithoutSplaying(). 00857 : 00858 00859 The function IsGenericTableEmpty will return to the caller TRUE if 00860 the input table is empty (i.e., does not contain any elements) and 00861 FALSE otherwise. 00862 00863 Arguments: 00864 00865 Table - Supplies a pointer to the Generic Table. 00866 00867 Return Value: 00868 00869 BOOLEAN - if enabled the tree is empty. 00870 00871 --*/ 00872 00873 { 00874 00875 // 00876 // Table is empty if the root pointer is null. 00877 // 00878 00879 return ((Table->TableRoot)?(FALSE):(TRUE)); 00880 00881 }

PVOID RtlLookupElementGenericTable (  IN PRTL_GENERIC_TABLE  Table, IN PVOID  Buffer )

Definition at line 619 of file gentable.c. References Buffer, and RtlLookupElementGenericTableFull(). Referenced by UdfLookupFcbTable(). : The function LookupElementGenericTable will find an element in a generic table. If the element is located the return value is a pointer to the user defined structure associated with the element, otherwise if the element is not located the return value is NULL. The user supplied input buffer is only used as a key in locating the element in the table. Arguments: Table - Pointer to the users Generic table to search for the key. Buffer - Used for the comparasion. Return Value: PVOID - returns a pointer to the user data. --*/ { // // Holds a pointer to the node in the table or what would be the // parent of the node. // PRTL_SPLAY_LINKS NodeOrParent; // // Holds the result of the table lookup. // TABLE_SEARCH_RESULT Lookup; return RtlLookupElementGenericTableFull( Table, Buffer, &NodeOrParent, &Lookup ); }

PVOID NTAPI RtlLookupElementGenericTableFull (  PRTL_GENERIC_TABLE  Table, PVOID  Buffer, OUT PVOID *  NodeOrParent, OUT TABLE_SEARCH_RESULT *  SearchResult )

Definition at line 669 of file gentable.c. References Buffer, FindNodeOrParent(), NULL, PTABLE_ENTRY_HEADER, and RtlSplay(). Referenced by RtlLookupElementGenericTable(). : The function LookupElementGenericTableFull will find an element in a generic table. If the element is located the return value is a pointer to the user defined structure associated with the element. If the element is not located then a pointer to the parent for the insert location is returned. The user must look at the SearchResult value to determine which is being returned. The user can use the SearchResult and parent for a subsequent FullInsertElement call to optimize the insert. Arguments: Table - Pointer to the users Generic table to search for the key. Buffer - Used for the comparasion. NodeOrParent - Address to store the desired Node or parent of the desired node. SearchResult - Describes the relationship of the NodeOrParent with the desired Node. Return Value: PVOID - returns a pointer to the user data. --*/ { // // Lookup the element and save the result. // *SearchResult = FindNodeOrParent( Table, Buffer, (PRTL_SPLAY_LINKS *)NodeOrParent ); if ((*SearchResult == TableEmptyTree) || (*SearchResult != TableFoundNode)) { return NULL; } else { // // Splay the tree with this node. // Table->TableRoot = RtlSplay(*NodeOrParent); // // Return a pointer to the user data. // return &((PTABLE_ENTRY_HEADER)*NodeOrParent)->UserData; } }

ULONG RtlNumberGenericTableElements (  IN PRTL_GENERIC_TABLE  Table  )

Definition at line 1079 of file gentable.c. : The function NumberGenericTableElements returns a ULONG value which is the number of generic table elements currently inserted in the generic table. Arguments: Table - Pointer to the generic table from which to find out the number of elements. Return Value: ULONG - The number of elements in the generic table. --*/ { return Table->NumberGenericTableElements; }

---