Boost :

garcia_at_[hidden]

----
:Author: Yigong Liu
:Review Manager: Needed
:Download: http://channel.sourceforge.net/
:Description: Join is an asynchronous, message based C++ concurrency
   library based on join calculus. It is applicable both to
   multi-threaded applications and to the orchestration of asynchronous,
   event-based applications. It follows Comega's design and
   implementation and builds with Boost facilities. It provides a high
   level concurrency API with asynchronous methods, synchronous methods,
   and chords which are "join-patterns" defining the synchronization,
   asynchrony, and concurrency.
Pimpl
-----
:Author: Vladimir Batov
:Review Manager: Needed
:Download: `Boost Sandbox Vault <http://www.boost-consulting.com/
vault/index.php?action=downloadfile&filename=Pimpl.zip&directory=&>`__
             http://www.ddj.com/cpp/205918714 (documentation)
:Description: The Pimpl idiom is a simple yet robust technique to
   minimize coupling via the separation of interface and implementation
   and then implementation hiding.  This library provides a convenient
   yet flexible and generic deployment technique for the Pimpl idiom.
   It's seemingly complete and broadly applicable, yet minimal, simple
   and pleasant to use.
Constrained Value
-----------------
:Author: Robert Kawulak
:Review Manager: Jeff Garland
:Download: http://rk.go.pl/f/constrained_value.zip
:Description:
   Review scheduled for 12/1/08-12/10/08
   The Boost Constrained Value library contains class templates useful
   for creating constrained objects. A simple example is an object
   representing an hour of a day, for which only integers from the range
   [0, 23] are valid values:
   ::
       bounded_int<int, 0, 23>::type hour;
       hour = 20; // OK
       hour = 26; // exception!
   Behavior in case of assignment of an invalid value can be
customized. For
   instance, instead of throwing an exception as in the example above,
the value
   may be adjusted to meet the constraint:
   ::
       wrapping_int<int, 0, 255>::type buffer_index;
       buffer_index = 257; // OK: wraps the value to fit in the range
       assert( buffer_index == 1 );
   The library doesn't focus only on bounded objects as in the
examples above --
   virtually any constraint can be imposed by using a predicate:
   ::
       // constraint (a predicate)
       struct is_odd {
	 bool operator () (int i) const
	 { return (i % 2) != 0; }
       };
   ::
       // and the usage is as simple as:
       constrained<int, is_odd> odd_int = 1;
       odd_int += 2; // OK
       ++odd_int; // exception!
   The library has a policy-based design to allow for flexibility in
defining
   constraints and behavior in case of assignment of invalid values.
Policies may
   be configured at compile-time for maximum efficiency or may be
changeable at
   runtime if such dynamic functionality is needed.
Thread Pool
-----------
:Author: Oliver Kowalke
:Review Manager: Needed
:Download: `Boost Sandbox Vault <http://www.boostpro.com/vault/
index.php?action=downloadfile&amp;filename=boost-threadpool.
2.tar.gz&amp;directory=Concurrent%20Programming>`__
:Description:
   The library provides:
   - thread creation policies: determines the managemnt of worker  
threads
       - fixed set of threads in pool
       - create workerthreads on demand (depending on context)
       - let worker threads ime out after certain idle time
   - channel policies: manages access to queued tasks
      - bounded channel with high and low watermark for queuing tasks
      - unbounded channel with unlimited numer of queued tasks
      - rendezvous syncron hand-over between producer and consumer
threads
   - queueing policy: determines how tasks will be removed from channel
      - FIFO
      - LIFO
      - priority queue (attribute assigned to task)
      - smart insertions and extractions (for instance remove oldest
task with
        certain attribute by newst one)
   - tasks can be chained and lazy submit of taks is also supported
(thanks to
     Braddocks future library).
   - returns a task object from the submit function. The task it self  
can
     be interrupted if its is cooperative (means it has some
interruption points
     in its code -> ``this_thread::interruption_point()`` ).
Polynomial
----------
:Author: Pawel Kieliszczyk
:Review Manager: Needed
:Download: `Boost Sandbox Vault <http://www.boostpro.com/vault/
index.php?
action=downloadfile&amp;filename=polynomial.zip&amp;directory=>`__
:Description:
   The library was written to enable fast and faithful polynomial
manupulation.
   It provides:
    - main arithmetic operators (+, -, * using FFT, /, %),
    - gcd,
    - different methods of evaluation (Horner Scheme, Compensated Horner
      Algorithm, by preconditioning),
    - derivatives and integrals,
    - interpolation,
    - conversions between various polynomial forms (special functions  
for
      creating Chebyshev, Hermite, Laguerre and Legendre form).
Libraries under development
===========================
Please let us know of any libraries you are currently
developing that you intend to submit for review.