| /*============================================================================= |
| Copyright (c) 2001-2014 Joel de Guzman |
| Copyright (c) 2013 Carl Barron |
| |
| 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_SYMBOLS_MARCH_11_2007_1055AM) |
| #define BOOST_SPIRIT_X3_SYMBOLS_MARCH_11_2007_1055AM |
| |
| #include <boost/spirit/home/x3/core/skip_over.hpp> |
| #include <boost/spirit/home/x3/core/parser.hpp> |
| #include <boost/spirit/home/x3/string/tst.hpp> |
| #include <boost/spirit/home/x3/support/unused.hpp> |
| #include <boost/spirit/home/x3/support/traits/string_traits.hpp> |
| #include <boost/spirit/home/x3/support/traits/move_to.hpp> |
| #include <boost/spirit/home/x3/support/no_case.hpp> |
| |
| #include <boost/spirit/home/support/char_encoding/ascii.hpp> |
| #include <boost/spirit/home/support/char_encoding/iso8859_1.hpp> |
| #include <boost/spirit/home/support/char_encoding/standard.hpp> |
| #include <boost/spirit/home/support/char_encoding/standard_wide.hpp> |
| |
| #include <initializer_list> |
| #include <iterator> // std::begin |
| #include <memory> // std::shared_ptr |
| #include <type_traits> |
| |
| #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 x3 |
| { |
| template < |
| typename Encoding |
| , typename T = unused_type |
| , typename Lookup = tst<typename Encoding::char_type, T> > |
| struct symbols_parser : parser<symbols_parser<Encoding, T, Lookup>> |
| { |
| typedef typename Encoding::char_type char_type; // the character type |
| typedef Encoding encoding; |
| typedef T value_type; // the value associated with each entry |
| typedef value_type attribute_type; |
| |
| static bool const has_attribute = |
| !std::is_same<unused_type, attribute_type>::value; |
| static bool const handles_container = |
| traits::is_container<attribute_type>::value; |
| |
| symbols_parser(std::string const& name = "symbols") |
| : add{*this} |
| , remove{*this} |
| , lookup(std::make_shared<Lookup>()) |
| , name_(name) |
| { |
| } |
| |
| symbols_parser(symbols_parser const& syms) |
| : add{*this} |
| , remove{*this} |
| , lookup(syms.lookup) |
| , name_(syms.name_) |
| { |
| } |
| |
| template <typename Symbols> |
| symbols_parser(Symbols const& syms, std::string const& name = "symbols") |
| : symbols_parser(name) |
| { |
| for (auto& sym : syms) |
| add(sym); |
| } |
| |
| template <typename Symbols, typename Data> |
| symbols_parser(Symbols const& syms, Data const& data |
| , std::string const& name = "symbols") |
| : symbols_parser(name) |
| { |
| using std::begin; |
| auto di = begin(data); |
| for (auto& sym : syms) |
| add(sym, *di++); |
| } |
| |
| symbols_parser(std::initializer_list<std::pair<char_type const*, T>> syms |
| , std::string const & name="symbols") |
| : symbols_parser(name) |
| { |
| for (auto& sym : syms) |
| add(sym.first, sym.second); |
| } |
| |
| symbols_parser(std::initializer_list<char_type const*> syms |
| , std::string const &name="symbols") |
| : symbols_parser(name) |
| { |
| for (auto str : syms) |
| add(str); |
| } |
| |
| symbols_parser& |
| operator=(symbols_parser const& rhs) |
| { |
| name_ = rhs.name_; |
| lookup = rhs.lookup; |
| return *this; |
| } |
| |
| void clear() |
| { |
| lookup->clear(); |
| } |
| |
| struct adder; |
| struct remover; |
| |
| template <typename Str> |
| adder const& |
| operator=(Str const& str) |
| { |
| lookup->clear(); |
| return add(str); |
| } |
| |
| template <typename Str> |
| friend adder const& |
| operator+=(symbols_parser& sym, Str const& str) |
| { |
| return sym.add(str); |
| } |
| |
| template <typename Str> |
| friend remover const& |
| operator-=(symbols_parser& sym, Str const& str) |
| { |
| return sym.remove(str); |
| } |
| |
| template <typename F> |
| void for_each(F f) const |
| { |
| lookup->for_each(f); |
| } |
| |
| template <typename Str> |
| value_type& at(Str const& str) |
| { |
| return *lookup->add(traits::get_string_begin<char_type>(str) |
| , traits::get_string_end<char_type>(str), T()); |
| } |
| |
| template <typename Iterator> |
| value_type* prefix_find(Iterator& first, Iterator const& last) |
| { |
| return lookup->find(first, last, case_compare<Encoding>()); |
| } |
| |
| template <typename Iterator> |
| value_type const* prefix_find(Iterator& first, Iterator const& last) const |
| { |
| return lookup->find(first, last, case_compare<Encoding>()); |
| } |
| |
| template <typename Str> |
| value_type* find(Str const& str) |
| { |
| return find_impl(traits::get_string_begin<char_type>(str) |
| , traits::get_string_end<char_type>(str)); |
| } |
| |
| template <typename Str> |
| value_type const* find(Str const& str) const |
| { |
| return find_impl(traits::get_string_begin<char_type>(str) |
| , traits::get_string_end<char_type>(str)); |
| } |
| |
| private: |
| |
| template <typename Iterator> |
| value_type* find_impl(Iterator begin, Iterator end) |
| { |
| value_type* r = lookup->find(begin, end, case_compare<Encoding>()); |
| return begin == end ? r : 0; |
| } |
| |
| template <typename Iterator> |
| value_type const* find_impl(Iterator begin, Iterator end) const |
| { |
| value_type const* r = lookup->find(begin, end, case_compare<Encoding>()); |
| return begin == end ? r : 0; |
| } |
| |
| public: |
| |
| template <typename Iterator, typename Context, typename Attribute> |
| bool parse(Iterator& first, Iterator const& last |
| , Context const& context, unused_type, Attribute& attr) const |
| { |
| x3::skip_over(first, last, context); |
| |
| if (value_type const* val_ptr |
| = lookup->find(first, last, get_case_compare<Encoding>(context))) |
| { |
| x3::traits::move_to(*val_ptr, attr); |
| return true; |
| } |
| return false; |
| } |
| |
| void name(std::string const &str) |
| { |
| name_ = str; |
| } |
| std::string const &name() const |
| { |
| return name_; |
| } |
| |
| struct adder |
| { |
| template <typename Iterator> |
| adder const& |
| operator()(Iterator first, Iterator last, T const& val) const |
| { |
| sym.lookup->add(first, last, val); |
| return *this; |
| } |
| |
| template <typename Str> |
| adder const& |
| operator()(Str const& s, T const& val = T()) const |
| { |
| sym.lookup->add(traits::get_string_begin<char_type>(s) |
| , traits::get_string_end<char_type>(s), val); |
| return *this; |
| } |
| |
| template <typename Str> |
| adder const& |
| operator,(Str const& s) const |
| { |
| sym.lookup->add(traits::get_string_begin<char_type>(s) |
| , traits::get_string_end<char_type>(s), T()); |
| return *this; |
| } |
| |
| symbols_parser& sym; |
| }; |
| |
| struct remover |
| { |
| template <typename Iterator> |
| remover const& |
| operator()(Iterator const& first, Iterator const& last) const |
| { |
| sym.lookup->remove(first, last); |
| return *this; |
| } |
| |
| template <typename Str> |
| remover const& |
| operator()(Str const& s) const |
| { |
| sym.lookup->remove(traits::get_string_begin<char_type>(s) |
| , traits::get_string_end<char_type>(s)); |
| return *this; |
| } |
| |
| template <typename Str> |
| remover const& |
| operator,(Str const& s) const |
| { |
| sym.lookup->remove(traits::get_string_begin<char_type>(s) |
| , traits::get_string_end<char_type>(s)); |
| return *this; |
| } |
| |
| symbols_parser& sym; |
| }; |
| |
| adder add; |
| remover remove; |
| std::shared_ptr<Lookup> lookup; |
| std::string name_; |
| }; |
| |
| template <typename Encoding, typename T, typename Lookup> |
| struct get_info<symbols_parser<Encoding, T, Lookup>> |
| { |
| typedef std::string result_type; |
| result_type operator()(symbols_parser< Encoding, T |
| , Lookup |
| > const& symbols) const |
| { |
| return symbols.name(); |
| } |
| }; |
| |
| namespace standard |
| { |
| template <typename T = unused_type> |
| using symbols = symbols_parser<char_encoding::standard, T>; |
| } |
| |
| using standard::symbols; |
| |
| #ifndef BOOST_SPIRIT_NO_STANDARD_WIDE |
| namespace standard_wide |
| { |
| template <typename T = unused_type> |
| using symbols = symbols_parser<char_encoding::standard_wide, T>; |
| } |
| #endif |
| |
| namespace ascii |
| { |
| template <typename T = unused_type> |
| using symbols = symbols_parser<char_encoding::ascii, T>; |
| } |
| |
| namespace iso8859_1 |
| { |
| template <typename T = unused_type> |
| using symbols = symbols_parser<char_encoding::iso8859_1, T>; |
| } |
| |
| }}} |
| |
| #if defined(BOOST_MSVC) |
| # pragma warning(pop) |
| #endif |
| |
| #endif |
