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