| Current File : //proc/self/root/usr/include/boost/spirit/repository/home/qi/directive/kwd.hpp |
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2011 Thomas Bernard
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_KWD_NOVEMBER_14_2008_1148AM)
#define SPIRIT_KWD_NOVEMBER_14_2008_1148AM
#if defined(_MSC_VER)
#pragma once
#endif
#include <boost/spirit/home/qi/meta_compiler.hpp>
#include <boost/spirit/home/qi/parser.hpp>
#include <boost/spirit/home/qi/auxiliary/lazy.hpp>
#include <boost/spirit/home/qi/operator/kleene.hpp>
#include <boost/spirit/home/support/container.hpp>
#include <boost/spirit/home/qi/detail/attributes.hpp>
#include <boost/spirit/home/qi/detail/fail_function.hpp>
#include <boost/spirit/home/support/info.hpp>
#include <boost/spirit/repository/home/support/kwd.hpp>
#include <boost/fusion/include/at.hpp>
#include <boost/foreach.hpp>
#include <vector>
namespace boost { namespace spirit
{
///////////////////////////////////////////////////////////////////////////
// Enablers
///////////////////////////////////////////////////////////////////////////
template < typename T>
struct use_directive<qi::domain
, terminal_ex<repository::tag::kwd // enables kwd(key)[p]
, fusion::vector1<T > >
> : mpl::true_ {};
template < typename T>
struct use_directive<qi::domain
, terminal_ex<repository::tag::ikwd // enables ikwd(key)[p]
, fusion::vector1<T > >
> : mpl::true_ {};
template < typename T>
struct use_directive<qi::domain
, terminal_ex<repository::tag::dkwd // enables dkwd(key)[p]
, fusion::vector1<T > >
> : mpl::true_ {};
template < typename T>
struct use_directive<qi::domain
, terminal_ex<repository::tag::idkwd // enables idkwd(key)[p]
, fusion::vector1<T > >
> : mpl::true_ {};
template < typename T1, typename T2>
struct use_directive<qi::domain
, terminal_ex<repository::tag::kwd // enables kwd(key,exact)[p]
, fusion::vector2< T1, T2 > >
> : mpl::true_ {};
template < typename T1, typename T2>
struct use_directive<qi::domain
, terminal_ex<repository::tag::ikwd // enables ikwd(key,exact)[p]
, fusion::vector2< T1, T2 > >
> : mpl::true_ {};
template < typename T1, typename T2>
struct use_directive<qi::domain
, terminal_ex<repository::tag::dkwd // enables dkwd(key,exact)[p]
, fusion::vector2< T1, T2 > >
> : mpl::true_ {};
template < typename T1, typename T2>
struct use_directive<qi::domain
, terminal_ex<repository::tag::idkwd // enables idkwd(key,exact)[p]
, fusion::vector2< T1, T2 > >
> : mpl::true_ {};
template < typename T1, typename T2>
struct use_directive<qi::domain
, terminal_ex<repository::tag::kwd // enables kwd(min, max)[p]
, fusion::vector3< T1, T2, T2 > >
> : mpl::true_ {};
template < typename T1, typename T2>
struct use_directive<qi::domain
, terminal_ex<repository::tag::ikwd // enables ikwd(min, max)[p]
, fusion::vector3< T1, T2, T2 > >
> : mpl::true_ {};
template < typename T1, typename T2>
struct use_directive<qi::domain
, terminal_ex<repository::tag::dkwd // enables dkwd(min, max)[p]
, fusion::vector3< T1, T2, T2 > >
> : mpl::true_ {};
template < typename T1, typename T2>
struct use_directive<qi::domain
, terminal_ex<repository::tag::idkwd // enables idkwd(min, max)[p]
, fusion::vector3< T1, T2, T2 > >
> : mpl::true_ {};
template < typename T1, typename T2>
struct use_directive<qi::domain
, terminal_ex<repository::tag::kwd // enables kwd(min, inf)[p]
, fusion::vector3<T1, T2, inf_type > >
> : mpl::true_ {};
template < typename T1, typename T2>
struct use_directive<qi::domain
, terminal_ex<repository::tag::ikwd // enables ikwd(min, inf)[p]
, fusion::vector3<T1, T2, inf_type > >
> : mpl::true_ {};
template < typename T1, typename T2>
struct use_directive<qi::domain
, terminal_ex<repository::tag::dkwd // enables dkwd(min, inf)[p]
, fusion::vector3<T1, T2, inf_type > >
> : mpl::true_ {};
template < typename T1, typename T2>
struct use_directive<qi::domain
, terminal_ex<repository::tag::idkwd // enables idkwd(min, inf)[p]
, fusion::vector3<T1, T2, inf_type > >
> : mpl::true_ {};
/* template <> // enables *lazy* kwd(exact)[p]
struct use_lazy_directive<
qi::domain
, tag::kwd
, 1 // arity
> : mpl::true_ {};
template <> // enables *lazy* kwd(min, max)[p]
struct use_lazy_directive< // and kwd(min, inf)[p]
qi::domain
, tag::kwd
, 2 // arity
> : mpl::true_ {};
*/
}}
namespace boost { namespace spirit { namespace repository { namespace qi
{
using repository::kwd;
using repository::ikwd;
using repository::dkwd;
using repository::idkwd;
using spirit::inf;
using spirit::inf_type;
template <typename T>
struct kwd_pass_iterator // handles kwd(exact)[p]
{
kwd_pass_iterator() {}
bool flag_init() const { return true; }
bool register_successful_parse(bool &flag,T &i) const {
flag=true;
return true;
}
private:
// silence MSVC warning C4512: assignment operator could not be generated
kwd_pass_iterator& operator= (kwd_pass_iterator const&);
};
template <typename T>
struct kwd_exact_iterator // handles kwd(exact)[p]
{
kwd_exact_iterator(T const exact)
: exact(exact){}
typedef T type;
bool flag_init() const { return false; }
bool register_successful_parse(bool &flag,T &i) const {
i++;
if(i<exact)
{
flag=false;
return true;
}
else if(i==exact)
{
flag=true;
return true;
}
else
return flag=false;
}
T const exact;
private:
// silence MSVC warning C4512: assignment operator could not be generated
kwd_exact_iterator& operator= (kwd_exact_iterator const&);
};
template <typename T>
struct kwd_finite_iterator // handles kwd(min, max)[p]
{
kwd_finite_iterator(T const min, T const max)
: min BOOST_PREVENT_MACRO_SUBSTITUTION (min)
, max BOOST_PREVENT_MACRO_SUBSTITUTION (max)
{}
typedef T type;
bool flag_init() const { return min==0; }
bool register_successful_parse(bool &flag,T &i) const {
i++;
if(i<min)
{
flag=false;
return true;
}
else if(i>=min && i<=max)
{
return flag=true;
}
else
return flag=false;
}
T const min;
T const max;
private:
// silence MSVC warning C4512: assignment operator could not be generated
kwd_finite_iterator& operator= (kwd_finite_iterator const&);
};
template <typename T>
struct kwd_infinite_iterator // handles kwd(min, inf)[p]
{
kwd_infinite_iterator(T const min)
: min BOOST_PREVENT_MACRO_SUBSTITUTION (min) {}
typedef T type;
bool flag_init() const { return min==0; }
bool register_successful_parse(bool &flag,T &i) const {
i++;
flag = i>=min;
return true;
}
T const min;
private:
// silence MSVC warning C4512: assignment operator could not be generated
kwd_infinite_iterator& operator= (kwd_infinite_iterator const&);
};
// This class enables the transportation of parameters needed to call
// the occurence constraint checker from higher level calls
// It also serves to select the correct parse function call
// of the keyword parser. The implementation changes depending if it is
// called form a keyword parsing loop or not.
template <typename Skipper, typename NoCasePass>
struct skipper_keyword_marker
{
typedef NoCasePass no_case_pass;
skipper_keyword_marker(Skipper const &skipper,bool &flag,int &counter) :
skipper(skipper)
, flag(flag)
, counter(counter)
{}
const Skipper &skipper;
bool &flag;
int &counter;
};
template <typename Subject, typename KeywordType, typename LoopIter , typename NoCase, typename Distinct >
struct kwd_parser : spirit::qi::unary_parser<kwd_parser<Subject, KeywordType, LoopIter , NoCase, Distinct > >
{
struct kwd_parser_id;
typedef Subject subject_type;
typedef NoCase no_case_keyword;
typedef Distinct distinct;
typedef typename
remove_const<typename traits::char_type_of<KeywordType>::type>::type
char_type;
typedef std::basic_string<char_type> keyword_type;
template <typename Context, typename Iterator>
struct attribute
{
typedef typename
traits::build_std_vector<
typename traits::attribute_of<
Subject, Context, Iterator>::type
>::type
type;
};
kwd_parser(Subject const& subject
, typename add_reference<KeywordType>::type keyword
, LoopIter const& iter)
: subject(subject), iter(iter), keyword(keyword) {}
template<typename CharEncoding>
kwd_parser(Subject const& subject
, typename add_reference<KeywordType>::type keyword
, LoopIter const& iter, CharEncoding encoding)
: subject(subject), iter(iter), keyword(keyword,encoding) {}
// Call the subject parser on a non container attribute
template <typename Iterator, typename Context
, typename Skipper, typename Attribute>
bool parse_impl(Iterator& first, Iterator const& last
, Context& context, Skipper const& skipper
, Attribute& attr,mpl::false_) const
{
return subject.parse(first,last,context,skipper,attr);
}
// Call the subject parser on a container attribute
template <typename Iterator, typename Context
, typename Skipper, typename Attribute>
bool parse_impl(Iterator& first, Iterator const& last
, Context& context, Skipper const& skipper
, Attribute& attr,mpl::true_) const
{
// synthesized attribute needs to be default constructed
typename traits::container_value<Attribute>::type val =
typename traits::container_value<Attribute>::type();
Iterator save = first;
bool r = subject.parse(first,last,context,skipper, val);
if (r)
{
// push the parsed value into our attribute
r = traits::push_back(attr, val);
if (!r)
first = save;
}
return r;
}
template <typename Iterator, typename Context
, typename Skipper, typename Attribute,typename NoCasePass>
bool parse(Iterator& first, Iterator const& last
, Context& context, skipper_keyword_marker<Skipper,NoCasePass> const& skipper
, Attribute &attr) const
{
typedef typename traits::attribute_of<
Subject, Context, Iterator>::type
subject_attribute;
typedef typename mpl::and_<
traits::is_container<Attribute>
, mpl::not_< traits::is_weak_substitute< subject_attribute,Attribute > >
>::type predicate;
if((no_case_keyword::value && NoCasePass::value) || !NoCasePass::value)
{
if(parse_impl(first,last,context,skipper.skipper,attr, predicate()))
return iter.register_successful_parse(skipper.flag,skipper.counter);
}
return false;
}
template <typename Iterator, typename Context
, typename Skipper, typename Attribute>
bool parse(Iterator& first, Iterator const& last
, Context& context, Skipper const& skipper
, Attribute& attr) const
{
typedef typename traits::attribute_of<
Subject, Context, Iterator>::type
subject_attribute;
typedef typename mpl::and_<
traits::is_container<Attribute>
, mpl::not_< traits::is_weak_substitute< subject_attribute,Attribute > >
>::type predicate;
// Parse the keyword
bool flag = iter.flag_init();
int counter = 0;
Iterator save = first;
spirit::qi::skip_over(first, last, skipper);
if(keyword.parse(first,last,context,skipper,unused)){
if((!distinct::value) || skipper.parse(first,last,unused,unused,unused)){
// Followed by the subject parser
spirit::qi::skip_over(first, last, skipper);
if(parse_impl(first,last,context,skipper,attr, predicate()))
{
return iter.register_successful_parse(flag,counter);
}
}
}
first = save;
return flag;
}
template <typename Context>
info what(Context& context) const
{
if(distinct::value){
if(no_case_keyword::value)
return info("idkwd", subject.what(context));
else
return info("dkwd", subject.what(context));
}
else
{
if(no_case_keyword::value)
return info("ikwd", subject.what(context));
else
return info("kwd", subject.what(context));
}
}
Subject subject;
LoopIter iter;
typedef typename mpl::if_<
no_case_keyword,
spirit::qi::no_case_literal_string< KeywordType, true>,
spirit::qi::literal_string<KeywordType, true> >::type keyword_string_type;
keyword_string_type keyword;
private:
// silence MSVC warning C4512: assignment operator could not be generated
kwd_parser& operator= (kwd_parser const&);
template <typename Iterator, typename Context, typename Skipper>
static spirit::qi::detail::fail_function<Iterator, Context, Skipper>
fail_function(
Iterator& first, Iterator const& last
, Context& context, Skipper const& skipper)
{
return spirit::qi::detail::fail_function<Iterator, Context, Skipper>
(first, last, context, skipper);
}
};
template <typename Subject, typename KeywordType, typename LoopIter, typename Distinct>
struct complex_kwd_parser : spirit::qi::unary_parser<complex_kwd_parser<Subject, KeywordType, LoopIter, Distinct > >
{
struct complex_kwd_parser_id;
typedef Subject subject_type;
typedef Distinct distinct;
template <typename Context, typename Iterator>
struct attribute
{
typedef typename
traits::build_std_vector<
typename traits::attribute_of<
Subject, Context, Iterator>::type
>::type
type;
};
complex_kwd_parser(Subject const& subject
, typename add_reference<KeywordType>::type keyword
, LoopIter const& iter)
: subject(subject), iter(iter), keyword(keyword) {}
// Call the subject parser on a non container attribute
template <typename Iterator, typename Context
, typename Skipper, typename Attribute>
bool parse_impl(Iterator& first, Iterator const& last
, Context& context, Skipper const& skipper
, Attribute& attr,mpl::false_) const
{
return subject.parse(first,last,context,skipper,attr);
}
// Call the subject parser on a container attribute
template <typename Iterator, typename Context
, typename Skipper, typename Attribute>
bool parse_impl(Iterator& first, Iterator const& last
, Context& context, Skipper const& skipper
, Attribute& attr,mpl::true_) const
{
// synthesized attribute needs to be default constructed
typename traits::container_value<Attribute>::type val =
typename traits::container_value<Attribute>::type();
Iterator save = first;
bool r = subject.parse(first,last,context,skipper, val);
if (r)
{
// push the parsed value into our attribute
r = traits::push_back(attr, val);
if (!r)
first = save;
}
return r;
}
template <typename Iterator, typename Context
, typename Skipper, typename Attribute,typename NoCasePass>
bool parse(Iterator& first, Iterator const& last
, Context& context, skipper_keyword_marker<Skipper,NoCasePass> const& skipper
, Attribute &attr) const
{
typedef typename traits::attribute_of<
Subject, Context, Iterator>::type
subject_attribute;
typedef typename mpl::and_<
traits::is_container<Attribute>
, mpl::not_< traits::is_weak_substitute< subject_attribute,Attribute > >
>::type predicate;
if(parse_impl(first,last,context,skipper.skipper,attr, predicate()))
return iter.register_successful_parse(skipper.flag,skipper.counter);
return false;
}
template <typename Iterator, typename Context
, typename Skipper, typename Attribute>
bool parse(Iterator& first, Iterator const& last
, Context& context, Skipper const& skipper
, Attribute& attr) const
{
typedef typename traits::attribute_of<
Subject, Context, Iterator>::type
subject_attribute;
typedef typename mpl::and_<
traits::is_container<Attribute>
, mpl::not_< traits::is_weak_substitute< subject_attribute,Attribute > >
>::type predicate;
// Parse the keyword
bool flag = iter.flag_init();
int counter = 0;
Iterator save = first;
spirit::qi::skip_over(first, last, skipper);
if(keyword.parse(first,last,context,skipper,unused)){
if( !distinct::value || skipper.parse(first,last,unused,unused,unused)){
// Followed by the subject parser
spirit::qi::skip_over(first, last, skipper);
if(parse_impl(first,last,context,skipper,attr, predicate()))
{
return iter.register_successful_parse(flag,counter);
}
}
}
first = save;
return flag;
}
template <typename Context>
info what(Context& context) const
{
if(distinct::value)
return info("dkwd", subject.what(context));
else
return info("kwd", subject.what(context));
}
Subject subject;
LoopIter iter;
KeywordType keyword;
private:
// silence MSVC warning C4512: assignment operator could not be generated
complex_kwd_parser& operator= (complex_kwd_parser const&);
template <typename Iterator, typename Context, typename Skipper>
static spirit::qi::detail::fail_function<Iterator, Context, Skipper>
fail_function(
Iterator& first, Iterator const& last
, Context& context, Skipper const& skipper)
{
return spirit::qi::detail::fail_function<Iterator, Context, Skipper>
(first, last, context, skipper);
}
};
}}}}
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit { namespace qi
{
///////////////////////////////////////////////////////////////////////////
// Parser generators: make_xxx function (objects)
///////////////////////////////////////////////////////////////////////////
template <typename T1, typename T2, typename Subject, typename Modifiers, typename Distinct, typename MakeDirectiveHelper>
struct make_directive_internal_2_args
{
// is the keyword a string keyword ?
typedef typename traits::is_string<T1> is_string_kwd_type;
// make the keyword type
typedef typename mpl::if_< is_string_kwd_type ,
T1 ,
typename result_of::compile<qi::domain, T1>::type
>::type keyword_type;
typedef typename add_const<keyword_type>::type const_keyword;
// select the pass iterator type
typedef typename MakeDirectiveHelper::iterator_type iterator_type;
// determine if a no case modifier applies to the context
typedef has_modifier<Modifiers, tag::char_code_base<tag::no_case> > no_case;
// Determine the full type of the kwd / complex_kwd directive
typedef typename
mpl::if_<
is_string_kwd_type,
repository::qi::kwd_parser<Subject, const_keyword, iterator_type, no_case, Distinct >,
repository::qi::complex_kwd_parser<Subject, const_keyword, iterator_type, Distinct >
>::type result_type;
// Return a kwd parser object
template <typename Terminal>
result_type create_kwd_string(Terminal const &term, Subject const & subject, boost::mpl::true_ ) const
{
typename spirit::detail::get_encoding<Modifiers,
spirit::char_encoding::standard>::type encoding;
return result_type(subject
,MakeDirectiveHelper::make_iterator(term.args)
,encoding
);
}
template <typename Terminal>
result_type create_kwd_string(Terminal const &term, Subject const & subject, boost::mpl::false_ ) const
{
return result_type(subject
,fusion::at_c<0>(term.args)
,MakeDirectiveHelper::make_iterator(term.args)
);
}
template <typename Terminal>
result_type create_kwd(Terminal const &term, Subject const & subject, Modifiers const& modifiers, boost::mpl::true_ ) const
{
return create_kwd_string(term,subject,no_case());
}
// Return a complex_kwd parser object
template <typename Terminal>
result_type create_kwd(Terminal const &term , Subject const & subject, Modifiers const& modifiers, boost::mpl::false_ ) const
{
return result_type(subject
,compile<qi::domain>(fusion::at_c<0>(term.args),modifiers)
,MakeDirectiveHelper::make_iterator(term.args)
);
}
// Select which object type to return
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
{
return create_kwd(term, subject, modifiers, is_string_kwd_type());
}
};
// Directive kwd(key)[p]
template <typename T1, typename Subject, typename Modifiers, typename Distinct>
struct make_directive_internal
{
// is the keyword a string keyword ?
typedef typename traits::is_string<T1> is_string_kwd_type;
// make the keyword type
typedef typename mpl::if_< is_string_kwd_type ,
T1 ,
typename result_of::compile<qi::domain, T1, Modifiers>::type
>::type keyword_type;
typedef typename add_const<keyword_type>::type const_keyword;
// select the pass iterator type
typedef repository::qi::kwd_pass_iterator<int> iterator_type;
// determine if a no case modifier applies to the context
typedef has_modifier<Modifiers, tag::char_code_base<tag::no_case> > no_case;
// Determine the full type of the kwd / complex_kwd directive
typedef typename
mpl::if_<
is_string_kwd_type,
repository::qi::kwd_parser<Subject, const_keyword, iterator_type, no_case, Distinct >,
repository::qi::complex_kwd_parser<Subject, const_keyword, iterator_type, Distinct>
>::type result_type;
// Return a kwd parser object
template <typename Terminal>
result_type create_kwd_string(Terminal const &term, Subject const & subject, boost::mpl::true_) const
{
typename spirit::detail::get_encoding<Modifiers,
spirit::char_encoding::standard>::type encoding;
return result_type(subject
,fusion::at_c<0>(term.args)
,iterator_type()
,encoding
);
}
template <typename Terminal>
result_type create_kwd_string(Terminal const &term, Subject const & subject, boost::mpl::false_) const
{
return result_type(subject
,fusion::at_c<0>(term.args)
,iterator_type()
);
}
template <typename Terminal>
result_type create_kwd(Terminal const &term, Subject const & subject, Modifiers const& modifiers, boost::mpl::true_ ) const
{
return create_kwd_string(term,subject,no_case());
}
// Return a complex_kwd parser object
template <typename Terminal>
result_type create_kwd(Terminal const &term , Subject const & subject, Modifiers const& modifiers, boost::mpl::false_ ) const
{
return result_type(subject
,compile<qi::domain>(fusion::at_c<0>(term.args),modifiers)
,iterator_type()
);
}
// Select which object type to return
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, Modifiers const& modifiers ) const
{
return create_kwd(term, subject, modifiers, is_string_kwd_type());
}
};
template <typename T1, typename Subject, typename Modifiers>
struct make_directive<
terminal_ex<repository::tag::kwd, fusion::vector1<T1> >, Subject, Modifiers>
{
typedef make_directive_internal<T1, Subject, Modifiers, mpl::false_> make_directive_type;
typedef typename make_directive_type::result_type result_type;
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
{
return make_directive_type()(term, subject, modifiers);
}
};
template <typename T1, typename Subject, typename Modifiers>
struct make_directive<
terminal_ex<repository::tag::dkwd, fusion::vector1<T1> >, Subject, Modifiers>
{
typedef make_directive_internal<T1, Subject, Modifiers, mpl::true_> make_directive_type;
typedef typename make_directive_type::result_type result_type;
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
{
return make_directive_type()(term, subject, modifiers);
}
};
// Directive ikwd(key)[p]
template <typename T1, typename Subject, typename Modifiers>
struct make_directive<
terminal_ex<repository::tag::ikwd, fusion::vector1<T1> >, Subject, Modifiers>
{
typedef typename add_const<T1>::type const_keyword;
typedef repository::qi::kwd_pass_iterator<int> iterator_type;
typedef repository::qi::kwd_parser<Subject, const_keyword, iterator_type, mpl::true_, mpl::false_ > result_type;
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, unused_type) const
{
typename spirit::detail::get_encoding<Modifiers,
spirit::char_encoding::standard>::type encoding;
return result_type(subject
,fusion::at_c<0>(term.args)
,iterator_type()
,encoding
);
}
};
template <typename T1, typename Subject, typename Modifiers>
struct make_directive<
terminal_ex<repository::tag::idkwd, fusion::vector1<T1> >, Subject, Modifiers>
{
typedef typename add_const<T1>::type const_keyword;
typedef repository::qi::kwd_pass_iterator<int> iterator_type;
typedef repository::qi::kwd_parser<Subject, const_keyword, iterator_type, mpl::true_, mpl::true_ > result_type;
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, unused_type) const
{
typename spirit::detail::get_encoding<Modifiers,
spirit::char_encoding::standard>::type encoding;
return result_type(subject
,fusion::at_c<0>(term.args)
,iterator_type()
,encoding
);
}
};
// Directive kwd(key,exact)[p]
template <typename T>
struct make_exact_helper
{
typedef repository::qi::kwd_exact_iterator<T> iterator_type;
template<typename Args>
static iterator_type make_iterator(Args const& args)
{
return iterator_type(fusion::at_c<1>(args));
}
};
template <typename T1, typename T2, typename Subject, typename Modifiers>
struct make_directive<
terminal_ex<repository::tag::kwd, fusion::vector2<T1,T2> >, Subject, Modifiers>
{
typedef make_directive_internal_2_args< T1
, T2
, Subject
, Modifiers
, mpl::false_
, make_exact_helper<T2>
> make_directive_type;
typedef typename make_directive_type::result_type result_type;
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
{
return make_directive_type()(term,subject, modifiers);
}
};
template <typename T1, typename T2, typename Subject, typename Modifiers>
struct make_directive<
terminal_ex<repository::tag::dkwd, fusion::vector2<T1,T2> >, Subject, Modifiers>
{
typedef make_directive_internal_2_args< T1
, T2
, Subject
, Modifiers
, mpl::true_
, make_exact_helper<T2>
> make_directive_type;
typedef typename make_directive_type::result_type result_type;
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
{
return make_directive_type()(term, subject, modifiers);
}
};
// Directive ikwd(key,exact)[p]
template <typename T1, typename T2, typename Subject, typename Modifiers>
struct make_directive<
terminal_ex<repository::tag::ikwd, fusion::vector2<T1,T2> >, Subject, Modifiers>
{
typedef typename add_const<T1>::type const_keyword;
typedef repository::qi::kwd_exact_iterator<T2> iterator_type;
typedef repository::qi::kwd_parser<Subject, const_keyword, iterator_type, mpl::true_, mpl::false_ > result_type;
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
{
typename spirit::detail::get_encoding<Modifiers,
spirit::char_encoding::standard>::type encoding;
return result_type(subject
,fusion::at_c<0>(term.args)
,fusion::at_c<1>(term.args)
, encoding
);
}
};
template <typename T1, typename T2, typename Subject, typename Modifiers>
struct make_directive<
terminal_ex<repository::tag::idkwd, fusion::vector2<T1,T2> >, Subject, Modifiers>
{
typedef typename add_const<T1>::type const_keyword;
typedef repository::qi::kwd_exact_iterator<T2> iterator_type;
typedef repository::qi::kwd_parser<Subject, const_keyword, iterator_type, mpl::true_, mpl::true_ > result_type;
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
{
typename spirit::detail::get_encoding<Modifiers,
spirit::char_encoding::standard>::type encoding;
return result_type(subject
, fusion::at_c<0>(term.args)
, fusion::at_c<1>(term.args)
, encoding
);
}
};
// Directive kwd(min, max)[p]
template <typename T>
struct make_finite_helper
{
typedef repository::qi::kwd_finite_iterator<T> iterator_type;
template<typename Args>
static iterator_type make_iterator(Args const& args)
{
return iterator_type(fusion::at_c<1>(args),fusion::at_c<2>(args));
}
};
template <typename T1, typename T2, typename Subject, typename Modifiers>
struct make_directive<
terminal_ex<repository::tag::kwd, fusion::vector3< T1, T2, T2> >, Subject, Modifiers>
{
typedef make_directive_internal_2_args< T1
, T2
, Subject
, Modifiers
, mpl::false_
, make_finite_helper<T2>
> make_directive_type;
typedef typename make_directive_type::result_type result_type;
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
{
return make_directive_type()(term,subject, modifiers);
}
};
template <typename T1, typename T2, typename Subject, typename Modifiers>
struct make_directive<
terminal_ex<repository::tag::dkwd, fusion::vector3<T1,T2,T2> >, Subject, Modifiers>
{
typedef make_directive_internal_2_args< T1
, T2
, Subject
, Modifiers
, mpl::true_
, make_finite_helper<T2>
> make_directive_type;
typedef typename make_directive_type::result_type result_type;
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, Modifiers const& modifiers) const
{
return make_directive_type()(term,subject, modifiers);
}
};
// Directive ikwd(min, max)[p]
template <typename T1, typename T2, typename Subject, typename Modifiers>
struct make_directive<
terminal_ex<repository::tag::ikwd, fusion::vector3< T1, T2, T2> >, Subject, Modifiers>
{
typedef typename add_const<T1>::type const_keyword;
typedef repository::qi::kwd_finite_iterator<T2> iterator_type;
typedef repository::qi::kwd_parser<Subject, const_keyword, iterator_type, mpl::true_, mpl::false_ > result_type;
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, unused_type) const
{
typename spirit::detail::get_encoding<Modifiers,
spirit::char_encoding::standard>::type encoding;
return result_type(subject, fusion::at_c<0>(term.args),
iterator_type(
fusion::at_c<1>(term.args)
, fusion::at_c<2>(term.args)
, encoding
)
);
}
};
template <typename T1, typename T2, typename Subject, typename Modifiers>
struct make_directive<
terminal_ex<repository::tag::idkwd, fusion::vector3< T1, T2, T2> >, Subject, Modifiers>
{
typedef typename add_const<T1>::type const_keyword;
typedef repository::qi::kwd_finite_iterator<T2> iterator_type;
typedef repository::qi::kwd_parser<Subject, const_keyword, iterator_type, mpl::true_, mpl::true_ > result_type;
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, unused_type) const
{
typename spirit::detail::get_encoding<Modifiers,
spirit::char_encoding::standard>::type encoding;
return result_type(subject, fusion::at_c<0>(term.args),
iterator_type(
fusion::at_c<1>(term.args)
, fusion::at_c<2>(term.args)
, encoding
)
);
}
};
// Directive kwd(min, inf)[p]
template <typename T>
struct make_infinite_helper
{
typedef repository::qi::kwd_infinite_iterator<T> iterator_type;
template<typename Args>
static iterator_type make_iterator(Args const& args)
{
return iterator_type(fusion::at_c<1>(args));
}
};
template <typename T1, typename T2, typename Subject, typename Modifiers>
struct make_directive<
terminal_ex<repository::tag::kwd, fusion::vector3<T1,T2,inf_type> >, Subject, Modifiers>
{
typedef make_directive_internal_2_args< T1
, T2
, Subject
, Modifiers
, mpl::false_
, make_infinite_helper<T2>
> make_directive_type;
typedef typename make_directive_type::result_type result_type;
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, unused_type) const
{
return make_directive_type()(term,subject, unused_type());
}
};
template <typename T1, typename T2, typename Subject, typename Modifiers>
struct make_directive<
terminal_ex<repository::tag::dkwd, fusion::vector3<T1,T2,inf_type> >, Subject, Modifiers>
{
typedef make_directive_internal_2_args< T1
, T2
, Subject
, Modifiers
, mpl::false_
, make_infinite_helper<T2>
> make_directive_type;
typedef typename make_directive_type::result_type result_type;
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, unused_type) const
{
return make_directive_type()(term,subject, unused_type());
}
};
// Directive ikwd(min, inf)[p]
template <typename T1, typename T2, typename Subject, typename Modifiers>
struct make_directive<
terminal_ex<repository::tag::ikwd
, fusion::vector3<T1, T2, inf_type> >, Subject, Modifiers>
{
typedef typename add_const<T1>::type const_keyword;
typedef repository::qi::kwd_infinite_iterator<T2> iterator_type;
typedef repository::qi::kwd_parser<Subject, const_keyword, iterator_type, mpl::true_, mpl::false_ > result_type;
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, unused_type) const
{
typename spirit::detail::get_encoding<Modifiers,
spirit::char_encoding::standard>::type encoding;
return result_type(subject
, fusion::at_c<0>(term.args)
, fusion::at_c<1>(term.args)
, encoding
);
}
};
template <typename T1, typename T2, typename Subject, typename Modifiers>
struct make_directive<
terminal_ex<repository::tag::idkwd
, fusion::vector3<T1, T2, inf_type> >, Subject, Modifiers>
{
typedef typename add_const<T1>::type const_keyword;
typedef repository::qi::kwd_infinite_iterator<T2> iterator_type;
typedef repository::qi::kwd_parser<Subject, const_keyword, iterator_type, mpl::true_, mpl::true_ > result_type;
template <typename Terminal>
result_type operator()(
Terminal const& term, Subject const& subject, unused_type) const
{
typename spirit::detail::get_encoding<Modifiers,
spirit::char_encoding::standard>::type encoding;
return result_type(subject
, fusion::at_c<0>(term.args)
, fusion::at_c<1>(term.args)
, encoding
);
}
};
}}}
namespace boost { namespace spirit { namespace traits
{
template <typename Subject, typename KeywordType
, typename LoopIter, typename NoCase , typename Distinct>
struct has_semantic_action<
repository::qi::kwd_parser< Subject, KeywordType, LoopIter, NoCase, Distinct > >
: unary_has_semantic_action<Subject> {};
template <typename Subject, typename KeywordType
, typename LoopIter, typename Distinct >
struct has_semantic_action<
repository::qi::complex_kwd_parser< Subject, KeywordType, LoopIter, Distinct > >
: unary_has_semantic_action<Subject> {};
template <typename Subject, typename KeywordType
, typename LoopIter, typename NoCase, typename Attribute, typename Context
, typename Iterator, typename Distinct>
struct handles_container<repository::qi::kwd_parser<Subject, KeywordType, LoopIter, NoCase, Distinct>, Attribute
, Context, Iterator>
: unary_handles_container<Subject, Attribute, Context, Iterator> {};
template <typename Subject, typename KeywordType
, typename LoopIter
, typename Attribute, typename Context
, typename Iterator, typename Distinct>
struct handles_container<repository::qi::complex_kwd_parser<Subject, KeywordType, LoopIter, Distinct>, Attribute
, Context, Iterator>
: unary_handles_container<Subject, Attribute, Context, Iterator> {};
}}}
#endif