RefObject is the base class for all reference counting objects. RefObject supports boost::intrusive_ptr<>, debug tracing and scope guard. RefObject based upon fast boost::detail::atomic_count.

SystemException provides standard interface for all system exception and support for some OS system backtrace functionality.

ThreadPool class creates threads with the specified maximum and initial count. You can schedule your task on thread pool with ThreadPool.schedule method. Also you can schedule your task with assigned task id if you want take more control for task lifecycle (canceling task by id, wait to finish, etc) and don't want run tasks simultaneously for same id. For example:

// Creating a thread pool. Maximum count of threads in the pool is 10 and initially will be created is 3

ThreadPool* pool = new ThreadPool ( 10 , 3 );

// Creation task id
ThreadPool::TaskId myTaskId = pool->createTaskId();
// Scheduling the user task function in user class (boost::bind usage)

// All scheduled tasks per task id can't run simultaneously
pool->schedule (
  myTaskId,
  boost::bind ( &MyClass::myTaskHandler, this)
);

// Canceling all scheduled jobs by id
pool->cancel ( myTaskId );

// Wait for finish scheduled jobs by id
pool->wait ( myTaskId );

You can utilize your objects with object instances pooling in the heap. ObjectPool class provides access to simple pooling. Look at the sample:

// Create a new object pool. Maximum pool size is 1000, initial created 5
ObjectPool<MyClass> pool = new ObjectPool<MyClass> ( 1000, 5 );

// Get an instance from the pool
MyClass* instance = pool->getObject();

// Return the instance to the pool
pool->returnObject(instance);

Timer provides timer queue and based upon OS high-resolution timer API. With the timer you can schedule your task for the spefied time interval.

For example:

// Create your timer
Timer* myTimer = new Timer();

// Assign your own id for this timer event
Timer::TimerId myTimerId = 1;

// Schedule one timer event
myTimer->schedule(
  myTimerId,
  10000, // Handler must be called after 10 sec
  boost::bind(&MyClass::myTimerHandler, this)
);

BigInteger can store very big integers (like Java BigInteger). You can initialize this type with standard std::string, int, long, double datatypes, call arithmetic operations or use logical operators. For example:

BigInteger a(10L), b("20000000000000000000000");

if ( a < b) {
   a*= b / BigInteger(1000000);
}

BigDecimal stores very big fixed point numbers (like Java BigDecimal) . You can initialize this type with standard std::string, int, long, double datatypes, call arithmetic operations or use logical operators. Also you can use this format for store financial prices and costs because this type based up on fixed point arithmetic. For example:

BigDecimal a("0.5"), b(1);

if ( a < b) {
   a+= BigDecimal("1.5");
}

ByteBuffer is a wrapper class for byte arrays ( unsigned char[] ) with length and read/write positions and very useful additional functions like append, fill, replace, cut, seek, etc. For example:

// Creating a byte buffer with initial capacity 1024 bytes
ByteBuffer* myBuffer = new ByteBuffer( 1024 );

// Appending a C-style buffer
const unsigned char cStyleBuffer[] =  { 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
myBuffer->append (cStyleBuffer, sizeof ( cStyleBuffer ) );

// Appending another ByteBuffer
myBuffer->append ( anotherBuffer );

// Get len of the buffer
myBuffer->getLen();

// Capacity of buffer
myBuffer->getCapacity();

// Resizing without lost current data
myBuffer->setLen ( 2048 );

// Filling the buffer with 0
myBuffer->fill ( 0 );

ByteArrayInputOutputStream provides implementation based upon ByteBuffer where you can write buffers to the stream and read from the stream in parallel threads with low thread locking algorithm based on blocks of arrays.

• Boost C++ library (http://www.boost.org)

• GNU MP Library (http://gmplib.org/) or MPIR fork for Windows (http://www.mpir.org)