Poco Namespace Reference

Data Structures

class AutoPtr

AutoPtr is a "smart" pointer for classes implementing reference counting based garbage collection. To be usable with the AutoPtr template, a class must implement the following behaviour: A class must maintain a reference count. The constructors of the object initialize the reference count to one. The class must implement a public duplicate() method: void duplicate(); that increments the reference count by one. The class must implement a public release() method: void release() that decrements the reference count by one, and, if the reference count reaches zero, deletes the object. More...

class Bugcheck

This class provides some static methods that are used by the poco_assert_dbg(), poco_assert(), poco_check_ptr() and poco_bugcheck() macros. You should not invoke these methods directly. Use the macros instead, as they automatically provide useful context information. More...

class Debugger

The Debugger class provides an interface to the debugger. The presence of a debugger can be checked for, messages can be written to the debugger's log window and a break into the debugger can be enforced. The methods only work if the program is compiled in debug mode (the macro _DEBUG is defined). More...

class ErrorHandler

This is the base class for thread error handlers. More...

class Event

An Event is a synchronization object that allows one thread to signal one or more other threads that a certain event has happened. Usually, one thread signals an event, while one or more other threads wait for an event to become signalled. More...

class EventImpl

class Exception

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

class LogicException

class AssertionViolationException

class NullPointerException

class BugcheckException

class InvalidArgumentException

class NotImplementedException

class RangeException

class IllegalStateException

class InvalidAccessException

class SignalException

class UnhandledException

class RuntimeException

class NotFoundException

class ExistsException

class TimeoutException

class SystemException

class RegularExpressionException

class LibraryLoadException

class LibraryAlreadyLoadedException

class NoThreadAvailableException

class PropertyNotSupportedException

class PoolOverflowException

class NoPermissionException

class OutOfMemoryException

class DataException

class DataFormatException

class SyntaxException

class CircularReferenceException

class PathSyntaxException

class IOException

class FileException

class FileExistsException

class FileNotFoundException

class PathNotFoundException

class FileReadOnlyException

class FileAccessDeniedException

class CreateFileException

class OpenFileException

class WriteFileException

class ReadFileException

class UnknownURISchemeException

class ApplicationException

class BadCastException

class Mutex

A Mutex (mutual exclusion) is a synchronization mechanism used to control access to a shared resource in a concurrent (multithreaded) scenario. Mutexes are recursive, that is, the same mutex can be locked multiple times by the same thread (but, of course, not by other threads). Using the ScopedLock class is the preferred way to automatically lock and unlock a mutex. More...

class FastMutex

A FastMutex (mutual exclusion) is similar to a Mutex. Unlike a Mutex, however, a FastMutex is not recursive, which means that a deadlock will occur if the same thread tries to lock a mutex it has already locked again. Locking a FastMutex is faster than locking a recursive Mutex. Using the ScopedLock class is the preferred way to automatically lock and unlock a mutex. More...

class MutexImpl

class FastMutexImpl

class RefCountedObject

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

class Runnable

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

class RWLock

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

class ScopedRWLock

A variant of ScopedLock for reader/writer locks. More...

class RWLockImpl

class ScopedLock

A class that simplifies thread synchronization with a mutex. The constructor accepts a Mutex and locks it. The destructor unlocks the mutex. More...

class Semaphore

A Semaphore is a synchronization object with the following characteristics: A semaphore has a value that is constrained to be a non-negative integer and two atomic operations. The allowable operations are V (here called set()) and P (here called wait()). A V (set()) operation increases the value of the semaphore by one. A P (wait()) operation decreases the value of the semaphore by one, provided that can be done without violating the constraint that the value be non-negative. A P (wait()) operation that is initiated when the value of the semaphore is 0 suspends the calling thread. The calling thread may continue when the value becomes positive again. More...

class SemaphoreImpl

class SingletonHolder

This is a helper template class for managing singleton objects allocated on the heap. The class ensures proper deletion (including calling of the destructor) of singleton objects when the application that created them terminates. More...

class Thread

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

class ThreadImpl

class TLSAbstractSlot

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

class TLSSlot

The Slot template wraps another class so that it can be stored in a ThreadLocalStorage object. This class is used internally, and you must not create instances of it yourself. More...

class ThreadLocalStorage

This class manages the local storage for each thread. Never use this class directly, always use the ThreadLocal template for managing thread local storage. More...

class ThreadLocal

This template is used to declare type safe thread local variables. It can basically be used like a smart pointer class with the special feature that it references a different object in every thread. The underlying object will be created when it is referenced for the first time. See the NestedDiagnosticContext class for an example how to use this template. Every thread only has access to its own thread local data. There is no way for a thread to access another thread's local data. More...

class Timestamp

A Timestamp stores a monotonic time value with (theoretical) microseconds resolution. Timestamps can be compared with each other and simple arithmetics are supported. Timestamps are UTC (Coordinated Universal Time) based and thus independent of the timezone in effect on the system. More...

Typedefs

typedef signed char Int8

typedef unsigned char UInt8

typedef signed short Int16

typedef unsigned short UInt16

typedef signed int Int32

typedef unsigned int UInt32

typedef signed __int64 Int64

typedef unsigned __int64 UInt64

typedef Int64 IntPtr

typedef UInt64 UIntPtr

Functions

template<class C>

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

void swap (Timestamp &s1, Timestamp &s2)

Typedef Documentation

typedef signed short Poco::Int16

Definition at line 89 of file Types.h.

typedef signed int Poco::Int32

Definition at line 91 of file Types.h.

typedef signed __int64 Poco::Int64

Definition at line 93 of file Types.h.

typedef signed char Poco::Int8

Definition at line 87 of file Types.h.

typedef Int64 Poco::IntPtr

Definition at line 99 of file Types.h.

typedef unsigned short Poco::UInt16

Definition at line 90 of file Types.h.

typedef unsigned int Poco::UInt32

Definition at line 92 of file Types.h.

typedef unsigned __int64 Poco::UInt64

Definition at line 94 of file Types.h.

typedef unsigned char Poco::UInt8

Definition at line 88 of file Types.h.

typedef UInt64 Poco::UIntPtr

Definition at line 100 of file Types.h.

Function Documentation

void Poco::swap	(	Timestamp &	s1,
		Timestamp &	s2
	)			`[inline]`

Definition at line 287 of file Timestamp.h.

References Poco::Timestamp::swap().

Referenced by Poco::Timestamp::swap(), and Poco::AutoPtr< Poco::ThreadImpl::ThreadData >::swap().

template<class C>

void Poco::swap	(	AutoPtr< C > &	p1,
		AutoPtr< C > &	p2
	)			`[inline]`

Definition at line 405 of file AutoPtr.h.

References Poco::AutoPtr< C >::swap().


Data Structures
class	AutoPtr
	AutoPtr is a "smart" pointer for classes implementing reference counting based garbage collection. To be usable with the AutoPtr template, a class must implement the following behaviour: A class must maintain a reference count. The constructors of the object initialize the reference count to one. The class must implement a public duplicate() method: void duplicate(); that increments the reference count by one. The class must implement a public release() method: void release() that decrements the reference count by one, and, if the reference count reaches zero, deletes the object. More...
class	Bugcheck
	This class provides some static methods that are used by the poco_assert_dbg(), poco_assert(), poco_check_ptr() and poco_bugcheck() macros. You should not invoke these methods directly. Use the macros instead, as they automatically provide useful context information. More...
class	Debugger
	The Debugger class provides an interface to the debugger. The presence of a debugger can be checked for, messages can be written to the debugger's log window and a break into the debugger can be enforced. The methods only work if the program is compiled in debug mode (the macro _DEBUG is defined). More...
class	ErrorHandler
	This is the base class for thread error handlers. More...
class	Event
	An Event is a synchronization object that allows one thread to signal one or more other threads that a certain event has happened. Usually, one thread signals an event, while one or more other threads wait for an event to become signalled. More...
class	EventImpl
class	Exception
	This is the base class for all exceptions defined in the Poco class library. More...
class	LogicException
class	AssertionViolationException
class	NullPointerException
class	BugcheckException
class	InvalidArgumentException
class	NotImplementedException
class	RangeException
class	IllegalStateException
class	InvalidAccessException
class	SignalException
class	UnhandledException
class	RuntimeException
class	NotFoundException
class	ExistsException
class	TimeoutException
class	SystemException
class	RegularExpressionException
class	LibraryLoadException
class	LibraryAlreadyLoadedException
class	NoThreadAvailableException
class	PropertyNotSupportedException
class	PoolOverflowException
class	NoPermissionException
class	OutOfMemoryException
class	DataException
class	DataFormatException
class	SyntaxException
class	CircularReferenceException
class	PathSyntaxException
class	IOException
class	FileException
class	FileExistsException
class	FileNotFoundException
class	PathNotFoundException
class	FileReadOnlyException
class	FileAccessDeniedException
class	CreateFileException
class	OpenFileException
class	WriteFileException
class	ReadFileException
class	UnknownURISchemeException
class	ApplicationException
class	BadCastException
class	Mutex
	A Mutex (mutual exclusion) is a synchronization mechanism used to control access to a shared resource in a concurrent (multithreaded) scenario. Mutexes are recursive, that is, the same mutex can be locked multiple times by the same thread (but, of course, not by other threads). Using the ScopedLock class is the preferred way to automatically lock and unlock a mutex. More...
class	FastMutex
	A FastMutex (mutual exclusion) is similar to a Mutex. Unlike a Mutex, however, a FastMutex is not recursive, which means that a deadlock will occur if the same thread tries to lock a mutex it has already locked again. Locking a FastMutex is faster than locking a recursive Mutex. Using the ScopedLock class is the preferred way to automatically lock and unlock a mutex. More...
class	MutexImpl
class	FastMutexImpl
class	RefCountedObject
	A base class for objects that employ reference counting based garbage collection. More...
class	Runnable
	The Runnable interface with the run() method must be implemented by classes that provide an entry point for a thread. More...
class	RWLock
	A reader writer lock allows multiple concurrent readers or one exclusive writer. More...
class	ScopedRWLock
	A variant of ScopedLock for reader/writer locks. More...
class	RWLockImpl
class	ScopedLock
	A class that simplifies thread synchronization with a mutex. The constructor accepts a Mutex and locks it. The destructor unlocks the mutex. More...
class	Semaphore
	A Semaphore is a synchronization object with the following characteristics: A semaphore has a value that is constrained to be a non-negative integer and two atomic operations. The allowable operations are V (here called set()) and P (here called wait()). A V (set()) operation increases the value of the semaphore by one. A P (wait()) operation decreases the value of the semaphore by one, provided that can be done without violating the constraint that the value be non-negative. A P (wait()) operation that is initiated when the value of the semaphore is 0 suspends the calling thread. The calling thread may continue when the value becomes positive again. More...
class	SemaphoreImpl
class	SingletonHolder
	This is a helper template class for managing singleton objects allocated on the heap. The class ensures proper deletion (including calling of the destructor) of singleton objects when the application that created them terminates. More...
class	Thread
	This class implements a platform-independent wrapper to an operating system thread. More...
class	ThreadImpl
class	TLSAbstractSlot
	This is the base class for all objects that the ThreadLocalStorage class manages. More...
class	TLSSlot
	The Slot template wraps another class so that it can be stored in a ThreadLocalStorage object. This class is used internally, and you must not create instances of it yourself. More...
class	ThreadLocalStorage
	This class manages the local storage for each thread. Never use this class directly, always use the ThreadLocal template for managing thread local storage. More...
class	ThreadLocal
	This template is used to declare type safe thread local variables. It can basically be used like a smart pointer class with the special feature that it references a different object in every thread. The underlying object will be created when it is referenced for the first time. See the NestedDiagnosticContext class for an example how to use this template. Every thread only has access to its own thread local data. There is no way for a thread to access another thread's local data. More...
class	Timestamp
	A Timestamp stores a monotonic time value with (theoretical) microseconds resolution. Timestamps can be compared with each other and simple arithmetics are supported. Timestamps are UTC (Coordinated Universal Time) based and thus independent of the timezone in effect on the system. More...
Typedefs
typedef signed char	Int8
typedef unsigned char	UInt8
typedef signed short	Int16
typedef unsigned short	UInt16
typedef signed int	Int32
typedef unsigned int	UInt32
typedef signed __int64	Int64
typedef unsigned __int64	UInt64
typedef Int64	IntPtr
typedef UInt64	UIntPtr
Functions
template<class C>
void	swap (AutoPtr< C > &p1, AutoPtr< C > &p2)
void	swap (Timestamp &s1, Timestamp &s2)