#ifndef boost_mpl_string_h_included
#define boost_mpl_string_h_included
///////////////////////////////////////////////////////////////////////////////
//
//  Copyright 2008 Eric Niebler. 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)

#include <string>
#include <cstring>
#include <iostream>
#include <boost/mpl/at.hpp>
#include <boost/mpl/long.hpp>
#include <boost/mpl/back.hpp>
#include <boost/mpl/copy.hpp>
#include <boost/mpl/size.hpp>
#include <boost/mpl/empty.hpp>
#include <boost/mpl/front.hpp>
#include <boost/mpl/clear.hpp>
#include <boost/mpl/erase.hpp>
#include <boost/mpl/insert.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/mpl/size_t.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/vector_c.hpp>
#include <boost/mpl/push_back.hpp>
#include <boost/mpl/joint_view.hpp>
#include <boost/mpl/insert_range.hpp>
#include <boost/mpl/back_inserter.hpp>
#include <boost/mpl/iterator_range.hpp>
#include <boost/preprocessor/arithmetic/dec.hpp>
#include <boost/preprocessor/arithmetic/div.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>

// Define mpl::char_
#include <boost/mpl/aux_/adl_barrier.hpp>
#include <boost/mpl/aux_/nttp_decl.hpp>
BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN
template< BOOST_MPL_AUX_NTTP_DECL(char, N) > struct char_;
BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE
BOOST_MPL_AUX_ADL_BARRIER_DECL(char_)
#define AUX_WRAPPER_VALUE_TYPE char
#include <boost/mpl/aux_/integral_wrapper.hpp>

#include <boost/detail/lightweight_test.hpp>

namespace boost { namespace mpl
{
    //#define BOOST_MPL_STRING_MAX_LENGTH 128
    #define BOOST_MPL_STRING_MAX_LENGTH 32
    #define BOOST_MPL_STRING_MAX_PARAMS BOOST_PP_DIV(BOOST_MPL_STRING_MAX_LENGTH, 4)

    #define BOOST_MPL_MULTICHAR_LENGTH(c)   ((std::size_t)((c>0xffffff)+(c>0xffff)+(c>0xff)+1))
    #define BOOST_MPL_MULTICHAR_AT(c,i)     (char)((c)>>(8*(BOOST_MPL_MULTICHAR_LENGTH(c)-((std::size_t)(i))-1)))

    struct string_tag;
    struct string_iterator_tag;

    template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_MPL_STRING_MAX_PARAMS, unsigned int C, 0)>
    struct string;

    template<typename Sequence, long N>
    struct string_iterator;

    template<typename Sequence>
    struct sequence_tag;

    template<typename Tag>
    struct size_impl;

    template<>
    struct size_impl<string_tag>
    {
        template<typename Sequence>
        struct apply
          : mpl::size_t<Sequence::size>
        {};
    };

    template<typename Tag>
    struct at_impl;

    template<>
    struct at_impl<string_tag>
    {
        template<typename Sequence, typename N>
        struct apply
          : Sequence::template at<N::value>
        {};
    };

    template<typename Tag>
    struct begin_impl;

    template<>
    struct begin_impl<string_tag>
    {
        template<typename Sequence>
        struct apply
        {
            typedef string_iterator<Sequence, 0> type;
        };
    };

    template<typename Tag>
    struct end_impl;

    template<>
    struct end_impl<string_tag>
    {
        template<typename Sequence>
        struct apply
        {
            typedef string_iterator<Sequence, Sequence::size> type;
        };
    };

    template<typename Tag>
    struct push_back_impl;

    template<>
    struct push_back_impl<string_tag>
    {
        template<typename Sequence, typename Value>
        struct apply;

        template<typename Value>
        struct apply<string<>, Value>
        {
            typedef string<(char)Value::value> type;
        };

        #define M0(z,n,data)                                                                        \
        template<BOOST_PP_ENUM_PARAMS_Z(z, n, unsigned int C), typename Value>                      \
        struct apply<string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)>, Value>                                \
        {                                                                                           \
            typedef string<                                                                         \
                BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_DEC(n), C)                                       \
                BOOST_PP_COMMA_IF(BOOST_PP_DEC(n))                                                  \
                (BOOST_PP_CAT(C,BOOST_PP_DEC(n))>0xffffff)                                          \
                ?BOOST_PP_CAT(C,BOOST_PP_DEC(n))                                                    \
                :(BOOST_PP_CAT(C,BOOST_PP_DEC(n))<<8)|(unsigned char)Value::value                   \
              , (BOOST_PP_CAT(C,BOOST_PP_DEC(n))>0xffffff)                                          \
                ?(char)Value::value                                                                 \
                :0                                                                                  \
            > type;                                                                                 \
        };

        BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_DEC(BOOST_MPL_STRING_MAX_PARAMS), M0, ~)
        #undef M0

        template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, unsigned int C), typename Value>
        struct apply<string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>, Value>
        {
            BOOST_MPL_ASSERT_RELATION(BOOST_PP_CAT(C,BOOST_PP_DEC(BOOST_MPL_STRING_MAX_PARAMS)), <=, 0xffffff);
            typedef string<
                BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(BOOST_MPL_STRING_MAX_PARAMS), C)
              , (BOOST_PP_CAT(C,BOOST_PP_DEC(BOOST_MPL_STRING_MAX_PARAMS))<<8)|(unsigned char)Value::value
            > type;
        };
    };

    template<typename Tag>
    struct push_front_impl;

    template<>
    struct push_front_impl<string_tag>
    {
        template<typename Sequence, typename Value, std::size_t N = BOOST_MPL_MULTICHAR_LENGTH(Sequence::head_)>
        struct apply;

        template<typename Value>
        struct apply<string<>, Value, 1>
        {
            typedef string<(char)Value::value> type;
        };

        #define M0(z,n,data)                                                                        \
        template<BOOST_PP_ENUM_PARAMS_Z(z, n, unsigned int C), typename Value, std::size_t N>       \
        struct apply<string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)>, Value, N>                             \
        {                                                                                           \
            typedef string<                                                                         \
                ((((unsigned char)Value::value)<<(N*8))|C0)                                         \
                BOOST_PP_COMMA_IF(BOOST_PP_DEC(n))                                                  \
                BOOST_PP_ENUM_SHIFTED_PARAMS_Z(z, n, C)                                             \
            > type;                                                                                 \
        };                                                                                          \
        template<BOOST_PP_ENUM_PARAMS_Z(z, n, unsigned int C), typename Value>                      \
        struct apply<string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)>, Value, 4>                             \
        {                                                                                           \
            typedef string<                                                                         \
                (char)Value::value                                                                  \
                BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, C)                                            \
            > type;                                                                                 \
        };

        BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_DEC(BOOST_MPL_STRING_MAX_PARAMS), M0, ~)
        #undef M0

        template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, unsigned int C), typename Value, std::size_t N>
        struct apply<string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>, Value, N>
        {
            BOOST_MPL_ASSERT_RELATION(C0, <=, 0xffffff);
            typedef string<
                (((unsigned char)Value::value)<<(N*8))|C0
              , BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)
            > type;
        };
    };

    template<typename Tag>
    struct insert_range_impl;

    template<>
    struct insert_range_impl<string_tag>
    {
        template<typename Sequence, typename Pos, typename Range>
        struct apply
          : copy<
                joint_view<
                    iterator_range<
                        string_iterator<Sequence, 0>
                      , Pos
                    >
                  , joint_view<
                        Range
                      , iterator_range<
                            Pos
                          , string_iterator<Sequence, Sequence::size>
                        >
                    >
                >
              , back_inserter<string<> >
            >
        {};
    };

    template<typename Tag>
    struct insert_impl;

    template<>
    struct insert_impl<string_tag>
    {
        template<typename Sequence, typename Pos, typename Value>
        struct apply
          : insert_range<Sequence, Pos, string<(char)Value::value> >
        {};
    };

    template<typename Tag>
    struct erase_impl;

    template<>
    struct erase_impl<string_tag>
    {
        template<typename Sequence, typename First, typename Last>
        struct apply
          : copy<
                joint_view<
                    iterator_range<
                        string_iterator<Sequence, 0>
                      , First
                    >
                  , iterator_range<
                        typename if_na<Last, typename next<First>::type>::type
                      , string_iterator<Sequence, Sequence::size>
                    >
                >
              , back_inserter<string<> >
            >
        {};
    };

    template<typename Tag>
    struct clear_impl;

    template<>
    struct clear_impl<string_tag>
    {
        template<typename>
        struct apply
        {
            typedef string<> type;
        };
    };

    template<typename Tag>
    struct advance_impl;

    template<>
    struct advance_impl<string_iterator_tag>
    {
        template<typename Iterator, typename N>
        struct apply
        {
            typedef string_iterator<
                typename Iterator::string_type
              , Iterator::index + N::value
            > type;
        };
    };

    template<typename Tag>
    struct distance_impl;

    template<>
    struct distance_impl<string_iterator_tag>
    {
        template<typename First, typename Last>
        struct apply
        {
            typedef mpl::long_<Last::index - First::index> type;
        };
    };

    template<typename Sequence, long N>
    struct string_iterator
      : Sequence::template at<N>
    {
        typedef string_iterator_tag tag;
        typedef std::random_access_iterator_tag category;
        typedef Sequence string_type;
        static long const index = N;
        typedef string_iterator<Sequence, N+1> next;
        typedef string_iterator<Sequence, N-1> prior;
    };

    template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, unsigned int C)>
    struct string
    {
        /// INTERNAL ONLY
        static unsigned int const head_ = C0;
        /// INTERNAL ONLY
        typedef string<BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)> tail_;

        typedef string_tag tag;

        static std::size_t const size = BOOST_MPL_MULTICHAR_LENGTH(C0) + tail_::size;

        template<long Pos, bool B = (Pos < BOOST_MPL_MULTICHAR_LENGTH(C0))>
        struct at
          : boost::mpl::char_<BOOST_MPL_MULTICHAR_AT(C0,Pos)>
        {};

        template<long Pos>
        struct at<Pos, false>
          : tail_::template at<Pos-BOOST_MPL_MULTICHAR_LENGTH(C0)>
        {};

        static char const c_str[];
    };

    template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, unsigned int C)>
    char const string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>::c_str[] =
    {
    #define M0(z, n, data) at<n>::value
        BOOST_PP_ENUM(BOOST_MPL_STRING_MAX_LENGTH, M0, ~)
    #undef M0
      , '\0' // to ensure the string is null-terminated
    };

    template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, unsigned int C)>
    std::size_t const string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>::size;

    template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, unsigned int C)>
    unsigned int const string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>::head_;

    template<>
    struct string<>
    {
        /// INTERNAL ONLY
        static unsigned int const head_ = 0;
        /// INTERNAL ONLY
        typedef string tail_;

        typedef string_tag tag;

        static std::size_t const size = 0;

        template<unsigned int>
        struct at
          : boost::mpl::char_<'\0'>
        {};

        static char const c_str[];
    };

    char const string<>::c_str[] = {'\0'};
    std::size_t const string<>::size;
    unsigned int const string<>::head_;

}} // namespace boost
#endif // !boost_mpl_string_h_included