namespace Poco

Overview

namespace Poco {

// namespaces

namespace Poco::Dynamic;
    namespace Poco::Dynamic::Impl;
namespace Poco::Impl;
namespace Poco::JSON;
namespace Poco::Net;
    namespace Poco::Net::Impl;
namespace Poco::Util;
    namespace Poco::Util::Units;
        namespace Poco::Util::Units::Constants;
        namespace Poco::Util::Units::Internal;
        namespace Poco::Util::Units::Units;
        namespace Poco::Util::Units::Values;
namespace Poco::XML;

// typedefs

typedef BasicMemoryBinaryReader<char> MemoryBinaryReader;
typedef BasicMemoryBinaryWriter<char> MemoryBinaryWriter;
typedef BasicBufferedBidirectionalStreamBuf<char, std::char_traits<char>> BufferedBidirectionalStreamBuf;
typedef BasicBufferedStreamBuf<char, std::char_traits<char>> BufferedStreamBuf;
typedef Dynamic::Struct<std::string> DynamicStruct;
typedef Dynamic::Var DynamicAny;
typedef BasicFIFOBuffer<char> FIFOBuffer;
typedef FPEnvironment FPE;
typedef BasicMemoryStreamBuf<char, std::char_traits<char>> MemoryStreamBuf;
typedef MutexImpl FastMutexImpl;
typedef NestedDiagnosticContext NDC;
typedef RecursiveDirectoryIterator<ChildrenFirstTraverse> SimpleRecursiveDirectoryIterator;
typedef RecursiveDirectoryIterator<SiblingsFirstTraverse> SiblingsFirstRecursiveDirectoryIterator;
typedef std::basic_string<char, i_char_traits<char>> istring;
typedef BasicUnbufferedStreamBuf<char, std::char_traits<char>> UnbufferedStreamBuf;
typedef Poco::UInt16 UTF16Char;
typedef std::basic_string<UTF16Char, UTF16CharTraits> UTF16String;
typedef wchar_t UTF32Char;
typedef std::wstring UTF32String;

// enums

enum NullType;

// structs

template <typename T>
struct AlignOf;

template <std::size_t Alignment>
struct AlignedCharArrayImpl;

template <typename T>
struct AlignmentCalcImpl;

struct CILess;

template <int n>
struct Getter;

template <>
struct Getter<0>;

template <class T>
struct Hash;

template <class T>
struct HashFunction;

template <>
struct HashFunction<std::string>;

template <
    class Key,
    class Value
    >
struct HashMapEntry;

template <
    class HME,
    class KeyHashFunc
    >
struct HashMapEntryHash;

template <
    typename T,
    int i
    >
struct IsConst<const T[i]>;

template <typename T>
struct IsConst<const T&>;

template <typename T>
struct IsConst<const T>;

template <typename T>
struct IsConst;

template <typename T>
struct IsReference<const T&>;

template <typename T>
struct IsReference<T&>;

template <typename T>
struct IsReference;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10,
    class T11,
    class T12
    >
struct NamedTuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10,
    class T11
    >
struct NamedTuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9
    >
struct NamedTuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10
    >
struct NamedTuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10,
    class T11,
    class T12,
    class T13
    >
struct NamedTuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10,
    class T11,
    class T12,
    class T13,
    class T14,
    class T15
    >
struct NamedTuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10,
    class T11,
    class T12,
    class T13,
    class T14,
    class T15,
    class T16
    >
struct NamedTuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10,
    class T11,
    class T12,
    class T13,
    class T14
    >
struct NamedTuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10,
    class T11,
    class T12,
    class T13,
    class T14,
    class T15,
    class T16,
    class T17,
    class T18
    >
struct NamedTuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10,
    class T11,
    class T12,
    class T13,
    class T14,
    class T15,
    class T16,
    class T17
    >
struct NamedTuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8
    >
struct NamedTuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4
    >
struct NamedTuple<T0, T1, T2, T3, T4, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6
    >
struct NamedTuple<T0, T1, T2, T3, T4, T5, T6, NullTypeList>;

template <
    class T0,
    class T1,
    class T2
    >
struct NamedTuple<T0, T1, T2, NullTypeList>;

template <
    class T0,
    class T1
    >
struct NamedTuple<T0, T1, NullTypeList>;

template <class T0>
struct NamedTuple<T0, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3
    >
struct NamedTuple<T0, T1, T2, T3, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5
    >
struct NamedTuple<T0, T1, T2, T3, T4, T5, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7
    >
struct NamedTuple<T0, T1, T2, T3, T4, T5, T6, T7, NullTypeList>;

template <
    class T0,
    class T1 = NullTypeList,
    class T2 = NullTypeList,
    class T3 = NullTypeList,
    class T4 = NullTypeList,
    class T5 = NullTypeList,
    class T6 = NullTypeList,
    class T7 = NullTypeList,
    class T8 = NullTypeList,
    class T9 = NullTypeList,
    class T10 = NullTypeList,
    class T11 = NullTypeList,
    class T12 = NullTypeList,
    class T13 = NullTypeList,
    class T14 = NullTypeList,
    class T15 = NullTypeList,
    class T16 = NullTypeList,
    class T17 = NullTypeList,
    class T18 = NullTypeList,
    class T19 = NullTypeList
    >
struct NamedTuple;

struct NullTypeList;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10
    >
struct Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10,
    class T11,
    class T12,
    class T13
    >
struct Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10,
    class T11,
    class T12
    >
struct Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10,
    class T11
    >
struct Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10,
    class T11,
    class T12,
    class T13,
    class T14,
    class T15,
    class T16,
    class T17,
    class T18
    >
struct Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10,
    class T11,
    class T12,
    class T13,
    class T14
    >
struct Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10,
    class T11,
    class T12,
    class T13,
    class T14,
    class T15,
    class T16
    >
struct Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10,
    class T11,
    class T12,
    class T13,
    class T14,
    class T15
    >
struct Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9,
    class T10,
    class T11,
    class T12,
    class T13,
    class T14,
    class T15,
    class T16,
    class T17
    >
struct Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8
    >
struct Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7,
    class T8,
    class T9
    >
struct Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, NullTypeList>;

template <
    class T0,
    class T1,
    class T2
    >
struct Tuple<T0, T1, T2, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6,
    class T7
    >
struct Tuple<T0, T1, T2, T3, T4, T5, T6, T7, NullTypeList>;

template <
    class T0,
    class T1
    >
struct Tuple<T0, T1, NullTypeList>;

template <class T0>
struct Tuple<T0, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3
    >
struct Tuple<T0, T1, T2, T3, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5
    >
struct Tuple<T0, T1, T2, T3, T4, T5, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4
    >
struct Tuple<T0, T1, T2, T3, T4, NullTypeList>;

template <
    class T0,
    class T1,
    class T2,
    class T3,
    class T4,
    class T5,
    class T6
    >
struct Tuple<T0, T1, T2, T3, T4, T5, T6, NullTypeList>;

template <
    class T0,
    class T1 = NullTypeList,
    class T2 = NullTypeList,
    class T3 = NullTypeList,
    class T4 = NullTypeList,
    class T5 = NullTypeList,
    class T6 = NullTypeList,
    class T7 = NullTypeList,
    class T8 = NullTypeList,
    class T9 = NullTypeList,
    class T10 = NullTypeList,
    class T11 = NullTypeList,
    class T12 = NullTypeList,
    class T13 = NullTypeList,
    class T14 = NullTypeList,
    class T15 = NullTypeList,
    class T16 = NullTypeList,
    class T17 = NullTypeList,
    class T18 = NullTypeList,
    class T19 = NullTypeList
    >
struct Tuple;

template <class T>
struct TypeAllEraser<NullTypeList, T>;

template <
    class T,
    class Tail
    >
struct TypeAllEraser<TypeList<T, Tail>, T>;

template <
    class Head,
    class Tail,
    class T
    >
struct TypeAllEraser<TypeList<Head, Tail>, T>;

template <
    class Head,
    class T
    >
struct TypeAllEraser;

template <
    class T,
    class Tail,
    class R
    >
struct TypeAllReplacer<TypeList<T, Tail>, T, R>;

template <
    class Head,
    class Tail,
    class T,
    class R
    >
struct TypeAllReplacer<TypeList<Head, Tail>, T, R>;

template <
    class T,
    class R
    >
struct TypeAllReplacer<NullTypeList, T, R>;

template <
    class Head,
    class T,
    class R
    >
struct TypeAllReplacer;

template <>
struct TypeAppender<NullTypeList, NullTypeList>;

template <
    class Head,
    class T
    >
struct TypeAppender;

template <class T>
struct TypeAppender<NullTypeList, T>;

template <
    class Head,
    class Tail,
    class T
    >
struct TypeAppender<TypeList<Head, Tail>, T>;

template <
    class Head,
    class Tail
    >
struct TypeAppender<NullTypeList, TypeList<Head, Tail>>;

template <
    class Head,
    class Tail
    >
struct TypeDuplicateEraser<TypeList<Head, Tail>>;

template <>
struct TypeDuplicateEraser<NullTypeList>;

template <class Head>
struct TypeDuplicateEraser;

template <
    int N,
    class Head,
    class Tail
    >
struct TypeGetter<N, TypeList<Head, Tail>>;

template <
    int N,
    class Head
    >
struct TypeGetter;

template <
    class Head,
    class Tail
    >
struct TypeGetter<0, TypeList<Head, Tail>>;

template <
    class Head,
    class Tail
    >
struct TypeList;

template <
    typename T0 = NullTypeList,
    typename T1 = NullTypeList,
    typename T2 = NullTypeList,
    typename T3 = NullTypeList,
    typename T4 = NullTypeList,
    typename T5 = NullTypeList,
    typename T6 = NullTypeList,
    typename T7 = NullTypeList,
    typename T8 = NullTypeList,
    typename T9 = NullTypeList,
    typename T10 = NullTypeList,
    typename T11 = NullTypeList,
    typename T12 = NullTypeList,
    typename T13 = NullTypeList,
    typename T14 = NullTypeList,
    typename T15 = NullTypeList,
    typename T16 = NullTypeList,
    typename T17 = NullTypeList,
    typename T18 = NullTypeList,
    typename T19 = NullTypeList
    >
struct TypeListType;

template <>
struct TypeListType<>;

template <
    class T,
    class Tail
    >
struct TypeLocator<TypeList<T, Tail>, T>;

template <class T>
struct TypeLocator<NullTypeList, T>;

template <
    class Head,
    class Tail,
    class T
    >
struct TypeLocator<TypeList<Head, Tail>, T>;

template <
    class Head,
    class T
    >
struct TypeLocator;

template <
    class T,
    class Tail
    >
struct TypeOneEraser<TypeList<T, Tail>, T>;

template <
    class Head,
    class Tail,
    class T
    >
struct TypeOneEraser<TypeList<Head, Tail>, T>;

template <class T>
struct TypeOneEraser<NullTypeList, T>;

template <
    class Head,
    class T
    >
struct TypeOneEraser;

template <
    class T,
    class Tail,
    class R
    >
struct TypeOneReplacer<TypeList<T, Tail>, T, R>;

template <
    class Head,
    class Tail,
    class T,
    class R
    >
struct TypeOneReplacer<TypeList<Head, Tail>, T, R>;

template <
    class T,
    class R
    >
struct TypeOneReplacer<NullTypeList, T, R>;

template <
    class Head,
    class T,
    class R
    >
struct TypeOneReplacer;

template <typename T>
struct TypeWrapper<const T&>;

template <typename T>
struct TypeWrapper;

template <typename T>
struct TypeWrapper<T&>;

template <typename T>
struct TypeWrapper<const T>;

struct UTF16CharTraits;
struct UTF32CharTraits;
struct UTF8;

template <typename charT>
struct i_char_traits;

// unions

template <
    typename PlaceholderT,
    unsigned int SizeV = POCO_SMALL_OBJECT_SIZE
    >
union Placeholder;

// classes

class ASCIIEncoding;

template <
    class TKey,
    class TValue,
    class TStrategy,
    class TMutex = FastMutex,
    class TEventMutex = FastMutex
    >
class AbstractCache;

template <>
class AbstractDelegate<void>;

template <class TArgs>
class AbstractDelegate;

template <
    class TStrategy,
    class TDelegate,
    class TMutex
    >
class AbstractEvent<void, TStrategy, TDelegate, TMutex>;

template <
    class TArgs,
    class TStrategy,
    class TDelegate,
    class TMutex = FastMutex
    >
class AbstractEvent;

template <class Base>
class AbstractInstantiator;

template <class B>
class AbstractMetaObject;

class AbstractObserver;

template <class TArgs>
class AbstractPriorityDelegate;

template <
    class TKey,
    class TValue
    >
class AbstractStrategy;

class AbstractTimerCallback;

template <typename TArgs>
class AccessExpirationDecorator;

template <
    class TKey,
    class TValue,
    class TMutex = FastMutex,
    class TEventMutex = FastMutex
    >
class AccessExpireCache;

template <
    class TKey,
    class TValue,
    class TMutex = FastMutex,
    class TEventMutex = FastMutex
    >
class AccessExpireLRUCache;

template <
    class TKey,
    class TValue
    >
class AccessExpireStrategy;

class ActiveDispatcher;

template <
    class ResultType,
    class OwnerType,
    class StarterType
    >
class ActiveMethod<ResultType, void, OwnerType, StarterType>;

template <
    class ResultType,
    class ArgType,
    class OwnerType,
    class StarterType = ActiveStarter<OwnerType>
    >
class ActiveMethod;

template <>
class ActiveResult<void>;

template <class RT>
class ActiveResult;

template <>
class ActiveResultHolder<void>;

template <class ResultType>
class ActiveResultHolder;

template <class OwnerType>
class ActiveRunnable<void, void, OwnerType>;

template <
    class ArgType,
    class OwnerType
    >
class ActiveRunnable<void, ArgType, OwnerType>;

template <
    class ResultType,
    class ArgType,
    class OwnerType
    >
class ActiveRunnable;

template <
    class ResultType,
    class OwnerType
    >
class ActiveRunnable<ResultType, void, OwnerType>;

class ActiveRunnableBase;

template <>
class ActiveStarter<ActiveDispatcher>;

template <class OwnerType>
class ActiveStarter;

template <class C>
class Activity;

class Any;
class ArchiveByNumberStrategy;

template <class DT>
class ArchiveByTimestampStrategy;

class ArchiveStrategy;

template <
    class T,
    std::size_t N
    >
class Array;

class Ascii;
class AsyncChannel;
class AtomicCounter;

template <class C>
class AutoPtr;

template <class C>
class AutoReleasePool;

class Base32Decoder;
class Base32DecoderBuf;
class Base32DecoderIOS;
class Base32Encoder;
class Base32EncoderBuf;
class Base32EncoderIOS;
class Base64Decoder;
class Base64DecoderBuf;
class Base64DecoderIOS;
class Base64Encoder;
class Base64EncoderBuf;
class Base64EncoderIOS;

template <
    typename ch,
    typename tr,
    typename ba = BufferAllocator<ch>
    >
class BasicBufferedBidirectionalStreamBuf;

template <
    typename ch,
    typename tr,
    typename ba = BufferAllocator<ch>
    >
class BasicBufferedStreamBuf;

template <
    class TArgs,
    class TMutex = FastMutex
    >
class BasicEvent;

template <class T>
class BasicFIFOBuffer;

template <typename T>
class BasicMemoryBinaryReader;

template <typename T>
class BasicMemoryBinaryWriter;

template <
    typename ch,
    typename tr
    >
class BasicMemoryStreamBuf;

template <
    typename ch,
    typename tr
    >
class BasicUnbufferedStreamBuf;

class BinaryReader;
class BinaryWriter;

template <class T>
class Buffer;

template <typename ch>
class BufferAllocator;

class Bugcheck;
class ByteOrder;
class Channel;
class Checksum;
class ChildrenFirstTraverse;

template <class Base>
class ClassLoader;

class Clock;
class ColorConsoleChannel;
class Condition;
class Configurable;
class ConsoleChannel;
class CountingIOS;
class CountingInputStream;
class CountingOutputStream;
class CountingStreamBuf;
class DateTime;
class DateTimeFormat;
class DateTimeFormatter;
class DateTimeParser;
class Debugger;

template <
    class TArgs,
    class TDelegate
    >
class DefaultStrategy;

template <class TDelegate>
class DefaultStrategy<void, TDelegate>;

class DeflatingIOS;
class DeflatingInputStream;
class DeflatingOutputStream;
class DeflatingStreamBuf;

template <class TObj>
class Delegate<TObj, void, false>;

template <
    class TObj,
    class TArgs
    >
class Delegate<TObj, TArgs, false>;

template <class TObj>
class Delegate<TObj, void, true>;

template <
    class TObj,
    class TArgs,
    bool withSender = true
    >
class Delegate;

class DigestBuf;
class DigestEngine;
class DigestIOS;
class DigestInputStream;
class DigestOutputStream;
class DirectoryIterator;
class DirectoryIteratorImpl;
class DirectoryWatcher;

template <class Base>
class DynamicFactory;

class EOFToken;
class Environment;
class EnvironmentImpl;
class Error;
class ErrorHandler;
class Event;
class EventArgs;
class EventChannel;
class EventImpl;
class EventLogChannel;
class Exception;

template <typename TArgs>
class ExpirationDecorator;

template <class TArgs>
class Expire;

template <>
class Expire<void>;

template <
    class TKey,
    class TValue,
    class TMutex = FastMutex,
    class TEventMutex = FastMutex
    >
class ExpireCache;

template <
    class TKey,
    class TValue,
    class TMutex = FastMutex,
    class TEventMutex = FastMutex
    >
class ExpireLRUCache;

template <
    class TKey,
    class TValue
    >
class ExpireStrategy;

class FIFOBufferStream;
class FIFOBufferStreamBuf;

template <
    class TArgs,
    class TMutex = FastMutex
    >
class FIFOEvent;

class FIFOIOS;

template <
    class TArgs,
    class TDelegate
    >
class FIFOStrategy;

class FPEnvironment;
class FPEnvironmentImpl;
class FastMutex;
class FastMutexImpl;
class File;
class FileChannel;
class FileIOS;
class FileImpl;
class FileInputStream;
class FileOutputStream;
class FileStream;
class FileStreamBuf;
class FileStreamFactory;
class Formatter;
class FormattingChannel;

template <>
class FunctionDelegate<void, true, false>;

template <>
class FunctionDelegate<void, true, true>;

template <bool senderIsConst>
class FunctionDelegate<void, false, senderIsConst>;

template <
    class TArgs,
    bool hasSender = true,
    bool senderIsConst = true
    >
class FunctionDelegate;

template <
    class TArgs,
    bool senderIsConst
    >
class FunctionDelegate<TArgs, false, senderIsConst>;

template <class TArgs>
class FunctionDelegate<TArgs, true, false>;

template <
    class TArgs,
    bool useSender = true,
    bool senderIsConst = true
    >
class FunctionPriorityDelegate;

template <>
class FunctionPriorityDelegate<void, true, true>;

template <>
class FunctionPriorityDelegate<void, false>;

template <>
class FunctionPriorityDelegate<void, true, false>;

template <class TArgs>
class FunctionPriorityDelegate<TArgs, true, false>;

template <class TArgs>
class FunctionPriorityDelegate<TArgs, false>;

class Glob;

template <class Engine>
class HMACEngine;

template <
    class Key,
    class Mapped,
    class HashFunc = Hash<Key>
    >
class HashMap;

template <
    class Value,
    class HashFunc = Hash<Value>
    >
class HashSet;

class HashStatistic;

template <
    class Key,
    class Value,
    class KeyHashFunction = HashFunction<Key>
    >
class HashTable;

class HexBinaryDecoder;
class HexBinaryDecoderBuf;
class HexBinaryDecoderIOS;
class HexBinaryEncoder;
class HexBinaryEncoderBuf;
class HexBinaryEncoderIOS;
class InflatingIOS;
class InflatingInputStream;
class InflatingOutputStream;
class InflatingStreamBuf;
class InputLineEndingConverter;
class InputStreamConverter;

template <
    class C,
    class Base
    >
class Instantiator;

class InvalidToken;

template <
    class TKey,
    class TValue
    >
class KeyValueArgs;

template <
    class TKey,
    class TValue,
    class TMutex = FastMutex,
    class TEventMutex = FastMutex
    >
class LRUCache;

template <
    class TKey,
    class TValue
    >
class LRUStrategy;

class Latin1Encoding;
class Latin2Encoding;
class Latin9Encoding;
class LineEnding;
class LineEndingConverterIOS;
class LineEndingConverterStreamBuf;

template <
    class Value,
    class HashFunc = Hash<Value>
    >
class LinearHashTable;

template <
    class Key,
    class Mapped,
    class Container = std::list<std::pair<Key, Mapped> >,
    bool CaseSensitive = false
    >
class ListMap;

class LocalDateTime;
class LogFile;
class LogFileImpl;
class LogIOS;
class LogStream;
class LogStreamBuf;
class Logger;
class LoggingFactory;
class LoggingRegistry;
class MD4Engine;
class MD5Engine;

template <class B>
class Manifest;

class ManifestBase;
class MemoryIOS;
class MemoryInputStream;
class MemoryOutputStream;
class MemoryPool;
class Message;

template <
    class C,
    class B
    >
class MetaObject;

template <
    class C,
    class B
    >
class MetaSingleton;

class Mutex;
class MutexImpl;
class NDCScope;

template <
    class C,
    class N
    >
class NObserver;

class NamedEvent;
class NamedEventImpl;
class NamedMutex;
class NamedMutexImpl;
class NestedDiagnosticContext;
class Notification;
class NotificationCenter;
class NotificationQueue;

template <
    class TArgs,
    class TDelegate
    >
class NotificationStrategy;

template <class TDelegate>
class NotificationStrategy<void, TDelegate>;

class NullChannel;
class NullIOS;
class NullInputStream;
class NullMutex;
class NullOutputStream;
class NullStreamBuf;

template <typename C>
class Nullable;

class NumberFormatter;
class NumberParser;

template <
    class C,
    class P = C*,
    class F = PoolableObjectFactory<C, P>
    >
class ObjectPool;

template <
    class C,
    class N
    >
class Observer;

class OpcomChannel;

template <typename C>
class Optional;

class OutputLineEndingConverter;
class OutputStreamConverter;

template <class PRF>
class PBKDF2Engine;

class Path;
class PathImpl;
class PatternFormatter;
class Pipe;
class PipeIOS;
class PipeImpl;
class PipeInputStream;
class PipeOutputStream;
class PipeStreamBuf;

template <class C>
class PoolableObjectFactory<C, Poco::SharedPtr<C>>;

template <class C>
class PoolableObjectFactory<C, Poco::AutoPtr<C>>;

template <
    class C,
    class P = C*
    >
class PoolableObjectFactory;

template <class TObj>
class PriorityDelegate<TObj, void, true>;

template <
    class TObj,
    class TArgs
    >
class PriorityDelegate<TObj, TArgs, false>;

template <class TObj>
class PriorityDelegate<TObj, void, false>;

template <
    class TObj,
    class TArgs,
    bool useSender = true
    >
class PriorityDelegate;

template <
    class TArgs,
    class TMutex = FastMutex
    >
class PriorityEvent;

template <class TArgs>
class PriorityExpire;

template <>
class PriorityExpire<void>;

class PriorityNotificationQueue;

template <
    class TArgs,
    class TDelegate
    >
class PriorityStrategy;

template <class TDelegate>
class PriorityStrategy<void, TDelegate>;

class Process;
class ProcessHandle;
class ProcessHandleImpl;
class ProcessImpl;
class PurgeByAgeStrategy;
class PurgeByCountStrategy;
class PurgeStrategy;
class RWLock;
class RWLockImpl;
class Random;
class RandomBuf;
class RandomIOS;
class RandomInputStream;

template <class TTravStr = ChildrenFirstTraverse>
class RecursiveDirectoryIterator;

template <class TTraverseStrategy = ChildrenFirstTraverse>
class RecursiveDirectoryIteratorImpl;

class RefCountedObject;
class ReferenceCounter;
class RegularExpression;

template <class C>
class ReleaseArrayPolicy;

template <class C>
class ReleasePolicy;

template <class DT>
class RotateAtTimeStrategy;

class RotateByIntervalStrategy;
class RotateBySizeStrategy;
class RotateStrategy;
class Runnable;

template <class C>
class RunnableAdapter;

class SHA1Engine;

template <class M>
class ScopedLock;

template <class M>
class ScopedLockWithUnlock;

class ScopedRWLock;
class ScopedReadRWLock;

template <class M>
class ScopedUnlock;

class ScopedWriteRWLock;
class Semaphore;
class SemaphoreImpl;
class SharedLibrary;
class SharedLibraryImpl;
class SharedMemory;
class SharedMemoryImpl;

template <
    class C,
    class RC = ReferenceCounter,
    class RP = ReleasePolicy<C>
    >
class SharedPtr;

class SiblingsFirstTraverse;
class SimpleFileChannel;

template <
    class Key,
    class Value,
    class KeyHashFunction = HashFunction<Key>
    >
class SimpleHashTable;

template <class S>
class SingletonHolder;

class SortedDirectoryIterator;
class SplitterChannel;
class Stopwatch;

template <
    class TKey,
    class TValue
    >
class StrategyCollection;

class StreamChannel;
class StreamConverterBuf;
class StreamConverterIOS;
class StreamCopier;
class StreamTokenizer;
class StringTokenizer;
class SynchronizedObject;
class SyslogChannel;
class TLSAbstractSlot;

template <class C>
class TLSSlot;

class Task;
class TaskCancelledNotification;

template <class C>
class TaskCustomNotification;

class TaskFailedNotification;
class TaskFinishedNotification;
class TaskManager;
class TaskNotification;
class TaskProgressNotification;
class TaskStartedNotification;
class TeeIOS;
class TeeInputStream;
class TeeOutputStream;
class TeeStreamBuf;
class TemporaryFile;
class TextBufferIterator;
class TextConverter;
class TextEncoding;
class TextIterator;
class Thread;
class ThreadImpl;

template <class C>
class ThreadLocal;

class ThreadLocalStorage;
class ThreadPool;
class ThreadTarget;
class TimedNotificationQueue;
class Timer;

template <class C>
class TimerCallback;

class Timespan;
class Timestamp;
class Timezone;
class Token;
class TraverseBase;
class URI;
class URIRedirection;
class URIStreamFactory;
class URIStreamOpener;
class UTF16Encoding;
class UTF32Encoding;
class UTF8Encoding;
class UUID;
class UUIDGenerator;
class Unicode;
class UnicodeConverter;

template <
    class TKey,
    class TValue,
    class TMutex = FastMutex,
    class TEventMutex = FastMutex
    >
class UniqueAccessExpireCache;

template <
    class TKey,
    class TValue,
    class TMutex = FastMutex,
    class TEventMutex = FastMutex
    >
class UniqueAccessExpireLRUCache;

template <
    class TKey,
    class TValue
    >
class UniqueAccessExpireStrategy;

template <
    class TKey,
    class TValue,
    class TMutex = FastMutex,
    class TEventMutex = FastMutex
    >
class UniqueExpireCache;

template <
    class TKey,
    class TValue,
    class TMutex = FastMutex,
    class TEventMutex = FastMutex
    >
class UniqueExpireLRUCache;

template <
    class TKey,
    class TValue
    >
class UniqueExpireStrategy;

template <class TKey>
class ValidArgs;

class Void;
class WhitespaceToken;
class Windows1250Encoding;
class Windows1251Encoding;
class Windows1252Encoding;
class WindowsColorConsoleChannel;
class WindowsConsoleChannel;

// global functions

template <typename T>
unsigned
alignOf();

template <typename ValueType>
ValueType*
AnyCast(Any* operand);

template <typename ValueType>
const ValueType*
AnyCast(const Any* operand);

template <typename ValueType>
ValueType
AnyCast(Any& operand);

template <typename ValueType>
ValueType
AnyCast(const Any& operand);

template <typename ValueType>
const ValueType&
RefAnyCast(const Any& operand);

template <typename ValueType>
ValueType&
RefAnyCast(Any& operand);

template <typename ValueType>
ValueType*
UnsafeAnyCast(Any* operand);

template <typename ValueType>
const ValueType*
UnsafeAnyCast(const Any* operand);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::string Foundation_API
format(
    const std::string& fmt,
    const Any& value1,
    const Any& value2
    );

std::string Foundation_API
format(
    const std::string& fmt,
    const Any& value1,
    const Any& value2,
    const Any& value3
    );

std::string Foundation_API
format(
    const std::string& fmt,
    const Any& value1,
    const Any& value2,
    const Any& value3,
    const Any& value4
    );

std::string Foundation_API
format(
    const std::string& fmt,
    const Any& value1,
    const Any& value2,
    const Any& value3,
    const Any& value4,
    const Any& value5
    );

std::string Foundation_API
format(
    const std::string& fmt,
    const Any& value1,
    const Any& value2,
    const Any& value3,
    const Any& value4,
    const Any& value5,
    const Any& value6
    );

std::string Foundation_API
format(
    const std::string& fmt,
    const Any& value1,
    const Any& value2,
    const Any& value3,
    const Any& value4,
    const Any& value5,
    const Any& value6,
    const Any& value7
    );

std::string Foundation_API
format(
    const std::string& fmt,
    const Any& value1,
    const Any& value2,
    const Any& value3,
    const Any& value4,
    const Any& value5,
    const Any& value6,
    const Any& value7,
    const Any& value8
    );

std::string Foundation_API
format(
    const std::string& fmt,
    const Any& value1,
    const Any& value2,
    const Any& value3,
    const Any& value4,
    const Any& value5,
    const Any& value6,
    const Any& value7,
    const Any& value8,
    const Any& value9
    );

std::string Foundation_API
format(
    const std::string& fmt,
    const Any& value1,
    const Any& value2,
    const Any& value3,
    const Any& value4,
    const Any& value5,
    const Any& value6,
    const Any& value7,
    const Any& value8,
    const Any& value9,
    const Any& value10
    );

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

void Foundation_API
format(
    std::string& result,
    const std::string& fmt,
    const Any& value1,
    const Any& value2
    );

void Foundation_API
format(
    std::string& result,
    const std::string& fmt,
    const Any& value1,
    const Any& value2,
    const Any& value3
    );

void Foundation_API
format(
    std::string& result,
    const std::string& fmt,
    const Any& value1,
    const Any& value2,
    const Any& value3,
    const Any& value4
    );

void Foundation_API
format(
    std::string& result,
    const std::string& fmt,
    const Any& value1,
    const Any& value2,
    const Any& value3,
    const Any& value4,
    const Any& value5
    );

void Foundation_API
format(
    std::string& result,
    const std::string& fmt,
    const Any& value1,
    const Any& value2,
    const Any& value3,
    const Any& value4,
    const Any& value5,
    const Any& value6
    );

void Foundation_API
format(
    std::string& result,
    const std::string& fmt,
    const Any& value1,
    const Any& value2,
    const Any& value3,
    const Any& value4,
    const Any& value5,
    const Any& value6,
    const Any& value7
    );

void Foundation_API
format(
    std::string& result,
    const std::string& fmt,
    const Any& value1,
    const Any& value2,
    const Any& value3,
    const Any& value4,
    const Any& value5,
    const Any& value6,
    const Any& value7,
    const Any& value8
    );

void Foundation_API
format(
    std::string& result,
    const std::string& fmt,
    const Any& value1,
    const Any& value2,
    const Any& value3,
    const Any& value4,
    const Any& value5,
    const Any& value6,
    const Any& value7,
    const Any& value8,
    const Any& value9
    );

void Foundation_API
format(
    std::string& result,
    const std::string& fmt,
    const Any& value1,
    const Any& value2,
    const Any& value3,
    const Any& value4,
    const Any& value5,
    const Any& value6,
    const Any& value7,
    const Any& value8,
    const Any& value9,
    const Any& value10
    );

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

std::size_t Foundation_API
hash(Int8 n);

std::size_t Foundation_API
hash(UInt8 n);

std::size_t Foundation_API
hash(Int16 n);

std::size_t Foundation_API
hash(UInt16 n);

std::size_t Foundation_API
hash(Int32 n);

std::size_t Foundation_API
hash(UInt32 n);

std::size_t Foundation_API
hash(Int64 n);

std::size_t Foundation_API
hash(UInt64 n);

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

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

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

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

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

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

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

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

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

char
decimalSeparator();

char
thousandSeparator();

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

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

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

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
    );

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

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

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

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

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

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

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

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

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

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

Foundation_API float
strToFloat(const char* str);

Foundation_API bool
strToFloat(
    const std::string&,
    float& result,
    char decSep = '.',
    char thSep = ','
    );

Foundation_API double
strToDouble(const char* str);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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
    );

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
    );

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

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

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

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

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

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

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

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

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
    );

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
    );

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

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

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
    );

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
    );

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

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

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

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

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

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

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

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

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

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

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

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

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

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

} // namespace Poco

Detailed Documentation

Typedefs

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

Case-insensitive std::string counterpart.

Global Functions

template <typename T>
unsigned
alignOf()

A templated function that returns the minimum alignment of of a type.

This provides no extra functionality beyond the AlignOf class besides some cosmetic cleanliness. Example usage: alignOf<int>() returns the alignment of an int.

template <typename ValueType>
ValueType*
AnyCast(Any* operand)

AnyCast operator used to extract the ValueType from an Any*.

Will return a pointer to the stored value.

Example Usage: MyType* pTmp = AnyCast<MyType*>(pAny). Will return NULL if the cast fails, i.e. types don’t match.

template <typename ValueType>
const ValueType*
AnyCast(const Any* operand)

AnyCast operator used to extract a const ValueType pointer from an const Any*.

Will return a const pointer to the stored value.

Example Usage: const MyType* pTmp = AnyCast<MyType*>(pAny). Will return NULL if the cast fails, i.e. types don’t match.

template <typename ValueType>
ValueType
AnyCast(Any& operand)

AnyCast operator used to extract a copy of the ValueType from an Any &.

Example Usage: MyType tmp = AnyCast<MyType>(anAny). Will throw a BadCastException if the cast fails. Dont use an AnyCast in combination with references, i.e. MyType& tmp = … or const MyType& tmp = … Some compilers will accept this code although a copy is returned. Use the RefAnyCast in these cases.

template <typename ValueType>
ValueType
AnyCast(const Any& operand)

AnyCast operator used to extract a copy of the ValueType from an const Any &.

Example Usage: MyType tmp = AnyCast<MyType>(anAny). Will throw a BadCastException if the cast fails. Dont use an AnyCast in combination with references, i.e. MyType& tmp = … or const MyType& = … Some compilers will accept this code although a copy is returned. Use the RefAnyCast in these cases.

template <typename ValueType>
const ValueType&
RefAnyCast(const Any& operand)

AnyCast operator used to return a const reference to the internal data.

Example Usage: const MyType& tmp = RefAnyCast<MyType>(anAny);

template <typename ValueType>
ValueType&
RefAnyCast(Any& operand)

AnyCast operator used to return a reference to the internal data.

Example Usage: MyType& tmp = RefAnyCast<MyType>(anAny);

template <typename ValueType>
ValueType*
UnsafeAnyCast(Any* operand)

The “unsafe” versions of AnyCast are not part of the public interface and may be removed at any time.

They are required where we know what type is stored in the any and can’t use typeid() comparison, e.g., when our types may travel across different shared libraries.

template <typename ValueType>
const ValueType*
UnsafeAnyCast(const Any* operand)

The “unsafe” versions of AnyCast are not part of the public interface and may be removed at any time.

They are required where we know what type is stored in the any and can’t use typeid() comparison, e.g., when our types may travel across different shared libraries.

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

global swap()

std::string Foundation_API
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 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, 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);

void Foundation_API
format(
    std::string& result,
    const std::string& fmt,
    const Any& value
    )

Appends the formatted string to result.

void Foundation_API
format(
    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().

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

Returns true if this Nullable is null.

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

Compares Nullable with value for non equality.

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

Compares Nullable with NullData for equality.

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

Returns true if this Nullable is not null.

char
decimalSeparator()

Returns decimal separator from global locale or default ‘.

‘ for platforms where locale is unavailable.

char
thousandSeparator()

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

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

Converts zero-terminated character array to integer number; Thousand separators are recognized for base10 and current locale; it is silently skipped but not verified for correct positioning.

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

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.

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

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

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

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

Foundation_API float
strToFloat(const char* str)

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

Function uses double_convesrion::DoubleToStringConverter to do the conversion.

Foundation_API bool
strToFloat(
    const std::string&,
    float& result,
    char decSep = '.',
    char thSep = ','
    )

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 succesful, false otherwise.

Foundation_API double
strToDouble(const char* str)

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

Foundation_API bool
strToDouble(
    const std::string& str,
    double& result,
    char decSep = '.',
    char thSep = ','
    )

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 succesful, false otherwise.

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

Returns a copy of str with all leading whitespace removed.

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

Removes all leading whitespace in str.

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

Returns a copy of str with all trailing whitespace removed.

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

Removes all trailing whitespace in str.

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

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

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

Removes all leading and trailing whitespace in str.

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

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

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

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

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

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

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

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

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.

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

Replaces in str all occurences of characters in from with the corresponding (by position) characters in to.

If there is no corresponding character, the character is removed.

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

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

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

Concatenates two strings.

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

Concatenates three strings.

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

Concatenates four strings.

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

Concatenates five strings.

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.

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.

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

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