command.hpp

Go to the documentation of this file.

/***************************************************************************

                    command.hpp - Processes client commands
                           -------------------
    begin                : Wed Aug 9 2006
    copyright            : (C) 2006 Bas Kemper
    email                : kst@ <my name> .be

 ***************************************************************************
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library 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     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place,                                    *
 *   Suite 330, Boston, MA  02111-1307  USA                                *
 *                                                                         *
 ***************************************************************************/

#ifndef ORO_COMP_TCP_REPORTING_COMMAND_HPP
#define ORO_COMP_TCP_REPORTING_COMMAND_HPP
#include <vector>
#include <rtt/os/Mutex.hpp>

namespace OCL
{

namespace TCP
{
    class Datasender;
    class Socket;
    class Command;
    class RealCommand;

    class TcpReportingInterpreter
    {
        protected:
            std::vector<Command*> cmds;
            RTT::os::MutexRecursive commands;
            unsigned int parseParameters( std::string& ipt, std::string& cmd, std::string** params );
            Datasender* _parent;

        public:
            TcpReportingInterpreter(Datasender* parent);
            ~TcpReportingInterpreter();
            void process();

            Datasender* getConnection() const;

            void setVersion10();

            const std::vector<Command*>& giveCommands() const;

            void addCommand( Command* command );

            void removeCommand( const char* name );
    };

    class Command
    {
        protected:
            std::string _name;

        public:
            Command( std::string name );
            virtual ~Command();
            virtual bool is(std::string& cmd) const;

            virtual RealCommand* getRealCommand(const std::vector<Command*>& cmds) const = 0;

            static Command* find(const std::vector<Command*>& cmds, const std::string& cmp);

            bool operator==(const std::string& cmp) const;
            bool operator!=(const std::string& cmp) const;
            bool operator<( const Command& cmp ) const;

            const std::string& getName() const;
    };

    class AliasCommand : public Command
    {
        private:
            std::string _alias;

        public:
            AliasCommand( std::string name, std::string alias );
            virtual ~AliasCommand() {}
            virtual RealCommand* getRealCommand(const std::vector<Command*>& cmds) const;
    };

    class RealCommand : public Command
    {
        protected:
            TcpReportingInterpreter* _parent;
            unsigned int _minargs;
            unsigned int _maxargs;
            const char* _syntax;

            virtual void maincode( int argc, std::string* args ) = 0;

            bool sendError102() const;

            bool sendOK() const;

            void toupper( std::string* args, int index ) const;

            void toupper( std::string* args, int start, int stop ) const;

            inline Socket& socket() const;

        public:
            RealCommand( std::string name, TcpReportingInterpreter* parent, unsigned int minargs = 0, unsigned int maxargs = 0, const char* syntax = 0);
            virtual ~RealCommand();

            virtual bool correctSyntax( unsigned int argc, std::string* args );

            const char* getSyntax() const;

            virtual RealCommand* getRealCommand(const std::vector<Command*>& cmds) const;

            void execute( int argc, std::string* args );
    };
}
}
#endif