FM / detail

/usr/include/boost/spirit/home/x3/operator/detail/

/usr/include/boost/spirit/home/x3/operator/detail

Name	Size	Mode	Actions
alternative.hpp	8406	0644	edit dl rm
sequence.hpp	15805	0644	edit dl rm

Edit: /usr/include/boost/spirit/home/x3/operator/detail/alternative.hpp (8406B)

/*=============================================================================
    Copyright (c) 2001-2014 Joel de Guzman

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(BOOST_SPIRIT_X3_ALTERNATIVE_DETAIL_JAN_07_2013_1245PM)
#define BOOST_SPIRIT_X3_ALTERNATIVE_DETAIL_JAN_07_2013_1245PM

#include <boost/spirit/home/x3/support/traits/attribute_of.hpp>
#include <boost/spirit/home/x3/support/traits/pseudo_attribute.hpp>
#include <boost/spirit/home/x3/support/traits/is_variant.hpp>
#include <boost/spirit/home/x3/support/traits/tuple_traits.hpp>
#include <boost/spirit/home/x3/support/traits/move_to.hpp>
#include <boost/spirit/home/x3/support/traits/variant_has_substitute.hpp>
#include <boost/spirit/home/x3/support/traits/variant_find_substitute.hpp>
#include <boost/spirit/home/x3/core/detail/parse_into_container.hpp>

#include <boost/mpl/if.hpp>

#include <boost/fusion/include/front.hpp>

#include <boost/type_traits/is_same.hpp>
#include <type_traits>

namespace boost { namespace spirit { namespace x3
{
    template <typename Left, typename Right>
    struct alternative;
}}}

namespace boost { namespace spirit { namespace x3 { namespace detail
{
    struct pass_variant_unused
    {
        typedef unused_type type;

template <typename T>
        static unused_type
        call(T&)
        {
            return unused_type();
        }
    };

template <typename Attribute>
    struct pass_variant_used
    {
        typedef Attribute& type;

static Attribute&
        call(Attribute& v)
        {
            return v;
        }
    };

template <>
    struct pass_variant_used<unused_type> : pass_variant_unused {};

template <typename Parser, typename Attribute, typename Context
      , typename Enable = void>
    struct pass_parser_attribute
    {
        typedef typename
            traits::attribute_of<Parser, Context>::type
        attribute_type;
        typedef typename
            traits::variant_find_substitute<Attribute, attribute_type>::type
        substitute_type;

typedef typename
            mpl::if_<
                is_same<Attribute, substitute_type>
              , Attribute&
              , substitute_type
            >::type
        type;

template <typename Attribute_>
        static Attribute_&
        call(Attribute_& attr, mpl::true_)
        {
            return attr;
        }

template <typename Attribute_>
        static type
        call(Attribute_&, mpl::false_)
        {
            return type();
        }

template <typename Attribute_>
        static type
        call(Attribute_& attr)
        {
            return call(attr, is_same<Attribute_, typename remove_reference<type>::type>());
        }
    };

// Pass non-variant attributes as-is
    template <typename Parser, typename Attribute, typename Context
      , typename Enable = void>
    struct pass_non_variant_attribute
    {
        typedef Attribute& type;

static Attribute&
        call(Attribute& attr)
        {
            return attr;
        }
    };

// Unwrap single element sequences
    template <typename Parser, typename Attribute, typename Context>
    struct pass_non_variant_attribute<Parser, Attribute, Context,
        typename enable_if<traits::is_size_one_sequence<Attribute>>::type>
    {
        typedef typename remove_reference<
            typename fusion::result_of::front<Attribute>::type>::type
        attr_type;

typedef pass_parser_attribute<Parser, attr_type, Context> pass;
        typedef typename pass::type type;

template <typename Attribute_>
        static type
        call(Attribute_& attr)
        {
            return pass::call(fusion::front(attr));
        }
    };

template <typename Parser, typename Attribute, typename Context>
    struct pass_parser_attribute<Parser, Attribute, Context,
        typename enable_if_c<(!traits::is_variant<Attribute>::value)>::type>
        : pass_non_variant_attribute<Parser, Attribute, Context>
    {};

template <typename Parser, typename Context>
    struct pass_parser_attribute<Parser, unused_type, Context>
        : pass_variant_unused {};

template <typename Parser, typename Attribute, typename Context>
    struct pass_variant_attribute :
        mpl::if_c<traits::has_attribute<Parser, Context>::value
          , pass_parser_attribute<Parser, Attribute, Context>
          , pass_variant_unused>::type
    {
    };

template <typename L, typename R, typename Attribute, typename Context>
    struct pass_variant_attribute<alternative<L, R>, Attribute, Context> :
        mpl::if_c<traits::has_attribute<alternative<L, R>, Context>::value
          , pass_variant_used<Attribute>
          , pass_variant_unused>::type
    {
    };

template <bool Condition>
    struct move_if
    {
        template<typename T1, typename T2>
        static void call(T1& /* attr_ */, T2& /* attr */) {}
    };

template <>
    struct move_if<true>
    {
        template<typename T1, typename T2>
        static void call(T1& attr_, T2& attr)
        {
            traits::move_to(attr_, attr);
        }
    };

template <typename Parser, typename Iterator, typename Context
      , typename RContext, typename Attribute>
    bool parse_alternative(Parser const& p, Iterator& first, Iterator const& last
      , Context const& context, RContext& rcontext, Attribute& attr)
    {
        using pass = detail::pass_variant_attribute<Parser, Attribute, Context>;
        using pseudo = traits::pseudo_attribute<Context, typename pass::type, Iterator>;

typename pseudo::type attr_ = pseudo::call(first, last, pass::call(attr));

if (p.parse(first, last, context, rcontext, attr_))
        {
            move_if<!std::is_reference<decltype(attr_)>::value>::call(attr_, attr);
            return true;
        }
        return false;
    }

template <typename Subject>
    struct alternative_helper : unary_parser<Subject, alternative_helper<Subject>>
    {
        static bool const is_pass_through_unary = true;

using unary_parser<Subject, alternative_helper<Subject>>::unary_parser;

template <typename Iterator, typename Context
          , typename RContext, typename Attribute>
        bool parse(Iterator& first, Iterator const& last
          , Context const& context, RContext& rcontext, Attribute& attr) const
        {
            return detail::parse_alternative(this->subject, first, last, context, rcontext, attr);
        }
    };

template <typename Left, typename Right, typename Context, typename RContext>
    struct parse_into_container_impl<alternative<Left, Right>, Context, RContext>
    {
        typedef alternative<Left, Right> parser_type;

template <typename Iterator, typename Attribute>
        static bool call(
            parser_type const& parser
          , Iterator& first, Iterator const& last
          , Context const& context, RContext& rcontext, Attribute& attr, mpl::false_)
        {
            return detail::parse_into_container(parser.left, first, last, context, rcontext, attr)
                || detail::parse_into_container(parser.right, first, last, context, rcontext, attr);
        }

template <typename Iterator, typename Attribute>
        static bool call(
            parser_type const& parser
          , Iterator& first, Iterator const& last
          , Context const& context, RContext& rcontext, Attribute& attr, mpl::true_)
        {
            return detail::parse_into_container(alternative_helper<Left>{parser.left}, first, last, context, rcontext, attr)
                || detail::parse_into_container(alternative_helper<Right>{parser.right}, first, last, context, rcontext, attr);
        }

template <typename Iterator, typename Attribute>
        static bool call(
            parser_type const& parser
          , Iterator& first, Iterator const& last
          , Context const& context, RContext& rcontext, Attribute& attr)
        {
            return call(parser, first, last, context, rcontext, attr,
                typename traits::is_variant<typename traits::container_value<Attribute>::type>::type{});
        }
    };

}}}}

#endif

/*============================================================================= Copyright (c) 2001-2014 Joel de Guzman 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(BOOST_SPIRIT_X3_ALTERNATIVE_DETAIL_JAN_07_2013_1245PM) #define BOOST_SPIRIT_X3_ALTERNATIVE_DETAIL_JAN_07_2013_1245PM #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace spirit { namespace x3 { template struct alternative; }}} namespace boost { namespace spirit { namespace x3 { namespace detail { struct pass_variant_unused { typedef unused_type type; template static unused_type call(T&) { return unused_type(); } }; template struct pass_variant_used { typedef Attribute& type; static Attribute& call(Attribute& v) { return v; } }; template <> struct pass_variant_used : pass_variant_unused {}; template struct pass_parser_attribute { typedef typename traits::attribute_of::type attribute_type; typedef typename traits::variant_find_substitute::type substitute_type; typedef typename mpl::if_< is_same , Attribute& , substitute_type >::type type; template static Attribute_& call(Attribute_& attr, mpl::true_) { return attr; } template static type call(Attribute_&, mpl::false_) { return type(); } template static type call(Attribute_& attr) { return call(attr, is_same::type>()); } }; // Pass non-variant attributes as-is template struct pass_non_variant_attribute { typedef Attribute& type; static Attribute& call(Attribute& attr) { return attr; } }; // Unwrap single element sequences template struct pass_non_variant_attribute>::type> { typedef typename remove_reference< typename fusion::result_of::front::type>::type attr_type; typedef pass_parser_attribute pass; typedef typename pass::type type; template static type call(Attribute_& attr) { return pass::call(fusion::front(attr)); } }; template struct pass_parser_attribute::value)>::type> : pass_non_variant_attribute {}; template struct pass_parser_attribute : pass_variant_unused {}; template struct pass_variant_attribute : mpl::if_c::value , pass_parser_attribute , pass_variant_unused>::type { }; template struct pass_variant_attribute, Attribute, Context> : mpl::if_c, Context>::value , pass_variant_used , pass_variant_unused>::type { }; template struct move_if { template static void call(T1& /* attr_ */, T2& /* attr */) {} }; template <> struct move_if { template static void call(T1& attr_, T2& attr) { traits::move_to(attr_, attr); } }; template bool parse_alternative(Parser const& p, Iterator& first, Iterator const& last , Context const& context, RContext& rcontext, Attribute& attr) { using pass = detail::pass_variant_attribute; using pseudo = traits::pseudo_attribute; typename pseudo::type attr_ = pseudo::call(first, last, pass::call(attr)); if (p.parse(first, last, context, rcontext, attr_)) { move_if::value>::call(attr_, attr); return true; } return false; } template struct alternative_helper : unary_parser> { static bool const is_pass_through_unary = true; using unary_parser>::unary_parser; template bool parse(Iterator& first, Iterator const& last , Context const& context, RContext& rcontext, Attribute& attr) const { return detail::parse_alternative(this->subject, first, last, context, rcontext, attr); } }; template struct parse_into_container_impl, Context, RContext> { typedef alternative parser_type; template static bool call( parser_type const& parser , Iterator& first, Iterator const& last , Context const& context, RContext& rcontext, Attribute& attr, mpl::false_) { return detail::parse_into_container(parser.left, first, last, context, rcontext, attr) || detail::parse_into_container(parser.right, first, last, context, rcontext, attr); } template static bool call( parser_type const& parser , Iterator& first, Iterator const& last , Context const& context, RContext& rcontext, Attribute& attr, mpl::true_) { return detail::parse_into_container(alternative_helper{parser.left}, first, last, context, rcontext, attr) || detail::parse_into_container(alternative_helper{parser.right}, first, last, context, rcontext, attr); } template static bool call( parser_type const& parser , Iterator& first, Iterator const& last , Context const& context, RContext& rcontext, Attribute& attr) { return call(parser, first, last, context, rcontext, attr, typename traits::is_variant::type>::type{}); } }; }}}} #endif