Boost.MultiIndex Release notes

Future work

Index

Acknowledgements

Boost 1.38 release
Boost 1.37 release
Boost 1.36 release
Boost 1.35 release
Boost 1.34 release
Boost 1.33.1 release
Boost 1.33 release

Boost 1.38 release

These constructs are deprecated:
- nth_index_iterator<MultiIndexContainer,N>::type,
- multi_index_container<...>::nth_index_iterator<N>::type,
- nth_index_const_iterator<MultiIndexContainer,N>::type,
- multi_index_container<...>::nth_index_const_iterator<N>::type,
- index_iterator<MultiIndexContainer,Tag>::type,
- multi_index_container<...>::index_iterator<Tag>::type,
- index_const_iterator<MultiIndexContainer,Tag>::type,
- multi_index_container<...>::index_const_iterator<Tag>::type.
Use the following instead:
- nth_index<MultiIndexContainer,N>::type::iterator,
- multi_index_container<...>::nth_index<N>::type::iterator,
- nth_index<MultiIndexContainer,N>::type::const_iterator,
- multi_index_container<...>::nth_index<N>::type::const_iterator,
- index<MultiIndexContainer,Tag>::type::iterator,
- multi_index_container<...>::index<Tag>::type::iterator,
- index<MultiIndexContainer,Tag>::type::const_iterator,
- multi_index_container<...>::index<Tag>::type::const_iterator.
Maintenance fixes.

Boost 1.36 release

On prior versions of the library, the update member functions of hashed indices could alter the position of an element even if the associated key did not change with the update. This is legal but probably unexpected behavior. The functions have been rewritten to provide the additional guarantee that elements with unmodified key will not change position in hashed indices, just as always was the case with ordered indices. These guarantees are now documented in the reference.
Added the constructor multi_index_container::multi_index_container(const allocator_type&) to mimic the equivalent interface in STL sequence containers.
Maintenance fixes.

Boost 1.35 release

New global_fun predefined key extractor.
Added iterator_to facility.
Included support for non-standard allocators such as those of Boost.Interprocess, which makes multi_index_containers placeable in shared memory.
New versions of modify and modify_key with rollback, as described in the tutorial.
Indices provide the new cbegin, cend and, when applicable, crbegin and crend member functions, in accordance with the latest drafts of the next revision of the C++ standard.
Hinted insertion in ordered indices fully conforms to the resolutions of C++ Standard Library Defect Report 233. The new requirement that the point of insertion be always as close as possible to the hint induces a different behavior than exhibited in former releases of Boost.MultiIndex, which can potentially cause backwards compatibility problems; in any case, the likelihood of these compatibility issues arising in a real scenario is very low.

Sequenced and random access indices now follow the requirements of the C++ standard for sequence containers with respect to the operations assign(f,l) and insert(p,f,l) (23.1.1/9): if f and l are of the same integral type, the iterator-based overloads of these member functions are avoided:

typedef multi_index_container<
  int,indexed_by<sequenced<> >
> sequenced_container;

std::list<int>      l(...);
sequenced_container c;

// iterator-based overload of assign
c.assign(l.begin(),l.end()); 

// The following is equivalent to
//   c.assign(
//      static_cast<sequenced_container::size_type>(10),100);
// that is, "10" and "100" are not taken to be iterators as
// in the previous expression.
c.assign(10,100);

The performance of ordered indices range and equal_range has been improved.
Maintenance fixes.

Boost 1.34 release

Added random access indices.
Non key-based indices provide new rearrange facilities allowing for interaction with external mutating algorithms.
All predefined Boost.MultiIndex key extractors instantiated for a given type T can handle objects of types derived from or convertible to T (and chained pointers to those). Previously, only objects of the exact type specified (along with reference_wrappers and chained pointers to them) were accepted.
composite_key_compare and related classes accept operands not included in tuples as if they were passed in a tuple of length 1; this allows the user to omit tuple enclosing in lookup operations involving composite keys when only the first key is provided.
The core algorithms of ordered indices have been optimized, yielding an estimated reduction of about 5% in insertion times.
Size of ordered indices node headers have been reduced by 25% on most platforms, using a well known optimization technique.
The tutorial has been restructured, new examples added.
Maintenance fixes.

Boost 1.33.1 release

For ordered and hashed indices, erase(it) and erase(first,last) now return an iterator to the element following those being deleted (previously nothing was returned), in accordance with the C++ Standard Library Defect Report 130 and issue 6.19 of TR1 Issues List.
Boost.MultiIndex offers the usual guarantees with respect to multithreading code provided by most STL implementations:
1. Concurrent access to different containers is safe.
2. Concurrent read-only access to the same container is safe.
In previous versions of the library, the latter guarantee was not properly maintained if the safe mode was set. This problem has been fixed now.
Maintenance fixes.

Boost 1.33 release

Added hashed indices, whose interface is based on the specification for unordered associative containers by the C++ Standard Library Technical Report (TR1).
Added serialization support for Boost.Serialization.
Destruction of multi_index_containers and clear memfuns now perform faster.
Internal changes aimed at reducing the length of symbol names generated by the compiler; cuts of up to a 50% can be achieved with respect to the Boost 1.32 release. This results in much shorter and more readable error messages and has also a beneficial impact on compilers with strict limits on symbol name lengths. Additionally, a section on further reduction of symbol name lengths has been added.
Restructured some parts of the documentation, new examples.
Maintenance fixes.