Data Structures

Here are the data structures with brief descriptions:
ucc::Socket::addressA generic socket address class
ucc::array_reuse< T >An array of reusable types
ucc::ArrayReuseAn array of reusable objects
assoc_pointer< T, I, M, P >A typed template for using a key association with typed objects
auto_deleteA helper class for the temporary object template
auto_pointerA general purpose smart pointer helper class
ucc::auto_protectA mutex locked object smart pointer helper class
autoreleaseCreate a linked list of auto-releasable objects
ucc::barrierA portable implimentation of "barrier" thread sychronization
bitmapA class to access bit fields in external bitmaps
ucc::BufferA thread-safe buffer for serializing and streaming class data
ucc::bufferof< T >A templated typed class for buffering of objects
ucc::charbuf< S >A template to create a character array that can be manipulated as a string
ucc::cidrA class to hold internet segment routing rules
ucc::ConditionalThe conditional is a common base for other thread synchronizing classes
ucc::ConditionalAccessThe conditional rw seperates scheduling for optizming behavior or rw locks
ucc::ConditionalLockAn optimized and convertable shared lock
CountedObjectA base class for reference counted objects
counterAutomatic integer counting class
ucc::string::cstringThis is an internal class which contains the actual string data along with some control fields
ucc::DetachedThreadA detached thread object that is stand-alone
ucc::TimerQueue::eventA timer event object that lives on a timer queue
ExclusiveAn exclusive locking protocol interface base
exclusive_lockA kind of smart pointer object to support exclusive locking protocol
fsysA container for generic and o/s portable threadsafe file system functions
ucc::mutex::gaurdGaurd class to apply scope based mutex locking to objects
ucc::rwlock::gaurd_readerGaurd class to apply scope based access locking to objects
ucc::rwlock::gaurd_writerGaurd class to apply scope based exclusive locking to objects
hostaddr_internetAn object that holds ipv4 or ipv6 binary encoded host addresses
ucc::JoinableThreadA child thread object that may be joined by parent
keyassocA class to hold memory pointers referenced by string names
keydataData keys parsed from a keyfile
keyfileTraditional keypair config file parsing class
keylist< T >A template for ordered index of typed name key mapped objects
keymap< T, M >A templated class for a hash map
keydata::keyvalueA key value set is used for iterative access
linked_pointer< T >A templated smart pointer for iterating linked lists
linked_value< T, O >Templated value class to embed data structure into a linked list
LinkedListA double linked list object
LinkedObjectCommon base class for all objects that can be formed into a linked list
ucc::ListenSocketA bound socket used to listen for inbound socket connections
ucc::locked_instance< T >A templated smart pointer instance for lock protected objects
ucc::locked_pointer< T >Templated locked pointer for referencing locked objects of specific type
ucc::locked_releaseAuto-pointer support class for locked objects
ucc::LockedPointerAn object pointer that uses mutex to assure thread-safe singleton use
mapped_array< T >Template class to map typed vector into shared memory
mapped_reuse< T >Template class to map typed resusble objects into shared memory heap
mapped_view< T >Class to access a named mapped segment published from another process
MappedMemoryConstruct or access a named section of memory
MappedReuseMap a reusable allocator over a named shared memory segment
memallocAn alternate memory pager private heap manager
mempagerA managed private heap for small allocations
ucc::memstringA string class that uses a cstring buffer that is fixed in memory
ucc::MemVectorVector with fixed size member list
MultiMapA multipath linked list where membership is managed in multiple lists
multimap< T, P >Embed data objects into a multipap structured memory database
ucc::mutexGeneric non-recursive exclusive lock class
ucc::mutex_pointer< T >Typed smart locked pointer class
named_value< T, O >Templated value class to embed data structure into a named list
NamedObjectA linked object base class with members found by name
NamedTreeThe named tree class is used to form a tree oriented list of associated objects
ObjectA common base class for all managed objects
object_value< T, O >Template for embedding a data structure into a reference counted object
OrderedIndexAn index container for maintaining an ordered list of objects
OrderedObjectA linked object base class for ordered objects
ucc::paged_reuse< T >A reusable private pool of reusable types
pager< T >Mempager managed type factory for pager pool objects
PagerObjectThis is a base class for objects that may be created in pager pools
PagerPoolPager pool base class for managed memory pools
ucc::PagerReuseA mempager source of reusable objects
pointer< T, P >Typed smart pointer class
ucc::queueManage a thread-safe queue of objects through reference pointers
ucc::queueof< T, P >A templated typed class for thread-safe queue of object pointers
ucc::ReusableAllocatorClass for resource bound memory pools between threads
ReusableObjectReusable objects for forming private heaps
ucc::rexlockPortable recursive exclusive lock
ucc::rwlockA generic and portable implimentation of Read/Write locking
sarray< T >Generate a typed sparse managed object array
ucc::semaphoreA portable counting semaphore class
SeqCounterAutomatically return a sequence of untyped objects
sequence< T >A template to return a sequence of objects of a specified type
SharedAn exclusive locking protocol interface base
ucc::shared_instance< T >A templated smart pointer instance for shared singleton typed objects
shared_lockA kind of smart pointer object to support shared locking protocol
ucc::shared_pointer< T >Templated shared pointer for singleton shared objects of specific type
ucc::shared_releaseAuto-pointer support class for shared singleton objects
ucc::SharedObjectShared singleton object
ucc::SharedPointerThe shared pointer is used to manage a singleton instance of shared object
ucc::SocketA generic socket base class
sparse_arrayA sparse array of managed objects
ucc::stackManage a thread-safe stack of objects through reference pointers
ucc::stackof< T, P >A templated typed class for thread-safe stack of object pointers
ucc::stringA copy-on-write string class that operates by reference count
ucc::stringbuf< S >A string class that has a predefined string buffer
ucc::StringFormatA string conversion class for use as a base class in objects which can transform themselves into string representations
TemporaryUsed as base class for temporary objects
temporary< T >Manage temporary object stored on the heap
ucc::ThreadAn abstract class for defining classes that operate as a thread
ucc::TimedEventEvent notification to manage scheduled realtime threads
ucc::TimerTimer class to use when scheduling realtime events
ucc::TimerQueueA timer queue for timer events
toggleAutomatically toggle a bool on each reference
treemap< T >Embed data objects into a tree structured memory database
ucc::VectorA managed vector for generic object pointers
ucc::vectorbuf< T, S >Allocated vector list of a specified type
ucc::vectorof< T >A templated vector for a list of a specific Object subtype
ucc::XMLParserXML streaming parser

Generated on 18 Dec 2009 for UCommon by  doxygen 1.6.1