Метафункции (Внутренние)

Метафункции, которые формируют основной интерфейс класса последовательности описаны в соответствующей концепции последовательности, явялются ее внутренними операциями.

Отличаются от обобщенных алгоритмов с последовательностями тем, что, в обобщенной версии, они должны быть реализованы с нуля для каждого нового класса последовательности. На практике, многие из внутренних метафункций предлагают реализацию по умолчанию, которая будет работать в большинстве случаев, реализация основной функциональности основана на концепции begin/ end.

Аналогичные операции из STL, как правило, реализованы в виде функций-класса.

at

Фомрат:

template

<

typename Sequence,

typename N

>

struct at

{

typedef unspecified type;

};

template

<

typename AssocSeq,

typename Key,

typename Default = unspecified

>

struct at

{

typedef unspecified type;

};

Описание:

Имя at является перегруженным:

• at<Sequence, N>: возвращает N-ый элемент от начала прямой последовательности.

• at<AssocSeq, Key, Default>: возвращает первый элемент, ассоциированный с ключом (Key) в ассоциативной последовательности AssocSeq, в случае отсутствия элемента возвращается Default.

Заголовок:

#include <boost/mpl/at.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
Sequence	Прямая последовательность	Проверяемая последовательность.
AssocSeq	Ассоциативная последовательность	Проверяемая последовательность.
N	Интегральная константа	Смещение от начала последовательности, определяя какой элемент должен быть найден.
Key	Любой тип	Ключ для поиска элемента.
Default	Любой тип	Значение по умолчанию, возвращается если элемент не найден.

Семантика выражений:

• Для любой прямой последовательности s и интегральной константы n:

typedef at<s,n>::type t;

Возвращаемый тип: тип.

Предусловие:

0 <= n::value < size<s>::value.

Семантика: эквивалентна

typedef deref< advance< begin<s>::type,n >::type >::type t;

• Для любой ассоциативной последовательности s и произвольных типов key и x:

typedef at<s,key,x>::type t;

Возвращаемый тип: тип.

Семантика: если

has_key<s,key>::value == true

то t – значение типа, ассоциированного с ключом key, иначае t идентична x.

typedef at<s,key>::type t;

Возвращаемый тип: тип.

Семантика: эквивалентна

typedef at<s,key,void_>::type t;

Сложность:

Архетип последовательности	Сложность
Forward Sequence	Линейная сложность.
Random Access Sequence	Амортизированная постоянная сложность.
Associative Sequence	Амортизированная постоянная сложность.

Пример:

#include <boost\assert.hpp>

#include <boost\mpl\at.hpp>

#include <boost\mpl\range_c.hpp>

#include <boost\mpl\int.hpp>

#include <boost\mpl\equal.hpp>

#include <boost\mpl\tag.hpp>

#include <boost\mpl\set.hpp>

#include <boost\mpl\void.hpp>

using namespace boost;

int main()

{

typedef mpl::range_c<long,10,50> range;

BOOST_MPL_ASSERT_RELATION((mpl::at<range, mpl::int_<0>>::type::value), ==, 10);

BOOST_MPL_ASSERT_RELATION((mpl::at<range, mpl::int_<10>>::type::value), ==, 20);

BOOST_MPL_ASSERT_RELATION((mpl::at<range, mpl::int_<40>>::type::value), ==, 50 );

typedef mpl::set< int const, long*, double > s;

BOOST_MPL_ASSERT((boost::is_same<mpl::at<s,char>::type, mpl::void_> ));// Возвращает пустой тип.

//BOOST_MPL_ASSERT((boost::is_same<mpl::at<s,int>::type, int > )); // Ошибка

return 0;

}

Смотри также:

Forward Sequence, Random Access Sequence, Associative Sequence, at_c, front, back

at_c

Фомрат:

template

<

typename Sequence,

long n

>

struct at_c

{

typedef unspecified type;

};

Описание:

Возвращает тип n-го элемента от начала последовательности.

at_c<Sequence, n>::type

является сокращением записи

at_c<Sequence, long_<n>>::type

Заголовок:

#include <boost/mpl/at.hpp>

Параметры:

Выражение	Требование	Описание
Sequence	Прямая последовательность	Проверяемая последовательность.
n	Интегральная константа времени компиляции	Смещение от начала последовательности, определяя какой элемент должен быть найден.

Семантика выражений:

• Для любой прямой последовательности s и интегральной константы n:

typedef at_c<Sequence,n>::type t;

Возвращаемый тип: тип.

Предусловие:

0 <= n < size<Sequence>::value

Семантика: эквивалентна

typedef at<Sequence, long_<n>>::type t;

Сложность:

Архетип последовательности	Сложность
Forward Sequence	Линейная сложность.
Random Access Sequence	Амортизированная постоянная сложность.

Пример:

#include <boost\assert.hpp>

#include <boost\mpl\at.hpp>

#include <boost\mpl\range_c.hpp>

using namespace boost;

int main()

{

typedef mpl::range_c<long,10,50> range;

BOOST_MPL_ASSERT_RELATION((mpl::at_c<range, 0>::type::value), ==, 10);

BOOST_MPL_ASSERT_RELATION((mpl::at_c<range, 10>::type::value), ==, 20);

BOOST_MPL_ASSERT_RELATION((mpl::at_c<range, 40>::type::value), ==, 50 );

return 0;

}

Смотри также:

Forward Sequence, Random Access Sequence, at, front, back

back

Фомрат:

template<typename Sequence>

struct back

{

typedef unspecified type;

};

Описание:

Возвращает последний элемент последовательности.

Заголовок:

#include <boost/mpl/back.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
Sequence	Двунаправленная последовательность	Проверяемая последовательность.

Семантика выражений:

• Для любой двунаправленной последовательности s:

typedef back<s>::type t;

Возвращаемый тип: тип.

Предусловие:

empty<s>::value == false.

Семантика: эквивалентна

typedef deref< prior< end<s>::type >::type >::type t;

Сложность:

Амортизированное постоянное время.

Пример:

#include <boost\assert.hpp>

#include <boost\mpl\range_c.hpp>

#include <boost\mpl\back.hpp>

using namespace boost;

int main()

{

typedef mpl::range_c<int,0,1> range1;

typedef mpl::range_c<int,0,10> range2;

typedef mpl::range_c<int,-10,0> range3;

BOOST_MPL_ASSERT_RELATION(mpl::back<range1>::type::value, ==, 0 );

BOOST_MPL_ASSERT_RELATION(mpl::back<range2>::type::value, ==, 9 );

BOOST_MPL_ASSERT_RELATION(mpl::back<range3>::type::value, ==, -1 );

return 0;

}

Смотри также:

Bidirectional Sequence, front, push_back, end, deref, at

begin

Фомрат:

template<typename X>

struct begin

{

typedef unspecified type;

};

Описание:

Возвращает итератор, указывающий на первый элемент последовательности. Если аргумент не является прямой последовательностью, то возвращается тип void_.

Заголовок:

#include <boost/mpl/begin_end.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
X	Любой тип	Тип, для которого должен быть возвращен итератор начала, если таковой имеется.

Семантика выражений:

Для любого произвольного типа x:

typedef begin<x>::type first;

Возвращаемый тип: прямой итератор или void_.

Семантика: если x является прямой последовательностью, first является итератором, указывающим на первый элемент s, в противном случае first является void_.

typedef deref< advance< begin<s>::type,n >::type >::type t;

Постусловие: если first является итератором, то это либо разыменование, либо последний элемент последовательности, последний элемент будет возвращен тогда и только тогда, когда

size<x>::value == 0

Сложность:

Амортизированное постоянное время.

Пример:

int main()

{

typedef mpl::vector

<

unsigned char,

unsigned short,

unsigned int,

unsigned long

> unsigned_types;

typedef mpl::begin<unsigned_types>::type iter;

BOOST_MPL_ASSERT((boost::is_same<mpl::deref<iter>::type, unsigned char > ));

BOOST_MPL_ASSERT((boost::is_same<mpl::begin<int>::type, mpl::void_ > ));

return 0;

}

Смотри также:

Iterators, Forward Sequence, end, size, empty

clear

Фомрат:

template<typename Sequence>

struct clear

{

typedef unspecified type;

};

Описание:

Возвращает пустую (empty) последовательность, концепт-иднтичную последовательности-аргументу.

Заголовок:

#include <boost/mpl/clear.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
Sequence	Расширяемя/расширяемая ассоциативная последовательность	Последовательность для получения пустой (empty) копии.

Семантика выражений:

• Для любой расширяемой/расширяемой ассоциативной последовательности s:

typedef clear<s>::type t;

Возвращаемый тип: расширяемая/расширяемая ассоциативная последовательность.

Семантика: эквивалентна

typedef erase< s, begin<s>::type, end<s>::type >::type t;

Постусловие:

empty<s>::value == true.

Сложность:

Амортизированное постоянное время.

Пример:

int main()

{

typedef mpl::vector_c<int,1,3,5,7,9,11> odds;

typedef mpl::clear<odds>::type nothing;

BOOST_MPL_ASSERT(( mpl::empty<nothing> ));

return 0;

}

Смотри также:

Extensible Sequence, Extensible Associative Sequence, erase, empty, begin, end

empty

Фомрат:

template<typename Sequence>

struct empty

{

typedef unspecified type;

};

Описание:

Возвращает интегральную константу с, для которой выполняется инструкция c::value == true, тогда и только тогда, когда в последовательности-аргументе не содержится элементов – является пустой (empty).

Заголовок:

#include <boost/mpl/empty.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
Sequence	Прямая последовательность	Проверяемая последовательность.

Семантика выражений:

Для любой прямой последовательности s:

typedef empty<s>::type c;

Возвращаемый тип: булева интегральная константа.

Семантика: эквивалентна

typedef is_same< begin<s>::type, end<s>::type >::type c;

Постусловия:

empty<s>::value == ( size<s>::value == 0 )

Сложность:

Амортизированное постоянное время.

Пример:

int main()

{

typedef mpl::range_c<int,0,0> _empty_range;

typedef mpl::vector<long, float, double> _types;

BOOST_MPL_ASSERT((mpl::empty<_empty_range>));

BOOST_MPL_ASSERT_NOT((mpl::empty<_types>));

return 0;

}

Смотри также:

Forward Sequence, Integral Constant, size, begin / end

end

Фомрат:

template<typename X>

struct end

{

typedef unspecified type;

};

Описание:

Возвращает итератор, указывющий на позицию, следующую за последней.

Если аргумент не является прямой последовательностью, то возвращается тип void_.

Заголовок:

#include <boost/mpl/begin_end.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
X	Любой тип	Тип, для которого должен быть возвращен итератор следующий за концом, если таковой имеется.

Семантика выражений:

Для любого произвольного типа x:

typedef end<x>::type last;

Возвращаемый тип: прямой итератор или void_.

Семантика: если x – прямая последовательность, то last – итератор, указывющий на позицию, следующую за последней в s, иначе возвращается void_.

Постусловия: если last – итератор, то он указывает на на позицию, следующую за последней.

Сложность:

Амортизированное постоянное время.

Пример:

int main()

{

typedef mpl::vector<long> v;

typedef mpl::begin<v>::type first;

typedef mpl::end<v>::type last;

BOOST_MPL_ASSERT(( boost::is_same< mpl::next<first>::type, last > ));

return 0;

}

Смотри также:

Iterators, Forward Sequence, begin, end, next

erase

Фомрат:

template

<

typename Sequence,

typename First,

typename Last = unspecified

>

struct erase

{

typedef unspecified type;

};

Описание:

Метафункция erase выполняет удаление одного или нескольких смежных элементов в последовательности, начиная с произвольной позиции.

Заголовок:

#include <boost/mpl/erase.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
Sequence	Расширяемая/расширяемая ассоциативная последовательность	Последовательность для очистки.
First	Прямая последовательность	Итератор начала диапазона очистки.
Last	Прямая последовательность	Итератор, следующий за концом диапазона очистки.

Семантика выражений:

• Для любой расширяемой последовательности s и итераторов pos, first и last в s.

1:

typedef erase<s,first,last>::type r;

Возвращаемый тип: расширяемая последовательность.

Предусловие: следующий диапазон должен быть действительным в s

[first,last)

Семантика: r – результирующая последовательность, концепт-идентичная последовательности s, из следующих элементов

[begin<s>::type, pos), [last, end<s>::type)

Постусловие: относительная упорядоченность элементов в r идентична s

size<r>::value == (size<s>::value - distance<first,last>::value)

2:

typedef erase<s,pos>::type r;

Возвращаемый тип: расширяемая последовательность.

Предусловие: pos – разыменованный итератор на s

Семантика: эквивалентна

typedef erase< s,pos,next<pos>::type >::type r;

Постусловие: относительная упорядоченность элементов в r идентична s

• Для любой расширяемой ассоциативной последовательности s и итератора pos в s.

typedef erase<s,pos>::type r;

Возвращаемый тип: расширяемая последовательность.

Предусловие: pos – разыменованный итератор на s.

Семантика: удаление элемента происходит из позиции pos; эквивалнтно

erase_key<s, deref<pos>::type >::type.

Постусловие:

size<r>::value == (size<s>::value – 1)

Сложность:

Архетип последовательности	Сложность
Extensible Associative Sequence	Амортизированное постоянное время.
Extensible Sequence	Квадратичное в худшем случае, линейное в лучшем случае.

Пример:

int main()

{

typedef mpl::vector_c<int,1,0,5,1,7,5,0,5> values;

typedef mpl::find< values, integral_c<int,7>>::type pos;

typedef mpl::erase<values, pos>::type result;

BOOST_MPL_ASSERT_RELATION(mpl::size<result>::value, ==, 7);

typedef mpl::find<result, integral_c<int,7>>::type iter;

BOOST_MPL_ASSERT(( boost::is_same< iter, mpl::end<result>::type > ));

return 0;

}

Смотри также:

Extensible Sequence, Extensible Associative Sequence, erase_key, pop_front, pop_back, insert

erase_key

Фомрат:

template

<

typename AssocSeq,

typename Key

>

struct erase_key

{

typedef unspecified type;

};

Описание:

Удаляет элементы, ассоциированные с ключом Key в расширенной ассоциативной последовательности AssocSeq.

Заголовок:

#include <boost/mpl/erase_key.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
AssocSeq	Расширенная ассоциативная последовательность	Последовательность для очистки.
Key	Любой тип	Ключ key для элементов, которые должны быть удалены.

Семантика выражений:

• Для любой расширенной ассоциативной последовательности s и произвольного типа key:

typedef erase_key<s,key>::type r;

Возвращаемый тип: расширенная ассоциативная последовательность.

Семантика: r – концепт-идентичная последовательность s, кроме инструкции

has_key<r,k>::value == false

Постусловие:

size<r>::value == (size<s>::value – 1)

Сложность:

Амортизированное постоянное время.

Пример:

int main()

{

typedef mpl::map<mpl::pair<int,unsigned>, mpl::pair<char,long>> m;

typedef mpl::erase_key<m,char>::type m1;

BOOST_MPL_ASSERT_RELATION( mpl::size<m1>::type::value, ==, 1 );

BOOST_MPL_ASSERT((boost::is_same< mpl::at<m1,char>::type,void_ > ));

BOOST_MPL_ASSERT((boost::is_same< mpl::at<m1,int>::type,unsigned > ));

return 0;

}

Смотри также:

Extensible Associative Sequence, erase, has_key, insert

front

Фомрат:

template<typename Sequence>

struct front

{

typedef unspecified type;

};

Описание:

Возвращает первый элемент последовательности.

Заголовок:

#include <boost/mpl/front.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
Sequence	Прямая последовательность	Проверяемая последовательность.

Семантика выражений:

• Для любой прямой последовательности s:

typedef front<s>::type t;

Возвращаемый тип: тип.

Предусловие:

empty<s>::value == false.

Семантика: эквивалентна

typedef deref< begin<s>::type >::type t;

Сложность:

Амортизированное постоянное время.

Пример:

int main()

{

typedef mpl::list<long>::type types1;

typedef mpl::list<int,long>::type types2;

typedef mpl::list<char,int,long>::type types3;

BOOST_MPL_ASSERT((boost::is_same< mpl::front<types1>::type, long > ));

BOOST_MPL_ASSERT((boost::is_same< mpl::front<types2>::type, int> ));

BOOST_MPL_ASSERT((boost::is_same< mpl::front<types3>::type, char> ));

return 0;

}

Смотри также:

Forward Sequence, back, push_front, begin, deref, at

has_key

Фомрат:

template

<

typename Sequence,

typename Key

>

struct has_key

{

typedef unspecified type;

};

Описание:

Возвращает правидивое значение интегральной константы, если Sequence содержит элемент с ключом Key.

Заголовок:

#include <boost/mpl/has_key.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
AssocSeq	Ассоциативная последовательность	Последовательность для запроса.
Key	Любой тип	Запрашиваемый ключ key.

Семантика выражений:

• Для любой ассоциативной последовательности s и произвольного типа key:

typedef has_key<s,key>::type c;

Возвращаемый тип: булева интегральная константа.

Семантика:

c::value == true

если ключ key есть в множестве ключей s; в противном случае

c::value == false.

Постусловие:

size<r>::value == (size<s>::value – 1)

Сложность:

Амортизированное постоянное время.

Пример:

int main()

{

typedef mpl::map< mpl::pair<int,unsigned>, mpl::pair<char,long>> m;

BOOST_MPL_ASSERT_NOT(( mpl::has_key<m, long> ));

typedef mpl::insert< m, mpl::pair<long, unsigned long>>::type m1;

BOOST_MPL_ASSERT((mpl::has_key<m1, long>));

return 0;

}

Смотри также:

Associative Sequence, count, insert, erase_key

insert

Фомрат:

template

<

typename Sequence,

typename Pos,

typename T

>

struct insert

{

typedef unspecified type;

};

template

<

typename Sequence,

typename T

>

struct insert

{

typedef unspecified type;

};

Описание:

Имя insert является перегруженным:

• insert<Sequence,Pos,T>: выполняет вставку типа Т в произвольную позицию Pos в последовательности. Pos игнорируется, если модель последовательности Sequence является расширенная ассоциативная последовательность.

• insert<Sequence,T>: сокращенная форма вставки

insert<Sequence,Pos,T>

если модель последовательности Sequence является расширенная ассоциативная последовательность.

Заголовок:

#include <boost/mpl/insert.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
Sequence	Расширенная/расширенная ассоциативная последовательность	Последовательность, в которую осуществляется вствка.
Pos	Прямая последовательность	Итератор в последовательности, определяющий позицию вставки.
T	Любой тип	Элемент вставки.

Семантика выражений:

• Для любой расширяемой последовательности s, итератора pos в s, произвольного типа х:

typedef insert<s,pos,x>::type r;

Возвращаемый тип: расширяемая последовательность.

Предусловие: pos – итератор в s.

Семантика: r – результирующая последовательность, концепт-идентичная последовательности s, из следующих элементов

[begin<s>::type, pos), x, [pos, end<s>::type)

Постусловие: относительная упорядоченность элементов в r идентична s

at< r, distance< begin<s>::type, pos >::type >::type

идентична вставленному типу х;

size<r>::value == (size<s>::value + 1);

• Для любой расширяемой ассоциативной последовательности s, итератора pos в s, произвольного типа х.

1:

typedef insert<s,x>::type r;

Возвращаемый тип: расширяемая ассоциативная последовательность.

Семантика: r – результирующая последовательность, концепт-идентичная и эквивалентная последовательности s, кроме инструкции

at<r, key_type<s,x>::type>::type

что идентично

value_type<s,x>::type

Постусловие:

size<r>::value == (size<s>::value + 1)

2:

typedef insert<s,pos,x>::type r;

Возвращаемый тип: расширяемая ассоциативная последовательность.

Предусловие: pos – итератор в s.

Семантика: pos игнорируется. Эквивалентно

typedef insert<s,x>::type r;

Сложность:

Архетип последовательности	Сложность
Extensible Associative Sequence	Амортизированное постоянное время.
Extensible Sequence	Линейное в худшем случае, или амортизированное постоянное время.

Пример:

int main()

{

typedef mpl::vector_c<int,0,1,3,4,5,6,7,8,9> numbers;

typedef mpl::find<numbers, mpl::integral_c<int,3>>::type pos;

typedef mpl::insert<numbers,pos, mpl::integral_c<int,2>>::type range;

BOOST_MPL_ASSERT_RELATION( mpl::size<range>::value, ==, 10 );

BOOST_MPL_ASSERT(( mpl::equal< range, mpl::range_c<int,0,10>> ));

typedef mpl::map< mpl::pair<int,unsigned> > m;

typedef insert<m, mpl::pair<char,long>>::type m1;

BOOST_MPL_ASSERT_RELATION( mpl::size<m1>::value, ==, 2 );

BOOST_MPL_ASSERT(( boost::is_same<mpl::at<m1,int>::type, unsigned> ));

BOOST_MPL_ASSERT(( boost::is_same<mpl::at<m1,char>::type, long> ));

return 0;

}

Смотри также:

Extensible Sequence, Extensible Associative Sequence, insert_range, push_front, push_back, erase

insert_range

Фомрат:

template

<

typename Sequence,

typename Pos,

typename Range

>

struct insert_range

{

typedef unspecified type;

};

Описание:

Метафункция insert_range выполняет вставку диапазона элементов в произвольную позицию в последовательности.

Заголовок:

#include <boost/mpl/insert_range.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
Sequence	Расширенная/расширенная ассоциативная последовательность	Последовательность, в которую осуществляется вствка.
Pos	Прямая последовательность	Итератор в последовательности, определяющий позицию вставки.
Range	Прямая последовательность	Диапазон элементов для вставки.

Семантика выражений:

• Для любой расширяемой последовательности s, итератора pos в s, прямой последовательности range:

typedef insert_range<s,pos,range>::type r;

Возвращаемый тип: расширяемая последовательность.

Предусловие: pos – итератор в s.

Семантика: r – результирующая последовательность, концепт-идентичная последовательности s, из следующих элементов

[begin<s>::type, pos), [begin<r>::type, end<r>::type), [pos, end<s>::type)

Постусловие: относительная упорядоченность элементов в r идентична s

size<r>::value == (size<s>::value + size<range>::value)

Сложность:

Зависит от конкретной последовательности. Квадратичное время в худшем случае, линейное в лучшем случае. Смотри спецификацию конкретного класса последовательности для деталей.

Пример:

int main()

{

typedef mpl::vector_c<int,0,1,7,8,9> numbers;

typedef mpl::find<numbers, mpl::integral_c<int,7> >::type pos;

typedef mpl::insert_range<numbers, pos, mpl::range_c<int,2,7>>::type range;

BOOST_MPL_ASSERT_RELATION((mpl::size<range>::value), ==, 10 );

BOOST_MPL_ASSERT(( mpl::equal<range, mpl::range_c<int,0,10>> ));

typedef mpl::insert_range<

mpl::list0<>, // Принимает вствку.

mpl::end<list0<>>::type, // Позиция для вставки.

mpl::list<int> // Последовательность для вставки.

>::type result2;

BOOST_MPL_ASSERT_RELATION( mpl::size<result2>::value, ==, 1 );

return 0;

}

Смотри также:

Extensible Sequence, insert, push_front, push_back, erase

is_sequence

Фомрат:

template<typename X>

struct is_sequence

{

typedef unspecified type;

};

Описание:

Возвращает булеву интегральную константу c, для которой c::value == true, тогда и только тогда, когда Х – модель прямой последовательности.

Заголовок:

#include <boost/mpl/is_sequence.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
Х	Любой тип	Тип запроса.

Семантика выражений:

typedef is_sequence<X>::type c;

Возвращаемый тип: булева интегральная константа.

Семантика: эквивалента

typedef not_< is_same<begin<T>::type, void_>>::type c;

Сложность:

Амортизированное постоянное время.

Пример:

int main()

{

struct UDT {};

BOOST_MPL_ASSERT_NOT((mpl::is_sequence< std::vector<int>> ));

BOOST_MPL_ASSERT_NOT((mpl::is_sequence< int > ));

BOOST_MPL_ASSERT_NOT(( mpl::is_sequence< int& > ));

BOOST_MPL_ASSERT_NOT(( mpl::is_sequence< UDT > ));

BOOST_MPL_ASSERT_NOT(( mpl::is_sequence< UDT* > ));

BOOST_MPL_ASSERT(( mpl::is_sequence< mpl::range_c<int,0,0> > ));

BOOST_MPL_ASSERT(( mpl::is_sequence< mpl::list<> > ));

BOOST_MPL_ASSERT(( mpl::is_sequence< mpl::list<int> > ));

BOOST_MPL_ASSERT(( mpl::is_sequence< mpl::vector<> > ));

BOOST_MPL_ASSERT(( mpl::is_sequence< mpl::vector<int> > ));

return 0;

}

Смотри также:

Forward Sequence, begin, end, vector, list, range_c

key_type

Фомрат:

template

<

typename Sequence,

typename X

>

struct key_type

{

typedef unspecified type;

};

Описание:

Возвращает ключ key, который может использоваться для идентификации Х в последовательности Sequence.

Заголовок:

#include <boost/mpl/key_type.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
Sequence	Ассоциативная последовательность	Последовательность для запроса.
T	Любой тип	Тип для получения ключа.

Семантика выражений:

• Для любой ассоциативной последовательности s, итераторов pos1 и pos2 в s, произвольного типа х:

typedef key_type<s,x>::type k;

Возвращаемый тип: тип.

Предусловие: x может быть помещен в s.

Семантика: k – ключ, который может быть использован для идентификации x в s.

Постусловие: если

key_type< s,deref<pos1>::type >::type

идентична

key_type<s,deref<pos2>::type >::type

то pos1 идентичен pos2.

Сложность:

Амортизированное постоянное время.

Пример:

int main()

{

// ключ: pair::first == int:

typedef mpl::key_type< mpl::map<>, mpl::pair<int,unsigned> >::type k1;

// ключ: mpl::pair<int,unsigned>:

typedef mpl::key_type< mpl::set<>, mpl::pair<int,unsigned> >::type k2;

BOOST_MPL_ASSERT(( boost::is_same< k1,int > ));

BOOST_MPL_ASSERT(( boost::is_same< k2, mpl::pair<int,unsigned> > )); //!

return 0;

}

Смотри также:

Associative Sequence, value_type, has_key, set, map

order

Фомрат:

template

<

typename Sequence,

typename Key

>

struct order

{

typedef unspecified type;

};

Описание:

Возвращает уникальную беззнаковую интегральную константу, ассоциированную с ключом Key в последовательности-аргументе Sequence, в противном случае void_.

Заголовок:

#include <boost/mpl/order.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
Sequence	Ассоциативная последовательность	Последовательность для запроса.
Key	Любой тип	Запрашиваемый ключ.

Семантика выражений:

• Для любой ассоциативной последовательности s и произвольного типа key:

typedef order<s,key>::type n;

Возвращаемый тип: беззнаковая интегральная константа..

Семантика: если

has_key<s,key>::value == true

то n - уникальная беззнаковая интегральная константа, ассоциированная с ключом key в s, в противном случае n идентифицируется как void_.

Сложность:

Амортизированное постоянное время.

Пример:

int main()

{

typedef mpl::map<mpl::pair<int,unsigned>, mpl::pair<char,long>> m;

BOOST_MPL_ASSERT_NOT(( boost::is_same< mpl::order<m,int>::type, mpl::void_ > ));

BOOST_MPL_ASSERT(( boost::is_same< mpl::order<m,long>::type, mpl::void_ > ));

return 0;

}

Смотри также:

Associative Sequence, has_key, count, map

pop_back

Фомрат:

template<typename Sequence>

struct pop_back

{

typedef unspecified type;

};

Описание:

Выполняет удаление последнего элемента последовательности. Гарантия сложности О(1).

Заголовок:

#include <boost/mpl/pop_back.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
Sequence	Расширенная последовательность конца	Последовательность для удаления последнего элемента.

Семантика выражений:

• Для любой расширяемой последовательности конца s:

typedef pop_back<s>::type r;

Возвращаемый тип: расширяемая последовательность конца.

Предусловие:

empty<s>::value == false.

Семантика: эквивалентно

erase<s,end<s>::type>::type;

Постусловие:

size<r>::value == (size<s>::value – 1).

Сложность:

Амортизированное постоянное время.

Пример:

int main()

{

typedef mpl::vector<long>::type types1;

typedef mpl::vector<long,int>::type types2;

typedef mpl::vector<long,int,char>::type types3;

typedef mpl::pop_back<types1>::type result1;

typedef mpl::pop_back<types2>::type result2;

typedef mpl::pop_back<types3>::type result3;

BOOST_MPL_ASSERT_RELATION( mpl::size<result1>::value, ==, 0 );

BOOST_MPL_ASSERT_RELATION( mpl::size<result2>::value, ==, 1 );

BOOST_MPL_ASSERT_RELATION( mpl::size<result3>::value, ==, 2 );

BOOST_MPL_ASSERT(( boost::is_same< mpl::back<result2>::type, long> ));

BOOST_MPL_ASSERT(( boost::is_same< mpl::back<result3>::type, int > ));

return 0;

}

Смотри также:

Back Extensible Sequence, erase, push_back, back, pop_front

pop_front

Фомрат:

template<typename Sequence>

struct pop_front

{

typedef unspecified type;

};

Описание:

Выполняет удаление первого элемента последовательности. Гарантия сложности О(1).

Заголовок:

#include <boost/mpl/pop_front.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
Sequence	Расширенная последовательность начала	Последовательность для удаления первого элемента.

Семантика выражений:

• Для любой расширяемой последовательности начала s:

typedef pop_front<s>::type r;

Возвращаемый тип: расширяемая последовательность начала.

Предусловие:

empty<s>::value == false.

Семантика: эквивалентно

erase<s,begin<s>::type>::type;

Постусловие:

size<r>::value == (size<s>::value – 1).

Сложность:

Амортизированное постоянное время.

Пример:

int main()

{

typedef mpl::vector<long>::type types1;

typedef mpl::vector<long,int>::type types2;

typedef mpl::vector<long,int,char>::type types3;

typedef mpl::pop_front<types1>::type result1;

typedef mpl::pop_front<types2>::type result2;

typedef mpl::pop_front<types3>::type result3;

BOOST_MPL_ASSERT_RELATION( mpl::size<result1>::value, ==, 0 );

BOOST_MPL_ASSERT_RELATION( mpl::size<result2>::value, ==, 1 );

BOOST_MPL_ASSERT_RELATION( mpl::size<result3>::value, ==, 2 );

BOOST_MPL_ASSERT(( boost::is_same< mpl::front<result2>::type, int> ));

BOOST_MPL_ASSERT(( boost::is_same< mpl::front<result3>::type, int > ));

return 0;

}

Смотри также:

Front Extensible Sequence, erase, push_front, front, pop_back

push_back

Фомрат:

template

<

typename Sequence,

typename T

>

struct push_back

{

typedef unspecified type;

}

Описание:

Выполняет вставку элемента в конец последовательности. Гарантия сложности О(1).

Заголовок:

#include <boost/mpl/push_back.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
Sequence	Расширенная последовательность конца	Последовательность для вставки элемента.
T	Любой тип	Элемент для вставки.

Семантика выражений:

• Для любой расширяемой последовательности конца s и произвольного типа х:

typedef push_back<s,x>::type r;

Возвращаемый тип: расширяемая последовательность конца.

Семантика: эквивалентно

typedef insert< s,end<s>::type,x >::type r;

Постусловие: тип x идентичен

back<r>::type

Выполняется инструкция:

size<r>::value == (size<s>::value + 1).

Сложность:

Амортизированное постоянное время.

Пример:

int main()

{

typedef mpl::vector_c<bool,false,false,false,true,true,true,false,false> bools;

typedef mpl::push_back<bools,mpl::false_>::type message;

BOOST_MPL_ASSERT_RELATION( mpl::back<message>::type::value, ==, false );

BOOST_MPL_ASSERT_RELATION

((

mpl::count_if< // Условный подсчет элементов.

message,

mpl::equal_to<mpl::_1, mpl::false_> // Предикат (сколько false).

>::value ), ==, 6

);

return 0;

};

Смотри также:

Back Extensible Sequence, insert, pop_back, back, push_front

push_front

Фомрат:

template

<

typename Sequence,

typename T

>

struct push_front

{

typedef unspecified type;

};

Описание:

Выполняет вставку элемента в начало последовательности. Гарантия сложности О(1).

Заголовок:

#include <boost/mpl/push_front.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
Sequence	Расширенная последовательность начала	Последовательность для вставки элемента.
T	Любой тип	Элемент для вставки.

Семантика выражений:

• Для любой расширяемой последовательности начала s и произвольного типа х:

typedef push_front<s,x>::type r;

Возвращаемый тип: расширяемая последовательность начала.

Семантика: эквивалентно

ypedef insert< s,begin<s>::type,x >::type r;

Постусловие: тип x идентичен

front<r>::type

Выполняется инструкция:

size<r>::value == (size<s>::value + 1).

Сложность:

Амортизированное постоянное время.

Пример:

int main()

{

typedef mpl::vector_c<int,1,2,3,5,8,13,21> v;

BOOST_MPL_ASSERT_RELATION( mpl::size<v>::value, ==, 7 );

typedef push_front<v, mpl::integral_c<int,1>>::type fibonacci;

BOOST_MPL_ASSERT_RELATION( mpl::size<fibonacci>::value, ==, 8 );

BOOST_MPL_ASSERT

((

mpl::equal<

fibonacci,

mpl::vector_c<int,1,1,2,3,5,8,13,21>,

mpl::equal_to<mpl::_,mpl::_>

>

));

return 0;

};

Смотри также:

Front Extensible Sequence, insert, pop_front, front, push_back

sequence_tag

Фомрат:

template<typename X>

struct sequence_tag

{

typedef unspecified type;

};

Описание:

Является метафункций для всех внутренний опреаций с последовательностями, которые применяют тэг диспетчеризации.

Заголовок:

#include <boost/mpl/sequence_tag.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
X	Любой тип	Тип для получения тэга последовательности.

Семантика выражений:

Для любого произвольного типа х:

typedef sequence_tag<x>::type tag;

Возвращаемый тип: тип.

Семантика: tag – неопредленный тип тэга для x.

Сложность:

Амортизированное постоянное время.

Пример:

#define PRINT(value) cout << typeid(value).name() << '\n'

//+--------------------------------------------------------------------+

int main()

{

PRINT(mpl::sequence_tag<int>::type);

typedef mpl::vector_c<int,1,2,3,5,8,13,21> v;

PRINT(mpl::sequence_tag<v>::type);

return 0;

};

Смотри также:

Intrinsic Metafunctions, Tag Dispatched Metafunction

size

Фомрат:

template<typename Sequence>

struct size

{

typedef unspecified type;

};

Описание:

Возвращает количество элементов в последовательности, что явялется количеством элементов в следующем диапазоне:

[begin<Sequence>::type, end<Sequence>::type)

Заголовок:

#include <boost/mpl/size.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
Sequence	Прямая последовательность	Последовательность для запроса.

Семантика выражений:

Для любой прямой последовательности s:

typedef size<s>::type n;

Возвращаемый тип: интегральная константа.

Семантика: эквивалнтно

typedef distance< begin<s>::type, end<s>::type >::type n;

Постусловие:

n::value >= 0.

Сложность:

Сложность напрямую зависит от реализации определенной последовательности, для которой используется данная метафункция. В худшем случае, гарантия сложности - линейная.

Если s - последовательность произвольного доступа, гарантия сложности O(1). Обратное не всегда верно, например, последовательность классов, моделью которых есть прямая последовательность еще может дать гарантию сложности O(1).

Пример:

int main()

{

typedef mpl::list0<> empty_list;

typedef mpl::vector_c<int,0,1,2,3,4,5> numbers;

typedef mpl::range_c<int,0,100> more_numbers;

BOOST_MPL_ASSERT_RELATION( mpl::size<empty_list>::value, ==, 0 );

BOOST_MPL_ASSERT_RELATION( mpl::size<numbers>::value, ==, 6 );

BOOST_MPL_ASSERT_RELATION( mpl::size<more_numbers>::value, ==, 100 );

return 0;

};

Смотри также:

Forward Sequence, Random Access Sequence, empty, begin, end, distance

value_type

Фомрат:

template

<

typename Sequence,

typename X

>

struct value_type

{

typedef unspecified type;

};

Описание:

Возвращает значение, которое может быть использовано для для элемента Х в последовательности Sequence.

Заголовок:

#include <boost/mpl/value_type.hpp>

Модель:

• Tag Dispatched Metafunction

Параметры:

Выражение	Требование	Описание
Sequence	Ассоциативная последовательность	Последовательность для запроса.
X	Любой тип	Тип для получения значения.

Семантика выражений:

Для любой ассоциативной последовательности s и произвольного типа х:

typedef value_type<s,x>::type v;

Возвращаемый тип: тип.

Предусловие: x может быть помещен в s.

Семантика: v – значение, которое может быть использовано для x в s.

Постусловие: если

has_key< s,key_type<s,x>::type >::type

то

at< s,key_type<s,x>::type >::type

идентичен

value_type<s,x>::type

Сложность:

Амортизированное постоянное время.

Пример:

int main()

{

typedef mpl::value_type< mpl::map<>, mpl::pair<int,unsigned>>::type v1;

typedef value_type<mpl::set<>, mpl::pair<int,unsigned>>::type v2;

BOOST_MPL_ASSERT((boost::is_same< v1,unsigned > ));

BOOST_MPL_ASSERT((boost::is_same< v2, mpl::pair<int,unsigned> > ));

return 0;

};

Смотри также:

Associative Sequence, key_type, at, set, map