

// Copyright Aleksey Gurtovoy 2000-2004

// Copyright David Abrahams 2003-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/map/map10.hpp" header

// -- DO NOT modify by hand!



namespace boost { namespace mpl {



template<>

struct m_at_impl<0>

{

    template< typename Map > struct result_

    {

        typedef typename Map::item0 type;

    };

};



template<>

struct m_item_impl<1>

{

    template< typename Key, typename T, typename Base > struct result_

        : m_item_< Key,T,Base >

    {

        typedef pair< Key,T > item0;

    };

};



template<

      typename P0

    >

struct map1

    : m_item<

          1

        , typename P0::first

        , typename P0::second

        , map0<  >

        >

{

    typedef map1 type;

};



template<>

struct m_at_impl<1>

{

    template< typename Map > struct result_

    {

        typedef typename Map::item1 type;

    };

};



template<>

struct m_item_impl<2>

{

    template< typename Key, typename T, typename Base > struct result_

        : m_item_< Key,T,Base >

    {

        typedef pair< Key,T > item1;

    };

};



template<

      typename P0, typename P1

    >

struct map2

    : m_item<

          2

        , typename P1::first

        , typename P1::second

        , map1<P0>

        >

{

    typedef map2 type;

};



template<>

struct m_at_impl<2>

{

    template< typename Map > struct result_

    {

        typedef typename Map::item2 type;

    };

};



template<>

struct m_item_impl<3>

{

    template< typename Key, typename T, typename Base > struct result_

        : m_item_< Key,T,Base >

    {

        typedef pair< Key,T > item2;

    };

};



template<

      typename P0, typename P1, typename P2

    >

struct map3

    : m_item<

          3

        , typename P2::first

        , typename P2::second

        , map2< P0,P1 >

        >

{

    typedef map3 type;

};



template<>

struct m_at_impl<3>

{

    template< typename Map > struct result_

    {

        typedef typename Map::item3 type;

    };

};



template<>

struct m_item_impl<4>

{

    template< typename Key, typename T, typename Base > struct result_

        : m_item_< Key,T,Base >

    {

        typedef pair< Key,T > item3;

    };

};



template<

      typename P0, typename P1, typename P2, typename P3

    >

struct map4

    : m_item<

          4

        , typename P3::first

        , typename P3::second

        , map3< P0,P1,P2 >

        >

{

    typedef map4 type;

};



template<>

struct m_at_impl<4>

{

    template< typename Map > struct result_

    {

        typedef typename Map::item4 type;

    };

};



template<>

struct m_item_impl<5>

{

    template< typename Key, typename T, typename Base > struct result_

        : m_item_< Key,T,Base >

    {

        typedef pair< Key,T > item4;

    };

};



template<

      typename P0, typename P1, typename P2, typename P3, typename P4

    >

struct map5

    : m_item<

          5

        , typename P4::first

        , typename P4::second

        , map4< P0,P1,P2,P3 >

        >

{

    typedef map5 type;

};



template<>

struct m_at_impl<5>

{

    template< typename Map > struct result_

    {

        typedef typename Map::item5 type;

    };

};



template<>

struct m_item_impl<6>

{

    template< typename Key, typename T, typename Base > struct result_

        : m_item_< Key,T,Base >

    {

        typedef pair< Key,T > item5;

    };

};



template<

      typename P0, typename P1, typename P2, typename P3, typename P4

    , typename P5

    >

struct map6

    : m_item<

          6

        , typename P5::first

        , typename P5::second

        , map5< P0,P1,P2,P3,P4 >

        >

{

    typedef map6 type;

};



template<>

struct m_at_impl<6>

{

    template< typename Map > struct result_

    {

        typedef typename Map::item6 type;

    };

};



template<>

struct m_item_impl<7>

{

    template< typename Key, typename T, typename Base > struct result_

        : m_item_< Key,T,Base >

    {

        typedef pair< Key,T > item6;

    };

};



template<

      typename P0, typename P1, typename P2, typename P3, typename P4

    , typename P5, typename P6

    >

struct map7

    : m_item<

          7

        , typename P6::first

        , typename P6::second

        , map6< P0,P1,P2,P3,P4,P5 >

        >

{

    typedef map7 type;

};



template<>

struct m_at_impl<7>

{

    template< typename Map > struct result_

    {

        typedef typename Map::item7 type;

    };

};



template<>

struct m_item_impl<8>

{

    template< typename Key, typename T, typename Base > struct result_

        : m_item_< Key,T,Base >

    {

        typedef pair< Key,T > item7;

    };

};



template<

      typename P0, typename P1, typename P2, typename P3, typename P4

    , typename P5, typename P6, typename P7

    >

struct map8

    : m_item<

          8

        , typename P7::first

        , typename P7::second

        , map7< P0,P1,P2,P3,P4,P5,P6 >

        >

{

    typedef map8 type;

};



template<>

struct m_at_impl<8>

{

    template< typename Map > struct result_

    {

        typedef typename Map::item8 type;

    };

};



template<>

struct m_item_impl<9>

{

    template< typename Key, typename T, typename Base > struct result_

        : m_item_< Key,T,Base >

    {

        typedef pair< Key,T > item8;

    };

};



template<

      typename P0, typename P1, typename P2, typename P3, typename P4

    , typename P5, typename P6, typename P7, typename P8

    >

struct map9

    : m_item<

          9

        , typename P8::first

        , typename P8::second

        , map8< P0,P1,P2,P3,P4,P5,P6,P7 >

        >

{

    typedef map9 type;

};



template<>

struct m_at_impl<9>

{

    template< typename Map > struct result_

    {

        typedef typename Map::item9 type;

    };

};



template<>

struct m_item_impl<10>

{

    template< typename Key, typename T, typename Base > struct result_

        : m_item_< Key,T,Base >

    {

        typedef pair< Key,T > item9;

    };

};



template<

      typename P0, typename P1, typename P2, typename P3, typename P4

    , typename P5, typename P6, typename P7, typename P8, typename P9

    >

struct map10

    : m_item<

          10

        , typename P9::first

        , typename P9::second

        , map9< P0,P1,P2,P3,P4,P5,P6,P7,P8 >

        >

{

    typedef map10 type;

};



}}

