// Copyright Aleksey Gurtovoy 2001-2004

//

// 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)

//

// Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header

// -- DO NOT modify by hand!

namespace boost { namespace mpl {

namespace aux {

template<

      bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false

    , bool C5 = false

    >

struct lambda_or

    : true_

{

};

template<>

struct lambda_or< false,false,false,false,false >

    : false_

{

};

} // namespace aux

template<

      typename T

    , typename Tag

    >

struct lambda

{

    typedef false_ is_le;

    typedef T result_;

    typedef T type;

};

template<

      typename T

    >

struct is_lambda_expression

    : lambda<T>::is_le

{

};

template< int N, typename Tag >

struct lambda< arg<N>, Tag >

{

    typedef true_ is_le;

    typedef mpl::arg<N> result_; // qualified for the sake of MIPSpro 7.41

    typedef mpl::protect<result_> type;

};

template<

      typename F

    , typename Tag

    >

struct lambda<

          bind0<F>

        , Tag

        >

{

    typedef false_ is_le;

    typedef bind0<

          F

        > result_;

    typedef result_ type;

};

namespace aux {

template<

      typename IsLE, typename Tag

    , template< typename P1 > class F

    , typename L1

    >

struct le_result1

{

    typedef F<

          typename L1::type

        > result_;

    typedef result_ type;

};

template<

      typename Tag

    , template< typename P1 > class F

    , typename L1

    >

struct le_result1< true_,Tag,F,L1 >

{

    typedef bind1<

          quote1< F,Tag >

        , typename L1::result_

        > result_;

    typedef mpl::protect<result_> type;

};

} // namespace aux

template<

      template< typename P1 > class F

    , typename T1

    , typename Tag

    >

struct lambda<

          F<T1>

        , Tag

        >

{

    typedef lambda< T1,Tag > l1;

    typedef typename l1::is_le is_le1;

    typedef typename aux::lambda_or<

          is_le1::value

        >::type is_le;

    typedef aux::le_result1<

          is_le, Tag, F, l1

        > le_result_;

    typedef typename le_result_::result_ result_;

    typedef typename le_result_::type type;

};

template<

      typename F, typename T1

    , typename Tag

    >

struct lambda<

          bind1< F,T1 >

        , Tag

        >

{

    typedef false_ is_le;

    typedef bind1<

          F

        , T1

        > result_;

    typedef result_ type;

};

namespace aux {

template<

      typename IsLE, typename Tag

    , template< typename P1, typename P2 > class F

    , typename L1, typename L2

    >

struct le_result2

{

    typedef F<

          typename L1::type, typename L2::type

        > result_;

    typedef result_ type;

};

template<

      typename Tag

    , template< typename P1, typename P2 > class F

    , typename L1, typename L2

    >

struct le_result2< true_,Tag,F,L1,L2 >

{

    typedef bind2<

          quote2< F,Tag >

        , typename L1::result_, typename L2::result_

        > result_;

    typedef mpl::protect<result_> type;

};

} // namespace aux

template<

      template< typename P1, typename P2 > class F

    , typename T1, typename T2

    , typename Tag

    >

struct lambda<

          F< T1,T2 >

        , Tag

        >

{

    typedef lambda< T1,Tag > l1;

    typedef lambda< T2,Tag > l2;

    typedef typename l1::is_le is_le1;

    typedef typename l2::is_le is_le2;

    typedef typename aux::lambda_or<

          is_le1::value, is_le2::value

        >::type is_le;

    typedef aux::le_result2<

          is_le, Tag, F, l1, l2

        > le_result_;

    typedef typename le_result_::result_ result_;

    typedef typename le_result_::type type;

};

template<

      typename F, typename T1, typename T2

    , typename Tag

    >

struct lambda<

          bind2< F,T1,T2 >

        , Tag

        >

{

    typedef false_ is_le;

    typedef bind2<

          F

        , T1, T2

        > result_;

    typedef result_ type;

};

namespace aux {

template<

      typename IsLE, typename Tag

    , template< typename P1, typename P2, typename P3 > class F

    , typename L1, typename L2, typename L3

    >

struct le_result3

{

    typedef F<

          typename L1::type, typename L2::type, typename L3::type

        > result_;

    typedef result_ type;

};

template<

      typename Tag

    , template< typename P1, typename P2, typename P3 > class F

    , typename L1, typename L2, typename L3

    >

struct le_result3< true_,Tag,F,L1,L2,L3 >

{

    typedef bind3<

          quote3< F,Tag >

        , typename L1::result_, typename L2::result_, typename L3::result_

        > result_;

    typedef mpl::protect<result_> type;

};

} // namespace aux

template<

      template< typename P1, typename P2, typename P3 > class F

    , typename T1, typename T2, typename T3

    , typename Tag

    >

struct lambda<

          F< T1,T2,T3 >

        , Tag

        >

{

    typedef lambda< T1,Tag > l1;

    typedef lambda< T2,Tag > l2;

    typedef lambda< T3,Tag > l3;

    typedef typename l1::is_le is_le1;

    typedef typename l2::is_le is_le2;

    typedef typename l3::is_le is_le3;

    typedef typename aux::lambda_or<

          is_le1::value, is_le2::value, is_le3::value

        >::type is_le;

    typedef aux::le_result3<

          is_le, Tag, F, l1, l2, l3

        > le_result_;

    typedef typename le_result_::result_ result_;

    typedef typename le_result_::type type;

};

template<

      typename F, typename T1, typename T2, typename T3

    , typename Tag

    >

struct lambda<

          bind3< F,T1,T2,T3 >

        , Tag

        >

{

    typedef false_ is_le;

    typedef bind3<

          F

        , T1, T2, T3

        > result_;

    typedef result_ type;

};

namespace aux {

template<

      typename IsLE, typename Tag

    , template< typename P1, typename P2, typename P3, typename P4 > class F

    , typename L1, typename L2, typename L3, typename L4

    >

struct le_result4

{

    typedef F<

          typename L1::type, typename L2::type, typename L3::type

        , typename L4::type

        > result_;

    typedef result_ type;

};

template<

      typename Tag

    , template< typename P1, typename P2, typename P3, typename P4 > class F

    , typename L1, typename L2, typename L3, typename L4

    >

struct le_result4< true_,Tag,F,L1,L2,L3,L4 >

{

    typedef bind4<

          quote4< F,Tag >

        , typename L1::result_, typename L2::result_, typename L3::result_

        , typename L4::result_

        > result_;

    typedef mpl::protect<result_> type;

};

} // namespace aux

template<

      template< typename P1, typename P2, typename P3, typename P4 > class F

    , typename T1, typename T2, typename T3, typename T4

    , typename Tag

    >

struct lambda<

          F< T1,T2,T3,T4 >

        , Tag

        >

{

    typedef lambda< T1,Tag > l1;

    typedef lambda< T2,Tag > l2;

    typedef lambda< T3,Tag > l3;

    typedef lambda< T4,Tag > l4;

    typedef typename l1::is_le is_le1;

    typedef typename l2::is_le is_le2;

    typedef typename l3::is_le is_le3;

    typedef typename l4::is_le is_le4;

    typedef typename aux::lambda_or<

          is_le1::value, is_le2::value, is_le3::value, is_le4::value

        >::type is_le;

    typedef aux::le_result4<

          is_le, Tag, F, l1, l2, l3, l4

        > le_result_;

    typedef typename le_result_::result_ result_;

    typedef typename le_result_::type type;

};

template<

      typename F, typename T1, typename T2, typename T3, typename T4

    , typename Tag

    >

struct lambda<

          bind4< F,T1,T2,T3,T4 >

        , Tag

        >

{

    typedef false_ is_le;

    typedef bind4<

          F

        , T1, T2, T3, T4

        > result_;

    typedef result_ type;

};

namespace aux {

template<

      typename IsLE, typename Tag

    , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F

    , typename L1, typename L2, typename L3, typename L4, typename L5

    >

struct le_result5

{

    typedef F<

          typename L1::type, typename L2::type, typename L3::type

        , typename L4::type, typename L5::type

        > result_;

    typedef result_ type;

};

template<

      typename Tag

    , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F

    , typename L1, typename L2, typename L3, typename L4, typename L5

    >

struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 >

{

    typedef bind5<

          quote5< F,Tag >

        , typename L1::result_, typename L2::result_, typename L3::result_

        , typename L4::result_, typename L5::result_

        > result_;

    typedef mpl::protect<result_> type;

};

} // namespace aux

template<

      template<

          typename P1, typename P2, typename P3, typename P4

        , typename P5

        >

      class F

    , typename T1, typename T2, typename T3, typename T4, typename T5

    , typename Tag

    >

struct lambda<

          F< T1,T2,T3,T4,T5 >

        , Tag

        >

{

    typedef lambda< T1,Tag > l1;

    typedef lambda< T2,Tag > l2;

    typedef lambda< T3,Tag > l3;

    typedef lambda< T4,Tag > l4;

    typedef lambda< T5,Tag > l5;

    typedef typename l1::is_le is_le1;

    typedef typename l2::is_le is_le2;

    typedef typename l3::is_le is_le3;

    typedef typename l4::is_le is_le4;

    typedef typename l5::is_le is_le5;

    typedef typename aux::lambda_or<

          is_le1::value, is_le2::value, is_le3::value, is_le4::value

        , is_le5::value

        >::type is_le;

    typedef aux::le_result5<

          is_le, Tag, F, l1, l2, l3, l4, l5

        > le_result_;

    typedef typename le_result_::result_ result_;

    typedef typename le_result_::type type;

};

template<

      typename F, typename T1, typename T2, typename T3, typename T4

    , typename T5

    , typename Tag

    >

struct lambda<

          bind5< F,T1,T2,T3,T4,T5 >

        , Tag

        >

{

    typedef false_ is_le;

    typedef bind5<

          F

        , T1, T2, T3, T4, T5

        > result_;

    typedef result_ type;

};

/// special case for 'protect'

template< typename T, typename Tag >

struct lambda< mpl::protect<T>, Tag >

{

    typedef false_ is_le;

    typedef mpl::protect<T> result_;

    typedef result_ type;

};

/// specializations for the main 'bind' form

template<

      typename F, typename T1, typename T2, typename T3, typename T4

    , typename T5

    , typename Tag

    >

struct lambda<

          bind< F,T1,T2,T3,T4,T5 >

        , Tag

        >

{

    typedef false_ is_le;

    typedef bind< F,T1,T2,T3,T4,T5 > result_;

    typedef result_ type;

};

/// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars

template<

      typename F, typename Tag1, typename Tag2

    >

struct lambda<

          lambda< F,Tag1 >

        , Tag2

        >

{

    typedef lambda< F,Tag2 > l1;

    typedef lambda< Tag1,Tag2 > l2;

    typedef typename l1::is_le is_le;

    typedef aux::le_result2<is_le, Tag2, mpl::lambda, l1, l2> le_result_;

    typedef typename le_result_::result_ result_;

    typedef typename le_result_::type type;

};

BOOST_MPL_AUX_NA_SPEC(2, lambda)

}}