root/lang/c/partty/kazuhiki/kazuhiki_extend.h @ 3319

/*
 * Kazuhiki
 *
 * Copyright (c) 2007 FURUHASHI Sadayuki
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#ifndef KAZUHIKI_EXTEND_H__
#define KAZUHIKI_EXTEND_H__ 1

#include "kazuhiki/kazuhiki.h"
#include "kazuhiki/kazuhiki_basic.h"

namespace Kazuhiki {



////
// Command
//
class CommandParser : public RecursiveParser {
public:
        CommandParser(bool required = true) : m_required(required) {}
public:

        class Command : public LeafParser {
        public:
                Command(const std::string& str, bool& set) :
                        LeafParser(&set),
                        m_str(str) {}
                Command(const std::string& str) :
                        m_str(str) {}
        public:
                template <typename T>
                Command& operator<< (T state) {
                        LeafParser::push(state);
                        return *this;
                }
        public:
                virtual bool complete_match(const std::string& v) const { return m_str == v; }
                virtual bool partial_match(const std::string& part) const {
                        if( part.length() > m_str.length() ) { return false; }
                        return part == m_str.substr(0, part.length());
                }
        public:
                void make_error_list(ArgumentError* err) { (*err) << m_str; }
        private:
                std::string m_str;
        };

public:
        unsigned int parse(int argc, const char* const argv[])
        {
                if( argc == 0 ) {
                        if( m_required ) {
                                ArgumentError err("one of commands have to be set");
                                throw make_error_list( m_commands.begin(), m_commands.end(), err );
                        } else {
                                return 0;
                        }
                }

                for(commands_type::iterator it(m_commands.begin()), it_end(m_commands.end());
                                it != it_end;
                                ++it ) {
                        if( (*it)->complete_match(argv[0]) ) {
                                return (*it)->parse(argc-1, &argv[1]) + 1;
                        }
                }

                std::vector<Command*> match;
                for(commands_type::iterator it(m_commands.begin()), it_end(m_commands.end());
                                it != it_end;
                                ++it ) {
                        if( (*it)->partial_match(argv[0]) ) {
                                match.push_back(*it);
                        }
                }
                if( match.size() == 1 ) {
                        return match[0]->parse(argc-1, &argv[1]) + 1;
                } else if( match.size() > 1 ) {
                        ArgumentError err("ambiguity command");
                        err << ArgumentError::inspect_string(argv[0]);
                        make_error_list( match.begin(), match.end(), err );
                        throw err;
                }
                ArgumentError err("unknown command");
                err << ArgumentError::inspect_string(argv[0]);
                throw make_error_list( m_commands.begin(), m_commands.end(), err );
        }
        void destruct(void)
        {
                std::for_each(  m_commands.begin(),
                                m_commands.end(),
                                BranchParser::each_destruct
                             );
        }
public:
        template <typename T>
        CommandParser& operator% (T cmd) {
                m_commands.push_back( new T(cmd) );
                return *this;
        }
private:
        template <class InputIterator>
        ArgumentError& make_error_list(InputIterator first, InputIterator last, ArgumentError& err) {
                err << "(";
                std::for_each(  first,
                                last,
                                std::bind2nd(
                                        std::mem_fun( &Command::make_error_list ),
                                        &err
                                        )
                             );
                err << ")";
                return err;
        }
private:
        typedef std::vector<Command*> commands_type;
        commands_type m_commands;
        const bool m_required;
};



////
// Switch
//
class SwitchParser : public RecursiveParser {
public:
        SwitchParser() :
                m_other(NULL),
                m_other_set(NULL) {}
public:

        class Switch : public LeafParser {
        public:
                Switch(const std::string& str, bool& set) :
                        LeafParser(&set),
                        m_str(str) {}
                Switch(const std::string& str) :
                        m_str(str) {}
        public:
                template <typename T>
                Switch& operator<< (T state) {
                        LeafParser::push(state);
                        return *this;
                }
        public:
                bool match(const std::string& v) const { return m_str == v; }
        private:
                std::string m_str;
        };

        class Other : public LeafParser {
        public:
                template <typename T>
                Other& operator<< (T state) {
                        LeafParser::push(state);
                        return *this;
                }
        };

public:
        unsigned int parse(int argc, const char* const argv[])
        {
                if( argc == 0 ) {
                        if( m_other_set ) { *m_other_set = true; }
                        return m_other->parse(argc, argv);
                }

                for(switches_type::iterator it(m_switches.begin()), it_end(m_switches.end());
                                it != it_end;
                                ++it ) {
                        if( (*it)->match(argv[0]) ) {
                                return (*it)->parse(argc-1, &argv[1]) + 1;
                        }
                }
                if( m_other_set ) { *m_other_set = true; }
                return m_other->parse(argc, argv);
        }
        void destruct(void)
        {
                std::for_each(  m_switches.begin(),
                                m_switches.end(),
                                BranchParser::each_destruct
                             );
                delete m_other;
        }
public:
        template <typename T>
        SwitchParser& operator% (T sw) {
                m_switches.push_back( new T(sw) );
                return *this;
        }
        SwitchParser& operator% (Other sw) {
                m_other = new Other(sw);
                return *this;
        }
private:
        typedef std::vector<Switch*> switches_type;
        switches_type m_switches;
        Other* m_other;
        bool* m_other_set;
};



}  // namespace Kazuhiki

#endif /* kazuhiki_extend.h */