\section{ost Namespace Reference}
\label{namespaceost}\index{ost@{ost}}
\subsection*{Classes}
\begin{CompactItemize}
\item
class {\bf IPV4Validator}
\begin{CompactList}\small\item\em Classes derived from {\bf IPV4Address}{\rm (p.\,\pageref{classost_1_1_i_p_v4_address})} would require an specific validator to pass to the {\bf IPV4Address}{\rm (p.\,\pageref{classost_1_1_i_p_v4_address})} constructor.Abstract base class for derived inet addresses validators. \item\end{CompactList}\item
class {\bf IPV4Multicast\-Validator}
\begin{CompactList}\small\item\em Class for the function object that validates multicast addresses.Validating class specialized for multicast addresses. \item\end{CompactList}\item
class {\bf IPV4Address}
\begin{CompactList}\small\item\em The network name and address objects are all derived from a common {\bf IPV4Address}{\rm (p.\,\pageref{classost_1_1_i_p_v4_address})} base class.Internet Address binary data type. \item\end{CompactList}\item
class {\bf IPV4Mask}
\begin{CompactList}\small\item\em Internet addresses used specifically as masking addresses (such as \char`\"{} 255.255.255.0\char`\"{}) are held in the {\bf IPV4Mask}{\rm (p.\,\pageref{classost_1_1_i_p_v4_mask})} derived object.Internet Address Mask such as subnet masks. \item\end{CompactList}\item
class {\bf IPV4Host}
\begin{CompactList}\small\item\em This object is used to hold the actual and valid internet address of a specific host machine that will be accessed through a socket.Address of a specific Internet host machine. \item\end{CompactList}\item
class {\bf IPV4Broadcast}
\begin{CompactList}\small\item\em The broadcast address object is used to store the broadcast address for a specific subnet. \item\end{CompactList}\item
class {\bf IPV4Multicast}
\begin{CompactList}\small\item\em A specialization of {\bf IPV4Address}{\rm (p.\,\pageref{classost_1_1_i_p_v4_address})} that provides address validation for multicast addresses.A multicast network address. \item\end{CompactList}\item
class {\bf IPV6Validator}
\begin{CompactList}\small\item\em Classes derived from {\bf IPV6Address}{\rm (p.\,\pageref{classost_1_1_i_p_v6_address})} would require an specific validator to pass to the {\bf IPV6Address}{\rm (p.\,\pageref{classost_1_1_i_p_v6_address})} constructor.Abstract base class for derived inet addresses validators. \item\end{CompactList}\item
class {\bf IPV6Multicast\-Validator}
\begin{CompactList}\small\item\em Class for the function object that validates multicast addresses.Validating class specialized for multicast addresses. \item\end{CompactList}\item
class {\bf IPV6Address}
\begin{CompactList}\small\item\em The network name and address objects are all derived from a common {\bf IPV6Address}{\rm (p.\,\pageref{classost_1_1_i_p_v6_address})} base class.Internet Address binary data type. \item\end{CompactList}\item
class {\bf IPV6Mask}
\begin{CompactList}\small\item\em Internet addresses used specifically as masking addresses (such as \char`\"{} 255.255.255.0\char`\"{}) are held in the {\bf IPV6Mask}{\rm (p.\,\pageref{classost_1_1_i_p_v6_mask})} derived object.Internet Address Mask such as subnet masks. \item\end{CompactList}\item
class {\bf IPV6Host}
\begin{CompactList}\small\item\em This object is used to hold the actual and valid internet address of a specific host machine that will be accessed through a socket.Address of a specific Internet host machine. \item\end{CompactList}\item
class {\bf IPV6Broadcast}
\begin{CompactList}\small\item\em The broadcast address object is used to store the broadcast address for a specific subnet. \item\end{CompactList}\item
class {\bf IPV6Multicast}
\begin{CompactList}\small\item\em A specialization of {\bf IPV6Address}{\rm (p.\,\pageref{classost_1_1_i_p_v6_address})} that provides address validation for multicast addresses.A multicast network address. \item\end{CompactList}\item
class {\bf Buffer}
\begin{CompactList}\small\item\em 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.Producer/Consumer buffer for use between threads. \item\end{CompactList}\item
class {\bf Fixed\-Buffer}
\begin{CompactList}\small\item\em A buffer class that holds a known capacity of fixed sized objects defined during creation.producer/consumer buffer for fixed size objects. \item\end{CompactList}\item
class {\bf Thread\-Queue}
\begin{CompactList}\small\item\em Somewhat generic queue processing class to establish a producer consumer queue.in memory data queue interface. \item\end{CompactList}\item
class {\bf Command\-Option}
\begin{CompactList}\small\item\em {\bf Command\-Option}{\rm (p.\,\pageref{classost_1_1_command_option})} is the base class for all command line options. \item\end{CompactList}\item
class {\bf Command\-Option\-With\-Arg}
\begin{CompactList}\small\item\em Derived class of {\bf Command\-Option}{\rm (p.\,\pageref{classost_1_1_command_option})} for options that have a value associated with them. \item\end{CompactList}\item
class {\bf Command\-Option\-Arg}
\begin{CompactList}\small\item\em Class for options with an argument e.g. \item\end{CompactList}\item
class {\bf Command\-Option\-Rest}
\begin{CompactList}\small\item\em It only makes sense to have a single one of these set and it is exclusive with {\bf Command\-Option\-Collect.Command\-Option}{\rm (p.\,\pageref{classost_1_1_command_option_989bf900aed6323812ae6922edcdc4af})} to take the rest of the command line. \item\end{CompactList}\item
class {\bf Command\-Option\-Collect}
\begin{CompactList}\small\item\em It only makes sense to have a single one of these set and it is also exclusive with {\bf Command\-Option\-Rest.Command\-Option}{\rm (p.\,\pageref{classost_1_1_command_option_989bf900aed6323812ae6922edcdc4af})} to collect parameters that are not options. \item\end{CompactList}\item
class {\bf Command\-Option\-No\-Arg}
\begin{CompactList}\small\item\em {\bf Command\-Option}{\rm (p.\,\pageref{classost_1_1_command_option})} type for flags. \item\end{CompactList}\item
class {\bf Command\-Option\-Parse}
\begin{CompactList}\small\item\em This is the {\bf Command\-Option\-Parse}{\rm (p.\,\pageref{classost_1_1_command_option_parse})} interface class. \item\end{CompactList}\item
class {\bf Counter}
\begin{CompactList}\small\item\em The counter template is used for generic objects which act as automatic counters.Automatic counter template class. \item\end{CompactList}\item
class {\bf Digest}
\begin{CompactList}\small\item\em The digest base class is used for implementing and deriving one way hashing functions.base class for hashing services. \item\end{CompactList}\item
class {\bf Checksum\-Digest}
\begin{CompactList}\small\item\em A simple checksum digest function.checksum hash function. \item\end{CompactList}\item
class {\bf CRC16Digest}
\begin{CompactList}\small\item\em A crc16 collection/compution hash accumulator class.crc16 computation hash. \item\end{CompactList}\item
class {\bf CRC32Digest}
\begin{CompactList}\small\item\em A crc32 collection/computation hash accumulator class.crc32 computation hash. \item\end{CompactList}\item
class {\bf MD5Digest}
\begin{CompactList}\small\item\em A md5 collection/computation accululator class.md5 hash accumulation. \item\end{CompactList}\item
class {\bf File}
\item
class {\bf Dir}
\begin{CompactList}\small\item\em A low level portable directory class.low level directory access class. \item\end{CompactList}\item
class {\bf Dir\-Tree}
\begin{CompactList}\small\item\em A generic class to walk a hierarchical directory structure.Directory tree walking. \item\end{CompactList}\item
class {\bf Random\-File}
\begin{CompactList}\small\item\em 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.Portable random disk file access. \item\end{CompactList}\item
class {\bf Thread\-File}
\begin{CompactList}\small\item\em This class defines a database I/O file service that can be shared by multiple threads.This class defines a database I/O file service that can be shared by multiple threads. \item\end{CompactList}\item
class {\bf Shared\-File}
\begin{CompactList}\small\item\em This class defines a database I/O file service that can be shared by multiple processes.This class defines a database I/O file service that can be shared by multiple processes. \item\end{CompactList}\item
class {\bf Mapped\-File}
\begin{CompactList}\small\item\em Create and map a disk file into memory.Map a named disk file into memory. \item\end{CompactList}\item
class {\bf DSO}
\begin{CompactList}\small\item\em The {\bf DSO}{\rm (p.\,\pageref{classost_1_1_d_s_o})} dynamic loader class is used to load object files.Dynamic class file loader. \item\end{CompactList}\item
class {\bf MIMEMultipart}
\begin{CompactList}\small\item\em A container class for multi-part MIME document objects which can be streamed to a std::ostream destination.container for streamable multi-part MIME documents. \item\end{CompactList}\item
class {\bf MIMEMultipart\-Form}
\begin{CompactList}\small\item\em 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.deliver form results as multipart document. \item\end{CompactList}\item
class {\bf MIMEItem\-Part}
\begin{CompactList}\small\item\em This is used to attach an item part to a MIME multipart document that is being streamed.item or part of a multi-part object. \item\end{CompactList}\item
class {\bf MIMEForm\-Data}
\begin{CompactList}\small\item\em This is a document part type for use in submitting multipart form data to a web server.multipart document part for web form data field. \item\end{CompactList}\item
class {\bf Mem\-Pager}
\begin{CompactList}\small\item\em The memory pager is used to allocate cumulative memory pages for storing object specific \char`\"{}persistant\char`\"{} data that is presumed to persist during the life of a given derived object.Accumulative object memory allocator. \item\end{CompactList}\item
class {\bf Stack\-Pager}
\begin{CompactList}\small\item\em The {\bf Stack\-Pager}{\rm (p.\,\pageref{classost_1_1_stack_pager})} provides a repository to stash and retrieve working data in last-in-first-out order.last in first out object pager. \item\end{CompactList}\item
class {\bf Shared\-Mem\-Pager}
\begin{CompactList}\small\item\em The shared mempager uses a mutex to protect key access methods.mutex protected memory pager. \item\end{CompactList}\item
class {\bf Keydata}
\begin{CompactList}\small\item\em {\bf Keydata}{\rm (p.\,\pageref{classost_1_1_keydata})} objects are used to load and hold \char`\"{}configuration\char`\"{} data for a given application.load text configuration files into keyword pairs. \item\end{CompactList}\item
class {\bf Mem\-Pager\-Object}
\begin{CompactList}\small\item\em This class is used to create derived classes which are constructed within a memory pager pool.create objects in a memory pager. \item\end{CompactList}\item
class {\bf Assoc}
\begin{CompactList}\small\item\em This class is used to associate (object) pointers with named strings.associate names with pointers. \item\end{CompactList}\item
class {\bf Runlist}
\begin{CompactList}\small\item\em A runlist is used to restrict concurrent exection to a limited set of concurrent sessions, much like a semaphore.list of runable objects. \item\end{CompactList}\item
class {\bf Runable}
\begin{CompactList}\small\item\em A container for objects that can be queued against a runlist.runable object with notify when ready. \item\end{CompactList}\item
class {\bf Network\-Device\-Info}
\begin{CompactList}\small\item\em Network device information class. \item\end{CompactList}\item
class {\bf Number}
\begin{CompactList}\small\item\em A number manipulation class.number manipulation. \item\end{CompactList}\item
class {\bf ZNumber}
\item
class {\bf Date}
\begin{CompactList}\small\item\em The {\bf Date}{\rm (p.\,\pageref{classost_1_1_date})} class uses a julian date representation of the current year, month, and day.julian number based date class. \item\end{CompactList}\item
class {\bf Time}
\begin{CompactList}\small\item\em The {\bf Time}{\rm (p.\,\pageref{classost_1_1_time})} class uses a integer representation of the current time.Integer based time class. \item\end{CompactList}\item
class {\bf Datetime}
\begin{CompactList}\small\item\em The {\bf Datetime}{\rm (p.\,\pageref{classost_1_1_datetime})} class uses a julian date representation of the current year, month, and day and a integer representation of the current time.Integer based time class. \item\end{CompactList}\item
class {\bf Date\-Number}
\begin{CompactList}\small\item\em A number class that manipulates a string buffer that is also a date.a number that is also a date string. \item\end{CompactList}\item
class {\bf obj\-Counter}
\begin{CompactList}\small\item\em Generic template class for creating classes which maintain an active count of the number of instances currently in active use.Object instance global reference count. \item\end{CompactList}\item
class {\bf Ref\-Object}
\begin{CompactList}\small\item\em A reference countable object.Object managed by smart pointer reference count. \item\end{CompactList}\item
class {\bf Ref\-Pointer}
\begin{CompactList}\small\item\em {\bf Pointer}{\rm (p.\,\pageref{classost_1_1_pointer})} to reference counted objects.Pointer to reference count managed objects. \item\end{CompactList}\item
class {\bf Linked\-Single}
\begin{CompactList}\small\item\em Self managed single linked list object chain.Accumulating single linked list. \item\end{CompactList}\item
class {\bf Linked\-Double}
\begin{CompactList}\small\item\em Self managed double linked list object chain.Accumulating double linked list. \item\end{CompactList}\item
class {\bf Map\-Table}
\begin{CompactList}\small\item\em A map table allows for entities to be mapped (hash index) onto it.Table to hold hash indexed objects. \item\end{CompactList}\item
class {\bf Map\-Object}
\begin{CompactList}\small\item\em The {\bf Map\-Object}{\rm (p.\,\pageref{classost_1_1_map_object})} is a base class which can be used to make a derived class operate on a Map\-Table.Mappable object. \item\end{CompactList}\item
class {\bf obj\-List}
\begin{CompactList}\small\item\em Used to create and manage a single linked list of objects of a common type.single linked list searchable template chain. \item\end{CompactList}\item
class {\bf obj\-Map}
\begin{CompactList}\small\item\em Used to create and manage a hash index of objects through a common type.hash indexed searchable template chain. \item\end{CompactList}\item
class {\bf key\-Map}
\item
class {\bf obj\-Sync}
\begin{CompactList}\small\item\em Generic template to create objects of a common base type which share a static mutex so that all instances of the class have a global lock.global mutex locked class. \item\end{CompactList}\item
struct {\bf cistring\_\-char\_\-traits}
\item
class {\bf Type\-Manager}
\begin{CompactList}\small\item\em This class manages the types for generation of the persistent objects.Type manager for persistence engine. \item\end{CompactList}\item
class {\bf Base\-Object}
\begin{CompactList}\small\item\em Base\-Object\-Base class for classes that will be persistent. \item\end{CompactList}\item
class {\bf Engine}
\begin{CompactList}\small\item\em Enginestream serialization of persistent classes. \item\end{CompactList}\item
class {\bf Pointer}
\begin{CompactList}\small\item\em Used to create and manage referece counted pointers.reference counted pointer template. \item\end{CompactList}\item
class {\bf Process}
\begin{CompactList}\small\item\em A class for containing portable process related functions that help create portable code.Peocess wrapper class. \item\end{CompactList}\item
class {\bf Lockfile}
\begin{CompactList}\small\item\em This class is used to create a \char`\"{}named\char`\"{} lock entity that can be used to control access to a resource between multiple processes.System-wide named lock. \item\end{CompactList}\item
class {\bf Serial}
\begin{CompactList}\small\item\em The {\bf Serial}{\rm (p.\,\pageref{classost_1_1_serial})} class is used as the base for all serial I/O services under APE.base class for all serial I/O services. \item\end{CompactList}\item
class {\bf TTYStream}
\begin{CompactList}\small\item\em TTY streams are used to represent serial connections that are fully \char`\"{}streamable\char`\"{} objects using C++ stream classes and friends.streamable tty serial I/O class. \item\end{CompactList}\item
class {\bf ttystream}
\begin{CompactList}\small\item\em A more natural C++ \char`\"{}ttystream\char`\"{} class for use by non-threaded applications.C++ \char`\"{}fstream\char`\"{} style ttystream class. \item\end{CompactList}\item
class {\bf TTYSession}
\begin{CompactList}\small\item\em The {\bf TTYSession}{\rm (p.\,\pageref{classost_1_1_t_t_y_session})} aggragates a {\bf TTYStream}{\rm (p.\,\pageref{classost_1_1_t_t_y_stream})} and a Common C++ {\bf Thread}{\rm (p.\,\pageref{classost_1_1_thread})} which is assumed to be the execution context that will be used to perform actual I/O operations.This class is very anagolous to {\bf TCPSession}{\rm (p.\,\pageref{classost_1_1_t_c_p_session})}. \item\end{CompactList}\item
class {\bf Serial\-Port}
\begin{CompactList}\small\item\em The serial port is an internal class which is attached to and then serviced by a specified {\bf Serial\-Service}{\rm (p.\,\pageref{classost_1_1_serial_service})} thread.base class for thread pool serviced serial I/O. \item\end{CompactList}\item
class {\bf Serial\-Service}
\begin{CompactList}\small\item\em The {\bf Serial\-Service}{\rm (p.\,\pageref{classost_1_1_serial_service})} is a thead service object that is meant to service attached serial {\bf ports.Thread}{\rm (p.\,\pageref{namespaceost_1a3b6738f6f759fcb52b544a4787cbb2})} pool service for serial ports. \item\end{CompactList}\item
class {\bf Slog}
\begin{CompactList}\small\item\em The slog class is used to stream messages to the system's logging facility (syslogd).system logging facility class. \item\end{CompactList}\item
class {\bf Socket}
\begin{CompactList}\small\item\em The {\bf Socket}{\rm (p.\,\pageref{classost_1_1_socket})} is used as the base for all Internet protocol services under Common C++.base class of all sockets. \item\end{CompactList}\item
class {\bf UDPSocket}
\begin{CompactList}\small\item\em UDP sockets implement the TCP SOCK\_\-DGRAM UDP protocol.Unreliable Datagram Protocol sockets. \item\end{CompactList}\item
class {\bf UDPBroadcast}
\begin{CompactList}\small\item\em Representing a UDP socket used for subnet broadcasts, this class provides an alternate binding and set\-Peer() capability for UDP sockets.Unreliable Datagram for subnet broadcasts. \item\end{CompactList}\item
class {\bf UDPTransmit}
\begin{CompactList}\small\item\em Representing half of a two-way UDP connection, the UDP transmitter can broadcast data to another selected peer host or to an entire subnet.Unreliable Datagram Peer Associations. \item\end{CompactList}\item
class {\bf UDPReceive}
\begin{CompactList}\small\item\em Representing half of a two-way UDP connection, the UDP receiver can receive data from another peer host or subnet.Unreliable Datagram Peer Associations. \item\end{CompactList}\item
class {\bf UDPDuplex}
\begin{CompactList}\small\item\em UDP duplex connections impliment a bi-directional point-to-point UDP session between two peer hosts.Unreliable Datagram Peer Associations. \item\end{CompactList}\item
class {\bf TCPSocket}
\begin{CompactList}\small\item\em TCP sockets are used for stream based connected sessions between two sockets.bound server for TCP streams and sessions. \item\end{CompactList}\item
class {\bf TCPV6Socket}
\begin{CompactList}\small\item\em TCPV6 sockets are used for stream based connected sessions between two ipv6 sockets.bound server for TCP streams and sessions. \item\end{CompactList}\item
class {\bf TCPStream}
\begin{CompactList}\small\item\em TCP streams are used to represent TCP client connections to a server by TCP protocol servers for accepting client connections.streamable TCP socket connection. \item\end{CompactList}\item
class {\bf TCPSession}
\begin{CompactList}\small\item\em The TCP session is used to primarily to represent a client connection that can be managed on a seperate thread.Threaded streamable socket with non-blocking constructor. \item\end{CompactList}\item
class {\bf Simple\-TCPStream}
\begin{CompactList}\small\item\em Simple TCP Stream, to be used with Common C++ Library. \item\end{CompactList}\item
class {\bf Socket\-Port}
\begin{CompactList}\small\item\em The socket port is an internal class which is attached to and then serviced by a specific {\bf Socket\-Service}{\rm (p.\,\pageref{classost_1_1_socket_service})} \char`\"{}object\char`\"{}.base class for realtime and thread pool serviced protocols. \item\end{CompactList}\item
class {\bf Socket\-Service}
\begin{CompactList}\small\item\em The {\bf Socket\-Service}{\rm (p.\,\pageref{classost_1_1_socket_service})} is a thread pool object that is meant to service attached socket {\bf ports.Thread}{\rm (p.\,\pageref{namespaceost_1a3b6738f6f759fcb52b544a4787cbb2})} pool service object for socket ports. \item\end{CompactList}\item
class {\bf String}
\begin{CompactList}\small\item\em This is a generic and portable string class.Generic string class. \item\end{CompactList}\item
class {\bf SString}
\item
class {\bf String\-Object}
\begin{CompactList}\small\item\em The {\bf String\-Object}{\rm (p.\,\pageref{classost_1_1_string_object})} class is used to derive subclasses that use the {\bf String}{\rm (p.\,\pageref{classost_1_1_string})} managed memory pool for all space allocations by overriding new and delete operators.Objects managed in reusable {\bf String}{\rm (p.\,\pageref{classost_1_1_string})} memory pools. \item\end{CompactList}\item
class {\bf Mutex}
\begin{CompactList}\small\item\em The {\bf Mutex}{\rm (p.\,\pageref{classost_1_1_mutex})} class is used to protect a section of code so that at any given time only a single thread can perform the protected operation.Mutex lock for protected access. \item\end{CompactList}\item
class {\bf Mutex\-Lock}
\begin{CompactList}\small\item\em The {\bf Mutex\-Lock}{\rm (p.\,\pageref{classost_1_1_mutex_lock})} class is used to protect a section of code so that at any given time only a single thread can perform the protected operation.Mutex automatic locker for protected access. \item\end{CompactList}\item
class {\bf Thread\-Lock}
\begin{CompactList}\small\item\em The {\bf Thread\-Lock}{\rm (p.\,\pageref{classost_1_1_thread_lock})} class impliments a thread rwlock for optimal reader performance on systems which have rwlock support, and reverts to a simple mutex for those that do not.Posix rwlock extension for protected access. \item\end{CompactList}\item
class {\bf Read\-Lock}
\begin{CompactList}\small\item\em The {\bf Read\-Lock}{\rm (p.\,\pageref{classost_1_1_read_lock})} class is used to protect a section of code through a {\bf Thread\-Lock}{\rm (p.\,\pageref{classost_1_1_thread_lock})} for \char`\"{}read\char`\"{} access to the member function.Read mode automatic locker for protected access. \item\end{CompactList}\item
class {\bf Write\-Lock}
\begin{CompactList}\small\item\em The {\bf Write\-Lock}{\rm (p.\,\pageref{classost_1_1_write_lock})} class is used to protect a section of code through a {\bf Thread\-Lock}{\rm (p.\,\pageref{classost_1_1_thread_lock})} for \char`\"{}write\char`\"{} access to the member function.Read mode automatic locker for protected access. \item\end{CompactList}\item
class {\bf Mutex\-Counter}
\begin{CompactList}\small\item\em The {\bf Mutex}{\rm (p.\,\pageref{classost_1_1_mutex})} {\bf Counter}{\rm (p.\,\pageref{classost_1_1_counter})} is a counter variable which can safely be incremented or decremented by multiple {\bf threads.Thread}{\rm (p.\,\pageref{namespaceost_1a3b6738f6f759fcb52b544a4787cbb2})} protected integer counter. \item\end{CompactList}\item
class {\bf Atomic\-Counter}
\begin{CompactList}\small\item\em The {\bf Atomic\-Counter}{\rm (p.\,\pageref{classost_1_1_atomic_counter})} class offers thread-safe manipulation of an integer counter.atomic counter operation. \item\end{CompactList}\item
class {\bf Conditional}
\begin{CompactList}\small\item\em A conditional variable synchcronization object for one to one and one to many signal and control events between processes.conditional. \item\end{CompactList}\item
class {\bf Semaphore}
\begin{CompactList}\small\item\em A semaphore is generally used as a synchronization object between multiple threads or to protect a limited and finite resource such as a memory or thread pool.Semaphore counter for thread synchronization. \item\end{CompactList}\item
class {\bf Semaphore\-Lock}
\begin{CompactList}\small\item\em The {\bf Semaphore\-Lock}{\rm (p.\,\pageref{classost_1_1_semaphore_lock})} class is used to protect a section of code through a semaphore so that only x instances of the member function may execute concurrently.Semaphore automatic locker for protected access. \item\end{CompactList}\item
class {\bf Event}
\begin{CompactList}\small\item\em The {\bf Event}{\rm (p.\,\pageref{classost_1_1_event})} class implements a feature originally found in the WIN32 API; event {\bf notification.Thread}{\rm (p.\,\pageref{namespaceost_1a3b6738f6f759fcb52b544a4787cbb2})} synchornization on event notification. \item\end{CompactList}\item
class {\bf Thread}
\begin{CompactList}\small\item\em Every thread of execution in an application is created by instantiating an object of a class derived from the {\bf Thread}{\rm (p.\,\pageref{classost_1_1_thread})} class.base class used to derive all threads of execution. \item\end{CompactList}\item
class {\bf Cancellation}
\begin{CompactList}\small\item\em A class to automatically set the thread cancellation mode of a member function.Automatic cancellation mode setting. \item\end{CompactList}\item
class {\bf Posix\-Thread}
\item
class {\bf Thread\-Key}
\begin{CompactList}\small\item\em This class allows the creation of a thread context unique \char`\"{}pointer\char`\"{} that can be set and retrieved and can be used to create thread specific data areas for implementing \char`\"{}thread safe\char`\"{} library routines.container for thread specific data storage. \item\end{CompactList}\item
class {\bf Timer\-Port}
\begin{CompactList}\small\item\em Timer ports are used to provide synchronized timing events when managed under a \char`\"{}service thread\char`\"{} such as Socket\-Service.synchronized millisecond timing for service threads. \item\end{CompactList}\item
class {\bf Sys\-Time}
\begin{CompactList}\small\item\em This class is used to access non-reentrant date and time functions in the standard C {\bf library.Thread}{\rm (p.\,\pageref{namespaceost_1a3b6738f6f759fcb52b544a4787cbb2})} safe date and time functions. \item\end{CompactList}\item
class {\bf String\-Tokenizer}
\begin{CompactList}\small\item\em Splits delimited string into tokens. \item\end{CompactList}\item
class {\bf Unix\-Socket}
\begin{CompactList}\small\item\em Unix domain sockets are used for stream based connected sessions between processes on the same machine.bound server for Unix domain streams and sessions. \item\end{CompactList}\item
class {\bf Unix\-Stream}
\begin{CompactList}\small\item\em Unix streams are used to represent Unix domain client connections to a local server for accepting client connections.streamable Unix domain socket connection. \item\end{CompactList}\item
class {\bf unixstream}
\begin{CompactList}\small\item\em A more natural C++ \char`\"{}unixstream\char`\"{} class for use by non-threaded applications.C++ \char`\"{}fstream\char`\"{} style unixstream class. \item\end{CompactList}\item
class {\bf Unix\-Session}
\begin{CompactList}\small\item\em The Unix domain session is used to primarily to represent a client connection that can be managed on a seperate thread.Threaded streamable unix domain socket with non-blocking constructor. \item\end{CompactList}\item
class {\bf URLStream}
\begin{CompactList}\small\item\em A URL processing version of TCPStream.C++ url processing stream class. \item\end{CompactList}\item
class {\bf XMLStream}
\begin{CompactList}\small\item\em This class impliments a basic XML stream parser that can be used to examine an XML resource thru virtual I/O methods.XML Stream Parser (SAX). \item\end{CompactList}\item
class {\bf XMLRPC}
\begin{CompactList}\small\item\em This class impliments a core {\bf XMLRPC}{\rm (p.\,\pageref{classost_1_1_x_m_l_r_p_c})} service without the underlying transports.XML-RPC service building class. \item\end{CompactList}\item
class {\bf IZStream}
\item
class {\bf OZStream}
\end{CompactItemize}
\subsection*{Typedefs}
\begin{CompactItemize}
\item
typedef unsigned short {\bf tpport\_\-t}
\begin{CompactList}\small\item\em Transport Protocol Ports. \item\end{CompactList}\item
typedef unsigned long {\bf pos\_\-t}
\item
typedef size\_\-t {\bf ccxx\_\-size\_\-t}
\item
typedef std::string\_\-char\_\-traits$<$ char $>$ {\bf cstring\_\-char\_\-traits}
\item
typedef std::basic\_\-string$<$ char $>$ {\bf cstring}
\item
typedef std::basic\_\-string$<$ char, {\bf cistring\_\-char\_\-traits}$<$ char $>$ $>$ {\bf cistring}
\item
typedef {\bf Base\-Object} $\ast$($\ast$ {\bf New\-Base\-Object\-Function} )(void)
\item
typedef unsigned short {\bf tpport\_\-t}
\begin{CompactList}\small\item\em Transport Protocol Ports. \item\end{CompactList}\item
typedef int {\bf signo\_\-t}
\end{CompactItemize}
\subsection*{Functions}
\begin{CompactItemize}
\item
\_\-\_\-EXPORT std::ostream \& {\bf operator$<$$<$} (std::ostream \&os, const {\bf IPV4Address} \&ia)
\item
in\_\-addr {\bf getaddress} (const {\bf IPV4Address} \&ia)
\item
\_\-\_\-EXPORT std::ostream \& {\bf operator$<$$<$} (std::ostream \&os, const {\bf IPV6Address} \&ia)
\item
in6\_\-addr {\bf getaddress} (const {\bf IPV6Address} \&ia)
\item
\_\-\_\-EXPORT {\bf Command\-Option\-Parse} $\ast$ {\bf make\-Command\-Option\-Parse} (int argc, char $\ast$$\ast$argv, char $\ast$comment, {\bf Command\-Option} $\ast$options={\bf default\-Command\-Option\-List})
\begin{CompactList}\small\item\em make\-Command\-Option\-Parse will create an implementation of a {\bf Command\-Option\-Parse}{\rm (p.\,\pageref{classost_1_1_command_option_parse})} object. \item\end{CompactList}\item
template$<$typename T$>$ const T \& {\bf abs} (const T \&v)
\item
\_\-\_\-EXPORT void $\ast$ {\bf memmove} (char $\ast$dest, const char $\ast$source, size\_\-t length)
\item
\_\-\_\-EXPORT char $\ast$ {\bf strdup} (const char $\ast$str)
\item
\_\-\_\-EXPORT int {\bf lockf} (int fd, int mode, long offset)
\item
char $\ast$ {\bf strtok\_\-r} (char $\ast$s, const char $\ast$d, char $\ast$$\ast$x)
\item
\_\-\_\-EXPORT char $\ast$ {\bf lset\-Field} (char $\ast$target, size\_\-t size, const char $\ast$src, const char fill=0)
\item
\_\-\_\-EXPORT char $\ast$ {\bf rset\-Field} (char $\ast$target, size\_\-t size, const char $\ast$src, const char fill=0)
\item
\_\-\_\-EXPORT char $\ast$ {\bf set\-String} (char $\ast$target, size\_\-t size, const char $\ast$src)
\item
\_\-\_\-EXPORT char $\ast$ {\bf add\-String} (char $\ast$target, size\_\-t size, const char $\ast$src)
\item
\_\-\_\-EXPORT char $\ast$ {\bf new\-String} (const char $\ast$src, size\_\-t size=0)
\item
\_\-\_\-EXPORT void {\bf del\-String} (char $\ast$str)
\item
\_\-\_\-EXPORT char $\ast$ {\bf set\-Upper} (char $\ast$string, size\_\-t size)
\item
\_\-\_\-EXPORT char $\ast$ {\bf set\-Lower} (char $\ast$string, size\_\-t size)
\item
\_\-\_\-EXPORT char $\ast$ {\bf find} (const char $\ast$cs, char $\ast$str, size\_\-t len=0)
\item
\_\-\_\-EXPORT char $\ast$ {\bf rfind} (const char $\ast$cs, char $\ast$str, size\_\-t len=0)
\item
\_\-\_\-EXPORT char $\ast$ {\bf ifind} (const char $\ast$cs, char $\ast$str, size\_\-t len=0)
\item
\_\-\_\-EXPORT char $\ast$ {\bf strip} (const char $\ast$cs, char $\ast$str, size\_\-t len=0)
\item
\_\-\_\-EXPORT size\_\-t {\bf strchop} (const char $\ast$cs, char $\ast$str, size\_\-t len=0)
\item
\_\-\_\-EXPORT size\_\-t {\bf strtrim} (const char $\ast$cs, char $\ast$str, size\_\-t len=0)
\item
char $\ast$ {\bf dup\-String} (const char $\ast$src, size\_\-t size=0)
\item
timespec $\ast$ {\bf get\-Timeout} (struct timespec $\ast$spec, {\bf timeout\_\-t} timeout)
\item
void {\bf wait} ({\bf signo\_\-t} signo)
\item
{\bf Thread} $\ast$ {\bf get\-Thread} (void)
\item
tm $\ast$ {\bf localtime\_\-r} (const time\_\-t $\ast$t, struct tm $\ast$b)
\item
char $\ast$ {\bf ctime\_\-r} (const time\_\-t $\ast$t, char $\ast$buf)
\item
tm $\ast$ {\bf gmtime\_\-r} (const time\_\-t $\ast$t, struct tm $\ast$b)
\item
char $\ast$ {\bf asctime\_\-r} (const struct tm $\ast$tm, char $\ast$b)
\end{CompactItemize}
\subsection*{Variables}
\begin{CompactItemize}
\item
\_\-\_\-EXPORT {\bf IPV4Host}
\item
\_\-\_\-EXPORT {\bf IPV6Host}
\item
\_\-\_\-EXPORT {\bf Command\-Option} $\ast$ {\bf default\-Command\-Option\-List}
\begin{CompactList}\small\item\em This defines a linked list head pointer for all the command line options that use the default list. \item\end{CompactList}\item
\_\-\_\-EXPORT {\bf MIMEMultipart}
\item
\_\-\_\-EXPORT {\bf MIMEItem\-Part}
\item
\_\-\_\-EXPORT {\bf Runlist}
\item
\_\-\_\-EXPORT {\bf Runable}
\item
\_\-\_\-EXPORT {\bf Map\-Object}
\item
\_\-\_\-EXPORT {\bf Serial\-Port}
\item
\_\-\_\-EXPORT {\bf Serial\-Service}
\item
\_\-\_\-EXPORT {\bf Slog} {\bf slog}
\item
\_\-\_\-EXPORT {\bf Simple\-TCPStream}
\item
\_\-\_\-EXPORT {\bf Socket\-Port}
\item
\_\-\_\-EXPORT {\bf Socket\-Service}
\item
\_\-\_\-EXPORT {\bf Thread}
\item
\_\-\_\-EXPORT {\bf Thread\-Key}
\item
\_\-\_\-EXPORT {\bf Conditional}
\item
\_\-\_\-EXPORT {\bf Event}
\end{CompactItemize}
\subsection{Typedef Documentation}
\index{ost@{ost}!ccxx_size_t@{ccxx\_\-size\_\-t}}
\index{ccxx_size_t@{ccxx\_\-size\_\-t}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}typedef size\_\-t {\bf ost::ccxx\_\-size\_\-t}}\label{namespaceost_cedd0902cc2709bd066b9f8a2d1f44a0}
\index{ost@{ost}!cistring@{cistring}}
\index{cistring@{cistring}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}typedef std::basic\_\-string$<$char, {\bf cistring\_\-char\_\-traits}$<$char$>$ $>$ {\bf ost::cistring}}\label{namespaceost_f44fd1ab13de12228f6399fb500ab690}
\index{ost@{ost}!cstring@{cstring}}
\index{cstring@{cstring}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}typedef std::basic\_\-string$<$char$>$ {\bf ost::cstring}}\label{namespaceost_e9d8b752b5266d622d1e8b038a39cb75}
\index{ost@{ost}!cstring_char_traits@{cstring\_\-char\_\-traits}}
\index{cstring_char_traits@{cstring\_\-char\_\-traits}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}typedef std::string\_\-char\_\-traits$<$char$>$ {\bf ost::cstring\_\-char\_\-traits}}\label{namespaceost_6ca9f3170d46bdf58c5a78ea0fe8b97c}
\index{ost@{ost}!NewBaseObjectFunction@{NewBaseObjectFunction}}
\index{NewBaseObjectFunction@{NewBaseObjectFunction}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}typedef class {\bf Base\-Object}$\ast$($\ast$ {\bf ost::New\-Base\-Object\-Function})(void)}\label{namespaceost_baf4b8bd869b80b3711d0d84f5b91ac5}
\index{ost@{ost}!pos_t@{pos\_\-t}}
\index{pos_t@{pos\_\-t}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}typedef unsigned long {\bf ost::pos\_\-t}}\label{namespaceost_4bb988be58c6264b160ef2d6ceb178e5}
\index{ost@{ost}!signo_t@{signo\_\-t}}
\index{signo_t@{signo\_\-t}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}typedef int {\bf ost::signo\_\-t}}\label{namespaceost_5dca865b107f598c88bd2106ea56c16e}
\index{ost@{ost}!tpport_t@{tpport\_\-t}}
\index{tpport_t@{tpport\_\-t}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}typedef unsigned short {\bf ost::tpport\_\-t}}\label{namespaceost_3c74a1a40c359fd349f3e3e1b96ebfc7}
Transport Protocol Ports.
\index{ost@{ost}!tpport_t@{tpport\_\-t}}
\index{tpport_t@{tpport\_\-t}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}typedef unsigned short {\bf ost::tpport\_\-t}}\label{namespaceost_3c74a1a40c359fd349f3e3e1b96ebfc7}
Transport Protocol Ports.
\begin{Desc}
\item[Examples: ]\par
{\bf Sample\-Socket\-Port.cpp}, {\bf tcp.cpp}, {\bf tcpservice.cpp}, and {\bf tcpthread.cpp}.\end{Desc}
\subsection{Function Documentation}
\index{ost@{ost}!abs@{abs}}
\index{abs@{abs}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$typename T$>$ const T\& ost::abs (const T \& {\em v})\hspace{0.3cm}{\tt [inline]}}\label{namespaceost_dc33f39b8be8739d341c90a82e721bf8}
\index{ost@{ost}!addString@{addString}}
\index{addString@{addString}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT char$\ast$ ost::add\-String (char $\ast$ {\em target}, size\_\-t {\em size}, const char $\ast$ {\em src})}\label{namespaceost_79f60448442dd704b8b73b849c6ca830}
\index{ost@{ost}!asctime_r@{asctime\_\-r}}
\index{asctime_r@{asctime\_\-r}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ ost::asctime\_\-r (const struct tm $\ast$ {\em tm}, char $\ast$ {\em b})\hspace{0.3cm}{\tt [inline]}}\label{namespaceost_6d84108739f29b7fbc773f1a57a3a439}
\index{ost@{ost}!ctime_r@{ctime\_\-r}}
\index{ctime_r@{ctime\_\-r}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ ost::ctime\_\-r (const time\_\-t $\ast$ {\em t}, char $\ast$ {\em buf})\hspace{0.3cm}{\tt [inline]}}\label{namespaceost_1951b0e03ecb3bf227e19855d3a1f11a}
\index{ost@{ost}!delString@{delString}}
\index{delString@{delString}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT void ost::del\-String (char $\ast$ {\em str})}\label{namespaceost_bc78fd2f60c7ba6ece122328c1480f65}
\index{ost@{ost}!dupString@{dupString}}
\index{dupString@{dupString}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ ost::dup\-String (const char $\ast$ {\em src}, size\_\-t {\em size} = {\tt 0})\hspace{0.3cm}{\tt [inline]}}\label{namespaceost_c3f504d61cf08cd1e1b848f99002d278}
\index{ost@{ost}!find@{find}}
\index{find@{find}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT char$\ast$ ost::find (const char $\ast$ {\em cs}, char $\ast$ {\em str}, size\_\-t {\em len} = {\tt 0})}\label{namespaceost_1b8165f8919a000a47f06b725a103a37}
\index{ost@{ost}!getaddress@{getaddress}}
\index{getaddress@{getaddress}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}struct in6\_\-addr ost::getaddress (const IPV6Address \& {\em ia})\hspace{0.3cm}{\tt [inline]}}\label{namespaceost_d50c9b5311667f2b1796374ea6e06dc4}
\index{ost@{ost}!getaddress@{getaddress}}
\index{getaddress@{getaddress}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}struct in\_\-addr ost::getaddress (const IPV4Address \& {\em ia})\hspace{0.3cm}{\tt [inline]}}\label{namespaceost_2814c59547dbc1ac351e7813b8034654}
\index{ost@{ost}!getThread@{getThread}}
\index{getThread@{getThread}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf Thread}$\ast$ ost::get\-Thread (void)\hspace{0.3cm}{\tt [inline]}}\label{namespaceost_99c7f7d02b00922b0f5ee62fc3bb75fd}
\index{ost@{ost}!getTimeout@{getTimeout}}
\index{getTimeout@{getTimeout}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}struct timespec$\ast$ ost::get\-Timeout (struct timespec $\ast$ {\em spec}, {\bf timeout\_\-t} {\em timeout})}\label{namespaceost_8fd139f80e945ac6d8cc53868cdacca6}
\index{ost@{ost}!gmtime_r@{gmtime\_\-r}}
\index{gmtime_r@{gmtime\_\-r}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}struct tm$\ast$ ost::gmtime\_\-r (const time\_\-t $\ast$ {\em t}, struct tm $\ast$ {\em b})\hspace{0.3cm}{\tt [inline]}}\label{namespaceost_64c9138a1bf7a0d56fc8060fa1e4552c}
\index{ost@{ost}!ifind@{ifind}}
\index{ifind@{ifind}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT char$\ast$ ost::ifind (const char $\ast$ {\em cs}, char $\ast$ {\em str}, size\_\-t {\em len} = {\tt 0})}\label{namespaceost_f8af60086b5fb3a2323c390bacc49c20}
\index{ost@{ost}!localtime_r@{localtime\_\-r}}
\index{localtime_r@{localtime\_\-r}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}struct tm$\ast$ ost::localtime\_\-r (const time\_\-t $\ast$ {\em t}, struct tm $\ast$ {\em b})\hspace{0.3cm}{\tt [inline]}}\label{namespaceost_2532506cb80f89403523d977ef6c2345}
\index{ost@{ost}!lockf@{lockf}}
\index{lockf@{lockf}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT int ost::lockf (int {\em fd}, int {\em mode}, long {\em offset})}\label{namespaceost_a1cac975d1f4e1abe9e259b384166922}
\index{ost@{ost}!lsetField@{lsetField}}
\index{lsetField@{lsetField}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT char$\ast$ ost::lset\-Field (char $\ast$ {\em target}, size\_\-t {\em size}, const char $\ast$ {\em src}, const char {\em fill} = {\tt 0})}\label{namespaceost_86830afc710ed44f9e5d09fbccd46610}
\index{ost@{ost}!makeCommandOptionParse@{makeCommandOptionParse}}
\index{makeCommandOptionParse@{makeCommandOptionParse}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT {\bf Command\-Option\-Parse}$\ast$ ost::make\-Command\-Option\-Parse (int {\em argc}, char $\ast$$\ast$ {\em argv}, char $\ast$ {\em comment}, Command\-Option $\ast$ {\em options} = {\tt {\bf default\-Command\-Option\-List}})}\label{namespaceost_9c8722a3e68ba930b72211f47eacc5eb}
make\-Command\-Option\-Parse will create an implementation of a {\bf Command\-Option\-Parse}{\rm (p.\,\pageref{classost_1_1_command_option_parse})} object.
This particular implementation is a wrapper around getopt\_\-long(3). That interface unfortunatly does not provide enough information to give the best error messages with malformed input. If the implementation changes there is a good chance that the binary interface will remain the same. \begin{Desc}
\item[Examples: ]\par
{\bf cmdlineopt.cpp}.\end{Desc}
\index{ost@{ost}!memmove@{memmove}}
\index{memmove@{memmove}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT void$\ast$ ost::memmove (char $\ast$ {\em dest}, const char $\ast$ {\em source}, size\_\-t {\em length})}\label{namespaceost_0160302fe3f8c97492c0cdc2e71723eb}
\index{ost@{ost}!newString@{newString}}
\index{newString@{newString}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT char$\ast$ ost::new\-String (const char $\ast$ {\em src}, size\_\-t {\em size} = {\tt 0})}\label{namespaceost_4ed98da16548e0636beb4ecc3de36379}
\index{ost@{ost}!operator<<@{operator$<$$<$}}
\index{operator<<@{operator$<$$<$}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT std::ostream\& ost::operator$<$$<$ (std::ostream \& {\em os}, const IPV6Address \& {\em ia})}\label{namespaceost_2327d882089117777717e801351ea2e7}
\index{ost@{ost}!operator<<@{operator$<$$<$}}
\index{operator<<@{operator$<$$<$}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT std::ostream\& ost::operator$<$$<$ (std::ostream \& {\em os}, const IPV4Address \& {\em ia})}\label{namespaceost_43b65f3c2266eb63ba22c1ff73a6e20b}
\index{ost@{ost}!rfind@{rfind}}
\index{rfind@{rfind}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT char$\ast$ ost::rfind (const char $\ast$ {\em cs}, char $\ast$ {\em str}, size\_\-t {\em len} = {\tt 0})}\label{namespaceost_977af6fa213a805e4f4d3dedcd260db9}
\index{ost@{ost}!rsetField@{rsetField}}
\index{rsetField@{rsetField}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT char$\ast$ ost::rset\-Field (char $\ast$ {\em target}, size\_\-t {\em size}, const char $\ast$ {\em src}, const char {\em fill} = {\tt 0})}\label{namespaceost_50cf77f6008e350caddb52e2018056d6}
\index{ost@{ost}!setLower@{setLower}}
\index{setLower@{setLower}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT char$\ast$ ost::set\-Lower (char $\ast$ {\em string}, size\_\-t {\em size})}\label{namespaceost_908e57b620c97ec9e15211b1714a5bea}
\index{ost@{ost}!setString@{setString}}
\index{setString@{setString}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT char$\ast$ ost::set\-String (char $\ast$ {\em target}, size\_\-t {\em size}, const char $\ast$ {\em src})}\label{namespaceost_b4a3706ed3a66b328d155b8a2718698b}
\index{ost@{ost}!setUpper@{setUpper}}
\index{setUpper@{setUpper}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT char$\ast$ ost::set\-Upper (char $\ast$ {\em string}, size\_\-t {\em size})}\label{namespaceost_64293a953574b332b34aab97940af1a7}
\index{ost@{ost}!strchop@{strchop}}
\index{strchop@{strchop}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT size\_\-t ost::strchop (const char $\ast$ {\em cs}, char $\ast$ {\em str}, size\_\-t {\em len} = {\tt 0})}\label{namespaceost_3ee3a534a2683b6b9c25540a3a394f0e}
\index{ost@{ost}!strdup@{strdup}}
\index{strdup@{strdup}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT char$\ast$ ost::strdup (const char $\ast$ {\em str})}\label{namespaceost_945b275fab2dac13c0f0b8b46e7c14b4}
\index{ost@{ost}!strip@{strip}}
\index{strip@{strip}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT char$\ast$ ost::strip (const char $\ast$ {\em cs}, char $\ast$ {\em str}, size\_\-t {\em len} = {\tt 0})}\label{namespaceost_505a9ca313f897bbf98877a69afb27b6}
\index{ost@{ost}!strtok_r@{strtok\_\-r}}
\index{strtok_r@{strtok\_\-r}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ ost::strtok\_\-r (char $\ast$ {\em s}, const char $\ast$ {\em d}, char $\ast$$\ast$ {\em x})\hspace{0.3cm}{\tt [inline]}}\label{namespaceost_cb0178dea54db048122f1886c725e5b8}
\index{ost@{ost}!strtrim@{strtrim}}
\index{strtrim@{strtrim}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT size\_\-t ost::strtrim (const char $\ast$ {\em cs}, char $\ast$ {\em str}, size\_\-t {\em len} = {\tt 0})}\label{namespaceost_6f212047b8e92dc9a5ce9ba169fd71da}
\index{ost@{ost}!wait@{wait}}
\index{wait@{wait}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void ost::wait ({\bf signo\_\-t} {\em signo})}\label{namespaceost_24c7774639b3768bdd45b65a296f6369}
\begin{Desc}
\item[Examples: ]\par
{\bf cmdlineopt.cpp}.\end{Desc}
\subsection{Variable Documentation}
\index{ost@{ost}!Conditional@{Conditional}}
\index{Conditional@{Conditional}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class \_\-\_\-EXPORT {\bf ost::Conditional}}\label{namespaceost_4528eecdfa02ab10dbfdc49f5b238506}
\index{ost@{ost}!defaultCommandOptionList@{defaultCommandOptionList}}
\index{defaultCommandOptionList@{defaultCommandOptionList}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT {\bf Command\-Option}$\ast$ {\bf ost::default\-Command\-Option\-List}}\label{namespaceost_3b701311bbf7cf16f954820e316f5766}
This defines a linked list head pointer for all the command line options that use the default list.
It will most likely be used in most cases without being explicitly referenced in application code. It is a default value of various method's parameters. \begin{Desc}
\item[Examples: ]\par
{\bf cmdlineopt.cpp}.\end{Desc}
\index{ost@{ost}!Event@{Event}}
\index{Event@{Event}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class \_\-\_\-EXPORT {\bf ost::Event}}\label{namespaceost_a1f2ab8ff95e0568261375df5837eb19}
\index{ost@{ost}!IPV4Host@{IPV4Host}}
\index{IPV4Host@{IPV4Host}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class \_\-\_\-EXPORT {\bf ost::IPV4Host}}\label{namespaceost_690ff5fe11ecacf1b08c88c6d042054c}
\index{ost@{ost}!IPV6Host@{IPV6Host}}
\index{IPV6Host@{IPV6Host}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class \_\-\_\-EXPORT {\bf ost::IPV6Host}}\label{namespaceost_0ef77c2689f8442b3b0d3a0f4d2151e0}
\index{ost@{ost}!MapObject@{MapObject}}
\index{MapObject@{MapObject}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class \_\-\_\-EXPORT {\bf ost::Map\-Object}}\label{namespaceost_37ea4bf108b19e62006ae456f816e556}
\index{ost@{ost}!MIMEItemPart@{MIMEItemPart}}
\index{MIMEItemPart@{MIMEItemPart}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class \_\-\_\-EXPORT {\bf ost::MIMEItem\-Part}}\label{namespaceost_516cf4d09b168c65060ab9ca3853f0b7}
\index{ost@{ost}!MIMEMultipart@{MIMEMultipart}}
\index{MIMEMultipart@{MIMEMultipart}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class \_\-\_\-EXPORT {\bf ost::MIMEMultipart}}\label{namespaceost_cd9ec421eb2d0fbaa1bc5139cf899689}
\index{ost@{ost}!Runable@{Runable}}
\index{Runable@{Runable}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class \_\-\_\-EXPORT {\bf ost::Runable}}\label{namespaceost_cc2811f07b6cc7ea5d96a90fee539ed2}
\index{ost@{ost}!Runlist@{Runlist}}
\index{Runlist@{Runlist}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class \_\-\_\-EXPORT {\bf ost::Runlist}}\label{namespaceost_dba459b2b0da06fe5e0cbaf2349eaaa5}
\index{ost@{ost}!SerialPort@{SerialPort}}
\index{SerialPort@{SerialPort}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class \_\-\_\-EXPORT {\bf ost::Serial\-Port}}\label{namespaceost_9efc8cc6866dd331e5f21c2a816ca6d2}
\index{ost@{ost}!SerialService@{SerialService}}
\index{SerialService@{SerialService}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class \_\-\_\-EXPORT {\bf ost::Serial\-Service}}\label{namespaceost_499e7de437b403177426e5066d84b306}
\index{ost@{ost}!SimpleTCPStream@{SimpleTCPStream}}
\index{SimpleTCPStream@{SimpleTCPStream}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class \_\-\_\-EXPORT {\bf ost::Simple\-TCPStream}}\label{namespaceost_33ac1051cb7ef5d55c254ff51054d2e7}
\index{ost@{ost}!slog@{slog}}
\index{slog@{slog}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\_\-\_\-EXPORT {\bf Slog} {\bf ost::slog}}\label{namespaceost_023b22e037f0fd450da335d51680fa34}
\begin{Desc}
\item[Examples: ]\par
{\bf slog\-Test.cpp}.\end{Desc}
\index{ost@{ost}!SocketPort@{SocketPort}}
\index{SocketPort@{SocketPort}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class \_\-\_\-EXPORT {\bf ost::Socket\-Port}}\label{namespaceost_0120970550868f111b2d9cc7054526f7}
\begin{Desc}
\item[Examples: ]\par
{\bf Sample\-Socket\-Port.cpp}.\end{Desc}
\index{ost@{ost}!SocketService@{SocketService}}
\index{SocketService@{SocketService}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class \_\-\_\-EXPORT {\bf ost::Socket\-Service}}\label{namespaceost_5b999accae7692fd2abbc9654a00eb8c}
\begin{Desc}
\item[Examples: ]\par
{\bf Sample\-Socket\-Port.cpp}, and {\bf tcpservice.cpp}.\end{Desc}
\index{ost@{ost}!Thread@{Thread}}
\index{Thread@{Thread}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class \_\-\_\-EXPORT {\bf ost::Thread}}\label{namespaceost_1a3b6738f6f759fcb52b544a4787cbb2}
\begin{Desc}
\item[Examples: ]\par
{\bf Sample\-Socket\-Port.cpp}.\end{Desc}
\index{ost@{ost}!ThreadKey@{ThreadKey}}
\index{ThreadKey@{ThreadKey}!ost@{ost}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}class \_\-\_\-EXPORT {\bf ost::Thread\-Key}}\label{namespaceost_1a0b31279d4e241eba24d251d1682176}
