Opening a door towards Spirit: a parser framework

#pragma once

#include <boost/spirit/core.hpp>
#include <boost/spirit/utility/escape_char.hpp>
#include <boost/spirit/utility/confix.hpp>
#include <iostream>
#include <vector>
#include <map>

namespace myparser
{
	using namespace std;
	using namespace boost::spirit;

    struct assign_string
    {
        assign_string(std::string& str_)
        : str(str_) {};

		template<typename IteratorT >
        void operator()(IteratorT first, IteratorT last) const
        {
            str.assign(first, last);
        }

        std::string& str;
    };

	struct keyvalue_grammar : public grammar<keyvalue_grammar>
	{
		keyvalue_grammar(std::string& str_key_, std::string& str_val_)
			: str_key(str_key_), str_val(str_val_){};

        template <typename ScannerT>
        struct definition
        {	
            definition(keyvalue_grammar const& self)  
			{ 
				equal = ch_p('=');

				key_value = key >> equal >> value;

				key_tag = ch_p('-') | ch_p('/');

				key = key_tag >> 
					(+alnum_p)[ assign_string(self.str_key) ];

				value = ( 
						confix_p( 
							'"',
							(+ c_escape_ch_p )[assign_string(self.str_val)] ,
							'"'
							)
					| (+ alnum_p )[assign_string(self.str_val)] );
			}

            rule<ScannerT>  key_tag, key, equal, value, key_value;
            rule<ScannerT> const& start() const { return key_value; };
		};

		std::string& str_key;
		std::string& str_val;
	};


	template<typename keyvalue_container> 
    class add_keyvalue_pair
    {
	public:
		add_keyvalue_pair( keyvalue_container& kvc_, std::string& key_, std::string& val_)
			: kvc( kvc_ ), key(key_), val(val_)
		{
		}

        template <typename IteratorT>
        void operator()(IteratorT first, IteratorT last) const
		{
			kvc.insert( keyvalue_container::value_type(key, val) );
		}
	private:
		std::string& key;
		std::string& val;
		keyvalue_container& kvc;
    };

	template<typename keyvalue_container> 
    struct cmdline_grammar : public grammar< cmdline_grammar >
    {
		cmdline_grammar( keyvalue_container& kvc_, std::string& str_command_)
			: kvc(kvc_), str_command(str_command_)
		{};

        template <typename ScannerT>
        struct definition
        {
            definition( cmdline_grammar<keyvalue_container> const& self )
				: key_value( key, value )
			{ 
				command = (+alnum_p)[assign_string(self.str_command)];
				line = command >> *( key_value[ add_keyvalue_pair<keyvalue_container>( self.kvc, key, value ) ] );
			}			

            rule<ScannerT> command, line;
			keyvalue_grammar key_value;
			std::string key;
			std::string value;
            rule<ScannerT> const& start() const { return line; }
        };

		keyvalue_container& kvc;
		std::string& str_command;
    };
};

class command_line_parser
{
public:
	typedef std::map< std::string, std::string> keyvalue_container;
	command_line_parser(){};
	~command_line_parser(){};

	bool parse(const std::string& str)
	{
		kvc.clear();

		myparser::cmdline_grammar<keyvalue_container> parser(kvc, command);
		info = boost::spirit::parse(str.c_str(), parser, boost::spirit::space_p);

		return info.full;
	};

	const char* stop() const	{	return info.stop;};

	const string& get_command() const				{	return command;};
	const keyvalue_container& get_keyvalues()const	{	return kvc;};

protected:
	std::string command;
	keyvalue_container kvc;
	parse_info<> info;
};