123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892 |
- // 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/is_same.hpp"
- #include "boost/type_traits/is_pointer.hpp"
- #include "boost/type_traits/is_float.hpp"
- #include "boost/type_traits/is_convertible.hpp"
- #include "boost/type_traits/remove_pointer.hpp"
- #include "boost/type_traits/remove_const.hpp"
- #include "boost/type_traits/remove_reference.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 {
- 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;
- };
- } // 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
|