JShell.hh

Go to the documentation of this file.

#ifndef __JSYSTEM__JSHELL__
#define __JSYSTEM__JSHELL__

#include <string>
#include <istream>
#include <ostream>

#include "JSystem/JProcess.hh"
#include "JLang/JFileStream.hh"
#include "JLang/JNullStream.hh"
#include "JLang/JAbstractObjectStatus.hh"


/**
 * \file
 * Shell interaction via I/O streams.
 * \author mdejong
 */
namespace JSYSTEM {}
namespace JPP { using namespace JSYSTEM; }

namespace JSYSTEM {

  using JLANG::JFileStream;
  using JLANG::JAbstractObjectStatus;
  using JLANG::null;


  /**
   * The JShell clas can be used to interact with the shell via I/O streams.
   */
  class JShell :
    public JProcess,
    public JFileStream,
    public JAbstractObjectStatus
  {   
  public:

    using std::istream::get;
    using JAbstractObjectStatus::operator bool;

    /**
     * Constructor.
     *
     * \param  size            size of internal buffer
     */
    JShell(const std::size_t  size = 65536) :
      JProcess(),
      JFileStream(JProcess::out, JProcess::in, size)
    {
      using namespace std;

      prompt = "_abc321_";

      static_cast<ostream&>(*this) << "set prompt=" << prompt << endl;
      static_cast<ostream&>(*this) << "echo hello"            << endl;

      flush();
    }


    /**
     * Destructor.
     */
    ~JShell()
    {
      this->exit();
    }


    /**
     * Get reference to unique instance of this class object.
     *
     * \return                 reference to this class object
     */
    static JShell& getInstance()
    {
      static JShell shell;

      return shell;
    }


    /**
     * Get prompt.
     *
     * \return                 prompt
     */
    const std::string& getPrompt() const
    {
      return prompt;
    }


    /**
     * Get value.
     *
     * Note that 
     *  - in case of success, the input stream is flushed; and
     *  - in case of failure, the input stream is cleared and flushed.
     *
     * \param  value           value
     * \return                 true if valid; else false
     */
    template<class T>
    inline bool get(T& value)
    {
      using namespace std;

      if (*this >> value) {

        this->flush();

        return true;

      } else {

        static_cast<istream&>(*this).clear();

        this->flush();

        return false;
      }
    }


    /**
     * Get line of text.
     *
     * Extracts characters from this shell and stores them into the given buffer
     * until the end of line character is found or the prompt is read.
     *
     * \param  buffer          buffer
     * \param  eol             end of line character
     * \return                 true if valid; else false
     */
    inline bool getline(std::string& buffer, const char eol = '\n') 
    {
      using namespace std;

      buffer.clear();

      while (this->getStatus()) {

        const int c = this->get();

        if        (c == streambuf::traits_type::eof()) {
          
          return !buffer.empty();

        } else if (c == eol) {
          
          return true;
          
        } else {
          
          buffer += (char) c;

          if (buffer.size() >= prompt.size()) {

            const size_t pos = buffer.size() - this->prompt.size();
          
            if (buffer.substr(pos) == this->prompt) {

              buffer.erase(pos);

              return !buffer.empty();
            }
          }
        }
      }

      return false;
    }


    /**
     * Extracts characters from this shell and flush them to the given output stream
     * until the prompt is read.
     *
     * \param  out             output stream
     * \return                 this shell
     */
    JShell& flush(std::ostream& out = null)
    {
      using namespace std;

      for (string buffer; this->getline(buffer); ) {
        out << buffer << endl;
      }

      return *this;
    }


    /**
     * Get status of this shell.
     *
     * \return                 status of this shell
     */
    virtual bool getStatus() const override 
    { 
      return ((bool) static_cast<const std::ostream&>(*this) && 
              (bool) static_cast<const std::istream&>(*this));
    }


    /**
     * Exit this shell.
     */
    void exit()
    { 
      using namespace std;

      static_cast<ostream&>(*this) << "exit" << endl;
    }


  protected:
    std::string  prompt;

  private:
    JShell(const JShell&);
    JShell(JShell&&);
    JShell& operator=(const JShell&);
    JShell& operator=(JShell&&);
  };  
}

#endif