meta.hpp File Reference
Include dependency graph for meta.hpp:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  all<... >
 
struct  all< B, Bs... >
 
struct  all<>
 
struct  all_of< class, class,... >
 
struct  all_of< list< Ts... >, F, Args... >
 
struct  any<... >
 
struct  any< B, Bs... >
 
struct  any<>
 
struct  any_of< class, class,... >
 
struct  any_of< list< Ts... >, F, Args... >
 
struct  apply< class,... >
 
struct  convert< class, class >
 
struct  convert< list< Ts... >, To >
 
struct  count< T, U >
 
struct  count< T, U >
 
struct  count_if< class, class,... >
 
struct  count_if< list< Ts... >, F, Args... >
 
struct  deducer<... >
 
struct  detect< T, V, Detector, Args >
 
struct  detect< T, deduce< Detector< Args... > >, Detector, Args... >
 
struct  equal< class, class >
 
struct  filter< class, class,... >
 
struct  filter< list< Ts... >, F, Args... >
 
struct  find< T, U >
 
struct  find< T, U >
 
struct  find_if< class, class,... >
 
struct  find_if< list< T, Ts... >, F, Args... >
 
struct  find_if< list<>, F, Args... >
 
struct  get< class, size_t >
 
struct  get< list< T, Ts... >, 0 >
 
struct  get< list< T, Ts... >, N >
 
struct  head< class >
 
struct  head< list< T, Ts... > >
 
struct  identity< T >
 
struct  index_of< class, class >
 
struct  index_of< list< Ts... >, T >
 
struct  into< class >
 
struct  into< T< Ts... > >
 
struct  is_specialization_of< T, U >
 
struct  is_specialization_of< T< Ts... >, T >
 
struct  join<... >
 
struct  join< list< Ts... > >
 
struct  join< list< Ts... >, list< Us... >, Vs... >
 
struct  list< Ts >
 
struct  map< class, class,... >
 
struct  map< list< Ts... >, F, Args... >
 
struct  none<... >
 
struct  none< B, Bs... >
 
struct  none<>
 
struct  none_of< class, class,... >
 
struct  none_of< list< Ts... >, F, Args... >
 
struct  rebind< class, class >
 
struct  rebind< list< Ts... >, To< Us... > >
 
struct  reverse< class >
 
struct  rotate< class, size_t >
 
struct  tail< class >
 
struct  tail< list< T, Ts... > >
 
struct  index_sequence_from< class >
 
struct  integer_sequence< T, I >
 
struct  iota< T, Index, N >
 
struct  iota< T, Index, 0u >
 

Namespaces

 core
 
Copyright © 2013 - 2015 MNMLSTC.
 
 core::v2
 
 core::v2::meta
 
 core::v2::meta::impl
 

Typedefs

template<class T , template< class... > class F, class... Args>
using all_of_t = impl::all_of< T, F, Args... >
 
template<bool... Bs>
using all_t = impl::all< Bs... >
 
template<class T , template< class... > class F, class... Args>
using any_of_t = impl::any_of< T, F, Args... >
 
template<bool... Bs>
using any_t = impl::any< Bs... >
 
template<bool B>
using boolean = integral< bool, B >
 
template<class T , template< class... > class U>
using convert = typename impl::convert< T, U >::type
 
template<class T , template< class... > class F, class... Args>
using count_if_t = impl::count_if< T, F, Args... >
 
template
<
class
T
,
class
U
>
using count_t = impl::count< T, U >
 
template<class... Ts>
using deduce = typename deducer< Ts... >::type
 
template<class... Ts>
using deduce = typename impl::deduce< Ts... >
 
template<bool B, class T , class F >
using either = typename ::std::conditional< B, T, F >::type
 
using false_t = ::std::false_type
 
template
<
class
T
,
class
U
>
using find = typename impl::find< T, U >::type
 
template<class T , template< class... > class F, class... Args>
using find_if = typename impl::find_if< T, F >::type
 
template<class T , size_t N>
using get = typename impl::get< T, N >::type
 
template
<
class
T
>
using head = typename impl::head< T >::type
 
template
<
class
T
,
class
U
>
using index_of_t = impl::index_of< T, U >
 
template<::std::size_t... I>
using index_sequence = integer_sequence<::std::size_t, I... >
 
template<class... Ts>
using index_sequence_for = make_index_sequence< sizeof...(Ts)>
 
template<bool B>
using inhibit = unless< B, ::std::size_t >
 
template<class T , T V>
using integral = ::std::integral_constant< T, V >
 
template
<
class
T
>
using into = typename impl::into< T >::type
 
template<class... Ts>
using join = typename impl::join< Ts... >::type
 
template<::std::size_t N>
using make_index_sequence = make_integer_sequence<::std::size_t, N >
 
template<class T , T N>
using make_integer_sequence = typename iota< T, N, N >::type
 
template<class T , template< class... > class F, class... Args>
using none_of_t = impl::none_of< T, F, Args... >
 
template<bool... Bs>
using none_t = impl::none< Bs... >
 
template
<
class
T
,
class
U
>
using rebind = typename impl::rebind< T, U >::type
 
template<bool B>
using require = when< B, ::std::size_t >
 
template
<
class
T
>
using tail = typename impl::tail< T >::type
 
using true_t = ::std::true_type
 
template<bool B, class T = void>
using unless = typename ::std::enable_if< not B, T >::type
 
template<bool B, class T = void>
using when = typename ::std::enable_if< B, T >::type
 

Functions

template<bool... Bs>
constexpr bool all () noexcept
 
template<class T , template< class... > class F, class... Args>
constexpr bool all_of () noexcept
 
template<bool... Bs>
constexpr bool any () noexcept
 
template<class T , template< class... > class F, class... Args>
constexpr bool any_of () noexcept
 
template
<
class
T
,
class
U
>
constexpr ::std::size_t count () noexcept
 
template<class T , template< class... > class F, class... Args>
constexpr ::std::size_t count_if () noexcept
 
template
<
class
T
,
class
U
>
constexpr ::std::size_t index_of () noexcept
 
template<bool... Bs>
constexpr bool none () noexcept
 
template<class T , template< class... > class F, class... Args>
constexpr bool none_of () noexcept