Boost logo

Boost Announcement :

Subject: [Boost-announce] Review Wizard Report for March 2011
From: Ronald Garcia (rxg_at_[hidden])
Date: 2011-03-04 15:39:44

Review Wizard Status Report for March 2011


1. Move Library Accepted

2. Ratio Library Accepted

3. Chrono Library Accepted

4. GIL.IO Library Accepted

5. Boost 1.46 Released
     New Libraries: Interval Containers

     Revised Libraries: Array, Asio, Bind, Concepts, Filesystem, Fusion, Graph,
     Hash, Iterator, Math, Meta State Machine, Optional, Pool, Program Options,
     Proto, Signals, Spirit, Tokenizer, Unordered, Wave
     Revised Tools: Boostbook, Inspect, Quickbook

Open Issues

The following libraries have been reviewed and await reports from their
review managers:

* Process - reviewed February 2011; review manager: Marshall Clow.
* Phoenix - reviewed March 2011; review manager: Hartmut Kaiser.

The following libraries have been accepted to Boost, but have not yet
been submitted to SVN:

* GIL.IO - accepted January 2011; author: Christian Henning.
* Move - accepted February 2011; author: Ion Gaztanaga.

The following libraries have been accepted and submitted to SVN, but
have not yet appeared in a release:

* Geometry Library - accepted November 2009; author: Barend Gehreis et al.
* Ratio - accepted October 2010; author: Vicente Botet.
* GIL.IO - accepted January 2011; author: Christian Henning.
* Chrono - accepted January 2011; author: Vicente Botet.

The following libraries have been accepted provisionally to Boost, but
have not been submitted for mini-review and full acceptance:

* Switch - accepted provisionally January 2008; author: Steven Watanabe.
* Log - accepted provisionally March 2010; author: Andrey Semashev.

General Announcements

As always, we need experienced review managers. The review schedule has
grown substantially but we have few volunteers, so manage reviews if
possible and if not please make sure to watch the review schedule and
participate. Please take a look at the list of libraries in need of
managers and check out their descriptions. In general review managers
are active boost participants, including library contributors,
infrastructure contributors, and other mailing list participants with
a substantial track record of constructive participation. If you can
serve as review manager for any of them, email Ron Garcia or John
Phillips, "rxg at cs dot cmu dot edu" and "phillips at mps dot
ohio-state dot edu" respectively.

We are also suffering from a lack of reviewers. While we all
understand time pressures and the need to complete paying work, the
strength of Boost is based on the detailed and informed reviews
submitted by you. If you are interested in reviewing a library but
won't have time during the review period, you can always prepare your
review ahead of time. No rule says you can only work on a review
during the review period.

A link to this report will be posted to If you would
like us to make any modifications or additions to this report before
we do that, please email Ron or John.

The review schedule is an unordered list of the libraries awaiting
review. As such, any library on the schedule can be reviewed once the
developer is ready, a review manager has been secured, and
the manager, developer, and wizards agree on a date
to schedule the review.

Review Schedule

* Join (M)
* Pimpl (M)
* Endian
* Conversion (M)
* Sorting (M)
* AutoBuffer (M)
* Convert
* Containers
* Type Traits Extensions
* Lockfree (M)
* Fiber (M)
* Quaternions, Vectors, Matrices (M)
* Locale
* Context
* Stopwatches
* Autoindex
* Variadic Macro Data (M)

``(M)`` marks libraries that need review managers.



:Author: Yigong Liu
:Review Manager: Needed
: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.
:Author: Vladimir Batov
:Review Manager: Needed
:Download: | `Boost Vault <;;directory=&amp;>`__
           | (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.
:Author: Beman Dawes
:Review Manager: Joel Falcou
:Author: Vicente Botet
:Review Manager: Needed
:Download: `Boost Vault <;;directory=Utilities&amp;>`__
:Description: Generic explicit conversion between unrelated types.
 Boost.Conversion provides:
     * a generic ``convert_to`` function which can be specialized by the user to
       make explicit conversion between unrelated types.
     * a generic ``assign_to`` function which can be specialized by the user to
       make explicit assignation between unrelated types.
     * conversion between ``std::complex`` of explicitly convertible types.
     * conversion between ``std::pair`` of explicitly convertible types.
     * conversion between ``boost::optional`` of explicitly convertible types.
     * conversion between ``boost::rational`` of explicitly convertible types.
     * conversion between ``boost::interval`` of explicitly convertible types.
     * conversion between ``boost::chrono::time_point`` and ``boost::ptime``.
     * conversion between ``boost::chrono::duration`` and 
:Author: Steven Ross
:Review Manager: Needed
:Download: `Boost Vault <;>`__
 A grouping of 3 templated hybrid radix/comparison-based sorting
 algorithms that provide superior worst-case and average-case
 performance to std::sort: integer_sort, which sorts fixed-size data
 types that support a rightshift (default of >>) and a comparison
 (default of <) operator.   float_sort, which sorts standard
 floating-point numbers by safely casting them to integers.
 string_sort, which sorts variable-length data types, and is optimized
 for 8-bit character strings.
 All 3 algorithms have O(n(k/s + s)) runtime where k is the number of
 bits in the data type and s is a constant, and limited memory overhead
 (in the kB for realistic inputs).   In testing, integer_sort varies
 from 35% faster to 2X as fast as std::sort, depending on processor,
 compiler optimizations, and data distribution.   float_sort is roughly
 70% faster than std::sort.   string_sort is roughly 2X
 as fast as std::sort.
:Author: Thorsten Ottosen
:Review Manager: Robert Stewart
  Boost.AutoBuffer provides a container for efficient dynamic, local buffers.
  Furthermore, the container may be used as an alternative to std::vector,
  offering greater flexibility and sometimes better performance.
:Author: Vladimir Batov
:Review Manager: Edward Diener
:Download: `Boost Vault <;>`__
 The Convert library takes the approach of boost::lexical_cast in the area of
 string-to-type and type-to-string conversions, builds on the past
 boost::lexical_cast experience and advances that conversion
 functionality further to additionally provide:
  * throwing and non-throwing conversion-failure behavior;
  * support for the default value to be returned when conversion fails;
  * two types of the conversion-failure check -- basic and better/safe;
  * formatting support based on the standard I/O Streams and the standard
    (or user-defined) I/O Stream-based manipulators
    (like std::hex, std::scientific, etc.);
  * locale support;
  * support for boost::range-compliant char and wchar_t-based string containers;
  * no DefaultConstructibility requirement for the Target type;
  * consistent framework to uniformly incorporate any type-to-type conversions.
 It is an essential tool with applications making extensive use of
 configuration files or having to process/prepare considerable amounts
 of data in, say, XML, etc.
:Author: Ion Gaztanaga
:Review Manager: John Maddock
:Download: `Boost Vault <;;directory=Containers&amp;>`__
:Documentation: `Boost Sandbox <>`__
 Boost.Container library implements several well-known containers,
 including STL containers. The aim of the library is to offers advanced
 features not present in standard containers or to offer the latest
 standard draft features for compilers that comply with C++03.
Type Traits Extensions
:Author: Frederic Bron
:Review Manager: Joel Falcou
:Download: `Boost Vault <;filename=type_traits.tar.bz2&amp;directory=Extension&amp;>`__
 The purpose of the addition is to add type traits to detect if types T and U
 are comparable in the sense of <, <=, >, >=, == or != operators, i.e. if
 t<u has a sens when t is of type T and u of type U (same for <=, >, >=, ==,
 The following traits are added:
 The names are based on the corresponding names of the standard
 template library (<functional> header, section 20.3.3 of the
 The code has the following properties:
 * returns true if t<u is meaningful and returns a value convertible to bool
 * returns false if t<u is meaningless.
 * fails with compile time error if t<u is meaningful and returns void
 (a possibility to avoid compile time error would be to return true
 with an operator, trick but this has little sens as returning false
 would be better)
:Author: Tim Blechmann
:Review Manager: Needed
:Download: `Boost Vault <;;directory=Concurrent%20Programming&amp;>`__
 Lockfree provides implementations of lock-free data structures.
 Lock-free data structures can be accessed by multiple threads without
 the necessity of blocking synchronization primitives such as guards.
 Lock-free data structures can be used in real-time systems, where
 blocking algorithms may lead to high worst-case execution times, to
 avoid priority inversion, or to increase the scalability for
 multi-processor machines.
 Lockfree provides:
  * boost::lockfree::fifo, a lock-free fifo queue
  * boost::lockfree::stack, a lock-free stack
:Author: Oliver Kowalke
:Review Manager: Needed
:Download: `Boost Vault <;;directory=Concurrent%20Programming&amp;>`__
:Description: C++ Library for launching fibers (micro-threads) and
 synchronizing data between the fibers.
Quaternions, Vectors, Matrices
:Author: Emil Dotchevski
:Review Manager: Needed
:Description: QVM defines a set of generic functions and
    operator overloads for working with quaternions, vectors and matrices
    of static size. The library also defines vector and matrix data types,
    however it allows users to introduce their own types by specializing
    the q_traits, v_traits and m_traits templates.
:Author: Artyom Beilis
:Review Manager: Chad Nelson
:Description: The Locale library provides powerful tools that extend
    existing built-in C++ localization facilities in a Unicode-aware way.
:Author: Oliver Kowalke
:Review Manager: Vicente Botet
:Download: `Boost Vault <;;directory=Concurrent%20Programming&amp;>`__
:Description: Context provides the ability to switch between
    different user-level context and is intended to be the basis for a
    higher abstraction like coroutine and fiber.
    A user-level context represents the current execution state, including
    all registers and CPU flags, the instruction pointer, the stack
    pointer. boost::context encapsulates such a user-level context and is
    able to store/restore its associated user-level context. This allows
    multiple execution paths running on a single thread using a sort of
    cooperative scheduling (in contrast a thread is preemptively
    scheduled) - the running boost::context decides explicitly when its
    yields to allow another boost::context to run (user-level context
    switching). A context can only run on a single thread at any point in
    time but may be migrated between thread.
:Author: Vicente Botet
:Review Manager: Anthony Williams
:Download: `Boost Vault <;;directory=System>`__
   On top of the standard facilities of Boost.Chrono, Stopwatches provides:
   * Stopwatches: A facility to measure elapsed time with the ability to
     start, stop, suspend, or resume measurement.
     * Stopwatch concept
     * Scoped helper classes allowing to pairwise start/stop operations,
       suspend/resume and resume/suspend a Stopwatch.
     * stopwatch, model of Stopwatch capturing elapsed Clock times.
     * stopwatch_accumulator, model of Stopwatch capturing accumulated
       elapsed Clock times.
   * Stopclocks: a complete time reporting package that can be invoked in
     a single line of code.
     * stopwatch_reporter, convenient reporting to an output stream
       (including wide char streams) of the elapsed time of models of
       Stopwatch results.
     * stopclock<Clock> shortcut of stopwatch_reporter<stopwatch<Clock>>
AutoIndex (Tool)
:Author: John Maddock
:Review Manager: Daniel James
:Download: `Boost Vault <;>`__
:Documentation: `Boost Sandbox <>`__
    AutoIndex is a tool for taking the grunt work out of indexing a
    Boostbook/Docbook document (perhaps generated by your Quickbook file
    mylibrary.qbk, and perhaps using also Doxygen autodoc) that describes
    C/C++ code.
    Traditionally, in order to index a Docbook document you would have to
    manually add a large amount of <indexterm> markup: in fact one
    <indexterm> for each occurrence of each term to be indexed.
    Instead AutoIndex will automatically scan one or more C/C++ header
    files and extract all the function, class, macro and typedef names
    that are defined by those headers, and then insert the <indexterm>s
    into the Docbook XML document for you.
Variadic Macro Data
:Author: Edward Diener
:Review Manager: Needed
:Download: `Boost Sandbox <>`__
  The variadic_macro_data library adds support and functionality for
  variadic macros to Boost as well as integrating variadic macros with
  the Boost PP library without changing the latter library in any way.
Libraries under development
for a current listing of libraries under development.

Boost-announce list run by bdawes at, david.abrahams at, gregod at, cpdaniel at, john at