| hostaddr_internet | An object that holds ipv4 or ipv6 binary encoded host addresses |
| ost::AppLog | Application logger is a class that implements a logger that can be used by applications to save log file somewhere on the system |
| ost::AppLog::Ident | Ident class that represents module name |
| ost::AppLogException | Applog exception, used for memory problems at the moment |
| ost::Buffer | The 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::DCCPSocket | DCCP sockets are used for stream based connected sessions between two sockets |
| ost::Dir | A low level portable directory class |
| ost::DirTree | A generic class to walk a hierarchical directory structure |
| ost::DSO | The DSO dynamic loader class is used to load object files |
| ost::Exception | Mainline 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::FixedBuffer | A buffer class that holds a known capacity of fixed sized objects defined during creation |
| ost::HEXdump | Produces a dump of a buffer in a hexdump way with its code Ascii translation and relative buffer address |
| ost::IOException | A sub-hierarchy for all Common C++ I/O related classes |
| ost::IPV4Address | The network name and address objects are all derived from a common IPV4Address base class |
| ost::IPV4Broadcast | The broadcast address object is used to store the broadcast address for a specific subnet |
| ost::IPV4Cidr | The CIDR class is used to support routing tables and validate address policies |
| ost::IPV4Host | This object is used to hold the actual and valid internet address of a specific host machine that will be accessed through a socket |
| ost::IPV4Mask | Internet addresses used specifically as masking addresses (such as "
255.255.255.0") are held in the IPV4Mask derived object |
| ost::IPV4Multicast | A specialization of IPV4Address that provides address validation for multicast addresses |
| ost::IPV4MulticastValidator | Class for the function object that validates multicast addresses |
| ost::IPV4Validator | Classes derived from IPV4Address would require an specific validator to pass to the IPV4Address constructor |
| ost::IPV6Address | The network name and address objects are all derived from a common IPV6Address base class |
| ost::IPV6Broadcast | The broadcast address object is used to store the broadcast address for a specific subnet |
| ost::IPV6Cidr | The CIDR class is used to support routing tables and validate address policies |
| ost::IPV6Host | This object is used to hold the actual and valid internet address of a specific host machine that will be accessed through a socket |
| ost::IPV6Mask | Internet addresses used specifically as masking addresses (such as "
255.255.255.0") are held in the IPV6Mask derived object |
| ost::IPV6Multicast | A specialization of IPV6Address that provides address validation for multicast addresses |
| ost::IPV6MulticastValidator | Class for the function object that validates multicast addresses |
| ost::IPV6Validator | Classes derived from IPV6Address would require an specific validator to pass to the IPV6Address constructor |
| ost::Lockfile | This class is used to create a "named" lock entity that can be used to control access to a resource between multiple processes |
| ost::MappedFile | Create and map a disk file into memory |
| ost::MIMEFormData | This is a document part type for use in submitting multipart form data to a web server |
| ost::MIMEItemPart | This is used to attach an item part to a MIME multipart document that is being streamed |
| ost::MIMEMultipart | A container class for multi-part MIME document objects which can be streamed to a std::ostream destination |
| ost::MIMEMultipartForm | The 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::MutexCounter | The Mutex Counter is a counter variable which can safely be incremented or decremented by multiple threads |
| ost::MutexLock | Used 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::Process | A class for containing portable process related functions that help create portable code |
| ost::RandomFile | The 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::ReadLock | Used to protect a section of code through a ThreadLock for "read" access to the member function |
| ost::SemaphoreLock | Used to protect a section of code through a semaphore so that only x instances of the member function may execute concurrently |
| ost::Serial | Used as the base for all serial I/O services under APE |
| ost::SerialPort | The serial port is an internal class which is attached to and then serviced by a specified SerialService thread |
| ost::SerialService | The SerialService is a thead service object that is meant to service attached serial ports |
| ost::SharedFile | This class defines a database I/O file service that can be shared by multiple processes |
| ost::Slog | The slog class is used to stream messages to the system's logging facility (syslogd) |
| ost::StringTokenizer | Splits delimited string into tokens |
| ost::StringTokenizer::iterator | The input forward iterator for tokens |
| ost::StringTokenizer::NoSuchElementException | Exception thrown, if someone tried to read beyond the end of the tokens |
| ost::SyncException | A sub-hierarchy for all task synchronizion related exceptions |
| ost::SysTime | This class is used to access non-reentrant date and time functions in the standard C library |
| ost::TCPSession | The TCP session is used to primarily to represent a client connection that can be managed on a seperate thread |
| ost::TCPSocket | TCP sockets are used for stream based connected sessions between two sockets |
| ost::TCPStream | TCP streams are used to represent TCP client connections to a server by TCP protocol servers for accepting client connections |
| ost::TCPV6Socket | TCPV6 sockets are used for stream based connected sessions between two ipv6 sockets |
| ost::ThreadQueue | Somewhat generic queue processing class to establish a producer consumer queue |
| ost::ThrException | A sub-hierarchy for thread exceptions |
| ost::TimerPort | Timer ports are used to provide synchronized timing events when managed under a "service thread" such as SocketService |
| ost::TTYSession | The 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::ttystream | A more natural C++ "ttystream" class for use by non-threaded applications |
| ost::TTYStream | TTY streams are used to represent serial connections that are fully "streamable" objects using C++ stream classes and friends |
| ost::UDPBroadcast | Representing a UDP socket used for subnet broadcasts, this class provides an alternate binding and setPeer() capability for UDP sockets |
| ost::UDPDuplex | UDP duplex connections impliment a bi-directional point-to-point UDP session between two peer hosts |
| ost::UDPReceive | Representing half of a two-way UDP connection, the UDP receiver can receive data from another peer host or subnet |
| ost::UDPSocket | UDP sockets implement the TCP SOCK_DGRAM UDP protocol |
| ost::UDPTransmit | Representing half of a two-way UDP connection, the UDP transmitter can broadcast data to another selected peer host or to an entire subnet |
| ost::WriteLock | Used to protect a section of code through a ThreadLock for "write" access to the member function |
| sockaddr_internet | An 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::ArrayReuse | An array of reusable objects |
| ucommon::assoc_pointer< T, I, M, P > | A typed template for using a key association with typed objects |
| ucommon::atomic | Generic atomic class for referencing atomic objects and static functions |
| ucommon::atomic::counter | Atomic counter class |
| ucommon::atomic::spinlock | Atomic spinlock class |
| ucommon::auto_object | A general purpose smart pointer helper class |
| ucommon::auto_protect | A mutex locked object smart pointer helper class |
| ucommon::autorelease | Create a linked list of auto-releasable objects |
| ucommon::barrier | A portable implimentation of "barrier" thread sychronization |
| ucommon::bitmap | A class to access bit fields in external bitmaps |
| ucommon::Buffer | A thread-safe buffer for serializing and streaming class data |
| ucommon::bufferof< T > | A templated typed class for buffering of objects |
| ucommon::BufferProtocol | Common buffer protocol class |
| ucommon::bufpager | Buffered pager for storing paged strings for character protocol |
| ucommon::CharacterProtocol | Common character processing protocol |
| ucommon::charbuf< S > | A template to create a character array that can be manipulated as a string |
| ucommon::charfile | Access standard files through character protocol |
| ucommon::cidr | A class to hold internet segment routing rules |
| ucommon::Cipher | A generic data ciphering class |
| ucommon::Cipher::Key | Cipher key formed by hash algorithm |
| ucommon::Conditional | The conditional is a common base for other thread synchronizing classes |
| ucommon::ConditionalAccess | The conditional rw seperates scheduling for optizming behavior or rw locks |
| ucommon::ConditionalLock | An optimized and convertable shared lock |
| ucommon::CountedObject | A base class for reference counted objects |
| ucommon::counter | Automatic integer counting class |
| ucommon::Date | Uses a julian date representation of the current year, month, and day |
| ucommon::DateNumber | A number class that manipulates a string buffer that is also a date |
| ucommon::DateTime | The Datetime class uses a julian date representation of the current year, month, and day and a integer representation of the current time |
| ucommon::DateTimeString | A DateTime string class |
| ucommon::DetachedThread | A detached thread object that is stand-alone |
| ucommon::Digest | A cryptographic digest class |
| ucommon::DLinkedObject | A double-linked Object, used for certain kinds of lists |
| ucommon::exclusive_lock | A kind of smart pointer object to support exclusive locking protocol |
| ucommon::ExclusiveProtocol | An exclusive locking protocol interface base |
| ucommon::fbuf | A generic file streaming class built from the buffer protocol |
| ucommon::filestream | Streamable tcp connection between client and server |
| ucommon::fsys | A container for generic and o/s portable threadsafe file system functions |
| ucommon::JoinableThread | A child thread object that may be joined by parent |
| ucommon::keyassoc | A class to hold memory pointers referenced by string names |
| ucommon::keydata | Data keys parsed from a keyfile |
| ucommon::keydata::keyvalue | A key value set is used for iterative access |
| ucommon::keyfile | Traditional 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::LinkedAllocator | Linked allocator helper for linked_allocator template |
| ucommon::LinkedList | A double linked list object |
| ucommon::LinkedObject | Common base class for all objects that can be formed into a linked list |
| ucommon::ListenSocket | A 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_release | Auto-pointer support class for locked objects |
| ucommon::LockedPointer | An object pointer that uses mutex to assure thread-safe singleton use |
| ucommon::LockingProtocol | Common 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::MappedMemory | Construct or access a named section of memory |
| ucommon::MappedReuse | Map a reusable allocator over a named shared memory segment |
| ucommon::memalloc | A memory protocol pager for private heap manager |
| ucommon::MemoryRedirect | A redirection base class for the memory protocol |
| ucommon::mempager | A managed private heap for small allocations |
| ucommon::memstring | A string class that uses a cstring buffer that is fixed in memory |
| ucommon::MemVector | Vector with fixed size member list |
| ucommon::MultiMap | A multipath linked list where membership is managed in multiple lists |
| ucommon::multimap< T, P > | Embed data objects into a multipap structured memory database |
| ucommon::Mutex | Generic non-recursive exclusive lock class |
| ucommon::Mutex::gaurd | Gaurd 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::NamedObject | A linked object base class with members found by name |
| ucommon::NamedTree | The named tree class is used to form a tree oriented list of associated objects |
| ucommon::Number | A 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::ObjectProtocol | A common base class for all managed objects |
| ucommon::ObjectQueue | A 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::OrderedIndex | An index container for maintaining an ordered list of objects |
| ucommon::OrderedObject | A 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::PagerObject | This is a base class for objects that may be created in pager pools |
| ucommon::PagerPool | Pager pool base class for managed memory pools |
| ucommon::PagerReuse | A mempager source of reusable objects |
| ucommon::PersistEngine | Stream serialization of persistent classes |
| ucommon::PersistObject | PersistObject |
| ucommon::pipestream | Streamable tcp connection between client and server |
| ucommon::pointer< T > | Generic smart pointer class |
| ucommon::queue | Manage a thread-safe queue of objects through reference pointers |
| ucommon::queueof< T > | A templated typed class for thread-safe queue of object pointers |
| ucommon::Random | Cryptographically relevant random numbers |
| ucommon::RecursiveMutex | Portable recursive exclusive lock |
| ucommon::ReusableAllocator | Class for resource bound memory pools between threads |
| ucommon::ReusableObject | Reusable 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::secure | Common secure socket support |
| ucommon::Semaphore | A portable counting semaphore class |
| ucommon::SeqCounter | Automatically 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_lock | A 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_release | Auto-pointer support class for shared singleton objects |
| ucommon::SharedObject | Shared singleton object |
| ucommon::SharedPointer | The shared pointer is used to manage a singleton instance of shared object |
| ucommon::SharedProtocol | An exclusive locking protocol interface base |
| ucommon::Socket | A generic socket base class |
| ucommon::Socket::address | A generic socket address class |
| ucommon::sparse_array | A sparse array of managed objects |
| ucommon::SSLBuffer | Secure socket buffer |
| ucommon::sstream | Secure socket using std::iostream |
| ucommon::stack | Manage a thread-safe stack of objects through reference pointers |
| ucommon::stackof< T > | A templated typed class for thread-safe stack of object pointers |
| ucommon::StreamProtocol | Common stream protocol for std C++ i/o classes |
| ucommon::string | A copy-on-write string class that operates by reference count |
| ucommon::string::cstring | This 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::stringpager | String pager for storing lists of NULL terminated strings |
| ucommon::stringpager::member | Member of string list |
| ucommon::TCPBuffer | A generic tcp socket class that offers i/o buffering |
| ucommon::TCPServer | A generic tcp server class |
| ucommon::tcpstream | Streamable 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::Thread | An abstract class for defining classes that operate as a thread |
| ucommon::ThreadLock | A generic and portable implimentation of Read/Write locking |
| ucommon::ThreadLock::gaurd_reader | Gaurd class to apply scope based access locking to objects |
| ucommon::ThreadLock::gaurd_writer | Gaurd class to apply scope based exclusive locking to objects |
| ucommon::Time | Uses a integer representation of the current time |
| ucommon::TimedEvent | Event notification to manage scheduled realtime threads |
| ucommon::Timer | Timer class to use when scheduling realtime events |
| ucommon::TimerQueue | A timer queue for timer events |
| ucommon::TimerQueue::event | A timer event object that lives on a timer queue |
| ucommon::toggle | Automatically toggle a bool on each reference |
| ucommon::treemap< T > | Embed data objects into a tree structured memory database |
| ucommon::TypeManager | Type manager for persistence engine |
| ucommon::TypeManager::registration | This manages a registration to the typemanager - attempting to remove problems with the optimizers |
| ucommon::UString | A copy-on-write utf8 string class that operates by reference count |
| ucommon::utf8 | A core class of ut8 encoded string functions |
| ucommon::utf8_pointer | Pointer to utf8 encoded character data |
| ucommon::Vector | A 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::XMLParser | XML streaming parser |
| ucommon::ZNumber | A number manipulation class that maintains a zero lead filled string |
