---
name: "ost"
section: "3"
platform: "linux"
package: "libcommoncpp2-doc"
version: "1.8.1-10"
release: "Debian 11 (Bullseye)"
platforms: ["linux"]
url: "https://new.carta.tech/ost"
---

# ost(3)

## 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)\
 **\_\_EXPORT** std::istream & **getline** (std::istream &is, **String** &str, char delim='\\n', 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

### 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

### 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

### \_\_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

### \_\_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::RandomFile::error(), ost::Serial::error(), and ost::Socket::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)` [inline]`

### struct in6\_addr ost::getaddress (const IPV6Address & ia)` [inline]`

### \_\_EXPORT std::istream& ost::getline (std::istream & is, String & str, char delim = `'\n'`, size\_t size = `0`)

**Parameters**

*is* stream to read. \
 *str* string to save into. \
 *delim* deliminator to use. \
 *size* optional size limitor.

### 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)` [inline]`

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

### struct tm\* ost::localtime\_r (const time\_t \* t, struct tm \* b)` [inline]`

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)](/getopt_long/3.md). 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

### \_\_EXPORT std::ostream& ost::operator\<\< (std::ostream & os, const IPV4Address & ia)

### \_\_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`)

### 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**.

### \_\_EXPORT AppLog& ost::warn (AppLog & sl)` [inline]`

Manipulator for warn level.

**Parameters**

*sl* application logger stream

**Returns**

application logger stream

## Variable Documentation

### \_\_EXPORT AppLog ost::alog` [extern]`

alog global log stream definition

### class \_\_EXPORT ost::Conditional

### \_\_EXPORT CommandOption\* ost::defaultCommandOptionList` [extern]`

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` [extern]`

**Examples** **slogTest.cpp**.

### class \_\_EXPORT ost::SocketPort

**Examples** **SampleSocketPort.cpp**.

### class \_\_EXPORT ost::SocketService

**Examples** **SampleSocketPort.cpp**, and **tcpservice.cpp**.

### class \_\_EXPORT ost::Thread

**Examples** **SampleSocketPort.cpp**.

### class \_\_EXPORT ost::ThreadKey

## Author

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