wiki:LibrariesUnderConstruction

Version 4 (modified by viboes, 14 years ago) ( diff )

Adding a Libraries Listed by Category section

  1. Libraries Under Construction
    1. Boost.AllocPlus
    2. Boost.Chono
    3. Boost.ConstantTimeSize
    4. Boost.Coroutines
    5. Boost.Dataflow
    6. Boost.Egg
    7. Boost.Endian
    8. Boost.Extension
    9. Boost.Fiber
    10. Boost.Fsm
    11. Boost.InterThreads
    12. Boost.ITL
    13. Boost.Log
    14. Boost.Mirror
    15. Boost.Move
    16. Poet
    17. Boost.Process
    18. Boost.Reflection
    19. Boost.Tree
  2. Other Open Source libraries
    1. ASL
    2. TBB
  3. Libraries Under Discussion
    1. Geometry
  4. Libraries Wish list
    1. AccummulatorsExt
    2. DenseSet
    3. Frames
    4. StableVector
    5. ThreaderJoiner
  5. Abandoned
  6. Libraries Listed by Category
    1. String and text processing
    2. Containers
    3. Iterators
    4. Algorithms
    5. Function Objects and higher-order programming
    6. Generic Programming
    7. Template Metaprogramming
    8. Preprocessor Metaprogramming
    9. Concurrent Programming
    10. Math and numerics
    11. Correctness and testing
    12. Data structures
    13. Image processing
    14. Input/Output
    15. Inter-language support
    16. Memory
    17. Parsing
    18. Programming Interfaces
    19. System
    20. Portability
    21. Miscellaneous
    22. Broken compiler workarounds

WARNING: The contents of this page could be incomplete and outdated. Please help us to improve this page by modifying it directly or posting on the Boost mailing lists ​boost-AT-lists.boost.org or ​boost-users-AT-lists.boost.org with the prefix `[LibrariesUnderConstruction].

See Boost Releases documentation for the list of libraries Boost by release. See Boost Review Schedule for Boost ongoing details.

Most of the ongoing libraries are stored on the ​SVN Sandbox, the ​Boost Vault or on specific sites.

Libraries Under Construction

This page is an index page for libraries under construction.

Boost.AllocPlus

Boost.Chono

  • Author(s): Beman Dawes
  • Version:
  • State:
  • Last upload:2008 Nov 26
  • Links: ​Boost Sandbox
  • Description: The Boost Chrono library provides:
    • The C++0x Standard Library's time utilities, including:
      • Class template duration
      • Class template time_point
      • Clocks:
        • system_clock
        • monotonic_clock
        • high_resolution_clock
    • Class template timer, with typedefs:
      • system_timer
      • monotonic_timer
      • high_resolution_timer
    • Process clocks and timers:
      • process_clock, capturing real, user-CPU, and system-CPU times.
      • process_timer, capturing elapsed real, user-CPU, and system-CPU times.
      • run_timer, convenient reporting of process_timer results.
    • The C++0x Standard Library's compile-time rational arithmetic.

Boost.ConstantTimeSize

  • Author(s): Vicente J. Botet Escriba
  • Version: 0.1
  • State: Stable
  • Last upload:2008 Oct 14
  • Links: ​Boost Vault ​Boost Sandbox
  • Description: Boost.ConstantTimeSize defines a wrapper to the STL container list giving the user the choice for the complexity of the size function: linear time, constant time or quasi-constant.

In future versions the library could include a similar wrapper to slist.

Boost.Coroutines

  • Author(s): Giovanni P. Deretta
  • Version:
  • State:
  • Last upload:2008 Mars 05
  • Links: ​Boost Sandbox ​Boost Vault
  • Description: The Boost.Coroutine library contains a family of class templates that wrap function objects in coroutines. Coroutines are a generalization of subroutines that can return and be reentered more than once without causing the destruction of automatic objects.

Coroutines are useful whenever it is necessary to keep state across a function call, a job usually reserved to stateful function objects.

Boost.Dataflow

  • Author(s): Stjepan Rajko
  • State: Rewriting ongoing
  • Version:
  • Last upload:
  • Links: ​Documentation ​Boost Sandbox
  • Description: Dataflow is a generic library for dataflow programming. Dataflow programs can typically be expressed as a graph in which vertices represent components that process data, and edges represent the flow of data between the components. As such, dataflow programs can be easily reconfigured by changing the components and/or the connections.

Boost.Egg

  • Author(s): Shunsuke Sogame
  • State:
  • Version: 0.91.0
  • Last upload: 30 Mars 2008
  • Links: ​Documentation ​SVN repository ​Boost Vault
  • Description: Egg is a header-only library for building Polymorphic Function Object which can be used with Boost.Lambda. Such a function object is called a Major Function Object. Egg mainly provides three components:
    • Function Builders which build Little Functions into Major Function Objects.
    • Function Adaptors which take Polymorphic Function Objects then return adapted ones.
    • Function Objects which are ports of famous function templates.

Boost.Endian

  • Author(s): Beman Dawes
  • Version:
  • State:
  • Last upload:2008 Nov 26
  • Links: ​Boost Sandbox
  • Description: Provides integer-like byte-holder binary types with explicit control over byte order, value type, size, and alignment. Typedefs provide easy-to-use names for common configurations.

These types provide portable byte-holders for integer data, independent of particular computer architectures. Use cases almost always involve I/O, either via files or network connections. Although portability is the primary motivation, these integer byte-holders may also be used to reduce memory use, file size, or network activity since they provide binary integer sizes not otherwise available.

Boost.Extension

  • Author(s): Jeremy Pack
  • Version:
  • State:
  • Last upload:2008 Nov 26
  • Links: ​Blog ​Download ​Headers Boost Sandbox ​Libs Boost Sandbox
  • Description: The Boost.Extension library has been developed to ease the development of plugins and similar extensions to software using shared libraries. Classes, functions and data can be made available from shared libraries and loaded by the application.

Boost.Fiber

  • Author(s): Oliver Kowalke
  • Version:
  • State:
  • Last upload:2008 Oct 30
  • Links: ​Boost Vault
  • Description: Boost.Fiber implements lightweight threads of execution - so called fibers

Boost.Fsm

  • Author(s): Andrey Semashev
  • State:
  • Version:
  • Last upload:
  • Links: ​Boost Vault
  • Description:The Boost.FSM library is an implementation of FSM (stands for Finite State Machine) programming concept.

There are many cases when a developer would like to distinguish behaviour of a given object depending on some conditions or its internal state. For example, while developing software to control an charging turnstile a programmer would like to separate states in which the turnstile may persist: an idle state, when the device awaits for another passenger that would like to pass; a processing state, when the passenger have come and put his ticket into the device; and the passing state, when the turnstile lets the passenger pass through. In fact, each state describes a different reaction of the machine at the same events. That's why a passenger may only pass after paying for ticket. Obviously, the turnstile have to be able to change its internal state in order to function properly, this is called state switching or transitions between states (or just transitions for short). This implementation is aimed to ease the creation of such state machines in C++. It supports constructing passive automatons (which means that every action the machine performs is a response to some external event) with finite number of states and finite number of transitions (that is why they are called finite state machines). The main goals of the library are:

  • Simplicity. It should be very simple to create state machines using this library.
  • Performance. The state machine infrastructure should not be very time and memory-consuming in order to be applicable in more use cases.
  • Extensibility. A developer may want to add more states to the existing state machine, for example, the maintenance state for the turnstile mentioned above, and this addition should be relatively safe since it shouldn't interfere with the existing states. The developer should also be able to specify additional transitions and events for the machine with minimum modifications to the existing code.

Boost.InterThreads

  • Author(s): Vicente J. Botet Escriba
  • Version: 0.1
  • State: Not stable
  • Last upload: 2008 Nov 26
  • Links: ​Boost Vault ​Boost Sandbox
  • Description: Boost.InterThreads extends Boost.Threads adding some features:
    • thread decorator: thread_decorator allows to define setup/cleanup functions which will be called only once by thread: setup before the thread function and cleanup at thread exit.
    • thread specific shared pointer: this is an extension of the thread_specific_ptr providing access to this thread specific context from other threads. As it is shared the stored pointer is a shared_ptr instead of a raw one.
    • thread keep alive mechanism: this mechanism allows to detect threads that do not prove that they are alive by calling to the keep_alive_point regularly. When a thread is declared dead a user provided function is called, which by default will abort the program.
    • thread tuple: defines a thread group where the number of threads is know statically and the threads are created at construction time.
    • set_once: a synchronizer that allows to set a variable only once, notifying to the variable value to whatever is waiting for that.
    • thread_tuple_once: an extension of the boost::thread_tuple which allows to join the thread finishing the first, using for that the set_once synchronizer.
    • thread_group_once: an extension of the boost::thread_group which allows to join the thread finishing the first, using for that the set_once synchronizer.

thread_decorator and thread_specific_shared_ptr are based on the original implementation of threadalert written by Roland Schwarz.

Boost.ITL

  • Author(s): Joachim Faulhaber
  • Version:
  • State:
  • Last upload: 2008 Nov 26
  • Links: ​Home Page ​Online Documentation ​Boost Sandbox
  • Description: The Interval Template Library (ITL) offers intervals and two kinds of interval containers: interval_sets and interval_maps.

Boost.Log

  • Author(s): Andrey Semashev `​andrey.semashev__AT__gmail.com
  • Version:
  • State:
  • Last upload: 2008 Nov 28
  • Links: ​Home Page
  • Description: This library aims to make logging significantly easier for the application developer. It provides a wide range of out-of-box tools, along with public interfaces ready to be used to extend the library. The main goals of the library are:
    • Simplicity. A small example code snippet should be enough to get the feel of the library and be ready to use its basic features.
    • Extensibility. A user should be able to extend functionality of the library with regard to collecting and storing information into logs.
    • Performance. The library should make as least performance impact on the user's application as possible.

Boost.Mirror

  • Author(s): Matus Chochlik
  • Version: 0.3
  • Last upload:
  • Links: ​Boost Vault ​Boost Sandbox
  • Description: The aim of the <libraryname>Mirror</libraryname> library is to provide useful meta-data at both compile-time and run-time about common C++ constructs like namespaces, types (and as an important special case <code>typedef</code>-ined types), classes and their base classes and member attributes, instances, etc. and to provide uniform and generic interfaces for their introspection.

Boost.Move

  • Author(s): Adobe
  • Version:
  • State: stable
  • Last upload:
  • Links: ​Boost Sandbox
  • Description: User defined types often have remote parts either because they are implemented using a pointer-to-implementation or are variable sized. Such objects can be expensive to copy and are often copied unnecessarily when they are returned from functions or stored in other objects or containers. Boost.Move is a collection of utilities to implement types which can be moved to elide copying in such situations as well as utilities to assist in moving value.

Poet

  • Author(s): Frank Mori Hess
  • Version:
  • State:
  • Last upload:
  • Links: ​Home Page
  • Description: libpoet is a C++ parallel programing library. It provides support for easily creating active objects, creating monitor objects, and automatically validating mutex locking order.

Active objects provide concurrency and thread-safety, since each active object executes in its own thread. Futures are employed to communicate with active objects in a thread-safe manner. To learn more about the active object concept, see the paper "Active Object, An Object Behavioral Pattern for Concurrent Programming." by R. Greg Lavender and Douglas C. Schmidt. Some of the more important active object classes in libpoet are poet::active_function, poet::future, and poet::scheduler.

Monitor objects provide thread-safety via automatically locked access to an object. See the paper "Monitor Object, An Object Behavioral Pattern for Concurrent Programming" by Douglas C. Schmidt for more information about monitor objects. The poet::monitor_ptr, poet::monitor, and poet::monitor_base classes in libpoet provide support for monitor objects.

Finally, the poet::acyclic_mutex class provides a wrapper for mutex classes which adds automatic validation of a program's mutex locking order. Following a consistent locking order ensures your program will not deadlock due to problems such as "deadly embrace" or the "dining philosophers" problem.

Boost.Process

  • Author(s): Julio M. Merino Vidal
  • Version: v0.1
  • State:
  • Last upload:
  • Links: ​Boost Sandbox
  • Description: Provides a flexible framework for the C++ programming language to manage running programs, also known as processes. Among other functionality, this includes the ability to manage the execution context of the currently running process, the ability to spawn new child processes, and a way to communicate with them them using standard C++ streams.

Boost.Reflection

  • Author(s): Jeremy Pack
  • Version:
  • State:
  • Last upload:2008 Aug 08
  • Links: ​Blog ​Download ​Boost Sandbox Headers ​Boost Sandbox
  • Description: The goal of this library is to provide runtime reflection for C++ classes, and to allow the same across shared library boundaries. It is an offshoot of the Extension library, which provides dynamic class loading across shared libraries.

Boost.Reflection does not provide automatic reflection of classes. Instead, the class data must be manually reflected. This does offer some benefits however:

  • This can result in better performance, since only the necessary functions are reflected.
  • Arbitrary classes can be reflected without modification.
  • It is possible to make a reflected interface that is quite different from the original interface.

Boost.Tree

Other Open Source libraries

This page contains other libraries that work well with Boost.

ASL

  • Author(s): Sean Parent and Mat Marcus - Adobe
  • Version: 1.0.39
  • State: Released
  • Last upload: November 6, 2008
  • Links: ​Home page
  • Description: Adobe Source Libraries (ASL) provides peer-reviewed and portable C++ source libraries. The libraries are intended to be widely useful, leveraging and extending both the C++ Standard Library and the Boost Libraries.

TBB

  • Author(s): Intel
  • Version: 2.1
  • State: stable release
  • Last upload: June 7, 2008
  • Links: ​Home page
  • Description: Intel® Threading Building Blocks (TBB) offers a rich and complete approach to expressing parallelism in a C++ program. It is a library that helps you take advantage of multi-core processor performance without having to be a threading expert. Threading Building Blocks is not just a threads-replacement library. It represents a higher-level, task-based parallelism that abstracts platform details and threading mechanism for performance and scalability and performance.

Libraries Under Discussion

This page is an index page for discussion of possible libraries as people get their ideas together.

Geometry

  • Description: geometry template library (manhattan/45-degree polygon ops)
  • Discussion:
  • Participants:
  • Links: ​Boost Vault

Libraries Wish list

This page contains libraries that people have requested of Boost (mostly on the developer's mailing list). If you're looking for a project, this is a good place to start.

AccummulatorsExt

  • Suggested by: Vicente J. Botet Escriba
  • Description: Adding sliding, dependable and cyclic accumulators to Boost.Accumulators.

The accumulator library allows to determine dependency between accumulator, but not between accumulator_sets. I would like to define an accumulator_set c so when we cumulate in two others c1 and c2 accumulator_set we cumulate also in c, some thing like: 

typedef dependable_accumulator_set <double, ...> dependable_acc_type;

dependable_acc_type c1, c2;
dependable_acc_type c=c1+c2

dependable_acc_type c3;

c+=c3;

c1(1);
c2(1);
c3(2);
assert(count(c)==3);
assert(sum(c)==4);

How dependable_accumulator_set can be defined? Here follows the interfaces of such a class and the pseudo code, I've named the class dependable_accumulator_set, sorry but I have not found a shorter and better name (may be observed/listened?) 

template <typename T, typename F, typename W>
class dependable_accumulator_set : public acumulator_set<T,F,W>
{
public:
    dependable_accumulator_set();
    void add_dependent(dependable_acumulator_set&);
    void remove_dependent(dependable_acumulator_set&);

    template<typename A1>
    void operator ()(A1 const &a1) {
        for (acc in dependents) {
            acc(a1);
        }
        this->accumulator_set_type::operator()(a1);
    }
    dependable_accumulator_set<T,F,W>& operator+=(dependable_accumulator_set<T,F,W>);
    dependable_accumulator_set<T,F,W>& operator-=(dependable_accumulator_set<T,F,W>);
};

template <typename T, typename F, typename W>
dependable_accumulator_set<T,F,W> 
operator+()(dependable_accumulator_set<T,F,W>,dependable_accumulator_set<T,F,W>);

In addition another variant could allow to cumulate on a sliding window, e.g. on the last N cumulated values. There is already a tail accumulator, but I don't know how to define a min_tail accumulator with the current framework. This class could behaves like: 

typedef sliding_accumulator_set <double, ...> sliding_acc_type;
sliding_acc_type c(window=2);
c(1);
c(5);
c(2);
assert(count(c)==3);
assert(sum(c)==7);
assert(min(c)==2);

We can state the sliding window at compile (template parameter) or run time (constructor parameter). 

template <std::size Window, typename T, typename F, typename W>
class static_sliding_accumulator_set;

template <typename T, typename F, typename W>
class sliding_accumulator_set;

Of course the complexity of the sliding accumulators operations is increased. Another variant could be also to have a temporary accumulator that cyclically push its current value on another accumulator. It will also interesting to have a sliding, dependable and cyclic accumulator set. It would be great to integrate these features on a unique class (accumulator_set?) in a clean way. 

template <typename T, typename F, typename W, 
          typename DependablePolicy, 
          typename SlicingPolicy, 
          typename CyclicPolicy>
class accumulator_set;

DenseSet

  • Suggested by: Vicente J. Botet Escriba
  • Description: Implementation of dense set of integers using intervals.

Frames

  • Suggested by: Vicente J. Botet Escriba
  • Description: in a frame library which will be based on an extension of the archive concept. The saving archive concept allows to save serializable data at the end of the archive, and the loading archive concept allows to read serializable data from the beginning of the archive. The saving frame concept will allows to save serializable data either at the end or the begin of the frame, and the loading frame concept allows to read serializable data from the beginning or the end of the archive.

StableVector

  • Suggested by: Joaquín M López Muñoz
  • Links: ​Stable Vectors
  • Description: a container mimicking the interface of std::vector except that it provides iterator and reference stability at the expense of losing memory contiguity.

ThreaderJoiner

Abandoned

Libraries Listed by Category

String and text processing

Containers

Iterators

Algorithms

Function Objects and higher-order programming

Generic Programming

Template Metaprogramming

Preprocessor Metaprogramming

Concurrent Programming

Math and numerics

Correctness and testing

Data structures

Image processing

Input/Output

Inter-language support

Memory

Parsing

Programming Interfaces

System

Portability

Miscellaneous

Broken compiler workarounds

Note: See TracWiki for help on using the wiki.