Boost logo

Boost :

From: Tom Brinkman (reportbase_at_[hidden])
Date: 2005-08-19 08:42:19

Boost Fall Review Schedule - version 2.0

Contact Tom Brinkman at reportbase_at_[hidden] to request a
review, to make updates to this document or to volunteer
to be a review manager.

The next library up for review is the xpressive library by
Eric Niebler on September 8, 2005. It is available at
This library still needs a review manager. Please contact me to volunteer.

Following the review of the xpressive library is the TR1 library by
John Maddock at The review is set for
September 20, 2005. This library can be download at
This library needs a review manager volunteer also.

Lets all make an effort to get more involved in the review processes this
fall. I know the library authors would love to get more feedback.

Check out the Boost::wiki page for New Libraries Under Construction at
If your one of the libray's authors or active users, please feel free
to make any changes to the libraries summary description. Click the
question mark to add more detailed information about the library.

Review Queue as of August 16, 2005.

1. xpressive - Eric Niebler (September 8, 2005)
2. TR1 - John Maddock (September 20, 2005)
3. logging - John Torjo (October 5, 2005)

To be Confirmed:
4. singleton - Jason Hise (postponed)
5. function types - Tobias Schwinger (mini post-review needed)
6. output formatters - Reece Dunn (new review needed)
7. policy pointer - David B. Held
8. fixed strings - Reece Dunn
9. intrusive - Olaf Krzikalla
10. interfaces - Jonathan Turkanis
11. binary_int - Scott Schurr (ready to be reviewed)

1. xpressive
Author: Eric Niebler eric_at_[hidden]
Review Manager: needed
Review Date: September 8, 2005

xpressive is a TR1 regex work-alike that also accepts regexes as
expression templates and lets regexes nest and call each other recursively.

Significant changes since 0.9.3
- c_regex_traits to wrap the global C locale
- null_regex_traits for searching non-char data
- doc and test improvements
- bugs in static regexes and Unicode support squashed

You can consider this the xpressive 1.0 release candidate. All
that remains is to add more tests and documentation, and perhaps a tweak
to the traits interface.

2. TR1
Author - John Maddock john_at_[hidden]
Review Manager - needed
Download -
Docs - in download file
Review Date: September 20, 2005 (follows xpressive)

The TR1 library provides an implementation of the C++ Technical Report
on Standard Library Extensions. This library does not itself
implement the TR1 components, rather it's a thin wrapper that will
include your standard library's TR1 implementation (if it has one),
otherwise it will include the Boost Library equivalents, and import
them into namespace std::tr1. Functionality supported includes:
Reference Wrappers, Smart Pointers, Class template result_of.,Function
template mem_fn., Function Object Binders, Polymorphic function
wrappers, Type Traits, Random Number Generators and Distributions,
Tuples, Tuple Interface to std::pair, Fixed Size Array, Hash Function
Objects, Regular Expressions, Complex Number Algorithm Overloads,
Complex Number Additional Algorithms, Functionality in TR1 but not yet
available in this implementation: Mathematical Special Functions,
Unordered Associative Set (Hash Table), Unordered Associative Map
(Hash Table), C99 C language additions. This library also makes
changes to Boost.Config, and adds some new functionality to
Boost.Math, reviewers should start with the readme.html in the root
directory of the zip file.

3. logging
Author - John Torjo john_at_[hidden]
Review Manager - Hartmut.Kaiser Hartmut.Kaiser_at_[hidden]
Review Date: October 5, 2005 (follows TR1)

The Boost Log Library is a small library, who:
 * makes it very easy to declare/define new logs
 * allows you very simple access to logs
 * allows for log hierarchies, and for modifying log hierarchies
 * allows for easy and efficient enabling/disabling of logs/log hierarchies
 * allows for easy manipulation of log behaviors
   (the log's destination(s) and/or adjusting the original message)
 * is thread-safe

Using the library in code is easy and straightforward:

int i = 1, j = 2, k = 3;
BOOST_LOG(app) << "testing " << i << '-' << j << '-' << k << std::endl;
BOOST_LOG(dbg) << "this is a debug message, i=" << i << std::endl;
BOOST_LOG(info) << "I just wanted to tell you something....";

Recent Additions:
- can be compiled as a static/dynamic runtime
  (works as a DLL as well)
- removed dependency on boost_thread
  Note: I did not test this on Unix, but it should work.
  If anybody can take a look at detail/ts_posix.hpp, I'd
  appreciate it.
- solved other small issues, based on feedback
- slightly improved documentation

4) Singleton
Author - Jason Hise chaos_at_[hidden]
Review Manager - Andreas Huber ahd6974-groups_at_[hidden]
Download: (old version from previous review)
Review Date: Winter-2006

The singleton library provides multiple
powerful methods of controlling
the lifetimes of global resources.
Client code can choose among the
many provided methods of creation,
or can easily write new creators for
specialized initialization needs. Client
code can additionally control
precisely when a singleton instance is
automatically created and
destroyed, can create and destroy
singleton instances explicitly any
number of times, and can set up
dependencies between singletons in an
easy and natural way.

Jason has stated that he will not be ready for the
next review for a few months.

5) Function Types
Author - Tobias Schwinger tschwinger_at_[hidden]
Review Manager - John Maddock john_at_[hidden]
Download: (old version - from previous review)
Review Date: needed

This library provides a metaprogramming facility
to classify, decompose and synthesize function-,
function pointer-, function reference- and
member function pointer types. For the purpose
of this documentation, these types are
collectively referred to as function
types (this differs from the standard
definition and redefines the term from
a programmer's perspective to refer to
the most common types that involve functions).

The classes introduced by this library
shall conform to the concepts of the
Boost Metaprogramming library (MPL).

The Function Types library enables the user to:
* test an arbitrary type for
        being a function type of specified kind,
* inspect properties of function types,
* view and modify sub types of an
        encapsulated function type with
        MPL Sequence operations, and
* synthesize function types.

This library supports variadic functions and
can be configured to support
non-default calling conventions.

This library was reviewed June 2005 and was accepted pending a
mini post-review.

6. Output formatters
Author - Reece Dunn msclrhd_at_[hidden]
Review Manager - needed
Download: needed
Docs: needed
Review Date: needed

This library was reviewed september 11, 2004. It
requires a second full review.

7. Policy Pointer
Author - David B. Held dheld_at_[hidden]
Review Manager - Gennadiy gennadiy.rozental_at_[hidden]
Download: Boost Sandbox under policy_ptr
Docs: Boost Sandbox under policy_ptr
Review Date: needed

Smart pointers are used to automate memory management by handling the
deletion of dynamically
allcoated objects (and other resources). They assist in ensuring
program correctness, exception
safety, and memory integrity. Policy Pointer is a policy-based smart
pointer framework designed
to accomodate the large number of smart pointer designs. Through the
use of policy classes, virtually
any smart pointer type can be constructed within this framework. This
library is a Boostification of
the original Loki::SmartPtr type with significant modifications.

8. Fixed Strings
Author - Reece Dunn msclrhd_at_[hidden]
Review Manager - Beman Dawes bdawes_at_[hidden]
Download: boosts-sandbox/boost/fixed_string
Docs: boosts-sandbox/boost/fixed_string
Review Date: needed

The fixed string library provides buffer overrun protection for static
sized strings (char s[ n ]). It provides a C-style string interface for
compatibility with C code (for example, porting a C program to C++).
There is also a std::string-style interface using a class based on
flex_string by Andre Alexandrescu with a few limitations due to
the non-resizable nature of the class.

9. Intrusive
Author - Olaf Krzikalla krzikalla_at_[hidden]
Review Manager - needed
Review Date: needed

While intrusive containers were and are
widely used in C, they became more and more forgotten in the C++-world
due to the presence of the standard containers, which don't support
intrusive techniques. Boost.Intrusive not only reintroduces this
technique to C++, but also encapsulates the implementation in STL-like
interfaces. Hence anyone familiar with standard containers can use
intrusive containers with ease.

10. Interfaces
Author - Jonathan Turkanis technews_at_[hidden]
Review Manager - needed
Review Date: needed

"Boost.Interfaces provides a macro-based Interface Definition Language (IDL)
which can be used to define C++ class types called interfaces. An interface is a
lightweight value type associated with a set of named function signatures. An
interface instance can be bound at runtime to any object which implements the
interface, i.e., to any object of a type with accessible non-static member
functions having the same name and signature as the set of functions associated
with the interface. The functions of the bound object can then be invoked
through the interface instance using the 'dot' operator. Binding is completely
non-intrusive: the object's type need not declare any virtual functions or
derive from any particluar base class.

"Current applications of Boost.Interfaces include:

* Non-intrusive dynamic polymorphism — interfaces can often be used in
place of abstract base classes, and are sometimes much faster (see Performance).
* Dynamic inheritance — allows function calls to be forwarded automatically
to an object specified at runtime (see Delegation).
* Smart Interface Pointers — smart pointers which can manage the lifetime
of any object whose type implements a given interface.
* Smart References — like smart interface pointers, but the managed object
is accessed using the "dot" operator."

11. binary_int
Author: Scott Schurr scott_schurr_at_[hidden]
Review Manager: pavel_vozenilek_at_[hidden]
Download: needed
Docs: needed
Review Date: October, 2005 (ready to be reviewed)

The binary_int<> template allows the compile-time expression of
integer binary literals. There is no run-time code overhead for
using this template; all overhead is at compile time. I expect
these binary literals to work any place that an integer literal
would work at compile (not preprocessing) time. The template
is designed to allow binary values up to 64-bits to be expressed,
although it has only been tested up to 32-bits to date.

Boost list run by bdawes at, gregod at, cpdaniel at, john at