// - lambda_traits.hpp --- Boost Lambda Library ---------------------------- | |
// | |
// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) | |
// | |
// Distributed under the Boost Software License, Version 1.0. (See | |
// accompanying file LICENSE_1_0.txt or copy at | |
// http://www.boost.org/LICENSE_1_0.txt) | |
// | |
// For more information, see www.boost.org | |
// ------------------------------------------------------------------------- | |
#ifndef BOOST_LAMBDA_LAMBDA_TRAITS_HPP | |
#define BOOST_LAMBDA_LAMBDA_TRAITS_HPP | |
#include "boost/type_traits/transform_traits.hpp" | |
#include "boost/type_traits/cv_traits.hpp" | |
#include "boost/type_traits/function_traits.hpp" | |
#include "boost/type_traits/object_traits.hpp" | |
#include "boost/tuple/tuple.hpp" | |
namespace boost { | |
namespace lambda { | |
// -- if construct ------------------------------------------------ | |
// Proposed by Krzysztof Czarnecki and Ulrich Eisenecker | |
namespace detail { | |
template <bool If, class Then, class Else> struct IF { typedef Then RET; }; | |
template <class Then, class Else> struct IF<false, Then, Else> { | |
typedef Else RET; | |
}; | |
// An if construct that doesn't instantiate the non-matching template: | |
// Called as: | |
// IF_type<condition, A, B>::type | |
// The matching template must define the typeded 'type' | |
// I.e. A::type if condition is true, B::type if condition is false | |
// Idea from Vesa Karvonen (from C&E as well I guess) | |
template<class T> | |
struct IF_type_ | |
{ | |
typedef typename T::type type; | |
}; | |
template<bool C, class T, class E> | |
struct IF_type | |
{ | |
typedef typename | |
IF_type_<typename IF<C, T, E>::RET >::type type; | |
}; | |
// helper that can be used to give typedef T to some type | |
template <class T> struct identity_mapping { typedef T type; }; | |
// An if construct for finding an integral constant 'value' | |
// Does not instantiate the non-matching branch | |
// Called as IF_value<condition, A, B>::value | |
// If condition is true A::value must be defined, otherwise B::value | |
template<class T> | |
struct IF_value_ | |
{ | |
BOOST_STATIC_CONSTANT(int, value = T::value); | |
}; | |
template<bool C, class T, class E> | |
struct IF_value | |
{ | |
BOOST_STATIC_CONSTANT(int, value = (IF_value_<typename IF<C, T, E>::RET>::value)); | |
}; | |
// -------------------------------------------------------------- | |
// removes reference from other than function types: | |
template<class T> class remove_reference_if_valid | |
{ | |
typedef typename boost::remove_reference<T>::type plainT; | |
public: | |
typedef typename IF< | |
boost::is_function<plainT>::value, | |
T, | |
plainT | |
>::RET type; | |
}; | |
template<class T> struct remove_reference_and_cv { | |
typedef typename boost::remove_cv< | |
typename boost::remove_reference<T>::type | |
>::type type; | |
}; | |
// returns a reference to the element of tuple T | |
template<int N, class T> struct tuple_element_as_reference { | |
typedef typename | |
boost::tuples::access_traits< | |
typename boost::tuples::element<N, T>::type | |
>::non_const_type type; | |
}; | |
// returns the cv and reverence stripped type of a tuple element | |
template<int N, class T> struct tuple_element_stripped { | |
typedef typename | |
remove_reference_and_cv< | |
typename boost::tuples::element<N, T>::type | |
>::type type; | |
}; | |
// is_lambda_functor ------------------------------------------------- | |
template <class T> struct is_lambda_functor_ { | |
BOOST_STATIC_CONSTANT(bool, value = false); | |
}; | |
template <class Arg> struct is_lambda_functor_<lambda_functor<Arg> > { | |
BOOST_STATIC_CONSTANT(bool, value = true); | |
}; | |
} // end detail | |
template <class T> struct is_lambda_functor { | |
BOOST_STATIC_CONSTANT(bool, | |
value = | |
detail::is_lambda_functor_< | |
typename detail::remove_reference_and_cv<T>::type | |
>::value); | |
}; | |
namespace detail { | |
// -- parameter_traits_ --------------------------------------------- | |
// An internal parameter type traits class that respects | |
// the reference_wrapper class. | |
// The conversions performed are: | |
// references -> compile_time_error | |
// T1 -> T2, | |
// reference_wrapper<T> -> T& | |
// const array -> ref to const array | |
// array -> ref to array | |
// function -> ref to function | |
// ------------------------------------------------------------------------ | |
template<class T1, class T2> | |
struct parameter_traits_ { | |
typedef T2 type; | |
}; | |
// Do not instantiate with reference types | |
template<class T, class Any> struct parameter_traits_<T&, Any> { | |
typedef typename | |
generate_error<T&>:: | |
parameter_traits_class_instantiated_with_reference_type type; | |
}; | |
// Arrays can't be stored as plain types; convert them to references | |
template<class T, int n, class Any> struct parameter_traits_<T[n], Any> { | |
typedef T (&type)[n]; | |
}; | |
template<class T, int n, class Any> | |
struct parameter_traits_<const T[n], Any> { | |
typedef const T (&type)[n]; | |
}; | |
template<class T, int n, class Any> | |
struct parameter_traits_<volatile T[n], Any> { | |
typedef volatile T (&type)[n]; | |
}; | |
template<class T, int n, class Any> | |
struct parameter_traits_<const volatile T[n], Any> { | |
typedef const volatile T (&type)[n]; | |
}; | |
template<class T, class Any> | |
struct parameter_traits_<boost::reference_wrapper<T>, Any >{ | |
typedef T& type; | |
}; | |
template<class T, class Any> | |
struct parameter_traits_<const boost::reference_wrapper<T>, Any >{ | |
typedef T& type; | |
}; | |
template<class T, class Any> | |
struct parameter_traits_<volatile boost::reference_wrapper<T>, Any >{ | |
typedef T& type; | |
}; | |
template<class T, class Any> | |
struct parameter_traits_<const volatile boost::reference_wrapper<T>, Any >{ | |
typedef T& type; | |
}; | |
template<class Any> | |
struct parameter_traits_<void, Any> { | |
typedef void type; | |
}; | |
template<class Arg, class Any> | |
struct parameter_traits_<lambda_functor<Arg>, Any > { | |
typedef lambda_functor<Arg> type; | |
}; | |
template<class Arg, class Any> | |
struct parameter_traits_<const lambda_functor<Arg>, Any > { | |
typedef lambda_functor<Arg> type; | |
}; | |
// Are the volatile versions needed? | |
template<class Arg, class Any> | |
struct parameter_traits_<volatile lambda_functor<Arg>, Any > { | |
typedef lambda_functor<Arg> type; | |
}; | |
template<class Arg, class Any> | |
struct parameter_traits_<const volatile lambda_functor<Arg>, Any > { | |
typedef lambda_functor<Arg> type; | |
}; | |
} // end namespace detail | |
// ------------------------------------------------------------------------ | |
// traits classes for lambda expressions (bind functions, operators ...) | |
// must be instantiated with non-reference types | |
// The default is const plain type ------------------------- | |
// const T -> const T, | |
// T -> const T, | |
// references -> compile_time_error | |
// reference_wrapper<T> -> T& | |
// array -> const ref array | |
template<class T> | |
struct const_copy_argument { | |
typedef typename | |
detail::parameter_traits_< | |
T, | |
typename detail::IF<boost::is_function<T>::value, T&, const T>::RET | |
>::type type; | |
}; | |
// T may be a function type. Without the IF test, const would be added | |
// to a function type, which is illegal. | |
// all arrays are converted to const. | |
// This traits template is used for 'const T&' parameter passing | |
// and thus the knowledge of the potential | |
// non-constness of an actual argument is lost. | |
template<class T, int n> struct const_copy_argument <T[n]> { | |
typedef const T (&type)[n]; | |
}; | |
template<class T, int n> struct const_copy_argument <volatile T[n]> { | |
typedef const volatile T (&type)[n]; | |
}; | |
template<class T> | |
struct const_copy_argument<T&> {}; | |
// do not instantiate with references | |
// typedef typename detail::generate_error<T&>::references_not_allowed type; | |
template<> | |
struct const_copy_argument<void> { | |
typedef void type; | |
}; | |
// Does the same as const_copy_argument, but passes references through as such | |
template<class T> | |
struct bound_argument_conversion { | |
typedef typename const_copy_argument<T>::type type; | |
}; | |
template<class T> | |
struct bound_argument_conversion<T&> { | |
typedef T& type; | |
}; | |
// The default is non-const reference ------------------------- | |
// const T -> const T&, | |
// T -> T&, | |
// references -> compile_time_error | |
// reference_wrapper<T> -> T& | |
template<class T> | |
struct reference_argument { | |
typedef typename detail::parameter_traits_<T, T&>::type type; | |
}; | |
template<class T> | |
struct reference_argument<T&> { | |
typedef typename detail::generate_error<T&>::references_not_allowed type; | |
}; | |
template<class Arg> | |
struct reference_argument<lambda_functor<Arg> > { | |
typedef lambda_functor<Arg> type; | |
}; | |
template<class Arg> | |
struct reference_argument<const lambda_functor<Arg> > { | |
typedef lambda_functor<Arg> type; | |
}; | |
// Are the volatile versions needed? | |
template<class Arg> | |
struct reference_argument<volatile lambda_functor<Arg> > { | |
typedef lambda_functor<Arg> type; | |
}; | |
template<class Arg> | |
struct reference_argument<const volatile lambda_functor<Arg> > { | |
typedef lambda_functor<Arg> type; | |
}; | |
template<> | |
struct reference_argument<void> { | |
typedef void type; | |
}; | |
namespace detail { | |
// Array to pointer conversion | |
template <class T> | |
struct array_to_pointer { | |
typedef T type; | |
}; | |
template <class T, int N> | |
struct array_to_pointer <const T[N]> { | |
typedef const T* type; | |
}; | |
template <class T, int N> | |
struct array_to_pointer <T[N]> { | |
typedef T* type; | |
}; | |
template <class T, int N> | |
struct array_to_pointer <const T (&) [N]> { | |
typedef const T* type; | |
}; | |
template <class T, int N> | |
struct array_to_pointer <T (&) [N]> { | |
typedef T* type; | |
}; | |
// --------------------------------------------------------------------------- | |
// The call_traits for bind | |
// Respects the reference_wrapper class. | |
// These templates are used outside of bind functions as well. | |
// the bind_tuple_mapper provides a shorter notation for default | |
// bound argument storing semantics, if all arguments are treated | |
// uniformly. | |
// from template<class T> foo(const T& t) : bind_traits<const T>::type | |
// from template<class T> foo(T& t) : bind_traits<T>::type | |
// Conversions: | |
// T -> const T, | |
// cv T -> cv T, | |
// T& -> T& | |
// reference_wrapper<T> -> T& | |
// const reference_wrapper<T> -> T& | |
// array -> const ref array | |
// make bound arguments const, this is a deliberate design choice, the | |
// purpose is to prevent side effects to bound arguments that are stored | |
// as copies | |
template<class T> | |
struct bind_traits { | |
typedef const T type; | |
}; | |
template<class T> | |
struct bind_traits<T&> { | |
typedef T& type; | |
}; | |
// null_types are an exception, we always want to store them as non const | |
// so that other templates can assume that null_type is always without const | |
template<> | |
struct bind_traits<null_type> { | |
typedef null_type type; | |
}; | |
// the bind_tuple_mapper, bind_type_generators may | |
// introduce const to null_type | |
template<> | |
struct bind_traits<const null_type> { | |
typedef null_type type; | |
}; | |
// Arrays can't be stored as plain types; convert them to references. | |
// All arrays are converted to const. This is because bind takes its | |
// parameters as const T& and thus the knowledge of the potential | |
// non-constness of actual argument is lost. | |
template<class T, int n> struct bind_traits <T[n]> { | |
typedef const T (&type)[n]; | |
}; | |
template<class T, int n> | |
struct bind_traits<const T[n]> { | |
typedef const T (&type)[n]; | |
}; | |
template<class T, int n> struct bind_traits<volatile T[n]> { | |
typedef const volatile T (&type)[n]; | |
}; | |
template<class T, int n> | |
struct bind_traits<const volatile T[n]> { | |
typedef const volatile T (&type)[n]; | |
}; | |
template<class R> | |
struct bind_traits<R()> { | |
typedef R(&type)(); | |
}; | |
template<class R, class Arg1> | |
struct bind_traits<R(Arg1)> { | |
typedef R(&type)(Arg1); | |
}; | |
template<class R, class Arg1, class Arg2> | |
struct bind_traits<R(Arg1, Arg2)> { | |
typedef R(&type)(Arg1, Arg2); | |
}; | |
template<class R, class Arg1, class Arg2, class Arg3> | |
struct bind_traits<R(Arg1, Arg2, Arg3)> { | |
typedef R(&type)(Arg1, Arg2, Arg3); | |
}; | |
template<class R, class Arg1, class Arg2, class Arg3, class Arg4> | |
struct bind_traits<R(Arg1, Arg2, Arg3, Arg4)> { | |
typedef R(&type)(Arg1, Arg2, Arg3, Arg4); | |
}; | |
template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5> | |
struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5)> { | |
typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5); | |
}; | |
template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6> | |
struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)> { | |
typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6); | |
}; | |
template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7> | |
struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7)> { | |
typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7); | |
}; | |
template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8> | |
struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8)> { | |
typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8); | |
}; | |
template<class R, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7, class Arg8, class Arg9> | |
struct bind_traits<R(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9)> { | |
typedef R(&type)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9); | |
}; | |
template<class T> | |
struct bind_traits<reference_wrapper<T> >{ | |
typedef T& type; | |
}; | |
template<class T> | |
struct bind_traits<const reference_wrapper<T> >{ | |
typedef T& type; | |
}; | |
template<> | |
struct bind_traits<void> { | |
typedef void type; | |
}; | |
template < | |
class T0 = null_type, class T1 = null_type, class T2 = null_type, | |
class T3 = null_type, class T4 = null_type, class T5 = null_type, | |
class T6 = null_type, class T7 = null_type, class T8 = null_type, | |
class T9 = null_type | |
> | |
struct bind_tuple_mapper { | |
typedef | |
tuple<typename bind_traits<T0>::type, | |
typename bind_traits<T1>::type, | |
typename bind_traits<T2>::type, | |
typename bind_traits<T3>::type, | |
typename bind_traits<T4>::type, | |
typename bind_traits<T5>::type, | |
typename bind_traits<T6>::type, | |
typename bind_traits<T7>::type, | |
typename bind_traits<T8>::type, | |
typename bind_traits<T9>::type> type; | |
}; | |
// bind_traits, except map const T& -> const T | |
// this is needed e.g. in currying. Const reference arguments can | |
// refer to temporaries, so it is not safe to store them as references. | |
template <class T> struct remove_const_reference { | |
typedef typename bind_traits<T>::type type; | |
}; | |
template <class T> struct remove_const_reference<const T&> { | |
typedef const T type; | |
}; | |
// maps the bind argument types to the resulting lambda functor type | |
template < | |
class T0 = null_type, class T1 = null_type, class T2 = null_type, | |
class T3 = null_type, class T4 = null_type, class T5 = null_type, | |
class T6 = null_type, class T7 = null_type, class T8 = null_type, | |
class T9 = null_type | |
> | |
class bind_type_generator { | |
typedef typename | |
detail::bind_tuple_mapper< | |
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 | |
>::type args_t; | |
BOOST_STATIC_CONSTANT(int, nof_elems = boost::tuples::length<args_t>::value); | |
typedef | |
action< | |
nof_elems, | |
function_action<nof_elems> | |
> action_type; | |
public: | |
typedef | |
lambda_functor< | |
lambda_functor_base< | |
action_type, | |
args_t | |
> | |
> type; | |
}; | |
} // detail | |
template <class T> inline const T& make_const(const T& t) { return t; } | |
} // end of namespace lambda | |
} // end of namespace boost | |
#endif // BOOST_LAMBDA_TRAITS_HPP |