size_type and difference_type are now
defined as the allocator's same-named types. This will not make any
difference in the vast majority of cases, but allows for some degree
of control of resulting internal structures via user-defined allocator
types (see
issue #17
for motivation). For the moment being, this change is not
documented in the reference section (i.e., it has semi-official status).

Made modify and modify_key more robust so that
the modified element is erased if the modifier throws or the rollback
functor does not properly restore the element (full discussion at
ticket #12542).
This is technically backwards incompatible; for instance, the following code:

c.modify(c.begin(),[](auto&){throw0;});

keeps the container c untouched in former versions of Boost whereas
now c.begin() is erased. Thanks to Jon Kalb for raising the issue.

The efficiency of lookup operations has improved in situations where they involve
the generation of temporary values of key_type. Consider for instance
the following code:

typedefmulti_index_container<std::string,indexed_by<ordered_unique<identity<std::string>>>>multi_t;...multi_tm=...;m.find("boost");// passed a const char*, not a std::string

In previous versions of the library, the find operation generates
several temporary std::strings (one every time an internal comparison is made).
In sufficiently advanced compilers, this is now avoided so that only one temporary is
created.

The erase(iterator) member function of hashed indices
used to have poor performance under low load conditions due to the requirement
that an iterator to the next element must be returned (see ticket
#4264). In accordance with
the resolution of LWG
issue #579, this problem has been fixed while maintaining the interface of
erase, at the expense of using one more
word of memory per element. In fact, C++ complexity requirements on unordered
associative containers have been improved for hashed indices so that

deletion of a given element is unconditionally constant-time,

worst-case performance is not O(n) but O(ndist),
where ndist is the number of non-equivalent elements in the index.

Due to the fact that hashed indices rely on a new data structure, the internal representation of
their iterators and local iterators have changed, which affects serialization: their corresponding
serialization class version has been
bumped from 0 to 1. Old archives involving hashed index (local) iterators can be loaded
by Boost 1.56 version of Boost.MultiIndex, but not the other way around.

Hashed indices now provide reserve.

Hashed indices can now be checked for equality and inequality following the
(suitably adapted) C++ standard specification in [unord.req].

The public interface of Boost.MultiIndex provide noexcept specifications
where appropriate (for compliant compilers).

Improved performance of failed insertions into a multi_index_container.

Much internal code aimed at supporting MSVC++ 7.0 and prior has been removed.
Compilation times without this legacy code might be slightly faster.

Boost.MultiIndex has been brought to a higher level of compliance
with C++11.

multi_index_container is now efficiently movable.

Initializer lists supported.

Emplace functions provided.

Non-copyable elements (such as std::unique_ptr<T>) supported. This includes
insertion of a range [first,last) where the iterators point to a type that is
convertible to that of the element: no copy construction happens in the process.

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.

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:

typedefmulti_index_container<int,indexed_by<sequenced<>>>sequenced_container;std::list<int>l(...);sequenced_containerc;// iterator-based overload of assignc.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.

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.

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:

Concurrent access to different containers is safe.

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.

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.