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
ucc::assoc_pointer< T, I, M, P >A typed template for using a key association with typed objects
ucc::auto_deleteA helper class for the temporary object template
ucc::auto_pointerA general purpose smart pointer helper class
ucc::auto_protectA mutex locked object smart pointer helper class
ucc::autoreleaseCreate a linked list of auto-releasable objects
ucc::barrierA portable implimentation of "barrier" thread sychronization
ucc::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
ucc::CountedObjectA base class for reference counted objects
ucc::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
ucc::ExclusiveAn exclusive locking protocol interface base
ucc::exclusive_lockA kind of smart pointer object to support exclusive locking protocol
ucc::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
ucc::keyassocA class to hold memory pointers referenced by string names
ucc::keydataData keys parsed from a keyfile
ucc::keyfileTraditional keypair config file parsing class
ucc::keylist< T >A template for ordered index of typed name key mapped objects
ucc::keymap< T, M >A templated class for a hash map
ucc::keydata::keyvalueA key value set is used for iterative access
ucc::linked_pointer< T >A templated smart pointer for iterating linked lists
ucc::linked_value< T, O >Templated value class to embed data structure into a linked list
ucc::LinkedListA double linked list object
ucc::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
ucc::mapped_array< T >Template class to map typed vector into shared memory
ucc::mapped_reuse< T >Template class to map typed resusble objects into shared memory heap
ucc::mapped_view< T >Class to access a named mapped segment published from another process
ucc::MappedMemoryConstruct or access a named section of memory
ucc::MappedReuseMap a reusable allocator over a named shared memory segment
ucc::memallocAn alternate memory pager private heap manager
ucc::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
ucc::MultiMapA multipath linked list where membership is managed in multiple lists
ucc::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
ucc::named_value< T, O >Templated value class to embed data structure into a named list
ucc::NamedObjectA linked object base class with members found by name
ucc::NamedTreeThe named tree class is used to form a tree oriented list of associated objects
ucc::ObjectA common base class for all managed objects
ucc::object_value< T, O >Template for embedding a data structure into a reference counted object
ucc::OrderedIndexAn index container for maintaining an ordered list of objects
ucc::OrderedObjectA linked object base class for ordered objects
ucc::paged_reuse< T >A reusable private pool of reusable types
ucc::pager< T >Mempager managed type factory for pager pool objects
ucc::PagerObjectThis is a base class for objects that may be created in pager pools
ucc::PagerPoolPager pool base class for managed memory pools
ucc::PagerReuseA mempager source of reusable objects
ucc::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
ucc::ReusableObjectReusable objects for forming private heaps
ucc::rexlockPortable recursive exclusive lock
ucc::rwlockA generic and portable implimentation of Read/Write locking
ucc::sarray< T >Generate a typed sparse managed object array
ucc::semaphoreA portable counting semaphore class
ucc::SeqCounterAutomatically return a sequence of untyped objects
ucc::sequence< T >A template to return a sequence of objects of a specified type
ucc::SharedAn exclusive locking protocol interface base
ucc::shared_instance< T >A templated smart pointer instance for shared singleton typed objects
ucc::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
ucc::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
ucc::temporary< T >Manage temporary object stored on the heap
ucc::TemporaryUsed as base class for temporary objects
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
ucc::toggleAutomatically toggle a bool on each reference
ucc::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 Tue Jul 28 21:43:39 2009 for UCommon by  doxygen 1.5.9