boost/spirit/home/classic/utility/distinct.hpp
/*=============================================================================
Copyright (c) 1998-2003 Joel de Guzman
Copyright (c) 2003 Vaclav Vesely
http://spirit.sourceforge.net/
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_DISTINCT_HPP)
#define BOOST_SPIRIT_DISTINCT_HPP
#include <boost/spirit/home/classic/core/parser.hpp>
#include <boost/spirit/home/classic/core/primitives/primitives.hpp>
#include <boost/spirit/home/classic/core/composite/operators.hpp>
#include <boost/spirit/home/classic/core/composite/directives.hpp>
#include <boost/spirit/home/classic/core/composite/epsilon.hpp>
#include <boost/spirit/home/classic/core/non_terminal/rule.hpp>
#include <boost/spirit/home/classic/utility/chset.hpp>
#include <boost/spirit/home/classic/utility/distinct_fwd.hpp>
namespace boost {
namespace spirit {
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
//-----------------------------------------------------------------------------
// distinct_parser class
template <typename CharT, typename TailT>
class distinct_parser
{
public:
typedef
contiguous<
sequence<
chseq<CharT const*>,
negated_empty_match_parser<
TailT
>
>
>
result_t;
distinct_parser()
: tail(chset<CharT>())
{
}
explicit distinct_parser(parser<TailT> const & tail_)
: tail(tail_.derived())
{
}
explicit distinct_parser(CharT const* letters)
: tail(chset_p(letters))
{
}
result_t operator()(CharT const* str) const
{
return lexeme_d[chseq_p(str) >> ~epsilon_p(tail)];
}
TailT tail;
};
//-----------------------------------------------------------------------------
// distinct_directive class
template <typename CharT, typename TailT>
class distinct_directive
{
public:
template<typename ParserT>
struct result {
typedef
contiguous<
sequence<
ParserT,
negated_empty_match_parser<
TailT
>
>
>
type;
};
distinct_directive()
: tail(chset<CharT>())
{
}
explicit distinct_directive(CharT const* letters)
: tail(chset_p(letters))
{
}
explicit distinct_directive(parser<TailT> const & tail_)
: tail(tail_.derived())
{
}
template<typename ParserT>
typename result<typename as_parser<ParserT>::type>::type
operator[](ParserT const &subject) const
{
return
lexeme_d[as_parser<ParserT>::convert(subject) >> ~epsilon_p(tail)];
}
TailT tail;
};
//-----------------------------------------------------------------------------
// dynamic_distinct_parser class
template <typename ScannerT>
class dynamic_distinct_parser
{
public:
typedef typename ScannerT::value_t char_t;
typedef
rule<
typename no_actions_scanner<
typename lexeme_scanner<ScannerT>::type
>::type
>
tail_t;
typedef
contiguous<
sequence<
chseq<char_t const*>,
negated_empty_match_parser<
tail_t
>
>
>
result_t;
dynamic_distinct_parser()
: tail(nothing_p)
{
}
template<typename ParserT>
explicit dynamic_distinct_parser(parser<ParserT> const & tail_)
: tail(tail_.derived())
{
}
explicit dynamic_distinct_parser(char_t const* letters)
: tail(chset_p(letters))
{
}
result_t operator()(char_t const* str) const
{
return lexeme_d[chseq_p(str) >> ~epsilon_p(tail)];
}
tail_t tail;
};
//-----------------------------------------------------------------------------
// dynamic_distinct_directive class
template <typename ScannerT>
class dynamic_distinct_directive
{
public:
typedef typename ScannerT::value_t char_t;
typedef
rule<
typename no_actions_scanner<
typename lexeme_scanner<ScannerT>::type
>::type
>
tail_t;
template<typename ParserT>
struct result {
typedef
contiguous<
sequence<
ParserT,
negated_empty_match_parser<
tail_t
>
>
>
type;
};
dynamic_distinct_directive()
: tail(nothing_p)
{
}
template<typename ParserT>
explicit dynamic_distinct_directive(parser<ParserT> const & tail_)
: tail(tail_.derived())
{
}
explicit dynamic_distinct_directive(char_t const* letters)
: tail(chset_p(letters))
{
}
template<typename ParserT>
typename result<typename as_parser<ParserT>::type>::type
operator[](ParserT const &subject) const
{
return
lexeme_d[as_parser<ParserT>::convert(subject) >> ~epsilon_p(tail)];
}
tail_t tail;
};
//-----------------------------------------------------------------------------
BOOST_SPIRIT_CLASSIC_NAMESPACE_END
} // namespace spirit
} // namespace boost
#endif // !defined(BOOST_SPIRIT_DISTINCT_HPP)