diff options
Diffstat (limited to '3rdParty/Boost/src/boost/lambda/detail/operator_return_type_traits.hpp')
-rw-r--r-- | 3rdParty/Boost/src/boost/lambda/detail/operator_return_type_traits.hpp | 917 |
1 files changed, 917 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/lambda/detail/operator_return_type_traits.hpp b/3rdParty/Boost/src/boost/lambda/detail/operator_return_type_traits.hpp new file mode 100644 index 0000000..b2d3d3a --- /dev/null +++ b/3rdParty/Boost/src/boost/lambda/detail/operator_return_type_traits.hpp @@ -0,0 +1,917 @@ +// operator_return_type_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_OPERATOR_RETURN_TYPE_TRAITS_HPP +#define BOOST_LAMBDA_OPERATOR_RETURN_TYPE_TRAITS_HPP + +#include "boost/lambda/detail/is_instance_of.hpp" +#include "boost/type_traits/same_traits.hpp" + +#include "boost/indirect_reference.hpp" +#include "boost/detail/container_fwd.hpp" + +#include <cstddef> // needed for the ptrdiff_t +#include <iosfwd> // for istream and ostream + +#include <iterator> // needed for operator& + +namespace boost { +namespace lambda { +namespace detail { + +// -- general helper templates for type deduction ------------------ + +// Much of the type deduction code for standard arithmetic types from Gary Powell + +template <class A> struct promote_code { static const int value = -1; }; +// this means that a code is not defined for A + +// -- the next 5 types are needed in if_then_else_return +// the promotion order is not important, but they must have distinct values. +template <> struct promote_code<bool> { static const int value = 10; }; +template <> struct promote_code<char> { static const int value = 20; }; +template <> struct promote_code<unsigned char> { static const int value = 30; }; +template <> struct promote_code<signed char> { static const int value = 40; }; +template <> struct promote_code<short int> { static const int value = 50; }; +// ---------- + +template <> struct promote_code<int> { static const int value = 100; }; +template <> struct promote_code<unsigned int> { static const int value = 200; }; +template <> struct promote_code<long> { static const int value = 300; }; +template <> struct promote_code<unsigned long> { static const int value = 400; }; + +template <> struct promote_code<float> { static const int value = 500; }; +template <> struct promote_code<double> { static const int value = 600; }; +template <> struct promote_code<long double> { static const int value = 700; }; + +// TODO: wchar_t + +// forward delcaration of complex. + +} // namespace detail +} // namespace lambda +} // namespace boost + +namespace boost { +namespace lambda { +namespace detail { + +template <> struct promote_code< std::complex<float> > { static const int value = 800; }; +template <> struct promote_code< std::complex<double> > { static const int value = 900; }; +template <> struct promote_code< std::complex<long double> > { static const int value = 1000; }; + +// -- int promotion ------------------------------------------- +template <class T> struct promote_to_int { typedef T type; }; + +template <> struct promote_to_int<bool> { typedef int type; }; +template <> struct promote_to_int<char> { typedef int type; }; +template <> struct promote_to_int<unsigned char> { typedef int type; }; +template <> struct promote_to_int<signed char> { typedef int type; }; +template <> struct promote_to_int<short int> { typedef int type; }; + +// The unsigned short int promotion rule is this: +// unsigned short int to signed int if a signed int can hold all values +// of unsigned short int, otherwise go to unsigned int. +template <> struct promote_to_int<unsigned short int> +{ + typedef + detail::IF<sizeof(int) <= sizeof(unsigned short int), +// I had the logic reversed but ">" messes up the parsing. + unsigned int, + int>::RET type; +}; + + +// TODO: think, should there be default behaviour for non-standard types? + +} // namespace detail + +// ------------------------------------------ +// Unary actions ---------------------------- +// ------------------------------------------ + +template<class Act, class A> +struct plain_return_type_1 { + typedef detail::unspecified type; +}; + + + +template<class Act, class A> +struct plain_return_type_1<unary_arithmetic_action<Act>, A> { + typedef A type; +}; + +template<class Act, class A> +struct return_type_1<unary_arithmetic_action<Act>, A> { + typedef + typename plain_return_type_1< + unary_arithmetic_action<Act>, + typename detail::remove_reference_and_cv<A>::type + >::type type; +}; + + +template<class A> +struct plain_return_type_1<bitwise_action<not_action>, A> { + typedef A type; +}; + +// bitwise not, operator~() +template<class A> struct return_type_1<bitwise_action<not_action>, A> { + typedef + typename plain_return_type_1< + bitwise_action<not_action>, + typename detail::remove_reference_and_cv<A>::type + >::type type; +}; + + +// prefix increment and decrement operators return +// their argument by default as a non-const reference +template<class Act, class A> +struct plain_return_type_1<pre_increment_decrement_action<Act>, A> { + typedef A& type; +}; + +template<class Act, class A> +struct return_type_1<pre_increment_decrement_action<Act>, A> { + typedef + typename plain_return_type_1< + pre_increment_decrement_action<Act>, + typename detail::remove_reference_and_cv<A>::type + >::type type; +}; + +// post decrement just returns the same plain type. +template<class Act, class A> +struct plain_return_type_1<post_increment_decrement_action<Act>, A> { + typedef A type; +}; + +template<class Act, class A> +struct return_type_1<post_increment_decrement_action<Act>, A> +{ + typedef + typename plain_return_type_1< + post_increment_decrement_action<Act>, + typename detail::remove_reference_and_cv<A>::type + >::type type; +}; + +// logical not, operator!() +template<class A> +struct plain_return_type_1<logical_action<not_action>, A> { + typedef bool type; +}; + +template<class A> +struct return_type_1<logical_action<not_action>, A> { + typedef + typename plain_return_type_1< + logical_action<not_action>, + typename detail::remove_reference_and_cv<A>::type + >::type type; +}; + +// address of action --------------------------------------- + + +template<class A> +struct return_type_1<other_action<addressof_action>, A> { + typedef + typename plain_return_type_1< + other_action<addressof_action>, + typename detail::remove_reference_and_cv<A>::type + >::type type1; + + // If no user defined specialization for A, then return the + // cv qualified pointer to A + typedef typename detail::IF< + boost::is_same<type1, detail::unspecified>::value, + typename boost::remove_reference<A>::type*, + type1 + >::RET type; +}; + +// contentsof action ------------------------------------ + +// TODO: this deduction may lead to fail directly, +// (if A has no specialization for iterator_traits and has no +// typedef A::reference. +// There is no easy way around this, cause there doesn't seem to be a way +// to test whether a class is an iterator or not. + +// The default works with std::iterators. + +namespace detail { + + // A is a nonreference type +template <class A> struct contentsof_type { + typedef typename boost::indirect_reference<A>::type type; +}; + + // this is since the nullary () in lambda_functor is always instantiated +template <> struct contentsof_type<null_type> { + typedef detail::unspecified type; +}; + + +template <class A> struct contentsof_type<const A> { + typedef typename contentsof_type<A>::type type; +}; + +template <class A> struct contentsof_type<volatile A> { + typedef typename contentsof_type<A>::type type; +}; + +template <class A> struct contentsof_type<const volatile A> { + typedef typename contentsof_type<A>::type type; +}; + + // standard iterator traits should take care of the pointer types + // but just to be on the safe side, we have the specializations here: + // these work even if A is cv-qualified. +template <class A> struct contentsof_type<A*> { + typedef A& type; +}; +template <class A> struct contentsof_type<A* const> { + typedef A& type; +}; +template <class A> struct contentsof_type<A* volatile> { + typedef A& type; +}; +template <class A> struct contentsof_type<A* const volatile> { + typedef A& type; +}; + +template<class A, int N> struct contentsof_type<A[N]> { + typedef A& type; +}; +template<class A, int N> struct contentsof_type<const A[N]> { + typedef const A& type; +}; +template<class A, int N> struct contentsof_type<volatile A[N]> { + typedef volatile A& type; +}; +template<class A, int N> struct contentsof_type<const volatile A[N]> { + typedef const volatile A& type; +}; + + + + + +} // end detail + +template<class A> +struct return_type_1<other_action<contentsof_action>, A> { + + typedef + typename plain_return_type_1< + other_action<contentsof_action>, + typename detail::remove_reference_and_cv<A>::type + >::type type1; + + // If no user defined specialization for A, then return the + // cv qualified pointer to A + typedef typename + detail::IF_type< + boost::is_same<type1, detail::unspecified>::value, + detail::contentsof_type< + typename boost::remove_reference<A>::type + >, + detail::identity_mapping<type1> + >::type type; +}; + + +// ------------------------------------------------------------------ +// binary actions --------------------------------------------------- +// ------------------------------------------------------------------ + +// here the default case is: no user defined versions: +template <class Act, class A, class B> +struct plain_return_type_2 { + typedef detail::unspecified type; +}; + +namespace detail { + +// error classes +class illegal_pointer_arithmetic{}; + +// pointer arithmetic type deductions ---------------------- +// value = false means that this is not a pointer arithmetic case +// value = true means, that this can be a pointer arithmetic case, but not necessarily is +// This means, that for user defined operators for pointer types, say for some operator+(X, *Y), +// the deductions must be coded at an earliel level (return_type_2). + +template<class Act, class A, class B> +struct pointer_arithmetic_traits { static const bool value = false; }; + +template<class A, class B> +struct pointer_arithmetic_traits<plus_action, A, B> { + + typedef typename + array_to_pointer<typename boost::remove_reference<A>::type>::type AP; + typedef typename + array_to_pointer<typename boost::remove_reference<B>::type>::type BP; + + static const bool is_pointer_A = boost::is_pointer<AP>::value; + static const bool is_pointer_B = boost::is_pointer<BP>::value; + + static const bool value = is_pointer_A || is_pointer_B; + + // can't add two pointers. + // note, that we do not check wether the other type is valid for + // addition with a pointer. + // the compiler will catch it in the apply function + + typedef typename + detail::IF< + is_pointer_A && is_pointer_B, + detail::return_type_deduction_failure< + detail::illegal_pointer_arithmetic + >, + typename detail::IF<is_pointer_A, AP, BP>::RET + >::RET type; + +}; + +template<class A, class B> +struct pointer_arithmetic_traits<minus_action, A, B> { + typedef typename + array_to_pointer<typename boost::remove_reference<A>::type>::type AP; + typedef typename + array_to_pointer<typename boost::remove_reference<B>::type>::type BP; + + static const bool is_pointer_A = boost::is_pointer<AP>::value; + static const bool is_pointer_B = boost::is_pointer<BP>::value; + + static const bool value = is_pointer_A || is_pointer_B; + + static const bool same_pointer_type = + is_pointer_A && is_pointer_B && + boost::is_same< + typename boost::remove_const< + typename boost::remove_pointer< + typename boost::remove_const<AP>::type + >::type + >::type, + typename boost::remove_const< + typename boost::remove_pointer< + typename boost::remove_const<BP>::type + >::type + >::type + >::value; + + // ptr - ptr has type ptrdiff_t + // note, that we do not check if, in ptr - B, B is + // valid for subtraction with a pointer. + // the compiler will catch it in the apply function + + typedef typename + detail::IF< + same_pointer_type, const std::ptrdiff_t, + typename detail::IF< + is_pointer_A, + AP, + detail::return_type_deduction_failure<detail::illegal_pointer_arithmetic> + >::RET + >::RET type; +}; + +} // namespace detail + +// -- arithmetic actions --------------------------------------------- + +namespace detail { + +template<bool is_pointer_arithmetic, class Act, class A, class B> +struct return_type_2_arithmetic_phase_1; + +template<class A, class B> struct return_type_2_arithmetic_phase_2; +template<class A, class B> struct return_type_2_arithmetic_phase_3; + +} // namespace detail + + +// drop any qualifiers from the argument types within arithmetic_action +template<class A, class B, class Act> +struct return_type_2<arithmetic_action<Act>, A, B> +{ + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2<arithmetic_action<Act>, plain_A, plain_B>::type type1; + + // if user defined return type, do not enter the whole arithmetic deductions + typedef typename + detail::IF_type< + boost::is_same<type1, detail::unspecified>::value, + detail::return_type_2_arithmetic_phase_1< + detail::pointer_arithmetic_traits<Act, A, B>::value, Act, A, B + >, + plain_return_type_2<arithmetic_action<Act>, plain_A, plain_B> + >::type type; +}; + +namespace detail { + +// perform integral promotion, no pointer arithmetic +template<bool is_pointer_arithmetic, class Act, class A, class B> +struct return_type_2_arithmetic_phase_1 +{ + typedef typename + return_type_2_arithmetic_phase_2< + typename remove_reference_and_cv<A>::type, + typename remove_reference_and_cv<B>::type + >::type type; +}; + +// pointer_arithmetic +template<class Act, class A, class B> +struct return_type_2_arithmetic_phase_1<true, Act, A, B> +{ + typedef typename + pointer_arithmetic_traits<Act, A, B>::type type; +}; + +template<class A, class B> +struct return_type_2_arithmetic_phase_2 { + typedef typename + return_type_2_arithmetic_phase_3< + typename promote_to_int<A>::type, + typename promote_to_int<B>::type + >::type type; +}; + +// specialization for unsigned int. +// We only have to do these two specialization because the value promotion will +// take care of the other cases. +// The unsigned int promotion rule is this: +// unsigned int to long if a long can hold all values of unsigned int, +// otherwise go to unsigned long. + +// struct so I don't have to type this twice. +struct promotion_of_unsigned_int +{ + typedef + detail::IF<sizeof(long) <= sizeof(unsigned int), + unsigned long, + long>::RET type; +}; + +template<> +struct return_type_2_arithmetic_phase_2<unsigned int, long> +{ + typedef promotion_of_unsigned_int::type type; +}; +template<> +struct return_type_2_arithmetic_phase_2<long, unsigned int> +{ + typedef promotion_of_unsigned_int::type type; +}; + + +template<class A, class B> struct return_type_2_arithmetic_phase_3 { + enum { promote_code_A_value = promote_code<A>::value, + promote_code_B_value = promote_code<B>::value }; // enums for KCC + typedef typename + detail::IF< + promote_code_A_value == -1 || promote_code_B_value == -1, + detail::return_type_deduction_failure<return_type_2_arithmetic_phase_3>, + typename detail::IF< + ((int)promote_code_A_value > (int)promote_code_B_value), + A, + B + >::RET + >::RET type; +}; + +} // namespace detail + +// -- bitwise actions ------------------------------------------- +// note: for integral types deuduction is similar to arithmetic actions. + +// drop any qualifiers from the argument types within arithmetic action +template<class A, class B, class Act> +struct return_type_2<bitwise_action<Act>, A, B> +{ + + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2<bitwise_action<Act>, plain_A, plain_B>::type type1; + + // if user defined return type, do not enter type deductions + typedef typename + detail::IF_type< + boost::is_same<type1, detail::unspecified>::value, + return_type_2<arithmetic_action<plus_action>, A, B>, + plain_return_type_2<bitwise_action<Act>, plain_A, plain_B> + >::type type; + + // plus_action is just a random pick, has to be a concrete instance + + // TODO: This check is only valid for built-in types, overloaded types might + // accept floating point operators + + // bitwise operators not defined for floating point types + // these test are not strictly needed here, since the error will be caught in + // the apply function + BOOST_STATIC_ASSERT(!(boost::is_float<plain_A>::value && boost::is_float<plain_B>::value)); + +}; + +namespace detail { + +#ifdef BOOST_NO_TEMPLATED_STREAMS + +template<class A, class B> +struct leftshift_type { + + typedef typename detail::IF< + boost::is_convertible< + typename boost::remove_reference<A>::type*, + std::ostream* + >::value, + std::ostream&, + typename detail::remove_reference_and_cv<A>::type + >::RET type; +}; + +template<class A, class B> +struct rightshift_type { + + typedef typename detail::IF< + + boost::is_convertible< + typename boost::remove_reference<A>::type*, + std::istream* + >::value, + std::istream&, + typename detail::remove_reference_and_cv<A>::type + >::RET type; +}; + +#else + +template <class T> struct get_ostream_type { + typedef std::basic_ostream<typename T::char_type, + typename T::traits_type>& type; +}; + +template <class T> struct get_istream_type { + typedef std::basic_istream<typename T::char_type, + typename T::traits_type>& type; +}; + +template<class A, class B> +struct leftshift_type { +private: + typedef typename boost::remove_reference<A>::type plainA; +public: + typedef typename detail::IF_type< + is_instance_of_2<plainA, std::basic_ostream>::value, + get_ostream_type<plainA>, //reference to the stream + detail::remove_reference_and_cv<A> + >::type type; +}; + +template<class A, class B> +struct rightshift_type { +private: + typedef typename boost::remove_reference<A>::type plainA; +public: + typedef typename detail::IF_type< + is_instance_of_2<plainA, std::basic_istream>::value, + get_istream_type<plainA>, //reference to the stream + detail::remove_reference_and_cv<A> + >::type type; +}; + + +#endif + +} // end detail + +// ostream +template<class A, class B> +struct return_type_2<bitwise_action<leftshift_action>, A, B> +{ + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2<bitwise_action<leftshift_action>, plain_A, plain_B>::type type1; + + // if user defined return type, do not enter type deductions + typedef typename + detail::IF_type< + boost::is_same<type1, detail::unspecified>::value, + detail::leftshift_type<A, B>, + plain_return_type_2<bitwise_action<leftshift_action>, plain_A, plain_B> + >::type type; +}; + +// istream +template<class A, class B> +struct return_type_2<bitwise_action<rightshift_action>, A, B> +{ + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2<bitwise_action<rightshift_action>, plain_A, plain_B>::type type1; + + // if user defined return type, do not enter type deductions + typedef typename + detail::IF_type< + boost::is_same<type1, detail::unspecified>::value, + detail::rightshift_type<A, B>, + plain_return_type_2<bitwise_action<rightshift_action>, plain_A, plain_B> + >::type type; +}; + +// -- logical actions ---------------------------------------- +// always bool +// NOTE: this may not be true for some weird user-defined types, +template<class A, class B, class Act> +struct plain_return_type_2<logical_action<Act>, A, B> { + typedef bool type; +}; + +template<class A, class B, class Act> +struct return_type_2<logical_action<Act>, A, B> { + + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2<logical_action<Act>, plain_A, plain_B>::type type; + +}; + + +// -- relational actions ---------------------------------------- +// always bool +// NOTE: this may not be true for some weird user-defined types, +template<class A, class B, class Act> +struct plain_return_type_2<relational_action<Act>, A, B> { + typedef bool type; +}; + +template<class A, class B, class Act> +struct return_type_2<relational_action<Act>, A, B> { + + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2<relational_action<Act>, plain_A, plain_B>::type type; +}; + +// Assingment actions ----------------------------------------------- +// return type is the type of the first argument as reference + +// note that cv-qualifiers are preserved. +// Yes, assignment operator can be const! + +// NOTE: this may not be true for some weird user-defined types, + +template<class A, class B, class Act> +struct return_type_2<arithmetic_assignment_action<Act>, A, B> { + + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2< + arithmetic_assignment_action<Act>, plain_A, plain_B + >::type type1; + + typedef typename + detail::IF< + boost::is_same<type1, detail::unspecified>::value, + typename boost::add_reference<A>::type, + type1 + >::RET type; +}; + +template<class A, class B, class Act> +struct return_type_2<bitwise_assignment_action<Act>, A, B> { + + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2< + bitwise_assignment_action<Act>, plain_A, plain_B + >::type type1; + + typedef typename + detail::IF< + boost::is_same<type1, detail::unspecified>::value, + typename boost::add_reference<A>::type, + type1 + >::RET type; +}; + +template<class A, class B> +struct return_type_2<other_action<assignment_action>, A, B> { + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2< + other_action<assignment_action>, plain_A, plain_B + >::type type1; + + typedef typename + detail::IF< + boost::is_same<type1, detail::unspecified>::value, + typename boost::add_reference<A>::type, + type1 + >::RET type; +}; + +// -- other actions ---------------------------------------- + +// comma action ---------------------------------- +// Note: this may not be true for some weird user-defined types, + +// NOTE! This only tries the plain_return_type_2 layer and gives +// detail::unspecified as default. If no such specialization is found, the +// type rule in the spcecialization of the return_type_2_prot is used +// to give the type of the right argument (which can be a reference too) +// (The built in operator, can return a l- or rvalue). +template<class A, class B> +struct return_type_2<other_action<comma_action>, A, B> { + + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename + plain_return_type_2< + other_action<comma_action>, plain_A, plain_B + >::type type; + }; + +// subscript action ----------------------------------------------- + + +namespace detail { + // A and B are nonreference types +template <class A, class B> struct subscript_type { + typedef detail::unspecified type; +}; + +template <class A, class B> struct subscript_type<A*, B> { + typedef A& type; +}; +template <class A, class B> struct subscript_type<A* const, B> { + typedef A& type; +}; +template <class A, class B> struct subscript_type<A* volatile, B> { + typedef A& type; +}; +template <class A, class B> struct subscript_type<A* const volatile, B> { + typedef A& type; +}; + + +template<class A, class B, int N> struct subscript_type<A[N], B> { + typedef A& type; +}; + + // these 3 specializations are needed to make gcc <3 happy +template<class A, class B, int N> struct subscript_type<const A[N], B> { + typedef const A& type; +}; +template<class A, class B, int N> struct subscript_type<volatile A[N], B> { + typedef volatile A& type; +}; +template<class A, class B, int N> struct subscript_type<const volatile A[N], B> { + typedef const volatile A& type; +}; + +} // end detail + +template<class A, class B> +struct return_type_2<other_action<subscript_action>, A, B> { + + typedef typename detail::remove_reference_and_cv<A>::type plain_A; + typedef typename detail::remove_reference_and_cv<B>::type plain_B; + + typedef typename boost::remove_reference<A>::type nonref_A; + typedef typename boost::remove_reference<B>::type nonref_B; + + typedef typename + plain_return_type_2< + other_action<subscript_action>, plain_A, plain_B + >::type type1; + + typedef typename + detail::IF_type< + boost::is_same<type1, detail::unspecified>::value, + detail::subscript_type<nonref_A, nonref_B>, + plain_return_type_2<other_action<subscript_action>, plain_A, plain_B> + >::type type; + +}; + +template<class Key, class T, class Cmp, class Allocator, class B> +struct plain_return_type_2<other_action<subscript_action>, std::map<Key, T, Cmp, Allocator>, B> { + typedef T& type; + // T == std::map<Key, T, Cmp, Allocator>::mapped_type; +}; + +template<class Key, class T, class Cmp, class Allocator, class B> +struct plain_return_type_2<other_action<subscript_action>, std::multimap<Key, T, Cmp, Allocator>, B> { + typedef T& type; + // T == std::map<Key, T, Cmp, Allocator>::mapped_type; +}; + + // deque +template<class T, class Allocator, class B> +struct plain_return_type_2<other_action<subscript_action>, std::deque<T, Allocator>, B> { + typedef typename std::deque<T, Allocator>::reference type; +}; +template<class T, class Allocator, class B> +struct plain_return_type_2<other_action<subscript_action>, const std::deque<T, Allocator>, B> { + typedef typename std::deque<T, Allocator>::const_reference type; +}; + + // vector +template<class T, class Allocator, class B> +struct plain_return_type_2<other_action<subscript_action>, std::vector<T, Allocator>, B> { + typedef typename std::vector<T, Allocator>::reference type; +}; +template<class T, class Allocator, class B> +struct plain_return_type_2<other_action<subscript_action>, const std::vector<T, Allocator>, B> { + typedef typename std::vector<T, Allocator>::const_reference type; +}; + + // basic_string +template<class Char, class Traits, class Allocator, class B> +struct plain_return_type_2<other_action<subscript_action>, std::basic_string<Char, Traits, Allocator>, B> { + typedef typename std::basic_string<Char, Traits, Allocator>::reference type; +}; +template<class Char, class Traits, class Allocator, class B> +struct plain_return_type_2<other_action<subscript_action>, const std::basic_string<Char, Traits, Allocator>, B> { + typedef typename std::basic_string<Char, Traits, Allocator>::const_reference type; +}; + +template<class Char, class Traits, class Allocator> +struct plain_return_type_2<arithmetic_action<plus_action>, + std::basic_string<Char, Traits, Allocator>, + std::basic_string<Char, Traits, Allocator> > { + typedef std::basic_string<Char, Traits, Allocator> type; +}; + +template<class Char, class Traits, class Allocator> +struct plain_return_type_2<arithmetic_action<plus_action>, + const Char*, + std::basic_string<Char, Traits, Allocator> > { + typedef std::basic_string<Char, Traits, Allocator> type; +}; + +template<class Char, class Traits, class Allocator> +struct plain_return_type_2<arithmetic_action<plus_action>, + std::basic_string<Char, Traits, Allocator>, + const Char*> { + typedef std::basic_string<Char, Traits, Allocator> type; +}; + +template<class Char, class Traits, class Allocator, std::size_t N> +struct plain_return_type_2<arithmetic_action<plus_action>, + Char[N], + std::basic_string<Char, Traits, Allocator> > { + typedef std::basic_string<Char, Traits, Allocator> type; +}; + +template<class Char, class Traits, class Allocator, std::size_t N> +struct plain_return_type_2<arithmetic_action<plus_action>, + std::basic_string<Char, Traits, Allocator>, + Char[N]> { + typedef std::basic_string<Char, Traits, Allocator> type; +}; + + +} // namespace lambda +} // namespace boost + +#endif + + |