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)
=============================================================================*/
-#if !defined(SPIRIT_SEQUENCE_DETAIL_JAN_06_2013_1015AM)
-#define SPIRIT_SEQUENCE_DETAIL_JAN_06_2013_1015AM
+#if !defined(BOOST_SPIRIT_X3_SEQUENCE_DETAIL_JAN_06_2013_1015AM)
+#define BOOST_SPIRIT_X3_SEQUENCE_DETAIL_JAN_06_2013_1015AM
#include <boost/spirit/home/x3/support/traits/attribute_of.hpp>
#include <boost/spirit/home/x3/support/traits/attribute_category.hpp>
#include <boost/spirit/home/x3/support/traits/has_attribute.hpp>
#include <boost/spirit/home/x3/support/traits/is_substitute.hpp>
#include <boost/spirit/home/x3/support/traits/container_traits.hpp>
+#include <boost/spirit/home/x3/support/traits/tuple_traits.hpp>
#include <boost/spirit/home/x3/core/detail/parse_into_container.hpp>
#include <boost/fusion/include/begin.hpp>
#include <boost/fusion/include/end.hpp>
#include <boost/fusion/include/advance.hpp>
+#include <boost/fusion/include/deref.hpp>
#include <boost/fusion/include/empty.hpp>
#include <boost/fusion/include/front.hpp>
#include <boost/fusion/include/iterator_range.hpp>
};
template <typename Attribute>
- struct pass_sequence_attribute_front
+ struct pass_sequence_attribute_size_one_view
{
- typedef typename fusion::result_of::front<Attribute>::type type;
+ typedef typename fusion::result_of::deref<
+ typename fusion::result_of::begin<Attribute>::type
+ >::type type;
static typename add_reference<type>::type
call(Attribute& attr)
{
- return fusion::front(attr);
+ return fusion::deref(fusion::begin(attr));
}
};
}
};
- template <typename Parser, typename Attribute, bool pass_through>
+ template <typename Parser, typename Attribute>
struct pass_sequence_attribute_used :
- mpl::if_c<
- (!pass_through && traits::is_size_one_sequence<Attribute>::value)
- , pass_sequence_attribute_front<Attribute>
+ mpl::if_<
+ traits::is_size_one_view<Attribute>
+ , pass_sequence_attribute_size_one_view<Attribute>
, pass_through_sequence_attribute<Attribute>>::type {};
- template <typename Parser, typename Attribute, bool pass_through = false, typename Enable = void>
+ template <typename Parser, typename Attribute, typename Enable = void>
struct pass_sequence_attribute :
mpl::if_<
fusion::result_of::empty<Attribute>
, pass_sequence_attribute_unused
- , pass_sequence_attribute_used<Parser, Attribute, pass_through>>::type {};
+ , pass_sequence_attribute_used<Parser, Attribute>>::type {};
- template <typename L, typename R, typename Attribute, bool pass_through>
- struct pass_sequence_attribute<sequence<L, R>, Attribute, pass_through>
+ template <typename L, typename R, typename Attribute>
+ struct pass_sequence_attribute<sequence<L, R>, Attribute>
: pass_through_sequence_attribute<Attribute> {};
template <typename Parser, typename Attribute>
struct pass_sequence_attribute_subject :
pass_sequence_attribute<typename Parser::subject_type, Attribute> {};
- template <typename Parser, typename Attribute, bool pass_through>
- struct pass_sequence_attribute<Parser, Attribute, pass_through
+ template <typename Parser, typename Attribute>
+ struct pass_sequence_attribute<Parser, Attribute
, typename enable_if_c<(Parser::is_pass_through_unary)>::type>
: pass_sequence_attribute_subject<Parser, Attribute> {};
typedef typename fusion::result_of::end<Attribute>::type r_end;
typedef fusion::iterator_range<l_begin, l_end> l_part;
typedef fusion::iterator_range<l_end, r_end> r_part;
- typedef pass_sequence_attribute<L, l_part, false> l_pass;
- typedef pass_sequence_attribute<R, r_part, false> r_pass;
+ typedef pass_sequence_attribute<L, l_part> l_pass;
+ typedef pass_sequence_attribute<R, r_part> r_pass;
static l_part left(Attribute& s)
{
typedef unused_type l_part;
typedef Attribute& r_part;
typedef pass_sequence_attribute_unused l_pass;
- typedef pass_sequence_attribute<R, Attribute, true> r_pass;
+ typedef pass_sequence_attribute<R, Attribute> r_pass;
static unused_type left(Attribute&)
{
{
typedef Attribute& l_part;
typedef unused_type r_part;
- typedef pass_sequence_attribute<L, Attribute, true> l_pass;
+ typedef pass_sequence_attribute<L, Attribute> l_pass;
typedef pass_sequence_attribute_unused r_pass;
static Attribute& left(Attribute& s)
return parse_sequence_plain(parser, first, last, context, rcontext, attr);
}
+ template <typename Parser, typename Iterator, typename Context
+ , typename RContext, typename Attribute>
+ bool parse_sequence(
+ Parser const& parser, Iterator& first, Iterator const& last
+ , Context const& context, RContext& rcontext, Attribute& attr
+ , traits::optional_attribute)
+ {
+ return parse_sequence_plain(parser, first, last, context, rcontext, attr);
+ }
+
+ template <typename Parser, typename Iterator, typename Context
+ , typename RContext, typename Attribute>
+ bool parse_sequence(
+ Parser const& parser, Iterator& first, Iterator const& last
+ , Context const& context, RContext& rcontext, Attribute& attr
+ , traits::range_attribute)
+ {
+ return parse_sequence_plain(parser, first, last, context, rcontext, attr);
+ }
+
template <typename Left, typename Right, typename Iterator
, typename Context, typename RContext, typename Attribute>
bool parse_sequence(