Provided by: libcommoncpp2-doc_1.8.1-7_all bug

NAME

       ost

SYNOPSIS

   Classes
       class AppLog
           Application logger is a class that implements a logger that can be used by
           applications to save log file somewhere on the system.
       class Assoc
           This class is used to associate (object) pointers with named strings.
       class AtomicCounter
           The AtomicCounter class offers thread-safe manipulation of an integer counter.
       class BaseObject
           BaseObject.
       class 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.
       class Cancellation
           A class to automatically set the thread cancellation mode of a member function.
       class ChecksumDigest
           A simple checksum digest function.
       struct cistring_char_traits
       class CommandOption
           CommandOption is the base class for all command line options.
       class CommandOptionArg
           Class for options with an argument e.g.
       class CommandOptionCollect
           It only makes sense to have a single one of these set and it is also exclusive with
           CommandOptionRest.
       class CommandOptionNoArg
           CommandOption type for flags.
       class CommandOptionParse
           This is the CommandOptionParse interface class.
       class CommandOptionRest
           It only makes sense to have a single one of these set and it is exclusive with
           CommandOptionCollect.
       class CommandOptionWithArg
           Derived class of CommandOption for options that have a value associated with them.
       class Conditional
           A conditional variable synchcronization object for one to one and one to many signal
           and control events between processes.
       class Counter
           The counter template is used for generic objects which act as automatic counters.
       class CRC16Digest
           A crc16 collection/compution hash accumulator class.
       class CRC32Digest
           A crc32 collection/computation hash accumulator class.
       class Date
           The Date class uses a julian date representation of the current year, month, and day.
       class DateNumber
           A number class that manipulates a string buffer that is also a date.
       class Datetime
           The Datetime class uses a julian date representation of the current year, month, and
           day and a integer representation of the current time.
       class DCCPSocket
           DCCP sockets are used for stream based connected sessions between two sockets.
       class Digest
           The digest base class is used for implementing and deriving one way hashing functions.
       class Dir
           A low level portable directory class.
       class DirTree
           A generic class to walk a hierarchical directory structure.
       class DSO
           The DSO dynamic loader class is used to load object files.
       class Engine
           Engine.
       class Event
           The Event class implements a feature originally found in the WIN32 API; event
           notification.
       class File
       class FixedBuffer
           A buffer class that holds a known capacity of fixed sized objects defined during
           creation.
       class HEXdump
           Produces a dump of a buffer in a hexdump way with its code Ascii translation and
           relative buffer address.
       class IPV4Address
           The network name and address objects are all derived from a common IPV4Address base
           class.
       class IPV4Broadcast
           The broadcast address object is used to store the broadcast address for a specific
           subnet.
       class IPV4Cidr
           The CIDR class is used to support routing tables and validate address policies.
       class 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.
       class IPV4Mask
           Internet addresses used specifically as masking addresses (such as ' 255.255.255.0')
           are held in the IPV4Mask derived object. "
       class IPV4Multicast
           A specialization of IPV4Address that provides address validation for multicast
           addresses.
       class IPV4MulticastValidator
           Class for the function object that validates multicast addresses.
       class IPV4Validator
           Classes derived from IPV4Address would require an specific validator to pass to the
           IPV4Address constructor.
       class IPV6Address
           The network name and address objects are all derived from a common IPV6Address base
           class.
       class IPV6Broadcast
           The broadcast address object is used to store the broadcast address for a specific
           subnet.
       class IPV6Cidr
           The CIDR class is used to support routing tables and validate address policies.
       class 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.
       class IPV6Mask
           Internet addresses used specifically as masking addresses (such as ' 255.255.255.0')
           are held in the IPV6Mask derived object. "
       class IPV6Multicast
           A specialization of IPV6Address that provides address validation for multicast
           addresses.
       class IPV6MulticastValidator
           Class for the function object that validates multicast addresses.
       class IPV6Validator
           Classes derived from IPV6Address would require an specific validator to pass to the
           IPV6Address constructor.
       class IZStream
       class Keydata
           Keydata objects are used to load and hold 'configuration' data for a given
           application.
       class keyMap
       class LinkedDouble
           Self managed double linked list object chain.
       class LinkedSingle
           Self managed single linked list object chain.
       class Lockfile
           This class is used to create a 'named' lock entity that can be used to control access
           to a resource between multiple processes.
       class MapIndex
           The MapIndex allows linear access into a MapTable, that otherwise could have its
           elements being retrieved only by key.
       class MapObject
           The MapObject is a base class which can be used to make a derived class operate on a
           MapTable.
       class MappedFile
           Create and map a disk file into memory.
       class MapTable
           A map table allows for entities to be mapped (hash index) onto it.
       class MD5Digest
           A md5 collection/computation accululator class.
       class MemPager
           The memory pager is used to allocate cumulative memory pages for storing object
           specific 'persistant' data that is presumed to persist during the life of a given
           derived object.
       class MemPagerObject
           This class is used to create derived classes which are constructed within a memory
           pager pool.
       class MIMEFormData
           This is a document part type for use in submitting multipart form data to a web
           server.
       class MIMEItemPart
           This is used to attach an item part to a MIME multipart document that is being
           streamed.
       class MIMEMultipart
           A container class for multi-part MIME document objects which can be streamed to a
           std::ostream destination.
       class 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.
       class Mutex
           The 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.
       class MutexCounter
           The Mutex Counter is a counter variable which can safely be incremented or decremented
           by multiple threads.
       class MutexLock
           The MutexLock class is used to protect a section of code so that at any given time
           only a single thread can perform the protected operation.
       class NetworkDeviceInfo
           Network device information class.
       class Number
           A number manipulation class.
       class objCounter
           Generic template class for creating classes which maintain an active count of the
           number of instances currently in active use.
       class objList
           Used to create and manage a single linked list of objects of a common type.
       class objMap
           Used to create and manage a hash index of objects through a common type.
       class objSync
           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.
       class OZStream
       class Pointer
           Used to create and manage referece counted pointers.
       class PosixThread
       class Process
           A class for containing portable process related functions that help create portable
           code.
       class 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.
       class ReadLock
           The ReadLock class is used to protect a section of code through a ThreadLock for
           'read' access to the member function.
       class RefObject
           A reference countable object.
       class RefPointer
           Pointer to reference counted objects.
       class Runable
           A container for objects that can be queued against a runlist.
       class Runlist
           A runlist is used to restrict concurrent exection to a limited set of concurrent
           sessions, much like a semaphore.
       class Semaphore
           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.
       class SemaphoreLock
           The SemaphoreLock class is used to protect a section of code through a semaphore so
           that only x instances of the member function may execute concurrently.
       class Serial
           The Serial class is used as the base for all serial I/O services under APE.
       class SerialPort
           The serial port is an internal class which is attached to and then serviced by a
           specified SerialService thread.
       class SerialService
           The SerialService is a thead service object that is meant to service attached serial
           ports.
       class SharedFile
           This class defines a database I/O file service that can be shared by multiple
           processes.
       class SharedMemPager
           The shared mempager uses a mutex to protect key access methods.
       class SimpleTCPStream
           Simple TCP Stream, to be used with Common C++ Library.
       class Slog
           The slog class is used to stream messages to the system's logging facility (syslogd).
       class Socket
           The Socket is used as the base for all Internet protocol services under Common C++.
       class SocketPort
           The socket port is an internal class which is attached to and then serviced by a
           specific SocketService 'object'.
       class SocketService
           The SocketService is a thread pool object that is meant to service attached socket
           ports.
       class SSLStream
       class SString
       class StackPager
           The StackPager provides a repository to stash and retrieve working data in last-in-
           first-out order.
       class String
           This is a generic and portable string class.
       class StringObject
           The StringObject class is used to derive subclasses that use the String managed memory
           pool for all space allocations by overriding new and delete operators.
       class StringTokenizer
           Splits delimited string into tokens.
       class SysTime
           This class is used to access non-reentrant date and time functions in the standard C
           library.
       class TCPSession
           The TCP session is used to primarily to represent a client connection that can be
           managed on a separate thread.
       class TCPSocket
           TCP sockets are used for stream based connected sessions between two sockets.
       class TCPStream
           TCP streams are used to represent TCP client connections to a server by TCP protocol
           servers for accepting client connections.
       class TCPV6Socket
           TCPV6 sockets are used for stream based connected sessions between two ipv6 sockets.
       class Thread
           Every thread of execution in an application is created by instantiating an object of a
           class derived from the Thread class.
       class ThreadFile
           This class defines a database I/O file service that can be shared by multiple threads.
       class ThreadKey
           This class allows the creation of a thread context unique 'pointer' that can be set
           and retrieved and can be used to create thread specific data areas for implementing
           'thread safe' library routines.
       class ThreadLock
           The ThreadLock 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.
       class ThreadQueue
           Somewhat generic queue processing class to establish a producer consumer queue.
       class Time
           The Time class uses a integer representation of the current time.
       class TimerPort
           Timer ports are used to provide synchronized timing events when managed under a
           'service thread' such as SocketService.
       class 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.
       class TTYStream
           TTY streams are used to represent serial connections that are fully 'streamable'
           objects using C++ stream classes and friends.
       class ttystream
           A more natural C++ 'ttystream' class for use by non-threaded applications.
       class TypeManager
           This class manages the types for generation of the persistent objects.
       class UDPBroadcast
           Representing a UDP socket used for subnet broadcasts, this class provides an alternate
           binding and setPeer() capability for UDP sockets.
       class UDPDuplex
           UDP duplex connections impliment a bi-directional point-to-point UDP session between
           two peer hosts.
       class UDPReceive
           Representing half of a two-way UDP connection, the UDP receiver can receive data from
           another peer host or subnet.
       class UDPSocket
           UDP sockets implement the TCP SOCK_DGRAM UDP protocol.
       class 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.
       class UnixSession
           The Unix domain session is used to primarily to represent a client connection that can
           be managed on a separate thread.
       class UnixSocket
           Unix domain sockets are used for stream based connected sessions between processes on
           the same machine.
       class unixstream
           A more natural C++ 'unixstream' class for use by non-threaded applications.
       class UnixStream
           Unix streams are used to represent Unix domain client connections to a local server
           for accepting client connections.
       class URLStream
           A URL processing version of TCPStream.
       class WriteLock
           The WriteLock class is used to protect a section of code through a ThreadLock for
           'write' access to the member function.
       class XMLRPC
           This class impliments a core XMLRPC service without the underlying transports.
       class XMLStream
           This class impliments a basic XML stream parser that can be used to examine an XML
           resource thru virtual I/O methods.
       class ZNumber

   Typedefs
       typedef unsigned short tpport_t
           Transport Protocol Ports.
       typedef unsigned long pos_t
       typedef size_t ccxx_size_t
       typedef std::string_char_traits< char > cstring_char_traits
       typedef std::basic_string< char > cstring
       typedef std::basic_string< char, cistring_char_traits< char > > cistring
       typedef class BaseObject *(* NewBaseObjectFunction) (void)
       typedef int signo_t

   Functions
       __EXPORT std::ostream & operator<< (std::ostream &os, const IPV4Address &ia)
       struct in_addr getaddress (const IPV4Address &ia)
       __EXPORT std::ostream & operator<< (std::ostream &os, const IPV6Address &ia)
       struct in6_addr getaddress (const IPV6Address &ia)
       __EXPORT AppLog & debug (AppLog &sl)
           Manipulator for debug level.
       __EXPORT AppLog & warn (AppLog &sl)
           Manipulator for warn level.
       __EXPORT AppLog & error (AppLog &sl)
           Manipulator for error level.
       __EXPORT AppLog & emerg (AppLog &sl)
           Manipulator for emerg level.
       __EXPORT AppLog & alert (AppLog &sl)
           Manipulator for alert level.
       __EXPORT AppLog & critical (AppLog &sl)
           Manipulator for critical level.
       __EXPORT AppLog & notice (AppLog &sl)
           Manipulator for notice level.
       __EXPORT AppLog & info (AppLog &sl)
           Manipulator for info level.
       __EXPORT CommandOptionParse * makeCommandOptionParse (int argc, char **argv, const char
           *comment, CommandOption *options=defaultCommandOptionList)
           makeCommandOptionParse will create an implementation of a CommandOptionParse object.
       template<typename T > const T & abs (const T &v)
       __EXPORT void endKeydata (void)
       __EXPORT void * memmove (char *dest, const char *source, size_t length)
       __EXPORT char * strdup (const char *str)
       __EXPORT int lockf (int fd, int mode, long offset)
       char * strtok_r (char *s, const char *d, char **x)
       __EXPORT char * lsetField (char *target, size_t size, const char *src, const char fill=0)
       __EXPORT char * rsetField (char *target, size_t size, const char *src, const char fill=0)
       __EXPORT char * setString (char *target, size_t size, const char *src)
       __EXPORT char * addString (char *target, size_t size, const char *src)
       __EXPORT char * newString (const char *src, size_t size=0)
       __EXPORT void delString (char *str)
       __EXPORT char * setUpper (char *string, size_t size)
       __EXPORT char * setLower (char *string, size_t size)
       __EXPORT char * find (const char *cs, char *str, size_t len=0)
       __EXPORT char * rfind (const char *cs, char *str, size_t len=0)
       __EXPORT char * ifind (const char *cs, char *str, size_t len=0)
       __EXPORT char * strip (const char *cs, char *str, size_t len=0)
       __EXPORT size_t strchop (const char *cs, char *str, size_t len=0)
       __EXPORT size_t strtrim (const char *cs, char *str, size_t len=0)
       char * dupString (const char *src, size_t size=0)
       struct timespec * getTimeout (struct timespec *spec, timeout_t timeout)
       void wait (signo_t signo)
       Thread * getThread (void)
       struct tm * localtime_r (const time_t *t, struct tm *b)
       char * ctime_r (const time_t *t, char *buf)
       struct tm * gmtime_r (const time_t *t, struct tm *b)
       char * asctime_r (const struct tm *tm, char *b)

   Variables
       class __EXPORT IPV4Host
       class __EXPORT IPV6Host
       __EXPORT AppLog alog
           alog global log stream definition
       __EXPORT CommandOption * defaultCommandOptionList
           This defines a linked list head pointer for all the command line options that use the
           default list.
       class __EXPORT MIMEMultipart
       class __EXPORT MIMEItemPart
       class __EXPORT Runlist
       class __EXPORT Runable
       class __EXPORT MapObject
       class __EXPORT MapIndex
       class __EXPORT SerialPort
       class __EXPORT SerialService
       __EXPORT Slog slog
       class __EXPORT SimpleTCPStream
       class __EXPORT SocketPort
       class __EXPORT SocketService
       class __EXPORT Thread
       class __EXPORT ThreadKey
       class __EXPORT Conditional
       class __EXPORT Event

Typedef Documentation

   typedef size_t ost::ccxx_size_t
   typedef std::basic_string<char, cistring_char_traits<char> > ost::cistring
   typedef std::basic_string<char> ost::cstring
   typedef std::string_char_traits<char> ost::cstring_char_traits
   typedef class BaseObject*(* ost::NewBaseObjectFunction) (void)
   typedef unsigned long ost::pos_t
   typedef int ost::signo_t
   typedef unsigned short ost::tpport_t
       Transport Protocol Ports.

       Examples:
           SampleSocketPort.cpp.

Function Documentation

   template<typename T > const T& ost::abs (const T & v) [inline]
   __EXPORT char* ost::addString (char * target, size_t size, const char * src)
   __EXPORT AppLog& ost::alert (AppLog & sl) [inline]
       Manipulator for alert level.

       Parameters:
           sl application logger stream

       Returns:
           application logger stream

       Referenced by ost::AppLog::Ident::c_str().

   char* ost::asctime_r (const struct tm * tm, char * b) [inline]
   __EXPORT AppLog& ost::critical (AppLog & sl) [inline]
       Manipulator for critical level.

       Parameters:
           sl application logger stream

       Returns:
           application logger stream

       Referenced by ost::AppLog::Ident::c_str().

   char* ost::ctime_r (const time_t * t, char * buf) [inline]
   __EXPORT AppLog& ost::debug (AppLog & sl) [inline]
       Manipulator for debug level.

       Parameters:
           sl application logger stream

       Returns:
           application logger stream

       Referenced by ost::AppLog::Ident::c_str().

   __EXPORT void ost::delString (char * str)
   char* ost::dupString (const char * src, size_t size = 0) [inline]
       References newString().

   __EXPORT AppLog& ost::emerg (AppLog & sl) [inline]
       Manipulator for emerg level.

       Parameters:
           sl application logger stream

       Returns:
           application logger stream

       Referenced by ost::AppLog::Ident::c_str().

   __EXPORT void ost::endKeydata (void)
       This should be used before detaching a deamon, exec(), fork(), etc.

       References ost::Keydata::end().

   __EXPORT AppLog& ost::error (AppLog & sl) [inline]
       Manipulator for error level.

       Parameters:
           sl application logger stream

       Returns:
           application logger stream

       Referenced by ost::AppLog::Ident::c_str(), ost::Serial::error(), ost::Socket::error(), and
       ost::RandomFile::error().

   __EXPORT char* ost::find (const char * cs, char * str, size_t len = 0)
       Referenced by ost::String::find().

   struct in_addr ost::getaddress (const IPV4Address & ia)
       References ost::IPV4Address::getAddress().

   struct in6_addr ost::getaddress (const IPV6Address & ia)
       References ost::IPV6Address::getAddress().

   Thread* ost::getThread (void) [inline]
       References ost::Thread::get().

   struct timespec* ost::getTimeout (struct timespec * spec, timeout_t timeout)
   struct tm* ost::gmtime_r (const time_t * t, struct tm * b)
       References ost::SysTime::getGMTTime().

   __EXPORT char* ost::ifind (const char * cs, char * str, size_t len = 0)
   __EXPORT AppLog& ost::info (AppLog & sl) [inline]
       Manipulator for info level.

       Parameters:
           sl application logger stream

       Returns:
           application logger stream

       References __EXPORT, and alog.

       Referenced by ost::AppLog::Ident::c_str().

   struct tm* ost::localtime_r (const time_t * t, struct tm * b)
       References ost::SysTime::getLocalTime().

   __EXPORT int ost::lockf (int fd, int mode, long offset)
   __EXPORT char* ost::lsetField (char * target, size_t size, const char * src, const char fill =
       0)
   __EXPORT CommandOptionParse* ost::makeCommandOptionParse (int argc, char ** argv, const char *
       comment, CommandOption * options = defaultCommandOptionList)
       makeCommandOptionParse will create an implementation of a CommandOptionParse 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.

       Examples:
           cmdlineopt.cpp.

   __EXPORT void* ost::memmove (char * dest, const char * source, size_t length)
   __EXPORT char* ost::newString (const char * src, size_t size = 0)
       Referenced by dupString().

   __EXPORT AppLog& ost::notice (AppLog & sl) [inline]
       Manipulator for notice level.

       Parameters:
           sl application logger stream

       Returns:
           application logger stream

       Referenced by ost::AppLog::Ident::c_str().

   __EXPORT std::ostream& ost::operator<< (std::ostream & os, const IPV4Address & ia)
       Referenced by ost::AppLog::operator()(), ost::String::operator+=(), and
       ost::Engine::read().

   __EXPORT std::ostream& ost::operator<< (std::ostream & os, const IPV6Address & ia)
   __EXPORT char* ost::rfind (const char * cs, char * str, size_t len = 0)
   __EXPORT char* ost::rsetField (char * target, size_t size, const char * src, const char fill =
       0)
   __EXPORT char* ost::setLower (char * string, size_t size)
   __EXPORT char* ost::setString (char * target, size_t size, const char * src)
   __EXPORT char* ost::setUpper (char * string, size_t size)
   __EXPORT size_t ost::strchop (const char * cs, char * str, size_t len = 0)
       Referenced by ost::String::chop().

   __EXPORT char* ost::strdup (const char * str)
   __EXPORT char* ost::strip (const char * cs, char * str, size_t len = 0)
       Referenced by ost::String::chop().

   char* ost::strtok_r (char * s, const char * d, char ** x) [inline]
   __EXPORT size_t ost::strtrim (const char * cs, char * str, size_t len = 0)
       Referenced by ost::String::trim().

   void ost::wait (signo_t signo)
       Examples:
           cmdlineopt.cpp.

       Referenced by ost::Buffer::getUsed().

   __EXPORT AppLog& ost::warn (AppLog & sl) [inline]
       Manipulator for warn level.

       Parameters:
           sl application logger stream

       Returns:
           application logger stream

       Referenced by ost::AppLog::Ident::c_str().

Variable Documentation

   __EXPORT AppLog ost::alog
       alog global log stream definition

       Referenced by info().

   class __EXPORT ost::Conditional
   __EXPORT CommandOption* ost::defaultCommandOptionList
       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.

       Examples:
           cmdlineopt.cpp.

   class __EXPORT ost::Event
   class __EXPORT ost::IPV4Host
   class __EXPORT ost::IPV6Host
   class __EXPORT ost::MapIndex
   class __EXPORT ost::MapObject
   class __EXPORT ost::MIMEItemPart
   class __EXPORT ost::MIMEMultipart
   class __EXPORT ost::Runable
   class __EXPORT ost::Runlist
   class __EXPORT ost::SerialPort
   class __EXPORT ost::SerialService
   class __EXPORT ost::SimpleTCPStream
   __EXPORT Slog ost::slog
       Examples:
           slogTest.cpp.

       Referenced by ost::Slog::info().

   class __EXPORT ost::SocketPort
       Examples:
           SampleSocketPort.cpp.

   class __EXPORT ost::SocketService
       Examples:
           SampleSocketPort.cpp, and tcpservice.cpp.

   class __EXPORT ost::Thread
       Examples:
           SampleSocketPort.cpp.

       Referenced by ost::Thread::clrParent().

   class __EXPORT ost::ThreadKey

Author

       Generated automatically by Doxygen for GNU CommonC++ from the source code.