Namespaces: Crypto, Data, Net, Util, XML, Zip
Classes: ASCIIEncoding, AbstractCache, AbstractDelegate, AbstractEvent, AbstractInstantiator, AbstractMetaObject, AbstractObserver, AbstractPriorityDelegate, AbstractStrategy, AbstractTimerCallback, AccessExpirationDecorator, AccessExpireCache, AccessExpireLRUCache, AccessExpireStrategy, ActiveDispatcher, ActiveMethod, ActiveResult, ActiveResultHolder, ActiveRunnable, ActiveRunnableBase, ActiveStarter, Activity, Any, ApplicationException, ArchiveByNumberStrategy, ArchiveByTimestampStrategy, ArchiveStrategy, AssertionViolationException, AsyncChannel, AtomicCounter, AutoPtr, AutoReleasePool, BadCastException, Base64Decoder, Base64DecoderBuf, Base64DecoderIOS, Base64Encoder, Base64EncoderBuf, Base64EncoderIOS, BasicBufferedBidirectionalStreamBuf, BasicBufferedStreamBuf, BasicEvent, BasicMemoryStreamBuf, BasicUnbufferedStreamBuf, BinaryReader, BinaryWriter, Buffer, BufferAllocator, Bugcheck, BugcheckException, ByteOrder, Channel, Checksum, CircularReferenceException, ClassLoader, Condition, Configurable, ConsoleChannel, CountingIOS, CountingInputStream, CountingOutputStream, CountingStreamBuf, CreateFileException, DataException, DataFormatException, DateTime, DateTimeFormat, DateTimeFormatter, DateTimeParser, Debugger, DefaultStrategy, DeflatingIOS, DeflatingInputStream, DeflatingOutputStream, DeflatingStreamBuf, Delegate, DigestBuf, DigestEngine, DigestIOS, DigestInputStream, DigestOutputStream, DirectoryIterator, DynamicAny, DynamicAnyHolder, DynamicAnyHolderImpl, DynamicFactory, EOFToken, Environment, ErrorHandler, Event, EventArgs, EventLogChannel, Exception, ExistsException, ExpirationDecorator, Expire, ExpireCache, ExpireLRUCache, ExpireStrategy, FIFOEvent, FIFOStrategy, FPEnvironment, FastMutex, File, FileAccessDeniedException, FileChannel, FileException, FileExistsException, FileIOS, FileInputStream, FileNotFoundException, 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, Latin9Encoding, LibraryAlreadyLoadedException, LibraryLoadException, LineEnding, LineEndingConverterIOS, LineEndingConverterStreamBuf, LinearHashTable, LocalDateTime, LogFile, LogIOS, LogStream, LogStreamBuf, Logger, LoggingFactory, LoggingRegistry, LogicException, MD2Engine, MD4Engine, MD5Engine, 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, NullOutputStream, NullPointerException, NullStreamBuf, NullTypeList, NumberFormatter, NumberParser, Observer, OpcomChannel, OpenFileException, OutOfMemoryException, OutputLineEndingConverter, OutputStreamConverter, Path, PathNotFoundException, PathSyntaxException, PatternFormatter, Pipe, PipeIOS, PipeInputStream, PipeOutputStream, PipeStreamBuf, PoolOverflowException, PriorityDelegate, PriorityEvent, PriorityExpire, PriorityNotificationQueue, Process, ProcessHandle, PropertyNotSupportedException, ProtocolException, PurgeByAgeStrategy, PurgeByCountStrategy, PurgeStrategy, RWLock, Random, RandomBuf, RandomIOS, RandomInputStream, RangeException, ReadFileException, RefCountedObject, ReferenceCounter, RegularExpression, RegularExpressionException, ReleaseArrayPolicy, ReleasePolicy, RotateAtTimeStrategy, RotateByIntervalStrategy, RotateBySizeStrategy, RotateStrategy, Runnable, RunnableAdapter, RuntimeException, SHA1Engine, ScopedLock, ScopedLockWithUnlock, ScopedRWLock, ScopedReadRWLock, ScopedUnlock, ScopedWriteRWLock, Semaphore, SharedLibrary, SharedMemory, SharedPtr, SignalException, SignalHandler, SimpleFileChannel, SimpleHashTable, SingletonHolder, 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, TextConverter, TextEncoding, TextIterator, Thread, ThreadLocal, ThreadLocalStorage, ThreadPool, ThreadTarget, TimedNotificationQueue, TimeoutException, Timer, TimerCallback, Timespan, Timestamp, Timezone, Token, Tuple, TypeList, TypeListType, TypeWrapper, URI, URIRedirection, URIStreamFactory, URIStreamOpener, UTF16Encoding, UTF8, UTF8Encoding, UUID, UUIDGenerator, UnhandledException, Unicode, UnicodeConverter, UniqueAccessExpireCache, UniqueAccessExpireLRUCache, UniqueAccessExpireStrategy, UniqueExpireCache, UniqueExpireLRUCache, UniqueExpireStrategy, UnknownURISchemeException, ValidArgs, Void, WhitespaceToken, Windows1252Encoding, WindowsConsoleChannel, WriteFileException, p_less
Types: BufferedBidirectionalStreamBuf, BufferedStreamBuf, FPE, Int16, Int32, Int64, Int8, IntPtr, MemoryStreamBuf, NDC, UInt16, UInt32, UInt64, UInt8, UIntPtr, UnbufferedStreamBuf
Functions: AnyCast, RefAnyCast, UnsafeAnyCast, cat, delegate, format, hash, icompare, operator !=, operator *, operator *=, operator +, operator +=, operator -, operator -=, operator /, operator /=, operator <, operator <=, operator ==, operator >, operator >=, priorityDelegate, replace, replaceInPlace, swap, toLower, toLowerInPlace, toUpper, toUpperInPlace, translate, translateInPlace, trim, trimInPlace, trimLeft, trimLeftInPlace, trimRight, trimRightInPlace
 An AbstractCache is the interface of all caches.  
 
 Interface for Delegate and Expire
 Very similar to AbstractPriorityDelegate but having two separate files (no inheritance)
 allows one to have compile-time checks when registering an observer
 instead of run-time checks.  
 
 An AbstractEvent is the super-class of all events.  
 
 The common base class for all Instantiator instantiations.  
 
 A MetaObject stores some information
 about a C++ class.  
 
 The base class for all instantiations of
 the Observer and NObserver template classes.  
 
 Interface for PriorityDelegate and PriorityExpire.  
 
 An AbstractStrategy is the interface for all strategies.  
 
 This is the base class for all instantiations of
 the TimerCallback template.  
 
 AccessExpirationDecorator adds an expiration method to values so that they can be used
 with the UniqueAccessExpireCache  
 
 An AccessExpireCache caches entries for a fixed time period (per default 10 minutes).  
 
 An AccessExpireLRUCache combines LRU caching and time based expire caching.  
 
 An AccessExpireStrategy implements time and access based expiration of cache entries  
 
 This class is used to implement an active object
 with strictly serialized method execution.  
 
 An active method is a method that, when called, executes
 in its own thread.  
 
 Creates an ActiveResultHolder.  
 
 This class holds the result of an asynchronous method
 invocation.  
 
 This class is used by ActiveMethod.  
 
 The base class for all ActiveRunnable instantiations.  
 
 The default implementation of the StarterType 
 policy for ActiveMethod.  
 
 This template class helps to implement active objects.  
 
 An Any class represents a general type and is capable of storing any type, supporting type-safe extraction
 of the internally stored data.  
 
 A monotonic increasing number is appended to the
 log file name.  
 
 A timestamp (YYYYMMDDhhmmssiii) is appended to archived
 log files.  
 
 The ArchiveStrategy is used by FileChannel 
 to rename a rotated log file for archiving.  
 
 A channel uses a separate thread for logging.  
 
 This class implements a simple counter, which
 provides atomic operations that are safe to
 use in a multithreaded environment.  
 
 AutoPtr is a "smart" pointer for classes implementing
 reference counting based garbage collection.  
 
 An AutoReleasePool implements simple garbage collection for 
 reference-counted objects.  
 
 This istream base64-decodes all data
 read from the istream connected to it.  
 
 This streambuf base64-decodes all data read
 from the istream connected to it.  
 
 The base class for Base64Decoder.  
 
 This ostream base64-encodes all data
 written to it and forwards it to
 a connected ostream.  
 
 This streambuf base64-encodes all data written
 to it and forwards it to a connected
 ostream.  
 
 The base class for Base64Encoder.  
 
 This is an implementation of a buffered bidirectional 
 streambuf that greatly simplifies the implementation of
 custom streambufs of various kinds.  
 
 This is an implementation of a buffered streambuf
 that greatly simplifies the implementation of
 custom streambufs of various kinds.  
 
 A BasicEvent uses internally a DefaultStrategy which 
 invokes delegates in an arbitrary manner.  
 
 BasicMemoryStreamBuf is a simple implementation of a 
 stream buffer for reading and writing from a memory area.  
 
 This is an implementation of an unbuffered streambuf
 that greatly simplifies the implementation of
 custom streambufs of various kinds.  
 
 This class reads basic types in binary form into an input stream.  
 
 This class writes basic types in binary form into an output stream.  
 
 A very simple buffer class that allocates a buffer of
 a given type and size in the constructor and
 deallocates the buffer in the destructor.  
 
 The BufferAllocator used if no specific
 BufferAllocator has been specified.  
 
 This class provides some static methods that are
 used by the
 poco_assert_dbg(), poco_assert(), poco_check_ptr() 
 and poco_bugcheck() macros.  
 
 This class contains a number of static methods
 to convert between big-endian and little-endian
 integers of various sizes.  
 
 The base class for all Channel classes.  
 
 This class calculates CRC-32 or Adler-32 checksums
 for arbitrary data.  
 
 The ClassLoader loads C++ classes from shared libraries
 at runtime.  
 
 A Condition is a synchronization object used to block a thread 
 until a particular condition is met.  
 
 A simple interface that defines
 getProperty() and setProperty() methods.  
 
 A channel that writes to an ostream.  
 
 The base class for CountingInputStream and CountingOutputStream.  
 
 This stream counts all characters and lines
 going through it.  
 
 This stream counts all characters and lines
 going through it.  
 
 This stream buffer counts all characters and lines
 going through it.  
 
 This class represents an instant in time, expressed
 in years, months, days, hours, minutes, seconds
 and milliseconds based on the Gregorian calendar.  
 
 Definition of date/time formats and various
 constants used by DateTimeFormatter and DateTimeParser.  
 
 This class converts dates and times into strings, supporting a  
 variety of standard and custom formats.  
 
 This class provides a method for parsing dates and times
 from strings.  
 
 The Debugger class provides an interface to the debugger.  
 
 Default notification strategy.  
 
 The base class for DeflatingOutputStream and DeflatingInputStream.  
 
 This stream compresses all data passing through it
 using zlib's deflate algorithm.  
 
 This stream compresses all data passing through it
 using zlib's deflate algorithm.  
 
 This is the streambuf class used by DeflatingInputStream and DeflatingOutputStream.  
 
 This streambuf computes a digest of all data going
 through it.  
 
 This class is an abstract base class
 for all classes implementing a message
 digest algorithm, like MD5Engine
 and SHA1Engine.  
 
 The base class for DigestInputStream and DigestOutputStream.  
 
 This istream computes a digest of
 all the data passing through it,
 using a DigestEngine.  
 
 This ostream computes a digest of
 all the data passing through it,
 using a DigestEngine.  
 
 The DirectoryIterator class is used to enumerate
 all files in a directory.  
 
 DynamicAny allows to store data of different types and to convert between these types transparently.  
 
 Interface for a data holder used by the DynamicAny class.  
 
 Template based implementation of a DynamicAnyHolder.  
 
 A factory that creates objects by class name.  
 
 This token class is used to signal the
 end of the input stream.  
 
 This class provides access to environment variables
 and some general system information.  
 
 This is the base class for thread error handlers.  
 
 An Event is a synchronization object that
 allows one thread to signal one or more
 other threads that a certain event
 has happened.  
 
 The purpose of the EventArgs class is to be used as parameter
 when one doesn't want to send any data.  
 
 This Windows-only channel works with the Windows NT Event Log
 service.  
 
 This is the base class for all exceptions defined
 in the Poco class library.  
 
 ExpirationDecorator adds an expiration method to values so that they can be used
 with the UniqueExpireCache  
 
 Decorator for AbstractDelegate adding automatic 
 expiring of registrations to AbstractDelegates.  
 
 An ExpireCache caches entries for a fixed time period (per default 10 minutes).  
 
 An ExpireLRUCache combines LRU caching and time based expire caching.  
 
 An ExpireStrategy implements time based expiration of cache entries  
 
 A FIFOEvent uses internally a FIFOStrategy which guarantees
 that delegates are invoked in the order they were added to
 the event.  
 
 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).  
 
 A FastMutex (mutual exclusion) is similar to a Mutex.  
 
 The File class provides methods for working with a file.  
 
 A Channel that writes to a file.  
 
 The base class for FileInputStream and FileOutputStream.  
 
 An input stream for reading from a file.  
 
 An output stream for writing to a file.  
 
 A stream for reading from and writing to a file.  
 
 An implementation of the URIStreamFactory interface
 that handles file URIs.  
 
 The base class for all Formatter classes.  
 
 The FormattingChannel is a filter channel that routes
 a Message through a Formatter before passing it on
 to the destination channel.  
 
 Wraps a C style function (or a C++ static fucntion) to be used as
 a delegate  
 
 Wraps a C style function (or a C++ static fucntion) to be used as
 a priority delegate  
 
 This class implements glob-style pattern matching
 as known from Unix shells.  
 
 This class implementes the HMAC message
 authentication code algorithm, as specified
 in RFC 2104.  
 
 This class implements a map using a LinearHashTable.  
 
 This class template is used internally by HashMap.  
 
 This class template is used internally by HashMap.  
 
 This class implements a set using a LinearHashTable.  
 
 HashStatistic class bundles statistical information on the current state of a HashTable  
 
 A HashTable stores a key value pair that can be looked up via a hashed key.  
 
 This istream decodes all hexBinary-encoded data read
 from the istream connected to it.  
 
 This streambuf decodes all hexBinary-encoded data read
 from the istream connected to it.  
 
 The base class for HexBinaryDecoder.  
 
 This ostream encodes all data
 written to it in BinHex encoding and forwards it to
 a connected ostream.  
 
 This streambuf encodes all data written
 to it in hexBinary encoding and forwards it to a connected
 ostream.  
 
 The base class for HexBinaryEncoder.  
 
 The base class for InflatingOutputStream and InflatingInputStream.  
 
 This stream decompresses all data passing through it
 using zlib's inflate algorithm.  
 
 This stream decompresses all data passing through it
 using zlib's inflate algorithm.  
 
 This is the streambuf class used by InflatingInputStream and InflatingOutputStream.  
 
 InputLineEndingConverter performs line ending conversion
 on text input streams.  
 
 This stream converts all characters read from the
 underlying istream from one character encoding into another.  
 
 A template class for the easy instantiation of 
 instantiators.  
 
 This token class is used for signalling that
 an invalid character sequence has been encountered
 in the input stream.  
 
Use this struct to determine if a template type is a const type  
 
Use this struct to determine if a template type is a reference  
 
 Simply event arguments class to transfer a key and a value via an event call.  
 
 An LRUCache implements Least Recently Used caching.  
 
 An LRUStrategy implements least recently used cache replacement.  
 
 ISO Latin-1 (8859-1) text encoding.  
 
 ISO Latin-9 (8859-15) text encoding.  
 
 This class defines valid line ending sequences
 for InputLineEndingConverter and OutputLineEndingConverter.  
 
 The base class for InputLineEndingConverter and OutputLineEndingConverter.  
 
 This stream buffer performs line ending conversion
 on text streams.  
 
 This class implements a linear hash table.  
 
 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.  
 
 This class is used by FileChannel to work
 with a log file.  
 
 The base class for LogStream.  
 
 This class implements an ostream interface
 to a Logger.  
 
 This class implements a streambuf interface
 to a Logger.  
 
 Logger is a special Channel that acts as the main
 entry point into the logging framework.  
 
 An extensible factory for channels and formatters.  
 
 A registry for channels and formatters.  
 
 This class implementes the MD2 message digest algorithm,
 described in RFC 1319.  
 
 This class implementes the MD4 message digest algorithm,
 described in RFC 1320.  
 
 This class implementes the MD5 message digest algorithm,
 described in RFC 1321.  
 
 A Manifest maintains a list of all classes
 contained in a dynamically loadable class
 library.  
 
 ManifestBase is a common base class for
 all instantiations of Manifest.  
 
 The base class for MemoryInputStream and MemoryOutputStream.  
 
 An input stream for reading from a memory area.  
 
 An input stream for reading from a memory area.  
 
 A simple pool for fixed-size memory blocks.  
 
 This class represents a log message that is sent through a
 chain of log channels.  
 
 A MetaObject stores some information
 about a C++ class.  
 
 A SingletonMetaObject disables the create() method
 and instead offers an instance() method to access
 the single instance of its class.  
 
 A Mutex (mutual exclusion) is a synchronization 
 mechanism used to control access to a shared resource
 in a concurrent (multithreaded) scenario.  
 
 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.  
 
 This template class implements an adapter that sits between
 a NotificationCenter and an object receiving notifications
 from it.  
 
 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.  
 
 A NamedMutex (mutual exclusion) is a global synchronization 
 mechanism used to control access to a shared resource
 in a concurrent (multi process) scenario.  
 
 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).  
 
 The base class for all notification classes used
 with the NotificationCenter and the NotificationQueue
 classes.  
 
 A NotificationCenter is essentially a notification dispatcher.  
 
 A NotificationQueue object provides a way to implement asynchronous
 notifications.  
 
 The interface that all notification strategies must implement.  
 
 The NullChannel is the /dev/null of Channels.  
 
 The base class for NullInputStream and NullOutputStream.  
 
 Any read operation from this stream immediately
 yields EOF.  
 
 This stream discards all characters written to it.  
 
 This stream buffer discards all characters written to it.  
 
 The NumberFormatter class provides static methods
 for formatting numeric values into strings.  
 
 The NumberParser class provides static methods
 for parsing numbers out of strings.  
 
 This template class implements an adapter that sits between
 a NotificationCenter and an object receiving notifications
 from it.  
 
 A OpenVMS-only channel that uses the OpenVMS OPCOM service.  
 
 OutputLineEndingConverter performs line ending conversion
 on text output streams.  
 
 This stream converts all characters written to the
 underlying ostream from one character encoding into another.  
 
 This class represents filesystem paths in a 
 platform-independent manner.  
 
 This Formatter allows for custom formatting of
 log messages based on format patterns.  
 
 This class implements an anonymous pipe.  
 
 The base class for PipeInputStream and
 PipeOutputStream.  
 
 An input stream for reading from a Pipe.  
 
 An output stream for writing to a Pipe.  
 
 This is the streambuf class used for reading from and writing to a Pipe.  
 
 A PriorityEvent uses internally a DefaultStrategy which 
 invokes delegates in a manner determined by the priority field 
 in the PriorityDelegates (lower priorities first).  
 
 Decorator for AbstractPriorityDelegate adding automatic 
 expiring of registrations to AbstractPriorityDelegate.  
 
 A PriorityNotificationQueue object provides a way to implement asynchronous
 notifications.  
 
 This class provides methods for working with processes.  
 
 A handle for a process created with Process::launch().  
 
 This purge strategy purges all files that have
 exceeded a given age (given in seconds).  
 
 This purge strategy ensures that a maximum number
 of archived files is not exceeded.  
 
 The PurgeStrategy is used by FileChannel
 to purge archived log files.  
 
 A reader writer lock allows multiple concurrent
 readers or one exclusive writer.  
 
 A better random number generator.  
 
 This streambuf generates random data.  
 
 The base class for RandomInputStream.  
 
 This istream generates random data
 using the RandomBuf.  
 
 A base class for objects that employ
 reference counting based garbage collection.  
 
 Simple ReferenceCounter object, does not delete itself when count reaches 0.  
 
 A class for working with regular expressions.  
 
 The release policy for SharedPtr holding arrays.  
 
 The default release policy for SharedPtr, which
 simply uses the delete operator to delete an object.  
 
 The file is rotated at specified [day,][hour]:minute  
 
 The file is rotated when the log file 
 exceeds a given age.  
 
 The file is rotated when the log file
 exceeds a given size.  
 
 The RotateStrategy is used by LogFile to determine when
 a file must be rotated.  
 
 The Runnable interface with the run() method
 must be implemented by classes that provide
 an entry point for a thread.  
 
 This adapter simplifies using ordinary methods as
 targets for threads.  
 
 This class implementes the SHA-1 message digest algorithm.  
 
 A class that simplifies thread synchronization
 with a mutex.  
 
 A class that simplifies thread synchronization
 with a mutex.  
 
 A variant of ScopedLock for reader/writer locks.  
 
 A variant of ScopedLock for reader locks.  
 
 A class that simplifies thread synchronization
 with a mutex.  
 
 A variant of ScopedLock for writer locks.  
 
 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.  
 
 The SharedLibrary class dynamically 
 loads shared libraries at run-time.  
 
 Create and manage a shared memory object.  
 
 SharedPtr is a "smart" pointer for classes implementing
 reference counting based garbage collection.  
 
 This helper class simplifies the handling of POSIX signals.  
 
 A Channel that writes to a file.  
 
 A SimpleHashTable stores a key value pair that can be looked up via a hashed key.  
 
 This is a helper template class for managing
 singleton objects allocated on the heap.  
 
 This channel sends a message to multiple
 channels simultaneously.  
 
 A simple facility to measure time intervals
 with microsecond resolution.  
 
 An StrategyCollection is a decorator masking n collections as a single one  
 
 A channel that writes to an ostream.  
 
 A StreamConverter converts streams from one encoding (inEncoding)
 into another (outEncoding).  
 
 The base class for InputStreamConverter and OutputStreamConverter.  
 
 This class provides static methods to copy the contents from one stream
 into another.  
 
 A stream tokenizer splits an input stream
 into a sequence of tokens of different kinds.  
 
 A simple tokenizer that splits a string into
 tokens, which are separated by separator characters.  
 
 This class aggregates a Mutex and an Event
 and can act as a base class for all objects
 requiring synchronization in a multithreaded
 scenario.  
 
 This Unix-only channel works with the Unix syslog service.  
 
 This is the base class for all objects
 that the ThreadLocalStorage class manages.  
 
 The Slot template wraps another class
 so that it can be stored in a ThreadLocalStorage
 object.  
 
 A Task is a subclass of Runnable that has a name 
 and supports progress reporting and cancellation.  
 
 This notification is posted by the TaskManager for
 every task that has been cancelled.  
 
 This is a template for "custom" notification.  
 
 This notification is posted by the TaskManager for
 every task that has failed with an exception.  
 
 This notification is posted by the TaskManager for
 every task that has finished.  
 
 The TaskManager manages a collection of tasks
 and monitors their lifetime.  
 
 Base class for TaskManager notifications.  
 
 This notification is posted by the TaskManager for
 every task that has failed with an exception.  
 
 This notification is posted by the TaskManager for
 every task that has been started.  
 
 The base class for TeeInputStream and TeeOutputStream.  
 
 This stream copies all characters read through it
 to one or multiple output streams.  
 
 This stream copies all characters written to it
 to one or multiple output streams.  
 
 This stream buffer copies all data written to or
 read from it to one or multiple output streams.  
 
 The TemporaryFile class helps with the handling
 of temporary files.  
 
 A TextConverter converts strings from one encoding
 into another.  
 
 An abstract base class for implementing text encodings
 like UTF-8 or ISO 8859-1.  
 
 An unidirectional iterator for iterating over characters in a string.  
 
 This class implements a platform-independent
 wrapper to an operating system thread.  
 
 This template is used to declare type safe thread
 local variables.  
 
 This class manages the local storage for each thread.  
 
 A thread pool always keeps a number of threads running, ready
 to accept work.  
 
 This adapter simplifies using static member functions as well as 
 standalone functions as targets for threads.  
 
 A TimedNotificationQueue object provides a way to implement timed, asynchronous
 notifications.  
 
 This class implements a thread-based timer.  
 
 This template class implements an adapter that sits between
 a Timer and an object's method invoked by the timer.  
 
 A class that represents time spans up to microsecond resolution.  
 
 A Timestamp stores a monotonic* time value
 with (theoretical) microseconds resolution.  
 
 This class provides information about the current timezone.  
 
 The base class for all token classes that can be
 registered with the StreamTokenizer.  
 
 TypeListType takes 1 - 20 typename arguments.  
 
 Use the type wrapper if you want to dedecouple constness and references from template types  
 
 A Uniform Resource Identifier, as specified in RFC 3986.  
 
 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).  
 
 This class defines the interface that all
 URI stream factories must implement.  
 
 The URIStreamOpener class is used to create and open input streams
 for resourced identified by Uniform Resource Identifiers.  
 
 UTF-16 text encoding, as defined in RFC 2781.  
 
 This class provides static methods that are UTF-8 capable variants
 of the same functions in Poco/String.  
 
 UTF-8 text encoding, as defined in RFC 2279.  
 
 A UUID is an identifier that is unique across both space and time,
 with respect to the space of all UUIDs.  
 
 This class implements a generator for Universal Unique Identifiers,
 as specified in Appendix A of the DCE 1.  
 
 This class contains enumerations and static
 utility functions for dealing with Unicode characters
 and their properties.  
 
 A convenience class that converts strings from
 UTF-8 encoded std::strings to UTF-16 encoded std::wstrings 
 and vice-versa.  
 
 An UniqueAccessExpireCache caches entries for a given time span.  
 
 A UniqueAccessExpireLRUCache combines LRU caching and time based per entry expire caching.  
 
 An UniqueExpireStrategy implements time based expiration of cache entries.  
 
 An UniqueExpireCache caches entries for a given time amount.  
 
 A UniqueExpireLRUCache combines LRU caching and time based per entry expire caching.  
 
 An UniqueExpireStrategy implements time based expiration of cache entries.  
 
 A dummy class with value-type semantics, 
 mostly useful as a template argument.  
 
 This pseudo token class is used to eat
 up whitespace in between real tokens.  
 
 Windows Codepage 1252 text encoding.  
 
 A channel that writes to the Windows console.  
 
typedef BasicBufferedBidirectionalStreamBuf < char, std::char_traits < char > > BufferedBidirectionalStreamBuf;
typedef BasicBufferedStreamBuf < char, std::char_traits < char > > BufferedStreamBuf;
typedef FPEnvironment FPE;
typedef signed short Int16;
typedef signed int Int32;
typedef signed long long Int64;
typedef signed char Int8;
typedef signed long IntPtr;
typedef BasicMemoryStreamBuf < char, std::char_traits < char > > MemoryStreamBuf;
typedef NestedDiagnosticContext NDC;
typedef unsigned short UInt16;
typedef unsigned int UInt32;
typedef unsigned long long UInt64;
typedef unsigned char UInt8;
typedef unsigned long UIntPtr;
typedef BasicUnbufferedStreamBuf < char, std::char_traits < char > > UnbufferedStreamBuf;
 
 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(
    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 > 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 > 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 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 < class TObj, class TArgs > static Delegate < TObj, TArgs, true > delegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(const void *, TArgs &) param73
);
 
   
 template < class TObj, class TArgs > static Delegate < TObj, TArgs, false > delegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(TArgs &) param74
);
 
   
 template < class TObj, class TArgs > static Expire < TArgs > delegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(const void *, TArgs &) param75,
    Timestamp::TimeDiff expireMillisecs
);
 
   
 template < class TObj, class TArgs > static Expire < TArgs > delegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(TArgs &) param76,
    Timestamp::TimeDiff expireMillisecs
);
 
   
 template < class TArgs > static Expire < TArgs > delegate(
    void (* NotifyMethod)(const void *, TArgs &) param77,
    Timestamp::TimeDiff expireMillisecs
);
 
   
 template < class TArgs > static Expire < TArgs > delegate(
    void (* NotifyMethod)(void *, TArgs &) param78,
    Timestamp::TimeDiff expireMillisecs
);
 
   
 template < class TArgs > static Expire < TArgs > delegate(
    void (* NotifyMethod)(TArgs &) param79,
    Timestamp::TimeDiff expireMillisecs
);
 
   
 template < class TArgs > static FunctionDelegate < TArgs, true, true > delegate(
    void (* NotifyMethod)(const void *, TArgs &) param80
);
 
   
 template < class TArgs > static FunctionDelegate < TArgs, true, false > delegate(
    void (* NotifyMethod)(void *, TArgs &) param81
);
 
   
 template < class TArgs > static FunctionDelegate < TArgs, false > delegate(
    void (* NotifyMethod)(TArgs &) param82
);
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:
%[<flags>][<width>][.<precision>][<modifier>]<type>
Flags, width, precision and prefix are optional. The only required part of the format specification, apart from the percent sign, is the type.
Following are valid type specifications and their meaning:
The following flags are supported:
The following modifiers are supported:
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 a BadCastException if an argument does not correspond to the type of its format specification.
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 Example:
std::string s = format("The answer to life, the universe, and everything is %d", 42);
std::string format(
    const std::string & fmt,
    const Any & value1,
    const Any & value2
);
std::string format(
    const std::string & fmt,
    const Any & value1,
    const Any & value2,
    const Any & value3
);
std::string format(
    const std::string & fmt,
    const Any & value1,
    const Any & value2,
    const Any & value3,
    const Any & value4
);
std::string format(
    const std::string & fmt,
    const Any & value1,
    const Any & value2,
    const Any & value3,
    const Any & value4,
    const Any & value5
);
std::string format(
    const std::string & fmt,
    const Any & value1,
    const Any & value2,
    const Any & value3,
    const Any & value4,
    const Any & value5,
    const Any & value6
);
void format(
    std::string & result,
    const std::string & fmt,
    const Any & value
);
Appends the formatted string to result.
void format(
    std::string & result,
    const std::string & fmt,
    const Any & value1,
    const Any & value2
);
void format(
    std::string & result,
    const std::string & fmt,
    const Any & value1,
    const Any & value2,
    const Any & value3
);
void format(
    std::string & result,
    const std::string & fmt,
    const Any & value1,
    const Any & value2,
    const Any & value3,
    const Any & value4
);
void format(
    std::string & result,
    const std::string & fmt,
    const Any & value1,
    const Any & value2,
    const Any & value3,
    const Any & value4,
    const Any & value5
);
void 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 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().
std::size_t hash(
    Int8 n
);
std::size_t hash(
    UInt8 n
);
std::size_t hash(
    Int16 n
);
std::size_t hash(
    UInt16 n
);
std::size_t hash(
    Int32 n
);
std::size_t hash(
    UInt32 n
);
std::size_t hash(
    Int64 n
);
std::size_t hash(
    UInt64 n
);
std::size_t hash(
    const std::string & str
);
 
 inline std::size_t hash(
    Int8 n
);
 
 inline std::size_t hash(
    UInt8 n
);
 
 inline std::size_t hash(
    Int16 n
);
 
 inline std::size_t hash(
    UInt16 n
);
 
 inline std::size_t hash(
    Int32 n
);
 
 inline std::size_t hash(
    UInt32 n
);
 
 inline std::size_t hash(
    Int64 n
);
 
 inline std::size_t hash(
    UInt64 n
);
 
 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
 
 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
);
 
 inline bool operator != (
    const char & other,
    const DynamicAny & da
);
Inequality operator for comparing DynamicAny with char
 
 inline bool operator != (
    const Poco::Int8 & other,
    const DynamicAny & da
);
Inequality operator for comparing DynamicAny with Poco::Int8
 
 inline bool operator != (
    const Poco::UInt8 & other,
    const DynamicAny & da
);
Inequality operator for comparing DynamicAny with Poco::UInt8
 
 inline bool operator != (
    const Poco::Int16 & other,
    const DynamicAny & da
);
Inequality operator for comparing DynamicAny with Poco::Int16
 
 inline bool operator != (
    const Poco::UInt16 & other,
    const DynamicAny & da
);
Inequality operator for comparing DynamicAny with Poco::UInt16
 
 inline bool operator != (
    const Poco::Int32 & other,
    const DynamicAny & da
);
Inequality operator for comparing DynamicAny with Poco::Int32
 
 inline bool operator != (
    const Poco::UInt32 & other,
    const DynamicAny & da
);
Inequality operator for comparing DynamicAny with Poco::UInt32
 
 inline bool operator != (
    const Poco::Int64 & other,
    const DynamicAny & da
);
Inequality operator for comparing DynamicAny with Poco::Int64
 
 inline bool operator != (
    const Poco::UInt64 & other,
    const DynamicAny & da
);
Inequality operator for comparing DynamicAny with Poco::UInt64
 
 inline bool operator != (
    const float & other,
    const DynamicAny & da
);
Inequality operator for comparing DynamicAny with float
 
 inline bool operator != (
    const double & other,
    const DynamicAny & da
);
Inequality operator for comparing DynamicAny with double
 
 inline bool operator != (
    const bool & other,
    const DynamicAny & da
);
Inequality operator for comparing DynamicAny with bool
 
 inline bool operator != (
    const std::string & other,
    const DynamicAny & da
);
Inequality operator for comparing DynamicAny with std::string
 
 inline bool operator != (
    const char * other,
    const DynamicAny & da
);
Inequality operator for comparing DynamicAny with const char*
 
 inline bool operator != (
    const long & other,
    const DynamicAny & da
);
Inequality operator for comparing DynamicAny with long
 
 inline char operator * (
    const char & other,
    const DynamicAny & da
);
Multiplication operator for multiplying DynamicAny with char
 
 inline Poco::Int8 operator * (
    const Poco::Int8 & other,
    const DynamicAny & da
);
Multiplication operator for multiplying DynamicAny with Poco::Int8
 
 inline Poco::UInt8 operator * (
    const Poco::UInt8 & other,
    const DynamicAny & da
);
Multiplication operator for multiplying DynamicAny with Poco::UInt8
 
 inline Poco::Int16 operator * (
    const Poco::Int16 & other,
    const DynamicAny & da
);
Multiplication operator for multiplying DynamicAny with Poco::Int16
 
 inline Poco::UInt16 operator * (
    const Poco::UInt16 & other,
    const DynamicAny & da
);
Multiplication operator for multiplying DynamicAny with Poco::UInt16
 
 inline Poco::Int32 operator * (
    const Poco::Int32 & other,
    const DynamicAny & da
);
Multiplication operator for multiplying DynamicAny with Poco::Int32
 
 inline Poco::UInt32 operator * (
    const Poco::UInt32 & other,
    const DynamicAny & da
);
Multiplication operator for multiplying DynamicAny with Poco::UInt32
 
 inline Poco::Int64 operator * (
    const Poco::Int64 & other,
    const DynamicAny & da
);
Multiplication operator for multiplying DynamicAny with Poco::Int64
 
 inline Poco::UInt64 operator * (
    const Poco::UInt64 & other,
    const DynamicAny & da
);
Multiplication operator for multiplying DynamicAny with Poco::UInt64
 
 inline float operator * (
    const float & other,
    const DynamicAny & da
);
Multiplication operator for multiplying DynamicAny with float
 
 inline double operator * (
    const double & other,
    const DynamicAny & da
);
Multiplication operator for multiplying DynamicAny with double
 
 inline long operator * (
    const long & other,
    const DynamicAny & da
);
Multiplication operator for multiplying DynamicAny with long
 
 inline char operator *= (
    char & other,
    const DynamicAny & da
);
Multiplication assignment operator for multiplying DynamicAny with char
 
 inline Poco::Int8 operator *= (
    Poco::Int8 & other,
    const DynamicAny & da
);
Multiplication assignment operator for multiplying DynamicAny with Poco::Int8
 
 inline Poco::UInt8 operator *= (
    Poco::UInt8 & other,
    const DynamicAny & da
);
Multiplication assignment operator for multiplying DynamicAny with Poco::UInt8
 
 inline Poco::Int16 operator *= (
    Poco::Int16 & other,
    const DynamicAny & da
);
Multiplication assignment operator for multiplying DynamicAny with Poco::Int16
 
 inline Poco::UInt16 operator *= (
    Poco::UInt16 & other,
    const DynamicAny & da
);
Multiplication assignment operator for multiplying DynamicAny with Poco::UInt16
 
 inline Poco::Int32 operator *= (
    Poco::Int32 & other,
    const DynamicAny & da
);
Multiplication assignment operator for multiplying DynamicAny with Poco::Int32
 
 inline Poco::UInt32 operator *= (
    Poco::UInt32 & other,
    const DynamicAny & da
);
Multiplication assignment operator for multiplying DynamicAny with Poco::UInt32
 
 inline Poco::Int64 operator *= (
    Poco::Int64 & other,
    const DynamicAny & da
);
Multiplication assignment operator for multiplying DynamicAny with Poco::Int64
 
 inline Poco::UInt64 operator *= (
    Poco::UInt64 & other,
    const DynamicAny & da
);
Multiplication assignment operator for multiplying DynamicAny with Poco::UInt64
 
 inline float operator *= (
    float & other,
    const DynamicAny & da
);
Multiplication assignment operator for multiplying DynamicAny with float
 
 inline double operator *= (
    double & other,
    const DynamicAny & da
);
Multiplication assignment operator for multiplying DynamicAny with double
 
 inline long operator *= (
    long & other,
    const DynamicAny & da
);
Multiplication assignment operator for multiplying DynamicAny with long
 
 inline const DynamicAny operator + (
    const char * other,
    const DynamicAny & da
);
inlines
DynamicAny members
DynamicAny non-member functions
Addition operator for adding DynamicAny to const char*
 
 inline char operator + (
    const char & other,
    const DynamicAny & da
);
Addition operator for adding DynamicAny to char
 
 inline Poco::Int8 operator + (
    const Poco::Int8 & other,
    const DynamicAny & da
);
Addition operator for adding DynamicAny to Poco::Int8
 
 inline Poco::UInt8 operator + (
    const Poco::UInt8 & other,
    const DynamicAny & da
);
Addition operator for adding DynamicAny to Poco::UInt8
 
 inline Poco::Int16 operator + (
    const Poco::Int16 & other,
    const DynamicAny & da
);
Addition operator for adding DynamicAny to Poco::Int16
 
 inline Poco::UInt16 operator + (
    const Poco::UInt16 & other,
    const DynamicAny & da
);
Addition operator for adding DynamicAny to Poco::UInt16
 
 inline Poco::Int32 operator + (
    const Poco::Int32 & other,
    const DynamicAny & da
);
Addition operator for adding DynamicAny to Poco::Int32
 
 inline Poco::UInt32 operator + (
    const Poco::UInt32 & other,
    const DynamicAny & da
);
Addition operator for adding DynamicAny to Poco::UInt32
 
 inline Poco::Int64 operator + (
    const Poco::Int64 & other,
    const DynamicAny & da
);
Addition operator for adding DynamicAny to Poco::Int64
 
 inline Poco::UInt64 operator + (
    const Poco::UInt64 & other,
    const DynamicAny & da
);
Addition operator for adding DynamicAny to Poco::UInt64
 
 inline float operator + (
    const float & other,
    const DynamicAny & da
);
Addition operator for adding DynamicAny to float
 
 inline double operator + (
    const double & other,
    const DynamicAny & da
);
Addition operator for adding DynamicAny to double
 
 inline long operator + (
    const long & other,
    const DynamicAny & da
);
Addition operator for adding DynamicAny to long
 
 inline char operator += (
    char & other,
    const DynamicAny & da
);
Addition assignment operator for adding DynamicAny to char
 
 inline Poco::Int8 operator += (
    Poco::Int8 & other,
    const DynamicAny & da
);
Addition assignment operator for adding DynamicAny to Poco::Int8
 
 inline Poco::UInt8 operator += (
    Poco::UInt8 & other,
    const DynamicAny & da
);
Addition assignment operator for adding DynamicAny to Poco::UInt8
 
 inline Poco::Int16 operator += (
    Poco::Int16 & other,
    const DynamicAny & da
);
Addition assignment operator for adding DynamicAny to Poco::Int16
 
 inline Poco::UInt16 operator += (
    Poco::UInt16 & other,
    const DynamicAny & da
);
Addition assignment operator for adding DynamicAny to Poco::UInt16
 
 inline Poco::Int32 operator += (
    Poco::Int32 & other,
    const DynamicAny & da
);
Addition assignment operator for adding DynamicAny to Poco::Int32
 
 inline Poco::UInt32 operator += (
    Poco::UInt32 & other,
    const DynamicAny & da
);
Addition assignment operator for adding DynamicAny to Poco::UInt32
 
 inline Poco::Int64 operator += (
    Poco::Int64 & other,
    const DynamicAny & da
);
Addition assignment operator for adding DynamicAny to Poco::Int64
 
 inline Poco::UInt64 operator += (
    Poco::UInt64 & other,
    const DynamicAny & da
);
Addition assignment operator for adding DynamicAny to Poco::UInt64
 
 inline float operator += (
    float & other,
    const DynamicAny & da
);
Addition assignment operator for adding DynamicAny to float
 
 inline double operator += (
    double & other,
    const DynamicAny & da
);
Addition assignment operator for adding DynamicAny to double
 
 inline long operator += (
    long & other,
    const DynamicAny & da
);
Addition assignment operator for adding DynamicAny to long
 
 inline char operator - (
    const char & other,
    const DynamicAny & da
);
Subtraction operator for subtracting DynamicAny from char
 
 inline Poco::Int8 operator - (
    const Poco::Int8 & other,
    const DynamicAny & da
);
Subtraction operator for subtracting DynamicAny from Poco::Int8
 
 inline Poco::UInt8 operator - (
    const Poco::UInt8 & other,
    const DynamicAny & da
);
Subtraction operator for subtracting DynamicAny from Poco::UInt8
 
 inline Poco::Int16 operator - (
    const Poco::Int16 & other,
    const DynamicAny & da
);
Subtraction operator for subtracting DynamicAny from Poco::Int16
 
 inline Poco::UInt16 operator - (
    const Poco::UInt16 & other,
    const DynamicAny & da
);
Subtraction operator for subtracting DynamicAny from Poco::UInt16
 
 inline Poco::Int32 operator - (
    const Poco::Int32 & other,
    const DynamicAny & da
);
Subtraction operator for subtracting DynamicAny from Poco::Int32
 
 inline Poco::UInt32 operator - (
    const Poco::UInt32 & other,
    const DynamicAny & da
);
Subtraction operator for subtracting DynamicAny from Poco::UInt32
 
 inline Poco::Int64 operator - (
    const Poco::Int64 & other,
    const DynamicAny & da
);
Subtraction operator for subtracting DynamicAny from Poco::Int64
 
 inline Poco::UInt64 operator - (
    const Poco::UInt64 & other,
    const DynamicAny & da
);
Subtraction operator for subtracting DynamicAny from Poco::UInt64
 
 inline float operator - (
    const float & other,
    const DynamicAny & da
);
Subtraction operator for subtracting DynamicAny from float
 
 inline double operator - (
    const double & other,
    const DynamicAny & da
);
Subtraction operator for subtracting DynamicAny from double
 
 inline long operator - (
    const long & other,
    const DynamicAny & da
);
Subtraction operator for subtracting DynamicAny from long
 
 inline char operator -= (
    char & other,
    const DynamicAny & da
);
Subtraction assignment operator for subtracting DynamicAny from char
 
 inline Poco::Int8 operator -= (
    Poco::Int8 & other,
    const DynamicAny & da
);
Subtraction assignment operator for subtracting DynamicAny from Poco::Int8
 
 inline Poco::UInt8 operator -= (
    Poco::UInt8 & other,
    const DynamicAny & da
);
Subtraction assignment operator for subtracting DynamicAny from Poco::UInt8
 
 inline Poco::Int16 operator -= (
    Poco::Int16 & other,
    const DynamicAny & da
);
Subtraction assignment operator for subtracting DynamicAny from Poco::Int16
 
 inline Poco::UInt16 operator -= (
    Poco::UInt16 & other,
    const DynamicAny & da
);
Subtraction assignment operator for subtracting DynamicAny from Poco::UInt16
 
 inline Poco::Int32 operator -= (
    Poco::Int32 & other,
    const DynamicAny & da
);
Subtraction assignment operator for subtracting DynamicAny from Poco::Int32
 
 inline Poco::UInt32 operator -= (
    Poco::UInt32 & other,
    const DynamicAny & da
);
Subtraction assignment operator for subtracting DynamicAny from Poco::UInt32
 
 inline Poco::Int64 operator -= (
    Poco::Int64 & other,
    const DynamicAny & da
);
Subtraction assignment operator for subtracting DynamicAny from Poco::Int64
 
 inline Poco::UInt64 operator -= (
    Poco::UInt64 & other,
    const DynamicAny & da
);
Subtraction assignment operator for subtracting DynamicAny from Poco::UInt64
 
 inline float operator -= (
    float & other,
    const DynamicAny & da
);
Subtraction assignment operator for subtracting DynamicAny from float
 
 inline double operator -= (
    double & other,
    const DynamicAny & da
);
Subtraction assignment operator for subtracting DynamicAny from double
 
 inline long operator -= (
    long & other,
    const DynamicAny & da
);
Subtraction assignment operator for subtracting DynamicAny from long
 
 inline char operator / (
    const char & other,
    const DynamicAny & da
);
Division operator for dividing DynamicAny with char
 
 inline Poco::Int8 operator / (
    const Poco::Int8 & other,
    const DynamicAny & da
);
Division operator for dividing DynamicAny with Poco::Int8
 
 inline Poco::UInt8 operator / (
    const Poco::UInt8 & other,
    const DynamicAny & da
);
Division operator for dividing DynamicAny with Poco::UInt8
 
 inline Poco::Int16 operator / (
    const Poco::Int16 & other,
    const DynamicAny & da
);
Division operator for dividing DynamicAny with Poco::Int16
 
 inline Poco::UInt16 operator / (
    const Poco::UInt16 & other,
    const DynamicAny & da
);
Division operator for dividing DynamicAny with Poco::UInt16
 
 inline Poco::Int32 operator / (
    const Poco::Int32 & other,
    const DynamicAny & da
);
Division operator for dividing DynamicAny with Poco::Int32
 
 inline Poco::UInt32 operator / (
    const Poco::UInt32 & other,
    const DynamicAny & da
);
Division operator for dividing DynamicAny with Poco::UInt32
 
 inline Poco::Int64 operator / (
    const Poco::Int64 & other,
    const DynamicAny & da
);
Division operator for dividing DynamicAny with Poco::Int64
 
 inline Poco::UInt64 operator / (
    const Poco::UInt64 & other,
    const DynamicAny & da
);
Division operator for dividing DynamicAny with Poco::UInt64
 
 inline float operator / (
    const float & other,
    const DynamicAny & da
);
Division operator for dividing DynamicAny with float
 
 inline double operator / (
    const double & other,
    const DynamicAny & da
);
Division operator for dividing DynamicAny with double
 
 inline long operator / (
    const long & other,
    const DynamicAny & da
);
Division operator for dividing DynamicAny with long
 
 inline char operator /= (
    char & other,
    const DynamicAny & da
);
Division assignment operator for dividing DynamicAny with char
 
 inline Poco::Int8 operator /= (
    Poco::Int8 & other,
    const DynamicAny & da
);
Division assignment operator for dividing DynamicAny with Poco::Int8
 
 inline Poco::UInt8 operator /= (
    Poco::UInt8 & other,
    const DynamicAny & da
);
Division assignment operator for dividing DynamicAny with Poco::UInt8
 
 inline Poco::Int16 operator /= (
    Poco::Int16 & other,
    const DynamicAny & da
);
Division assignment operator for dividing DynamicAny with Poco::Int16
 
 inline Poco::UInt16 operator /= (
    Poco::UInt16 & other,
    const DynamicAny & da
);
Division assignment operator for dividing DynamicAny with Poco::UInt16
 
 inline Poco::Int32 operator /= (
    Poco::Int32 & other,
    const DynamicAny & da
);
Division assignment operator for dividing DynamicAny with Poco::Int32
 
 inline Poco::UInt32 operator /= (
    Poco::UInt32 & other,
    const DynamicAny & da
);
Division assignment operator for dividing DynamicAny with Poco::UInt32
 
 inline Poco::Int64 operator /= (
    Poco::Int64 & other,
    const DynamicAny & da
);
Division assignment operator for dividing DynamicAny with Poco::Int64
 
 inline Poco::UInt64 operator /= (
    Poco::UInt64 & other,
    const DynamicAny & da
);
Division assignment operator for dividing DynamicAny with Poco::UInt64
 
 inline float operator /= (
    float & other,
    const DynamicAny & da
);
Division assignment operator for dividing DynamicAny with float
 
 inline double operator /= (
    double & other,
    const DynamicAny & da
);
Division assignment operator for dividing DynamicAny with double
 
 inline long operator /= (
    long & other,
    const DynamicAny & da
);
Division assignment operator for dividing DynamicAny with long
 
 inline bool operator < (
    const char & other,
    const DynamicAny & da
);
Less than operator for comparing DynamicAny with char
 
 inline bool operator < (
    const Poco::Int8 & other,
    const DynamicAny & da
);
Less than operator for comparing DynamicAny with Poco::Int8
 
 inline bool operator < (
    const Poco::UInt8 & other,
    const DynamicAny & da
);
Less than operator for comparing DynamicAny with Poco::UInt8
 
 inline bool operator < (
    const Poco::Int16 & other,
    const DynamicAny & da
);
Less than operator for comparing DynamicAny with Poco::Int16
 
 inline bool operator < (
    const Poco::UInt16 & other,
    const DynamicAny & da
);
Less than operator for comparing DynamicAny with Poco::UInt16
 
 inline bool operator < (
    const Poco::Int32 & other,
    const DynamicAny & da
);
Less than operator for comparing DynamicAny with Poco::Int32
 
 inline bool operator < (
    const Poco::UInt32 & other,
    const DynamicAny & da
);
Less than operator for comparing DynamicAny with Poco::UInt32
 
 inline bool operator < (
    const Poco::Int64 & other,
    const DynamicAny & da
);
Less than operator for comparing DynamicAny with Poco::Int64
 
 inline bool operator < (
    const Poco::UInt64 & other,
    const DynamicAny & da
);
Less than operator for comparing DynamicAny with Poco::UInt64
 
 inline bool operator < (
    const float & other,
    const DynamicAny & da
);
Less than operator for comparing DynamicAny with float
 
 inline bool operator < (
    const double & other,
    const DynamicAny & da
);
Less than operator for comparing DynamicAny with double
 
 inline bool operator < (
    const long & other,
    const DynamicAny & da
);
Less than operator for comparing DynamicAny with long
 
 inline bool operator <= (
    const char & other,
    const DynamicAny & da
);
Less than or equal operator for comparing DynamicAny with char
 
 inline bool operator <= (
    const Poco::Int8 & other,
    const DynamicAny & da
);
Less than or equal operator for comparing DynamicAny with Poco::Int8
 
 inline bool operator <= (
    const Poco::UInt8 & other,
    const DynamicAny & da
);
Less than or equal operator for comparing DynamicAny with Poco::UInt8
 
 inline bool operator <= (
    const Poco::Int16 & other,
    const DynamicAny & da
);
Less than or equal operator for comparing DynamicAny with Poco::Int16
 
 inline bool operator <= (
    const Poco::UInt16 & other,
    const DynamicAny & da
);
Less than or equal operator for comparing DynamicAny with Poco::UInt16
 
 inline bool operator <= (
    const Poco::Int32 & other,
    const DynamicAny & da
);
Less than or equal operator for comparing DynamicAny with Poco::Int32
 
 inline bool operator <= (
    const Poco::UInt32 & other,
    const DynamicAny & da
);
Less than or equal operator for comparing DynamicAny with Poco::UInt32
 
 inline bool operator <= (
    const Poco::Int64 & other,
    const DynamicAny & da
);
Less than or equal operator for comparing DynamicAny with Poco::Int64
 
 inline bool operator <= (
    const Poco::UInt64 & other,
    const DynamicAny & da
);
Less than or equal operator for comparing DynamicAny with Poco::UInt64
 
 inline bool operator <= (
    const float & other,
    const DynamicAny & da
);
Less than or equal operator for comparing DynamicAny with float
 
 inline bool operator <= (
    const double & other,
    const DynamicAny & da
);
Less than or equal operator for comparing DynamicAny with double
 
 inline bool operator <= (
    const long & other,
    const DynamicAny & da
);
Less than or equal operator for comparing DynamicAny with long
 
 inline bool operator == (
    const char & other,
    const DynamicAny & da
);
Equality operator for comparing DynamicAny with char
 
 inline bool operator == (
    const Poco::Int8 & other,
    const DynamicAny & da
);
Equality operator for comparing DynamicAny with Poco::Int8
 
 inline bool operator == (
    const Poco::UInt8 & other,
    const DynamicAny & da
);
Equality operator for comparing DynamicAny with Poco::UInt8
 
 inline bool operator == (
    const Poco::Int16 & other,
    const DynamicAny & da
);
Equality operator for comparing DynamicAny with Poco::Int16
 
 inline bool operator == (
    const Poco::UInt16 & other,
    const DynamicAny & da
);
Equality operator for comparing DynamicAny with Poco::UInt16
 
 inline bool operator == (
    const Poco::Int32 & other,
    const DynamicAny & da
);
Equality operator for comparing DynamicAny with Poco::Int32
 
 inline bool operator == (
    const Poco::UInt32 & other,
    const DynamicAny & da
);
Equality operator for comparing DynamicAny with Poco::UInt32
 
 inline bool operator == (
    const Poco::Int64 & other,
    const DynamicAny & da
);
Equality operator for comparing DynamicAny with Poco::Int64
 
 inline bool operator == (
    const Poco::UInt64 & other,
    const DynamicAny & da
);
Equality operator for comparing DynamicAny with Poco::UInt64
 
 inline bool operator == (
    const float & other,
    const DynamicAny & da
);
Equality operator for comparing DynamicAny with float
 
 inline bool operator == (
    const double & other,
    const DynamicAny & da
);
Equality operator for comparing DynamicAny with double
 
 inline bool operator == (
    const bool & other,
    const DynamicAny & da
);
Equality operator for comparing DynamicAny with bool
 
 inline bool operator == (
    const std::string & other,
    const DynamicAny & da
);
Equality operator for comparing DynamicAny with std::string
 
 inline bool operator == (
    const char * other,
    const DynamicAny & da
);
Equality operator for comparing DynamicAny with const char*
 
 inline bool operator == (
    const long & other,
    const DynamicAny & da
);
Equality operator for comparing DynamicAny with long
 
 inline bool operator > (
    const char & other,
    const DynamicAny & da
);
Greater than operator for comparing DynamicAny with char
 
 inline bool operator > (
    const Poco::Int8 & other,
    const DynamicAny & da
);
Greater than operator for comparing DynamicAny with Poco::Int8
 
 inline bool operator > (
    const Poco::UInt8 & other,
    const DynamicAny & da
);
Greater than operator for comparing DynamicAny with Poco::UInt8
 
 inline bool operator > (
    const Poco::Int16 & other,
    const DynamicAny & da
);
Greater than operator for comparing DynamicAny with Poco::Int16
 
 inline bool operator > (
    const Poco::UInt16 & other,
    const DynamicAny & da
);
Greater than operator for comparing DynamicAny with Poco::UInt16
 
 inline bool operator > (
    const Poco::Int32 & other,
    const DynamicAny & da
);
Greater than operator for comparing DynamicAny with Poco::Int32
 
 inline bool operator > (
    const Poco::UInt32 & other,
    const DynamicAny & da
);
Greater than operator for comparing DynamicAny with Poco::UInt32
 
 inline bool operator > (
    const Poco::Int64 & other,
    const DynamicAny & da
);
Greater than operator for comparing DynamicAny with Poco::Int64
 
 inline bool operator > (
    const Poco::UInt64 & other,
    const DynamicAny & da
);
Greater than operator for comparing DynamicAny with Poco::UInt64
 
 inline bool operator > (
    const float & other,
    const DynamicAny & da
);
Greater than operator for comparing DynamicAny with float
 
 inline bool operator > (
    const double & other,
    const DynamicAny & da
);
Greater than operator for comparing DynamicAny with double
 
 inline bool operator > (
    const long & other,
    const DynamicAny & da
);
Greater than operator for comparing DynamicAny with long
 
 inline bool operator >= (
    const char & other,
    const DynamicAny & da
);
Greater than or equal operator for comparing DynamicAny with char
 
 inline bool operator >= (
    const Poco::Int8 & other,
    const DynamicAny & da
);
Greater than or equal operator for comparing DynamicAny with Poco::Int8
 
 inline bool operator >= (
    const Poco::UInt8 & other,
    const DynamicAny & da
);
Greater than or equal operator for comparing DynamicAny with Poco::UInt8
 
 inline bool operator >= (
    const Poco::Int16 & other,
    const DynamicAny & da
);
Greater than or equal operator for comparing DynamicAny with Poco::Int16
 
 inline bool operator >= (
    const Poco::UInt16 & other,
    const DynamicAny & da
);
Greater than or equal operator for comparing DynamicAny with Poco::UInt16
 
 inline bool operator >= (
    const Poco::Int32 & other,
    const DynamicAny & da
);
Greater than or equal operator for comparing DynamicAny with Poco::Int32
 
 inline bool operator >= (
    const Poco::UInt32 & other,
    const DynamicAny & da
);
Greater than or equal operator for comparing DynamicAny with Poco::UInt32
 
 inline bool operator >= (
    const Poco::Int64 & other,
    const DynamicAny & da
);
Greater than or equal operator for comparing DynamicAny with Poco::Int64
 
 inline bool operator >= (
    const Poco::UInt64 & other,
    const DynamicAny & da
);
Greater than or equal operator for comparing DynamicAny with Poco::UInt64
 
 inline bool operator >= (
    const float & other,
    const DynamicAny & da
);
Greater than or equal operator for comparing DynamicAny with float
 
 inline bool operator >= (
    const double & other,
    const DynamicAny & da
);
Greater than or equal operator for comparing DynamicAny with double
 
 inline bool operator >= (
    const long & other,
    const DynamicAny & da
);
Greater than or equal operator for comparing DynamicAny with long
 
   
 template < class TObj, class TArgs > static PriorityDelegate < TObj, TArgs, true > priorityDelegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(const void *, TArgs &) param148,
    int prio
);
 
   
 template < class TObj, class TArgs > static PriorityDelegate < TObj, TArgs, false > priorityDelegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(TArgs &) param149,
    int prio
);
 
   
 template < class TObj, class TArgs > static PriorityExpire < TArgs > priorityDelegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(const void *, TArgs &) param150,
    int prio,
    Timestamp::TimeDiff expireMilliSec
);
 
   
 template < class TObj, class TArgs > static PriorityExpire < TArgs > priorityDelegate(
    TObj * pObj,
    void (TObj::* NotifyMethod)(TArgs &) param151,
    int prio,
    Timestamp::TimeDiff expireMilliSec
);
 
   
 template < class TArgs > static PriorityExpire < TArgs > priorityDelegate(
    void (* NotifyMethod)(const void *, TArgs &) param152,
    int prio,
    Timestamp::TimeDiff expireMilliSec
);
 
   
 template < class TArgs > static PriorityExpire < TArgs > priorityDelegate(
    void (* NotifyMethod)(void *, TArgs &) param153,
    int prio,
    Timestamp::TimeDiff expireMilliSec
);
 
   
 template < class TArgs > static PriorityExpire < TArgs > priorityDelegate(
    void (* NotifyMethod)(TArgs &) param154,
    int prio,
    Timestamp::TimeDiff expireMilliSec
);
 
   
 template < class TArgs > static FunctionPriorityDelegate < TArgs, true, true > priorityDelegate(
    void (* NotifyMethod)(const void *, TArgs &) param155,
    int prio
);
 
   
 template < class TArgs > static FunctionPriorityDelegate < TArgs, true, false > priorityDelegate(
    void (* NotifyMethod)(void *, TArgs &) param156,
    int prio
);
 
   
 template < class TArgs > static FunctionPriorityDelegate < TArgs, false > priorityDelegate(
    void (* NotifyMethod)(TArgs &) param157,
    int prio
);
 
 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 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 & 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 C > inline void swap(
    AutoPtr < C > & p1,
    AutoPtr < C > & p2
);
 
 inline void swap(
    DateTime & d1,
    DateTime & d2
);
 
 inline void swap(
    File & f1,
    File & f2
);
 
 inline void swap(
    LocalDateTime & d1,
    LocalDateTime & d2
);
 
 inline void swap(
    Message & m1,
    Message & m2
);
 
 inline void swap(
    Path & p1,
    Path & p2
);
 
 template < class C, class RC, class RP > inline void swap(
    SharedPtr < C,
    RC,
    RP > & p1,
    SharedPtr < C,
    RC,
    RP > & p2
);
 
 inline void swap(
    TextIterator & it1,
    TextIterator & it2
);
 
 inline void swap(
    Timespan & s1,
    Timespan & s2
);
 
 inline void swap(
    Timestamp & s1,
    Timestamp & s2
);
 
 inline void swap(
    URI & u1,
    URI & u2
);
 
 inline void swap(
    UUID & u1,
    UUID & u2
);
 
 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 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 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 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
);
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 translateInPlace(
    S & str,
    const typename S::value_type * from,
    const typename S::value_type * to
);
 
 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 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.