namespace boost {
namespace bimaps {
template< class KeyType >
struct vector_of;
struct vector_of_relation;
} // namespace bimap
} // namespace boost

vector_of views - это последовательности свободного порядка с постоянным временным позиционным доступом и итераторами случайного доступа. Элементы в векторе_вида по умолчанию отсортированы в соответствии с их порядком вставки: это означает, что новые элементы, вставленные через другой вид<bimap>, прилагаются к концу вектора_вида; кроме того, предусмотрены средства для дальнейшей перестановки элементов. Публичный интерфейс vector_of view включает в себя интерфейс list_of views с различиями в сложности операций, а также дополнительные операции для позиционного доступа (<operator[]>и<at()>) и для обработки емкости. Действительность итераторов и ссылки на элементы сохраняются во всех операциях, независимо от состояния мощности.

Как и в случае с list_of views, вектор_of views имеет следующие ограничения в отношении контейнеров последовательностей STL:

Учитывая эти ограничения, вектором просмотров являются моделиКонтейнера случайного доступаиПоследовательности обратной вставки. Хотя эти представления не моделируютFront Insertion Sequence, поскольку вставка и удаление передней части занимают линейное время, операции фронта, тем не менее, предоставляются для соответствия интерфейсу list_of views. Мы описываем только те виды и операции, которые либо не присутствуют в моделируемых концепциях, либо не соответствуют требованиям к этим типам контейнеров.

namespace boost {
namespace bimaps {
namespace views {
template< -implementation defined parameter list- >
class -implementation defined view name-
{
    public:
    // types
    typedef -unspecified- value_type;
    typedef -unspecified- allocator_type;
    typedef -unspecified- reference;
    typedef -unspecified- const_reference;
    typedef -unspecified- iterator;
    typedef -unspecified- const_iterator;
    typedef -unspecified- size_type;
    typedef -unspecified- difference_type;
    typedef -unspecified- pointer;
    typedef -unspecified- const_pointer;
    typedef -unspecified- reverse_iterator;
    typedef -unspecified- const_reverse_iterator;
    typedef -unspecified- info_type;
    // construct / copy / destroy
    this_type & operator=(this_type & x);
    template< class InputIterator >
    void assign(InputIterator first, InputIterator last);
    void assign(size_type n, const value_type & value);
    allocator_type get_allocator() const;
    // iterators
    iterator               begin();
    const_iterator         begin() const;
    iterator               end();
    const_iterator         end() const;
    reverse_iterator       rbegin();
    const_reverse_iterator rbegin() const;
    reverse_iterator       rend();
    const_reverse_iterator rend() const;
    // capacity
    bool      empty() const;
    size_type size() const;
    size_type max_size() const;
    size_type capacity() const;
    void reserve(size_type m);
    void resize(size_type n, const value_type & x = value_type());
    // access
    const_reference operator[](size_type n) const;
    const_reference at(size_type n) const;
    const_reference front() const;
    const_reference back() const;
    // modifiers
    std::pair<iterator,bool> push_front(const value_type & x);
    void                     pop_front();
    std::pair<iterator,bool> push_back(const value_type & x);
    void                     pop_back();
    std::pair<iterator,bool> insert(iterator position, const value_type & x);
    void insert(iterator position, size_type m, const value_type & x);
    template< class InputIterator>
    void insert(iterator position, InputIterator first, InputIterator last);
    iterator erase(iterator position);
    iterator erase(iterator first, iterator last);
    bool replace(iterator position, const value_type & x);
    // Only in map views
    // {
      typedef -unspecified- key_type;
      typedef -unspecified- mapped_type;
      typedef -unspecified- data_type; // Equal to mapped_type
      template< class CompatibleKey >
      bool replace_key(iterator position, const CompatibleKey & x);
      template< class CompatibleData >
      bool replace_data(iterator position, const CompatibleData & x);
      template< class KeyModifier >
      bool modify_key(iterator position, KeyModifier mod);
      template< class DataModifier >
      bool modify_data(iterator position, DataModifier mod);
    // }
    void clear();
    // list operations
    void splice(iterator position, this_type & x);
    void splice(iterator position, this_type & x, iterator i);
    void splice(
        iterator position, this_type & x, iterator first, iterator last);
    void remove(const value_type & value);
    template< class Predicate >
    void remove_if(Predicate pred);
    void unique();
    template< class BinaryPredicate >
    void unique(BinaryPredicate binary_pred);
    void merge(this_type & x);
    template< typename Compare >
    void merge(this_type & x, Compare comp);
    void sort();
    template< typename Compare >
    void sort(Compare comp);
    void reverse();
    // rearrange operations
    void relocate(iterator position, iterator i);
    void relocate(iterator position, iterator first, iterator last);
};
// view comparison
bool operator==(const this_type & v1, const this_type & v2 );
bool operator< (const this_type & v1, const this_type & v2 );
bool operator!=(const this_type & v1, const this_type & v2 );
bool operator> (const this_type & v1, const this_type & v2 );
bool operator>=(const this_type & v1, const this_type & v2 );
bool operator<=(const this_type & v1, const this_type & v2 );
} // namespace views
} // namespace bimap
} // namespace boost

В случае с<bimap<vector_of<Left>,...>>

В представленном виде:

typedef signature-compatible with relation< Left, ... > key_type;
typedef signature-compatible with relation< Left, ... > value_type;

На левой карте вид:

typedef  Left  key_type;
typedef  ...   mapped_type;
typedef signature-compatible with std::pair< Left, ... > value_type;

В правильном виде карты:

typedef  ...  key_type;
typedef  Left mapped_type;
typedef signature-compatible with std::pair< ... , Left > value_type;

this_type & operator=(const this_type & x);

template< class InputIterator >
void assign(InputIterator first, InputIterator last);

void assign(size_type n, const value_type & value);

size_type capacity() const;

void reserve(size_type m);

void resize(size_type n, const value_type & x = value_type());

std::pair<iterator,bool> push_front(const value_type & x);

std::pair<iterator,bool> push_back(const value_type & x);

std::pair<iterator,bool> insert(iterator position, const value_type & x);

void insert(iterator position, size_type m, const value_type & x);

template< class InputIterator >
void insert(iterator position, InputIterator first, InputIterator last);

iterator erase(iterator position);

iterator erase(iterator first, iterator last);

bool replace(iterator position, const value_type & x);

template< class CompatibleKey >
bool replace_key(iterator position, const CompatibleKey & x);

template< class CompatibleData >
bool replace_data(iterator position, const CompatibleData & x);

template< class KeyModifier >
bool modify_key(iterator position, KeyModifier mod);

template< class DataModifier >
bool modify_data(iterator position, DataModifier mod);

void splice(iterator position, this_type & x);

void splice(iterator position, this_type & x,iterator i);

void splice(iterator position, this_type & x, iterator first, iterator last);

void remove(const value_type & value);

template< class Predicate >
void remove_if(Predicate pred);

void unique();

template< class BinaryPredicate >
void unique(BinaryPredicate binary_pred);

void merge(this_type & x);

template< class Compare >
void merge(this_type & x, Compare comp);

void sort();

template< class Compare >
void sort(Compare comp);

void reverse();

void relocate(iterator position, iterator i);

void relocate(iterator position, iterator first, iterator last);