# Boost.MultiIndex Release notes

Future work
Index
Acknowledgements

## Contents

- 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.37 release

- 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_container`s 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_wrapper`s 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_container`s 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.

Future work
Index
Acknowledgements

Revised August 29th 2008

© Copyright 2003-2008 Joaquín M López Muñoz. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)