[boost] Review Wizard Status Report

From: Tom Brinkman (reportbase_at_[hidden])
Date: 2005-04-25 22:30:50

Review Wizard Status Report

According to my notes, the following five
libraries are up for review in the following
weeks.  

The Typeof, Function Types and Logging libraries 
still need review manager volunteers.

I'm sorry if I missed your email or posting about volunteering
and I have not included you here, please
email me again at reportbase_at_google.com.  I'll
make shur that I keep this status report
up to date.

I will try to post this document weekly until
this set of libraries have completed their 
reviews.

I will also try to respond to questions about
this schedule in the developers message board,
rather than through private emails.  

Keep your suggestions coming about how to improve the
review process.

1) FOREACH Macro  (Starts: 25-Apr-2005; Ends: 1-May-2005)
2) Typeof (Review Manage Needed)
3) Singleton 
4) Function Types (Review Manage Needed)
5) Logging (Review Manage Needed)

1) FOREACH Macro
Author: Eric Niebler
eric_at_[hidden]

Review Manager: Gennadiy
gennadiy.rozental_at_[hidden] 

Available At:
http://boost-sandbox.sourceforge.net/vault/index.php?directory=eric_niebler,
foreach.zip

BOOST_FOREACH is a macro that makes it 
simple to iterate over STL
containers, ranges, arrays and null-terminated 
strings. Its performance
approaches that of the hand-coded 
equivalent loop. BOOST_FOREACH uses
Boost.Range can be extended to 
iterating user-defined collections by
extending Boost.Range. Documentation is at 
http://boost-sandbox.sourceforge.net/libs/foreach

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

Review Manager: Needed

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

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

Review Manager: Needed

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.

5) Logging LIbrary
Author: John Torjo <john.lists_at_[hidden]>

Review Manaer: Needed

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