::

namespace Poco

Overview

Namespaces: ActiveRecord, CodeGeneration, CppParser, Crypto, Data, Details, Dynamic, Impl, JSON, JWT, MongoDB, Net, OSP, Prometheus, Redis, RemotingNG, Util, XML, XSD, Zip

Classes: ASCIIEncoding, AbstractCache, AbstractDelegate, AbstractEvent, AbstractInstantiator, AbstractMetaObject, AbstractObserver, AbstractPriorityDelegate, AbstractStrategy, AbstractTimerCallback, AccessExpirationDecorator, AccessExpireCache, AccessExpireLRUCache, AccessExpireStrategy, ActiveDispatcher, ActiveMethod, ActiveResult, ActiveResultHolder, ActiveRunnable, ActiveRunnableBase, ActiveStarter, ActiveThreadPool, Activity, ApplicationException, ArchiveByNumberStrategy, ArchiveByTimestampStrategy, ArchiveStrategy, Array, Ascii, AssertionViolationException, AsyncChannel, AtomicCounter, AtomicFlag, AutoPtr, AutoReleasePool, BadCastException, Base32Decoder, Base32DecoderBuf, Base32DecoderIOS, Base32Encoder, Base32EncoderBuf, Base32EncoderIOS, Base64Decoder, Base64DecoderBuf, Base64DecoderIOS, Base64Encoder, Base64EncoderBuf, Base64EncoderIOS, BasicBufferedBidirectionalStreamBuf, BasicBufferedStreamBuf, BasicEvent, BasicFIFOBuffer, BasicMemoryBinaryReader, BasicMemoryBinaryWriter, BasicMemoryStreamBuf, BasicUnbufferedStreamBuf, BinaryReader, BinaryWriter, Buffer, BufferAllocator, Bugcheck, BugcheckException, ByteOrder, CILess, Channel, Checksum, ChildrenFirstTraverse, CircularReferenceException, ClassLoader, Clock, ColorConsoleChannel, Condition, Configurable, ConsoleChannel, CountingIOS, CountingInputStream, CountingOutputStream, CountingStreamBuf, CreateFileException, DataException, DataFormatException, DataURIStream, DataURIStreamFactory, DataURIStreamIOS, DateTime, DateTimeFormat, DateTimeFormatter, DateTimeParser, Debugger, DefaultStrategy, DeflatingIOS, DeflatingInputStream, DeflatingOutputStream, DeflatingStreamBuf, Delegate, DigestBuf, DigestEngine, DigestIOS, DigestInputStream, DigestOutputStream, DirectoryIterator, DirectoryNotEmptyException, DirectoryWatcher, DoubleByteEncoding, DynamicFactory, EOFToken, Environment, Error, ErrorHandler, Event, EventArgs, EventChannel, EventLogChannel, Exception, ExistsException, ExpirationDecorator, Expire, ExpireCache, ExpireLRUCache, ExpireStrategy, FIFOBufferStream, FIFOBufferStreamBuf, FIFOEvent, FIFOIOS, FIFOStrategy, FPEnvironment, FastMemoryPool, FastMutex, File, FileAccessDeniedException, FileChannel, FileException, FileExistsException, FileIOS, FileInputStream, FileNotFoundException, FileNotReadyException, FileOutputStream, FileReadOnlyException, FileStream, FileStreamFactory, Formatter, FormattingChannel, FunctionDelegate, FunctionPriorityDelegate, Getter, Glob, HMACEngine, Hash, HashFunction, HashMap, HashMapEntry, HashMapEntryHash, HashSet, HashStatistic, HashTable, HexBinaryDecoder, HexBinaryDecoderBuf, HexBinaryDecoderIOS, HexBinaryEncoder, HexBinaryEncoderBuf, HexBinaryEncoderIOS, IOException, IllegalStateException, InflatingIOS, InflatingInputStream, InflatingOutputStream, InflatingStreamBuf, InputLineEndingConverter, InputStreamConverter, Instantiator, InvalidAccessException, InvalidArgumentException, InvalidToken, IsConst, IsReference, KeyValueArgs, LRUCache, LRUStrategy, Latin1Encoding, Latin2Encoding, Latin9Encoding, LibraryAlreadyLoadedException, LibraryLoadException, LineEnding, LineEndingConverterIOS, LineEndingConverterStreamBuf, LinearHashTable, ListMap, LocalDateTime, LogFile, LogIOS, LogStream, LogStreamBuf, Logger, LoggingFactory, LoggingRegistry, LogicException, MD4Engine, MD5Engine, MacCentralEurRomanEncoding, MacChineseSimpEncoding, MacChineseTradEncoding, MacCyrillicEncoding, MacJapaneseEncoding, MacKoreanEncoding, MacRomanEncoding, Manifest, ManifestBase, MemoryIOS, MemoryInputStream, MemoryOutputStream, MemoryPool, Message, MetaObject, MetaSingleton, Mutex, NDCScope, NObserver, NamedEvent, NamedMutex, NamedTuple, NestedDiagnosticContext, NoPermissionException, NoThreadAvailableException, NotFoundException, NotImplementedException, Notification, NotificationCenter, NotificationQueue, NotificationStrategy, NullChannel, NullIOS, NullInputStream, NullMutex, NullOutputStream, NullPointerException, NullPurgeStrategy, NullRotateStrategy, NullStreamBuf, NullTypeList, NullValueException, Nullable, NumberFormatter, NumberParser, ObjectPool, Observer, OpenFileException, Optional, OutOfMemoryException, OutputLineEndingConverter, OutputStreamConverter, PBKDF2Engine, PIDFile, Path, PathNotFoundException, PathSyntaxException, PatternFormatter, Pipe, PipeIOS, PipeInputStream, PipeOutputStream, PipeStreamBuf, PoolOverflowException, PoolableObjectFactory, PriorityDelegate, PriorityEvent, PriorityExpire, PriorityNotificationQueue, PriorityStrategy, Process, ProcessHandle, ProcessRunner, PropertyNotSupportedException, ProtocolException, PurgeByAgeStrategy, PurgeByCountStrategy, PurgeStrategy, RWLock, Random, RandomBuf, RandomIOS, RandomInputStream, RangeException, ReadFileException, RecursiveDirectoryIterator, RecursiveDirectoryIteratorImpl, RefCountedObject, ReferenceCounter, RegularExpression, RegularExpressionException, ReleaseArrayPolicy, ReleasePolicy, RotateAtTimeStrategy, RotateByIntervalStrategy, RotateBySizeStrategy, RotateStrategy, Runnable, RunnableAdapter, RuntimeException, SHA1Engine, SHA2Engine, SHA2Engine224, SHA2Engine256, SHA2Engine384, SHA2Engine512, ScopedLock, ScopedLockWithUnlock, ScopedRWLock, ScopedReadRWLock, ScopedUnlock, ScopedWriteRWLock, Semaphore, SharedLibrary, SharedMemory, SharedPtr, SiblingsFirstTraverse, SignalException, SignalHandler, SimpleFileChannel, SimpleHashTable, SingletonHolder, SortedDirectoryIterator, SpinlockMutex, SplitterChannel, Stopwatch, StrategyCollection, StreamChannel, StreamConverterBuf, StreamConverterIOS, StreamCopier, StreamTokenizer, StringTokenizer, SynchronizedObject, SyntaxException, SyslogChannel, SystemException, TLSAbstractSlot, TLSSlot, Task, TaskCancelledNotification, TaskCustomNotification, TaskFailedNotification, TaskFinishedNotification, TaskManager, TaskNotification, TaskProgressNotification, TaskStartedNotification, TeeIOS, TeeInputStream, TeeOutputStream, TeeStreamBuf, TemporaryFile, TextBufferIterator, TextConverter, TextEncoding, TextIterator, Thread, ThreadLocal, ThreadLocalStorage, ThreadPool, ThreadTarget, TimedNotificationQueue, TimeoutException, Timer, TimerCallback, Timespan, Timestamp, Timezone, Token, TooManyURIRedirectsException, TraverseBase, Tuple, TypeList, TypeListType, TypeSizeGT, TypeSizeLE, TypeWrapper, URI, URIRedirection, URIStreamFactory, URIStreamOpener, URISyntaxException, UTF16CharTraits, UTF16Encoding, UTF32CharTraits, UTF32Encoding, UTF8, UTF8Encoding, UUID, UUIDGenerator, UnhandledException, Unicode, UnicodeConverter, UniqueAccessExpireCache, UniqueAccessExpireLRUCache, UniqueAccessExpireStrategy, UniqueExpireCache, UniqueExpireLRUCache, UniqueExpireStrategy, UnknownURISchemeException, ValidArgs, Void, WhitespaceToken, Windows1250Encoding, Windows1251Encoding, Windows1252Encoding, Windows1253Encoding, Windows1254Encoding, Windows1255Encoding, Windows1256Encoding, Windows1257Encoding, Windows1258Encoding, Windows874Encoding, Windows932Encoding, Windows936Encoding, Windows949Encoding, Windows950Encoding, WindowsColorConsoleChannel, WindowsConsoleChannel, WriteFileException, i_char_traits

Types: BufferedBidirectionalStreamBuf, BufferedStreamBuf, DynamicAny, FIFOBuffer, FPE, MemoryBinaryReader, MemoryBinaryWriter, MemoryStreamBuf, NDC, SiblingsFirstRecursiveDirectoryIterator, SimpleRecursiveDirectoryIterator, UTF16Char, UTF16String, UTF32Char, UTF32String, UnbufferedStreamBuf, istring

Types Aliases: DynamicStruct, Int16, Int32, Int64, Int8, IntPtr, OrderedDynamicStruct, UInt16, UInt32, UInt64, UInt8, UIntPtr

Functions: cat, decimalSeparator, delegate, doubleToFixedStr, doubleToStr, endsWith, floatToFixedStr, floatToStr, format, formatAny, hash, hashCombine, hashRange, icompare, intToStr, isIntOverflow, isNegative, isSafeIntCast, isubstr, makeAuto, makeShared, makeSharedArray, operator !=, operator &, operator &=, operator <, operator <<, operator <=, operator ==, operator >, operator >=, operator [], operator |, operator |=, priorityDelegate, registerExtraEncodings, remove, removeInPlace, replace, replaceInPlace, safeIntCast, safeMultiply, startsWith, strToDouble, strToFloat, strToInt, swap, thousandSeparator, toJSON, toLower, toLowerInPlace, toUpper, toUpperInPlace, translate, translateInPlace, trim, trimInPlace, trimLeft, trimLeftInPlace, trimRight, trimRightInPlace, uIntToStr

Namespaces

namespace ActiveRecord

namespace CodeGeneration

namespace CppParser

namespace Crypto

namespace Data

namespace Details

namespace Dynamic

namespace Impl

namespace JSON

namespace JWT

namespace MongoDB

namespace Net

namespace OSP

namespace Prometheus

namespace Redis

namespace RemotingNG

namespace Util

namespace XML

namespace XSD

namespace Zip

Classes

class ASCIIEncoding

7-bit ASCII text encoding. 

class AbstractCache

An AbstractCache is the interface of all caches. 

class AbstractDelegate

Base class for Delegate and Expire

class AbstractEvent

An AbstractEvent is the base class of all events. 

class AbstractInstantiator

The common base class for all Instantiator instantiations. 

class AbstractMetaObject

A MetaObject stores some information about a C++ class. 

class AbstractObserver

The base class for all instantiations of the Observer and NObserver template classes. 

class AbstractPriorityDelegate

Base class for PriorityDelegate and PriorityExpire

class AbstractStrategy

An AbstractStrategy is the interface for all strategies. 

class AbstractTimerCallback

This is the base class for all instantiations of the TimerCallback template. 

class AccessExpirationDecorator

AccessExpirationDecorator adds an expiration method to values so that they can be used with the UniqueAccessExpireCache 

class AccessExpireCache

An AccessExpireCache caches entries for a fixed time period (per default 10 minutes). 

class AccessExpireLRUCache

An AccessExpireLRUCache combines LRU caching and time based expire caching. 

class AccessExpireStrategy

An AccessExpireStrategy implements time and access based expiration of cache entries 

class ActiveDispatcher

This class is used to implement an active object with strictly serialized method execution. 

class ActiveMethod

An active method is a method that, when called, executes in its own thread. 

class ActiveResult

Creates an ActiveResultHolder

class ActiveResultHolder

This class holds the result of an asynchronous method invocation. 

class ActiveRunnable

This class is used by ActiveMethod

class ActiveRunnableBase

The base class for all ActiveRunnable instantiations. 

class ActiveStarter

The default implementation of the StarterType policy for ActiveMethod

class ActiveThreadPool

A thread pool always keeps a number of threads running, ready to accept work. 

class Activity

This template class helps to implement active objects. 

class ApplicationException

 

class ArchiveByNumberStrategy

A monotonic increasing number is appended to the log file name. 

class ArchiveByTimestampStrategy

A timestamp (YYYYMMDDhhmmssiii) is appended to archived log files. 

class ArchiveStrategy

The ArchiveStrategy is used by FileChannel to rename a rotated log file for archiving. 

class Array

STL container like C-style array replacement class. 

class Ascii

This class contains enumerations and static utility functions for dealing with ASCII characters and their properties. 

class AssertionViolationException

 

class AsyncChannel

A channel uses a separate thread for logging. 

class AtomicCounter

This class implements a simple counter, which provides atomic operations that are safe to use in a multithreaded environment. 

class AtomicFlag

This class implements an atomic boolean flag by wrapping the std::atomic_flag. 

class AutoPtr

AutoPtr is a "smart" pointer for classes implementing reference counting based garbage collection. 

class AutoReleasePool

An AutoReleasePool implements simple garbage collection for reference-counted objects. 

class BadCastException

 

class Base32Decoder

This istream base32-decodes all data read from the istream connected to it. 

class Base32DecoderBuf

This streambuf base32-decodes all data read from the istream connected to it. 

class Base32DecoderIOS

The base class for Base32Decoder

class Base32Encoder

This ostream base32-encodes all data written to it and forwards it to a connected ostream. 

class Base32EncoderBuf

This streambuf base32-encodes all data written to it and forwards it to a connected ostream. 

class Base32EncoderIOS

The base class for Base32Encoder

class Base64Decoder

This istream base64-decodes all data read from the istream connected to it. 

class Base64DecoderBuf

This streambuf base64-decodes all data read from the istream connected to it. 

class Base64DecoderIOS

The base class for Base64Decoder

class Base64Encoder

This ostream base64-encodes all data written to it and forwards it to a connected ostream. 

class Base64EncoderBuf

This streambuf base64-encodes all data written to it and forwards it to a connected ostream. 

class Base64EncoderIOS

The base class for Base64Encoder

class BasicBufferedBidirectionalStreamBuf

This is an implementation of a buffered bidirectional streambuf that greatly simplifies the implementation of custom streambufs of various kinds. 

class BasicBufferedStreamBuf

This is an implementation of a buffered streambuf that greatly simplifies the implementation of custom streambufs of various kinds. 

class BasicEvent

A BasicEvent uses the DefaultStrategy which invokes delegates in the order they have been registered. 

class BasicFIFOBuffer

A simple buffer class with support for re-entrant, FIFO-style read/write operations, as well as (optional) empty/non-empty/full (i. 

class BasicMemoryBinaryReader

A convenient wrapper for using Buffer and MemoryStream with BinaryReader

class BasicMemoryBinaryWriter

A convenient wrapper for using Buffer and MemoryStream with BinarWriter. 

class BasicMemoryStreamBuf

BasicMemoryStreamBuf is a simple implementation of a stream buffer for reading and writing from a memory area. 

class BasicUnbufferedStreamBuf

This is an implementation of an unbuffered streambuf that greatly simplifies the implementation of custom streambufs of various kinds. 

class BinaryReader

This class reads basic types (and std::vectors thereof) in binary form into an input stream. 

class BinaryWriter

This class writes basic types (and std::vectors of these) in binary form into an output stream. 

class Buffer

A buffer class that allocates a buffer of a given type and size in the constructor and deallocates the buffer in the destructor. 

class BufferAllocator

The BufferAllocator used if no specific BufferAllocator has been specified. 

class Bugcheck

This class provides some static methods that are used by the poco_assert_dbg(), poco_assert(), poco_check_ptr(), poco_bugcheck() and poco_unexpected() macros. 

class BugcheckException

 

class ByteOrder

This class contains a number of static methods to convert between big-endian and little-endian integers of various sizes. 

struct CILess

Case-insensitive less-than functor; useful for standard maps and sets with std::strings keys and case-insensitive ordering requirement. 

class Channel

The base class for all Channel classes. 

class Checksum

This class calculates CRC-32 or Adler-32 checksums for arbitrary data. 

class ChildrenFirstTraverse

 

class CircularReferenceException

 

class ClassLoader

The ClassLoader loads C++ classes from shared libraries at runtime. 

class Clock

A Clock stores a monotonic* clock value with (theoretical) microseconds resolution. 

class ColorConsoleChannel

A channel that writes to an ostream. 

class Condition

A Condition is a synchronization object used to block a thread until a particular condition is met. 

class Configurable

A simple interface that defines getProperty() and setProperty() methods. 

class ConsoleChannel

A channel that writes to an ostream. 

class CountingIOS

The base class for CountingInputStream and CountingOutputStream

class CountingInputStream

This stream counts all characters and lines going through it. 

class CountingOutputStream

This stream counts all characters and lines going through it. 

class CountingStreamBuf

This stream buffer counts all characters and lines going through it. 

class CreateFileException

 

class DataException

 

class DataFormatException

 

class DataURIStream

An input stream for reading data from a data URI

class DataURIStreamFactory

An implementation of the URIStreamFactory interface that read data from data URIs. 

class DataURIStreamIOS

The base class for DataURIStream

class DateTime

This class represents an instant in time, expressed in years, months, days, hours, minutes, seconds and milliseconds based on the Gregorian calendar. 

class DateTimeFormat

Definition of date/time formats and various constants used by DateTimeFormatter and DateTimeParser

class DateTimeFormatter

This class converts dates and times into strings, supporting a variety of standard and custom formats. 

class DateTimeParser

This class provides a method for parsing dates and times from strings. 

class Debugger

The Debugger class provides an interface to the debugger. 

class DefaultStrategy

Default notification strategy. 

class DeflatingIOS

The base class for DeflatingOutputStream and DeflatingInputStream

class DeflatingInputStream

This stream compresses all data passing through it using zlib's deflate algorithm. 

class DeflatingOutputStream

This stream compresses all data passing through it using zlib's deflate algorithm. 

class DeflatingStreamBuf

This is the streambuf class used by DeflatingInputStream and DeflatingOutputStream

class Delegate

 

class DigestBuf

This streambuf computes a digest of all data going through it. 

class DigestEngine

This class is an abstract base class for all classes implementing a message digest algorithm, like MD5Engine and SHA1Engine

class DigestIOS

The base class for DigestInputStream and DigestOutputStream

class DigestInputStream

This istream computes a digest of all the data passing through it, using a DigestEngine

class DigestOutputStream

This ostream computes a digest of all the data passing through it, using a DigestEngine

class DirectoryIterator

The DirectoryIterator class is used to enumerate all files in a directory. 

class DirectoryNotEmptyException

 

class DirectoryWatcher

This class is used to get notifications about changes to the filesystem, more specifically, to a specific directory. 

class DoubleByteEncoding

This abstract class is a base class for various double-byte character set (DBCS) encodings. 

class DynamicFactory

A factory that creates objects by class name. 

class EOFToken

This token class is used to signal the end of the input stream. 

class Environment

This class provides access to environment variables and some general system information. 

class Error

The Error class provides utility functions for error reporting. 

class ErrorHandler

This is the base class for thread error handlers. 

class Event

An Event is a synchronization object that allows one thread to signal one or more other threads that a certain event has happened. 

class EventArgs

The purpose of the EventArgs class is to be used as parameter when one doesn't want to send any data. 

class EventChannel

The EventChannel fires the messageLogged event for every log message received. 

class EventLogChannel

This Windows-only channel works with the Windows NT Event Log service. 

class Exception

This is the base class for all exceptions defined in the Poco class library. 

class ExistsException

 

class ExpirationDecorator

ExpirationDecorator adds an expiration method to values so that they can be used with the UniqueExpireCache

class Expire

Decorator for AbstractDelegate adding automatic expiration of registrations to AbstractDelegate's. 

class ExpireCache

An ExpireCache caches entries for a fixed time period (per default 10 minutes). 

class ExpireLRUCache

An ExpireLRUCache combines LRU caching and time based expire caching. 

class ExpireStrategy

An ExpireStrategy implements time based expiration of cache entries 

class FIFOBufferStream

An output stream for writing to a FIFO. 

class FIFOBufferStreamBuf

This is the streambuf class used for reading from and writing to a FIFOBuffer

class FIFOEvent

A FIFOEvent uses internally a FIFOStrategy which guarantees that delegates are invoked in the order they were added to the event. 

class FIFOIOS

The base class for FIFOBufferInputStream and FIFOBufferStream

class FIFOStrategy

Note: As of release 1. 

class FPEnvironment

Instances of this class can be used to save and later restore the current floating point environment (consisting of rounding mode and floating-point flags). 

class FastMemoryPool

FastMemoryPool is a class for pooling fixed-size blocks of memory. 

class FastMutex

A FastMutex (mutual exclusion) is similar to a Mutex

class File

The File class provides methods for working with a file. 

class FileAccessDeniedException

 

class FileChannel

A Channel that writes to a file. 

class FileException

 

class FileExistsException

 

class FileIOS

The base class for FileInputStream and FileOutputStream

class FileInputStream

An input stream for reading from a file. 

class FileNotFoundException

 

class FileNotReadyException

 

class FileOutputStream

An output stream for writing to a file. 

class FileReadOnlyException

 

class FileStream

A stream for reading from and writing to a file. 

class FileStreamFactory

An implementation of the URIStreamFactory interface that handles file URIs. 

class Formatter

The base class for all Formatter classes. 

class FormattingChannel

The FormattingChannel is a filter channel that routes a Message through a Formatter before passing it on to the destination channel. 

class FunctionDelegate

Wraps a freestanding function or static member function for use as a Delegate

class FunctionPriorityDelegate

Wraps a freestanding function or static member function for use as a PriorityDelegate

struct Getter

 

class Glob

This class implements glob-style pattern matching as known from Unix shells. 

class HMACEngine

This class implements the HMAC message authentication code algorithm, as specified in RFC 2104

struct Hash

A generic hash function. 

struct HashFunction

A generic hash function. 

class HashMap

This class implements a map using a LinearHashTable

struct HashMapEntry

This class template is used internally by HashMap

struct HashMapEntryHash

This class template is used internally by HashMap

class HashSet

This class implements a set using a LinearHashTable

class HashStatistic

HashStatistic class bundles statistical information on the current state of a HashTable 

class HashTable

A HashTable stores a key value pair that can be looked up via a hashed key. 

class HexBinaryDecoder

This istream decodes all hexBinary-encoded data read from the istream connected to it. 

class HexBinaryDecoderBuf

This streambuf decodes all hexBinary-encoded data read from the istream connected to it. 

class HexBinaryDecoderIOS

The base class for HexBinaryDecoder

class HexBinaryEncoder

This ostream encodes all data written to it in BinHex encoding and forwards it to a connected ostream. 

class HexBinaryEncoderBuf

This streambuf encodes all data written to it in hexBinary encoding and forwards it to a connected ostream. 

class HexBinaryEncoderIOS

The base class for HexBinaryEncoder

class IOException

 

class IllegalStateException

 

class InflatingIOS

The base class for InflatingOutputStream and InflatingInputStream

class InflatingInputStream

This stream decompresses all data passing through it using zlib's inflate algorithm. 

class InflatingOutputStream

This stream decompresses all data passing through it using zlib's inflate algorithm. 

class InflatingStreamBuf

This is the streambuf class used by InflatingInputStream and InflatingOutputStream

class InputLineEndingConverter

InputLineEndingConverter performs line ending conversion on text input streams. 

class InputStreamConverter

This stream converts all characters read from the underlying istream from one character encoding into another. 

class Instantiator

A template class for the easy instantiation of instantiators. 

class InvalidAccessException

 

class InvalidArgumentException

 

class InvalidToken

This token class is used for signalling that an invalid character sequence has been encountered in the input stream. 

struct IsConst

Use this struct to determine if a template type is a const type. 

struct IsReference

Use this struct to determine if a template type is a reference. 

class KeyValueArgs

Simply event arguments class to transfer a key and a value via an event call. 

class LRUCache

An LRUCache implements Least Recently Used caching. 

class LRUStrategy

An LRUStrategy implements least recently used cache replacement. 

class Latin1Encoding

ISO Latin-1 (8859-1) text encoding. 

class Latin2Encoding

ISO Latin-2 (8859-2) text encoding. 

class Latin9Encoding

ISO Latin-9 (8859-15) text encoding. 

class LibraryAlreadyLoadedException

 

class LibraryLoadException

 

class LineEnding

This class defines valid line ending sequences for InputLineEndingConverter and OutputLineEndingConverter

class LineEndingConverterIOS

The base class for InputLineEndingConverter and OutputLineEndingConverter

class LineEndingConverterStreamBuf

This stream buffer performs line ending conversion on text streams. 

class LinearHashTable

This class implements a linear hash table. 

class ListMap

This class implements a multimap in terms of a sequential container. 

class LocalDateTime

This class represents an instant in local time (as opposed to UTC), expressed in years, months, days, hours, minutes, seconds and milliseconds based on the Gregorian calendar. 

class LogFile

This class is used by FileChannel to work with a log file. 

class LogIOS

The base class for LogStream

class LogStream

This class implements an ostream interface to a Logger

class LogStreamBuf

This class implements a streambuf interface to a Logger

class Logger

Logger is a special Channel that acts as the main entry point into the logging framework. 

class LoggingFactory

An extensible factory for channels and formatters. 

class LoggingRegistry

A registry for channels and formatters. 

class LogicException

 

class MD4Engine

This class implements the MD4 message digest algorithm, described in RFC 1320

class MD5Engine

This class implements the MD5 message digest algorithm, described in RFC 1321

class MacCentralEurRomanEncoding

MacCentralEurRoman Encoding. 

class MacChineseSimpEncoding

MacChineseSimp Encoding. 

class MacChineseTradEncoding

MacChineseTrad Encoding. 

class MacCyrillicEncoding

MacCyrillic Encoding. 

class MacJapaneseEncoding

MacJapanese Encoding. 

class MacKoreanEncoding

MacKorean Encoding. 

class MacRomanEncoding

MacRoman Encoding. 

class Manifest

A Manifest maintains a list of all classes contained in a dynamically loadable class library. 

class ManifestBase

ManifestBase is a common base class for all instantiations of Manifest

class MemoryIOS

The base class for MemoryInputStream and MemoryOutputStream

class MemoryInputStream

An input stream for reading from a memory area. 

class MemoryOutputStream

An input stream for reading from a memory area. 

class MemoryPool

A simple pool for fixed-size memory blocks. 

class Message

This class represents a log message that is sent through a chain of log channels. 

class MetaObject

A MetaObject stores some information about a C++ class. 

class MetaSingleton

A SingletonMetaObject disables the create() method and instead offers an instance() method to access the single instance of its class. 

class Mutex

A Mutex (mutual exclusion) is a synchronization mechanism used to control access to a shared resource in a concurrent (multithreaded) scenario. 

class NDCScope

This class can be used to automatically push a context onto the NDC stack at the beginning of a scope, and to pop the context at the end of the scope. 

class NObserver

This template class implements an adapter that sits between a NotificationCenter and an object receiving notifications from it. 

class NamedEvent

An NamedEvent is a global synchronization object that allows one process or thread to signal an other process or thread that a certain event has happened. 

class NamedMutex

A NamedMutex (mutual exclusion) is a global synchronization mechanism used to control access to a shared resource in a concurrent (multi process) scenario. 

struct NamedTuple

 

class NestedDiagnosticContext

This class implements a Nested Diagnostic Context (NDC), as described in Neil Harrison's article "Patterns for Logging Diagnostic Messages" in "Pattern Languages of Program Design 3" (Addison-Wesley). 

class NoPermissionException

 

class NoThreadAvailableException

 

class NotFoundException

 

class NotImplementedException

 

class Notification

The base class for all notification classes used with the NotificationCenter and the NotificationQueue classes. 

class NotificationCenter

A NotificationCenter is essentially a notification dispatcher. 

class NotificationQueue

A NotificationQueue object provides a way to implement asynchronous notifications. 

class NotificationStrategy

The interface that all notification strategies must implement. 

class NullChannel

The NullChannel is the /dev/null of Channels. 

class NullIOS

The base class for NullInputStream and NullOutputStream

class NullInputStream

Any read operation from this stream immediately yields EOF. 

class NullMutex

A NullMutex is an empty mutex implementation which performs no locking at all. 

class NullOutputStream

This stream discards all characters written to it. 

class NullPointerException

 

class NullPurgeStrategy

 

class NullRotateStrategy

 

class NullStreamBuf

This stream buffer discards all characters written to it. 

struct NullTypeList

 

class NullValueException

 

class Nullable

Nullable is a simple wrapper class for value types that allows objects or native type variables to have "null" value. 

class NumberFormatter

The NumberFormatter class provides static methods for formatting numeric values into strings. 

class NumberParser

The NumberParser class provides static methods for parsing numbers out of strings. 

class ObjectPool

An ObjectPool manages a pool of objects of a certain class. 

class Observer

This template class implements an adapter that sits between a NotificationCenter and an object receiving notifications from it. 

class OpenFileException

 

class Optional

Optional is a simple wrapper class for value types that allows to introduce a specified/unspecified state to value objects. 

class OutOfMemoryException

 

class OutputLineEndingConverter

OutputLineEndingConverter performs line ending conversion on text output streams. 

class OutputStreamConverter

This stream converts all characters written to the underlying ostream from one character encoding into another. 

class PBKDF2Engine

This class implements the Password-Based Key Derivation Function 2, as specified in RFC 2898

class PIDFile

A utility class, creating process ID file on construction and deleting it on destruction. 

class Path

This class represents filesystem paths in a platform-independent manner. 

class PathNotFoundException

 

class PathSyntaxException

 

class PatternFormatter

This Formatter allows for custom formatting of log messages based on format patterns. 

class Pipe

This class implements an anonymous pipe. 

class PipeIOS

The base class for PipeInputStream and PipeOutputStream

class PipeInputStream

An input stream for reading from a Pipe

class PipeOutputStream

An output stream for writing to a Pipe

class PipeStreamBuf

This is the streambuf class used for reading from and writing to a Pipe

class PoolOverflowException

 

class PoolableObjectFactory

A PoolableObjectFactory is responsible for creating and resetting objects managed by an ObjectPool

class PriorityDelegate

 

class PriorityEvent

A PriorityEvent uses internally a PriorityStrategy which invokes delegates in order of priority (lower priorities first). 

class PriorityExpire

Decorator for AbstractPriorityDelegate adding automatic expiring of registrations to AbstractPriorityDelegate

class PriorityNotificationQueue

A PriorityNotificationQueue object provides a way to implement asynchronous notifications. 

class PriorityStrategy

NotificationStrategy for PriorityEvent

class Process

This class provides methods for working with processes. 

class ProcessHandle

A handle for a process created with Process::launch(). 

class ProcessRunner

ProcessRunner is a wrapper class for Poco::ProcessHandle

class PropertyNotSupportedException

 

class ProtocolException

 

class PurgeByAgeStrategy

This purge strategy purges all files that have exceeded a given age (given in seconds). 

class PurgeByCountStrategy

This purge strategy ensures that a maximum number of archived files is not exceeded. 

class PurgeStrategy

The PurgeStrategy is used by FileChannel to purge archived log files. 

class RWLock

A reader writer lock allows multiple concurrent readers or one exclusive writer. 

class Random

A better random number generator. 

class RandomBuf

This streambuf generates random data. 

class RandomIOS

The base class for RandomInputStream

class RandomInputStream

This istream generates random data using the RandomBuf

class RangeException

 

class ReadFileException

 

class RecursiveDirectoryIterator

The RecursiveDirectoryIterator class is used to enumerate all files in a directory and its subdirectories. 

class RecursiveDirectoryIteratorImpl

 

class RefCountedObject

A base class for objects that employ reference counting based garbage collection. 

class ReferenceCounter

Simple ReferenceCounter object, does not delete itself when count reaches 0. 

class RegularExpression

A class for working with regular expressions. 

class RegularExpressionException

 

class ReleaseArrayPolicy

The release policy for SharedPtr holding arrays. 

class ReleasePolicy

The default release policy for SharedPtr, which simply uses the delete operator to delete an object. 

class RotateAtTimeStrategy

The file is rotated at specified [day,][hour]:minute 

class RotateByIntervalStrategy

The file is rotated when the log file exceeds a given age. 

class RotateBySizeStrategy

The file is rotated when the log file exceeds a given size. 

class RotateStrategy

The RotateStrategy is used by LogFile to determine when a file must be rotated. 

class Runnable

The Runnable interface with the run() method must be implemented by classes that provide an entry point for a thread. 

class RunnableAdapter

This adapter simplifies using ordinary methods as targets for threads. 

class RuntimeException

 

class SHA1Engine

This class implements the SHA-1 message digest algorithm. 

class SHA2Engine

This class implements the SHA-2 message digest algorithm. 

class SHA2Engine224

 

class SHA2Engine256

 

class SHA2Engine384

 

class SHA2Engine512

 

class ScopedLock

A class that simplifies thread synchronization with a mutex. 

class ScopedLockWithUnlock

A class that simplifies thread synchronization with a mutex. 

class ScopedRWLock

A variant of ScopedLock for reader/writer locks. 

class ScopedReadRWLock

A variant of ScopedLock for reader locks. 

class ScopedUnlock

A class that simplifies thread synchronization with a mutex. 

class ScopedWriteRWLock

A variant of ScopedLock for writer locks. 

class Semaphore

A Semaphore is a synchronization object with the following characteristics: A semaphore has a value that is constrained to be a non-negative integer and two atomic operations. 

class SharedLibrary

The SharedLibrary class dynamically loads shared libraries at run-time. 

class SharedMemory

Create and manage a shared memory object. 

class SharedPtr

SharedPtr is a "smart" pointer for classes implementing reference counting based garbage collection. 

class SiblingsFirstTraverse

 

class SignalException

 

class SignalHandler

This helper class simplifies the handling of POSIX signals. 

class SimpleFileChannel

A Channel that writes to a file. 

class SimpleHashTable

A SimpleHashTable stores a key value pair that can be looked up via a hashed key. 

class SingletonHolder

This is a helper template class for managing singleton objects allocated on the heap. 

class SortedDirectoryIterator

The SortedDirectoryIterator class is similar to DirectoryIterator class, but places directories before files and sorts content alphabetically. 

class SpinlockMutex

A SpinlockMutex, implemented in terms of std::atomic_flag, as busy-wait mutual exclusion. 

class SplitterChannel

This channel sends a message to multiple channels simultaneously. 

class Stopwatch

A simple facility to measure time intervals with microsecond resolution. 

class StrategyCollection

An StrategyCollection is a decorator masking n collections as a single one. 

class StreamChannel

A channel that writes to an ostream. 

class StreamConverterBuf

A StreamConverter converts streams from one encoding (inEncoding) into another (outEncoding). 

class StreamConverterIOS

The base class for InputStreamConverter and OutputStreamConverter

class StreamCopier

This class provides static methods to copy the contents from one stream into another. 

class StreamTokenizer

A stream tokenizer splits an input stream into a sequence of tokens of different kinds. 

class StringTokenizer

A simple tokenizer that splits a string into tokens, which are separated by separator characters. 

class SynchronizedObject

This class aggregates a Mutex and an Event and can act as a base class for all objects requiring synchronization in a multithreaded scenario. 

class SyntaxException

 

class SyslogChannel

This Unix-only channel works with the Unix syslog service. 

class SystemException

 

class TLSAbstractSlot

This is the base class for all objects that the ThreadLocalStorage class manages. 

class TLSSlot

The Slot template wraps another class so that it can be stored in a ThreadLocalStorage object. 

class Task

A Task is a subclass of Runnable that has a name and supports progress reporting and cancellation. 

class TaskCancelledNotification

This notification is posted by the TaskManager for every task that has been cancelled. 

class TaskCustomNotification

This is a template for "custom" notification. 

class TaskFailedNotification

This notification is posted by the TaskManager for every task that has failed with an exception. 

class TaskFinishedNotification

This notification is posted by the TaskManager for every task that has finished. 

class TaskManager

The TaskManager manages a collection of tasks and monitors their lifetime. 

class TaskNotification

Base class for TaskManager notifications. 

class TaskProgressNotification

This notification is posted by the TaskManager for a task when its progress changes. 

class TaskStartedNotification

This notification is posted by the TaskManager for every task that has been started. 

class TeeIOS

The base class for TeeInputStream and TeeOutputStream

class TeeInputStream

This stream copies all characters read through it to one or multiple output streams. 

class TeeOutputStream

This stream copies all characters written to it to one or multiple output streams. 

class TeeStreamBuf

This stream buffer copies all data written to or read from it to one or multiple output streams. 

class TemporaryFile

The TemporaryFile class helps with the handling of temporary files. 

class TextBufferIterator

An unidirectional iterator for iterating over characters in a buffer. 

class TextConverter

A TextConverter converts strings from one encoding into another. 

class TextEncoding

An abstract base class for implementing text encodings like UTF-8 or ISO 8859-1. 

class TextIterator

An unidirectional iterator for iterating over characters in a string. 

class Thread

This class implements a platform-independent wrapper to an operating system thread. 

class ThreadLocal

This template is used to declare type safe thread local variables. 

class ThreadLocalStorage

This class manages the local storage for each thread. 

class ThreadPool

A thread pool always keeps a number of threads running, ready to accept work. 

class ThreadTarget

This adapter simplifies using static member functions as well as standalone functions as targets for threads. 

class TimedNotificationQueue

A TimedNotificationQueue object provides a way to implement timed, asynchronous notifications. 

class TimeoutException

 

class Timer

This class implements a thread-based timer. 

class TimerCallback

This template class implements an adapter that sits between a Timer and an object's method invoked by the timer. 

class Timespan

A class that represents time spans up to microsecond resolution. 

class Timestamp

A Timestamp stores a monotonic* time value with (theoretical) microseconds resolution. 

class Timezone

This class provides information about the current timezone. 

class Token

The base class for all token classes that can be registered with the StreamTokenizer

class TooManyURIRedirectsException

 

class TraverseBase

 

struct Tuple

 

struct TypeList

Compile Time List of Types 

struct TypeListType

TypeListType takes 1 - 40 typename arguments. 

struct TypeSizeGT

 

struct TypeSizeLE

 

struct TypeWrapper

Specialization for const char arrays Use the type wrapper if you want to decouple constness and references from template types. 

class URI

A Uniform Resource Identifier, as specified in RFC 3986

class URIRedirection

An instance of URIRedirection is thrown by a URIStreamFactory::open() if opening the original URI resulted in a redirection response (such as a MOVED PERMANENTLY in HTTP). 

class URIStreamFactory

This class defines the interface that all URI stream factories must implement. 

class URIStreamOpener

The URIStreamOpener class is used to create and open input streams for resourced identified by Uniform Resource Identifiers. 

class URISyntaxException

 

struct UTF16CharTraits

 

class UTF16Encoding

UTF-16 text encoding, as defined in RFC 2781

struct UTF32CharTraits

 

class UTF32Encoding

UTF-32 text encoding, as defined in RFC 2781

struct UTF8

This class provides static methods that are UTF-8 capable variants of the same functions in Poco/String. 

class UTF8Encoding

UTF-8 text encoding, as defined in RFC 2279

class UUID

A UUID is an identifier that is unique across both space and time, with respect to the space of all UUIDs. 

class UUIDGenerator

This class implements a generator for Universal Unique Identifiers, as specified in Appendix A of the DCE 1. 

class UnhandledException

 

class Unicode

This class contains enumerations and static utility functions for dealing with Unicode characters and their properties. 

class UnicodeConverter

A convenience class that converts strings from UTF-8 encoded std::strings to UTF-16 or UTF-32 encoded std::wstrings and vice-versa. 

class UniqueAccessExpireCache

An UniqueAccessExpireCache caches entries for a given time span. 

class UniqueAccessExpireLRUCache

A UniqueAccessExpireLRUCache combines LRU caching and time based per entry expire caching. 

class UniqueAccessExpireStrategy

An UniqueExpireStrategy implements time based expiration of cache entries. 

class UniqueExpireCache

An UniqueExpireCache caches entries for a given time amount. 

class UniqueExpireLRUCache

A UniqueExpireLRUCache combines LRU caching and time based per entry expire caching. 

class UniqueExpireStrategy

An UniqueExpireStrategy implements time based expiration of cache entries. 

class UnknownURISchemeException

 

class ValidArgs

 

class Void

A dummy class with value-type semantics, mostly useful as a template argument. 

class WhitespaceToken

This pseudo token class is used to eat up whitespace in between real tokens. 

class Windows1250Encoding

Windows Codepage 1250 text encoding. 

class Windows1251Encoding

Windows Codepage 1251 text encoding. 

class Windows1252Encoding

Windows Codepage 1252 text encoding. 

class Windows1253Encoding

windows-1253 Encoding. 

class Windows1254Encoding

windows-1254 Encoding. 

class Windows1255Encoding

windows-1255 Encoding. 

class Windows1256Encoding

windows-1256 Encoding. 

class Windows1257Encoding

windows-1257 Encoding. 

class Windows1258Encoding

windows-1258 Encoding. 

class Windows874Encoding

windows-874 Encoding. 

class Windows932Encoding

windows-932 Encoding. 

class Windows936Encoding

windows-936 Encoding. 

class Windows949Encoding

windows-949 Encoding. 

class Windows950Encoding

windows-950 Encoding. 

class WindowsColorConsoleChannel

A channel that writes to the Windows console. 

class WindowsConsoleChannel

A channel that writes to the Windows console. 

class WriteFileException

 

struct i_char_traits

 

Types

BufferedBidirectionalStreamBuf

typedef BasicBufferedBidirectionalStreamBuf < char, std::char_traits < char >> BufferedBidirectionalStreamBuf;

BufferedStreamBuf

typedef BasicBufferedStreamBuf < char, std::char_traits < char >> BufferedStreamBuf;

DynamicAny

typedef Dynamic::Var DynamicAny;

FIFOBuffer

typedef BasicFIFOBuffer < char > FIFOBuffer;

FPE

typedef FPEnvironment FPE;

MemoryBinaryReader

typedef BasicMemoryBinaryReader < char > MemoryBinaryReader;

MemoryBinaryWriter

typedef BasicMemoryBinaryWriter < char > MemoryBinaryWriter;

MemoryStreamBuf

typedef BasicMemoryStreamBuf < char, std::char_traits < char >> MemoryStreamBuf;

NDC

typedef NestedDiagnosticContext NDC;

SiblingsFirstRecursiveDirectoryIterator

typedef RecursiveDirectoryIterator < SiblingsFirstTraverse > SiblingsFirstRecursiveDirectoryIterator;

SimpleRecursiveDirectoryIterator

typedef RecursiveDirectoryIterator < ChildrenFirstTraverse > SimpleRecursiveDirectoryIterator;

UTF16Char

typedef Poco::UInt16 UTF16Char;

UTF16String

typedef std::basic_string < UTF16Char, UTF16CharTraits > UTF16String;

UTF32Char

typedef wchar_t UTF32Char;

UTF32String

typedef std::wstring UTF32String;

UnbufferedStreamBuf

typedef BasicUnbufferedStreamBuf < char, std::char_traits < char >> UnbufferedStreamBuf;

istring

typedef std::basic_string < char, i_char_traits < char >> istring;

Case-insensitive std::string counterpart.

Types Aliases

DynamicStruct

using DynamicStruct = Dynamic::Struct < std::string >;

Int16

using Int16 = std::int16_t;

Int32

using Int32 = std::int32_t;

Int64

using Int64 = std::int64_t;

Int8

using Int8 = std::conditional < std::is_same < signed char, std::int8_t >::value, std::int8_t, signed char >::type;

IntPtr

using IntPtr = std::intptr_t;

OrderedDynamicStruct

using OrderedDynamicStruct = Dynamic::Struct < std::string, Poco::OrderedMap < std::string, Dynamic::Var >, Poco::OrderedSet < std::string >>;

UInt16

using UInt16 = std::uint16_t;

UInt32

using UInt32 = std::uint32_t;

UInt64

using UInt64 = std::uint64_t;

UInt8

using UInt8 = std::uint8_t;

UIntPtr

using UIntPtr = std::uintptr_t;

Enumerations

Base64EncodingOptions

BASE64_URL_ENCODING = 0x01

Use the URL and filename-safe alphabet, replacing '+' with '-' and '/' with '_'.

Will also set line length to unlimited.

BASE64_NO_PADDING = 0x02

Do not append padding characters ('=') at end.

JSONOptions

JSON_PRESERVE_KEY_ORDER = 1

Applies to JSON::Object. If specified, the Object will preserve the items insertion order. Otherwise, items will be sorted by keys.

Has no effect on toJSON() function.

JSON_ESCAPE_UNICODE = 2

If specified, when the object is stringified, all unicode characters will be escaped in the resulting string.

JSON_WRAP_STRINGS = 4

If specified, the object will preserve the items insertion order. Otherwise, items will be sorted by keys.

JSON_LOWERCASE_HEX = 8

If specified, all encoding happens with lowercase HEX characters instead of capitals

NullType

NULL_GENERIC = 0

ProcessOptions

Options to configure child process behavior.

PROCESS_CLOSE_STDIN = 1

Causes the child process STDIN to be closed.

PROCESS_CLOSE_STDOUT = 2

Causes the child process STDOUT to be closed.

PROCESS_CLOSE_STDERR = 4

Causes the child process STDERR to be closed.

Functions

cat inline

template < class S > S cat(
    const S & s1,
    const S & s2
);

Concatenates two strings.

cat inline

template < class S > S cat(
    const S & s1,
    const S & s2,
    const S & s3
);

Concatenates three strings.

cat inline

template < class S > S cat(
    const S & s1,
    const S & s2,
    const S & s3,
    const S & s4
);

Concatenates four strings.

cat inline

template < class S > S cat(
    const S & s1,
    const S & s2,
    const S & s3,
    const S & s4,
    const S & s5
);

Concatenates five strings.

cat inline

template < class S > S cat(
    const S & s1,
    const S & s2,
    const S & s3,
    const S & s4,
    const S & s5,
    const S & s6
);

Concatenates six strings.

cat inline

template < class S, class It > S cat(
    const S & delim,
    const It & begin,
    const It & end
);

Concatenates a sequence of strings, delimited by the string given in delim.

decimalSeparator inline

inline char decimalSeparator();

Returns decimal separator from global locale or default '.' for platforms where locale is unavailable.

delegate inline

template < class TObj, class TArgs > inline Delegate < TObj, TArgs, true > delegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(const void *, TArgs &) param187
);

delegate inline

template < class TObj, class TArgs > inline Delegate < TObj, TArgs, false > delegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(TArgs &) param188
);

delegate inline

template < class TObj, class TArgs > inline Expire < TArgs > delegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(const void *, TArgs &) param189,
    Timestamp::TimeDiff expireMillisecs
);

delegate inline

template < class TObj, class TArgs > inline Expire < TArgs > delegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(TArgs &) param190,
    Timestamp::TimeDiff expireMillisecs
);

delegate inline

template < class TArgs > inline Expire < TArgs > delegate(
    void (* NotifyMethod)(const void *, TArgs &) param191,
    Timestamp::TimeDiff expireMillisecs
);

delegate inline

template < class TArgs > inline Expire < TArgs > delegate(
    void (* NotifyMethod)(void *, TArgs &) param192,
    Timestamp::TimeDiff expireMillisecs
);

delegate inline

template < class TArgs > inline Expire < TArgs > delegate(
    void (* NotifyMethod)(TArgs &) param193,
    Timestamp::TimeDiff expireMillisecs
);

delegate inline

template < class TArgs > inline FunctionDelegate < TArgs, true, true > delegate(
    void (* NotifyMethod)(const void *, TArgs &) param194
);

delegate inline

template < class TArgs > inline FunctionDelegate < TArgs, true, false > delegate(
    void (* NotifyMethod)(void *, TArgs &) param195
);

delegate inline

template < class TArgs > inline FunctionDelegate < TArgs, false > delegate(
    void (* NotifyMethod)(TArgs &) param196
);

delegate inline

template < class TObj > inline Delegate < TObj, void, true > delegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(const void *) param197
);

delegate inline

template < class TObj > inline Delegate < TObj, void, false > delegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)()
);

delegate inline

template < class TObj > inline Expire < void > delegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(const void *) param198,
    Timestamp::TimeDiff expireMillisecs
);

delegate inline

template < class TObj > inline Expire < void > delegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(),
    Timestamp::TimeDiff expireMillisecs
);

delegate inline

inline Expire < void > delegate(
    void (* NotifyMethod)(const void *) param199,
    Timestamp::TimeDiff expireMillisecs
);

delegate inline

inline Expire < void > delegate(
    void (* NotifyMethod)(void *) param200,
    Timestamp::TimeDiff expireMillisecs
);

delegate inline

inline Expire < void > delegate(
    void (* NotifyMethod)(),
    Timestamp::TimeDiff expireMillisecs
);

delegate inline

inline FunctionDelegate < void, true, true > delegate(
    void (* NotifyMethod)(const void *) param201
);

delegate inline

inline FunctionDelegate < void, true, false > delegate(
    void (* NotifyMethod)(void *) param202
);

delegate inline

inline FunctionDelegate < void, false > delegate(
    void (* NotifyMethod)()
);

doubleToFixedStr

void doubleToFixedStr(
    char * buffer,
    int bufferSize,
    double value,
    int precision
);

Converts a double value to string. Converted string must be shorter than bufferSize. Computes a decimal representation with a fixed number of digits after the decimal point.

doubleToFixedStr

std::string & doubleToFixedStr(
    std::string & str,
    double value,
    int precision = - 1,
    int width = 0,
    char thSep = 0,
    char decSep = 0
);

Converts a double value, assigns it to the supplied string and returns the reference. This function calls doubleToFixedStr(char*, int, double, int) and formats the result according to precision (total number of digits after the decimal point) and width (total length of formatted string).

doubleToStr

void doubleToStr(
    char * buffer,
    int bufferSize,
    double value,
    int lowDec = - std::numeric_limits < double >::digits10,
    int highDec = std::numeric_limits < double >::digits10
);

Converts a double value to string. Converted string must be shorter than bufferSize. Conversion is done by computing the shortest string of digits that correctly represents the input number. Depending on lowDec and highDec values, the function returns decimal or exponential representation.

doubleToStr

std::string & doubleToStr(
    std::string & str,
    double value,
    int precision = - 1,
    int width = 0,
    char thSep = 0,
    char decSep = 0
);

Converts a double value, assigns it to the supplied string and returns the reference. This function calls doubleToStr(char*, int, double, int, int) and formats the result according to precision (total number of digits after the decimal point, -1 means ignore precision argument) and width (total length of formatted string).

endsWith inline

template < class S > bool endsWith(
    const S & str,
    const S & suffix
);

Tests whether the string ends with the given suffix.

floatToFixedStr

void floatToFixedStr(
    char * buffer,
    int bufferSize,
    float value,
    int precision
);

Converts a float value to string. Converted string must be shorter than bufferSize. Computes a decimal representation with a fixed number of digits after the decimal point.

floatToFixedStr

std::string & floatToFixedStr(
    std::string & str,
    float value,
    int precision,
    int width = 0,
    char thSep = 0,
    char decSep = 0
);

Converts a float value, assigns it to the supplied string and returns the reference. This function calls floatToFixedStr(char*, int, float, int) and formats the result according to precision (total number of digits after the decimal point) and width (total length of formatted string).

floatToStr

void floatToStr(
    char * buffer,
    int bufferSize,
    float value,
    int lowDec = - std::numeric_limits < float >::digits10,
    int highDec = std::numeric_limits < float >::digits10
);

Converts a float value to string. Converted string must be shorter than bufferSize. Conversion is done by computing the shortest string of digits that correctly represents the input number. Depending on lowDec and highDec values, the function returns decimal or exponential representation.

floatToStr

std::string & floatToStr(
    std::string & str,
    float value,
    int precision = - 1,
    int width = 0,
    char thSep = 0,
    char decSep = 0
);

Converts a float value, assigns it to the supplied string and returns the reference. This function calls floatToStr(char*, int, float, int, int) and formats the result according to precision (total number of digits after the decimal point, -1 means ignore precision argument) and width (total length of formatted string).

format

std::string format(
    const std::string & fmt,
    const Any & value
);

This function implements sprintf-style formatting in a typesafe way. Various variants of the function are available, supporting a different number of arguments (up to six).

The formatting is controlled by the format string in fmt. Format strings are quite similar to those of the std::printf() function, but there are some minor differences.

The format string can consist of any sequence of characters; certain characters have a special meaning. Characters without a special meaning are copied verbatim to the result. A percent sign (%) marks the beginning of a format specification. Format specifications have the following syntax:

%[<index>][<flags>][<width>][.<precision>][<modifier>]<type>

Index, flags, width, precision and prefix are optional. The only required part of the format specification, apart from the percent sign, is the type.

The optional index argument has the format "[<n>]" and allows to address an argument by its zero-based position (see the example below).

Following are valid type specifications and their meaning:

  • b boolean (true = 1, false = 0)
  • c character
  • d signed decimal integer
  • i signed decimal integer
  • o unsigned octal integer
  • u unsigned decimal integer
  • x unsigned hexadecimal integer (lower case)
  • X unsigned hexadecimal integer (upper case)
  • e signed floating-point value in the form [-]d.dddde[<sign>]dd[d]
  • E signed floating-point value in the form [-]d.ddddE[<sign>]dd[d]
  • f signed floating-point value in the form [-]dddd.dddd
  • s std::string
  • z std::size_t

The following flags are supported:

  • - left align the result within the given field width
  • + prefix the output value with a sign (+ or -) if the output value is of a signed type
  • 0 if width is prefixed with 0, zeros are added until the minimum width is reached
  • # For o, x, X, the # flag prefixes any nonzero output value with 0, 0x, or 0X, respectively; for e, E, f, the # flag forces the output value to contain a decimal point in all cases.

The following modifiers are supported:

  • (none) argument is char (c), int (d, i), unsigned (o, u, x, X) double (e, E, f, g, G) or string (s)
  • l argument is long (d, i), unsigned long (o, u, x, X) or long double (e, E, f, g, G)
  • L argument is long long (d, i), unsigned long long (o, u, x, X)
  • h argument is short (d, i), unsigned short (o, u, x, X) or float (e, E, f, g, G)
  • ? argument is any signed or unsigned int, short, long, or 64-bit integer (d, i, o, x, X)

The width argument is a nonnegative decimal integer or '*' with an additional nonnegative integer value preceding the value to be formated, controlling the minimum number of characters printed. If the number of characters in the output value is less than the specified width, blanks or leading zeros are added, according to the specified flags (-, +, 0).

Precision is a nonnegative decimal integer or '*' with an additional nonnegative integer value preceding the value to be formated, preceded by a period (.), which specifies the number of characters to be printed, the number of decimal places, or the number of significant digits.

Throws an InvalidArgumentException if an argument index is out of range.

Starting with release 1.4.3, an argument that does not match the format specifier no longer results in a BadCastException. The string [ERRFMT] is written to the result string instead.

If there are more format specifiers than values, the format specifiers without a corresponding value are copied verbatim to output.

If there are more values than format specifiers, the superfluous values are ignored.

Usage Examples:

std::string s1 = format("The answer to life, the universe, and everything is %d", 42);
std::string s2 = format("second: %[1]d, first: %[0]d", 1, 2);

format

void format(
    std::string & result,
    const char * fmt,
    const std::vector < Any > & values
);

Supports a variable number of arguments.

format

void format(
    std::string & result,
    const std::string & fmt,
    const std::vector < Any > & values
);

Supports a variable number of arguments.

format inline

template < typename T, typename ... Args > void format(
    std::string & result,
    const std::string & fmt,
    T arg1,
    Args ... args
);

Appends the formatted string to result.

format inline

template < typename T, typename ... Args > void format(
    std::string & result,
    const char * fmt,
    T arg1,
    Args ... args
);

Appends the formatted string to result.

format inline

template < typename T, typename ... Args > std::string format(
    const std::string & fmt,
    T arg1,
    Args ... args
);

Returns the formatted string.

format inline

template < typename T, typename ... Args > std::string format(
    const char * fmt,
    T arg1,
    Args ... args
);

Returns the formatted string.

formatAny inline

inline void formatAny(
    std::string & result,
    const std::string & fmt,
    const std::vector < Any > & values
);

Supports a variable number of arguments and is used by all other variants of format().

formatAny inline

inline void formatAny(
    std::string & result,
    const char * fmt,
    const std::vector < Any > & values
);

Supports a variable number of arguments and is used by all other variants of format().

hash

std::size_t hash(
    Int8 n
);

hash

std::size_t hash(
    UInt8 n
);

hash

std::size_t hash(
    Int16 n
);

hash

std::size_t hash(
    UInt16 n
);

hash

std::size_t hash(
    Int32 n
);

hash

std::size_t hash(
    UInt32 n
);

hash

std::size_t hash(
    Int64 n
);

hash

std::size_t hash(
    UInt64 n
);

hash

std::size_t hash(
    const std::string & str
);

hash inline

inline std::size_t hash(
    Int8 n
);

hash inline

inline std::size_t hash(
    UInt8 n
);

hash inline

inline std::size_t hash(
    Int16 n
);

hash inline

inline std::size_t hash(
    UInt16 n
);

hash inline

inline std::size_t hash(
    Int32 n
);

hash inline

inline std::size_t hash(
    UInt32 n
);

hash inline

inline std::size_t hash(
    Int64 n
);

hash inline

inline std::size_t hash(
    UInt64 n
);

hashCombine inline

template < class T > inline void hashCombine(
    std::size_t & seed,
    T const & v
);

hashRange inline

template < class It > inline std::size_t hashRange(
    It first,
    It last
);

hashRange inline

template < class It > inline void hashRange(
    std::size_t & seed,
    It first,
    It last
);

icompare inline

template < class S, class It > int icompare(
    const S & str,
    typename S::size_type pos,
    typename S::size_type n,
    It it2,
    It end2
);

Case-insensitive string comparison

icompare inline

template < class S > int icompare(
    const S & str1,
    const S & str2
);

icompare inline

template < class S > int icompare(
    const S & str1,
    typename S::size_type n1,
    const S & str2,
    typename S::size_type n2
);

icompare inline

template < class S > int icompare(
    const S & str1,
    typename S::size_type n,
    const S & str2
);

icompare inline

template < class S > int icompare(
    const S & str1,
    typename S::size_type pos,
    typename S::size_type n,
    const S & str2
);

icompare inline

template < class S > int icompare(
    const S & str1,
    typename S::size_type pos1,
    typename S::size_type n1,
    const S & str2,
    typename S::size_type pos2,
    typename S::size_type n2
);

icompare inline

template < class S > int icompare(
    const S & str1,
    typename S::size_type pos1,
    typename S::size_type n,
    const S & str2,
    typename S::size_type pos2
);

icompare inline

template < class S > int icompare(
    const S & str,
    typename S::size_type pos,
    typename S::size_type n,
    const typename S::value_type * ptr
);

icompare inline

template < class S > int icompare(
    const S & str,
    typename S::size_type pos,
    const typename S::value_type * ptr
);

icompare inline

template < class S > int icompare(
    const S & str,
    const typename S::value_type * ptr
);

intToStr inline

template < typename T, Impl::EnableSigned < T > = __nullptr > bool intToStr(
    T value,
    unsigned short base,
    char * result,
    std::size_t & size,
    bool prefix = false,
    int width = - 1,
    char fill = ' ',
    char thSep = 0,
    bool lowercase = false
);

Converts signed integer to string. Standard numeric bases from binary to hexadecimal are supported. If width is non-zero, it pads the return value with fill character to the specified width. When padding is zero character ('0'), it is prepended to the number itself; all other paddings are prepended to the formatted result with minus sign or base prefix included If prefix is true and base is octal or hexadecimal, respective prefix ('0' for octal, "0x" for hexadecimal) is prepended. For all other bases, prefix argument is ignored. Formatted string has at least [width] total length.

intToStr inline

template < typename T, Impl::EnableUnsigned < T > = __nullptr > bool intToStr(
    T value,
    unsigned short base,
    char * result,
    std::size_t & size,
    bool prefix = false,
    int width = - 1,
    char fill = ' ',
    char thSep = 0,
    bool lowercase = false
);

Converts unsigned integer to string. Numeric bases from binary to hexadecimal are supported. If width is non-zero, it pads the return value with fill character to the specified width. When padding is zero character ('0'), it is prepended to the number itself; all other paddings are prepended to the formatted result with minus sign or base prefix included If prefix is true and base is octal or hexadecimal, respective prefix ('0' for octal, "0x" for hexadecimal) is prepended. For all other bases, prefix argument is ignored. Formatted string has at least [width] total length.

intToStr inline

template < typename T > bool intToStr(
    T number,
    unsigned short base,
    std::string & result,
    bool prefix = false,
    int width = - 1,
    char fill = ' ',
    char thSep = 0,
    bool lowercase = false
);

Converts integer to string; This is a wrapper function, for details see the bool intToStr(T, unsigned short, char*, int, int, char, char) implementation.

isIntOverflow inline

template < typename To, typename From > inline bool isIntOverflow(
    From val
);

isNegative inline

template < typename T > inline bool isNegative(
    T x
);

isSafeIntCast inline

template < typename F, typename T > inline T & isSafeIntCast(
    F from
);

Returns true if it is safe to cast integer from F to T.

isubstr inline

template < typename T > std::size_t isubstr(
    const T & str,
    const T & sought
);

Case-insensitive substring; searches for a substring without regards to case.

makeAuto inline

template < typename T, typename ... Args > AutoPtr < T > makeAuto(
    Args && ... args
);

makeShared inline

template < typename T, typename ... Args > SharedPtr < T > makeShared(
    Args && ... args
);

makeSharedArray inline

template < typename T > SharedPtr < T, ReferenceCounter, ReleaseArrayPolicy < T >> makeSharedArray(
    std::size_t size
);

operator != inline

template < class T, std::size_t N > bool operator != (
    const Array < T, N > & x,
    const Array < T, N > & y
);

operator != inline

template < typename C > bool operator != (
    const C & c,
    const Nullable < C > & n
);

Compares Nullable with value for non equality

operator != inline

template < typename C > bool operator != (
    const NullType & param265,
    const Nullable < C > & n
);

Returns true if this Nullable is not null.

operator != inline

template < class T1, class T2 > inline bool operator != (
    const RecursiveDirectoryIterator < T1 > & a,
    const RecursiveDirectoryIterator < T2 > & b
);

operator & inline

inline NumberFormatter::Options operator & (
    NumberFormatter::Options lhs,
    NumberFormatter::Options rhs
);

operator &= inline

inline NumberFormatter::Options & operator &= (
    NumberFormatter::Options & lhs,
    NumberFormatter::Options rhs
);

operator < inline

template < class T, std::size_t N > bool operator < (
    const Array < T, N > & x,
    const Array < T, N > & y
);

operator << inline

template < typename C > std::ostream & operator << (
    std::ostream & out,
    const Nullable < C > & obj
);

operator <= inline

template < class T, std::size_t N > bool operator <= (
    const Array < T, N > & x,
    const Array < T, N > & y
);

operator == inline

template < class T, std::size_t N > bool operator == (
    const Array < T, N > & x,
    const Array < T, N > & y
);

operator == inline

template < typename C > bool operator == (
    const NullType & param264,
    const Nullable < C > & n
);

Returns true if this Nullable is null.

operator == inline

template < typename C > bool operator == (
    const C & c,
    const Nullable < C > & n
);

Compares Nullable with NullData for equality

operator == inline

template < class T1, class T2 > inline bool operator == (
    const RecursiveDirectoryIterator < T1 > & a,
    const RecursiveDirectoryIterator < T2 > & b
);

operator > inline

template < class T, std::size_t N > bool operator > (
    const Array < T, N > & x,
    const Array < T, N > & y
);

operator >= inline

template < class T, std::size_t N > bool operator >= (
    const Array < T, N > & x,
    const Array < T, N > & y
);

operator [] inline

inline std::string & StringTokenizer::operator[] (
    std::size_t index
);

operator [] inline

inline const std::string & StringTokenizer::operator[] (
    std::size_t index
) const;

operator | inline

inline NumberFormatter::Options operator | (
    NumberFormatter::Options lhs,
    NumberFormatter::Options rhs
);

operator |= inline

inline NumberFormatter::Options & operator |= (
    NumberFormatter::Options & lhs,
    NumberFormatter::Options rhs
);

priorityDelegate static inline

template < class TObj, class TArgs > static PriorityDelegate < TObj, TArgs, true > priorityDelegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(const void *, TArgs &) param271,
    int prio
);

priorityDelegate static inline

template < class TObj, class TArgs > static PriorityDelegate < TObj, TArgs, false > priorityDelegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(TArgs &) param272,
    int prio
);

priorityDelegate static inline

template < class TObj, class TArgs > static PriorityExpire < TArgs > priorityDelegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(const void *, TArgs &) param273,
    int prio,
    Timestamp::TimeDiff expireMilliSec
);

priorityDelegate static inline

template < class TObj, class TArgs > static PriorityExpire < TArgs > priorityDelegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(TArgs &) param274,
    int prio,
    Timestamp::TimeDiff expireMilliSec
);

priorityDelegate static inline

template < class TArgs > static PriorityExpire < TArgs > priorityDelegate(
    void (* NotifyMethod)(const void *, TArgs &) param275,
    int prio,
    Timestamp::TimeDiff expireMilliSec
);

priorityDelegate static inline

template < class TArgs > static PriorityExpire < TArgs > priorityDelegate(
    void (* NotifyMethod)(void *, TArgs &) param276,
    int prio,
    Timestamp::TimeDiff expireMilliSec
);

priorityDelegate static inline

template < class TArgs > static PriorityExpire < TArgs > priorityDelegate(
    void (* NotifyMethod)(TArgs &) param277,
    int prio,
    Timestamp::TimeDiff expireMilliSec
);

priorityDelegate static inline

template < class TArgs > static FunctionPriorityDelegate < TArgs, true, true > priorityDelegate(
    void (* NotifyMethod)(const void *, TArgs &) param278,
    int prio
);

priorityDelegate static inline

template < class TArgs > static FunctionPriorityDelegate < TArgs, true, false > priorityDelegate(
    void (* NotifyMethod)(void *, TArgs &) param279,
    int prio
);

priorityDelegate static inline

template < class TArgs > static FunctionPriorityDelegate < TArgs, false > priorityDelegate(
    void (* NotifyMethod)(TArgs &) param280,
    int prio
);

priorityDelegate static inline

template < class TObj > static PriorityDelegate < TObj, void, true > priorityDelegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(const void *) param281,
    int prio
);

priorityDelegate static inline

template < class TObj > static PriorityDelegate < TObj, void, false > priorityDelegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(),
    int prio
);

priorityDelegate static inline

template < class TObj > static PriorityExpire < void > priorityDelegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(const void *) param282,
    int prio,
    Timestamp::TimeDiff expireMilliSec
);

priorityDelegate static inline

template < class TObj > static PriorityExpire < void > priorityDelegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(),
    int prio,
    Timestamp::TimeDiff expireMilliSec
);

priorityDelegate inline

inline PriorityExpire < void > priorityDelegate(
    void (* NotifyMethod)(const void *) param283,
    int prio,
    Timestamp::TimeDiff expireMilliSec
);

priorityDelegate inline

inline PriorityExpire < void > priorityDelegate(
    void (* NotifyMethod)(void *) param284,
    int prio,
    Timestamp::TimeDiff expireMilliSec
);

priorityDelegate inline

inline PriorityExpire < void > priorityDelegate(
    void (* NotifyMethod)(),
    int prio,
    Timestamp::TimeDiff expireMilliSec
);

priorityDelegate inline

inline FunctionPriorityDelegate < void, true, true > priorityDelegate(
    void (* NotifyMethod)(const void *) param285,
    int prio
);

priorityDelegate inline

inline FunctionPriorityDelegate < void, true, false > priorityDelegate(
    void (* NotifyMethod)(void *) param286,
    int prio
);

priorityDelegate inline

inline FunctionPriorityDelegate < void, false > priorityDelegate(
    void (* NotifyMethod)(),
    int prio
);

registerExtraEncodings

void registerExtraEncodings();

Registers the character encodings from the Encodings library with the TextEncoding class.

remove inline

template < class S > S remove(
    const S & str,
    const typename S::value_type ch,
    typename S::size_type start = 0
);

removeInPlace inline

template < class S > S & removeInPlace(
    S & str,
    const typename S::value_type ch,
    typename S::size_type start = 0
);

replace inline

template < class S > S replace(
    const S & str,
    const S & from,
    const S & to,
    typename S::size_type start = 0
);

Replace all occurrences of from (which must not be the empty string) in str with to, starting at position start.

replace inline

template < class S > S replace(
    const S & str,
    const typename S::value_type * from,
    const typename S::value_type * to,
    typename S::size_type start = 0
);

replace inline

template < class S > S replace(
    const S & str,
    const typename S::value_type from,
    const typename S::value_type to = 0,
    typename S::size_type start = 0
);

replaceInPlace inline

template < class S > S & replaceInPlace(
    S & str,
    const S & from,
    const S & to,
    typename S::size_type start = 0
);

replaceInPlace inline

template < class S > S & replaceInPlace(
    S & str,
    const typename S::value_type * from,
    const typename S::value_type * to,
    typename S::size_type start = 0
);

replaceInPlace inline

template < class S > S & replaceInPlace(
    S & str,
    const typename S::value_type from,
    const typename S::value_type to = 0,
    typename S::size_type start = 0
);

safeIntCast inline

template < typename F, typename T > inline T & safeIntCast(
    F from,
    T & to
);

Returns cast value if it is safe to cast integer from F to T, otherwise throws BadCastException.

safeMultiply inline

template < typename R, typename F, typename S > bool safeMultiply(
    R & result,
    F f,
    S s
);

startsWith inline

template < class S > bool startsWith(
    const S & str,
    const S & prefix
);

Tests whether the string starts with the given prefix.

strToDouble

double strToDouble(
    const char * str,
    const char * inf = "inf",
    const char * nan = "nan"
);

Converts the string of characters into double-precision floating point number.

strToDouble

bool strToDouble(
    const std::string & str,
    double & result,
    char decSep = '.',
    char thSep = ',',
    const char * inf = "inf",
    const char * nan = "nan"
);

Converts the string of characters into double-precision floating point number. The conversion result is assigned to the result parameter. If decimal separator and/or thousand separator are different from defaults, they should be supplied to ensure proper conversion.

Returns true if successful, false otherwise.

strToFloat

float strToFloat(
    const char * str,
    const char * inf = "inf",
    const char * nan = "nan"
);

Converts the string of characters into single-precision floating point number. Function uses double_conversion::DoubleToStringConverter to do the conversion.

strToFloat

bool strToFloat(
    const std::string & param266,
    float & result,
    char decSep = '.',
    char thSep = ',',
    const char * inf = "inf",
    const char * nan = "nan"
);

Converts the string of characters into single-precision floating point number. The conversion result is assigned to the result parameter. If decimal separator and/or thousand separator are different from defaults, they should be supplied to ensure proper conversion.

Returns true if successful, false otherwise.

strToInt inline

template < typename I > bool strToInt(
    const char * pStr,
    I & outResult,
    short base,
    char thSep = ','
);

Converts zero-terminated character array to integer number; Thousand separators are recognized for base10 and current locale; they are silently skipped and not verified for correct positioning. It is not allowed to convert a negative number to anything except 10-base signed integer. For hexadecimal numbers, the case of the digits is not relevant.

Function returns true if successful. If parsing was unsuccessful, the return value is false with the result value undetermined.

strToInt inline

template < typename I > bool strToInt(
    const std::string & str,
    I & result,
    short base,
    char thSep = ','
);

Converts string to integer number; This is a wrapper function, for details see see the bool strToInt(const char*, I&, short, char) implementation.

swap inline

template < class T, std::size_t N > inline void swap(
    Array < T, N > & x,
    Array < T, N > & y
) noexcept;

global swap()

swap inline

template < class C > inline void swap(
    AutoPtr < C > & p1,
    AutoPtr < C > & p2
) noexcept;

swap inline

inline void swap(
    Clock & s1,
    Clock & s2
) noexcept;

swap inline

inline void swap(
    DateTime & d1,
    DateTime & d2
) noexcept;

swap inline

inline void swap(
    File & f1,
    File & f2
) noexcept;

swap inline

inline void swap(
    LocalDateTime & d1,
    LocalDateTime & d2
) noexcept;

swap inline

inline void swap(
    Message & m1,
    Message & m2
) noexcept;

swap inline

template < typename C > inline void swap(
    Nullable < C > & n1,
    Nullable < C > & n2
) noexcept;

swap inline

template < typename C > inline void swap(
    Optional < C > & n1,
    Optional < C > & n2
) noexcept;

swap inline

inline void swap(
    Path & p1,
    Path & p2
) noexcept;

swap inline

template < class C, class RC, class RP > inline void swap(
    SharedPtr < C, RC, RP > & p1,
    SharedPtr < C, RC, RP > & p2
);

swap inline

inline void swap(
    TextBufferIterator & it1,
    TextBufferIterator & it2
) noexcept;

swap inline

inline void swap(
    TextIterator & it1,
    TextIterator & it2
) noexcept;

swap inline

inline void swap(
    Timespan & s1,
    Timespan & s2
) noexcept;

swap inline

inline void swap(
    Timestamp & s1,
    Timestamp & s2
) noexcept;

swap inline

inline void swap(
    URI & u1,
    URI & u2
) noexcept;

swap inline

inline void swap(
    UUID & u1,
    UUID & u2
) noexcept;

thousandSeparator inline

inline char thousandSeparator();

Returns thousand separator from global locale or default ',' for platforms where locale is unavailable.

toJSON

void toJSON(
    const std::string & value,
    std::ostream & out,
    int options = Poco::JSON_WRAP_STRINGS
);

Formats string value into the supplied output stream by escaping control characters. If JSON_WRAP_STRINGS is in options, the resulting strings is enclosed in double quotes If JSON_ESCAPE_UNICODE is in options, all unicode characters will be escaped, otherwise only the compulsory ones.

toJSON

std::string toJSON(
    const std::string & value,
    int options = Poco::JSON_WRAP_STRINGS
);

Formats string value by escaping control characters. If JSON_WRAP_STRINGS is in options, the resulting string is enclosed in double quotes If JSON_ESCAPE_UNICODE is in options, all unicode characters will be escaped, otherwise only the compulsory ones.

Returns formatted string. If escapeAllUnicode is true, all unicode characters will be escaped, otherwise only the compulsory ones.

toLower inline

template < class S > S toLower(
    const S & str
);

Returns a copy of str containing all lower-case characters.

toLowerInPlace inline

template < class S > S & toLowerInPlace(
    S & str
);

Replaces all characters in str with their lower-case counterparts.

toUpper inline

template < class S > S toUpper(
    const S & str
);

Returns a copy of str containing all upper-case characters.

toUpperInPlace inline

template < class S > S & toUpperInPlace(
    S & str
);

Replaces all characters in str with their upper-case counterparts.

translate inline

template < class S > S translate(
    const S & str,
    const S & from,
    const S & to
);

Returns a copy of str with all characters in from replaced by the corresponding (by position) characters in to. If there is no corresponding character in to, the character is removed from the copy.

translate inline

template < class S > S translate(
    const S & str,
    const typename S::value_type * from,
    const typename S::value_type * to
);

translateInPlace inline

template < class S > S & translateInPlace(
    S & str,
    const S & from,
    const S & to
);

Replaces in str all occurrences of characters in from with the corresponding (by position) characters in to. If there is no corresponding character, the character is removed.

translateInPlace inline

template < class S > S translateInPlace(
    S & str,
    const typename S::value_type * from,
    const typename S::value_type * to
);

trim inline

template < class S > S trim(
    const S & str
);

Returns a copy of str with all leading and trailing whitespace removed.

trimInPlace inline

template < class S > S & trimInPlace(
    S & str
);

Removes all leading and trailing whitespace in str.

trimLeft inline

template < class S > S trimLeft(
    const S & str
);

Returns a copy of str with all leading whitespace removed.

trimLeftInPlace inline

template < class S > S & trimLeftInPlace(
    S & str
);

Removes all leading whitespace in str.

trimRight inline

template < class S > S trimRight(
    const S & str
);

Returns a copy of str with all trailing whitespace removed.

trimRightInPlace inline

template < class S > S & trimRightInPlace(
    S & str
);

Removes all trailing whitespace in str.

uIntToStr inline

[[deprecated ("use intToStr instead")]]
template < typename T > bool uIntToStr(
    T value,
    unsigned short base,
    char * result,
    std::size_t & size,
    bool prefix = false,
    int width = - 1,
    char fill = ' ',
    char thSep = 0,
    bool lowercase = false
);

Deprecated. This function issc_deprecated.

Converts unsigned integer to string. Numeric bases from binary to hexadecimal are supported. If width is non-zero, it pads the return value with fill character to the specified width. When padding is zero character ('0'), it is prepended to the number itself; all other paddings are prepended to the formatted result with minus sign or base prefix included If prefix is true and base is octal or hexadecimal, respective prefix ('0' for octal, "0x" for hexadecimal) is prepended. For all other bases, prefix argument is ignored. Formatted string has at least [width] total length.

This function is deprecated; use intToStr instead.

uIntToStr inline

[[deprecated ("use intToStr instead")]]
template < typename T > bool uIntToStr(
    T number,
    unsigned short base,
    std::string & result,
    bool prefix = false,
    int width = - 1,
    char fill = ' ',
    char thSep = 0,
    bool lowercase = false
);

Deprecated. This function issc_deprecated.

Converts unsigned integer to string; This is a wrapper function, for details see the bool uIntToStr(T, unsigned short, char*, int, int, char, char) implementation.

This function is deprecated; use intToStr instead.

Variables

OrderedMap

template < class Key, class T, class Hash = std::hash < Key >, class KeyEqual = std::equal_to < Key >, class Allocator = std::allocator < std::pair < Key, T >>, class ValueTypeContainer = std::deque < std::pair < Key, T >, Allocator >> using OrderedMap = tsl::ordered_map < Key, T, Hash, KeyEqual, Allocator, ValueTypeContainer >;

For documentation, see https://tessil.github.io/ordered-map/

OrderedSet

template < class Key, class Hash = std::hash < Key >, class KeyEqual = std::equal_to < Key >, class Allocator = std::allocator < Key >, class ValueTypeContainer = std::deque < Key, Allocator >> using OrderedSet = tsl::ordered_set < Key, Hash, KeyEqual, Allocator, ValueTypeContainer >;

For documentation, see https://tessil.github.io/ordered-map/