command.hpp

Go to the documentation of this file.

/* libobby - Network text editing library
 * Copyright (C) 2005, 2006 0x539 dev group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#ifndef _OBBY_COMMAND_HPP_
#define _OBBY_COMMAND_HPP_

#include <map>
#include <list>
#include <queue>
#include <memory>

#include <net6/packet.hpp>

#include "user.hpp"

namespace obby
{

// TODO: Put all this in a separate namespace?

template<typename data_type>
class command_context_from: public ::serialise::default_context_from<data_type>
{
};

class command_query
{
public:
        command_query(const std::string& command,
                      const std::string& paramlist);

        command_query(const net6::packet& pack,
                      unsigned int& index);

        const std::string& get_command() const;

        const std::string& get_paramlist() const;

        void append_packet(net6::packet& pack) const;
protected:
        std::string m_command;
        std::string m_paramlist;
};

class command_result
{
public:
        enum type {
                NOT_FOUND,

                NO_REPLY,

                REPLY
        };

        command_result();

        command_result(type type, const std::string& reply = "");

        command_result(const net6::packet& pack, unsigned int& index);

        type get_type() const;

        const std::string& get_reply() const;

        void append_packet(net6::packet& pack) const;
protected:
        type m_type;
        std::string m_reply;
};

class command_paramlist
{
public:
        typedef std::vector<std::string>::size_type size_type;

        command_paramlist(const std::string& list);

        size_type count() const;

        template<typename data_type>
        data_type get(unsigned int index,
                      const ::serialise::context_base_from<data_type>& context =
                      command_context_from<data_type>() )
        {
                return context.from_string(m_params.at(index) );
        }

        const std::string& value(unsigned int index) const;
protected:
        std::vector<std::string> m_params;
};

class command_map
{
public:
        typedef sigc::slot<command_result, const user&, const std::string&>
                slot_type;

        command_map();

        void add_command(const std::string& name,
                         const std::string& desc,
                         const slot_type& func);

        command_result exec_command(const user& from,
                                    const command_query& query) const;
protected:
        command_result on_help(const user& from, const std::string& paramlist);

        struct command
        {
                std::string name;
                std::string desc;
                slot_type func;
        };

        typedef std::map<std::string, command> map_type;

        std::auto_ptr<map_type> m_map;
};

class command_queue
{
public:
        typedef sigc::signal<void, const command_query&, const command_result&>
                signal_result_type;

        typedef sigc::signal<void, const command_query&>
                signal_query_failed_type;

        typedef sigc::signal<void, const std::string&, const std::string&>
                signal_help_type;

        command_queue();

        void query(const command_query& query);

        void result(const command_result& result);

        void clear();

        signal_result_type result_event(const std::string& command) const;

        signal_query_failed_type query_failed_event() const;

        signal_help_type help_event() const;

protected:
        void on_help(const command_query& query, const command_result& result);

        typedef std::map<std::string, signal_result_type> map_type;

        std::auto_ptr<map_type> m_map;
        std::queue<command_query> m_commands;
        signal_query_failed_type m_signal_query_failed;
        signal_help_type m_signal_help;
};

} // namespace obby

#endif // _OBBY_COMMAND_HPP_

---