Marshall Clow | 21 Oct 00:14 2014
Picon

1.57.0 beta 1 is now available

Boost release 1.57.0 beta 1 is now available from SourceForge

See http://sourceforge.net/projects/boost/files/boost-binaries/1.57.0.beta.1/

This release contains no new libraries.

For details of what's in the release, see http://www.boost.org/users/history/version_1_57_0.html
Note that the links to files on this web page are for the final release - use the SourceForge link above to get the beta files.

Please download the beta, give it a try, and report any problems you encounter.

Thanks,

-- The Boost Release Team

P.S. There are a couple of known problems with this beta:
* There are problems building with MSVC 8.0
* There are some problems with range/detail/any_iterator.hpp.

These will be fixed before the release.
 
<div>
<span>Boost release 1.57.0 beta 1 is now available from SourceForge</span><br><br><span>See&nbsp;</span><a href="http://sourceforge.net/projects/boost/files/boost-binaries/1.57.0.beta.1/">http://sourceforge.net/projects/boost/files/boost-binaries/1.57.0.beta.1/</a><br><br>This release contains no new libraries.<br><br><div>
<div><div>For details of what's in the release, see&nbsp;<a href="http://www.boost.org/users/history/version_1_57_0.html">http://www.boost.org/users/history/version_1_57_0.html</a>.&nbsp;<br>Note that the links to files on this web page are for the final release - use the SourceForge link above to get the beta files.<br><br>Please download the beta, give it a try, and report any problems you encounter.<br><br>Thanks,<br><br>-- The Boost Release Team</div></div>
<div><br></div>
<div>P.S.<span class="Apple-tab-span">	</span>There are a couple of known problems with this beta:</div>
<div>* There are problems building with MSVC 8.0</div>
<div>* There are some problems with&nbsp;range/detail/any_iterator.hpp.</div>
<div><br></div>
<div>These will be fixed before the release.</div>
<div>&nbsp;</div>
</div>
</div>
Ron Garcia | 30 Aug 13:09 2014
Picon

Review Wizard Status Report for August 2014


==============================================
Review Wizard Status Report for August 2014
==============================================

News
====

1. Fiber Accepted Provisionally. January 2014.
2. Align Accepted. April 2014.
3. TypeIndex Accepted. May 2014.
4. Convert Accepted. June 2014.
5. Boost 1.56 Released -- New Libraries: Align, TypeIndex

Open Issues
===========

The following libraries have review managers, but have not yet been
scheduled for review:

* Range Extensions - added May 2012; review manager: Neil Groves.

The following libraries have been accepted to Boost, but have not yet
been integrated into Boost Git:

* Contract - accepted September 2012; author: Lorenzo Caminiti.

The following libraries have been accepted and submitted to Boost Git, but
have not yet appeared in a release:

* Convert - accepted June 2014; author: Vladimir Batov.

The following libraries have been accepted provisionally to Boost, but
have not been submitted for mini-review and full acceptance:

* Fiber - accepted provisionally January 2014; author Oliver Kowalke.

General Announcements
=====================

As always, 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, including library contributors, infrastructure
contributors, and other mailing list participants with a substantial
track record of constructive participation. If you can serve as review
manager for any of them, email Ron Garcia or John Phillips, "rxg at cs
dot ubc dot ca" and "johnphillipsithica at gmail dot com" respectively.

We are also suffering from a lack of reviewers. While we all
understand time pressures and the need to complete paying work, the
strength of Boost is based on the detailed and informed reviews
submitted by you.  If you are interested in reviewing a library but
won't have time during the review period, you can always prepare your
review ahead of time.  No rule says you can only work on a review
during the review period.

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, please
email Ron or John.

The review schedule is an unordered list of the libraries awaiting
review. As such, any library on the schedule can be reviewed once the
developer is ready, a review manager has been secured, and 
the manager, developer, and wizards agree on a date 
to schedule the review.

Review Schedule
===============

* Join (M)
* Sorting (M)
* Quaternions, Vectors, Matrices (M)
* Block Pointer (M)
* Singularity (M)
* Extended Complex Numbers (M)
* Metaparse (M)
* Boost.Range Extensions
* Nowide (M)
* Array (M)
* STL Extensions (M)
* Countertree (M)
* Process (M)
* Asynchronous File I/O (M)
* Application (M)
* Edit Distance (M)
* Mixin (M)

``(M)`` marks libraries that need review managers.

--------------------

Join
----
:Author: Yigong Liu

:Review Manager: Needed

:Download: http://channel.sourceforge.net/

:Description:
 Join is an asynchronous, message based C++ concurrency
 library based on join calculus. It is applicable both to
 multi-threaded applications and to the orchestration of asynchronous,
 event-based applications. It follows Comega's design and
 implementation and builds with Boost facilities. It provides a high
 level concurrency API with asynchronous methods, synchronous methods,
 and chords which are "join-patterns" defining the synchronization,
 asynchrony, and concurrency.

Sorting
-------
:Author: Steven Ross

:Review Manager: Needed

:Download: https://github.com/boost-vault/Sorting

:Description:
 A grouping of 3 templated hybrid radix/comparison-based sorting
 algorithms that provide superior worst-case and average-case
 performance to std::sort: integer_sort, which sorts fixed-size data
 types that support a rightshift (default of >>) and a comparison
 (default of <) operator.   float_sort, which sorts standard
 floating-point numbers by safely casting them to integers.
 string_sort, which sorts variable-length data types, and is optimized
 for 8-bit character strings.

 All 3 algorithms have O(n(k/s + s)) runtime where k is the number of
 bits in the data type and s is a constant, and limited memory overhead
 (in the kB for realistic inputs).   In testing, integer_sort varies
 from 35% faster to 2X as fast as std::sort, depending on processor,
 compiler optimizations, and data distribution.   float_sort is roughly
 70% faster than std::sort.   string_sort is roughly 2X
 as fast as std::sort.

Quaternions, Vectors, Matrices
------------------------------
:Author: Emil Dotchevski

:Review Manager: Needed

:Download: http://www.revergestudios.com/boost-qvm/

:Description:
 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.

Block Pointer
-------------
:Author: Phil Bouchard

:Review Manager: Needed

:Download: https://svn.boost.org/svn/boost/sandbox/block_ptr/

:Description:
 Deterministic memory manager of constant complexity capable of
 handling cyclic collections.

Singularity
-----------
:Author: Ben Robinson

:Review Manager: Needed

:Download: https://github.com/cppmaven/Singularity

:Description: The Singularity Design Pattern allows you to restrict
  any class to a single instance. Unlike the infamous Singleton,
  Singularity gives you direct control over the lifetime of the object,
  does not require you to grant global access to the object, nor does it
  limit you to the default constructor for that object.

Extended Complex Numbers
------------------------
:Author: Matthieu Schaller

:Review Manager: Needed

:Download: http://code.google.com/p/cpp-imaginary-numbers/

:Description:
 The library is an extension of the std::complex class addressing two issues:

 1.  The standard does not guaranty the behaviour of the complex class if 
     instantiated with types other than float/double/long double.

 2.  Some calculation where pure imaginary numbers (i.e. multiples of
     sqrt(-1)) appear are unnecessarily slowed down due to the lack of
     support for these numbers.  The code I submit contains two
     interleaved classes boost::complex and boost::imaginary which can
     be instantiated with any type T provided T overloads the usual
     arithmetic operators and some basic (real) mathematical functions
     depending on which complex function will be used.  It is thus an
     extended version of Thorsten Ottosen's n1869 proposal
     (http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1869.html)

Metaparse
---------
:Author: Abel Sinkovics

:Review Manager: Needed

:Download: http://abel.web.elte.hu/metaparse/metaparse.zip

:Description:

 Metaparse is a library for constructing parsers parsing at
 compile-time based on template metaprogramming. The parsers built with
 the library take boost::mpl::strings as input and can produce

 - types
 - objects (types with public static members)
 - callable C++ functions (types with public static method)
 - template metafunction classes

 as output (based on the input being parsed).

 On compilers supporting constexpr the library provides the following
 syntactic sugar for writing the input of the parsers:

 BOOST_STRING("this is a string")

 The library can be used for implementing DSLs in C++, including DSLs
 making C++ template metaprogramming easier (see examples).

Range Extensions
----------------
:Author: Akira Takahashi

:Review Manager: Neil Groves

:Download: https://github.com/faithandbrave/OvenToBoost

:Description:
 This project adds some features of the Oven Range Library to Boost.Range.
 Features:
 - Additional Range Adaptors (taken, taken_while, dropped,
 dropped_while, elements, elements_key, memoized, outdirected)
 - Extensions for using Lambda (regular function, regular operator)
 - Infinite Range (iteration function)
 - and additional range utilities.

Nowide
------
:Author: Artyom Beilis

:Review Manager: Needed

:Download: http://cppcms.com/files/nowide/

:Description:
 This library makes cross platform Unicode aware programming easier.
 It provides an implementation of standard C and C++ library functions,
 such that their inputs are UTF-8 aware on Windows without requiring to
 use Wide API.

Array
-----
:Author: Brian Smith

:Review Manager: Needed

:Download: https://github.com/BrianJSmith/Array

:Description:
 The array class is a C++11 compatible implementation of static
 multidimensional arrays.

STL Extensions
--------------
:Author: Vadim Stadnik

:Review Manager: Needed

:Download: https://github.com/vstadnik/stl_ext_adv_review

:Description:
 The proposed library [stl_ext_adv] offers augmented array based B+ trees 
 and STL containers that support the interfaces of the C++03 sequences 
 and associative containers. The library offers a number of extensions 
 and performance improvements that are not available in 
 C++03 and C++11 standard containers. 

Countertree
-----------
:Author: Francisco Jose Tapia

:Review Manager: Needed

:Download: https://dl.dropbox.com/u/8437476/works/countertree_code_doc.zip

:Description:
 This library is an implementation of a binary red-black counter tree. This
 tree have an additional counter in each leaf. This permit the access to the
 elements by the position, like in a vector. It is a random access container
 with random access iterators. 

 COUNTERTREE

 This kind of trees have an additional counter in each leaf. This
 permit the access to the elements by the position, like in a
 vector. It is a random access container with random access iterators.

 With unordered information we have a vector with the same speed
 inserting and deleting in any position (O(log N)).  With ordered
 information, we have the classes set, multiset, map and multimap, with
 identical interface than the STL classes, with the plus of access to
 the elements by position, like in a vector. The iterators are random
 access , and you can subtract them.

 SUBALLOCATOR

 The suballocator is a layer between the allocator and the data
 structures, compatible with any allocator with the STL definition. The
 suballocator replace to the allocator in the allocation of equal size
 elements. It provides speed, return the unused memory and decrease the
 memory used by the program and improve the cache performance due to
 the data locality improvement ( 30% of improvement of speed respect
 the std::allocator with GCC 4.7)

Process
-------
:Author: Boris Schaeling
:Review Manager: Needed
:Download: http://www.highscore.de/boost/process0.5/process.zip

:Description:
 Boost.Process is a library to manage system processes. It can be used to:

  * create child processes
  * setup streams for child processes
  * communicate with child processes through streams (synchronously or
    asynchronously)
  * wait for processes to exit (synchronously or asynchronously)
  * terminate processes

Asynchronous File I/O
---------------------
:Author: Niall Douglas and Paul Kirth
:Review Manager: Needed
:Download: https://github.com/BoostGSoC/boost.afio/archive/boost-peer-review.tar.gz

:Description: 
  Boost.AFIO is a linear scalable, batch, chainable,
  asynchronous closure execution engine with an almost wait free
  implementation extending Boost.ASIO and Boost.Thread specialised as a
  portable asynchronous file i/o implementation library. Implementation
  of this first version has been kept as simple as possible (~ 1000
  active LOC) at the cost of some performance, though with a good
  compiler you can expect 25-50% of the performance of using raw
  Boost.ASIO.

Application
-----------
:Author: Renato Tegon Forti
:Review Manager: Needed
:Download: https://github.com/retf/Boost.Application
:Documentation: http://www.dokfile.com/appbeta4/docs/libs/application/doc/html/index.html
:Description:
 Application provides an application environment, or start point
 to any people that want a basic infrastructure to build an system
 application on Windows or Unix Variants (e.g. Linux, MacOS).

 Application uses behaviours modeled using 'aspects' concept
 proposed by 'Vicente J. Botet Escriba', that allow easy extension and
 customization of library components. The application modes uses these
 components internally to achieve the user desirable behaviours.

 Application provide many useful ready-to-use features, e.g:

 * Run application as Windows Service;
 * Run application as UNIX/POSIX Daemon;
 * Plugin extension system;
 * Process(executable) Single instance Instantiation support;
 * Application SIGNAL/Callbacks customization;
 * Windows Service Setup feature;
 * And many others.

Edit Distance
-------------
:Author: Erik Erlandson
:Review Manager: Needed
:Download: https://github.com/erikerlandson/algorithm/tree/edit_distance/sequence
:Description:
  The edit distance is the length of the shortest (or least-cost) edit
  script from one sequence to another, where an edit script is defined
  as a sequence of insertion, deletion and (optionally) substitution
  operations.  The function implementing the edit distance is named
  edit_distance. This function will return the edit distance between two
  sequences, where sequences may be any valid range object supporting
  forward iteration.  The edit_distance function will also, if
  requested, return the edit script.

Mixin
-----
:Author: Borislav Stanimirov
:Download: https://github.com/iboB/boost.mixin
:Documentation: http://ibob.github.io/boost.mixin/
:Review Manager: Needed
:Description:
  Boost.Mixin is a library that allows the composition and
  modifications of polymorphic types at run time. Types and objects
  are constructed out of building blocks called mixins.

  The library uses the type boost::mixin::object as a placeholder,
  whose instances can be extended with existing classes (mixins), thus
  providing a particular instance with the functionality of all those
  types. Accessing the newly formed type's interface is made through
  messages:  stand-alone functions generated by the library, which can
  be thought of as methods.

  This is given while also having full abstraction between the
  interface and the definition of types.

  An existing feature in another language similar to Boost.Mixin and
  also an inspiration for the library are the mixins in Ruby. The
  library also has similarities with the pattern
  entity-component-system.

Libraries under development
===========================

See http://svn.boost.org/trac/boost/wiki/LibrariesUnderConstruction
for a current listing of libraries under development.

Steven Watanabe | 21 Aug 16:07 2014
Picon

[review] Formal review period for VMD library begins today, Aug 21, and ends Sat, Aug 30

AMDG

The formal review of the VMD library by Edward Diener
starts today, Aug 21st and is scheduled to continue until Aug 30th.

About VMD
===============

The Variadic Macro Data library is a library
of variadic macros which enhance the functionality in
the Boost preprocessor library ( Boost PP ). The main
focus of the library is the parsing/identifying of a subset
of C++ preprocessor data types and of all Boost PP data types.
This allows enhanced preprocessor metaprogramming based on the type of
macro input. The library may also be seen as a repository for
future enhancements to the Boost PP library functionality using
variadic macros.

Where to get it
===============

The library is available on github at
https://github.com/eldiener/variadic_macro_data

Review guidelines
=================

Reviews should be submitted to the developer list
(boost <at> lists.boost.org), with '[vmd]' in the subject. Or if you
don't wish to for some reason, you can send them privately to me. If
so, please let me know whether or not you'd like your review to be
forwarded to the list.

For your review you may wish to consider the following questions:

     - What is your evaluation of the design?
     - What is your evaluation of the implementation?
     - What is your evaluation of the documentation?
     - What is your evaluation of the potential usefulness of the
       library?
     - Did you try to use the library?  With what compiler?  Did you
       have any problems?
     - How much effort did you put into your evaluation? A glance? A
       quick reading? In-depth study?
     - Are you knowledgeable about the problem domain?

And finally, every review should answer this question:

     - Do you think the library should be accepted as a Boost library?

Be sure to say this explicitly so that your other comments don't
obscure your overall opinion.

In Christ,
Steven Watanabe

Marshall Clow | 7 Aug 19:54 2014
Picon

Boost 1.56.0 has been released

Release 1.56.0 of the Boost C++ Libraries is now available.

These open-source libraries work well with the C++ Standard Library, and are usable across a broad spectrum of applications. 
The Boost license encourages both commercial and non-commercial use.

This release contains one new library and numerous enhancements and bug fixes for existing libraries.

=== Modularization ===
Boost version control has migrated to a system using git submodules. This shouldn't make too much of a difference to users, although the directory structure is now a bit different.

Parts of some libraries have been moved into different modules, and several new modules have been extracted from existing code. All header paths should remain the same. The new modules are:

• Assert: Customizable assert macros. Maintained by Peter Dimov.
• Core:  Core utilities used by other libraries, with minimal dependencies. Maintained by Peter Dimov, Glen Fernandes and Andrey Semashev.
• Lexical_Cast: General literal text conversions, such as an int represented a string, or vice-versa, from Kevlin Henney.
• Throw_Exception: A common infrastructure for throwing exceptions from Boost libraries, from Emil Dotchevski.
• Winapi: Windows API declarations without <windows.h>, for internal Boost use.

=== New Libraries ===
• Align: Memory alignment functions, allocators, and adaptors, from Glen Fernandes.
• Type_Index: Runtime/Compile time copyable type info, from Antony Polukhin.


For details, including download links, see http://www.boost.org/users/news/version_1.56.0

You can also download directly from SourceForge: http://sourceforge.net/projects/boost/files/boost/1.56.0/

To install this release on your system, see http://www.boost.org/doc/libs/release/more/getting_started/index.html

Thanks,

--The Boost release team

  Vladimir Prus
  Rene Rivera
  Marshall Clow
  Eric Niebler
  Daniel James
  Beman Dawes
<div>
<div>
<span>Release 1.56.0 of the Boost C++ Libraries is now available.</span><br><br><span>These open-source libraries work well with the C++ Standard Library, and are usable across a broad spectrum of applications.&nbsp;</span><br><span>The Boost license encourages both commercial and non-commercial use.</span><br><br><span>This release contains one new library and numerous enhancements and bug fixes for existing libraries.</span><br><br>=== Modularization ===</div>
<div>Boost version control has migrated to a system using git submodules. This shouldn't make too much of a difference to users, although&nbsp;the directory structure is now a bit different.<br><br>Parts of some libraries have been moved into different modules, and several new modules have been extracted from existing code. All&nbsp;header paths should remain the same. The new modules are:<br><br><div>
<span class="Apple-tab-span">	</span>&bull; Assert:<span class="Apple-tab-span">	</span>Customizable assert macros. Maintained by Peter Dimov.<br>
</div>
<div>
<span class="Apple-tab-span">	</span>&bull; Core:&nbsp;<span class="Apple-tab-span">	</span>Core utilities used by other libraries, with minimal dependencies. Maintained by Peter Dimov, Glen Fernandes and Andrey&nbsp;Semashev.<br>
</div>
<div>
<span class="Apple-tab-span">	</span>&bull; Lexical_Cast:<span class="Apple-tab-span">	</span>General literal text conversions, such as an int represented a string, or vice-versa, from Kevlin Henney.<br>
</div>
<div>
<span class="Apple-tab-span">	</span>&bull; Throw_Exception:<span class="Apple-tab-span">	</span>A common infrastructure for throwing exceptions from Boost libraries, from Emil Dotchevski.<br>
</div>
<div>
<span class="Apple-tab-span">	</span>&bull; Winapi:<span class="Apple-tab-span">	</span>Windows API declarations without &lt;windows.h&gt;, for internal Boost use.<br>
</div>
<div><br></div>=== New Libraries ===<br><div>
<span class="Apple-tab-span">	</span>&bull; Align:<span class="Apple-tab-span">	</span>Memory alignment functions, allocators, and adaptors, from Glen Fernandes.<br>
</div>
<div>
<span class="Apple-tab-span">	</span>&bull; Type_Index:<span class="Apple-tab-span">	</span>Runtime/Compile time copyable type info, from Antony Polukhin.<br>
</div>
<br><br><span>For details, including download links, see&nbsp;</span><a href="http://www.boost.org/users/news/version_1.56.0">http://www.boost.org/users/news/version_1.56.0</a><br><br><span>You can also download directly from SourceForge:&nbsp;</span><a href="http://sourceforge.net/projects/boost/files/boost/1.56.0/">http://sourceforge.net/projects/boost/files/boost/1.56.0/</a><br><br><span>To install this release on your system, see&nbsp;</span><a href="http://www.boost.org/doc/libs/release/more/getting_started/index.html">http://www.boost.org/doc/libs/release/more/getting_started/index.html</a><br><br><span>Thanks,</span><br><br><span>--The Boost release team</span><br><br><span>&nbsp;&nbsp;Vladimir Prus</span><br><span>&nbsp;&nbsp;Rene Rivera</span><br><span>&nbsp;&nbsp;Marshall Clow</span><br><span>&nbsp;&nbsp;Eric Niebler</span><br><span>&nbsp;&nbsp;Daniel James</span><br><span>&nbsp;&nbsp;Beman Dawes</span>
</div>
</div>
Marshall Clow | 18 Jul 17:01 2014
Picon

[1.56.0] Beta 1 Available

Boost release 1.56.0 beta 1 is now available from SourceForge

See http://sourceforge.net/projects/boost/files/boost/1.56.0.beta.1/

This release contains 2 new libraries:
* Align: Memory alignment functions, allocators, and adaptors, from Glen Fernandes.
* Type_Index: Runtime/Compile time copyable type info, from Antony Polukhin.

Modularization
Boost version control has migrated to a system using git submodules. This shouldn't make too much of a difference to users, although the directory structure is now a bit different.

Parts of some libraries have been moved into different modules, and several new modules have been extracted from existing code. All header paths should remain the same.

The new modules are:
* Assert: Customizable assert macros. Maintained by Peter Dimov.
* Core: Core utilities used by other libraries, with minimal dependencies. Maintained by Peter Dimov, Glen Fernandes and Andrey Semashev.
* Lexical_Cast: General literal text conversions, such as an int represented a string, or vice-versa, from Kevlin Henney.
* Throw_Exception: A common infrastructure for throwing exceptions from Boost libraries, from Emil Dotchevski.
* Winapi: Windows API declarations without <windows.h>, for internal Boost use.

For details of what's in the release, see http://www.boost.org/users/history/version_1_56_0.html
Note that the links to files on this web page are for the final release - use the SourceForge link above to get the beta files.

Please download the beta, give it a try, and report any problems you encounter.

Thanks,

-- The Boost Release Team
<div>
<span>Boost release 1.56.0 beta 1 is now available from SourceForge</span><br><br><span>See&nbsp;</span><a href="http://sourceforge.net/projects/boost/files/boost/1.56.0.beta.1/">http://sourceforge.net/projects/boost/files/boost/1.56.0.beta.1/</a><br><br>This release contains 2 new libraries:<br><span class="Apple-tab-span">	</span>* Align: Memory alignment functions, allocators, and adaptors, from Glen Fernandes.<br><span class="Apple-tab-span">	</span>* Type_Index: Runtime/Compile time copyable type info, from Antony Polukhin.<br><br>Modularization<br>Boost version control has migrated to a system using git submodules. This shouldn't make too much of a difference to users, although&nbsp;the directory structure is now a bit different.<br><br>Parts of some libraries have been moved into different modules, and several new modules have been extracted from existing code. All&nbsp;header paths should remain the same.<div><span><br></span></div>
<div>
<span>The new modules are:</span><div>
<div>
<span class="Apple-tab-span">	</span>* Assert:&nbsp;Customizable assert macros. Maintained by Peter Dimov.<br>
</div>
<div>
<span class="Apple-tab-span">	</span>* Core:&nbsp;Core utilities used by other libraries, with minimal dependencies. Maintained by Peter Dimov, Glen Fernandes and Andrey&nbsp;Semashev.<br>
</div>
<div>
<span class="Apple-tab-span">	</span>* Lexical_Cast:&nbsp;General literal text conversions, such as an int represented a string, or vice-versa, from Kevlin Henney.<br>
</div>
<div>
<span class="Apple-tab-span">	</span>* Throw_Exception:&nbsp;A common infrastructure for throwing exceptions from Boost libraries, from Emil Dotchevski.<br>
</div>
<div>
<span class="Apple-tab-span">	</span>* Winapi:&nbsp;Windows API declarations without &lt;windows.h&gt;, for internal Boost use.</div>
<div><br></div>
<div>
<span>For details of what's in the release, see&nbsp;</span><a href="http://www.boost.org/users/history/version_1_56_0.html">http://www.boost.org/users/history/version_1_56_0.html</a><span>.&nbsp;</span><br><span>Note that the links to files on this web page are for the final release - use the SourceForge link above to get the beta files.</span><br><br><span>Please download the beta, give it a try, and report any problems you encounter.</span><br><br><span>Thanks,</span><br><br><span>-- The Boost Release Team</span>
</div>
</div>
</div>
</div>
Beman Dawes | 10 Jun 22:19 2014
Picon

Boost Library Incubator recommended by steering committee


The Boost Library Incubator (www.blincubator.com) is a web site conceived, designed, and implemented to alleviate the log-jam of libraries waiting to be reviewed by Boost. It helps new library submitters through the process, encourages development of an initial user base, and accumulates feedback in the form of comments, test results and Boost style reviews.

The Boost Steering Committee has voted to recommend using the Boost Library Incubator as a prelude to getting a library reviewed by Boost.  The Steering Committee recommends libraries currently in the Boost review queue be added to the Incubator by their developers.

The relationship between Boost and the Incubator is purely informal, but there as several things Boosters can do to help make the Incubator a success.  Authors can submit their libraries and respond to feedback.  Users can experiment with submitted libraries and provide feedback on their experience.  WordPress/php developers can contribute enhancements to the Boost Library Incubator implementation.

The steering committee extends its thanks to Robert Ramey for launching the Boost Library Incubator!

--The Boost Steering Committee

<div><div dir="ltr">
<br><div>
<div>The Boost Library Incubator (<a href="http://www.blincubator.com/" target="_blank">www.blincubator.com</a>)
 is a web site conceived, designed, and implemented to alleviate the 
log-jam of libraries waiting to be reviewed by Boost. It helps new 
library submitters through the process, encourages development of an 
initial user base, and accumulates feedback in the form of comments, 
test results and Boost style reviews.<br><br>The
 Boost Steering Committee has voted to recommend using the Boost Library
 Incubator as a prelude to getting a library reviewed by Boost.&nbsp; The 
Steering Committee recommends libraries currently in the Boost review 
queue be added to the Incubator by their developers.<br><br>The
 relationship between Boost and the Incubator is purely informal, but 
there as several things Boosters can do to help make the Incubator a 
success. &nbsp;Authors can submit their libraries and respond to feedback. 
&nbsp;Users can experiment with submitted libraries and provide feedback on 
their experience. &nbsp;WordPress/php developers can contribute enhancements to the Boost Library Incubator implementation.<br><br>
</div>
<div>The steering committee extends its thanks to Robert Ramey for launching the Boost Library Incubator!<br><br>
</div>
<div>--The Boost Steering Committee<br>
</div>
<div><div><br></div></div>
</div>
</div></div>
Glen Fernandes | 10 Jun 00:53 2014
Picon

[boost] [pimpl] Boost.Pimpl review canceled

Hi everyone,

Vladimir has elected to withdraw Boost.Pimpl submission and cancel the
formal review. On behalf of Vladimir, thank you for the feedback
provided in response to the pre-view announcement mail: it was
especially useful to him.

Best,
Glen
Glen Fernandes | 5 Jun 18:32 2014
Picon

Boost.Pimpl upcoming formal review (June 15 - June 24)

The formal review period of Boost.Pimpl by Vladimir Batov is scheduled
to begin later this month, on June 15th, and will conclude on June
24th, and we welcome your participation.

Vladimir's library provides a mechanism for implementing this popular,
and still very relevant, idiom. To borrow his words from the
documentation:

[quote] In the domain of commercial large-scale software development
the following design principles come to the fore:
    - component-based, modular and API-centered design,
    - separation of concerns,
    - implementation hiding,
    - minimization of compilation and component dependencies,
    - consistent and recognizable deployment and implementation patterns,
multi-platform support.

    The Pimpl idiom can help great deal achieving those goals. It is a
simple yet robust programming technique to minimize coupling via the
separation of public interface and private implementation and then
implementation hiding. [/quote]

Please feel encouraged to browse the source code, documentation, and
tests, before the review commences. Any feedback you have prior to the
review period is also very appreciated.

Source:
https://github.com/yet-another-user/boost.pimpl/

Documentation:
http://yet-another-user.github.io/boost.pimpl/

Download:
https://github.com/yet-another-user/boost.pimpl/archive/master.zip

If you would like to submit a review earlier, please provide your
thoughts on the following topics:

- What is your evaluation of the design?
- What is your evaluation of the implementation?
- What is your evaluation of the documentation?
- What is your evaluation of the potential usefulness of the library?

As well as information on the following questions:

- Did you try to use the library? With what compiler? Did you have any problems?
- How much effort did you put into your evaluation? A glance? A quick
reading? In-depth study?
- Are you knowledgeable about the problem domain?

And most importantly:

- Do you think the library should be accepted as a Boost library?

Best,
Glen
Edward Diener | 2 Jun 00:02 2014

Convert library review manager result

This is my analysis of the 'convert' library review and the result
of whether the convert library should be accepted into Boost.
Please read the entire analysis to understand my reasoning before
reading the result.

I would like to thank all of those who took part in the review and made
comments. This includes Julian Gonggrip, Rob Stewart, Andrzej Krzemienski,
Matus Chochlik, Jeroen Habraken, Erik Nelson, Hartmut Kaiser, Joel De 
Guzman,
Thijs (M.A.) van den Berg, Roland Bock, Gavin Lambert, feverzsj, Paul 
Bristow,
and alex. If I have missed anybody I do apologize. All comments were taken
into account and all comments were intelligent and to the point.

Naturally I would also like to than Vladimir Batov for patiently answering
all comments and explaining and defending his library and his design 
decisions.

For the most part I am going to focus on general issues rather than on the
individuals who made them.

Documentation issues:

The documentation was too focused on explaining the
library as it differed from lexical_cast. Vladimir Batov explained why
this is so but I also agree that the documentation can be better by simply
focusing on what the library provides in terms of functionality. Comments
also mentioned that the current converters are not documented as well as
the could be, and some commenters reflected that knowledge of how a 
particular
converter works, including possible failures using that converter,
is also needed despite the common library interface.

The documentation did not provide enough information
about the use of locales in the library.

The reference section was very limited with not enough explanation. A 
reference
built from doxygen comments in the source files would be better.

A better explanation or example in the documentation for writing one's own
converter was suggested.

Although the Performance section in the documentation was fairly lengthy
some commenters wanted to know why some things could not be tested. 
Others wanted
more information about how convert performance compared to other 
convert-like
implementations.

In general I think most reviewers found the documentation adequate for
understanding how to use the library but lacking in completeness. Vladimir
Batov reflected that if the library were accepted into Boost he would then
create more complete documentation and the above issues could be addressed.

Implementation issues:

As in most reviews most commenters did not look very deeply into the actual
code but were happy to know how to use the library, and this is 
understandable
for a review. There were a few pertinent comments however and I am just 
going
to enumerate them.

All macros should be prefix with BOOST_. My own addition to that is that all
macros should be prefixed with BOOST_CONVERT_ to avoid any conflicts 
with other
libraries.

There should be a jamfile for running the tests. Also some full-blown 
examples
of using the library in a simple program, along with the appropriate 
jamfile,
would be helpful.

Source code should contain spaces, not tabs. This is an easily fixed 
minor issue.

As mentioned before doxygen comments in the public source are the usual 
Boost
way of doing things.

The main header file should be convert.hpp instead of api.h.

Some includes were missing from the printf converter.

Design issues:

In the design of the library is where we have the most varying views. 
The major
issue in discussing the design of the library for those who felt it was 
inadequate
were the comments that using the library was too complicated, that the 
central
function for invoking a conversion should be simpler to use. While all 
suggestions
were well-argued I felt that a number of these differences were merely 
syntactical
issues rather than issues that made the functionality easier to use. The 
main
interface for using the library is:

   convert<output_type>::from(input_value, converter)

Vladimir Batov had asserted during the review that this could be 
simplified further
by removing the need for the 'from::' part of the signature which would 
make the syntax
simpler. Some reviewers did not like the name 'convert' and offered 
substitutions, others
wanted the default value, currently specified as '.value_or(default)', 
to be specified as a direct
input parameter, others wanted the converter itself which is an input 
parameter to be specified
via another syntax. All of these are too me syntactical issues and no 
resolution could
possibly please everybody but it is understandable that different 
reviewers have different
syntactical preferences.

More to the point were some changes in actual functionality. The three 
most important
involved the return value, type requirements for the output type, and 
the use of a default
converter. Considering each in its turn:

1) The return value is some form of 'optional', with the idea of using 
boost::optional
if it meets all the requirements needed by the 'convert' library. A 
number of people
wanted the actual value returned without having to append .value() to 
the convert signature to get it.
They were also concerned with the performance overhead of having to 
create an optional
value as the immediate return value. It was also suggested that while 
the current
convert syntax might be fine, some alternatives directly returning the 
value, for those
who like maximum simplicity, might be possible.

2) The type requirements for the output type are default constructible 
and copy
constructible. A number of reviewers felt that if a non-const reference 
were passed
to the convert function as an output instance then the type requirements 
would not have
to be met. However the type requirements of some of the underlying 
converters might be
affected by this and the documentation does explain how to work around 
the default
constructible requirement, but I still do understand the reasoning 
behind this possibility.

3) A number of reviewers wanted a default converter to be used but there 
was hardly an
agreement on what this default converter should be, some favoring 
lexical_cast, others
favoring stringstream, and no doubt others might want something else. 
Nevertheless
providing a default constructor interface, possible with a macro defined 
a compile time,
seems like it might be doable.

There was further discussion about the actual callable signature for a 
plug-in converter.
Here there was less contention about the interface, which is currently a 
callable with a
signature of:

   template<typename TypeOut, typename TypeIn>
   bool operator()(TypeIn const& value_in, TypeOut& result_out) const;

Vladimir Batov did suggest some possible alternatives and there was a 
discussion
with a number of reviewers about alternatives that seem implementable. 
This also ties
into the concern of some reviewers that it should be straightforward to 
create one's
own converters with minimum restrictions on the input and output types, 
as well as
minimum performance overhead.

Votes:

A number of reviewers made comments but offered no final vote on whether 
or not the
conversion library should be accepted into Boost. Some reviewers offered 
a Yes vote, but
heavily based on changes they want to see. I will attempt to tabulate 
them here:

YES votes:

Christopher Kormanyos
Paul Bristow
Julian Gonggrip ( with some reservations which Vladimir Batove has met 
or may easily meet )
Andrzej Krzemienski
Matus Chochlik

YES, conditionally but otherwise NO if conditions are not met, which the 
current version does not meet]

Jeroen Habraken
Roland Bock
alex

NO

Rob Stewart

Final Decision:

Among those who voted YES conditionally but otherwise NO there was a 
general consensus
including Vladimir Batov, the 'convert' library creator, and some of the 
others that an attempt
could be made to satisfy some of the conditions for simplification 
and/or functionality they
desired.

My decision, based on the votes as I interpret them, is that the convert 
library is ACCEPTED
into Boost. While a perfect design is impossible I believe that the 
design of the library
is an adequate starting point for a general-purpose conversion framework 
and that the design
could change incrementally enough to satisfy some of the qualms of those 
who might not find
it as initially useful as they have hoped, while still maintaining the 
central framework
which Vladimir Batov has created. Furthermore I believe that others have 
reflected that a
general-purpose conversion library would be very useful if it were 
flexible enough to support
plug-in converters created by programmers, as the 'convert' library 
does. I realize that what is
essentially a 5 to 4 vote in favor of the library is not an overwhelming 
consensus by any means
but I feel that 3 of those 4 NO votes are predicated on wishes for 
possible changes to the 'convert' library
which may yet be met before the library gets officially added to an 
upcoming Boost release.

Since I have accepted the library based on the votes and my 
interpretation of the issues I
would like to encourage those who feel that some alternate designs could 
be implemented as part
of the 'convert' library to work with Vladimir Batov, if he is 
agreeable, to add those alternatives
to the library. Nonetheless it is his library and he would be the final 
arbiter of any decisions
reached. I would like to encourage the view, however, that the current 
design is what has been
voted in by others as the 'convert' library so that any changes made to 
it as it is added to
Boost should be incremental additions which minimally change what others 
see as an acceptable library.
Edward Diener | 26 May 18:28 2014

Convert library review period has ended

The review period for the Convert library of Vladimir Batov has ended. 
There is one more potential review, from Rob Stewart, by the end of 
today, as well as any response from Vladimir Batov, I am willing to 
consider as the review manager.

I would like to thank all those who have participated in the review, as 
well as Vladimir Batov for patiently answering reviews and following up 
in discussions.

I will be working on summing up the discussion and votes on whether or 
not Convert should be accepted into Boost, and will issue my final 
decision sometime by the end of this week ( by the end of Sunday June 1 
US Eastern time at the latest ).

Again thanks to all of those who participated in the review and its 
discussions.

Edward Diener
Edward Diener | 14 May 00:07 2014

Boost review of the Convert library is ongoing

The review of the Convert library started Monday, May 12 and goes 
through Wednesday May 21. Many people may have missed the first 
announcement since the mailing lists were held back when the review 
started so I am announcing this again.

The Convert library builds on the boost::lexical_cast original design 
and experience and takes those conversion/transformation-related ideas 
further.

     * to be applicable to a wider range of conversion-related use-cases,
     * to provide a more flexible, extendible and configurable 
type-conversion framework.

The Convert library can be cloned from GitHub at 
https://github.com/yet-another-user/boost.convert. The library follows 
the modular-boost format. Just clone it to modular-boost/libs in the 
'convert' subdirectory and run 'b2 headers' in order to create a link to 
its header file directory in the modular-boost/boost subdirectory.

The library comes with documentation in its top-level index.html or 
doc/html/index.html file. You can also view the documentation online at 
http://yet-another-user.github.io/boost.convert/doc/html/index.html.
The library is by Vladimir Batov and is a second reiteration with a 
greater focus of his library that was reviewed in the past. I am Edward 
Diener and I am again serving as the review manager of the library.

If you have used lexical_cast or, like many C++ programmers, have used 
stringstream to do string-to-type, type-to-string conversions please 
look at this library. We need reviews of whatever point of view before a 
library can even be considered a Boost library.

Comments, questions, and reviews will all be welcome for the library. 
Please try to sum up your review by answering these questions:

     What is your evaluation of the design?
     What is your evaluation of the implementation?
     What is your evaluation of the documentation?
     What is your evaluation of the potential usefulness of the library?
     Did you try to use the library? With what compiler? Did you have 
any problems?
     How much effort did you put into your evaluation? A glance? A quick 
reading? In-depth study?
     Are you knowledgeable about the problem domain?

And finally:

     Do you think the library should be accepted as a Boost library?

As always whether you do or do not feel that the library should be 
accepted into Boost please specify any changes you would like to see for 
the library to be better in your estimation.

Gmane