Subject: [Boost-commit] svn:boost r53838 - in branches/release: . boost/mpl boost/mpl/limits libs/mpl/doc/src/refmanual libs/mpl/test
From: eric_at_[hidden]
Date: 2009-06-12 21:03:46
Author: eric_niebler
Date: 2009-06-12 21:03:44 EDT (Fri, 12 Jun 2009)
New Revision: 53838
URL: http://svn.boost.org/trac/boost/changeset/53838
Log:
Merged revisions 52208,52241,52271,52314-52315,52317,52361,52542,52579 via svnmerge from
https://svn.boost.org/svn/boost/trunk
Added:
branches/release/boost/mpl/char.hpp
- copied unchanged from r52208, /trunk/boost/mpl/char.hpp
branches/release/boost/mpl/char_fwd.hpp
- copied unchanged from r52208, /trunk/boost/mpl/char_fwd.hpp
branches/release/boost/mpl/limits/string.hpp
- copied unchanged from r52317, /trunk/boost/mpl/limits/string.hpp
branches/release/boost/mpl/string.hpp
- copied, changed from r52208, /trunk/boost/mpl/string.hpp
branches/release/libs/mpl/doc/src/refmanual/LIMIT_STRING_SIZE.rst
- copied unchanged from r52317, /trunk/libs/mpl/doc/src/refmanual/LIMIT_STRING_SIZE.rst
branches/release/libs/mpl/doc/src/refmanual/c_str.rst
- copied unchanged from r52315, /trunk/libs/mpl/doc/src/refmanual/c_str.rst
branches/release/libs/mpl/doc/src/refmanual/char_.rst
- copied unchanged from r52208, /trunk/libs/mpl/doc/src/refmanual/char_.rst
branches/release/libs/mpl/doc/src/refmanual/string.rst
- copied, changed from r52208, /trunk/libs/mpl/doc/src/refmanual/string.rst
branches/release/libs/mpl/test/char.cpp
- copied unchanged from r52208, /trunk/libs/mpl/test/char.cpp
branches/release/libs/mpl/test/string.cpp
- copied, changed from r52208, /trunk/libs/mpl/test/string.cpp
Properties modified:
branches/release/ (props changed)
Text files modified:
branches/release/boost/mpl/string.hpp | 545 +++++++++++++++++++++++++--------------
branches/release/libs/mpl/doc/src/refmanual/IntegralConstant.rst | 1
branches/release/libs/mpl/doc/src/refmanual/refmanual.toc | 1
branches/release/libs/mpl/doc/src/refmanual/string.rst | 49 +-
branches/release/libs/mpl/test/Jamfile.v2 | 2
branches/release/libs/mpl/test/string.cpp | 476 ++++++++++++++++++++++++++++------
6 files changed, 767 insertions(+), 307 deletions(-)
Copied: branches/release/boost/mpl/string.hpp (from r52208, /trunk/boost/mpl/string.hpp)
==============================================================================
--- /trunk/boost/mpl/string.hpp (original)
+++ branches/release/boost/mpl/string.hpp 2009-06-12 21:03:44 EDT (Fri, 12 Jun 2009)
@@ -4,8 +4,8 @@
// Copyright Eric Niebler 2009
//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// 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.
@@ -13,22 +13,32 @@
// $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/detail/endian.hpp>
+#include <boost/mpl/limits/string.hpp>
+#include <boost/mpl/if.hpp>
#include <boost/mpl/char.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/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/repetition/enum.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>
@@ -37,22 +47,58 @@
namespace boost { namespace mpl
{
- #ifndef BOOST_MPL_STRING_MAX_LENGTH
- # define BOOST_MPL_STRING_MAX_LENGTH 32
- #endif
-
- #define BOOST_MPL_STRING_MAX_PARAMS BOOST_PP_DIV(BOOST_PP_ADD(BOOST_MPL_STRING_MAX_LENGTH, 3), 4)
+ #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>0xffffff)+(c>0xffff)+(c>0xff)+1)
+
+ #if defined(BOOST_LITTLE_ENDIAN) && defined(__SUNPRO_CC)
+
+ #define BOOST_MPL_MULTICHAR_AT(c,i) \
+ (char)(0xff&(c>>(8*(std::size_t)(i))))
+
+ #define BOOST_MPL_MULTICHAR_PUSH_BACK(c,i) \
+ ((((unsigned char)(i))<<(BOOST_MPL_MULTICHAR_LENGTH(c)*8))|(c))
+
+ #define BOOST_MPL_MULTICHAR_PUSH_FRONT(c,i) \
+ (((c)<<8)|(unsigned char)(i))
+
+ #define BOOST_MPL_MULTICHAR_POP_BACK(c) \
+ (((1<<((BOOST_MPL_MULTICHAR_LENGTH(c)-1)*8))-1)&(c))
+
+ #define BOOST_MPL_MULTICHAR_POP_FRONT(c) \
+ ((c)>>8)
+
+ #else
+
+ #define BOOST_MPL_MULTICHAR_AT(c,i) \
+ (char)(0xff&(c>>(8*(BOOST_MPL_MULTICHAR_LENGTH(c)-(std::size_t)(i)-1))))
+
+ #define BOOST_MPL_MULTICHAR_PUSH_BACK(c,i) \
+ (((c)<<8)|(unsigned char)(i))
+
+ #define BOOST_MPL_MULTICHAR_PUSH_FRONT(c,i) \
+ ((((unsigned char)(i))<<(BOOST_MPL_MULTICHAR_LENGTH(c)*8))|(c))
+
+ #define BOOST_MPL_MULTICHAR_POP_BACK(c) \
+ ((c)>>8)
- #define BOOST_MPL_MULTICHAR_LENGTH(c) (std::size_t)((c>0xffffff)+(c>0xffff)+(c>0xff)+1)
- #define BOOST_MPL_MULTICHAR_AT(c,i) (char)(0xff&(c>>(8*(BOOST_MPL_MULTICHAR_LENGTH(c)-(std::size_t)(i)-1))))
+ #define BOOST_MPL_MULTICHAR_POP_FRONT(c) \
+ (((1<<((BOOST_MPL_MULTICHAR_LENGTH(c)-1)*8))-1)&(c))
+
+ #endif
struct string_tag;
struct string_iterator_tag;
- template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_MPL_STRING_MAX_PARAMS, unsigned int C, 0)>
+ template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_MPL_STRING_MAX_PARAMS, unsigned C, 0)>
struct string;
- template<typename Sequence, long N>
+ template<typename Sequence, unsigned I, unsigned J>
struct string_iterator;
template<typename Sequence>
@@ -62,36 +108,40 @@
struct size_impl;
template<>
- struct size_impl<string_tag>
+ struct size_impl<mpl::string_tag>
{
template<typename Sequence>
- struct apply
- : mpl::size_t<Sequence::size>
- {};
- };
+ struct apply;
- template<typename Tag>
- struct at_impl;
+ #define M0(z, n, data) \
+ + BOOST_MPL_MULTICHAR_LENGTH(BOOST_PP_CAT(C,n))
- template<>
- struct at_impl<string_tag>
- {
- template<typename Sequence, typename N>
- struct apply
- : Sequence::template at<N::value>
+ #define M1(z, n, data) \
+ template<BOOST_PP_ENUM_PARAMS_Z(z, n, unsigned 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<string_tag>
+ struct begin_impl<mpl::string_tag>
{
template<typename Sequence>
struct apply
{
- typedef string_iterator<Sequence, 0> type;
+ typedef mpl::string_iterator<Sequence, 0, 0> type;
};
};
@@ -99,102 +149,226 @@
struct end_impl;
template<>
- struct end_impl<string_tag>
+ struct end_impl<mpl::string_tag>
{
template<typename Sequence>
- struct apply
- {
- typedef string_iterator<Sequence, Sequence::size> type;
+ struct apply;
+
+ #define M0(z,n,data) \
+ template<BOOST_PP_ENUM_PARAMS_Z(z, n, unsigned 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<string_tag>
+ 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(false, PUSH_BACK_FAILED_MPL_STRING_IS_FULL, (Sequence));
- typedef void type;
+ 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<string<>, Value, false>
+ struct apply<mpl::string<>, Value, false>
{
- typedef string<(char)Value::value> type;
+ typedef mpl::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, false> \
+ template<BOOST_PP_ENUM_PARAMS_Z(z, n, unsigned C), typename Value> \
+ struct apply<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)>, Value, false> \
{ \
- 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; \
+ typedef \
+ mpl::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_MPL_MULTICHAR_PUSH_BACK(BOOST_PP_CAT(C,BOOST_PP_DEC(n)), 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, ~)
+ BOOST_PP_REPEAT_FROM_TO(1, 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, false>
+ template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, unsigned C), typename Value>
+ struct apply<mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>, Value, false>
{
- 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;
+ 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 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, unsigned 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 push_front_impl;
template<>
- struct push_front_impl<string_tag>
+ 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(false, PUSH_FRONT_FAILED_MPL_STRING_IS_FULL, (Sequence));
- typedef void type;
+ 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<string<>, Value, false>
+ 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, unsigned 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, unsigned C), typename Value>
+ struct apply<mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>, Value, false>
{
- typedef string<(char)Value::value> type;
+ 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 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, unsigned int C), typename Value> \
- struct apply<string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)>, Value, true> \
+ template<BOOST_PP_ENUM_PARAMS_Z(z, n, unsigned C)> \
+ struct apply<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)>, true> \
{ \
- typedef string< \
- (char)Value::value \
- BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, C) \
- > type; \
+ 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_PP_DEC(BOOST_MPL_STRING_MAX_PARAMS), M0, ~)
+ BOOST_PP_REPEAT_FROM_TO(1, 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, false>
+ template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, unsigned C)>
+ struct apply<mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>, false>
{
- typedef string<
- ((((unsigned char)Value::value)<<(BOOST_MPL_MULTICHAR_LENGTH(C0)*8))|C0)
- , BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)
- > type;
+ typedef
+ mpl::string<
+ BOOST_MPL_MULTICHAR_POP_FRONT(C0)
+ , BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)
+ >
+ type;
};
};
@@ -202,25 +376,25 @@
struct insert_range_impl;
template<>
- struct insert_range_impl<string_tag>
+ struct insert_range_impl<mpl::string_tag>
{
template<typename Sequence, typename Pos, typename Range>
struct apply
- : copy<
- joint_view<
- iterator_range<
- string_iterator<Sequence, 0>
+ : mpl::copy<
+ mpl::joint_view<
+ mpl::iterator_range<
+ mpl::string_iterator<Sequence, 0, 0>
, Pos
>
- , joint_view<
+ , mpl::joint_view<
Range
- , iterator_range<
+ , mpl::iterator_range<
Pos
- , string_iterator<Sequence, Sequence::size>
+ , typename mpl::end<Sequence>::type
>
>
>
- , back_inserter<string<> >
+ , mpl::back_inserter<mpl::string<> >
>
{};
};
@@ -229,11 +403,11 @@
struct insert_impl;
template<>
- struct insert_impl<string_tag>
+ struct insert_impl<mpl::string_tag>
{
template<typename Sequence, typename Pos, typename Value>
struct apply
- : insert_range<Sequence, Pos, string<(char)Value::value> >
+ : mpl::insert_range<Sequence, Pos, mpl::string<(char)Value::value> >
{};
};
@@ -241,22 +415,22 @@
struct erase_impl;
template<>
- struct erase_impl<string_tag>
+ struct erase_impl<mpl::string_tag>
{
template<typename Sequence, typename First, typename Last>
struct apply
- : copy<
- joint_view<
- iterator_range<
- string_iterator<Sequence, 0>
+ : mpl::copy<
+ mpl::joint_view<
+ mpl::iterator_range<
+ mpl::string_iterator<Sequence, 0, 0>
, First
>
- , iterator_range<
- typename if_na<Last, typename next<First>::type>::type
- , string_iterator<Sequence, Sequence::size>
+ , mpl::iterator_range<
+ typename mpl::if_na<Last, typename mpl::next<First>::type>::type
+ , typename mpl::end<Sequence>::type
>
>
- , back_inserter<string<> >
+ , mpl::back_inserter<mpl::string<> >
>
{};
};
@@ -265,132 +439,117 @@
struct clear_impl;
template<>
- struct clear_impl<string_tag>
+ struct clear_impl<mpl::string_tag>
{
template<typename>
struct apply
{
- typedef string<> type;
+ typedef mpl::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;
- };
+ #define M0(z, n, data) \
+ template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, unsigned C), unsigned J> \
+ struct string_iterator<mpl::string<BOOST_PP_ENUM_PARAMS(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(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(BOOST_MPL_STRING_MAX_PARAMS, unsigned C)> \
+ struct string_iterator<mpl::string<BOOST_PP_ENUM_PARAMS(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(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; \
};
- template<typename Tag>
- struct distance_impl;
+ BOOST_PP_REPEAT(BOOST_MPL_STRING_MAX_PARAMS, M0, ~)
+ #undef M0
- template<>
- struct distance_impl<string_iterator_tag>
+ template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, unsigned C)>
+ struct string
{
- template<typename First, typename Last>
- struct apply
+ /// INTERNAL ONLY
+ enum
{
- typedef mpl::long_<Last::index - First::index> type;
+ front_ = C0
+ , back_ = BOOST_PP_CAT(C, BOOST_PP_DEC(BOOST_MPL_STRING_MAX_PARAMS))
};
- };
- 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;
+ typedef string type;
+ typedef string_tag tag;
};
- template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, unsigned int C)>
- struct string
+ namespace aux_
{
- /// INTERNAL ONLY
- static unsigned int const front_ = C0;
- /// INTERNAL ONLY
- static unsigned int const back_ = BOOST_PP_CAT(C, BOOST_PP_DEC(BOOST_MPL_STRING_MAX_PARAMS));
- /// INTERNAL ONLY
- typedef string<BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)> rest_;
-
- typedef string type;
-
- typedef string_tag tag;
-
- static std::size_t const size = BOOST_MPL_MULTICHAR_LENGTH(C0) + rest_::size;
-
- template<long Pos, bool B = (Pos < BOOST_MPL_MULTICHAR_LENGTH(C0))>
- struct at
- : boost::mpl::char_<BOOST_MPL_MULTICHAR_AT(C0,Pos)>
+ template<typename It, typename End>
+ struct next_unless
+ : mpl::next<It>
{};
- template<long Pos>
- struct at<Pos, false>
- : rest_::template at<Pos-BOOST_MPL_MULTICHAR_LENGTH(C0)>
+ template<typename End>
+ struct next_unless<End, End>
+ {
+ typedef End type;
+ };
+
+ template<typename It, typename End>
+ struct deref_unless
+ : mpl::deref<It>
{};
- static char const c_str[];
- };
+ template<typename End>
+ struct deref_unless<End, End>
+ {
+ typedef mpl::char_<'\0'> type;
+ };
+ }
- 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[] =
+ template<typename Sequence>
+ struct 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)>::front_;
+ 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
- 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)>::back_;
+ typedef c_str type;
+ static char const value[];
+ };
- template<>
- struct string<>
+ template<typename Sequence>
+ char const c_str<Sequence>::value[] =
{
- /// INTERNAL ONLY
- static unsigned int const front_ = 0;
- /// INTERNAL ONLY
- static unsigned int const back_ = 0;
- /// INTERNAL ONLY
- typedef string rest_;
-
- typedef string type;
-
- 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[];
+ #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'
};
- char const string<>::c_str[] = {'\0'};
- std::size_t const string<>::size;
- unsigned int const string<>::front_;
- unsigned int const string<>::back_;
-
}} // namespace boost
#endif // BOOST_MPL_STRING_HPP_INCLUDED
Modified: branches/release/libs/mpl/doc/src/refmanual/IntegralConstant.rst
==============================================================================
--- branches/release/libs/mpl/doc/src/refmanual/IntegralConstant.rst (original)
+++ branches/release/libs/mpl/doc/src/refmanual/IntegralConstant.rst 2009-06-12 21:03:44 EDT (Fri, 12 Jun 2009)
@@ -71,6 +71,7 @@
* |bool_|
* |int_|
* |long_|
+* |char_|
* |integral_c|
Modified: branches/release/libs/mpl/doc/src/refmanual/refmanual.toc
==============================================================================
--- branches/release/libs/mpl/doc/src/refmanual/refmanual.toc (original)
+++ branches/release/libs/mpl/doc/src/refmanual/refmanual.toc 2009-06-12 21:03:44 EDT (Fri, 12 Jun 2009)
@@ -23,6 +23,7 @@
Metafunctions/Logical Operations
Metafunctions/Bitwise Operations
Metafunctions/Trivial
+Metafunctions/String Operations
Metafunctions/Miscellaneous
Data Types
Data Types/Concepts
Copied: branches/release/libs/mpl/doc/src/refmanual/string.rst (from r52208, /trunk/libs/mpl/doc/src/refmanual/string.rst)
==============================================================================
--- /trunk/libs/mpl/doc/src/refmanual/string.rst (original)
+++ branches/release/libs/mpl/doc/src/refmanual/string.rst 2009-06-12 21:03:44 EDT (Fri, 12 Jun 2009)
@@ -11,14 +11,15 @@
Description
-----------
-``string`` is a |variadic|, `random access`__, `extensible`__ |Integral Sequence Wrapper| of
-characters that supports constant-time insertion and removal of elements at both ends, and
-linear-time insertion and removal of elements in the middle. The parameters to ``string``
+``string`` is a |variadic|, `bidirectional`__, `extensible`__ |Integral Sequence Wrapper| of
+characters that supports amortized constant-time insertion and removal of elements at both ends,
+and linear-time insertion and removal of elements in the middle. The parameters to ``string``
are multi-character literals, giving a somewhat readable syntax for compile-time strings.
-``string`` also has a class static null-terminated character array called ``c_str`` that
-facilitates interoperability with runtime string processing routines.
+``string`` can also be an argument to the ``c_str`` metafunction, which generates a
+null-terminated character array that facilitates interoperability with runtime string
+processing routines.
-__ `Random Access Sequence`_
+__ `Bidirectional Sequence`_
__ `Extensible Sequence`_
Header
@@ -35,12 +36,11 @@
* |Integral Sequence Wrapper|
* |Variadic Sequence|
-* |Random Access Sequence|
+* |Bidirectional Sequence|
* |Extensible Sequence|
* |Back Extensible Sequence|
* |Front Extensible Sequence|
-
Expression semantics
--------------------
@@ -60,24 +60,21 @@
| string<|c1...cn|>::type | |
+---------------------------------------+-----------------------------------------------------------+
| ``begin<s>::type`` | An iterator pointing to the beginning of ``s``; |
-| | see |Random Access Sequence|. |
+| | see |Bidirectional Sequence|. |
+---------------------------------------+-----------------------------------------------------------+
| ``end<s>::type`` | An iterator pointing to the end of ``s``; |
-| | see |Random Access Sequence|. |
+| | see |Bidirectional Sequence|. |
+---------------------------------------+-----------------------------------------------------------+
-| ``size<s>::type`` | The size of ``s``; see |Random Access Sequence|. |
+| ``size<s>::type`` | The size of ``s``; see |Bidirectional Sequence|. |
+---------------------------------------+-----------------------------------------------------------+
| ``empty<s>::type`` | |true if and only if| the sequence is empty; |
-| | see |Random Access Sequence|. |
+| | see |Bidirectional Sequence|. |
+---------------------------------------+-----------------------------------------------------------+
| ``front<s>::type`` | The first element in ``s``; see |
-| | |Random Access Sequence|. |
+| | |Bidirectional Sequence|. |
+---------------------------------------+-----------------------------------------------------------+
| ``back<s>::type`` | The last element in ``s``; see |
-| | |Random Access Sequence|. |
-+---------------------------------------+-----------------------------------------------------------+
-| ``at<s,n>::type`` | The ``n``\ th element from the beginning of ``s``; see |
-| | |Random Access Sequence|. |
+| | |Bidirectional Sequence|. |
+---------------------------------------+-----------------------------------------------------------+
| ``insert<s,pos,x>::type`` | A new ``string`` of following elements: |
| | [``begin<s>::type``, ``pos``), ``x``, |
@@ -114,11 +111,10 @@
| | [``next< begin<s>::type >::type``, ``end<s>::type``); |
| | see |Front Extensible Sequence|. |
+---------------------------------------+-----------------------------------------------------------+
-| ``s::c_str`` | A null-terminated byte string such that |
-| | ``s::c_str[``\ *n*\ ``]`` is |
-| | ``at<s,``\ *n*\ ``>::type::value`` for each *n* in |
-| | [``0``, ``size<s>::type::value``), and |
-| | ``s::c_str[size<s>::type::value]`` is ``'\0'``. |
+| ``c_str<s>::value`` | A null-terminated byte string such that |
+| | ``c_str<s>::value[``\ *n*\ ``]`` is equal to the *n*\ -th |
+| | character in ``s``, and |
+| | ``c_str<s>::value[size<s>::type::value]`` is ``'\0'``. |
+---------------------------------------+-----------------------------------------------------------+
@@ -127,14 +123,13 @@
.. parsed-literal::
- typedef string<'hell','o wo','rld'> hello;
- typedef push_back<hello, char_<'!'> >::type hello2;
+ typedef mpl::string<'hell','o wo','rld'> hello;
+ typedef mpl::push_back<hello, mpl::char_<'!'> >::type hello2;
- BOOST_ASSERT(0 == std::strcmp(hello2::c_str, "hello world!"));
+ BOOST_ASSERT(0 == std::strcmp(mpl::c_str<hello2>::value, "hello world!"));
See also
--------
-|Sequences|, |Variadic Sequence|, |Random Access Sequence|, |Extensible Sequence|, |Integral Sequence Wrapper|, |char_|
-
+|Sequences|, |Variadic Sequence|, |Bidirectional Sequence|, |Extensible Sequence|, |Integral Sequence Wrapper|, |char_|, |c_str|
Modified: branches/release/libs/mpl/test/Jamfile.v2
==============================================================================
--- branches/release/libs/mpl/test/Jamfile.v2 (original)
+++ branches/release/libs/mpl/test/Jamfile.v2 2009-06-12 21:03:44 EDT (Fri, 12 Jun 2009)
@@ -44,6 +44,7 @@
compile insert.cpp ;
compile insert_range.cpp ;
run int.cpp ;
+run char.cpp ;
run integral_c.cpp : : : <toolset>vacpp:<cxxflags>-qchars=signed ;
compile is_placeholder.cpp ;
compile is_sequence.cpp ;
@@ -90,3 +91,4 @@
compile vector.cpp ;
compile vector_c.cpp ;
compile zip_view.cpp ;
+run string.cpp ;
Copied: branches/release/libs/mpl/test/string.cpp (from r52208, /trunk/libs/mpl/test/string.cpp)
==============================================================================
--- /trunk/libs/mpl/test/string.cpp (original)
+++ branches/release/libs/mpl/test/string.cpp 2009-06-12 21:03:44 EDT (Fri, 12 Jun 2009)
@@ -17,27 +17,21 @@
#include <boost/mpl/string.hpp>
-#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/advance.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/vector_c.hpp>
+#include <boost/mpl/pop_back.hpp>
+#include <boost/mpl/pop_front.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/mpl/push_front.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/detail/lightweight_test.hpp>
+
namespace mpl = boost::mpl;
// Accept a string as a template parameter!
@@ -64,110 +58,418 @@
std::string *str_;
};
-void test1()
+int main()
{
- BOOST_TEST(0 == std::strcmp(mpl::string<'Hell','o wo','rld!'>::c_str, "Hello world!"));
- BOOST_TEST((12 == mpl::size<mpl::string<'Hell','o wo','rld!'> >::type::value));
- BOOST_TEST(('w' == mpl::at_c<mpl::string<'Hell','o wo','rld!'>, 6>::type::value));
+ // Test mpl::size of strings
+ {
+ typedef mpl::string<'aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaa'> almost_full;
+ typedef mpl::string<'aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa'> full;
- // test using a string as a template parameter
- greeting<mpl::string<'Hell','o wo','rld!'>::c_str> g;
- BOOST_TEST("Hello world!" == g.say_hello());
+ BOOST_MPL_ASSERT_RELATION(0, ==, (mpl::size<mpl::string<> >::value));
+ BOOST_MPL_ASSERT_RELATION(1, ==, (mpl::size<mpl::string<'a'> >::value));
+ BOOST_MPL_ASSERT_RELATION(2, ==, (mpl::size<mpl::string<'ab'> >::value));
+ BOOST_MPL_ASSERT_RELATION(2, ==, (mpl::size<mpl::string<'a','b'> >::value));
+ BOOST_MPL_ASSERT_RELATION(4, ==, (mpl::size<mpl::string<'abcd'> >::value));
+ BOOST_MPL_ASSERT_RELATION(5, ==, (mpl::size<mpl::string<'abcd','e'> >::value));
+ BOOST_MPL_ASSERT_RELATION(31, ==, (mpl::size<almost_full>::value));
+ BOOST_MPL_ASSERT_RELATION(32, ==, (mpl::size<full>::value));
+ }
- BOOST_TEST(0 == std::strcmp("", mpl::string<>::c_str));
+ // Test mpl::begin and mpl::end with strings
+ {
+ typedef mpl::string<'aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaa'> almost_full;
+ typedef mpl::string<'aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa'> full;
- std::string result;
- mpl::for_each<mpl::string<'Hell','o wo','rld!'> >(push_char(result));
- BOOST_TEST("Hello world!" == result);
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::begin<mpl::string<> >::type
+ , mpl::end<mpl::string<> >::type
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::begin<mpl::string<'a'> >::type
+ , mpl::string_iterator<mpl::string<'a'>, 0, 0>
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::end<mpl::string<'a'> >::type
+ , mpl::string_iterator<mpl::string<'a'>, 1, 0>
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::begin<almost_full>::type
+ , mpl::string_iterator<almost_full, 0, 0>
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::end<almost_full>::type
+ , mpl::string_iterator<almost_full, 8, 0>
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::begin<full>::type
+ , mpl::string_iterator<full, 0, 0>
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::end<full>::type
+ , mpl::string_iterator<full, 8, 0>
+ >
+ ));
+ }
- BOOST_MPL_ASSERT((mpl::empty<mpl::string<> >));
- BOOST_MPL_ASSERT_NOT((mpl::empty<mpl::string<'hi!'> >));
+ // testing push_back
+ {
+ typedef mpl::push_back<mpl::string<>, mpl::char_<'a'> >::type t1;
+ BOOST_MPL_ASSERT((boost::is_same<t1, mpl::string<'a'> >));
- BOOST_TEST(('h' == mpl::front<mpl::string<'hi!'> >::type()));
- BOOST_TEST(('!' == mpl::back<mpl::string<'hi!'> >::type()));
-}
+ typedef mpl::push_back<t1, mpl::char_<'b'> >::type t2;
+ BOOST_MPL_ASSERT((boost::is_same<t2, mpl::string<'ab'> >));
-// testing push_back
-void test2()
-{
- typedef mpl::push_back<mpl::string<>, mpl::char_<'a'> >::type t1;
- BOOST_TEST(0 == std::strcmp("a", t1::c_str));
+ typedef mpl::push_back<t2, mpl::char_<'c'> >::type t3;
+ BOOST_MPL_ASSERT((boost::is_same<t3, mpl::string<'abc'> >));
+
+ typedef mpl::push_back<t3, mpl::char_<'d'> >::type t4;
+ BOOST_MPL_ASSERT((boost::is_same<t4, mpl::string<'abcd'> >));
- typedef mpl::push_back<t1, mpl::char_<'b'> >::type t2;
- BOOST_TEST(0 == std::strcmp("ab", t2::c_str));
+ typedef mpl::push_back<t4, mpl::char_<'e'> >::type t5;
+ BOOST_MPL_ASSERT((boost::is_same<t5, mpl::string<'abcd','e'> >));
- typedef mpl::push_back<t2, mpl::char_<'c'> >::type t3;
- BOOST_TEST(0 == std::strcmp("abc", t3::c_str));
- BOOST_MPL_ASSERT((boost::is_same<t3, mpl::string<'abc'> >));
+ typedef mpl::string<'aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaa'> almost_full;
+ typedef mpl::push_back<almost_full, mpl::char_<'X'> >::type t6;
+ BOOST_MPL_ASSERT((boost::is_same<t6, mpl::string<'aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaX'> >));
+ }
- typedef mpl::push_back<t3, mpl::char_<'d'> >::type t4;
- BOOST_TEST(0 == std::strcmp("abcd", t4::c_str));
+ // Test mpl::next
+ {
+ typedef mpl::string<'a','bc','def','ghij'> s;
- typedef mpl::push_back<t4, mpl::char_<'e'> >::type t5;
- BOOST_TEST(0 == std::strcmp("abcde", t5::c_str));
- BOOST_MPL_ASSERT((boost::is_same<t5, mpl::string<'abcd','e'> >));
+ typedef mpl::begin<s>::type i0;
+ BOOST_MPL_ASSERT((boost::is_same<i0, mpl::string_iterator<s,0,0> >));
- typedef mpl::string<'aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaa'> almost_full;
- BOOST_TEST(0 == std::strcmp("aaaa" "aaaa" "aaaa" "aaaa" "aaaa" "aaaa" "aaaa" "aaa", almost_full::c_str));
+ typedef mpl::next<i0>::type i1;
+ BOOST_MPL_ASSERT((boost::is_same<i1, mpl::string_iterator<s,1,0> >));
- typedef mpl::push_back<almost_full, mpl::char_<'X'> >::type t6;
- BOOST_TEST(0 == std::strcmp("aaaa" "aaaa" "aaaa" "aaaa" "aaaa" "aaaa" "aaaa" "aaaX", t6::c_str));
-}
+ typedef mpl::next<i1>::type i2;
+ BOOST_MPL_ASSERT((boost::is_same<i2, mpl::string_iterator<s,1,1> >));
-// testing push_front
-void test3()
-{
- typedef mpl::push_front<mpl::string<>, mpl::char_<'a'> >::type t1;
- BOOST_TEST(0 == std::strcmp("a", t1::c_str));
+ typedef mpl::next<i2>::type i3;
+ BOOST_MPL_ASSERT((boost::is_same<i3, mpl::string_iterator<s,2,0> >));
- typedef mpl::push_front<t1, mpl::char_<'b'> >::type t2;
- BOOST_TEST(0 == std::strcmp("ba", t2::c_str));
+ typedef mpl::next<i3>::type i4;
+ BOOST_MPL_ASSERT((boost::is_same<i4, mpl::string_iterator<s,2,1> >));
- typedef mpl::push_front<t2, mpl::char_<'c'> >::type t3;
- BOOST_TEST(0 == std::strcmp("cba", t3::c_str));
+ typedef mpl::next<i4>::type i5;
+ BOOST_MPL_ASSERT((boost::is_same<i5, mpl::string_iterator<s,2,2> >));
- typedef mpl::push_front<t3, mpl::char_<'d'> >::type t4;
- BOOST_TEST(0 == std::strcmp("dcba", t4::c_str));
+ typedef mpl::next<i5>::type i6;
+ BOOST_MPL_ASSERT((boost::is_same<i6, mpl::string_iterator<s,3,0> >));
- typedef mpl::push_front<t4, mpl::char_<'e'> >::type t5;
- BOOST_TEST(0 == std::strcmp("edcba", t5::c_str));
+ typedef mpl::next<i6>::type i7;
+ BOOST_MPL_ASSERT((boost::is_same<i7, mpl::string_iterator<s,3,1> >));
- typedef mpl::string<'aaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa'> almost_full;
- BOOST_TEST(0 == std::strcmp("aaa" "aaaa" "aaaa" "aaaa" "aaaa" "aaaa" "aaaa" "aaaa", almost_full::c_str));
+ typedef mpl::next<i7>::type i8;
+ BOOST_MPL_ASSERT((boost::is_same<i8, mpl::string_iterator<s,3,2> >));
- typedef mpl::push_front<almost_full, mpl::char_<'X'> >::type t6;
- BOOST_TEST(0 == std::strcmp("Xaaa" "aaaa" "aaaa" "aaaa" "aaaa" "aaaa" "aaaa" "aaaa", t6::c_str));
-}
+ typedef mpl::next<i8>::type i9;
+ BOOST_MPL_ASSERT((boost::is_same<i9, mpl::string_iterator<s,3,3> >));
+
+ typedef mpl::next<i9>::type i10;
+ BOOST_MPL_ASSERT((boost::is_same<i10, mpl::string_iterator<s,4,0> >));
+
+ BOOST_MPL_ASSERT((boost::is_same<i10, mpl::end<s>::type>));
+ }
+
+ // Test mpl::prior
+ {
+ typedef mpl::string<'a','bc','def','ghij'> s;
+
+ typedef mpl::end<s>::type i10;
+ BOOST_MPL_ASSERT((boost::is_same<i10, mpl::string_iterator<s,4,0> >));
+
+ typedef mpl::prior<i10>::type i9;
+ BOOST_MPL_ASSERT((boost::is_same<i9, mpl::string_iterator<s,3,3> >));
+
+ typedef mpl::prior<i9>::type i8;
+ BOOST_MPL_ASSERT((boost::is_same<i8, mpl::string_iterator<s,3,2> >));
+
+ typedef mpl::prior<i8>::type i7;
+ BOOST_MPL_ASSERT((boost::is_same<i7, mpl::string_iterator<s,3,1> >));
+
+ typedef mpl::prior<i7>::type i6;
+ BOOST_MPL_ASSERT((boost::is_same<i6, mpl::string_iterator<s,3,0> >));
+
+ typedef mpl::prior<i6>::type i5;
+ BOOST_MPL_ASSERT((boost::is_same<i5, mpl::string_iterator<s,2,2> >));
+
+ typedef mpl::prior<i5>::type i4;
+ BOOST_MPL_ASSERT((boost::is_same<i4, mpl::string_iterator<s,2,1> >));
+
+ typedef mpl::prior<i4>::type i3;
+ BOOST_MPL_ASSERT((boost::is_same<i3, mpl::string_iterator<s,2,0> >));
+
+ typedef mpl::prior<i3>::type i2;
+ BOOST_MPL_ASSERT((boost::is_same<i2, mpl::string_iterator<s,1,1> >));
+
+ typedef mpl::prior<i2>::type i1;
+ BOOST_MPL_ASSERT((boost::is_same<i1, mpl::string_iterator<s,1,0> >));
+
+ typedef mpl::prior<i1>::type i0;
+ BOOST_MPL_ASSERT((boost::is_same<i0, mpl::string_iterator<s,0,0> >));
+
+ BOOST_MPL_ASSERT((boost::is_same<i0, mpl::begin<s>::type>));
+ }
+
+ // Test mpl::deref
+ {
+ typedef mpl::string<'a','bc','def','ghij'> s;
+
+ typedef mpl::begin<s>::type i0;
+ BOOST_MPL_ASSERT((boost::is_same<mpl::deref<i0>::type, mpl::char_<'a'> >));
+
+ typedef mpl::next<i0>::type i1;
+ BOOST_MPL_ASSERT((boost::is_same<mpl::deref<i1>::type, mpl::char_<'b'> >));
+
+ typedef mpl::next<i1>::type i2;
+ BOOST_MPL_ASSERT((boost::is_same<mpl::deref<i2>::type, mpl::char_<'c'> >));
+
+ typedef mpl::next<i2>::type i3;
+ BOOST_MPL_ASSERT((boost::is_same<mpl::deref<i3>::type, mpl::char_<'d'> >));
+
+ typedef mpl::next<i3>::type i4;
+ BOOST_MPL_ASSERT((boost::is_same<mpl::deref<i4>::type, mpl::char_<'e'> >));
+
+ typedef mpl::next<i4>::type i5;
+ BOOST_MPL_ASSERT((boost::is_same<mpl::deref<i5>::type, mpl::char_<'f'> >));
+
+ typedef mpl::next<i5>::type i6;
+ BOOST_MPL_ASSERT((boost::is_same<mpl::deref<i6>::type, mpl::char_<'g'> >));
+
+ typedef mpl::next<i6>::type i7;
+ BOOST_MPL_ASSERT((boost::is_same<mpl::deref<i7>::type, mpl::char_<'h'> >));
+
+ typedef mpl::next<i7>::type i8;
+ BOOST_MPL_ASSERT((boost::is_same<mpl::deref<i8>::type, mpl::char_<'i'> >));
+
+ typedef mpl::next<i8>::type i9;
+ BOOST_MPL_ASSERT((boost::is_same<mpl::deref<i9>::type, mpl::char_<'j'> >));
+ }
+
+ // testing push_back
+ {
+ typedef mpl::push_back<mpl::string<>, mpl::char_<'a'> >::type t1;
+ BOOST_MPL_ASSERT((boost::is_same<t1, mpl::string<'a'> >));
+
+ typedef mpl::push_back<t1, mpl::char_<'b'> >::type t2;
+ BOOST_MPL_ASSERT((boost::is_same<t2, mpl::string<'ab'> >));
+
+ typedef mpl::push_back<t2, mpl::char_<'c'> >::type t3;
+ BOOST_MPL_ASSERT((boost::is_same<t3, mpl::string<'abc'> >));
+
+ typedef mpl::push_back<t3, mpl::char_<'d'> >::type t4;
+ BOOST_MPL_ASSERT((boost::is_same<t4, mpl::string<'abcd'> >));
+
+ typedef mpl::push_back<t4, mpl::char_<'e'> >::type t5;
+ BOOST_MPL_ASSERT((boost::is_same<t5, mpl::string<'abcd','e'> >));
+
+ typedef mpl::string<'aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaa'> almost_full;
+ typedef mpl::push_back<almost_full, mpl::char_<'X'> >::type t6;
+ BOOST_MPL_ASSERT((boost::is_same<t6, mpl::string<'aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaX'> >));
+
+ typedef mpl::string<'a','a','a','a','a','a','a','aaaa'> must_repack;
+ typedef mpl::push_back<must_repack, mpl::char_<'X'> >::type t7;
+ BOOST_MPL_ASSERT((boost::is_same<t7, mpl::string<'aaaa','aaaa','aaaX'> >));
+ }
+
+ BOOST_MPL_ASSERT((mpl::empty<mpl::string<> >));
+ BOOST_MPL_ASSERT_NOT((mpl::empty<mpl::string<'hi!'> >));
+
+ // testing push_front
+ {
+ typedef mpl::push_front<mpl::string<>, mpl::char_<'a'> >::type t1;
+ BOOST_MPL_ASSERT((boost::is_same<t1, mpl::string<'a'> >));
+
+ typedef mpl::push_front<t1, mpl::char_<'b'> >::type t2;
+ BOOST_MPL_ASSERT((boost::is_same<t2, mpl::string<'ba'> >));
+
+ typedef mpl::push_front<t2, mpl::char_<'c'> >::type t3;
+ BOOST_MPL_ASSERT((boost::is_same<t3, mpl::string<'cba'> >));
+
+ typedef mpl::push_front<t3, mpl::char_<'d'> >::type t4;
+ BOOST_MPL_ASSERT((boost::is_same<t4, mpl::string<'dcba'> >));
+
+ typedef mpl::push_front<t4, mpl::char_<'e'> >::type t5;
+ BOOST_MPL_ASSERT((boost::is_same<t5, mpl::string<'e','dcba'> >));
+
+ typedef mpl::string<'aaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa'> almost_full;
+ typedef mpl::push_front<almost_full, mpl::char_<'X'> >::type t6;
+ BOOST_MPL_ASSERT((boost::is_same<t6, mpl::string<'Xaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa'> >));
+
+ typedef mpl::string<'aaaa','a','a','a','a','a','a','a'> must_repack;
+ typedef mpl::push_front<must_repack, mpl::char_<'X'> >::type t7;
+ BOOST_MPL_ASSERT((boost::is_same<t7, mpl::string<'Xaaa','aaaa','aaaa'> >));
+ }
+
+ // Test c_str<>
+ BOOST_TEST(0 == std::strcmp(
+ mpl::c_str<mpl::string<> >::value
+ , ""
+ ));
+
+ BOOST_TEST(0 == std::strcmp(
+ mpl::c_str<mpl::string<'Hell','o wo','rld!'> >::value
+ , "Hell" "o wo" "rld!"
+ ));
+
+ BOOST_TEST(0 == std::strcmp(
+ mpl::c_str<mpl::string<'aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaX'> >::value
+ , "aaaa" "aaaa" "aaaa" "aaaa" "aaaa" "aaaa" "aaaa" "aaaX"
+ ));
+
+ // test using a string as a template parameter
+ greeting<mpl::c_str<mpl::string<'Hell','o wo','rld!'> >::value> g;
+ BOOST_TEST("Hello world!" == g.say_hello());
+
+ std::string result;
+ mpl::for_each<mpl::string<'Hell','o wo','rld!'> >(push_char(result));
+ BOOST_TEST("Hello world!" == result);
+
+ BOOST_TEST(('h' == mpl::front<mpl::string<'hi!'> >::type()));
+ BOOST_TEST(('!' == mpl::back<mpl::string<'hi!'> >::type()));
-void test4()
-{
// back-inserter with copy
typedef mpl::vector_c<char, 'a','b','c','d','e'> rgc;
+ BOOST_TEST(0 == std::strcmp("abcde", mpl::c_str<rgc>::value));
typedef mpl::copy<rgc, mpl::back_inserter<mpl::string<> > >::type str;
- BOOST_TEST(0 == std::strcmp("abcde", str::c_str));
-}
+ BOOST_TEST(0 == std::strcmp("abcde", mpl::c_str<str>::value));
-// test insert_range and erase
-void test5()
-{
- typedef mpl::string<'Hell','o wo','rld!'> hello;
- typedef mpl::advance_c<mpl::begin<hello>::type, 5>::type where;
- typedef mpl::string<' cru','el'> cruel;
- typedef mpl::insert_range<hello, where, cruel>::type hello_cruel;
- BOOST_TEST(0 == std::strcmp("Hello cruel world!", hello_cruel::c_str));
+ // test insert_range and erase
+ {
+ typedef mpl::string<'Hell','o wo','rld!'> hello;
+ typedef mpl::advance_c<mpl::begin<hello>::type, 5>::type where;
+ typedef mpl::string<' cru','el'> cruel;
+ typedef mpl::insert_range<hello, where, cruel>::type hello_cruel;
+ BOOST_TEST(0 == std::strcmp("Hello cruel world!", mpl::c_str<hello_cruel>::value));
- typedef mpl::erase<hello, mpl::begin<hello>::type, where>::type erased1;
- BOOST_TEST(0 == std::strcmp(" world!", erased1::c_str));
-}
+ typedef mpl::erase<hello, mpl::begin<hello>::type, where>::type erased1;
+ BOOST_TEST(0 == std::strcmp(" world!", mpl::c_str<erased1>::value));
+ }
+ // test pop_front
+ {
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::pop_front<mpl::string<'a'> >::type
+ , mpl::string<>
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::pop_front<mpl::string<'ab'> >::type
+ , mpl::string<'b'>
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::pop_front<mpl::string<'abc'> >::type
+ , mpl::string<'bc'>
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::pop_front<mpl::string<'abcd'> >::type
+ , mpl::string<'bcd'>
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::pop_front<mpl::string<'abcd','e'> >::type
+ , mpl::string<'bcd','e'>
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::pop_front<mpl::string<'d','e'> >::type
+ , mpl::string<'e'>
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::pop_front<mpl::string<'aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa'> >::type
+ , mpl::string<'aaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa'>
+ >
+ ));
+ }
-int main()
-{
- test1();
- test2();
- test3();
- test4();
- test5();
+ // test pop_back
+ {
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::pop_back<mpl::string<'a'> >::type
+ , mpl::string<>
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::pop_back<mpl::string<'ab'> >::type
+ , mpl::string<'a'>
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::pop_back<mpl::string<'abc'> >::type
+ , mpl::string<'ab'>
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::pop_back<mpl::string<'abcd'> >::type
+ , mpl::string<'abc'>
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::pop_back<mpl::string<'abcd','e'> >::type
+ , mpl::string<'abcd'>
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::pop_back<mpl::string<'d','e'> >::type
+ , mpl::string<'d'>
+ >
+ ));
+
+ BOOST_MPL_ASSERT((
+ boost::is_same<
+ mpl::pop_back<mpl::string<'aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa'> >::type
+ , mpl::string<'aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaaa','aaa'>
+ >
+ ));
+ }
return boost::report_errors();
}