Ticket #6106: map.hpp

/*=============================================================================
    Copyright (c) 2011 Alex Dubov

    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_MAP)
#define SPIRIT_MAP

#if defined(_MSC_VER)
#pragma once
#endif

#include <boost/spirit/home/qi/parser.hpp>
#include <boost/spirit/home/qi/detail/assign_to.hpp>
#include <boost/spirit/home/support/unused.hpp>
#include <boost/spirit/home/support/info.hpp>
#include <boost/spirit/home/support/common_terminals.hpp>
#include <boost/spirit/home/support/unused.hpp>
#include <boost/spirit/home/support/has_semantic_action.hpp>
#include <boost/spirit/home/support/assert_msg.hpp>
#include <map>
#include <iostream>

namespace boost { namespace spirit {
namespace repository
{
        BOOST_SPIRIT_DEFINE_TERMINALS_NAME_EX((map, map_type))
}

template <typename T, typename U>
struct use_directive<
        qi::domain,
        terminal_ex<repository::tag::map, fusion::vector1<std::map<T, U> > >
> : mpl::true_ {};

template <>
struct use_lazy_directive<qi::domain, repository::tag::map, 1> : mpl::true_ {};

namespace repository { namespace qi
{
        using repository::map_type;
        using repository::map;

        template <typename Subject, typename T, typename U>
        struct map_parser : spirit::qi::unary_parser<map_parser<Subject, T, U> >
        {
                template <typename Context, typename Iterator>
                struct attribute : mpl::identity<U> {};

                map_parser(Subject const& subject, std::map<T, U> const& lookup)
                : subject(subject), lookup(lookup) {}

                template <typename Iterator, typename Context, typename Skipper,
                          typename Attribute>
                bool parse(Iterator& first, Iterator const& last,
                           Context& context, Skipper const& skipper,
                           Attribute& attr) const
                {
                        T attr_;

                        Iterator iter = first;
                        typename std::map<T, U>::const_iterator attr_iter;

                        if (subject.parse(iter, last, context, skipper,
                                          attr_)) {
                                attr_iter = lookup.find(attr_);
                                if (attr_iter != lookup.end()) {
                                        attr = attr_iter->second;
                                        first = iter;
                                        return true;
                                }
                        }
                        return false;
                }

                template <typename Context>
                info what(Context const& ctx) const
                {
                        return info("map", subject.what(ctx));
                }

                Subject subject;
                std::map<T, U> lookup;
        };
}}

namespace qi
{
        template <typename T, typename U, typename Subject, typename Modifiers>
        struct make_directive<
                terminal_ex<repository::tag::map,
                            fusion::vector1<std::map<T, U> > >,
                Subject, Modifiers
        >
        {
                typedef repository::qi::map_parser<Subject, T, U> result_type;

                template <typename Terminal>
                result_type operator()(
                        Terminal const& term,
                        Subject const& subject,
                        Modifiers const& modifiers
                ) const
                {
                        return result_type(subject, fusion::at_c<0>(term.args));
                }
        };
}

namespace traits
{
        template <typename Subject, typename T, typename U>
        struct has_semantic_action<
                repository::qi::map_parser<Subject, T, U>
        > : unary_has_semantic_action<Subject> {};
}}}

#endif