FM / operator

/usr/include/boost/spirit/home/qi/operator/

/usr/include/boost/spirit/home/qi/operator

Name	Size	Mode	Actions
alternative.hpp	4574	0644	edit dl rm
and_predicate.hpp	3325	0644	edit dl rm
difference.hpp	4154	0644	edit dl rm
expect.hpp	3403	0644	edit dl rm
kleene.hpp	4802	0644	edit dl rm
list.hpp	4751	0644	edit dl rm
not_predicate.hpp	3293	0644	edit dl rm
optional.hpp	5026	0644	edit dl rm
permutation.hpp	5614	0644	edit dl rm
plus.hpp	4359	0644	edit dl rm
sequence.hpp	3789	0644	edit dl rm
sequence_base.hpp	5443	0644	edit dl rm
sequential_or.hpp	5225	0644	edit dl rm

Edit: /usr/include/boost/spirit/home/qi/operator/sequence.hpp (3789B)

/*=============================================================================
    Copyright (c) 2001-2011 Joel de Guzman
    Copyright (c) 2001-2011 Hartmut Kaiser

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)
=============================================================================*/
#ifndef BOOST_SPIRIT_QI_OPERATOR_SEQUENCE_HPP
#define BOOST_SPIRIT_QI_OPERATOR_SEQUENCE_HPP

#if defined(_MSC_VER)
#pragma once
#endif

#include <boost/spirit/home/qi/operator/sequence_base.hpp>
#include <boost/spirit/home/qi/detail/fail_function.hpp>
#include <boost/spirit/home/qi/meta_compiler.hpp>
#include <boost/proto/operators.hpp>
#include <boost/proto/tags.hpp>

namespace boost { namespace spirit
{
    ///////////////////////////////////////////////////////////////////////////
    // Enablers
    ///////////////////////////////////////////////////////////////////////////
    template <>
    struct use_operator<qi::domain, proto::tag::shift_right> // enables >>
      : mpl::true_ {};

template <>
    struct flatten_tree<qi::domain, proto::tag::shift_right> // flattens >>
      : mpl::true_ {};
}}

namespace boost { namespace spirit { namespace qi
{
    template <typename Elements>
    struct sequence : sequence_base<sequence<Elements>, Elements>
    {
        friend struct sequence_base<sequence<Elements>, Elements>;

sequence(Elements const& elements)
          : sequence_base<sequence<Elements>, Elements>(elements) {}

private:

template <typename Iterator, typename Context, typename Skipper>
        static detail::fail_function<Iterator, Context, Skipper>
        fail_function(
            Iterator& first, Iterator const& last
          , Context& context, Skipper const& skipper)
        {
            return detail::fail_function<Iterator, Context, Skipper>
                (first, last, context, skipper);
        }

std::string id() const { return "sequence"; }
    };

///////////////////////////////////////////////////////////////////////////
    // Parser generators: make_xxx function (objects)
    ///////////////////////////////////////////////////////////////////////////
    template <typename Elements, typename Modifiers>
    struct make_composite<proto::tag::shift_right, Elements, Modifiers>
      : make_nary_composite<Elements, sequence>
    {};

//     ///////////////////////////////////////////////////////////////////////////
//     // Define what attributes are compatible with a sequence
//     template <typename Attribute, typename Elements, typename Context, typename Iterator>
//     struct is_attribute_compatible<Attribute, sequence<Elements>, Context, Iterator>
//       : mpl::or_<
//             is_convertible<Attribute
//               , typename traits::attribute_of<sequence<Elements>, Context, Iterator>::type> 
//           , traits::is_fusion_sequence_compatible<qi::domain, Attribute
//               , sequence<Elements>, Context, Iterator> 
//           , traits::is_container_compatible<qi::domain, Attribute
//               , sequence<Elements>, Context, Iterator>
//         >
//     {};
}}}

namespace boost { namespace spirit { namespace traits
{
    ///////////////////////////////////////////////////////////////////////////
    template <typename Elements>
    struct has_semantic_action<qi::sequence<Elements> >
      : nary_has_semantic_action<Elements> {};

///////////////////////////////////////////////////////////////////////////
    template <typename Elements, typename Attribute, typename Context
      , typename Iterator>
    struct handles_container<qi::sequence<Elements>, Attribute, Context
          , Iterator>
      : mpl::true_ {};
}}}

#endif

/*============================================================================= Copyright (c) 2001-2011 Joel de Guzman Copyright (c) 2001-2011 Hartmut Kaiser 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) =============================================================================*/ #ifndef BOOST_SPIRIT_QI_OPERATOR_SEQUENCE_HPP #define BOOST_SPIRIT_QI_OPERATOR_SEQUENCE_HPP #if defined(_MSC_VER) #pragma once #endif #include #include #include #include #include namespace boost { namespace spirit { /////////////////////////////////////////////////////////////////////////// // Enablers /////////////////////////////////////////////////////////////////////////// template <> struct use_operator // enables >> : mpl::true_ {}; template <> struct flatten_tree // flattens >> : mpl::true_ {}; }} namespace boost { namespace spirit { namespace qi { template struct sequence : sequence_base, Elements> { friend struct sequence_base, Elements>; sequence(Elements const& elements) : sequence_base, Elements>(elements) {} private: template static detail::fail_function fail_function( Iterator& first, Iterator const& last , Context& context, Skipper const& skipper) { return detail::fail_function (first, last, context, skipper); } std::string id() const { return "sequence"; } }; /////////////////////////////////////////////////////////////////////////// // Parser generators: make_xxx function (objects) /////////////////////////////////////////////////////////////////////////// template struct make_composite : make_nary_composite {}; // /////////////////////////////////////////////////////////////////////////// // // Define what attributes are compatible with a sequence // template // struct is_attribute_compatible, Context, Iterator> // : mpl::or_< // is_convertible, Context, Iterator>::type> // , traits::is_fusion_sequence_compatible, Context, Iterator> // , traits::is_container_compatible, Context, Iterator> // > // {}; }}} namespace boost { namespace spirit { namespace traits { /////////////////////////////////////////////////////////////////////////// template struct has_semantic_action > : nary_has_semantic_action {}; /////////////////////////////////////////////////////////////////////////// template struct handles_container, Attribute, Context , Iterator> : mpl::true_ {}; }}} #endif