ost(3)

📦 version 1.8.1, in ubuntu jammy

🎀 ost 🎀

okay bestie, welcome to ost(3) — yes that's section 3 of the Library Functions Manual, the cute little corner of the man pages where the C library functions live. pull up a chair, grab a boba, we're doing this 💅

✨ NAME ✨

ost

that's it. that's the name. ost. no cap, no extra words, the page just says its own name and moves on — iconic honestly 🦋

stay tuned tho, because there's a whole lot more coming and you're gonna wanna see it 👀

✨ SYNOPSIS ✨

okay bestie, buckle UP, because this is the master list of every class this library is serving, and there are so many of them 💅 each one gets a lil one-liner so you know exactly what vibe it's bringing.

🌈 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. your apps journaling their whole life, iconic behavior 🎀
class Assoc — This class is used to associate (object) pointers with named strings. matching names to pointer besties, no cap ✨
class AtomicCounter — The AtomicCounter class offers thread-safe manipulation of an integer counter. counter go up, counter go down, threads never fight over it 🫶
class BaseObject — BaseObject. that's it. that's the whole description, and honestly? slay, minimalism ate 💅
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. fixed-capacity baddie moving objects between producers and consumers 🦋
class Cancellation — A class to automatically set the thread cancellation mode of a member function. sets the mode for you, zero effort required 💖
class ChecksumDigest — A simple checksum digest function. simple. digest. checksum. periodt 🌸
struct cistring_char_traits — no description given, it's just vibing there, mysterious main character energy 👑
class CommandOption — CommandOption is the base class for all command line options. the blueprint every CLI flag descends from 💅
class CommandOptionArg — Class for options with an argument e.g. takes a lil something-something along with the flag ✨
class CommandOptionCollect — It only makes sense to have a single one of these set and it is also exclusive with CommandOptionRest. one only, and it does NOT share the spotlight with CommandOptionRest 🚫
class CommandOptionNoArg — CommandOption type for flags. no arg, just vibes, pure boolean energy 💀
class CommandOptionParse — This is the CommandOptionParse interface class. the interface, the contract, the whole mood 🔥
class CommandOptionRest — It only makes sense to have a single one of these set and it is also exclusive with CommandOptionCollect. same deal as its rival: one only, and never with CommandOptionCollect 🙈
class CommandOptionWithArg — Derived class of CommandOption for options that have a value associated with them. flags that come with a whole plus-one 💜
class Conditional — A conditional variable synchcronization object for one to one and one to many signal and control events between processes. signaling across processes, one-to-one and one-to-many, the social butterfly of sync objects 🦋
class Counter — The counter template is used for generic objects which act as automatic counters. generic auto-counting, it just does it 🎀
class CRC16Digest — A crc16 collection/compution hash accumulator class. crc16 accumulation, collecting and computing 🌈
class CRC32Digest — A crc32 collection/computation hash accumulator class. crc32 edition, same energy, more bits ⭐
class Date — The Date class uses a julian date representation of the current year, month, and day. julian date representation of year/month/day, keeping it old-school 💅
class DateNumber — A number class that manipulates a string buffer that is also a date. a number that's secretly a date, double life fr fr 😭
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. julian date for the day, integer for the time, both at once, multitasking queen 👑
class DCCPSocket — DCCP sockets are used for stream based connected sessions between two sockets. stream-based connected sessions between two sockets 💖
class Digest — The digest base class is used for implementing and deriving one way hashing functions. the base class for one-way hashing, the ancestor of all the digests 🌸
class Dir — A low level portable directory class. low level, portable, directories, we love to see it ✨
class DirTree — A generic class to walk a hierarchical directory structure. walking the whole tree structure like it's a runway 💅
class DSO — The DSO dynamic loader class is used to load object files. loading object files dynamically, popping off 🔥
class Engine — Engine. just Engine. iconic, mysterious, no notes 🎀
class Event — The Event class implements a feature originally found in the WIN32 API; event notification. straight from the WIN32 API, event notification, retro but make it serve 💜
class File — no description given, it's just File, being File, the moment 🦋
class FixedBuffer — A buffer class that holds a known capacity of fixed sized objects defined during creation. capacity locked in at creation time, fixed-size objects only 🫶
class HEXdump — Produces a dump of a buffer in a hexdump way with its code Ascii translation and relative buffer address. hex + ascii + relative buffer address, the full aesthetic 😭
class IPV4Address — The network name and address objects are all derived from a common IPV4Address base class. the common ancestor every network name and address object descends from 🌈
class IPV4Broadcast — The broadcast address object is used to store the broadcast address for a specific subnet. storing the broadcast address for a specific subnet, doing its one job 💅
class IPV4Cidr — The CIDR class is used to support routing tables and validate address policies. routing tables + address policy validation, the responsible one ⭐
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. holding the real, valid internet address of a host you'll reach 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. " masking addresses like 255.255.255.0 live right here 🎀
class IPV4Multicast — A specialization of IPV4Address that provides address validation for multicast addresses. IPV4Address but specialized for multicast validation 🌸
class IPV4MulticastValidator — Class for the function object that validates multicast addresses. the function object that does the multicast validating 💅
class IPV4Validator — Classes derived from IPV4Address would require an specific validator to pass to the IPV4Address constructor. derived classes gotta hand a specific validator to the IPV4Address constructor, rules are rules ✨
class IPV6Address — The network name and address objects are all derived from a common IPV6Address base class. same deal as v4, but make it IPV6, the common base class 🦋
class IPV6Broadcast — The broadcast address object is used to store the broadcast address for a specific subnet. broadcast address for a specific subnet, holding it down 💜
class IPV6Cidr — The CIDR class is used to support routing tables and validate address policies. routing tables and address policy validation, v6 flavor 🔥
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. the actual valid internet address of a host, socket-bound 👑
class IPV6Mask — Internet addresses used specifically as masking addresses (such as ' 255.255.255.0') are held in the IPV6Mask derived object. " masking addresses like 255.255.255.0 but in the IPV6Mask derived object 🎀
class IPV6Multicast — A specialization of IPV6Address that provides address validation for multicast addresses. specialized IPV6Address with multicast validation on board 🌈
class IPV6MulticastValidator — Class for the function object that validates multicast addresses. the multicast-validating function object, v6 edition ⭐
class IPV6Validator — Classes derived from IPV6Address would require an specific validator to pass to the IPV6Address constructor. derived classes must pass a specific validator to the IPV6Address constructor, no skipping 💅
class IZStream — no description given, it's just out here existing, z-streaming silently 🦋
class Keydata — Keydata objects are used to load and hold 'configuration' data for a given application. loading and holding an app's config data, the keeper of secrets 🎀
class keyMap — no description given, a quiet little keymap just doing its thing 💜
class LinkedDouble — Self managed double linked list object chain. self-managed doubly linked chain, handling itself fr fr ✨
class LinkedSingle — Self managed single linked list object chain. single linked version, still fully self-managed 💖
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. named lock entities keeping multiple processes from stepping on each other 🌸
class MapIndex — The MapIndex allows linear access into a MapTable, that otherwise could have its elements being retrieved only by key. linear access into a MapTable that normally only gives you elements by key, glow up 🔥
class MapObject — The MapObject is a base class which can be used to make a derived class operate on a MapTable. base class so your derived class can operate on a MapTable 💅
class MappedFile — Create and map a disk file into memory. disk file → memory, mapped, done 👑
class MapTable — A map table allows for entities to be mapped (hash index) onto it. entities get hash-indexed onto it, mapping behavior 🦋
class MD5Digest — A md5 collection/computation accululator class. md5 accumulating, collecting, computing, the whole trio 🌈
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. cumulative memory pages for object-specific 'persistant' data that lives as long as the derived object does ⭐
class MemPagerObject — This class is used to create derived classes which are constructed within a memory pager pool. derived classes get constructed inside a memory pager pool, cozy 💜
class MIMEFormData — This is a document part type for use in submitting multipart form data to a web server. a document part type for shipping 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. attaching an item part to a MIME multipart doc mid-stream ✨
class MIMEMultipart — A container class for multi-part MIME document objects which can be streamed to a std::ostream destination. container for multi-part MIME docs, streamable straight to a std::ostream 💅
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. purpose-built MIME multipart for building and delivering form data to a web server via post 🫶
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. one thread at a time in the protected section, no line-jumping 💖
class MutexCounter — The Mutex Counter is a counter variable which can safely be incremented or decremented by multiple threads. a counter that many threads can safely bump up and down, team effort 🌸
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. same protection energy, single-thread-at-a-time, locked in 🔥
class NetworkDeviceInfo — Network device information class. it's the class. for network device info. it tells you things 🎀
class Number — A number manipulation class. numbers, manipulated, that's the pitch 💜
class objCounter — Generic template class for creating classes which maintain an active count of the number of instances currently in active use. template that keeps a live count of how many instances are currently in use, keeping tabs 👑
class objList — Used to create and manage a single linked list of objects of a common type. single linked list of same-type objects, managed for you 🦋
class objMap — Used to create and manage a hash index of objects through a common type. hash index of objects, all 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. every instance shares one static mutex, so the whole class gets a global lock 🌈
class OZStream — no description given, sitting quietly next to its sibling IZStream, mysterious 💅
class Pointer — Used to create and manage referece counted pointers. reference counted pointers, created and managed, no leaks no drama 💖
class PosixThread — no description given, it's a PosixThread, it's threading, it's posix, iconic 🎀
class Process — A class for containing portable process related functions that help create portable code. portable process functions so your code stays portable, helpful king 🫶
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. base class for low level random file access that travels between Win32 and Posix 💜
class ReadLock — The ReadLock class is used to protect a section of code through a ThreadLock for 'read' access to the member function. locks a code section via a ThreadLock for 'read' access to the member function 🌸
class RefObject — A reference countable object. countable by reference, that's the whole personality 🔥
class RefPointer — Pointer to reference counted objects. a pointer that points at reference counted objects, doing the pointing 👑
class Runable — A container for objects that can be queued against a runlist. holds objects that can be queued up against a runlist 🦋
class Runlist — A runlist is used to restrict concurrent exection to a limited set of concurrent sessions, much like a semaphore. caps concurrent execution to a limited set of sessions, semaphore-adjacent behavior ⭐
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. syncs threads or guards a limited finite resource like 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. protects a section so only x instances of the member function run at once, math but make it safe 💅
class Serial — The Serial class is used as the base for all serial I/O services under APE. the base for every serial I/O service under APE, founding mother 💖
class SerialPort — The serial port is an internal class which is attached to and then serviced by a specified SerialService thread. internal class, attached to and serviced by a specified SerialService thread 🎀
class SerialService — The SerialService is a thead service object that is meant to service attached serial ports. a thread service object that services whatever serial ports are attached 🫶
class SharedFile — This class defines a database I/O file service that can be shared by multiple processes. a database I/O file service shared across multiple processes, generous 🌸
class SharedMemPager — The shared mempager uses a mutex to protect key access methods. shared mempager with a mutex guarding the key access methods 🔥
class SimpleTCPStream — Simple TCP Stream, to be used with Common C++ Library. simple TCP stream, built for the Common C++ Library, uncomplicated and proud 👑
class Slog — The slog class is used to stream messages to the system's logging facility (syslogd). streams your messages to syslogd, the system logging facility 🦋
class Socket — The Socket is used as the base for all Internet protocol services under Common C++. the base for every Internet protocol service under Common C++, the blueprint ⭐
class SocketPort — The socket port is an internal class which is attached to and then serviced by a specific SocketService 'object'. internal class, attached to and serviced by a specific SocketService 'object' 🌈
class SocketService — The SocketService is a thread pool object that is meant to service

bestie we are NOT done yet, there is so much more coming, stay with me 💅✨

attached socket ports. (yep, that's the tail end of the entry right above — we're picking up mid-list, no big deal, just vibing 🫶)

class SSLStream — listed here with no blurb attached, so we're respecting the mystery ✨
class SString — also serving silent, iconic, no notes 💅
class StackPager — this one is a whole repository for stashing and grabbing your working data in last-in-first-out order. Stack behavior, stack energy 📚
class String — a generic and portable string class. Your everyday string bestie 🎀
class StringObject — you use this one to derive subclasses that lean on the String managed memory pool for all space allocations, by overriding the new and delete operators. Memory pool queen 👑
class StringTokenizer — splits a delimited string into tokens. Snip snip ✂️
class SysTime — your access point to the non-reentrant date and time functions sitting in the standard C library ⏰
class TCPSession — primarily there to represent a client connection that can be managed on a separate thread 🧵
class TCPSocket — TCP sockets are for stream based connected sessions between two sockets 🔌
class TCPStream — TCP streams represent TCP client connections to a server, used by TCP protocol servers for accepting client connections 🌊
class TCPV6Socket — TCPV6 sockets are for stream based connected sessions between two ipv6 sockets 💫
class Thread — every single thread of execution in an application gets created by instantiating an object of a class derived from the Thread class. That's the whole vibe 🧵✨
class ThreadFile — defines a database I/O file service that multiple threads can share 🤝
class ThreadKey — lets you create a thread context unique 'pointer' that you can set and retrieve, and you can use it to build thread specific data areas for implementing 'thread safe' library routines 🔑
class ThreadLock — impliments a thread rwlock for optimal reader performance on systems that have rwlock support, and falls back to a simple mutex for the systems that don't. Adaptable queen 🔒
class ThreadQueue — a somewhat generic queue processing class, there to establish a producer consumer queue 📥📤
class Time — uses an integer representation of the current time 🔢
class TimerPort — timer ports give you synchronized timing events when they're managed under a 'service thread' like SocketService ⏱️
class TTYSession — aggragates a TTYStream and a Common C++ Thread, which is assumed to be the execution context that'll be doing the actual I/O operations 🖥️
class TTYStream — TTY streams represent serial connections that are fully 'streamable' objects, using C++ stream classes and friends 🌈
class ttystream — a more natural C++ 'ttystream' class, made for non-threaded applications 🍓
class TypeManager — manages the types for generation of the persistent objects 🗂️
class UDPBroadcast — represents a UDP socket used for subnet broadcasts, and gives you an alternate binding plus 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 — one half of a two-way UDP connection: the UDP receiver can receive data from another peer host or from a subnet 📨
class UDPSocket — UDP sockets implement the TCP SOCK_DGRAM UDP protocol 🎯
class UDPTransmit — the other 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 primarily to represent a client connection that can be managed on a separate thread 🧵
class UnixSocket — Unix domain sockets are for stream based connected sessions between processes on the same machine 🏠
class unixstream — a more natural C++ 'unixstream' class for non-threaded applications 🦋
class UnixStream — Unix streams represent Unix domain client connections to a local server, for accepting client connections 🌉
class URLStream — a URL processing version of TCPStream 🔗
class WriteLock — used to protect a section of code through a ThreadLock, for 'write' access to the member function ✍️
class XMLRPC — impliments a core XMLRPC service without the underlying transports 📦
class XMLStream — impliments a basic XML stream parser that you can use to examine an XML resource thru virtual I/O methods 🔍
class ZNumber — no blurb here either. Mysterious. We love that for them 🫥

✨ Typedefs ✨

typedef unsigned short tpport_t — Transport Protocol Ports. The port type, right there 💅
typedef unsigned long pos_t — a position type, unsigned long flavored 📍
typedef size_t ccxx_size_t — size type, all dressed up 📏
typedef std::string_char_traits< char > cstring_char_traits — the char traits for cstring 🎀
typedef std::basic_string< char > cstring — your plain basic string of char 🧵
typedef std::basic_string< char, cistring_char_traits< char > > cistring — the case-insensitive sibling of cstring 💅
typedef class BaseObject *(* NewBaseObjectFunction) (void) — a function pointer type returning a BaseObject *, taking void 🏭
typedef int signo_t — signal number type, int in a trench coat 🚨

🔥 Functions 🔥

__EXPORT std::ostream & operator<< (std::ostream &os, const IPV4Address &ia) — streams out an IPV4Address 📤
struct in_addr getaddress (const IPV4Address &ia) — pulls the struct in_addr out of an IPV4Address 🔎
__EXPORT std::ostream & operator<< (std::ostream &os, const IPV6Address &ia) — streams out an IPV6Address 📤
struct in6_addr getaddress (const IPV6Address &ia) — pulls the struct in6_addr out of an IPV6Address 🔎
__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) — the templated absolute value, doing its thing ➕
__EXPORT void endKeydata (void) — ends the keydata 🔚
__EXPORT void * memmove (char *dest, const char *source, size_t length) — the portable memmove shim 🧳
__EXPORT char * strdup (const char *str) — the portable strdup shim 📋
__EXPORT int lockf (int fd, int mode, long offset) — the portable lockf shim 🔒
char * strtok_r (char *s, const char *d, char **x) — the portable reentrant strtok_r shim ✂️
__EXPORT char * lsetField (char *target, size_t size, const char *src, const char fill=0) — sets a field, left-aligned, with an optional fill 🎀
__EXPORT char * rsetField (char *target, size_t size, const char *src, const char fill=0) — sets a field, right-aligned, with an optional fill 🎀
__EXPORT char * setString (char *target, size_t size, const char *src) — sets a string into target 📝
__EXPORT char * addString (char *target, size_t size, const char *src) — appends a string onto target ➕
__EXPORT char * newString (const char *src, size_t size=0) — makes you a brand new string ✨
__EXPORT void delString (char *str) — deletes that string, bye bestie 👋
__EXPORT char * setUpper (char *string, size_t size) — uppercases the string 🔠
__EXPORT char * setLower (char *string, size_t size) — lowercases the string 🔡
__EXPORT char * find (const char *cs, char *str, size_t len=0) — finds cs in str 🔍
__EXPORT char * rfind (const char *cs, char *str, size_t len=0) — finds cs in str, from the back 🔍
__EXPORT char * ifind (const char *cs, char *str, size_t len=0) — finds cs in str, case-insensitively 🙈
__EXPORT char * strip (const char *cs, char *str, size_t len=0) — strips cs out of str 🧼
__EXPORT size_t strchop (const char *cs, char *str, size_t len=0) — chops str at cs 🪓
__EXPORT size_t strtrim (const char *cs, char *str, size_t len=0) — trims str with cs ✂️
char * dupString (const char *src, size_t size=0) — duplicates a string 🪞
__EXPORT std::istream & getline (std::istream &is, String &str, char delim='0, size_t size=0) — grabs a line from the stream into a String 📥
struct timespec * getTimeout (struct timespec *spec, timeout_t timeout) — turns a timeout_t into a struct timespec * ⏳
void wait (signo_t signo) — waits on a signal 🛑
Thread * getThread (void) — hands you the current Thread * 🧵
struct tm * localtime_r (const time_t *t, struct tm *b) — the portable reentrant localtime_r shim 🕐
char * ctime_r (const time_t *t, char *buf) — the portable reentrant ctime_r shim 🕑
struct tm * gmtime_r (const time_t *t, struct tm *b) — the portable reentrant gmtime_r shim 🌍
char * asctime_r (const struct tm *tm, char *b) — the portable reentrant asctime_r shim 🕒

🌈 Variables 🌈

class __EXPORT IPV4Host — an exported IPV4Host 🏠
class __EXPORT IPV6Host — an exported 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 — an exported MIMEMultipart 📧
class __EXPORT MIMEItemPart — an exported MIMEItemPart 📧
class __EXPORT Runlist — an exported Runlist 📋
class __EXPORT Runable — an exported Runable 🏃
class __EXPORT MapObject — an exported MapObject 🗺️
class __EXPORT MapIndex — an exported MapIndex 🗺️
class __EXPORT SerialPort — an exported SerialPort 🔌
class __EXPORT SerialService — an exported SerialService 🔌
__EXPORT Slog slog — the slog 🪵
class __EXPORT SimpleTCPStream — an exported SimpleTCPStream 🌊
class __EXPORT SocketPort — an exported SocketPort 🧦
class __EXPORT SocketService — an exported SocketService 🧦
class __EXPORT Thread — an exported Thread 🧵
class __EXPORT ThreadKey — an exported ThreadKey 🔑
class __EXPORT Conditional — an exported Conditional ⚖️
class __EXPORT Event — an exported Event 🎉

📚 Typedef Documentation 📚

typedef size_t ost::ccxx_size_t — the ost namespaced size type 📏
typedef std::basic_string<char, cistring_char_traits<char> > ost::cistring — the ost case-insensitive string 💅
typedef std::basic_string<char> ost::cstring — the ost plain basic string of char 🎀
typedef std::string_char_traits<char> ost::cstring_char_traits — the ost char traits for cstring 🧵
typedef class BaseObject*(* ost::NewBaseObjectFunction) (void) — the ost function pointer type returning a BaseObject *, taking void 🏭
typedef unsigned long ost::pos_t — the ost position type 📍
typedef int ost::signo_t — the ost signal number type 🚨
typedef unsigned short ost::tpport_t — Transport Protocol Ports 🚪

Examples

SampleSocketPort.cpp 🌟

✨ Function Documentation ✨

Okay bestie, this is the big one: every single function documented here, in order, no skips, no cap. 💖

template<typename T > const T& ost::abs (const T & v) [inline] — literally just the signature, no extra lore in the original. slay
__EXPORT char* ost::addString (char * target, size_t size, const char * src) — signature only, bestie.
__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] — no extra description, just vibes.
__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] — signature only.
__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) — signature only.
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] — signature only.
struct in6_addr ost::getaddress (const IPV6Address & ia) [inline] — signature only.
__EXPORT std::istream& ost::getline (std::istream & is, String & str, char delim = '0, size_t size = 0) — okay so this one has parameters.
- 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) — signature only.
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) — signature only.
__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) — signature only.
__EXPORT char* ost::lsetField (char * target, size_t size, const char * src, const char fill = 0) — signature only.
__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) — signature only.
__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) — signature only.
__EXPORT std::ostream& ost::operator<< (std::ostream & os, const IPV6Address & ia) — signature only.
__EXPORT char* ost::rfind (const char * cs, char * str, size_t len = 0) — signature only.
__EXPORT char* ost::rsetField (char * target, size_t size, const char * src, const char fill = 0) — signature only.
__EXPORT char* ost::setLower (char * string, size_t size) — signature only.
__EXPORT char* ost::setString (char * target, size_t size, const char * src) — signature only.
__EXPORT char* ost::setUpper (char * string, size_t size) — signature only.
__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) — signature only.
__EXPORT char* ost::strip (const char * cs, char * str, size_t len = 0) — signature only.
char* ost::strtok_r (char * s, const char * d, char ** x) [inline] — signature only.
__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) — signature only, but it has examples.
- 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 — class declaration, no extra tea.
__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 declaration.
class __EXPORT ost::IPV4Host — class declaration.
class __EXPORT ost::IPV6Host — class declaration.
class __EXPORT ost::MapIndex — class declaration.
class __EXPORT ost::MapObject — class declaration.
class __EXPORT ost::MIMEItemPart — class declaration.
class __EXPORT ost::MIMEMultipart — class declaration.
class __EXPORT ost::Runable — class declaration.
class __EXPORT ost::Runlist — class declaration.
class __EXPORT ost::SerialPort — class declaration.
class __EXPORT ost::SerialService — class declaration.
class __EXPORT ost::SimpleTCPStream — class declaration.
__EXPORT Slog ost::slog [extern] — no description given.
- Examples: slogTest.cpp.
class __EXPORT ost::SocketPort — class declaration.
- Examples: SampleSocketPort.cpp.
class __EXPORT ost::SocketService — class declaration.
- Examples: SampleSocketPort.cpp, and tcpservice.cpp.
class __EXPORT ost::Thread — class declaration.
- Examples: SampleSocketPort.cpp.
class __EXPORT ost::ThreadKey — class declaration.

💖 Author 💖

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

This page is from GNU CommonC++ and dated Sun Dec 27 2020, and it's ost(3) forever. Bye bestie! 💅🦋

📦 where this page comes from

ubuntu jammy: libcommoncpp2-doc 1.8.1-10
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-14: a language model's rewrite of the original, under its terms