cli.h

Go to the documentation of this file.

/*
 * cli.h
 *
 * Command line interpreter
 *
 * Copyright (C) 2006-2008 Post Increment
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is WOpenMCU
 *
 * The Initial Developer of the Original Code is Post Increment
 *
 * Contributor(s): Craig Southeren (craigs@postincrement.com)
 *                 Robert Jongbloed (robertj@voxlucida.com.au)
 *
 * Portions of this code were written by Post Increment (http://www.postincrement.com)
 * with the assistance of funding from US Joint Forces Command Joint Concept Development &
 * Experimentation (J9) http://www.jfcom.mil/about/abt_j9.htm
 *
 * $Revision: 23007 $
 * $Author: rjongbloed $
 * $Date: 2009-06-29 04:13:04 +0000 (Mon, 29 Jun 2009) $
 */

#include <ptlib.h>
#include <ptlib/sockets.h>

#include <list>


class PCLI : public PObject
{
    PCLASSINFO(PCLI, PObject);
  public:
    class Context;

    class Context : public PIndirectChannel
    {
      public:
        Context(
          PCLI & cli
        );

        virtual ~Context();

        virtual PBoolean Write(
          const void * buf, 
          PINDEX len        
        );

        bool Start();

        void Stop();

        virtual void OnStart();

        virtual void OnStop();

        virtual bool ReadAndProcessInput();

        virtual void ProcessInput(char ch);

        virtual void OnCompletedLine();

        PCLI & GetCLI() const { return m_cli; }

        bool IsProcessingCommand() const { return m_processingCommand; }

      protected:
        PDECLARE_NOTIFIER(PThread, Context, ThreadMain);

        PCLI      & m_cli;
        PString     m_commandLine;
        bool        m_ignoreNextLF;
        PStringList m_commandHistory;
        PThread   * m_thread;
        bool        m_processingCommand;
    };

    class Arguments : public PArgList
    {
      public:
        Arguments(
          Context & context,
          const PString & rawLine
        );

        Context & WriteUsage();

        Context & WriteError(
          const PString & error = PString::Empty()  
        );

        Context & GetContext() const { return m_context; }

      protected:
        Context & m_context;
        PString   m_command;
        PString   m_usage;

      friend class PCLI;
    };


    PCLI(
      const char * prompt = NULL
    );

    virtual ~PCLI();

    virtual bool Start(
      bool runInBackground = true   
    );

    virtual void Stop();

    bool StartContext(
      PChannel * channel,           
      bool autoDelete = true,       
      bool runInBackground = true   
    );
    bool StartContext(
      PChannel * readChannel,      
      PChannel * writeChannel,     
      bool autoDeleteRead = true,  
      bool autoDeleteWrite = true, 
      bool runInBackground = true   
    );

    virtual Context * CreateContext();

    virtual Context * AddContext(
      Context * context = NULL    
    );

    virtual void RemoveContext(
      Context * context   
    );

    virtual void GarbageCollection();

    virtual void OnReceivedLine(
      Arguments & line
    );

    void Broadcast(
      const PString & message   
    ) const;

    bool SetCommand(
      const char * command,       
      const PNotifier & notifier, 
      const char * help = NULL,   
      const char * usage = NULL   
    );

    void ShowHelp(
      Context & context   
    );

    const PString & GetPrompt() const { return m_prompt; }

    void SetPrompt(const PString & prompt) { m_prompt = prompt; }

    const PString & GetNewLine() const { return m_newLine; }

    void SetNewLine(const PString & newLine) { m_newLine = newLine; }

    const PCaselessString & GetHelpCommand() const { return m_helpCommand; }

    void SetHelpCommand(const PCaselessString & helpCommand) { m_helpCommand = helpCommand; }

    const PString & GetHelpOnHelp() const { return m_helpOnHelp; }

    void SetHelpOnHelp(const PCaselessString & helpOnHelp) { m_helpOnHelp = helpOnHelp; }

    const PCaselessString & GetRepeatCommand() const { return m_repeatCommand; }

    void SetRepeatCommand(const PCaselessString & repeatCommand) { m_repeatCommand = repeatCommand; }

    const PCaselessString & GetHistoryCommand() const { return m_historyCommand; }

    void SetHistoryCommand(const PCaselessString & historyCommand) { m_historyCommand = historyCommand; }

    const PString & GetNoHistoryError() const { return m_noHistoryError; }

    void SetNoHistoryError(const PString & noHistoryError) { m_noHistoryError = noHistoryError; }

    const PString & GetCommandUsagePrefix() const { return m_commandUsagePrefix; }

    void SetCommandUsagePrefix(const PString & commandUsagePrefix) { m_commandUsagePrefix = commandUsagePrefix; }

    const PString & GetCommandErrorPrefix() const { return m_commandErrorPrefix; }

    void SetCommandErrorPrefix(const PString & commandErrorPrefix) { m_commandErrorPrefix = commandErrorPrefix; }

    const PString & GetUnknownCommandError() const { return m_unknownCommandError; }

    void SetUnknownCommandError(const PString & unknownCommandError) { m_unknownCommandError = unknownCommandError; }

  protected:
    PString         m_prompt;
    PString         m_newLine;
    PCaselessString m_helpCommand;
    PString         m_helpOnHelp;
    PCaselessString m_repeatCommand;
    PCaselessString m_historyCommand;
    PString         m_noHistoryError;
    PString         m_commandUsagePrefix;
    PString         m_commandErrorPrefix;
    PString         m_unknownCommandError;

    struct InternalCommand {
      PNotifier m_notifier;
      PString   m_help;
      PString   m_usage;
    };
    typedef std::map<PString, InternalCommand> CommandMap_t;
    CommandMap_t m_commands;

    typedef std::list<Context *> ContextList_t;
    ContextList_t m_contextList;
    PMutex        m_contextMutex;
};


class PCLIStandard : public PCLI
{
  public:
    PCLIStandard(
      const char * prompt = NULL
    );

    virtual bool Start(
      bool runInBackground = true   
    );
};


class PCLISocket : public PCLI
{
  public:
    PCLISocket(
      WORD port = 0,
      const char * prompt = NULL,
      bool singleThreadForAll = false
    );
    ~PCLISocket();

    virtual bool Start(
      bool runInBackground = true   
    );

    virtual void Stop();

    virtual Context * AddContext(
      Context * context = NULL
    );

    virtual void RemoveContext(
      Context * context
    );

    bool Listen(
      WORD port = 0
    );

    WORD GetPort() const { return m_listenSocket.GetPort(); }

  protected:
    PDECLARE_NOTIFIER(PThread, PCLISocket, ThreadMain);
    bool HandleSingleThreadForAll();
    bool HandleIncoming();

    bool m_singleThreadForAll;

    PTCPSocket m_listenSocket;
    PThread  * m_thread;

    typedef std::map<PSocket *, Context *> ContextMap_t;
    ContextMap_t m_contextBySocket;
};

---