From cfd127be486a3a0200ba6025a053501ab9e90b32 Mon Sep 17 00:00:00 2001
From: Ronald Garcia
We need experienced review managers. 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 or library +contributors. If you can serve as review manager for any of them, +email Ron Garcia or John Phillips, "garcia at cs dot indiana dot edu" +and "jphillip at capital dot edu" respectively.
+A link to this report will be posted to www.boost.org. +If you would like us to make any modifications or additions to this +report before we do that, please email Ron or John.
+If you're library author and plan on submitting a library for review +in the next 3-6 months, send Ron or John a short description of your +library and we'll add it to the Libraries Under Construction below. +We know that there are many libraries that are near completion, but we +have hard time keeping track all of them. Please keep us informed +about your progress.
+Author: | Andrey Semashev | +
---|---|
Review Manager: | Martin Vuille | +
Download: | Boost Sandbox Vault | +
Description: | The Boost.FSM library is an implementation of FSM (stands for +Finite State Machine) programming concept. The main goals of the +library are: +
|
+
Author: | Johan RÃ¥de | +
---|---|
Review Manager: | Need Volunteer | +
Download: | Boost Sandbox Vault | +
Description: | The Floating Point Utilities library contains the following: +
|
+
Author: | Steven Watanabe | +
---|---|
Review Manager: | Need Volunteer | +
Download: | Boost Sandbox Vault | +
Description: | The built in C/C++ switch statement is very efficient. Unfortunately, +unlike a chained if/else construct there is no easy way to use it when +the number of cases depends on a template parameter. The Switch library +addresses this issue. | +
Author: | Andrew Sutton | +
---|---|
Review Manager: | Jeremy Siek | +
Download: | http://svn.boost.org/svn/boost/sandbox/graph-v2 | +
Description: | A number of additions and modifications to the Property Map Library, +including: +
|
+
Author: | Andrew Sutton | +
---|---|
Review Manager: | Jeremy Siek | +
Download: | http://svn.boost.org/svn/boost/sandbox/graph-v2 | +
Description: | A number of additions and modifications to the Graph Library, +including: +
|
+
Author: | Tobias Schwinger | +
---|---|
Review Manager: | John Torjo | +
Download: | http://boost-consulting.com/vault/index.php?&direction=0&order=&directory=X-Files | +
Description: | A brute-force solution to the forwarding problem. | +
Author: | Tobias Schwinger | +
---|---|
Review Manager: | John Torjo | +
Download: | http://boost-consulting.com/vault/index.php?&direction=0&order=&directory=X-Files | +
Description: | Three thread-safe Singleton templates with an +easy-to-use interface. | +
Author: | Tobias Schwinger | +
---|---|
Review Manager: | John Torjo | +
Download: | http://boost-consulting.com/vault/index.php?&direction=0&order=&directory=X-Files | +
Description: | Generic factories. | +
Author: | Ben Hanson | +
---|---|
Review Manager: | Need Volunteer | +
Download: | http://boost-consulting.com/vault/index.php?action=downloadfile&filename=boost.lexer.zip&directory=Strings%20-%20Text%20Processing& | +
Description: | A programmable lexical analyser generator inspired by 'flex'. +Like flex, it is programmed by the use of regular expressions +and outputs a state machine as a number of DFAs utilising +equivalence classes for compression. | +
Author: | Frank Hess | +
---|---|
Review Manager: | Need Volunteer | +
Download: | http://www.boost-consulting.com/vault/index.php?&direction=0&order=&directory=thread_safe_signals | +
Description: | A thread-safe implementation of Boost.signals that +has some interface changes to accommodate thread safety, mostly with +respect to automatic connection management. | +
Author: | John Torjo | +
---|---|
Review Manager: | Need Volunteer | +
Download: | http://torjo.com/log2/ | +
Description: | Used properly, logging is a very powerful tool. Besides aiding +debugging/testing, it can also show you how your application is +used. The Boost Logging Library allows just for that, supporting +a lot of scenarios, ranging from very simple (dumping all to one +destination), to very complex (multiple logs, some enabled/some +not, levels, etc). It features a very simple and flexible +interface, efficient filtering of messages, thread-safety, +formatters and destinations, easy manipulation of logs, finding +the best logger/filter classes based on your application's +needs, you can define your own macros and much more! | +
Author: | JoaquÃn M López Muñoz | +
---|---|
Review Manager: | Need Volunteer | +
Download: | http://www.boost-consulting.com/vault/index.php?action=downloadfile&filename=flyweight.zip&directory=Patterns | +
Description: | Flyweights are small-sized handle classes granting +constant access to shared common data, thus allowing for the +management of large amounts of entities within reasonable memory +limits. Boost.Flyweight makes it easy to use this common +programming idiom by providing the class template flyweight<T>, +which acts as a drop-in replacement for const T. | +
Author: | Daniel James | +
---|---|
Review Manager: | Need Volunteer | +
Download: | http://www.boost-consulting.com/vault/index.php?action=downloadfile&filename=unordered.zip&directory=Containers | +
Description: | An implementation of the unordered containers specified +in TR1, with most of the changes from the recent draft standards. | +
Author: | Stjepan Rajko | +
---|---|
Description: | The Dataflow library provides generic support for data +producers, consumers, and connections between the two. It also +provides layers for several specific dataflow mechanisms, namely +Boost.Signals, VTK data/display pipelines, and plain +pointers. The Dataflow library came out of the Signal Network +GSoC project, mentored by Doug Gregor. | +
Status: | I am polishing the Dataflow library for submission, and am expecting +to add it to the review queue in the next couple of months. +I am currently ironing out some faults in the design of the library, +filling in missing features, and testing it on / adapting it to +different dataflow mechanisms (currently VTK and soon +Boost.Iostreams). As soon as I'm pretty sure that things are going +the right way, I'll submit this to the review queue while I do the +finishing touches. | +
Author: | Robert Kawulak | +
---|---|
Download: | http://rk.go.pl/f/constrained_value.zip +http://rk.go.pl/r/constrained_value (Documentation) + |
+
Description: | The Constrained Value library contains class templates +useful for creating constrained objects. The simplest example +of a constrained object is hour. The only valid values for an hour +within a day are integers from the range [0, 23]. With this library, +you can create a variable which behaves exactly like int, but does +not allow for assignment of values which do not belong to the +allowed range. The library doesn't focus only on constrained +objects that hold a value belonging to a specified range (i.e., +bounded objects). Virtually any constraint can be imposed using +appropriate predicate. You can specify what happens in case of +assignment of an invalid value, e.g. an exception may be thrown or +the value may be adjusted to meet the constraint criterions. | +
Status: | I'm planning to finish it in 1-2 months. | +
Please let us know of any libraries you are currently +developing that you intend to submit for review.
+- | -Home | -- Libraries | -- People | -FAQ | -More | -
cvs diff -du
);
- if you can, send a patch relative to the current CVS state. A canonical
-example of creating a patch file follows (let's assume that you've found
-a bug in the file intentional_bug.hpp
:intentional_bug.hpp
from CVS.intentional_bug.hpp
to a file called intentional_bug.hpp.orig
.intentional_bug.hpp
.diff -du intentional_bug.hpp.orig intentional_bug.hpp > intentional_bug.hpp.patch
" from the command prompt.typename
,
- etc.), and you are willing to make a fix, either make your changes locally
- and contact the library author(s)/maintainer(s) about it, or go ahead and
- check the fix into CVS, but post a notification about it to the
- boost mailing
- list (if the author is not very active on the list, you also might want
- to consider cc
'ing him as well); Revised 18 January, 2002 -
- -© Copyright Aleksey Gurtovoy -2002
-Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE_1_0.txt or -copy at www.boost.org/LICENSE_1_0.txt) -
- -- | -Home | -- Libraries | -- People | -FAQ | -More | -
If you have an idea for a feature or improvement to an existing Boost library -- go ahead and post it to either -boost-users list -or boost mailing list -(if you are posting for the first time, please read our -discussion policy -before you actually post).
-You can also use our -feature request tracking facility at SourceForge, but experience has shown -that posting to either of the mailing lists is usually a more effective way to -get attention of boost developers.
-If your proposal has its merits, it's very likely that it will generate a -constructive discussion that might actually result in (sometimes substantial) -improvement of the library - and your name being put on the library's - -Acknowledgements section!
-Revised 26 November, 2003 -
- -© Copyright Aleksey Gurtovoy -2002
-Distributed under the Boost Software License, Version 1.0. -(See accompanying file LICENSE_1_0.txt or -copy at www.boost.org/LICENSE_1_0.txt) -
- - - - \ No newline at end of file From 09b9373d596ca64a06483d45bcbc9db8b4c3e136 Mon Sep 17 00:00:00 2001 From: Daniel James- | Home | -Libraries | -People | -FAQ | -More | -
The interface specifications for boost.org library components (as well as for -quality software in general) are conceptually separate from implementations of -those interfaces. This may not be obvious, particularly when a component is -implemented entirely within a header, but this separation of interface and -implementation is always assumed. From the perspective of those concerned with -software design, portability, and standardization, the interface is what is -important, while the implementation is just a detail.
-Dietmar Kühl, one of the original boost.org contributors, comments "The -main contribution is the interface, which is augmented with an implementation, -proving that it is possible to implement the corresponding class and providing a -free implementation."
- -There may be a need for multiple implementations of an interface, to -accommodate either platform dependencies or performance tradeoffs. Examples of -platform dependencies include compiler shortcomings, file systems, thread -mechanisms, and graphical user interfaces. The classic example of a performance -tradeoff is a fast implementation which uses a lot of memory versus a slower -implementation which uses less memory.
-Boost libraries generally use a configuration -header, boost/config.hpp, to capture compiler and platform -dependencies. Although the use of boost/config.hpp is not required, it is -the preferred approach for simple configuration problems.
-The Boost policy is to avoid platform dependent variations in interface -specifications, but supply implementations which are usable over a wide range of -platforms and applications. That means boost libraries will use the -techniques below described as appropriate for dealing with platform -dependencies.
-The Boost policy toward implementation variations designed to enhance -performance is to avoid them unless the benefits greatly exceed the full -costs. The term "full costs" is intended to include both -tangible costs like extra maintenance, and intangible cost like increased -difficulty in user understanding.
- -Several techniques may be used to provide implementation variations. Each is -appropriate in some situations, and not appropriate in other situations.
-The first technique is to simply not provide implementation variation at -all. Instead, provide a single general purpose implementation, and forgo -the increased complexity implied by all other techniques.
-Appropriate: When it is possible to write a single portable -implementation which has reasonable performance across a wide range of -platforms. Particularly appropriate when alternative implementations differ only -in esoteric ways.
-Not appropriate: When implementation requires platform specific -features, or when there are multiple implementation possible with widely -differing performance characteristics.
-Beman Dawes comments "In design discussions some implementation is often -alleged to be much faster than another, yet a timing test discovers no -significant difference. The lesson is that while algorithmic differences may -affect speed dramatically, coding differences such as changing a class from -virtual to non-virtual members or removing a level of indirection are unlikely -to make any measurable difference unless deep in an inner loop. And even in an -inner loop, modern CPUs often execute such competing code sequences in the -same number of clock cycles! A single general purpose implementation is -often just fine."
-Or as Donald Knuth said, "Premature optimization is the root of all -evil." (Computing Surveys, vol 6, #4, p 268).
-While the evils of macros are well known, there remain a few cases where -macros are the preferred solution:
----
-- Preventing multiple inclusion of headers via #include guards.
-- Passing minor configuration information from a configuration - header to other files.
-
Appropriate: For small compile-time variations which would -otherwise be costly or confusing to install, use, or maintain. More appropriate -to communicate within and between library components than to communicate with -library users.
-Not appropriate: If other techniques will do.
-To minimize the negative aspects of macros:
----
-- Only use macros when they are clearly superior to other - techniques. They should be viewed as a last resort.
-- Names should be all uppercase, and begin with the namespace name. This - will minimize the chance of name collisions. For example, the #include - guard for a boost header called foobar.h might be named BOOST_FOOBAR_H.
-
A library component can have multiple variations, each contained in its own -separate file or files. The files for the most appropriate variation are -copied to the appropriate include or implementation directories at installation -time.
-The way to provide this approach in boost libraries is to include specialized -implementations as separate files in separate sub-directories in the .ZIP -distribution file. For example, the structure within the .ZIP distribution file -for a library named foobar which has both default and specialized variations -might look something like:
---foobar.h // The default header file -foobar.cpp // The default implementation file -readme.txt // Readme explains when to use which files -self_contained/foobar.h // A variation with everything in the header -linux/foobar.cpp // Implementation file to replace the default -win32/foobar.h // Header file to replace the default -win32/foobar.cpp // Implementation file to replace the default-
Appropriate: When different platforms require different -implementations, or when there are major performance differences between -possible implementations.
-Not appropriate: When it makes sense to use more that one of the -variations in the same installation.
-Rather than have several implementation variations of a single component,
-supply several separate components. For example, the Boost library currently
-supplies scoped_ptr
and shared_ptr
classes rather than
-a single smart_ptr
class parameterized to distinguish between the
-two cases. There are several ways to make the component choice:
---
-- Hardwired by the programmer during coding.
-- Chosen by programmer written runtime logic (trading off some extra - space, time, and program complexity for the ability to select the - implementation at run-time.)
-
Appropriate: When the interfaces for the variations diverge, and when -it is reasonably to use more than one of the variations. When run-time selection -of implementation is called for.
-Not appropriate: When the variations are data type, traits, or -specialization variations which can be better handled by making the component a -template. Also not appropriate when choice of variation is best done by some -setup or installation mechanism outside of the program itself. Thus -usually not appropriate to cope with platform differences.
-Note: There is a related technique where the interface is specified as -an abstract (pure virtual) base class (or an interface definition language), and -the implementation choice is passed off to some third-party, such as a -dynamic-link library or object-request broker. While that is a powerful -technique, it is way beyond the scope of this discussion.
-Turning a class or function into a template is often an elegant way to cope -with variations. Template-based approaches provide optimal space and time -efficiency in return for constraining the implementation selection to compile -time.
-Important template techniques include:
----
-- Data type parameterization. This allows a single component to - operate on a variety of data types, and is why templates were originally - invented.
-- Traits parameterization. If parameterization is complex, bundling - up aspects into a single traits helper class can allow great variation - while hiding messy details. The C++ Standard Library provides - several examples of this idiom, such as
-iterator_traits<>
- (24.3.1 lib.iterator.traits) and char_traits<> (21.2 - lib.char.traits).- Specialization. A template parameter can be used purely for the - purpose of selecting a specialization. For example:
-----SomeClass<fast> my_fast_object; // fast and small are empty classes -SomeClass<small> my_small_object; // used just to select specialization-
Appropriate: When the need for variation is due to data type or -traits, or is performance related like selecting among several algorithms, and -when a program might reasonably use more than one of the variations.
-Not appropriate: When the interfaces for variations are -different, or when choice of variation is best done by some mechanism outside of -the program itself. Thus usually not appropriate to cope with platform -differences.
-Revised 02 October, 2003
- -© Copyright Beman Dawes 2001
- -Distributed under the Boost Software License, Version 1.0. (See - accompanying file LICENSE_1_0.txt or copy - at http://www.boost.org/LICENSE_1_0.txt) -
- - - - \ No newline at end of file From eaf201d7b0da99b1234a15b49a6e79ac98ef82d6 Mon Sep 17 00:00:00 2001 From: Ronald Garcia