Semantics: typedefs

The following types are implementation defined:

typedef ... value_type;
typedef ... reference;
typedef ... const_reference;
typedef ... pointer;
typedef ... const_pointer;

However, the structure of the type mimics std::pair s.t. one can use first and second members. The reference-types are not real references and the pointer-types are not real pointers. However, one may still write

map_type::value_type       a_value      = *m.begin();
a_value.second->foo();
map_type::reference        a_reference  = *m.begin();
a_reference.second->foo();
map_type::const_reference  a_creference = *const_begin(m);
map_type::pointer          a_pointer    = &*m.begin();
a_pointer->second->foo();
map_type::const_pointer    a_cpointer   = &*const_begin(m);

The difference compared to std::map<Key,T*> is that constness is propagated to the pointer (that is, to second) in const_itertor.

Semantics: modifiers

• iterator insert( key_type& k, T* x );

  • Requirements: x != 0
  • Effects: Takes ownership of x and returns an iterator pointing to it.
  • Throws: bad_pointer if x == 0
  • Exception safety: Strong guarantee

• template< class U > iterator insert( const key_type& k, compatible-smart-ptr<U> x );

  • Equivalent to (but without the const_cast): return insert( const_cast<key_type&>(k), x.release() );

Semantics: pointer container requirements

• void transfer( iterator object, ptr_multimap_adapter& from );

  • Requirements: not from.empty()
  • Effects: Inserts the object defined by object into the container and remove it from from.
  • Postconditions: size() is one more, from.size() is one less.
  • Exception safety: Strong guarantee

• void transfer( iterator first, iterator last, ptr_multimap_adapter& from );

  • Requirements: not from.empty()
  • Effects: Inserts the objects defined by the range [first,last) into the container and remove it from from.
  • Postconditions: Let N == std::distance(first,last); then size() is N more, from.size() is N less.
  • Exception safety: Basic guarantee

• template< class Range > void transfer( const Range& r, ptr_multimap_adapter& from );

  • Effects: transfer( boost::begin(r), boost::end(r), from );

• void transfer( ptr_multimap_adapter& from );

  • Effects: transfer( from.begin(), from.end(), from );.
  • Postconditions: from.empty();
  • Exception safety: Basic guarantee