wiki:ReviewScheduleLibraries

  1. Depends on not yet accepted libraries
    1. Boost.Fiber
  2. Unassigned review manager
    1. Boost.Algorithm.Sorting
    2. Boost.BlockPtr
    3. Boost.Network
    4. Boost.QVM
    5. Boost.Pimpl
    6. Boost.VariadicMacrosData
  3. Review Date pending
    1. Boost.AutoBuffer
    2. Boost.Stopwatches
  4. Review Scheduled
    1. Boost.Algorithm.String
    2. Boost.Integer.Endian
    3. Boost.Local
  5. Review on going
    1. Boost.Conversion
  6. Review results pending
    1. Boost.Containers
    2. Boost.LockFree
  7. Mini-review required Libraries
    1. Boost.Context
    2. Boost.Switch
  8. Accepted but Orphaned Libraries
    1. Boost.TimeSeries
  9. Accepted Libraries
    1. Boost.GIL.IO
    2. Boost.Heaps
    3. Boost.Log
  10. Included on Trunk
    1. Boost.Locale
    2. Boost.TypeTraits.Extensions
    3. Boost.TTI
    4. Boost.Move

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 `[ReviewScheduleLibraries].

Depends on not yet accepted libraries

Boost.Fiber

  • Author(s): Oliver Kowalke
  • Version:
  • State:
  • Last upload:2011 January 31
  • Inclusion date: ???
  • Depends on: Boost.Atomic
  • Fulfill review criteria checked by : ??? At:
    • Missing criteria
      • C1
  • Pre-reviewed by : ??? people
  • Review Manager: Needed
  • Expected review date: ???
  • Links: ​Boost Vault ​GitHub Sandbox
  • Categories: Concurrent Programming
  • Description: Boost.Fiber implements lightweight threads of execution - so called fibers

Unassigned review manager

Boost.Algorithm.Sorting

  • Author(s): Steven Ross
  • Last upload: 2009 Jan 13
  • Review Manager:
  • Expected review date: September 22, 2011 - October 1, 2011
  • Links: ​Bosst Vault
  • Categories: Algorithm
  • Description: The Sorting Algorithm Library provides a generic implementation of high-speed sorting algorithms that outperform those in the C++ standard in both average and worst case performance. These algorithms only work on random access iterators.

These algorithms are hybrids using both radix and comparison-based sorting, specialized to sorting common data types, such as integers, floats, and strings. These algorithms are encoded in a generic fashion and accept functors, enabling them to sort any object that can be processed like these basic data types.

Unlike many radix-based algorithms, the underlying Spreadsort algorithm is designed around worst-case performance, and performs better on chunky data (where it is not widely distributed), so that on real data it can perform substantially better than on random data. Conceptually, Spreadsort can sort any data for which an absolute ordering can be determined.

Boost.BlockPtr

  • Author(s): Phil Bouchard
  • Version:
  • State:
  • Last upload:
  • Inclusion date: ???
  • Depends on:
  • Fulfill review criteria checked by : ??? At:
    • Missing criteria
      • C1
  • Pre-reviewed by : ??? people
  • Review Manager: Needed
  • Expected review date: ???
  • Links: ​Sandbox
  • Categories: Memory
  • Description: Smart pointers are in general optimized for a specific resource (memory usage, CPU cycles, user friendliness, ...) depending on what the user need to make the most of. The purpose of this smart pointer is mainly to allocate the reference counter (or owner) and the object itself at the same time so that dynamic memory management is simplified thus accelerated and cheaper on the memory map.

Boost.Network

  • Author(s): Dean Michael Berris
  • Version: 0.7
  • State: Under development but usable
  • Last upload: 2010, October 10
  • Links: [​http://github.com/mikhailberis/cpp-netlib/downloads Downloads] ​Documentation
  • Categories: DataCommunication
  • Description:The cpp-netlib is a library that provides application layer protocol support using modern C++ techniques. It is light-weight, fast, cross-platform and is intended to be as easy to configure as possible.

Boost.QVM

  • Author(s): Emil Dotchevski
  • Version:
  • State:
  • Last upload: 2011 Feb 07
  • Inclusion date: ???
  • Depends on:
  • Fulfill review criteria checked by : ??? At:
    • Missing criteria
      • C1
  • Pre-reviewed by : ??? people
  • Review Manager: Needed
  • Expected review date: ???
  • Links: ​Web Page
  • Categories: Math And Numerics
  • Description: Boost QVM defines a set of generic functions and operator overloads for working with quaternions, vectors and matrices of static size. The library also defines vector and matrix data types, however it allows users to introduce their own types by specializing the q_traits, v_traits and m_traits templates.

Boost.Pimpl

  • Author(s): Vladimir Batov
  • Version:
  • State: Ready
  • Last upload:
  • Inclusion date: ???
  • Depends on:
  • Fulfill review criteria checked by : ??? At:
    • Missing criteria
      • C1
  • Pre-reviewed by : ??? people
  • Review Manager: Needed
  • Expected review date: ???
  • Links: ​Boost Vault ​Documentation
  • Categories: Memory
  • Description: The Pimpl idiom is a simple yet robust technique to minimize coupling via the separation of interface and implementation and then implementation hiding. This library provides a convenient yet flexible and generic deployment technique for the Pimpl idiom. It's seemingly complete and broadly applicable, yet minimal, simple and pleasant to use.

Boost.VariadicMacrosData

  • Author(s): Edward Diener
  • Version: 1.3
  • State:
  • Last upload: Feb 6, 2011
  • Links: ​Boost Sandbox
  • Categories: Preprocessor Metaprogramming
  • Description: The variadic macro data library, or VMD for short, is a library of macros which provide important functionality for variadic macros as well as integrating variadic macros with the Boost preprocessor library ( Boost PP ). It integrates with Boost PP without changing the latter library in any way.

The functionality of the library may be summed up as:

  1. Providing the means to extract any single token from the comma-separated data which makes up variadic macro data, as well as to calculate the number of tokens.
  2. Convert variadic macro data to and from Boost PP data types.
  3. Enhance the tuple functionality of Boost PP by providing a means of calculating the size of a tuple as well as by providing equivalent macros to Boost PP tuple macros which do not require the size of the tuple to be explicitly passed.

Review Date pending

This section contains an index of the libraries with a pending date.

Boost.AutoBuffer

  • Author(s): Thorsten Ottosen
  • Version:
  • State: Stable.
  • Last upload: 2009 Jan 13
  • Depends on:
  • Fulfill review criteria checked by : ??? At:
    • Missing criteria
      • C1
  • Pre-reviewed by : ??? people
  • Review Manager: Robert Stewart
  • Expected review date: ???
  • Links: ​Download
  • Categories: Data Structures
  • Description: Boost.AutoBuffer provides a container for efficient dynamic, local buffers. Furthermore, the container may be used as an alternative to std::vector, offering greater flexibility and sometimes better performance.

Boost.Stopwatches

  • Author(s): Vicente J. Botet Escribá
  • Version: 0.1.0
  • State: Not ready. Needs adaptation to new Chrono steady_clock interface.
  • Last upload:2010 September 7
  • Inclusion date: ???
  • Depends on:
  • Fulfill review criteria checked by : ??? At:
    • Missing criteria
      • C1
  • Pre-reviewed by : ??? people
  • Review Manager: Anthoni Williams
  • Expected review date: ???
  • Links: ​Documentation ​Download ​Boost Sandbox
  • Categories: System
  • Description: The Boost Stopwatches library provides:
    • Stopwatches:
      • stopwatch, capturing elapsed Clock times.
      • stopwatch_accumulator, capturing cumulated elapsed Clock times.
      • scoped helper classes allowing to pairwise start/stop operations, suspend/resume and resume/suspend a Stopwatch.
    • Stopwatch reporters:
      • stopwatch_reporter, convenient reporting of models of Stopwatch results.
      • stopclock<Clock> shortcut of stopwatch_reporter<stopwatch<Clock>>.
      • Support for wide characters (strings and ostreams).

Review Scheduled

This section contains an index for libraries that are scheduled.

Boost.Algorithm.String

  • Author(s): Marshall Clow
  • Review Manager: Dave Abrahams
  • Expected review date: September 22, 2011 - October 1, 2011
  • Links: ​Boost Vault
  • Categories: Algorithm
  • Description:

Boost.Integer.Endian

  • Author(s): Beman Dawes
  • Version:
  • State:
  • Last upload:2008 Nov 26
  • Inclusion date: ???
  • Depends on:
  • Fulfill review criteria checked by : ??? At:
    • Missing criteria
      • C1
  • Pre-reviewed by : ??? people
  • Review Manager: Joel Falcou
  • Expected review date: September 5, 2011 - September 14, 2011
  • Links: ​Boost Sandbox
  • Categories: Portability
  • 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.Local

Local functions are a form of information hiding and are useful for dividing procedural tasks into subtasks which are only meaningful locally, avoiding cluttering other parts of the program with functions, variables, etc unrelated to those parts. Local functions therefore complement other structuring possibilities such as namespaces and classes.

  • Local functions can access, or better bind, any of the variables from the enclosing scope. Furthermore, local functions defined within a member function can bind the enclosing object this.
  • The local function body is programmed using the usual C++ syntax.
  • Local functions can be passed as template parameters (so they can be conveniently passed to STL algorithms, etc).
  • However, local functions must be defined within a declarative context (e.g., at a point in the code where local variables can be declared) thus they cannot be defined within an expression.

In addition to local functions, this library also supports the following features:

  • Local blocks which define blocks of code that bind variables from the enclosing scope. Local blocks allow programmers to bind variables as constants (constant binding) so to prevent local chunks of code from modifying selected variables.
  • Local exits which define blocks of code that are executed when the enclosing scope is exited (again with support for constant binding and binding of the object this).

Review on going

Boost.Conversion

  • Author(s): Vicente J. Botet Escribá
  • Version: 0.4
  • State: Ready
  • Last upload:2009 October 27
  • Inclusion date: ???
  • Depends on:
  • Fulfill review criteria checked by : ??? At:
    • Missing criteria
      • C1
  • Pre-reviewed by : ??? people
  • Review Manager: Gordon Woodhull
  • Expected review date: August 20, 2011 - August 29, 2011
  • Links: ​Boost Vault ​Boost Sandbox ​Documentation
  • Categories: Utilities
  • Description: Generic explicit conversion between unrelated types.

The template function convert_to allows to convert a source type to a target type, using argument dependent lookup to select a specialized convert_to function if available. If no specialized convert_to function is available, boost::conversion::convert_to is used.

The generic convert_to function requires that the elements to be converted are assignable and copy constructible. It is implemented using the Target copy construction from a Source or the Source conversion operator Target - this is sometimes unavailable.

For standard types, we can not add a specialized convert_to function on the namespace std. The alternative to using argument dependent lookup in this situation is to provide a template specialization of boost::conversion::convert_to for every pair of standard types that requires a specialized convert_to.

Boost.Conversion provides:

  • a generic convert_to function which can be specialized by the user to make explicit conversion between unrelated types.
  • a generic assign_to function which can be specialized by the user to make explicit assignation between unrelated types.
  • a generic mca/tie function returning a wrapper which replace assignments by a call to assign_to and conversion operators by a call convert_to.
  • a generic convert_to_via function which convert a type From to another To using a temporary one Via.
  • conversion between std::complex of explicitly convertible types.
  • conversion between std::pair of explicitly convertible types.
  • conversion between boost::optional of explicitly convertible types.
  • conversion between boost::rational of explicitly convertible types.
  • conversion between boost::interval of explicitly convertible types.
  • conversion between boost::chrono::time_point and boost::ptime.
  • conversion between boost::chrono::duration and boost::time_duration.
  • conversion between boost::array of explicitly convertible types.
  • conversion between Boost.Fusion sequences of explicitly convertible types.

Review results pending

Boost.Containers

  • Author(s): Ion Gaztañaga
  • Version:
  • State: stable. Ready for review.
  • Last upload:
  • Inclusion date: 2009 Dec 14
  • Depends on: Boost.Move
  • Fulfill review criteria checked by : ??? At:
    • Missing criteria
      • C1
  • Pre-reviewed by : ??? people
  • Review Manager: John Maddock
  • Expected review date: August 3, 2011 - August 12, 2011
  • Links: ​Boost Sandbox ​Download ​Documentation
  • Categories: Container
  • Description: Containers of Movable objects emulation using Boost.Move

Boost.LockFree

  • Author(s): Tim Blechmann
  • Version: v0.2
  • State: Ready
  • Last upload: 2009 November 24
  • Inclusion date: ???
  • Depends on: Boost.Atomic
  • Fulfill review criteria checked by : ??? At:
    • Missing criteria
      • C1
  • Pre-reviewed by : ??? people
  • Review Manager: Hartmut Kaiser
  • Expected review date: July 18, 2011 - July 27, 2011
  • Links: ​Download ​Git ​Documentation
  • Categories: Concurrent Programming Containers
  • Description: Provides implementations of lock-free data structures. Lock-free data structures can be accessed by multiple threads without the necessity of blocking synchronization primitives such as guards. Lock-free data structures can be used in real-time systems, where blocking algorithms may lead to high worst-case execution times, to avoid priority inversion, or to increase the scalability for multi-processor machines.

The following data structures are provided:

  • boost::lockfree::fifo, a lock-free fifo queue
  • boost::lockfree::stack, a lock-free stack
  • boost::lockfree::atomic_int, an atomic integer class

Mini-review required Libraries

Boost.Context

  • Author(s): Oliver Kowalke
  • Version: 0.6.1
  • State: Stable
  • Last upload:February 2, 2011
  • Fulfill review criteria checked by : Vicente Botet At: February 2, 2011
  • Pre-reviewed by : ??? people
  • Review Manager: Giovanni Deretta
  • Expected review date:
  • Links: ​Boost Vault ​GitHub Sandbox
  • Categories: Concurrent Programming
  • Description: Boost.Context provides framework for user-context swapping/switching - has assembler for some platforms.

Boost.Switch

  • Author(s): Steven Watanabe

Accepted but Orphaned Libraries

Boost.TimeSeries

  • Author(s): Eric Niebler
  • State: Needs some rework before going to trunk.
  • Categories: Math And Numerics
  • Description:

Accepted Libraries

Boost.GIL.IO

Boost.Heaps

  • Author(s): Tim Blechmann
  • Version:
  • State: Ready
  • Last upload:
  • Inclusion date: ???
  • Depends on:
  • Fulfill review criteria checked by : ??? At:
    • Missing criteria
      • C1
  • Pre-reviewed by : ??? people
  • Review Manager: Andrew Sutton
  • Expected review date: May 30, 2011 - June 8, 2011
  • Links: ​Download
  • Categories: Containers
  • Description:

Boost.Log

  • Author(s): Andrey Semashev `​andrey.semashev__AT__gmail.com
  • Version: RC3
  • State: ​Accepted Provisionally
  • Review Manager: Vladimir Prus
  • Links:​Home Page ​Review Version
  • Categories: Input/Output
  • 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.

Included on Trunk

Boost.Locale

  • Author(s): Artyom Beilis
  • Version:
  • State:
  • Review Manager: Chad Nelson
  • Links: ​Download
  • Categories: String And Text Processing
  • Description: Boost.Locale is a library that brings high quality localization facilities in C++ way.

It uses std::locale, and std::locale facets in order to provide localization in transparent and C++ aware way to user..

Boost.TypeTraits.Extensions

  • Author(s): Frédéric Bron
  • Version: 1.0
  • State: Quite Stable
  • Review Manager: Joel Falcou
  • Review date: March 14, 2011 - March 18, 2011
  • Links: ​Boost Vault ​Boost Sandbox
  • Categories: Function Objects And Higher-order Programming
  • Description: The purpose of the addition is to add type traits to detect if types T and U are comparable in the sense of <, <=, >, >=, == or != operators, i.e. if t<u has a sens when t is of type T and u of type U (same for <=, >, >=, ==, !=).

The following traits are added: is_equal_to_comparable<T,U> is_greater_comparable<T,U> is_greater_equal_comparable<T,U> is_less_comparable<T,U> is_less_equal_comparable<T,U> is_not_equal_to_comparable<T,U>

The names are based on the corresponding names of the standard template library (<functional> header, section 20.3.3 of the standard).

The code has the following properties: * returns true if t<u is meaningful and returns a value convertible to bool * returns false if t<u is meaningless. * fails with compile time error if t<u is meaningful and returns void (a possibility to avoid compile time error would be to return true with an operator, trick but this has little sens as returning false would be better)

Boost.TTI

  • Author(s): Edward Diener
  • Version: 1.0
  • State:
  • Last upload: 2011 Feb 6
  • Links: ​Boost Sandbox
  • Categories: Generic Programming
  • Review Manager: Joel Falcou
  • Expected review date: July 1, 2011 - July 10, 2011
  • Description: The Type Traits Introspection library, or TTI for short, is a library of macros generating metafunctions, and a set of parallel nullary type metafunctions, which provide the ability to introspect by name the elements of a type at compile time.

Boost.Move

Last modified 11 years ago Last modified on Aug 21, 2011, 3:10:06 PM
Note: See TracWiki for help on using the wiki.