types.hpp File Reference

#include "timemory/api.hpp"
#include "timemory/mpl/concepts.hpp"
#include "timemory/utility/types.hpp"
#include <cstdint>
#include <functional>
#include <iostream>
#include <string>
#include <type_traits>
#include <vector>

Include dependency graph for types.hpp:

Go to the source code of this file.

Classes
struct	tim::trait::apply< TraitT, CommonT >
	generic functions for setting/accessing static properties on types More...
struct	tim::trait::is_available< T >
	trait that signifies that an implementation for the component is available. When this is set to false, the variadic component bundlers like component_tuple will silently filter out this type from the template parameters, e.g. More...
struct	tim::trait::is_available< T * >
struct	tim::get_index_sequence< Tp >
struct	tim::get_index_sequence< Tuple< Types... > >
struct	tim::mpl::get_tuple_size< Tp >
struct	tim::mpl::push_back< Tuple< Types... >, T >
struct	tim::mpl::push_back< Hybrid< Lhs< LhsTypes... >, Rhs< RhsTypes... > >, T >
struct	tim::mpl::union_index_of< T, TupleT< Types... > >
struct	tim::mpl::union_index_of< T *, TupleT< Types... > >
struct	tim::mpl::union_index_sequence< LhsT< Lhs... >, RhsT< Rhs... > >

Namespaces
namespace	tim
namespace	tim::trait
namespace	tim::policy
namespace	tim::mpl

Typedefs
template<typename T >
using	tim::trait::runtime_configurable = concepts::is_runtime_configurable< T >
template<typename T >
using	tim::trait::input_archive_t = typename input_archive< T, TIMEMORY_API >::type
template<typename T >
using	tim::trait::output_archive_t = typename output_archive< T, TIMEMORY_API >::type
template<typename T >
using	tim::trait::is_available_t = typename is_available< T >::type
template<typename T >
using	tim::policy::input_archive_t = input_archive< trait::input_archive_t< T >, TIMEMORY_API >
template<typename T >
using	tim::policy::output_archive_t = output_archive< trait::output_archive_t< T >, TIMEMORY_API >
template<typename... Ts>
using	tim::tuple_concat_t = typename impl::tuple_concat< Ts... >::type
template<typename... Ts>
using	tim::type_concat_t = typename impl::type_concat< Ts... >::type
template<typename U >
using	tim::remove_pointer_t = typename std::remove_pointer< U >::type
template<typename U >
using	tim::add_pointer_t = conditional_t<(std::is_pointer< U >::value), U, U * >
template<typename Tp , typename Type >
using	tim::index_of = impl::index_of< Tp, Type >
template<typename Tp , typename Types >
using	tim::is_one_of = typename impl::is_one_of< Tp, Types >
	check if type is in expansion More...
template<template< typename > class Predicate, typename Types >
using	tim::contains_one_of = typename impl::contains_one_of< Predicate, Types >
	check if type is in expansion More...
template<template< typename > class Predicate, typename Types >
using	tim::contains_one_of_t = typename contains_one_of< Predicate, Types >::type
template<typename Tp >
using	tim::get_index_sequence_t = typename get_index_sequence< decay_t< Tp > >::type
template<typename T , typename U >
using	tim::convert_t = typename impl::convert< T, U >::type
template<template< typename... > class T, typename... U>
using	tim::convert_each_t = typename impl::convert_each< T, U... >::type
template<typename T >
using	tim::unwrap_t = typename impl::unwrapper< T >::type
template<template< typename > class CheckT, bool CheckV, template< typename > class TransformT, typename T , typename U >
using	tim::apply_transform_t = typename impl::apply_transform< CheckT, CheckV, TransformT, T, U >::type
template<typename... T>
using	tim::mpl::union_index_sequence_t = typename union_index_sequence< T... >::type
template<typename Tuple , typename T >
using	tim::push_back_t = typename mpl::push_back< Tuple, T >::type

Functions
template<typename TraitT >
std::string	tim::trait::as_string ()
template<typename Tp , typename std::enable_if<(std::is_arithmetic< Tp >::value), int >::type = 0>
constexpr auto	tim::mpl::get_size (const Tp &, std::tuple<>) -> size_t
template<typename Tp >
auto	tim::mpl::get_size (const Tp &_val, std::tuple<>) -> decltype(_val.size(), size_t())
template<typename Tp , typename std::enable_if<(std::is_arithmetic< Tp >::value), int >::type = 0>
constexpr auto	tim::mpl::get_size (const Tp &, type_list<>) -> size_t
template<typename Tp >
auto	tim::mpl::get_size (const Tp &_val, type_list<>) -> decltype(_val.size(), size_t())
template<typename Tp , size_t... Idx>
constexpr auto	tim::mpl::get_size (const Tp &_val, index_sequence< Idx... >) -> decltype(std::get< 0 >(_val), size_t())
template<typename Tp >
auto	tim::mpl::get_size (const Tp &_val) -> decltype(get_size(_val, get_index_sequence< decay_t< Tp > >::value))
template<typename T >
auto	tim::mpl::resize (T &,...) -> void
template<typename T >
auto	tim::mpl::resize (T &_targ, size_t _n) -> decltype(_targ.resize(_n), void())
template<typename Tp >
void	tim::mpl::assign (Tp &_targ, const Tp &_val,...)
template<typename Tp , typename Vp , typename ValueType = typename Tp::value_type>
auto	tim::mpl::assign (Tp &_targ, const Vp &_val, type_list<>) -> decltype(_targ[0], void())
template<typename Tp , size_t... Idx>
auto	tim::mpl::assign (Tp &_targ, const Tp &_val, index_sequence< Idx... >) -> decltype(std::get< 0 >(_val), void())
template<typename Tp , typename Vp , size_t... Idx, enable_if_t<!std::is_same< Tp, Vp >::value, int > = 0>
auto	tim::mpl::assign (Tp &_targ, const Vp &_val, index_sequence< Idx... >) -> decltype(std::get< 0 >(_targ)= *std::begin(_val), void())
template<typename Tp , typename Vp >
void	tim::mpl::assign (Tp &_targ, const Vp &_val)
template<typename Rp , typename Tp >
decltype(auto)	tim::mpl::get_reference_tuple (Tp &&_tuple)

Detailed Description

This is a declaration of all the operation structs. Care should be taken to make sure that this includes a minimal number of additional headers.

Definition in file types.hpp.

---

Class Documentation

tim::mpl::push_back< Tuple< Types... >, T >

struct tim::mpl::push_back< Tuple< Types... >, T >

template<template< typename... > class Tuple, typename... Types, typename T>
struct tim::mpl::push_back< Tuple< Types... >, T >

Definition at line 995 of file types.hpp.

Collaboration diagram for tim::mpl::push_back< Tuple< Types... >, T >:

Class Members
typedef Tuple< Types..., T >	type

tim::mpl::push_back< Hybrid< Lhs< LhsTypes... >, Rhs< RhsTypes... > >, T >

struct tim::mpl::push_back< Hybrid< Lhs< LhsTypes... >, Rhs< RhsTypes... > >, T >

template<template< typename, typename > class Hybrid, template< typename... > class Lhs, typename... LhsTypes, template< typename... > class Rhs, typename... RhsTypes, typename T>
struct tim::mpl::push_back< Hybrid< Lhs< LhsTypes... >, Rhs< RhsTypes... > >, T >

Definition at line 1003 of file types.hpp.

Collaboration diagram for tim::mpl::push_back< Hybrid< Lhs< LhsTypes... >, Rhs< RhsTypes... > >, T >:

Class Members
typedef Hybrid< Lhs< LhsTypes..., T >, Rhs< RhsTypes... > >	type

tim::mpl::union_index_sequence< LhsT< Lhs... >, RhsT< Rhs... > >

struct tim::mpl::union_index_sequence< LhsT< Lhs... >, RhsT< Rhs... > >

template<template< typename... > class LhsT, typename... Lhs, template< typename... > class RhsT, typename... Rhs>
struct tim::mpl::union_index_sequence< LhsT< Lhs... >, RhsT< Rhs... > >

Definition at line 1054 of file types.hpp.

Collaboration diagram for tim::mpl::union_index_sequence< LhsT< Lhs... >, RhsT< Rhs... > >:

Class Members
typedef index_sequence< union_index_of< decay_t< Lhs >, RhsT< decay_t< Rhs >... > >::value(0)... >	type