Go to the documentation of this file.
33 #ifndef _UCOMMON_LINKED_H_
34 #define _UCOMMON_LINKED_H_
36 #ifndef _UCOMMON_CONFIG_H_
40 #ifndef _UCOMMON_OBJECT_H_
90 virtual void retain(
void) __OVERRIDE;
271 return polystatic_cast<LinkedObject*>(head);
279 return polystatic_cast<LinkedObject*>(tail);
287 return polystatic_cast<LinkedObject*>(head);
504 static unsigned keyindex(
const char *name,
unsigned size);
545 inline bool equal(
const char *name)
const {
546 return (compare(name) == 0);
555 return compare(name) == 0;
564 return compare(name) != 0;
700 inline operator bool()
const {
730 return (Child.
begin() == NULL);
738 return (Parent == NULL);
771 friend class ObjectQueue;
827 return polypointer_cast<DLinkedObject *>(Root->head) ==
this;
835 return polypointer_cast<DLinkedObject *>(Root->tail) ==
this;
908 template <
typename T,
class O = LinkedObject>
958 inline void set(
const T& typed_value) {
971 inline T& operator*() {
975 inline operator T&() {
979 inline void operator()(
const T data) {
1018 ptr =
static_cast<T*
>(
pointer);
1022 ptr =
static_cast<T*
>(
pointer);
1030 ptr =
static_cast<T*
>(index->
begin());
1061 ptr =
static_cast<T*
>(index->
begin());
1069 ptr =
static_cast<T*
>(
pointer);
1092 inline operator T*()
const {
1100 ptr =
static_cast<T*
>(ptr->getPrev());
1107 ptr =
static_cast<T*
>(ptr->getNext());
1115 return static_cast<T*
>(ptr->getNext());
1124 return static_cast<T*
>(ptr->getPrev());
1131 ptr =
static_cast<T*
>(ptr->getNext());
1138 ptr =
static_cast<T*
>(ptr->getPrev());
1146 return (ptr->getNext() != NULL);
1154 return (ptr->getPrev() != NULL);
1161 inline operator bool()
const {
1162 return (ptr != NULL);
1170 return (ptr == NULL);
1173 inline bool is()
const {
1174 return (ptr != NULL);
1204 template <
typename T>
1223 value = source.value;
1247 inline const T&
get(
void)
const {
1265 return (node == NULL) ? NULL : node->value;
1273 return (!Child.
begin() && value != NULL);
1304 inline void set(
const T& reference) {
1330 return static_cast<treemap*
>(Parent);
bool equal(const char *name) const
Equal function which calls compare.
A common object base class with auto-pointer support.
bool is_leaf(void) const
Test if node has children.
virtual int compare(const char *name) const
Compare the name of our object to see if equal.
void delist(void)
Remove our object from the list it is currently part of.
Generic smart pointer class.
void setId(char *name)
Set or replace the name id of this node.
LinkedObject * LinkedIndex
Convenience typedef for root pointers of single linked lists.
NamedTree * leaf(const char *name) const
Find a child leaf node of our object with the specified name.
char * getId(void) const
Get the named id string of this object.
void purge(void)
Performs object destruction.
NamedObject(OrderedIndex *index, char *name)
Created a named object on an ordered list.
LinkedObject * begin(void) const
Return first object in list for iterators.
DLinkedObject * getPrev(void) const
Get previous node in the list for reverse iteration.
OrderedObject * getNext(void) const
Get next ordered member when iterating.
LinkedObject * get(void)
Get (pull) object off the list.
unsigned count(void) const
Count of objects this list manages.
void delist(OrderedIndex *index)
Remove our ordered object from an existing index.
DLinkedObject & operator*=(DLinkedObject *object)
Insert object in list with our object.
treemap * find(const char *name) const
Find a subnode from our node by name.
A double linked list object.
T * operator->() const
Return member from typed object our pointer references.
LinkedObject ** root(void) const
Return pointer to our linked pointer to use as root node of a chain.
linked_pointer(OrderedIndex *index)
Create a linked pointer to examine an ordered index.
LinkedObject()
Construct base class unattached to anyone.
NamedTree * getIndexed(unsigned index) const
Get child by index number.
bool operator!=(const char *name) const
Comparison operator between our name and a string.
A linked object base class for ordered objects.
NamedTree * getChild(const char *name) const
Find a direct child of our node which matches the specified name.
NamedObject * getNext(void) const
Get next effective object when iterating.
virtual void release(void)
Release list, mark as no longer linked.
void purge(void)
Purge the linked list and then set the index to empty.
bool is_attribute(void) const
Test if this node is a leaf node for a tree pointer table.
void operator=(linked_pointer &pointer)
Assign our pointer from another pointer.
static unsigned keyindex(const char *name, unsigned size)
Internal function to convert a name to a hash index number.
Reusable objects for forming private heaps.
DLinkedObject & operator-=(DLinkedObject *object)
Insert object in front of our object.
treemap(treemap *parent, char *name, T &reference)
Construct a child node on an existing tree and assign it's value.
OrderedIndex * getIndex(void) const
Get the ordered index of our child nodes.
void operator=(const T &data)
Assign the value of our node.
linked_value(OrderedIndex *index)
Construct embedded object on an ordered list.
bool is_prev(void) const
Test for previous member in double linked list.
The named tree class is used to form a tree oriented list of associated objects.
void prev(void)
Move (iterate) pointer to previous member in double linked list.
linked_pointer()
Create a linked pointer not attached to a list.
void enlistHead(OrderedIndex *index)
List our ordered object at start of a linked list on an index.
An index container for maintaining an ordered list of objects.
NamedObject()
Create an empty unnamed cell object.
ReusableObject * getNext(void)
Get next effective reusable object when iterating.
NamedTree * path(const char *path) const
Find a subnode by a dot separated list of node names.
treemap * getIndexed(unsigned index) const
Get child member node by index.
void enlist(LinkedObject **root)
Add our object to an existing linked list through a pointer.
linked_pointer(LinkedObject *pointer)
Create a linked pointer assigned from a raw linked object pointer.
void add(OrderedObject *ordered)
Add an object into the ordered index.
treemap(char *name=NULL)
Construct a typed root node for the tree.
LinkedObject * operator*() const
Return head object pointer.
Common base class for all objects that can be formed into a linked list.
T * getNext(void) const
Get the next member in linked list.
bool is_root(void) const
Test if node is root node.
bool operator!() const
Test if linked list is empty/we are at end of list.
void remove(void)
Remove our node from our parent list.
linked_value(LinkedObject **root)
Construct embedded object on a linked list.
NamedTree * getLeaf(const char *name) const
Find a direct leaf node on our node.
LinkedObject * find(unsigned offset) const
Find a specific member in the ordered list.
~NamedObject()
Destroy named object.
void operator=(T *pointer)
Assign our typed iterative pointer from a matching typed object.
virtual void clearId(void)
The behavior of clearing id's can be overridden if they are not assigned as strdup's from the heap....
virtual void insert(DLinkedObject *object)
Insert object, method in derived object.
linked_value(LinkedObject **root, const T &typed_value)
Assign embedded value from related type and link to list.
virtual ~OrderedIndex()
Destroy index.
static T getPointer(treemap *node)
Return value from tree element when value is a pointer.
NamedTree * find(const char *name) const
Find a child node of our object with the specified name.
bool operator==(const char *name) const
Comparison operator between our name and a string.
treemap(const treemap &source)
Construct a copy of the treemap object.
const T & getData(void) const
Get the data value of a data based value tree.
linked_value & operator=(const T &typed_value)
Assign embedded value from related type.
OrderedIndex()
Create and initialize an empty index.
virtual void lock_index(void)
Used to synchronize lists managed by multiple threads.
void relistHead(NamedTree *trunk)
Add leaf to a trunk, by reverse order.
Various miscellaneous platform specific headers and defines.
void operator=(LinkedObject *pointer)
Assign our pointer from a generic linked object pointer.
static NamedObject * skip(NamedObject **hash, NamedObject *current, unsigned size)
Iterate through a hash map table.
Common namespace for all ucommon objects.
Class for resource bound memory pools between threads.
linked_value()
Create embedded value object unlinked.
void operator*=(OrderedObject *object)
Add object to our list.
bool is_tail(void) const
Test if we are at the end of a list.
T getValue(const char *name) const
Get the value pointer of a leaf node of a pointer tree.
treemap * getParent(void) const
Get the typed parent node for our node.
Embed data objects into a tree structured memory database.
void enlist(OrderedIndex *index)
Attach our object to a linked list.
static NamedObject ** index(NamedObject **hash, unsigned size)
Convert a hash index into a linear object pointer array.
treemap(treemap *parent, char *name)
Construct a child node on an existing tree.
void next(void)
Move (iterate) pointer to next member in linked list.
void enlistTail(OrderedIndex *index)
Attach our object to the end of a linked list though an ordered index.
NamedTree(const NamedTree &source)
Construct a copy of the tree.
T * getPrev(void) const
Get the previous member in double linked list.
T copy(const T &src)
Convenience function to copy objects.
void delist(LinkedObject **root)
Locate and remove ourselves from a list of objects.
linked_pointer(T *pointer)
Create a linked pointer and assign to start of a list.
void setPointer(const T pointer)
Set the pointer of a pointer based value tree.
const T & get(void) const
Return the typed value of this node.
OrderedObject(OrderedIndex *index)
Construct an ordered object aot end of a an index.
bool is_next(void) const
Test for next member in linked list.
static unsigned count(const LinkedObject *root)
Count the number of linked objects in a list.
treemap * getLeaf(const char *name) const
Find a direct typed leaf node on our node.
bool is_head(void) const
Test if we are at the head of a list.
DLinkedObject & operator+=(DLinkedObject *object)
Insert object behind our object.
void reset(void)
Reset linked list to empty without purging.
OrderedIndex & operator=(const OrderedIndex &object)
Assign ordered index.
static unsigned count(NamedObject **hash, unsigned size)
Count the total named objects in a hash table.
LinkedObject * getNext(void) const
Get next effective object when iterating.
static NamedObject ** sort(NamedObject **list, size_t count=0)
Sort an array of named objects in alphabetical order.
DLinkedObject(OrderedIndex *index)
Construct and add our object to an existing double linked list at end.
virtual void retain(void)
Retain by marking as self referenced list.
static void purge(LinkedObject *root)
Release all objects from a list.
OrderedObject()
Construct an ordered object unattached.
NamedTree * getParent(void) const
Get parent node we are listed as a child on.
void enlistHead(OrderedIndex *index)
Attach our object to the start of a linked list though an ordered index.
void operator--()
Move (iterate) pointer to previous member in double linked list.
bool is_member(LinkedObject *list) const
Search to see if we are a member of a specific list.
LinkedObject ** index(void) const
Return a pointer to the head of the list.
NamedTree * getFirst(void) const
Get first child node in our ordered list of children.
static NamedObject * remove(NamedObject **hash, const char *name, unsigned size)
Remove an object from a hash map table.
void add(NamedObject **hash, char *name, unsigned size=1)
Add object to hash indexed list.
T * operator*() const
Return object we currently point to.
linked_value(OrderedIndex *index, const T &typed_value)
Assign embedded value from related type and add to list.
virtual void enlist(OrderedIndex *index)
List our ordered object in default strategy mode.
NamedObject(NamedObject **hash, char *name, unsigned size=1)
Create a named object and add to hash indexed list.
linked_pointer(const linked_pointer &pointer)
Create a copy of an existing linked pointer.
DLinkedObject()
Construct an unlinked object.
void operator=(OrderedIndex *index)
Assign our pointer from the start of an ordered index.
const T & operator*() const
Return typed value of this node by pointer reference.
static NamedObject * find(NamedObject *root, const char *name)
Find a named object from a simple list.
A smart pointer template for iterating linked lists.
void insertHead(DLinkedObject *object)
Insert object in front of our object.
static LinkedObject * getIndexed(LinkedObject *root, unsigned index)
Get member by index.
virtual void release(void)
Release list, mark as no longer linked.
LinkedObject * end(void) const
Return last object in list for iterators.
void enlistTail(OrderedIndex *index)
List our ordered object at end of a linked list on an index.
A linked object base class with members found by name.
void operator++()
Move (iterate) pointer to next member in linked list.
void relistTail(NamedTree *trunk)
Add leaf to a trunk, by order.
void relist(NamedTree *trunk=NULL)
Default relist is by tail...
virtual void unlock_index(void)
Used to synchronize lists managed by multiple threads.
static NamedObject * remove(NamedObject **root, const char *name)
Remove a named object from a simple list.
LinkedObject * getIndexed(unsigned index) const
Get an indexed member from the ordered index.
LinkedObject(LinkedObject **root)
Construct base class attached to a chain of objects.
void set(const T &reference)
Set the value of a data based value tree.
treemap * getChild(const char *name) const
Get direct typed child node of our node of specified name.
NamedTree(NamedTree *parent, char *name)
Create a tree node as a child of an existing node.
treemap * leaf(const char *name) const
Search for a leaf node of our node.
treemap * path(const char *path) const
Find a subnode by pathname.
static void purge(NamedObject **hash, unsigned size)
Purge a hash indexed table of named objects.
treemap * getFirst(void) const
Get first child of our node.
virtual ~DLinkedObject()
Delete linked list object.
static NamedObject * map(NamedObject **hash, const char *name, unsigned size)
Find a named object through a hash map table.
Template value class to embed data structure into a linked list.
DLinkedObject * getNext(void) const
Get next node in the list when iterating.
A common base class for all managed objects.
void insertTail(DLinkedObject *object)
Insert object behind our object.
NamedTree(char *name=NULL)
Create a stand-alone or root tree node, with an optional name.
virtual ~NamedTree()
Delete node in a tree.
const T getPointer(void) const
Get the pointer of a pointer based value tree.
bool operator!() const
Test if this node is unnamed.