ucommon
Data Structures
Here are the data structures with brief descriptions:
hostaddr_internetAn object that holds ipv4 or ipv6 binary encoded host addresses
ost::AppLogApplication logger is a class that implements a logger that can be used by applications to save log file somewhere on the system
ost::AppLog::IdentIdent class that represents module name
ost::AppLogExceptionApplog exception, used for memory problems at the moment
ost::BufferThe buffer class represents an IPC service that is built upon a buffer of fixed capacity that can be used to transfer objects between one or more producer and consumer threads
ost::DCCPSocketDCCP sockets are used for stream based connected sessions between two sockets
ost::DirA low level portable directory class
ost::DirTreeA generic class to walk a hierarchical directory structure
ost::DSOThe DSO dynamic loader class is used to load object files
ost::ExceptionMainline exception handler, this is the root for all Common C++ exceptions and assures the ansi C++ exception class hierarchy is both followed and imported into the gnu Common C++ class hierarchy
ost::FixedBufferA buffer class that holds a known capacity of fixed sized objects defined during creation
ost::HEXdumpProduces a dump of a buffer in a hexdump way with its code Ascii translation and relative buffer address
ost::IOExceptionA sub-hierarchy for all Common C++ I/O related classes
ost::IPV4AddressThe network name and address objects are all derived from a common IPV4Address base class
ost::IPV4BroadcastThe broadcast address object is used to store the broadcast address for a specific subnet
ost::IPV4CidrThe CIDR class is used to support routing tables and validate address policies
ost::IPV4HostThis object is used to hold the actual and valid internet address of a specific host machine that will be accessed through a socket
ost::IPV4MaskInternet addresses used specifically as masking addresses (such as " 255.255.255.0") are held in the IPV4Mask derived object
ost::IPV4MulticastA specialization of IPV4Address that provides address validation for multicast addresses
ost::IPV4MulticastValidatorClass for the function object that validates multicast addresses
ost::IPV4ValidatorClasses derived from IPV4Address would require an specific validator to pass to the IPV4Address constructor
ost::IPV6AddressThe network name and address objects are all derived from a common IPV6Address base class
ost::IPV6BroadcastThe broadcast address object is used to store the broadcast address for a specific subnet
ost::IPV6CidrThe CIDR class is used to support routing tables and validate address policies
ost::IPV6HostThis object is used to hold the actual and valid internet address of a specific host machine that will be accessed through a socket
ost::IPV6MaskInternet addresses used specifically as masking addresses (such as " 255.255.255.0") are held in the IPV6Mask derived object
ost::IPV6MulticastA specialization of IPV6Address that provides address validation for multicast addresses
ost::IPV6MulticastValidatorClass for the function object that validates multicast addresses
ost::IPV6ValidatorClasses derived from IPV6Address would require an specific validator to pass to the IPV6Address constructor
ost::LockfileThis class is used to create a "named" lock entity that can be used to control access to a resource between multiple processes
ost::MappedFileCreate and map a disk file into memory
ost::MIMEFormDataThis is a document part type for use in submitting multipart form data to a web server
ost::MIMEItemPartThis is used to attach an item part to a MIME multipart document that is being streamed
ost::MIMEMultipartA container class for multi-part MIME document objects which can be streamed to a std::ostream destination
ost::MIMEMultipartFormThe Multipart form is a MIME multipart document specific for the construction and delivery of form data to a web server through a post method
ost::MutexCounterThe Mutex Counter is a counter variable which can safely be incremented or decremented by multiple threads
ost::MutexLockUsed to protect a section of code so that at any given time only a single thread can perform the protected operation
ost::Pointer< T >Used to create and manage referece counted pointers
ost::ProcessA class for containing portable process related functions that help create portable code
ost::RandomFileThe purpose of this class is to define a base class for low level random file access that is portable between Win32 and Posix systems
ost::ReadLockUsed to protect a section of code through a ThreadLock for "read" access to the member function
ost::SemaphoreLockUsed to protect a section of code through a semaphore so that only x instances of the member function may execute concurrently
ost::SerialUsed as the base for all serial I/O services under APE
ost::SerialPortThe serial port is an internal class which is attached to and then serviced by a specified SerialService thread
ost::SerialServiceThe SerialService is a thead service object that is meant to service attached serial ports
ost::SharedFileThis class defines a database I/O file service that can be shared by multiple processes
ost::SlogThe slog class is used to stream messages to the system's logging facility (syslogd)
ost::StringTokenizerSplits delimited string into tokens
ost::StringTokenizer::iteratorThe input forward iterator for tokens
ost::StringTokenizer::NoSuchElementExceptionException thrown, if someone tried to read beyond the end of the tokens
ost::SyncExceptionA sub-hierarchy for all task synchronizion related exceptions
ost::SysTimeThis class is used to access non-reentrant date and time functions in the standard C library
ost::TCPSessionThe TCP session is used to primarily to represent a client connection that can be managed on a seperate thread
ost::TCPSocketTCP sockets are used for stream based connected sessions between two sockets
ost::TCPStreamTCP streams are used to represent TCP client connections to a server by TCP protocol servers for accepting client connections
ost::TCPV6SocketTCPV6 sockets are used for stream based connected sessions between two ipv6 sockets
ost::ThreadQueueSomewhat generic queue processing class to establish a producer consumer queue
ost::ThrExceptionA sub-hierarchy for thread exceptions
ost::TimerPortTimer ports are used to provide synchronized timing events when managed under a "service thread" such as SocketService
ost::TTYSessionThe TTYSession aggragates a TTYStream and a Common C++ Thread which is assumed to be the execution context that will be used to perform actual I/O operations
ost::ttystreamA more natural C++ "ttystream" class for use by non-threaded applications
ost::TTYStreamTTY streams are used to represent serial connections that are fully "streamable" objects using C++ stream classes and friends
ost::UDPBroadcastRepresenting a UDP socket used for subnet broadcasts, this class provides an alternate binding and setPeer() capability for UDP sockets
ost::UDPDuplexUDP duplex connections impliment a bi-directional point-to-point UDP session between two peer hosts
ost::UDPReceiveRepresenting half of a two-way UDP connection, the UDP receiver can receive data from another peer host or subnet
ost::UDPSocketUDP sockets implement the TCP SOCK_DGRAM UDP protocol
ost::UDPTransmitRepresenting half of a two-way UDP connection, the UDP transmitter can broadcast data to another selected peer host or to an entire subnet
ost::WriteLockUsed to protect a section of code through a ThreadLock for "write" access to the member function
sockaddr_internetAn object that can hold a ipv4 or ipv6 socket address
ucommon::array_pointer< T >Generic smart array class
ucommon::array_reuse< T >An array of reusable types
ucommon::ArrayReuseAn array of reusable objects
ucommon::assoc_pointer< T, I, M, P >A typed template for using a key association with typed objects
ucommon::atomicGeneric atomic class for referencing atomic objects and static functions
ucommon::atomic::counterAtomic counter class
ucommon::atomic::spinlockAtomic spinlock class
ucommon::auto_objectA general purpose smart pointer helper class
ucommon::auto_protectA mutex locked object smart pointer helper class
ucommon::autoreleaseCreate a linked list of auto-releasable objects
ucommon::barrierA portable implimentation of "barrier" thread sychronization
ucommon::bitmapA class to access bit fields in external bitmaps
ucommon::BufferA thread-safe buffer for serializing and streaming class data
ucommon::bufferof< T >A templated typed class for buffering of objects
ucommon::BufferProtocolCommon buffer protocol class
ucommon::bufpagerBuffered pager for storing paged strings for character protocol
ucommon::CharacterProtocolCommon character processing protocol
ucommon::charbuf< S >A template to create a character array that can be manipulated as a string
ucommon::charfileAccess standard files through character protocol
ucommon::cidrA class to hold internet segment routing rules
ucommon::CipherA generic data ciphering class
ucommon::Cipher::KeyCipher key formed by hash algorithm
ucommon::ConditionalThe conditional is a common base for other thread synchronizing classes
ucommon::ConditionalAccessThe conditional rw seperates scheduling for optizming behavior or rw locks
ucommon::ConditionalLockAn optimized and convertable shared lock
ucommon::CountedObjectA base class for reference counted objects
ucommon::counterAutomatic integer counting class
ucommon::DateUses a julian date representation of the current year, month, and day
ucommon::DateNumberA number class that manipulates a string buffer that is also a date
ucommon::DateTimeThe Datetime class uses a julian date representation of the current year, month, and day and a integer representation of the current time
ucommon::DateTimeStringA DateTime string class
ucommon::DetachedThreadA detached thread object that is stand-alone
ucommon::DigestA cryptographic digest class
ucommon::DLinkedObjectA double-linked Object, used for certain kinds of lists
ucommon::exclusive_lockA kind of smart pointer object to support exclusive locking protocol
ucommon::ExclusiveProtocolAn exclusive locking protocol interface base
ucommon::fbufA generic file streaming class built from the buffer protocol
ucommon::filestreamStreamable tcp connection between client and server
ucommon::fsysA container for generic and o/s portable threadsafe file system functions
ucommon::JoinableThreadA child thread object that may be joined by parent
ucommon::keyassocA class to hold memory pointers referenced by string names
ucommon::keydataData keys parsed from a keyfile
ucommon::keydata::keyvalueA key value set is used for iterative access
ucommon::keyfileTraditional keypair config file parsing class
ucommon::keylist< T >A template for ordered index of typed name key mapped objects
ucommon::keymap< T, M >A template class for a hash map
ucommon::keypager< T, M >A template class for a hash pager
ucommon::linked_allocator< T >Linked allocator template to gather linked objects
ucommon::linked_pointer< T >A smart pointer template for iterating linked lists
ucommon::linked_pointer< struct sockaddr >Linked pointer for address lists
ucommon::linked_value< T, O >Template value class to embed data structure into a linked list
ucommon::LinkedAllocatorLinked allocator helper for linked_allocator template
ucommon::LinkedListA double linked list object
ucommon::LinkedObjectCommon base class for all objects that can be formed into a linked list
ucommon::ListenSocketA bound socket used to listen for inbound socket connections
ucommon::locked_instance< T >A templated smart pointer instance for lock protected objects
ucommon::locked_pointer< T >Templated locked pointer for referencing locked objects of specific type
ucommon::locked_releaseAuto-pointer support class for locked objects
ucommon::LockedPointerAn object pointer that uses mutex to assure thread-safe singleton use
ucommon::LockingProtocolCommon locking protocol
ucommon::mapped_array< T >Template class to map typed vector into shared memory
ucommon::mapped_reuse< T >Template class to map typed reusable objects into shared memory heap
ucommon::mapped_view< T >Class to access a named mapped segment published from another process
ucommon::MappedMemoryConstruct or access a named section of memory
ucommon::MappedReuseMap a reusable allocator over a named shared memory segment
ucommon::memallocA memory protocol pager for private heap manager
ucommon::MemoryRedirectA redirection base class for the memory protocol
ucommon::mempagerA managed private heap for small allocations
ucommon::memstringA string class that uses a cstring buffer that is fixed in memory
ucommon::MemVectorVector with fixed size member list
ucommon::MultiMapA multipath linked list where membership is managed in multiple lists
ucommon::multimap< T, P >Embed data objects into a multipap structured memory database
ucommon::MutexGeneric non-recursive exclusive lock class
ucommon::Mutex::gaurdGaurd class to apply scope based mutex locking to objects
ucommon::mutex_pointer< T >Typed smart locked pointer class
ucommon::named_value< T, O >Template value class to embed data structure into a named list
ucommon::NamedObjectA linked object base class with members found by name
ucommon::NamedTreeThe named tree class is used to form a tree oriented list of associated objects
ucommon::NumberA number manipulation class
ucommon::object_pointer< T, P >Typed smart pointer class
ucommon::object_value< T, O >Template for embedding a data structure into a reference counted object
ucommon::ObjectProtocolA common base class for all managed objects
ucommon::ObjectQueueA queue of double linked object
ucommon::objfifo< T >Template for typesafe basic object fifo container
ucommon::objqueue< T >Template for typesafe basic object queue container
ucommon::objstack< T >Template for typesafe basic object stack container
ucommon::OrderedIndexAn index container for maintaining an ordered list of objects
ucommon::OrderedObjectA linked object base class for ordered objects
ucommon::paged_reuse< T >A reusable private pool of reusable types
ucommon::pager< T >Mempager managed type factory for pager pool objects
ucommon::PagerObjectThis is a base class for objects that may be created in pager pools
ucommon::PagerPoolPager pool base class for managed memory pools
ucommon::PagerReuseA mempager source of reusable objects
ucommon::PersistEngineStream serialization of persistent classes
ucommon::PersistObjectPersistObject
ucommon::pipestreamStreamable tcp connection between client and server
ucommon::pointer< T >Generic smart pointer class
ucommon::queueManage a thread-safe queue of objects through reference pointers
ucommon::queueof< T >A templated typed class for thread-safe queue of object pointers
ucommon::RandomCryptographically relevant random numbers
ucommon::RecursiveMutexPortable recursive exclusive lock
ucommon::ReusableAllocatorClass for resource bound memory pools between threads
ucommon::ReusableObjectReusable objects for forming private heaps
ucommon::sarray< T >Generate a typed sparse managed object array
ucommon::save_restore< T >Save and restore global objects in function call stack frames
ucommon::secureCommon secure socket support
ucommon::SemaphoreA portable counting semaphore class
ucommon::SeqCounterAutomatically return a sequence of untyped objects
ucommon::sequence< T >A template to return a sequence of objects of a specified type
ucommon::shared_instance< T >A templated smart pointer instance for shared singleton typed objects
ucommon::shared_lockA kind of smart pointer object to support shared locking protocol
ucommon::shared_pointer< T >Templated shared pointer for singleton shared objects of specific type
ucommon::shared_releaseAuto-pointer support class for shared singleton objects
ucommon::SharedObjectShared singleton object
ucommon::SharedPointerThe shared pointer is used to manage a singleton instance of shared object
ucommon::SharedProtocolAn exclusive locking protocol interface base
ucommon::SocketA generic socket base class
ucommon::Socket::addressA generic socket address class
ucommon::sparse_arrayA sparse array of managed objects
ucommon::SSLBufferSecure socket buffer
ucommon::sstreamSecure socket using std::iostream
ucommon::stackManage a thread-safe stack of objects through reference pointers
ucommon::stackof< T >A templated typed class for thread-safe stack of object pointers
ucommon::StreamProtocolCommon stream protocol for std C++ i/o classes
ucommon::stringA copy-on-write string class that operates by reference count
ucommon::string::cstringThis is an internal class which contains the actual string data along with some control fields
ucommon::stringbuf< S >A string class that has a predefined string buffer
ucommon::stringpagerString pager for storing lists of NULL terminated strings
ucommon::stringpager::memberMember of string list
ucommon::TCPBufferA generic tcp socket class that offers i/o buffering
ucommon::TCPServerA generic tcp server class
ucommon::tcpstreamStreamable tcp connection between client and server
ucommon::temp_array< T >Manage temporary array stored on the heap
ucommon::temporary< T >Manage temporary object stored on the heap
ucommon::ThreadAn abstract class for defining classes that operate as a thread
ucommon::ThreadLockA generic and portable implimentation of Read/Write locking
ucommon::ThreadLock::gaurd_readerGaurd class to apply scope based access locking to objects
ucommon::ThreadLock::gaurd_writerGaurd class to apply scope based exclusive locking to objects
ucommon::TimeUses a integer representation of the current time
ucommon::TimedEventEvent notification to manage scheduled realtime threads
ucommon::TimerTimer class to use when scheduling realtime events
ucommon::TimerQueueA timer queue for timer events
ucommon::TimerQueue::eventA timer event object that lives on a timer queue
ucommon::toggleAutomatically toggle a bool on each reference
ucommon::treemap< T >Embed data objects into a tree structured memory database
ucommon::TypeManagerType manager for persistence engine
ucommon::TypeManager::registrationThis manages a registration to the typemanager - attempting to remove problems with the optimizers
ucommon::UStringA copy-on-write utf8 string class that operates by reference count
ucommon::utf8A core class of ut8 encoded string functions
ucommon::utf8_pointerPointer to utf8 encoded character data
ucommon::VectorA managed vector for generic object pointers
ucommon::vectorbuf< T, S >Allocated vector list of a specified type
ucommon::vectorof< T >A templated vector for a list of a specific Object subtype
ucommon::XMLParserXML streaming parser
ucommon::ZNumberA number manipulation class that maintains a zero lead filled string