# CAMP

Library API

File Hierarchy

Full API

Namespaces

Namespace camp

Namespaces
Classes
Functions
Typedefs

Namespace camp::resources

Page Contents

Namespaces

Namespace camp::type::rvref

Page Contents

Typedefs

Classes and Structs

Template Struct accumulate

Template Parameter Order
  1. template< typename... > class Op

  2. typename Initial

  3. typename Seq

Struct Documentation
template<template<typename...> class Op, typename Initial, typename Seq>
struct accumulate

Template Struct accumulate< Op, Initial, list< Elements… > >

Template Parameter Order
  1. template< typename... > class Op

  2. typename Initial

  3. typename... Elements

Struct Documentation
template<template<typename...> class Op, typename Initial, typename ...Elements>
struct accumulate<Op, Initial, list<Elements...>>

Public Types

using type = typename detail::accumulate_impl<Op, Initial, Elements...>::type

Template Struct append

Template Parameter Order
  1. typename Seq

  2. typename T

Struct Documentation
template<typename Seq, typename T>
struct append

Template Struct append< list< Elements… >, T >

Template Parameter Order
  1. typename... Elements

  2. typename T

Struct Documentation
template<typename ...Elements, typename T>
struct append<list<Elements...>, T>

Public Types

using type = list<Elements..., T>

Template Struct apply_l

Template Parameter Order
  1. typename Lambda

  2. typename Seq

Struct Documentation
template<typename Lambda, typename Seq>
struct apply_l

Template Struct apply_l< Lambda, list< Args… > >

Template Parameter Order
  1. typename Lambda

  2. typename... Args

Struct Documentation
template<typename Lambda, typename ...Args>
struct apply_l<Lambda, list<Args...>>

Public Types

using type = typename Lambda::template expr<Args...>::type

Template Struct arg

Template Parameter Order
  1. idx_t n

Struct Documentation
template<idx_t n>
struct arg

Public Types

using expr = typename at<list<Ts...>, num<n - 1>>::type

Template Struct as_list_s

Inheritance Relationships
Base Type
  • public detail::_as_list::type< T >

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T>
struct as_list_s : public detail::_as_list::type<T>

Template Struct as_list_s< tagged_tuple< camp::list< Tags… >, Args… > >

Template Parameter Order
  1. typename... Tags

  2. typename... Args

Struct Documentation
template<typename ...Tags, typename ...Args>
struct as_list_s<tagged_tuple<camp::list<Tags...>, Args...>>

Public Types

using type = list<Args...>

Template Struct at

Template Parameter Order
  1. typename Seq

  2. typename Num

Struct Documentation
template<typename Seq, typename Num>
struct at

Template Struct at< T, num< Val > >

Template Parameter Order
  1. typename T

  2. idx_t Val

Struct Documentation
template<typename T, idx_t Val>
struct at<T, num<Val>>

Public Types

using type = typename detail::_at<T, Val>::type

Template Struct at_key_s

Template Parameter Order
  1. typename Seq

  2. typename Key

Struct Documentation
template<typename Seq, typename Key>
struct at_key_s

Public Types

using type = decltype(detail::lookup<Key>(declptr<detail::lookup_table<Seq>>()))

Template Struct bind

Template Parameter Order
  1. template< typename... > class Expr

  2. typename... ArgBindings

Struct Documentation
template<template<typename...> class Expr, typename ...ArgBindings>
struct bind

Public Types

using bindings = list<ArgBindings...>
using expr = typename Expr<typename detail::get_bound_arg<ArgBindings, Ts...>::type...>::type
using type = bind

Template Struct bind_front

Template Parameter Order
  1. template< typename... > class Expr

  2. typename... BoundArgs

Struct Documentation
template<template<typename...> class Expr, typename ...BoundArgs>
struct bind_front

Public Types

using expr = typename Expr<BoundArgs..., Ts...>::type
using type = bind_front

Template Struct all_of

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct all_of : public camp::concepts::metalib::all_of_t<Args...>

metaprogramming concept for SFINAE checking of aggregating concepts

Template Struct any_of

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct any_of : public camp::concepts::metalib::any_of_t<Args...>

metaprogramming concept for SFINAE checking of aggregating concepts

Template Struct Arithmetic

Inheritance Relationships
Base Type
  • public decltype___valid_expr___ isstd::is_arithmetic< T >

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::Arithmetic : public decltype___valid_expr___ isstd::is_arithmetic< T >

Template Struct BidirectionalIterator

Inheritance Relationships
Base Types
  • public decltype___valid_expr___ ForwardIterator< T >

  • public has_typeval< T &>

  • public convertible_toval< T &>

  • public val< T &>

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::BidirectionalIterator : public decltype___valid_expr___ ForwardIterator< T > , public has_typeval< T &> , public convertible_toval< T &> , public val< T &>

Template Struct BidirectionalRange

Inheritance Relationships
Base Types
Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::BidirectionalRange : public decltype___valid_expr___ HasBeginEnd< T > , public camp::concepts::BidirectionalIterator< iterator_from< T > >

Template Struct Comparable

Inheritance Relationships
Base Type
Derived Type
Template Parameter Order
  1. typename T

Struct Documentation
template<typename T>
struct Comparable : public camp::concepts::ComparableTo<T, T>

Subclassed by camp::concepts::RandomAccessIterator< T >

Template Struct ComparableTo

Inheritance Relationships
Base Types
  • public decltype___valid_expr___ convertible_toval< U >< val< T >()), convertible_to< bool >(val< T >()< val< U >()), convertible_to< bool >(val< U >()<=val< T >()), convertible_to< bool >(val< T >()<=val< U >()), convertible_to< bool >(val< U >() > val< T >()), convertible_to< bool >(val< T >() > val< U >()), convertible_to< bool >(val< U >() >=val< T >()), convertible_to< bool >(val< T >() > val< U >

  • public convertible_toval< U > val< T >

  • public convertible_toval< T > val< U >

  • public convertible_toval< U > val< T >

  • public convertible_toval< T > val< U >

Template Parameter Order
  1. typename T

  2. typename U

Struct Documentation
template<typename T, typename U> camp::concepts::ComparableTo : public decltype___valid_expr___ convertible_toval< U >< val< T >()), convertible_to< bool >(val< T >()< val< U >()), convertible_to< bool >(val< U >()<=val< T >()), convertible_to< bool >(val< T >()<=val< U >()), convertible_to< bool >(val< U >() > val< T >()), convertible_to< bool >(val< T >() > val< U >()), convertible_to< bool >(val< U >() >=val< T >()), convertible_to< bool >(val< T >() > val< U > , public convertible_toval< U > val< T > , public convertible_toval< T > val< U > , public convertible_toval< U > val< T > , public convertible_toval< T > val< U >

Template Struct EqualityComparable

Inheritance Relationships
Base Type
  • public decltype___valid_expr___ convertible_toval< T > val< T >

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::EqualityComparable : public decltype___valid_expr___ convertible_toval< T > val< T >

Template Struct FloatingPoint

Inheritance Relationships
Base Type
  • public decltype___valid_expr___ isstd::is_floating_point< T >

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::FloatingPoint : public decltype___valid_expr___ isstd::is_floating_point< T >

Template Struct ForwardIterator

Inheritance Relationships
Base Types
  • public decltype___valid_expr___ Iterator< T >

  • public val< T &>

  • public val< T &>

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::ForwardIterator : public decltype___valid_expr___ Iterator< T > , public val< T &> , public val< T &>

Template Struct ForwardRange

Inheritance Relationships
Base Types
Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::ForwardRange : public decltype___valid_expr___ HasBeginEnd< T > , public camp::concepts::ForwardIterator< iterator_from< T > >

Template Struct HasBeginEnd

Inheritance Relationships
Base Types
  • public decltype___valid_expr___ std::beginval< T >

  • public std::endval< T >

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::HasBeginEnd : public decltype___valid_expr___ std::beginval< T > , public std::endval< T >

Template Struct Integral

Inheritance Relationships
Base Type
  • public decltype___valid_expr___ isstd::is_integral< T >

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::Integral : public decltype___valid_expr___ isstd::is_integral< T >

Template Struct Iterator

Inheritance Relationships
Base Types
  • public decltype___valid_expr___ is_notIntegral< T >

  • public val< T >

  • public has_typeval< T &>

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::Iterator : public decltype___valid_expr___ is_notIntegral< T > , public val< T > , public has_typeval< T &>

Template Struct LessEqualComparable

Inheritance Relationships
Base Type
  • public decltype___valid_expr___ convertible_toval< T ><=val< T >()))) { };template< T > struct GreaterEqualComparable :decltype(___valid_expr___(convertible_to< bool >(val< T >() > val< T >

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::LessEqualComparable : public decltype___valid_expr___ convertible_toval< T ><=val< T >()))) { };template< T > struct GreaterEqualComparable :decltype(___valid_expr___(convertible_to< bool >(val< T >() > val< T >

Template Struct LessThanComparable

Inheritance Relationships
Base Type
  • public decltype___valid_expr___ convertible_toval< T >< val< T >()))) { };template< T > struct GreaterThanComparable :decltype(___valid_expr___(convertible_to< bool >(val< T >() > val< T >

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::LessThanComparable : public decltype___valid_expr___ convertible_toval< T >< val< T >()))) { };template< T > struct GreaterThanComparable :decltype(___valid_expr___(convertible_to< bool >(val< T >() > val< T >

Template Struct all_of

Inheritance Relationships
Base Type
  • public camp::is_same< list< t, num< Bs >... >, list< num< Bs >..., t > >

Template Parameter Order
  1. bool... Bs

Struct Documentation
template<bool... Bs>
struct all_of : public camp::is_same<list<t, num<Bs>...>, list<num<Bs>..., t>>

all_of metafunction of a value type list &#8212; all must be “true”

Template Struct all_of_t

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Bs

Struct Documentation
template<typename ...Bs>
struct all_of_t : public camp::concepts::metalib::all_of<Bs::value...>

all_of metafunction of a bool list &#8212; all must be “true”

Template Struct any_of

Inheritance Relationships
Base Type
Template Parameter Order
  1. bool... Bs

Struct Documentation
template<bool... Bs>
struct any_of : public camp::concepts::metalib::negate_t<none_of<Bs...>>

any_of metafunction of a value type list &#8212; at least one must be “true””

Template Struct any_of_t

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Bs

Struct Documentation
template<typename ...Bs>
struct any_of_t : public camp::concepts::metalib::any_of<Bs::value...>

any_of metafunction of a bool list &#8212; at least one must be “true””

Template Struct negate_t

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename T

Struct Documentation
template<typename T>
struct negate_t : public camp::integral_constant<!T::value>

negation metafunction of a value type

Template Struct none_of

Inheritance Relationships
Base Type
  • public camp::is_same< idx_seq< false, Bs... >, idx_seq< Bs..., false > >

Template Parameter Order
  1. bool... Bs

Struct Documentation
template<bool... Bs>
struct none_of : public camp::is_same<idx_seq<false, Bs...>, idx_seq<Bs..., false>>

none_of metafunction of a value type list &#8212; all must be “false”

Template Struct none_of_t

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Bs

Struct Documentation
template<typename ...Bs>
struct none_of_t : public camp::concepts::metalib::none_of<Bs::value...>

none_of metafunction of a bool list &#8212; all must be “false”

Template Struct none_of

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct none_of : public camp::concepts::metalib::none_of_t<Args...>

metaprogramming concept for SFINAE checking of aggregating concepts

Template Struct RandomAccessIterator

Inheritance Relationships
Base Types
  • public decltype___valid_expr___ BidirectionalIterator< T >

  • public camp::concepts::Comparable< T > (Template Struct Comparable)

  • public has_typeval< T &> val< diff_from< T > >

  • public has_typeval< T > val< diff_from< T > >

  • public has_typeval< diff_from< T > > val< T >

  • public has_typeval< T &> val< diff_from< T > >

  • public has_typeval< T > val< diff_from< T > >

  • public valval< diff_from< T > >

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::RandomAccessIterator : public decltype___valid_expr___ BidirectionalIterator< T > , public camp::concepts::Comparable< T > , public has_typeval< T &> val< diff_from< T > > , public has_typeval< T > val< diff_from< T > > , public has_typeval< diff_from< T > > val< T > , public has_typeval< T &> val< diff_from< T > > , public has_typeval< T > val< diff_from< T > > , public valval< diff_from< T > >

Template Struct RandomAccessRange

Inheritance Relationships
Base Types
Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::RandomAccessRange : public decltype___valid_expr___ HasBeginEnd< T > , public camp::concepts::RandomAccessIterator< iterator_from< T > >

Template Struct Range

Inheritance Relationships
Base Types
  • public decltype___valid_expr___ HasBeginEnd< T >

  • public camp::concepts::Iterator< iterator_from< T > > (Template Struct Iterator)

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::Range : public decltype___valid_expr___ HasBeginEnd< T > , public camp::concepts::Iterator< iterator_from< T > >

Template Struct requires_

Inheritance Relationships
Base Type
  • public detail::detected< Op, detail::TL< Args... > >

Template Parameter Order
  1. template< class... > class Op

  2. class... Args

Struct Documentation
template<template<class...> class Op, class ...Args>
struct requires_ : public detail::detected<Op, detail::TL<Args...>>

SFINAE concept checking.

Template Struct Signed

Inheritance Relationships
Base Types
  • public decltype___valid_expr___ Integral< T >

  • public isstd::is_signed< T >

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::Signed : public decltype___valid_expr___ Integral< T > , public isstd::is_signed< T >

Template Struct Swappable

Inheritance Relationships
Base Types
  • public decltype___valid_expr___ swapval< T >

  • public val< T >

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::Swappable : public decltype___valid_expr___ swapval< T > , public val< T >

Template Struct Unsigned

Inheritance Relationships
Base Types
  • public decltype___valid_expr___ Integral< T >

  • public isstd::is_unsigned< T >

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T> camp::concepts::Unsigned : public decltype___valid_expr___ Integral< T > , public isstd::is_unsigned< T >

Template Struct extend

Template Parameter Order
  1. typename Seq

  2. typename T

Struct Documentation
template<typename Seq, typename T>
struct extend

Template Struct extend< list< Elements… >, list< NewElements… > >

Template Parameter Order
  1. typename... Elements

  2. typename... NewElements

Struct Documentation
template<typename ...Elements, typename ...NewElements>
struct extend<list<Elements...>, list<NewElements...>>

Public Types

using type = list<Elements..., NewElements...>

Template Struct filter

Template Parameter Order
  1. template< typename... > class Op

  2. typename Seq

Struct Documentation
template<template<typename...> class Op, typename Seq>
struct filter

Template Struct filter< Op, list< Elements… > >

Template Parameter Order
  1. template< typename... > class Op

  2. typename... Elements

Struct Documentation
template<template<typename...> class Op, typename ...Elements>
struct filter<Op, list<Elements...>>

Public Types

using append_if = if_<typename Op<T>::type, typename append<Seq, T>::type, Seq>
using type = typename accumulate<append_if, list<>, list<Elements...>>::type

Template Struct find_if

Template Parameter Order
  1. template< typename... > class Cond

  2. typename Seq

Struct Documentation
template<template<typename...> class Cond, typename Seq>
struct find_if

Template Struct find_if< Cond, list< Elements… > >

Template Parameter Order
  1. template< typename... > class Cond

  2. typename... Elements

Struct Documentation
template<template<typename...> class Cond, typename ...Elements>
struct find_if<Cond, list<Elements...>>

Public Types

using type = typename detail::_find_if<Cond, Elements...>::type

Template Struct flatten

Template Parameter Order
  1. typename Seq

Struct Documentation
template<typename Seq>
struct flatten

Template Struct flatten< list< Elements… > >

Inheritance Relationships
Base Type
  • public camp::detail::flatten_impl< list<>, sizeof...(Elements), Elements... >

Template Parameter Order
  1. typename... Elements

Struct Documentation
template<typename ...Elements>
struct flatten<list<Elements...>> : public camp::detail::flatten_impl<list<>, sizeof...(Elements), Elements...>

Template Struct idx_seq_from

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T>
struct idx_seq_from

Template Struct idx_seq_from< int_seq< T, Args… > >

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename T

  2. T... Args

Struct Documentation
template<typename T, T... Args>
struct idx_seq_from<int_seq<T, Args...>> : public camp::make_idx_seq<sizeof...(Args)>

Template Struct idx_seq_from< T< Args… > >

Inheritance Relationships
Base Type
Template Parameter Order
  1. template< typename... > class T

  2. typename... Args

Struct Documentation
template<template<typename...> class T, typename ...Args>
struct idx_seq_from<T<Args...>> : public camp::make_idx_seq<sizeof...(Args)>

Template Struct if_cs

Template Parameter Order
  1. bool Cond

  2. typename Then

  3. typename Else

Struct Documentation
template<bool Cond, typename Then = camp::true_type, typename Else = camp::false_type>
struct if_cs

Public Types

using type = Then

Template Struct if_cs< false, Then, Else >

Inheritance Relationships
Derived Type
Template Parameter Order
  1. typename Then

  2. typename Else

Struct Documentation
template<typename Then, typename Else>
struct if_cs<false, Then, Else>

Subclassed by camp::if_s< nil, Then, Else >

Public Types

using type = Else

Template Struct if_s

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename Cond

  2. typename Then

  3. typename Else

Struct Documentation
template<typename Cond, typename Then = camp::true_type, typename Else = camp::false_type>
struct if_s : public camp::if_cs<Cond::value, Then, Else>

Template Struct if_s< nil, Then, Else >

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename Then

  2. typename Else

Struct Documentation
template<typename Then, typename Else>
struct if_s<nil, Then, Else> : public camp::if_cs<false, Then, Else>

Template Struct index_of

Template Parameter Order
  1. typename T

  2. typename L

Struct Documentation
template<typename T, typename L>
struct index_of

Get the index of the first instance of T in L.

Template Struct index_of< T, list< Elements… > >

Template Parameter Order
  1. typename T

  2. typename... Elements

Struct Documentation
template<typename T, typename ...Elements>
struct index_of<T, list<Elements...>>

Public Types

using inc_until = if_<typename std::is_same<T, Item>::type, if_c<size<Seq>::value == 1, typename prepend<Seq, num<first<Seq>::value>>::type, Seq>, list<num<first<Seq>::value + 1>>>
using indices = typename accumulate<inc_until, list<num<0>>, list<Elements...>>::type
using type = typename if_c<size<indices>::value == 2, first<indices>, camp::nil>::type

Template Struct int_seq

Template Parameter Order
  1. typename T

  2. T... vs

Struct Documentation
template<typename T, T... vs>
struct int_seq

Public Types

using type = int_seq

Template Struct integral_constant

Inheritance Relationships
Derived Types
Template Parameter Order
  1. class NumT

  2. NumT v

Struct Documentation
template<class NumT, NumT v>
struct integral_constant

Subclassed by camp::concepts::metalib::negate_t< T >, camp::is_same_s< T, U >, camp::is_same_s< T, T >, camp::tuple_size< const T >, camp::tuple_size< const volatile T >, camp::tuple_size< tagged_tuple< L, Args… > >, camp::tuple_size< tuple< Args… > >, camp::tuple_size< volatile T >, camp::type_traits::SpecializationOf< class, T >, camp::concepts::metalib::negate_t< none_of< Bs… > >

Public Types

using value_type = NumT
using type = integral_constant

Public Functions

inline constexpr operator value_type() const noexcept
inline constexpr value_type operator()() const noexcept

Public Static Attributes

static constexpr NumT value = v

Template Struct invoke_l

Template Parameter Order
  1. typename Lambda

  2. typename... Args

Struct Documentation
template<typename Lambda, typename ...Args>
struct invoke_l

Public Types

using type = typename Lambda::template expr<Args...>::type

Template Struct is_same_s

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename T

  2. typename U

Struct Documentation
template<typename T, typename U>
struct is_same_s : public camp::integral_constant<false>

Template Struct is_same_s< T, T >

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename T

Struct Documentation
template<typename T>
struct is_same_s<T, T> : public camp::integral_constant<true>

Template Struct is_value_s

Template Parameter Order
  1. typename Val

Struct Documentation
template<typename Val>
struct is_value_s

Test whether a type is a valid camp value.

Public Types

using type = camp::t

Template Struct join

Template Parameter Order
  1. typename... Seqs

Struct Documentation
template<typename ...Seqs>
struct join

Template Struct join< Seq1 >

Template Parameter Order
  1. typename Seq1

Struct Documentation
template<typename Seq1>
struct join<Seq1>

Public Types

using type = Seq1

Template Struct join< Seq1, Seq2, Rest… >

Template Parameter Order
  1. typename Seq1

  2. typename Seq2

  3. typename... Rest

Struct Documentation
template<typename Seq1, typename Seq2, typename ...Rest>
struct join<Seq1, Seq2, Rest...>

Public Types

using type = typename join<typename extend<Seq1, Seq2>::type, Rest...>::type

Template Struct join< >

Page Contents

Struct Documentation
template<>
struct join<>

Public Types

using type = list<>

Template Struct lambda

Template Parameter Order
  1. template< typename... > class Expr

Struct Documentation
template<template<typename...> class Expr>
struct lambda

Public Types

using expr = typename Expr<Ts...>::type

Template Struct list

Template Parameter Order
  1. typename... Ts

Struct Documentation
template<typename ...Ts>
struct list

Public Types

using type = list

Template Struct make_idx_seq

Template Parameter Order
  1. idx_t Upper

Struct Documentation
template<idx_t Upper>
struct make_idx_seq

Public Types

using type = typename detail::gen_seq<idx_t, integral_constant<idx_t, Upper>>::type

Template Struct make_int_seq

Inheritance Relationships
Base Type
  • public detail::gen_seq::type< T, integral_constant< T, Upper > >

Template Parameter Order
  1. typename T

  2. T Upper

Struct Documentation
template<typename T, T Upper>
struct make_int_seq : public detail::gen_seq::type<T, integral_constant<T, Upper>>

Template Struct not_

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T>
struct not_

Public Types

using type = typename if_s<T, false_type, true_type>::type

Template Struct prepend

Template Parameter Order
  1. typename Seq

  2. typename T

Struct Documentation
template<typename Seq, typename T>
struct prepend

Template Struct prepend< list< Elements… >, T >

Template Parameter Order
  1. typename... Elements

  2. typename T

Struct Documentation
template<typename ...Elements, typename T>
struct prepend<list<Elements...>, T>

Public Types

using type = list<Elements..., T>

Template Struct EventProxy

Inheritance Relationships
Base Type
  • public EventProxyBase

Template Parameter Order
  1. typename Res

Struct Documentation
template<typename Res>
struct EventProxy : public EventProxyBase

Public Types

using native_event = ::camp::resources::detail::get_event_type<Res>

Public Functions

EventProxy(EventProxy&&) = default
EventProxy(EventProxy const&) = delete
EventProxy &operator=(EventProxy&&) = default
EventProxy &operator=(EventProxy const&) = delete
inline EventProxy(Res r)
template<typename T = Res>
inline std::enable_if<!detail::is_erased_resource_or_proxy<T>::value, native_event>::type get()
template<typename T = Res>
inline std::enable_if<detail::is_erased_resource_or_proxy<T>::value, Event>::type get()
inline operator Event()

Public Members

Res resource_

Template Struct resource_from_platform

Template Parameter Order
  1. Platform p

Struct Documentation
template<Platform p>
struct resource_from_platform

Template Struct resource_from_platform< Platform::host >

Page Contents

Struct Documentation
template<>
struct resource_from_platform<Platform::host>

Public Types

using type = ::camp::resources::Host

Template Struct seq_at

Template Parameter Order
  1. idx_t N

  2. typename IdxSeg

Struct Documentation
template<idx_t N, typename IdxSeg>
struct seq_at

Template Struct seq_at< 0, camp::int_seq< T, Idx0, IdxRest… > >

Template Parameter Order
  1. typename T

  2. T Idx0

  3. T... IdxRest

Struct Documentation
template<typename T, T Idx0, T... IdxRest>
struct seq_at<0, camp::int_seq<T, Idx0, IdxRest...>>

Public Static Attributes

static constexpr T value = Idx0

Template Struct seq_at< N, camp::int_seq< T, Idx0, IdxRest… > >

Template Parameter Order
  1. idx_t N

  2. typename T

  3. T Idx0

  4. T... IdxRest

Struct Documentation
template<idx_t N, typename T, T Idx0, T... IdxRest>
struct seq_at<N, camp::int_seq<T, Idx0, IdxRest...>>

Public Static Attributes

static constexpr T value = seq_at<N - 1, camp::int_seq<T, IdxRest...>>::value

Template Struct size

Template Parameter Order
  1. typename T

Struct Documentation
template<typename T>
struct size

Template Struct size< int_seq< T, Args… > >

Template Parameter Order
  1. typename T

  2. T... Args

Struct Documentation
template<typename T, T... Args>
struct size<int_seq<T, Args...>>

Public Types

using type = num<sizeof...(Args)>

Public Static Attributes

static constexpr idx_t value = {sizeof...(Args)}

Template Struct size< list< Args… > >

Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct size<list<Args...>>

Public Types

using type = num<sizeof...(Args)>

Public Static Attributes

static constexpr idx_t value = {sizeof...(Args)}

Template Struct transform

Template Parameter Order
  1. template< typename... > class Op

  2. typename T

Struct Documentation
template<template<typename...> class Op, typename T>
struct transform

Template Struct transform< Op, list< Elements… > >

Template Parameter Order
  1. template< typename... > class Op

  2. typename... Elements

Struct Documentation
template<template<typename...> class Op, typename ...Elements>
struct transform<Op, list<Elements...>>

Public Types

using type = list<typename Op<Elements>::type...>

Template Struct tuple

Nested Relationships
Nested Types
Template Parameter Order
  1. typename... Elements

Struct Documentation
template<typename ...Elements>
struct tuple

Public Types

using TList = camp::list<Elements...>
using TMap = typename internal::tag_map<camp::list<Elements...>, camp::make_idx_seq_t<sizeof...(Elements)>>::type
using type = tuple

Public Functions

inline explicit constexpr tuple(const Elements&... rest)
template<typename ...Args, typename std::enable_if<!is_pack_this_tuple<Args...>::value>::type* = nullptr>
inline explicit constexpr tuple(Args&&... rest)
template<typename ...RTypes, typename std::enable_if<sizeof...(RTypes) == sizeof...(Elements)>::type* = nullptr>
inline explicit constexpr tuple(const tuple<RTypes...> &rhs)
template<typename ...RTypes, typename std::enable_if<sizeof...(RTypes) == sizeof...(Elements)>::type* = nullptr>
inline explicit constexpr tuple(tuple<RTypes...> &&rhs)
template<typename ...RTypes>
inline constexpr Self &operator=(const tuple<RTypes...> &rhs)

Public Members

Base base

Template Struct tuple::is_pack_this_tuple

Nested Relationships

This struct is a nested type of Template Struct tuple.

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Ts

Struct Documentation
template<typename ...Ts>
struct is_pack_this_tuple : public camp::integral_constant<false>

Template Struct tuple::is_pack_this_tuple< That >

Nested Relationships

This struct is a nested type of Template Struct tuple.

Inheritance Relationships
Base Type
  • public std::is_same< tuple, decay< That > >

Template Parameter Order
  1. typename That

Struct Documentation
template<typename That>
struct is_pack_this_tuple<That> : public std::is_same<tuple, decay<That>>

Template Struct tuple< >

Page Contents

Struct Documentation
template<>
struct tuple<>

Public Types

using TList = camp::list<>
using TMap = TList
using type = tuple

Template Struct tuple_element

Template Parameter Order
  1. camp::idx_t i

  2. typename T

Struct Documentation
template<camp::idx_t i, typename T>
struct tuple_element

Public Types

using type = camp::at_v<typename T::TList, i>

Template Struct tuple_size

Template Parameter Order
  1. typename Tuple

Struct Documentation
template<typename Tuple>
struct tuple_size

Template Struct tuple_size< const T >

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename T

Struct Documentation
template<typename T>
struct tuple_size<const T> : public camp::integral_constant<tuple_size<T>::value>

Template Struct tuple_size< const volatile T >

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename T

Struct Documentation
template<typename T>
struct tuple_size<volatile const T> : public camp::integral_constant<tuple_size<T>::value>

Template Struct tuple_size< tagged_tuple< L, Args… > >

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename L

  2. typename... Args

Struct Documentation
template<typename L, typename ...Args>
struct tuple_size<tagged_tuple<L, Args...>> : public camp::integral_constant<sizeof...(Args)>

Template Struct tuple_size< tuple< Args… > >

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct tuple_size<tuple<Args...>> : public camp::integral_constant<sizeof...(Args)>

Template Struct tuple_size< volatile T >

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename T

Struct Documentation
template<typename T>
struct tuple_size<volatile T> : public camp::integral_constant<tuple_size<T>::value>

Template Struct rem_s

Template Parameter Order
  1. class T

Struct Documentation
template<class T>
struct rem_s

Public Types

using type = T

Template Struct rem_s< const T >

Template Parameter Order
  1. class T

Struct Documentation
template<class T>
struct rem_s<const T>

Public Types

using type = T

Template Struct rem_s

Template Parameter Order
  1. class T

Struct Documentation
template<class T>
struct rem_s

Public Types

using type = T

Template Struct rem_s< const T >

Template Parameter Order
  1. class T

Struct Documentation
template<class T>
struct rem_s<const T>

Public Types

using type = T

Template Struct rem_s< const volatile T >

Template Parameter Order
  1. class T

Struct Documentation
template<class T>
struct rem_s<volatile const T>

Public Types

using type = T

Template Struct rem_s< volatile T >

Template Parameter Order
  1. class T

Struct Documentation
template<class T>
struct rem_s<volatile T>

Public Types

using type = T

Template Struct rem_s

Template Parameter Order
  1. class T

Struct Documentation
template<class T>
struct rem_s

Public Types

using type = T

Template Struct rem_s< T * >

Template Parameter Order
  1. class T

Struct Documentation
template<class T>
struct rem_s<T*>

Public Types

using type = T

Template Struct rem_s

Template Parameter Order
  1. class T

Struct Documentation
template<class T>
struct rem_s

Public Types

using type = T

Template Struct rem_s< T & >

Template Parameter Order
  1. class T

Struct Documentation
template<class T>
struct rem_s<T&>

Public Types

using type = T

Template Struct rem_s< T && >

Template Parameter Order
  1. class T

Struct Documentation
template<class T>
struct rem_s<T&&>

Public Types

using type = T

Template Struct rem_s

Template Parameter Order
  1. class T

Struct Documentation
template<class T>
struct rem_s

Public Types

using type = T

Template Struct rem_s< volatile T >

Template Parameter Order
  1. class T

Struct Documentation
template<class T>
struct rem_s<volatile T>

Public Types

using type = T

Template Struct is_arithmetic

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct is_arithmetic : public camp::concepts::requires_<camp::concepts::Arithmetic, Args...>

Template Struct is_bidirectional_iterator

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct is_bidirectional_iterator : public camp::concepts::requires_<camp::concepts::BidirectionalIterator, Args...>

Template Struct is_bidirectional_range

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct is_bidirectional_range : public camp::concepts::requires_<camp::concepts::BidirectionalRange, Args...>

Template Struct is_comparable

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct is_comparable : public camp::concepts::requires_<camp::concepts::Comparable, Args...>

Template Struct is_comparable_to

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct is_comparable_to : public camp::concepts::requires_<camp::concepts::ComparableTo, Args...>

Template Struct is_floating_point

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct is_floating_point : public camp::concepts::requires_<camp::concepts::FloatingPoint, Args...>

Template Struct is_forward_iterator

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct is_forward_iterator : public camp::concepts::requires_<camp::concepts::ForwardIterator, Args...>

Template Struct is_forward_range

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct is_forward_range : public camp::concepts::requires_<camp::concepts::ForwardRange, Args...>

Template Struct is_integral

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct is_integral : public camp::concepts::requires_<camp::concepts::Integral, Args...>

Template Struct is_iterator

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct is_iterator : public camp::concepts::requires_<camp::concepts::Iterator, Args...>

Template Struct is_random_access_iterator

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct is_random_access_iterator : public camp::concepts::requires_<camp::concepts::RandomAccessIterator, Args...>

Template Struct is_random_access_range

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct is_random_access_range : public camp::concepts::requires_<camp::concepts::RandomAccessRange, Args...>

Template Struct is_range

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct is_range : public camp::concepts::requires_<camp::concepts::Range, Args...>

Template Struct is_signed

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct is_signed : public camp::concepts::requires_<camp::concepts::Signed, Args...>

Template Struct is_unsigned

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename... Args

Struct Documentation
template<typename ...Args>
struct is_unsigned : public camp::concepts::requires_<camp::concepts::Unsigned, Args...>

Template Struct SpecializationOf

Inheritance Relationships
Base Type
Template Parameter Order
  1. template< class... > class

  2. typename T

Struct Documentation
template<template<class...> class, typename T>
struct SpecializationOf : public camp::integral_constant<false>

Template Struct SpecializationOf< Expected, Actual< Args… > >

Inheritance Relationships
Base Type
  • public detail::SpecializationOf< Expected, Actual, IsSpecialized< Expected, Args... >::value, Args... >

Template Parameter Order
  1. template< class... > class Expected

  2. template< class... > class Actual

  3. class... Args

Struct Documentation
template<template<class...> class Expected, template<class...> class Actual, class ...Args>
struct SpecializationOf<Expected, Actual<Args...>> : public detail::SpecializationOf<Expected, Actual, IsSpecialized<Expected, Args...>::value, Args...>

Template Struct value

Template Parameter Order
  1. typename val

Struct Documentation
template<typename val>
struct value

Public Types

using type = val

Class Event

Nested Relationships
Nested Types
Class Documentation
class Event

Public Functions

Event() = default
Event(Event const &e) = default
Event(Event &&e) = default
Event &operator=(Event const &e) = default
Event &operator=(Event &&e) = default
template<typename T, typename std::enable_if<!(std::is_convertible<typename std::decay<T>::type*, ::camp::resources::detail::EventProxyBase*>::value)>::type* = nullptr>
inline Event(T &&value)
inline bool check() const
inline void wait() const
template<typename T>
inline T *try_get()
template<typename T>
inline T get()

Class Event::EventInterface

Nested Relationships

This class is a nested type of Class Event.

Class Documentation
class EventInterface

Public Functions

inline virtual ~EventInterface()
virtual bool check() const = 0
virtual void wait() const = 0

Template Class Event::EventModel

Nested Relationships

This class is a nested type of Class Event.

Inheritance Relationships
Base Type
  • public camp::resources::v1::Event::EventInterface

Template Parameter Order
  1. typename T

Class Documentation
template<typename T>
class EventModel : public camp::resources::v1::Event::EventInterface

Public Functions

inline EventModel(T const &modelVal)
inline bool check() const override
inline void wait() const override
inline T *get()

Class Host

Page Contents

Class Documentation
class Host

Public Functions

inline Host(int = -1)
inline Platform get_platform() const
inline HostEvent get_event()
inline Event get_event_erased()
inline void wait()
inline void wait_for(Event *e)
template<typename T>
inline T *allocate(size_t n, MemoryAccess = MemoryAccess::Device)
inline void *calloc(size_t size, MemoryAccess = MemoryAccess::Device)
inline void deallocate(void *p, MemoryAccess = MemoryAccess::Device)
inline void memcpy(void *dst, const void *src, size_t size)
inline void memset(void *p, int val, size_t size)

Public Static Functions

static inline Host get_default()

Class HostEvent

Page Contents

Class Documentation
class HostEvent

Public Functions

inline HostEvent()
inline bool check() const
inline void wait() const

Class Resource

Nested Relationships
Nested Types
Class Documentation
class Resource

Public Functions

Resource(Resource&&) = default
Resource(Resource const&) = default
Resource &operator=(Resource&&) = default
Resource &operator=(Resource const&) = default
template<typename T, typename = typename std::enable_if<!std::is_same<typename std::decay<T>::type, Resource>::value>::type>
inline Resource(T &&value)
template<typename T>
inline T *try_get()
template<typename T>
inline T get()
inline Platform get_platform() const
template<typename T>
inline T *allocate(size_t size, MemoryAccess ma = MemoryAccess::Device)
inline void *calloc(size_t size, MemoryAccess ma = MemoryAccess::Device)
inline void deallocate(void *p, MemoryAccess ma = MemoryAccess::Device)
inline void memcpy(void *dst, const void *src, size_t size)
inline void memset(void *p, int val, size_t size)
inline Event get_event()
inline Event get_event_erased()
inline void wait_for(Event *e)
inline void wait()

Class Resource::ContextInterface

Nested Relationships

This class is a nested type of Class Resource.

Class Documentation
class ContextInterface

Public Functions

inline virtual ~ContextInterface()
virtual Platform get_platform() const = 0
virtual void *calloc(size_t size, MemoryAccess ma = MemoryAccess::Device) = 0
virtual void deallocate(void *p, MemoryAccess ma = MemoryAccess::Device) = 0
virtual void memcpy(void *dst, const void *src, size_t size) = 0
virtual void memset(void *p, int val, size_t size) = 0
virtual Event get_event() = 0
virtual Event get_event_erased() = 0
virtual void wait_for(Event *e) = 0
virtual void wait() = 0

Template Class Resource::ContextModel

Nested Relationships

This class is a nested type of Class Resource.

Inheritance Relationships
Base Type
  • public camp::resources::v1::Resource::ContextInterface

Template Parameter Order
  1. typename T

Class Documentation
template<typename T>
class ContextModel : public camp::resources::v1::Resource::ContextInterface

Public Functions

inline ContextModel(T const &modelVal)
inline Platform get_platform() const override
inline void *calloc(size_t size, MemoryAccess ma = MemoryAccess::Device) override
inline void deallocate(void *p, MemoryAccess ma = MemoryAccess::Device) override
inline void memcpy(void *dst, const void *src, size_t size) override
inline void memset(void *p, int val, size_t size) override
inline Event get_event() override
inline Event get_event_erased() override
inline void wait_for(Event *e) override
inline void wait() override
inline T *get()

Template Class tagged_tuple

Inheritance Relationships
Base Type
Template Parameter Order
  1. typename TagList

  2. typename... Elements

Class Documentation
template<typename TagList, typename ...Elements>
class tagged_tuple : public camp::tuple<Elements...>

Public Types

using TMap = typename internal::tag_map<TagList, camp::make_idx_seq_t<sizeof...(Elements)>>::type
using type = tagged_tuple

Public Functions

constexpr tagged_tuple() = default
constexpr tagged_tuple(tagged_tuple const &o) = default
constexpr tagged_tuple(tagged_tuple &&o) = default
tagged_tuple &operator=(tagged_tuple const &rhs) = default
tagged_tuple &operator=(tagged_tuple &&rhs) = default
inline explicit constexpr tagged_tuple(const Base &rhs)
template<typename ...RTypes>
inline explicit constexpr tagged_tuple(const tagged_tuple<RTypes...> &rhs)
template<typename ...RTypes>
inline explicit constexpr tagged_tuple(tagged_tuple<RTypes...> &&rhs)
template<typename ...RTypes>
inline constexpr Self &operator=(const tagged_tuple<RTypes...> &rhs)

Enums

Enum MemoryAccess

Enum Documentation
enum camp::resources::v1::MemoryAccess

Values:

enumerator Unknown
enumerator Device
enumerator Pinned
enumerator Managed

Enum Platform

Enum Documentation
enum camp::resources::v1::Platform

Values:

enumerator undefined
enumerator host
enumerator cuda
enumerator omp_target
enumerator hip
enumerator sycl

Functions

Template Function ___valid_expr___

Function Documentation

Warning

doxygenfunction: Unable to resolve function “___valid_expr___” with arguments (T&&) in doxygen xml output for project “camp” from directory: ./doxyoutput/xml. Potential matches:

- template<typename ...T> camp::true_type ___valid_expr___(T&&...) noexcept

Template Function camp::apply

Function Documentation
template<class Fn, class TupleLike>
constexpr auto camp::apply(Fn &&f, TupleLike &&tup)

Forward the elements of a tuple to a callable.

Function camp::CAMP_MAKE_L(accumulate)

Function Documentation
camp::CAMP_MAKE_L(accumulate)

Function camp::CAMP_MAKE_L(filter)

Function Documentation
camp::CAMP_MAKE_L(filter)

Function camp::CAMP_MAKE_L(bind_front)

Function Documentation
camp::CAMP_MAKE_L(bind_front)

Function camp::CAMP_MAKE_L(find_if)

Function Documentation
camp::CAMP_MAKE_L(find_if)

Template Function camp::concepts::convertible_to

Function Documentation
template<typename T, typename U>
constexpr auto camp::concepts::convertible_to(U &&u) noexcept -> decltype(detail::returns<camp::true_type>(static_cast<T>((U&&)u)))

metafunction for use within decltype expression to validate return type is convertible to given type

Template Function camp::concepts::has_type

Function Documentation
template<typename T, typename U>
constexpr auto camp::concepts::has_type(U&&) noexcept -> metalib::is_same<T, U>

metafunction for use within decltype expression to validate type of expression

Template Function camp::concepts::is

Function Documentation
template<typename BoolLike>
constexpr auto camp::concepts::is(BoolLike) noexcept -> camp::if_<BoolLike, camp::true_type, camp::false_type>

Template Function camp::concepts::is_not

Function Documentation
template<typename BoolLike>
constexpr auto camp::concepts::is_not(BoolLike) noexcept -> camp::if_c<!BoolLike::value, camp::true_type, camp::false_type>

Template Function camp::cval

Function Documentation
template<typename T>
auto camp::cval() noexcept -> decltype(std::declval<T const>())

metafunction to get instance of const type

Template Function camp::declptr

Function Documentation
template<typename T>
T *camp::declptr()

metafunction to get instance of pointer type

Template Function camp::for_each_arg

Function Documentation
template<typename Fn, typename ...Args>
constexpr void camp::for_each_arg(Fn &&f, Args&&... args)

Template Function camp::forward(type::ref::rem<T>&)

Function Documentation
template<class T>
constexpr T &&camp::forward(type::ref::rem<T> &t) noexcept

Template Function camp::forward(type::ref::rem<T>&&)

Function Documentation
template<class T>
constexpr T &&camp::forward(type::ref::rem<T> &&t) noexcept

Template Function camp::forward_as_tuple

Function Documentation
template<typename ...Args>
constexpr auto camp::forward_as_tuple(Args&&... args) noexcept

Template Function camp::get(const tuple<Types…>&)

Function Documentation

Warning

doxygenfunction: Unable to resolve function “camp::get” with arguments (const tuple<Types…>&) in doxygen xml output for project “camp” from directory: ./doxyoutput/xml. Potential matches:

- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> &&get(tuple<Types...> &&t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> &get(tuple<Types...> &t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> const &&get(const tuple<Types...> &&t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> const &get(const tuple<Types...> &t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> &&get(tuple<Types...> &&t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> &get(tuple<Types...> &t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> const &&get(const tuple<Types...> &&t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> const &get(const tuple<Types...> &t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &&get(tagged_tuple<TagList, Types...> &&t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &get(tagged_tuple<TagList, Types...> &t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &&get(const tagged_tuple<TagList, Types...> &&t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &get(const tagged_tuple<TagList, Types...> &t) noexcept

Template Function camp::get(const tuple<Types…>&&)

Function Documentation

Warning

doxygenfunction: Unable to resolve function “camp::get” with arguments (const tuple<Types…>&&) in doxygen xml output for project “camp” from directory: ./doxyoutput/xml. Potential matches:

- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> &&get(tuple<Types...> &&t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> &get(tuple<Types...> &t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> const &&get(const tuple<Types...> &&t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> const &get(const tuple<Types...> &t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> &&get(tuple<Types...> &&t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> &get(tuple<Types...> &t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> const &&get(const tuple<Types...> &&t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> const &get(const tuple<Types...> &t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &&get(tagged_tuple<TagList, Types...> &&t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &get(tagged_tuple<TagList, Types...> &t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &&get(const tagged_tuple<TagList, Types...> &&t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &get(const tagged_tuple<TagList, Types...> &t) noexcept

Template Function camp::get(tuple<Types…>&)

Function Documentation

Warning

doxygenfunction: Unable to resolve function “camp::get” with arguments (tuple<Types…>&) in doxygen xml output for project “camp” from directory: ./doxyoutput/xml. Potential matches:

- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> &&get(tuple<Types...> &&t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> &get(tuple<Types...> &t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> const &&get(const tuple<Types...> &&t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> const &get(const tuple<Types...> &t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> &&get(tuple<Types...> &&t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> &get(tuple<Types...> &t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> const &&get(const tuple<Types...> &&t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> const &get(const tuple<Types...> &t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &&get(tagged_tuple<TagList, Types...> &&t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &get(tagged_tuple<TagList, Types...> &t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &&get(const tagged_tuple<TagList, Types...> &&t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &get(const tagged_tuple<TagList, Types...> &t) noexcept

Template Function camp::get(tuple<Types…>&&)

Function Documentation

Warning

doxygenfunction: Unable to resolve function “camp::get” with arguments (tuple<Types…>&&) in doxygen xml output for project “camp” from directory: ./doxyoutput/xml. Potential matches:

- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> &&get(tuple<Types...> &&t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> &get(tuple<Types...> &t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> const &&get(const tuple<Types...> &&t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> const &get(const tuple<Types...> &t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> &&get(tuple<Types...> &&t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> &get(tuple<Types...> &t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> const &&get(const tuple<Types...> &&t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> const &get(const tuple<Types...> &t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &&get(tagged_tuple<TagList, Types...> &&t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &get(tagged_tuple<TagList, Types...> &t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &&get(const tagged_tuple<TagList, Types...> &&t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &get(const tagged_tuple<TagList, Types...> &t) noexcept

Template Function camp::get(const tuple<Types…>&)

Function Documentation

Warning

doxygenfunction: Unable to resolve function “camp::get” with arguments (const tuple<Types…>&) in doxygen xml output for project “camp” from directory: ./doxyoutput/xml. Potential matches:

- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> &&get(tuple<Types...> &&t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> &get(tuple<Types...> &t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> const &&get(const tuple<Types...> &&t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> const &get(const tuple<Types...> &t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> &&get(tuple<Types...> &&t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> &get(tuple<Types...> &t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> const &&get(const tuple<Types...> &&t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> const &get(const tuple<Types...> &t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &&get(tagged_tuple<TagList, Types...> &&t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &get(tagged_tuple<TagList, Types...> &t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &&get(const tagged_tuple<TagList, Types...> &&t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &get(const tagged_tuple<TagList, Types...> &t) noexcept

Template Function camp::get(const tuple<Types…>&&)

Function Documentation

Warning

doxygenfunction: Unable to resolve function “camp::get” with arguments (const tuple<Types…>&&) in doxygen xml output for project “camp” from directory: ./doxyoutput/xml. Potential matches:

- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> &&get(tuple<Types...> &&t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> &get(tuple<Types...> &t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> const &&get(const tuple<Types...> &&t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> const &get(const tuple<Types...> &t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> &&get(tuple<Types...> &&t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> &get(tuple<Types...> &t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> const &&get(const tuple<Types...> &&t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> const &get(const tuple<Types...> &t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &&get(tagged_tuple<TagList, Types...> &&t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &get(tagged_tuple<TagList, Types...> &t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &&get(const tagged_tuple<TagList, Types...> &&t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &get(const tagged_tuple<TagList, Types...> &t) noexcept

Template Function camp::get(tuple<Types…>&)

Function Documentation

Warning

doxygenfunction: Unable to resolve function “camp::get” with arguments (tuple<Types…>&) in doxygen xml output for project “camp” from directory: ./doxyoutput/xml. Potential matches:

- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> &&get(tuple<Types...> &&t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> &get(tuple<Types...> &t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> const &&get(const tuple<Types...> &&t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> const &get(const tuple<Types...> &t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> &&get(tuple<Types...> &&t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> &get(tuple<Types...> &t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> const &&get(const tuple<Types...> &&t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> const &get(const tuple<Types...> &t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &&get(tagged_tuple<TagList, Types...> &&t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &get(tagged_tuple<TagList, Types...> &t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &&get(const tagged_tuple<TagList, Types...> &&t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &get(const tagged_tuple<TagList, Types...> &t) noexcept

Template Function camp::get(tuple<Types…>&&)

Function Documentation

Warning

doxygenfunction: Unable to resolve function “camp::get” with arguments (tuple<Types…>&&) in doxygen xml output for project “camp” from directory: ./doxyoutput/xml. Potential matches:

- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> &&get(tuple<Types...> &&t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> &get(tuple<Types...> &t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> const &&get(const tuple<Types...> &&t) noexcept
- template<camp::idx_t index, class ...Types> constexpr tuple_element_t<index, tuple<Types...>> const &get(const tuple<Types...> &t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> &&get(tuple<Types...> &&t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> &get(tuple<Types...> &t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> const &&get(const tuple<Types...> &&t) noexcept
- template<typename T, class ...Types> constexpr tuple_ebt_t<T, tuple<Types...>> const &get(const tuple<Types...> &t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &&get(tagged_tuple<TagList, Types...> &&t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &get(tagged_tuple<TagList, Types...> &t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &&get(const tagged_tuple<TagList, Types...> &&t) noexcept
- template<typename T, typename TagList, class ...Types> constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &get(const tagged_tuple<TagList, Types...> &t) noexcept

Template Function camp::get(const tagged_tuple<TagList, Types…>&)

Function Documentation
template<typename T, typename TagList, class ...Types>
constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &camp::get(const tagged_tuple<TagList, Types...> &t) noexcept

Template Function camp::get(const tagged_tuple<TagList, Types…>&&)

Function Documentation
template<typename T, typename TagList, class ...Types>
constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> const &&camp::get(const tagged_tuple<TagList, Types...> &&t) noexcept

Template Function camp::get(tagged_tuple<TagList, Types…>&)

Function Documentation
template<typename T, typename TagList, class ...Types>
constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &camp::get(tagged_tuple<TagList, Types...> &t) noexcept

Template Function camp::get(tagged_tuple<TagList, Types…>&&)

Function Documentation
template<typename T, typename TagList, class ...Types>
constexpr tuple_ebt_t<T, tagged_tuple<TagList, Types...>> &&camp::get(tagged_tuple<TagList, Types...> &&t) noexcept

Template Function camp::invoke

Function Documentation

Warning

doxygenfunction: Unable to resolve function “camp::invoke” with arguments “(TupleLike&&, Fn&&)”. Candidate function could not be parsed. Parsing error is Error when parsing function declaration. If the function has no return type: Error in declarator or parameters-and-qualifiers Invalid C++ declaration: Expecting “(” in parameters-and-qualifiers. [error at 64] template<typename Fn, typename TupleLike> CAMP_SUPPRESS_HD_WARN constexpr auto invoke (TupleLike &&tup, Fn &&f) —————————————————————-^ If the function has a return type: Error in declarator or parameters-and-qualifiers If pointer to member declarator: Invalid C++ declaration: Expected identifier in nested name, got keyword: auto [error at 78] template<typename Fn, typename TupleLike> CAMP_SUPPRESS_HD_WARN constexpr auto invoke (TupleLike &&tup, Fn &&f) ——————————————————————————^ If declarator-id: Invalid C++ declaration: Expected identifier in nested name, got keyword: auto [error at 78] template<typename Fn, typename TupleLike> CAMP_SUPPRESS_HD_WARN constexpr auto invoke (TupleLike &&tup, Fn &&f) ——————————————————————————^

Template Function camp::invoke_with_order

Function Documentation

Warning

doxygenfunction: Unable to resolve function “camp::invoke_with_order” with arguments “(TupleLike&&, Fn&&, camp::idx_seq<Sequence…>)”. Candidate function could not be parsed. Parsing error is Error when parsing function declaration. If the function has no return type: Error in declarator or parameters-and-qualifiers Invalid C++ declaration: Expecting “(” in parameters-and-qualifiers. [error at 89] template<typename Fn, camp::idx_t… Sequence, typename TupleLike> CAMP_SUPPRESS_HD_WARN constexpr auto invoke_with_order (TupleLike &&tup, Fn &&f, camp::idx_seq< Sequence… >) —————————————————————————————–^ If the function has a return type: Error in declarator or parameters-and-qualifiers If pointer to member declarator: Invalid C++ declaration: Expected identifier in nested name, got keyword: auto [error at 103] template<typename Fn, camp::idx_t… Sequence, typename TupleLike> CAMP_SUPPRESS_HD_WARN constexpr auto invoke_with_order (TupleLike &&tup, Fn &&f, camp::idx_seq< Sequence… >) ——————————————————————————————————-^ If declarator-id: Invalid C++ declaration: Expected identifier in nested name, got keyword: auto [error at 103] template<typename Fn, camp::idx_t… Sequence, typename TupleLike> CAMP_SUPPRESS_HD_WARN constexpr auto invoke_with_order (TupleLike &&tup, Fn &&f, camp::idx_seq< Sequence… >) ——————————————————————————————————-^

Template Function camp::make_from_tuple

Function Documentation
template<class T, class Tuple>
constexpr T camp::make_from_tuple(Tuple &&tup)

Instantiate T from tuple contents, like camp::invoke(tuple,constructor) but functional

Template Function camp::make_tagged_tuple

Function Documentation
template<typename TagList, typename ...Args>
constexpr auto camp::make_tagged_tuple(Args&&... args)

Template Function camp::make_tuple

Function Documentation
template<typename ...Args>
constexpr auto camp::make_tuple(Args&&... args)

Template Function camp::make_unique

Function Documentation
template<typename T, typename ...Args>
inline constexpr std::unique_ptr<T> camp::make_unique(Args&&... args)

Template Function camp::move

Function Documentation
template<typename T>
constexpr type::ref::rem<T> &&camp::move(T &&t) noexcept

Template Function camp::safe_swap(T&, T&)

Function Documentation
template<typename T>
void camp::safe_swap(T &t1, T &t2)

Template Function camp::safe_swap(T&, T&)

Function Documentation
template<typename T>
void camp::safe_swap(T &t1, T &t2)

Template Function camp::sink

Function Documentation

Warning

doxygenfunction: Unable to resolve function “camp::sink” with arguments (Ts const&) in doxygen xml output for project “camp” from directory: ./doxyoutput/xml. Potential matches:

- template<typename ...Ts> constexpr void sink(Ts const&...)

Function camp::throw_re

Function Documentation

Warning

doxygenfunction: Unable to resolve function “camp::throw_re” with arguments “(const char*)”. Candidate function could not be parsed. Parsing error is Error when parsing function declaration. If the function has no return type: Error in declarator or parameters-and-qualifiers Invalid C++ declaration: Expecting “(” in parameters-and-qualifiers. [error at 16] CAMP_DLL_EXPORT void throw_re (const char *s) —————-^ If the function has a return type: Error in declarator or parameters-and-qualifiers If pointer to member declarator: Invalid C++ declaration: Expected identifier in nested name, got keyword: void [error at 20] CAMP_DLL_EXPORT void throw_re (const char *s) ——————–^ If declarator-id: Invalid C++ declaration: Expected identifier in nested name, got keyword: void [error at 20] CAMP_DLL_EXPORT void throw_re (const char *s) ——————–^

Template Function camp::tie

Function Documentation
template<class ...Types>
constexpr tuple<Types&...> camp::tie(Types&... args) noexcept

Template Function camp::tuple_cat_pair(L&&, camp::idx_seq<Lidx…>, R&&, camp::idx_seq<Ridx…>)

Function Documentation
template<typename L, typename R, camp::idx_t... Lidx, camp::idx_t... Ridx>
constexpr auto camp::tuple_cat_pair(L &&l, camp::idx_seq<Lidx...>, R &&r, camp::idx_seq<Ridx...>) noexcept

Template Function camp::tuple_cat_pair(L&&, R&&)

Function Documentation
template<typename L, typename R>
constexpr auto camp::tuple_cat_pair(L &&l, R &&r) noexcept

Template Function camp::val

Function Documentation
template<typename T>
auto camp::val() noexcept -> decltype(std::declval<T>())

metafunction to get instance of value type

Template Function operator<<

Function Documentation
template<class ...Args>
auto operator<<(std::ostream &os, camp::tuple<Args...> const &tup) -> std::ostream&

Defines

Define __has_declspec_attribute

Define Documentation
__has_declspec_attribute(__x)

Define CAMP_ALLOW_UNUSED_LOCAL

Define Documentation
CAMP_ALLOW_UNUSED_LOCAL(X)

Define CAMP_DEVICE

Define Documentation
CAMP_DEVICE

Define CAMP_DLL_EXPORT

Define Documentation
CAMP_DLL_EXPORT

Define CAMP_EMPTY_BASES

Define Documentation
CAMP_EMPTY_BASES

Define CAMP_ENABLE_CUDA

Define Documentation
CAMP_ENABLE_CUDA

Define CAMP_ENABLE_HIP

Define Documentation
CAMP_ENABLE_HIP

Define CAMP_ENABLE_OPENMP

Define Documentation
CAMP_ENABLE_OPENMP

Define CAMP_ENABLE_SYCL

Define Documentation
CAMP_ENABLE_SYCL

Define CAMP_ENABLE_TARGET_OPENMP

Define Documentation
CAMP_ENABLE_TARGET_OPENMP

Define CAMP_EXPAND

Define Documentation
CAMP_EXPAND(...)

Define CAMP_HAS_IS_TRIVIALLY_COPY_CONSTRUCTIBLE

Define Documentation
CAMP_HAS_IS_TRIVIALLY_COPY_CONSTRUCTIBLE

Define CAMP_HIP_HOST_DEVICE

Define Documentation
CAMP_HIP_HOST_DEVICE

Define CAMP_HOST_DEVICE

Define Documentation
CAMP_HOST_DEVICE

Define CAMP_MAKE_L

Define Documentation
CAMP_MAKE_L(X)

Define CAMP_SUPPRESS_HD_WARN

Define Documentation
CAMP_SUPPRESS_HD_WARN

Define CAMP_USE_INTEGER_PACK

Define Documentation
CAMP_USE_INTEGER_PACK

Define CAMP_USE_MAKE_INTEGER_SEQ

Define Documentation
CAMP_USE_MAKE_INTEGER_SEQ

Define CAMP_USE_PLATFORM_DEFAULT_STREAM

Define Documentation
CAMP_USE_PLATFORM_DEFAULT_STREAM

Define CAMP_USE_TYPE_PACK_ELEMENT

Define Documentation
CAMP_USE_TYPE_PACK_ELEMENT

Define CAMP_VERSION

Define Documentation
CAMP_VERSION

Define CAMP_VERSION_MAJOR

Define Documentation
CAMP_VERSION_MAJOR

Define CAMP_VERSION_MINOR

Define Documentation
CAMP_VERSION_MINOR

Define CAMP_VERSION_PATCH

Define Documentation
CAMP_VERSION_PATCH

Define CAMP_WIN_STATIC_BUILD

Define Documentation
CAMP_WIN_STATIC_BUILD

Define DefineConcept

Define Documentation
DefineConcept(...)

Define DefineTypeTraitFromConcept

Define Documentation
DefineTypeTraitFromConcept(TTName, ConceptName)

Typedefs

Typedef camp::_1

Typedef Documentation
using camp::_1 = arg<1>

Typedef camp::_2

Typedef Documentation
using camp::_2 = arg<2>

Typedef camp::_3

Typedef Documentation
using camp::_3 = arg<3>

Typedef camp::_4

Typedef Documentation
using camp::_4 = arg<4>

Typedef camp::_5

Typedef Documentation
using camp::_5 = arg<5>

Typedef camp::_6

Typedef Documentation
using camp::_6 = arg<6>

Typedef camp::_7

Typedef Documentation
using camp::_7 = arg<7>

Typedef camp::_8

Typedef Documentation
using camp::_8 = arg<8>

Typedef camp::_9

Typedef Documentation
using camp::_9 = arg<9>

Typedef camp::as_list

Typedef Documentation
using camp::as_list = typename as_list_s<T>::type

Typedef camp::at_key

Typedef Documentation
using camp::at_key = typename at_key_s<Map, Key>::type

Get value at Key from Map.

Template Parameters
  • Map – The map, or associative list, to index

  • Key – The key to find

Typedef camp::at_t

Typedef Documentation
using camp::at_t = typename at<T, U>::type

Typedef camp::at_v

Typedef Documentation
using camp::at_v = typename at<T, num<Idx>>::type

Typedef camp::cartesian_product

Typedef Documentation
using camp::cartesian_product = typename accumulate<detail::product, list<list<>>, list<Seqs...>>::type

Typedef camp::concepts::enable_if

Typedef Documentation
using camp::concepts::enable_if = typename std::enable_if<all_of<Args...>::value, void>::type

SFINAE multiple type traits.

Typedef camp::concepts::enable_if_t

Typedef Documentation
using camp::concepts::enable_if_t = typename std::enable_if<all_of<Args...>::value, T>::type

Typedef camp::concepts::negate

Typedef Documentation
using camp::concepts::negate = metalib::negate_t<T>

Typedef camp::decay

Typedef Documentation
using camp::decay = type::cv::rem<type::ref::rem<T>>

Typedef camp::diff_between

Typedef Documentation
using camp::diff_between = decltype(val<plain<T>>() - val<plain<U>>())

Typedef camp::diff_from

Typedef Documentation
using camp::diff_from = decltype(val<plain<T>>() - val<plain<T>>())

Typedef camp::eval

Typedef Documentation
using camp::eval = typename Val::type

Typedef camp::false_type

Typedef Documentation
using camp::false_type = num<false>

Typedef camp::first

Typedef Documentation
using camp::first = typename at<T, num<0>>::type

Typedef camp::idx_seq

Typedef Documentation
using camp::idx_seq = int_seq<idx_t, vs...>

Index list, use for indexing into parameter packs and lists.

Typedef camp::idx_seq_for_t

Typedef Documentation
using camp::idx_seq_for_t = typename make_idx_seq<sizeof...(Ts)>::type

Typedef camp::idx_seq_from_t

Typedef Documentation
using camp::idx_seq_from_t = typename idx_seq_from<camp::decay<T>>::type

Typedef camp::idx_t

Typedef Documentation
using camp::idx_t = std::ptrdiff_t

Typedef camp::if_

Typedef Documentation
using camp::if_ = typename if_s<Ts...>::type

Typedef camp::if_c

Typedef Documentation
using camp::if_c = typename if_cs<Cond, Then, Else>::type

Typedef camp::is_same

Typedef Documentation
using camp::is_same = typename is_same_s<T, U>::type

Typedef camp::is_same_t

Typedef Documentation
using camp::is_same_t = is_same<T, U>

Typedef camp::is_tuple

Typedef Documentation
using camp::is_tuple = typename std::is_base_of<tuple<>, Tup<>>::type

Typedef camp::is_value

Typedef Documentation
using camp::is_value = typename is_value_s<Val>::type

Test whether a type is a valid camp value.

Typedef camp::iterator_from

Typedef Documentation
using camp::iterator_from = decltype(begin(val<plain<T>>()))

Typedef camp::make_idx_seq_t

Typedef Documentation
using camp::make_idx_seq_t = typename make_idx_seq<Upper>::type

Typedef camp::make_int_seq_t

Typedef Documentation
using camp::make_int_seq_t = typename make_int_seq<T, Upper>::type

Typedef camp::nil

Typedef Documentation
using camp::nil = value<>

A non-value, in truth tests evaluates to false.

Typedef camp::nullptr_t

Typedef Documentation
using camp::nullptr_t = decltype(nullptr)

Typedef camp::num

Typedef Documentation
using camp::num = integral_constant<idx_t, N>

Short-form for a whole number.

Template Parameters

N – The integral value

Typedef camp::plain

Typedef Documentation
using camp::plain = type::ref::rem<T>

Typedef camp::second

Typedef Documentation
using camp::second = typename at<T, num<1>>::type

Typedef camp::t

Typedef Documentation
using camp::t = num<true>

Typedef camp::true_type

Typedef Documentation
using camp::true_type = num<true>

Typedef camp::tuple_ebt_t

Typedef Documentation
using camp::tuple_ebt_t = typename tuple_element<camp::at_key<typename Tuple::TMap, T>::value, Tuple>::type

Typedef camp::tuple_element_t

Typedef Documentation
using camp::tuple_element_t = typename tuple_element<i, T>::type

Typedef camp::type::c::add

Typedef Documentation
using camp::type::c::add = const T

add const qualifier to T

Typedef camp::type::c::rem

Typedef Documentation
using camp::type::c::rem = typename rem_s<T>::type

remove const qualifier from T

Typedef camp::type::cv::add

Typedef Documentation
using camp::type::cv::add = volatile const T

add const and volatile qualifiers to T

Typedef camp::type::cv::rem

Typedef Documentation
using camp::type::cv::rem = typename rem_s<T>::type

remove const and volatile qualifiers from T

Typedef camp::type::ptr::add

Typedef Documentation
using camp::type::ptr::add = T*

add remove pointer to T

Typedef camp::type::ptr::rem

Typedef Documentation
using camp::type::ptr::rem = typename rem_s<T>::type

remove pointer from T

Typedef camp::type::ref::add

Typedef Documentation
using camp::type::ref::add = T&

add remove reference to T

Typedef camp::type::ref::rem

Typedef Documentation
using camp::type::ref::rem = typename rem_s<T>::type

remove reference from T

Typedef camp::type::rvref::add

Typedef Documentation
using camp::type::rvref::add = T&&

add rvalue reference to T

Typedef camp::type::v::add

Typedef Documentation
using camp::type::v::add = T

add volatile qualifier to T

Typedef camp::type::v::rem

Typedef Documentation
using camp::type::v::rem = typename rem_s<T>::type

remove volatile qualifier from T

Typedef camp::type_traits::IsSpecialized

Typedef Documentation
using camp::type_traits::IsSpecialized = detail::IsSpecialized<void, Outer, Args...>

Typedef camp::type_traits::IterableValue

Typedef Documentation
using camp::type_traits::IterableValue = decltype(*std::begin(camp::val<T>()))

Typedef camp::type_traits::IteratorValue

Typedef Documentation
using camp::type_traits::IteratorValue = decltype(*camp::val<T>())