EQ2EMu/EQ2/source/depends/boost_1_72_0/boost/spirit/home/x3/string/symbols.hpp

/*=============================================================================
    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