bc::traits Namespace Reference

Namespaces
	common
	detail

Classes
struct	all
struct	all< Function, T, Ts... >
struct	any
struct	any< Function, T, Ts... >
struct	Bind
	Similar to std::bind but the evaluation of the function in respect to its bound arguments are deduced if and only if the function is called. More...
struct	common_traits
struct	conditional_detected
struct	conditional_detected< func, TestType, DefaultType, enable_if_t< is_detected_v< func, TestType > > >
struct	Integer
struct	is_detected
struct	is_detected< func, T, enable_if_t< true_v< func< T > > > >
struct	is_template_same
struct	is_template_same< T< Args1... >, T< Args2... > >
class	None
class	sequence_contains
class	sequence_first
class	sequence_last
class	sequence_last< T >
class	sequence_of
struct	Type
struct	using_type

Typedefs
template<bool x, class T >
using	only_if = conditional_t< x, T, detail::DISABLE< T > >
template<class... >
using	void_t = void
template<class... >
using	true_t = true_type
template<class... >
using	false_t = false_type
template<bool Bool>
using	truth_type = conditional_t< Bool, true_type, false_type >
template<bool cond>
using	not_type = conditional_t< cond, false_type, true_type >
template<template< class > class func, class TestType , class DefaultType >
using	conditional_detected_t = typename conditional_detected< func, TestType, DefaultType >::type
template<class T >
using	query_value_type = typename T::value_type
template<class T >
using	query_allocator_type = typename T::allocator_type
template<class T >
using	query_system_tag = typename T::system_tag
template<class T >
using	query_get_stream = decltype(std::declval< T >().get_stream)
template<class T >
using	query_get_allocator = decltype(std::declval< T >().get_allocator)

Functions
template<class Function , class... Args>
Bind< Function, Args &&... >	bind (Function function, Args &&... args)
template<bool cond, class f1 , class f2 >
auto	constexpr_ternary (f1 true_path, f2 false_path)
	C++ 11/14 version of constexpr if. More...
template<bool Bool, class Function >
auto	constexpr_if (Function function)
template<bool Bool, class F1 , class F2 >
auto	constexpr_if (F1 f1, F2 f2)
template<bool Bool, class Function >
auto	constexpr_else_if (Function function)
template<bool Bool, class F1 , class F2 >
auto	constexpr_else_if (F1 f1, F2 f2)
template<class Function >
auto	constexpr_else (Function function)
template<int Index, class... Args>
__host__ __device__ auto	get (Args &&... args) -> decltype(detail::get_impl(Integer< Index >(), std::forward< Args >(args)...))
template<class... Args>
auto	get_last (Args &&... args) -> decltype(get< sizeof...(Args) -1 >(std::forward< Args >(args)...))
template<class Arg , class... Args>
auto	get_first (Arg &&arg, Args &&... args) -> decltype(std::forward< Arg >(arg))

Typedef Documentation

conditional_detected_t

template<template< class > class func, class TestType , class DefaultType >

using bc::traits::conditional_detected_t = typedef typename conditional_detected<func, TestType, DefaultType>::type

false_t

template<class... >

using bc::traits::false_t = typedef false_type

not_type

template<bool cond>

using bc::traits::not_type = typedef conditional_t<cond, false_type, true_type>

only_if

template<bool x, class T >

using bc::traits::only_if = typedef conditional_t<x, T, detail::DISABLE<T> >

query_allocator_type

template<class T >

using bc::traits::query_allocator_type = typedef typename T::allocator_type

query_get_allocator

template<class T >

using bc::traits::query_get_allocator = typedef decltype(std::declval<T>().get_allocator)

query_get_stream

template<class T >

using bc::traits::query_get_stream = typedef decltype(std::declval<T>().get_stream)

query_system_tag

template<class T >

using bc::traits::query_system_tag = typedef typename T::system_tag

query_value_type

template<class T >

using bc::traits::query_value_type = typedef typename T::value_type

true_t

template<class... >

using bc::traits::true_t = typedef true_type

truth_type

template<bool Bool>

using bc::traits::truth_type = typedef conditional_t<Bool, true_type, false_type>

void_t

template<class... >

using bc::traits::void_t = typedef void

Function Documentation

bind()

template<class Function , class... Args>

Bind<Function, Args&&...> bc::traits::bind	(	Function	function,
		Args &&...	args
	)

constexpr_else()

template<class Function >

auto bc::traits::constexpr_else

(

Function

function

)

constexpr_else_if() [1/2]

template<bool Bool, class Function >

auto bc::traits::constexpr_else_if

(

Function

function

)

constexpr_else_if() [2/2]

template<bool Bool, class F1 , class F2 >

auto bc::traits::constexpr_else_if	(	F1	f1,
		F2	f2
	)

constexpr_if() [1/2]

template<bool Bool, class Function >

auto bc::traits::constexpr_if

(

Function

function

)

constexpr_if() [2/2]

template<bool Bool, class F1 , class F2 >

auto bc::traits::constexpr_if	(	F1	f1,
		F2	f2
	)

constexpr_ternary()

template<bool cond, class f1 , class f2 >

auto bc::traits::constexpr_ternary	(	f1	true_path,
		f2	false_path
	)

C++ 11/14 version of constexpr if.

(Required because NVCC doesn't support C++17)

Accepts a constexpr bool template argument, and one or two functors (that take no arguments) if true, calls and returns the first functor, else the second.

Example:

int main() { return bc::traits::constexpr_if<true>( []() { std::cout << " constexpr_boolean is true " << std::endl; return true; }, []() { std::cout << " constexpr_boolean is false " << std::endl; return false; } ); } output: constexpr_boolean is true

get()

template<int Index, class... Args>

__host__ __device__ auto bc::traits::get ( Args &&...  args ) -> decltype(detail::get_impl(Integer<Index>(), std::forward<Args>(args)...))

inline

get_first()

template<class Arg , class... Args>

auto bc::traits::get_first	(	Arg &&	arg,
		Args &&...	args
	)		-> decltype(std::forward<Arg>(arg))

get_last()

template<class... Args>

auto bc::traits::get_last

(

Args &&...

args

)

-> decltype(get<sizeof...(Args)-1>(std::forward<Args>(args)...))