Review Wizard Report

Thanks to "Ron Garcia" for keeping the Review Schedule page
up to date: The current schedule is located at:

http://www.boost.org/more/formal_review_schedule.html .

If you have any changes, post them as a reply to this thread.

We need experienced review managers for most of the libraries.
If your interested, let us know. Preferably, you would have
a background in the problem domain, but no association
with the library and a regular contributer on the boost mailing list.
You can read the "review manager" requirements at the
following link:

http://www.boost.org/more/formal_review_process.htm

Most of the libraries are located at the Boost Sandbox Vault,
located here:

http://boost-consulting.com/vault/

Here is a summary of the libraries that are in the queue.

-------------------------------------
Library: Accumulators
Author: Eric Niebler
Location: Boost Sandbox Vault
Review Manger: John R. Phillips
Date: January 29, 2007 - February 7, 2007
Summary:
The Accumulators Framework is framework for performing
incremental calculations. Usage of the framework
follows the following pattern: Users build a computational
object, called an accumulator_set<>, by selecting the
computations in which they are interested, or authoring
their own computational primitives which fit
within the framework. Users push data into the
accumulator_set<> object one sample at a time.
The accumulator_set<> computes the requested
quantities in the most efficient method possible,
resolving dependencies between requested calculations,
possibly cacheing intermediate results. The Accumulators
Framework defines the utilities needed for defining
primitive computational elements, called accumulators.
It also provides the accumulator_set<> type,
described above.

-------------------------------------
Library: Exception
Author: Emil Dotchevski
Location: http://www.revergestudios.com/boost-exception/boost-exception.zip
Review Manager: Needed
Date: Needed
Summary:
The purpose of Boost Exception is to free designers of
exception classes from having to consider what data needs to
be stored in exception objects in order for the catch site to
be able to make sense of what went wrong. When Boost Exception
is used, arbitrary values can be stored in any exception. This can be
done directly in the throw-expression, or at a later time as the
exception object propagates up the call stack. The ability to add
data to any exception object after it has been thrown is important,
because often some of the information needed to handle an
exception is unavailable at the time of the throw.

-----------------------------------------
Library: Bimap
Author: Matias Capeletto
Location: Boost Sandbox Vault
Review Manager: Needed
Date: Needed
Summary:
With Boost.Bimap you can create associative containers
where both types can be used as key. You can think a
`bimap<X,Y>` as a merge of a `std::map<X,Y>`
and a `std::map<Y,X>`. The learning curve of bimap is
almost zero if you know how to use standard containers.
A big effort was put in mapping the naming scheme
of the STL in Boost.Bimap. The library is designed to
match the STL common containers.

-----------------------------------------
Library: Globally Unique Identifier
Author: Andy Tompkins
Location: Boost Sandbox Vault
Review Manager: Needed
Date: Needed
Summary:
A guid, or globally unique identifier, is an identifier
standard used in many disciplines including computer networks,
distributed computing, and databases. They can be used to tag
objects with very short lifetimes, to reliably identify very
persistent objects across a network. An attractive feature of
guids is their relative small size, of 128-bits, compared to
alternatives. Also the creation of guids does not require
a centralized authority.

-----------------------------------------
Library: Intrusive Containers
Author: Ion Gaztañaga
Location: Boost Sandbox Vault
Review Manager: Needed
Date: Needed
Summary:
Existing practice have shown the need for
intrusive containers. Widely used C++ libraries, such
as C++ Standard Library and Boost have long
missed such facilities so that users had to refrain
from using those due to mandatory element copying
or fall back to techniques like two phase construction to
insert logically non-copyable elements in containers
and initialize them after that or insert pointers to
dynamically allocated objects which is rather
inelegant and inefficient since containers also dynamically
allocate nodes. The most common use cases for intrusive
containers are, when one would like to store non-copyable
elements in a container when it's beneficial to
avoid needless data copy in performance critical applications.
The most prominent example of both the use cases,
although written for the most part in C rather than C++,
is Linux kernel built solely upon intrusive lists, hash
tables and trees.

-----------------------------------------
Library: Scope Exit
Author: Alexander Nasonov
Location: Boost Sandbox Vault
Review Manager: Needed
Date: Needed
Summary:
The scope-exit-arg-pp-seq is Boot.Preprocessor sequence
of identifiers that can be used inside scope-exit-body.
The direct-declarator is declarator-id followed by optional
argument of type boost::scope_exit_group (inside brackets or
after the equal sign). This construct executes scope-exit-body
at the close of the current scope.

-----------------------------------------
Library: Finite State Machines
Author: Andrey Semashev
Location: Boost Sandbox Vault
Review Manager: Needed
Date: Needed
Summary:
The Boost.FSM library is an implementation of FSM
(stands for Finite State Machine) programming concept.
There are many cases when a developer would like to distinguish the
behavior of a given object depending on some conditions or its
internal state. For example, when making software to control
an underground charging tourniquiet a programmer would like to
separate states in which the tourniquiet may persist: an idle state,
when the device awaits for another passenger that would like to
pass; a processing state, when the passenger have come
and put his ticket into the device; and the passing state,
when the tourniquiet lets the passenger pass through. In
fact, each state describes different reaction of the machine
at the same events (a passenger may only pass after paying
for ticket). Obviously, the tourniquiet have to be able to
change its internal state in order to function properly,
this is called state switching or transitions between
states (or just transitions for short).

-----------------------------------
Library: Statistical Distributions
Author: John Maddock
Location: Boost Sandbox Vault (math-toolkit)
Review Manager: Needed
Date: Needed
Summary:
Provides many of the tools required to implement
mathematical special functions: hopefully the
presence of these will encourage other authors to
contribute more special function implementations in the future.
There are helpers for the evaluation of infinite series,
continued fractions and rational approximations.
There is a fairly comprehensive set of root finding and
function minimisation algorithms: both with and
without derivative support. A Remez algorithm
implementation allows for the locating of minimax
rational approximations. There are also (experimental)
classes for the manipulation of polynomials, for testing
a special function against tabulated test data, and
for the rapid generation of test data and/or data
for output to an external graphing application.