/usr/include/boost/spirit/home/qi/string
Edit: /usr/include/boost/spirit/home/qi/string/symbols.hpp (12987B)
/*=============================================================================
Copyright (c) 2001-2011 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_SYMBOLS_MARCH_11_2007_1055AM)
#define BOOST_SPIRIT_SYMBOLS_MARCH_11_2007_1055AM
#if defined(_MSC_VER)
#pragma once
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#if defined(BOOST_MSVC)
# pragma warning(push)
# pragma warning(disable: 4355) // 'this' : used in base member initializer list warning
#endif
namespace boost { namespace spirit { namespace qi
{
template <
typename Char = char
, typename T = unused_type
, typename Lookup = tst
, typename Filter = tst_pass_through>
struct symbols
: proto::extends<
typename proto::terminal<
reference >
>::type
, symbols
>
, primitive_parser >
{
typedef Char char_type; // the character type
typedef T value_type; // the value associated with each entry
typedef symbols this_type;
typedef reference reference_;
typedef typename proto::terminal::type terminal;
typedef proto::extends base_type;
template
struct attribute
{
typedef value_type type;
};
symbols(std::string const& name = "symbols")
: base_type(terminal::make(reference_(*this)))
, add(*this)
, remove(*this)
, lookup(new Lookup())
, name_(name)
{
}
symbols(symbols const& syms)
: base_type(terminal::make(reference_(*this)))
, add(*this)
, remove(*this)
, lookup(syms.lookup)
, name_(syms.name_)
{
}
template
symbols(symbols const& syms)
: base_type(terminal::make(reference_(*this)))
, add(*this)
, remove(*this)
, lookup(syms.lookup)
, name_(syms.name_)
{
}
template
symbols(Symbols const& syms, std::string const& name = "symbols")
: base_type(terminal::make(reference_(*this)))
, add(*this)
, remove(*this)
, lookup(new Lookup())
, name_(name)
{
typename range_const_iterator::type si = boost::begin(syms);
while (si != boost::end(syms))
add(*si++);
}
template
symbols(Symbols const& syms, Data const& data
, std::string const& name = "symbols")
: base_type(terminal::make(reference_(*this)))
, add(*this)
, remove(*this)
, lookup(new Lookup())
, name_(name)
{
typename range_const_iterator::type si = boost::begin(syms);
typename range_const_iterator::type di = boost::begin(data);
while (si != boost::end(syms))
add(*si++, *di++);
}
symbols&
operator=(symbols const& rhs)
{
name_ = rhs.name_;
*lookup = *rhs.lookup;
return *this;
}
template
symbols&
operator=(symbols const& rhs)
{
name_ = rhs.name_;
*lookup = *rhs.lookup;
return *this;
}
void clear()
{
lookup->clear();
}
struct adder;
struct remover;
template
adder const&
operator=(Str const& str)
{
lookup->clear();
return add(str);
}
template
friend adder const&
operator+=(symbols& sym, Str const& str)
{
return sym.add(str);
}
template
friend remover const&
operator-=(symbols& sym, Str const& str)
{
return sym.remove(str);
}
#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
// non-const version needed to suppress proto's += kicking in
template
friend adder const&
operator+=(symbols& sym, Str& str)
{
return sym.add(str);
}
// non-const version needed to suppress proto's -= kicking in
template
friend remover const&
operator-=(symbols& sym, Str& str)
{
return sym.remove(str);
}
#else
// for rvalue references
template
friend adder const&
operator+=(symbols& sym, Str&& str)
{
return sym.add(str);
}
// for rvalue references
template
friend remover const&
operator-=(symbols& sym, Str&& str)
{
return sym.remove(str);
}
#endif
template
void for_each(F f) const
{
lookup->for_each(f);
}
template
value_type& at(Str const& str)
{
return *lookup->add(traits::get_begin(str)
, traits::get_end(str), T());
}
template
value_type* prefix_find(Iterator& first, Iterator const& last)
{
return lookup->find(first, last, Filter());
}
template
value_type const* prefix_find(Iterator& first, Iterator const& last) const
{
return lookup->find(first, last, Filter());
}
template
value_type* find(Str const& str)
{
return find_impl(traits::get_begin(str)
, traits::get_end(str));
}
template
value_type const* find(Str const& str) const
{
return find_impl(traits::get_begin(str)
, traits::get_end(str));
}
private:
template
value_type* find_impl(Iterator begin, Iterator end)
{
value_type* r = lookup->find(begin, end, Filter());
return begin == end ? r : 0;
}
template
value_type const* find_impl(Iterator begin, Iterator end) const
{
value_type const* r = lookup->find(begin, end, Filter());
return begin == end ? r : 0;
}
public:
template
bool parse(Iterator& first, Iterator const& last
, Context& /*context*/, Skipper const& skipper, Attribute& attr_) const
{
qi::skip_over(first, last, skipper);
if (value_type* val_ptr
= lookup->find(first, last, Filter()))
{
spirit::traits::assign_to(*val_ptr, attr_);
return true;
}
return false;
}
template
info what(Context& /*context*/) const
{
return info(name_);
}
void name(std::string const &str)
{
name_ = str;
}
std::string const &name() const
{
return name_;
}
struct adder
{
template
struct result { typedef adder const& type; };
adder(symbols& sym_)
: sym(sym_)
{
}
template
adder const&
operator()(Iterator const& first, Iterator const& last, T const& val) const
{
sym.lookup->add(first, last, val);
return *this;
}
template
adder const&
operator()(Str const& s, T const& val = T()) const
{
sym.lookup->add(traits::get_begin(s)
, traits::get_end(s), val);
return *this;
}
template
adder const&
operator,(Str const& s) const
{
sym.lookup->add(traits::get_begin(s)
, traits::get_end(s), T());
return *this;
}
symbols& sym;
// silence MSVC warning C4512: assignment operator could not be generated
BOOST_DELETED_FUNCTION(adder& operator= (adder const&))
};
struct remover
{
template
struct result { typedef remover const& type; };
remover(symbols& sym_)
: sym(sym_)
{
}
template
remover const&
operator()(Iterator const& first, Iterator const& last) const
{
sym.lookup->remove(first, last);
return *this;
}
template
remover const&
operator()(Str const& s) const
{
sym.lookup->remove(traits::get_begin(s)
, traits::get_end(s));
return *this;
}
template
remover const&
operator,(Str const& s) const
{
sym.lookup->remove(traits::get_begin(s)
, traits::get_end(s));
return *this;
}
symbols& sym;
// silence MSVC warning C4512: assignment operator could not be generated
BOOST_DELETED_FUNCTION(remover& operator= (remover const&))
};
adder add;
remover remove;
shared_ptr lookup;
std::string name_;
};
///////////////////////////////////////////////////////////////////////////
// Parser generators: make_xxx function (objects)
///////////////////////////////////////////////////////////////////////////
template
struct make_primitive >, Modifiers>
{
template
struct no_case_filter
{
Char operator()(Char ch) const
{
return static_cast(CharEncoding::tolower(ch));
}
};
typedef has_modifier > no_case;
typedef reference > reference_;
typedef no_case_filter<
typename spirit::detail::get_encoding_with_case<
Modifiers
, char_encoding::standard
, no_case::value>::type>
nc_filter;
typedef typename mpl::if_<
no_case
, symbols
, reference_>::type
result_type;
result_type operator()(reference_ ref, unused_type) const
{
return result_type(ref.ref.get());
}
};
}}}
namespace boost { namespace spirit { namespace traits
{
///////////////////////////////////////////////////////////////////////////
template
struct handles_container, Attr, Context, Iterator>
: traits::is_container {};
}}}
#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif
#endif