[boost] Review Schedule (11-May-2005)

From: Tom Brinkman (reportbase_at_[hidden])
Date: 2005-05-11 11:23:44

The singleton library review started on 5-May-2005.
If you haven't done so already, download the library at
http://tinyurl.com/6qvrd. 
You should submit a review by 15-May-2005.

The Typeof Library review begins 20-May-2005.  You 
can download this library at 
http://boost-sandbox.sourceforge.net/vault/ (typeof.zip)

Contact Tom Brinkman at reportbase_at_[hidden] for 
updates to this schedule.
 
Review Queue as of May 11, 2005

1) Singleton (Current)
5-May-2005; Ends: 15-May-2005

2) Typeof 
Starts: 20-May-2005; Ends: 30-May-2005

3) Function Types 
Starts: 5-June-2005; Ends: 15-June-2005

4) Logging 
To be confirmed: 20-June-2005; Ends: 30-June-2005

5) Policy Pointer 
To be confirmed: 5-July-2005; Ends: 15-June-2005

Other Libraries (no particular order):
6) Fixed Strings 
7) Intrusive
8) TR1 
9) Fusion
10) Factory
11) Interfaces

1) Singleton
Author: 
Jason Hise
chaos_at_[hidden]

Review Manager: 
Pavel Vozenilek
pavel_vozenilek_at_[hidden]

Availabe At:
http://tinyurl.com/6qvrd

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.

2) Typeof
Author: Arkadiy Vertleyb
Arkadiy Vertleyb, Peder Holt
vertleyb_at_[hidden]
peder.holt_at_[hidden] 

Review Manager:
Andy Little 
andy_at_[hidden]

Available:
http://boost-sandbox.sourceforge.net/vault/ (typeof.zip)

The proposed Typeof library implements the
functionality of the non-standard
typeof() operator.  Depending on the
compiler, it utilizes one of the
following three methods: 1) Forwards to the
non-standard typeof extension, usually called
__typeof__, on the compilers where such
extension is available;
2) Utilises a loophole, available on the
Microsoft vc6.5, vc7.0, and vc7.1; 3) Emulates
typeof by the means of template and
preprocessor metaprogramming
for the compilers that do not fall into
above two categories, such as vc8.0
beta, etc.  This method is rather portable,
and can also be used on the
compilers that implement the __typeof__
as a language extension, when
compiling with language extensions switched off.
The emulation mode is currently working
with vc7.1, vc8.0 beta, and gcc
3.3/3.4; The MS-specific trick is
working with vc6.5, 7.0, and  7.1.
The __typeof__ extension forwarding is
working with gcc 3.3/3.4 and Metrowerks.

3) Function Types
Author: Tobias Schwinger
tschwinger_at_[hidden]

Review Manager:
John Maddock
john_at_[hidden] 

Available at:
http://tinyurl.com/4oe7q

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.

4) Logging Library
Author: 
John Torjo 
john.lists_at_[hidden]

Review Manaer: 
Hartmut Kaiser
hartmut.kaiser_at_[hidden]

Available at:
http://torjo.com/code/logging-v132.zip

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....";

Additions to v1.3.2
- 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

5) Policy Pointer
Author: David B. Held
dheld_at_[hidden]

Review Manager:
Gennadiy
gennadiy.rozental_at_[hidden]

Available At:
Boost Sandbox under policy_ptr

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.

6) Fixed Strings

Author: 
Reece Dunn
msclrhd_at_[hidden]

Review Manager:
Beman Dawes
bdawes_at_[hidden]

Available At:
boosts-sandbox/boost/fixed_string

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.

7)Intrusive

Author:
Olaf Krzikalla
krzikalla_at_[hidden]

Review Manager:
Needed

Available At:
http://people.freenet.de/turtle++/intrusive.zip

Library presenting some intrusive
containers to the world of C++. 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.

8) TR1
9) Fusion

10) Factory
Author:
Federico Stella
f.stella_at_[hidden] 

11) Interfaces

Author:
Jonathan Turkanis <technews_at_[hidden]> 

Review Manager:
Needed

Available:
http://www.kangaroologic.com/interfaces

"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."