boost/mpl/string.hpp
#ifndef BOOST_MPL_STRING_HPP_INCLUDED #define BOOST_MPL_STRING_HPP_INCLUDED // Copyright Eric Niebler 2009 // // 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) // // See http://www.boost.org/libs/mpl for documentation. // $Id: string.hpp 49239 2009-04-01 09:10:26Z eric_niebler $ // $Date: 2009-04-01 02:10:26 -0700 (Wed, 1 Apr 2009) $ // $Revision: 49239 $ // // Thanks to: // Dmitry Goncharov for porting this to the Sun compiler #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #include <boost/predef/other/endian.h> #include <boost/mpl/limits/string.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/char.hpp> #include <boost/mpl/copy.hpp> #include <boost/mpl/size.hpp> #include <boost/mpl/empty.hpp> #include <boost/mpl/assert.hpp> #include <boost/mpl/size_t.hpp> #include <boost/mpl/begin_end.hpp> #include <boost/mpl/joint_view.hpp> #include <boost/mpl/insert_range.hpp> #include <boost/mpl/back_inserter.hpp> #include <boost/mpl/front_inserter.hpp> #include <boost/mpl/iterator_range.hpp> #include <boost/preprocessor/arithmetic/dec.hpp> #include <boost/preprocessor/arithmetic/add.hpp> #include <boost/preprocessor/arithmetic/div.hpp> #include <boost/preprocessor/punctuation/comma_if.hpp> #include <boost/preprocessor/repetition/repeat.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> #include <iterator> // for bidirectional_iterator_tag #include <climits> namespace boost { namespace mpl { #define BOOST_MPL_STRING_MAX_PARAMS \ BOOST_PP_DIV(BOOST_PP_ADD(BOOST_MPL_LIMIT_STRING_SIZE, 3), 4) // Low-level bit-twiddling is done by macros. Any implementation-defined behavior of // multi-character literals should be localized to these macros. #define BOOST_MPL_MULTICHAR_LENGTH(c) \ (std::size_t)((c<CHAR_MIN) ? 4 : ((c>0xffffff)+(c>0xffff)+(c>0xff)+1)) #if BOOST_ENDIAN_LITTLE_BYTE && defined(__SUNPRO_CC) #define BOOST_MPL_MULTICHAR_AT(c,i) \ (char)(0xff&((unsigned)(c)>>(8*(std::size_t)(i)))) #define BOOST_MPL_MULTICHAR_PUSH_BACK(c,i) \ ((((unsigned char)(i))<<(BOOST_MPL_MULTICHAR_LENGTH(c)*8))|(unsigned)(c)) #define BOOST_MPL_MULTICHAR_PUSH_FRONT(c,i) \ (((unsigned)(c)<<8)|(unsigned char)(i)) #define BOOST_MPL_MULTICHAR_POP_BACK(c) \ (((1<<((BOOST_MPL_MULTICHAR_LENGTH(c)-1)*8))-1)&(unsigned)(c)) #define BOOST_MPL_MULTICHAR_POP_FRONT(c) \ ((unsigned)(c)>>8) #else #define BOOST_MPL_MULTICHAR_AT(c,i) \ (char)(0xff&((unsigned)(c)>>(8*(BOOST_MPL_MULTICHAR_LENGTH(c)-(std::size_t)(i)-1)))) #define BOOST_MPL_MULTICHAR_PUSH_BACK(c,i) \ (((unsigned)(c)<<8)|(unsigned char)(i)) #define BOOST_MPL_MULTICHAR_PUSH_FRONT(c,i) \ ((((unsigned char)(i))<<(BOOST_MPL_MULTICHAR_LENGTH(c)*8))|(unsigned)(c)) #define BOOST_MPL_MULTICHAR_POP_BACK(c) \ ((unsigned)(c)>>8) #define BOOST_MPL_MULTICHAR_POP_FRONT(c) \ (((1<<((BOOST_MPL_MULTICHAR_LENGTH(c)-1)*8))-1)&(unsigned)(c)) #endif struct string_tag; struct string_iterator_tag; template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_MPL_STRING_MAX_PARAMS, int C, 0)> struct string; template<typename Sequence, int I, int J> struct string_iterator; template<typename Sequence> struct sequence_tag; template<typename Tag> struct size_impl; template<> struct size_impl<mpl::string_tag> { template<typename Sequence> struct apply; #define M0(z, n, data) \ + BOOST_MPL_MULTICHAR_LENGTH(BOOST_PP_CAT(C,n)) #define M1(z, n, data) \ template<BOOST_PP_ENUM_PARAMS_Z(z, n, int C)> \ struct apply<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)> > \ : mpl::size_t<(0 BOOST_PP_REPEAT_ ## z(n, M0, ~))> \ {}; BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_MPL_STRING_MAX_PARAMS), M1, ~) #undef M0 #undef M1 }; template<> struct size_impl<mpl::string_tag>::apply<mpl::string<> > : mpl::size_t<0> {}; template<typename Tag> struct begin_impl; template<> struct begin_impl<mpl::string_tag> { template<typename Sequence> struct apply { typedef mpl::string_iterator<Sequence, 0, 0> type; }; }; template<typename Tag> struct end_impl; template<> struct end_impl<mpl::string_tag> { template<typename Sequence> struct apply; #define M0(z,n,data) \ template<BOOST_PP_ENUM_PARAMS_Z(z, n, int C)> \ struct apply<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)> > \ { \ typedef mpl::string_iterator<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)>, n, 0> type; \ }; BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_MPL_STRING_MAX_PARAMS), M0, ~) #undef M0 }; template<> struct end_impl<mpl::string_tag>::apply<mpl::string<> > { typedef mpl::string_iterator<mpl::string<>, 0, 0> type; }; template<typename Tag> struct push_back_impl; template<> struct push_back_impl<mpl::string_tag> { template<typename Sequence, typename Value, bool B = (4==BOOST_MPL_MULTICHAR_LENGTH(Sequence::back_))> struct apply { BOOST_MPL_ASSERT_MSG( (BOOST_MPL_LIMIT_STRING_SIZE != mpl::size<Sequence>::type::value) , PUSH_BACK_FAILED_MPL_STRING_IS_FULL , (Sequence) ); // If the above assertion didn't fire, then the string is sparse. // Repack the string and retry the push_back typedef typename mpl::push_back< typename mpl::copy< Sequence , mpl::back_inserter<mpl::string<> > >::type , Value >::type type; }; template<typename Value> struct apply<mpl::string<>, Value, false> { typedef mpl::string<(char)Value::value> type; }; #define M0(z,n,data) \ template<BOOST_PP_ENUM_PARAMS_Z(z, n, int C), typename Value> \ struct apply<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)>, Value, false> \ { \ typedef \ mpl::string< \ BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_DEC(n), C) \ BOOST_PP_COMMA_IF(BOOST_PP_DEC(n)) \ ((unsigned)BOOST_PP_CAT(C,BOOST_PP_DEC(n))>0xffffff) \ ?BOOST_PP_CAT(C,BOOST_PP_DEC(n)) \ :BOOST_MPL_MULTICHAR_PUSH_BACK(BOOST_PP_CAT(C,BOOST_PP_DEC(n)), Value::value) \ , ((unsigned)BOOST_PP_CAT(C,BOOST_PP_DEC(n))>0xffffff) \ ?(char)Value::value \ :0 \ > \ type; \ }; BOOST_PP_REPEAT_FROM_TO(1, BOOST_MPL_STRING_MAX_PARAMS, M0, ~) #undef M0 template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, int C), typename Value> struct apply<mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>, Value, false> { typedef mpl::string< BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(BOOST_MPL_STRING_MAX_PARAMS), C) , BOOST_MPL_MULTICHAR_PUSH_BACK(BOOST_PP_CAT(C,BOOST_PP_DEC(BOOST_MPL_STRING_MAX_PARAMS)), Value::value) > type; }; }; template<typename Tag> struct has_push_back_impl; template<> struct has_push_back_impl<mpl::string_tag> { template<typename Sequence> struct apply : mpl::true_ {}; }; template<typename Tag> struct pop_back_impl; template<> struct pop_back_impl<mpl::string_tag> { template<typename Sequence> struct apply; #define M0(z,n,data) \ template<BOOST_PP_ENUM_PARAMS_Z(z, n, int C)> \ struct apply<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)> > \ { \ BOOST_MPL_ASSERT_MSG((C0 != 0), POP_BACK_FAILED_MPL_STRING_IS_EMPTY, (mpl::string<>)); \ typedef \ mpl::string< \ BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_DEC(n), C) \ BOOST_PP_COMMA_IF(BOOST_PP_DEC(n)) \ BOOST_MPL_MULTICHAR_POP_BACK(BOOST_PP_CAT(C,BOOST_PP_DEC(n))) \ > \ type; \ }; BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_MPL_STRING_MAX_PARAMS), M0, ~) #undef M0 }; template<typename Tag> struct has_pop_back_impl; template<> struct has_pop_back_impl<mpl::string_tag> { template<typename Sequence> struct apply : mpl::true_ {}; }; template<typename Tag> struct push_front_impl; template<> struct push_front_impl<mpl::string_tag> { template<typename Sequence, typename Value, bool B = (4==BOOST_MPL_MULTICHAR_LENGTH(Sequence::front_))> struct apply { BOOST_MPL_ASSERT_MSG( (BOOST_MPL_LIMIT_STRING_SIZE != mpl::size<Sequence>::type::value) , PUSH_FRONT_FAILED_MPL_STRING_IS_FULL , (Sequence) ); // If the above assertion didn't fire, then the string is sparse. // Repack the string and retry the push_front. typedef typename mpl::push_front< typename mpl::reverse_copy< Sequence , mpl::front_inserter<string<> > >::type , Value >::type type; }; #if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590)) template<typename Value> struct apply<mpl::string<>, Value, false> { typedef mpl::string<(char)Value::value> type; }; #endif #define M0(z,n,data) \ template<BOOST_PP_ENUM_PARAMS_Z(z, n, int C), typename Value> \ struct apply<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)>, Value, true> \ { \ typedef \ mpl::string< \ (char)Value::value \ BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, C) \ > \ type; \ }; BOOST_PP_REPEAT_FROM_TO(1, BOOST_MPL_STRING_MAX_PARAMS, M0, ~) #undef M0 template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, int C), typename Value> struct apply<mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>, Value, false> { typedef mpl::string< BOOST_MPL_MULTICHAR_PUSH_FRONT(C0, Value::value) , BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C) > type0; #if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590)) typedef typename mpl::if_< mpl::empty<mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)> > , mpl::string<(char)Value::value> , type0 >::type type; #else typedef type0 type; #endif }; }; template<typename Tag> struct has_push_front_impl; template<> struct has_push_front_impl<mpl::string_tag> { template<typename Sequence> struct apply : mpl::true_ {}; }; template<typename Tag> struct pop_front_impl; template<> struct pop_front_impl<mpl::string_tag> { template<typename Sequence, bool B = (1==BOOST_MPL_MULTICHAR_LENGTH(Sequence::front_))> struct apply; #define M0(z,n,data) \ template<BOOST_PP_ENUM_PARAMS_Z(z, n, int C)> \ struct apply<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)>, true> \ { \ BOOST_MPL_ASSERT_MSG((C0 != 0), POP_FRONT_FAILED_MPL_STRING_IS_EMPTY, (mpl::string<>)); \ typedef \ mpl::string<BOOST_PP_ENUM_SHIFTED_PARAMS_Z(z, n, C)> \ type; \ }; BOOST_PP_REPEAT_FROM_TO(1, BOOST_MPL_STRING_MAX_PARAMS, M0, ~) #undef M0 template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, int C)> struct apply<mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>, false> { typedef mpl::string< BOOST_MPL_MULTICHAR_POP_FRONT(C0) , BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C) > type; }; }; template<typename Tag> struct has_pop_front_impl; template<> struct has_pop_front_impl<mpl::string_tag> { template<typename Sequence> struct apply : mpl::true_ {}; }; template<typename Tag> struct insert_range_impl; template<> struct insert_range_impl<mpl::string_tag> { template<typename Sequence, typename Pos, typename Range> struct apply : mpl::copy< mpl::joint_view< mpl::iterator_range< mpl::string_iterator<Sequence, 0, 0> , Pos > , mpl::joint_view< Range , mpl::iterator_range< Pos , typename mpl::end<Sequence>::type > > > , mpl::back_inserter<mpl::string<> > > {}; }; template<typename Tag> struct insert_impl; template<> struct insert_impl<mpl::string_tag> { template<typename Sequence, typename Pos, typename Value> struct apply : mpl::insert_range<Sequence, Pos, mpl::string<(char)Value::value> > {}; }; template<typename Tag> struct erase_impl; template<> struct erase_impl<mpl::string_tag> { template<typename Sequence, typename First, typename Last> struct apply : mpl::copy< mpl::joint_view< mpl::iterator_range< mpl::string_iterator<Sequence, 0, 0> , First > , mpl::iterator_range< typename mpl::if_na<Last, typename mpl::next<First>::type>::type , typename mpl::end<Sequence>::type > > , mpl::back_inserter<mpl::string<> > > {}; }; template<typename Tag> struct clear_impl; template<> struct clear_impl<mpl::string_tag> { template<typename> struct apply { typedef mpl::string<> type; }; }; #define M0(z, n, data) \ template<BOOST_PP_ENUM_PARAMS_Z(z, BOOST_MPL_STRING_MAX_PARAMS, int C), int J> \ struct string_iterator<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, BOOST_MPL_STRING_MAX_PARAMS, C)>, n, J> \ { \ enum { eomc_ = (BOOST_MPL_MULTICHAR_LENGTH(BOOST_PP_CAT(C, n)) == J + 1) }; \ typedef mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, BOOST_MPL_STRING_MAX_PARAMS, C)> string; \ typedef std::bidirectional_iterator_tag category; \ typedef \ mpl::string_iterator<string, n + eomc_, eomc_ ? 0 : J + 1> \ next; \ typedef \ mpl::string_iterator<string, n, J - 1> \ prior; \ typedef mpl::char_<BOOST_MPL_MULTICHAR_AT(BOOST_PP_CAT(C, n), J)> type; \ }; \ template<BOOST_PP_ENUM_PARAMS_Z(z, BOOST_MPL_STRING_MAX_PARAMS, int C)> \ struct string_iterator<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, BOOST_MPL_STRING_MAX_PARAMS, C)>, n, 0> \ { \ enum { eomc_ = (BOOST_MPL_MULTICHAR_LENGTH(BOOST_PP_CAT(C, n)) == 1) }; \ typedef mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, BOOST_MPL_STRING_MAX_PARAMS, C)> string; \ typedef std::bidirectional_iterator_tag category; \ typedef \ mpl::string_iterator<string, n + eomc_, !eomc_> \ next; \ typedef \ mpl::string_iterator< \ string \ , n - 1 \ , BOOST_MPL_MULTICHAR_LENGTH(BOOST_PP_CAT(C, BOOST_PP_DEC(n))) - 1 \ > \ prior; \ typedef mpl::char_<BOOST_MPL_MULTICHAR_AT(BOOST_PP_CAT(C, n), 0)> type; \ }; BOOST_PP_REPEAT(BOOST_MPL_STRING_MAX_PARAMS, M0, ~) #undef M0 template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, int C)> struct string { /// INTERNAL ONLY enum { front_ = C0 , back_ = BOOST_PP_CAT(C, BOOST_PP_DEC(BOOST_MPL_STRING_MAX_PARAMS)) }; typedef char value_type; typedef string type; typedef string_tag tag; }; namespace aux_ { template<typename It, typename End> struct next_unless : mpl::next<It> {}; template<typename End> struct next_unless<End, End> { typedef End type; }; template<typename It, typename End> struct deref_unless : mpl::deref<It> {}; template<typename End> struct deref_unless<End, End> { typedef mpl::char_<'\0'> type; }; } template<typename Sequence> struct c_str { typedef typename mpl::end<Sequence>::type iend; typedef typename mpl::begin<Sequence>::type i0; #define M0(z, n, data) \ typedef \ typename mpl::aux_::next_unless<BOOST_PP_CAT(i, n), iend>::type \ BOOST_PP_CAT(i, BOOST_PP_INC(n)); BOOST_PP_REPEAT(BOOST_MPL_LIMIT_STRING_SIZE, M0, ~) #undef M0 typedef c_str type; static typename Sequence::value_type const value[BOOST_MPL_LIMIT_STRING_SIZE+1]; }; template<typename Sequence> typename Sequence::value_type const c_str<Sequence>::value[BOOST_MPL_LIMIT_STRING_SIZE+1] = { #define M0(z, n, data) \ mpl::aux_::deref_unless<BOOST_PP_CAT(i, n), iend>::type::value, BOOST_PP_REPEAT(BOOST_MPL_LIMIT_STRING_SIZE, M0, ~) #undef M0 '\0' }; }} // namespace boost #endif // BOOST_MPL_STRING_HPP_INCLUDED