[Boost-users] [review] The review of Boost.DoubleEnded starts today: September 21 - September 30

Subject: [Boost-users] [review] The review of Boost.DoubleEnded starts today: September 21 - September 30
From: Thorsten Ottosen (tottosen_at_[hidden])
Date: 2017-09-21 17:50:41

Dear users and members of Boost,

I'm proud to announce that the formal review of Benedek Thaler's 
Boost.DoubleEnded library starts today, September 21, and runs through 
September 30. This library is the result of Benedek's participation in 
Google Summer of Code 2015.

The library may be downloaded from

https://github.com/erenon/double_ended

and the documentation may be found here:

http://erenon.hu/double_ended/

Anyone is welcome to post a review and/or take part in subsequent 
discussions on the boost developer list (see below for review guidelines).

Introduction
------------

This is a container library that provides two containers:

A. boost::devector

B. boost::batch_deque

Both containers provides efficient push_front and push_back operations, 
hence the name DoubleEnded.

The boost::devector class can be seen as an extension of std::vector 
with efficient support for push_front (so boost::devector provides 
contiguous storage). In addition, it provides a customizable small 
buffer optimization like boost::small_vector(*).
It furthermore allows for customization of the growth factor such that 
the user can decide if a reallocation should allocate 1.5 or 2 or 
whatever more memory. And finally it provides new functionality that 
does not exist in normal vector implementations -- this functionality 
allow the class to excel in performance in certain situations like 
serialization or transfer of data from sources that require a 
preallocated buffer.

The boost::batch_deque is similar to std::deque, but with two important 
twists. Like std::deque, it provides reference stability when calling 
push_front/push_back. Reference stability is crucial for programs that
uses intrusive containers e.g. using Boost.Intrusive (**). 
boost::batch_deque has the following main advantages:

1. It allows the user to specify the segment size

2. It allows for external iteration over the segments

Taken together, they provide a very efficient and flexible basis for
intrusive containers. Access to the segments also increases performance 
for tasks such as serialization. Finally, boost::batch_deque may be seen 
as an efficient alternative to std::vector if you want to replace
a percent-wise memory overhead with a constant memory overhead and have 
no need for contiguous storage.

Review guidelines
-----------------

Please provide in your review whatever information you think is
valuable to understand your final choice of ACCEPT or REJECT including
Fit as a Boost library. Please be explicit about your decision.

Some other questions you might want to consider answering:

   - 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 which compiler(s)? 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?

More information about the Boost Formal Review Process can be found 
here: http://www.boost.org/community/reviews.html

Kind regards

Thorsten, Review manager

(*) boost::small_vector: https://tinyurl.com/ycslp4ot

(**) http://www.boost.org/doc/libs/1_64_0/doc/html/intrusive.html