basic_shell.h

Go to the documentation of this file.

//
// Copyright (c) 2015 by François Mauger <mauger@lpccaen.in2p3.fr>
//
// This file is part of datatools.
//
// datatools 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 3 of the License, or
// (at your option) any later version.
//
// datatools 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 datatools. If not, see <http://www.gnu.org/licenses/>.

#ifndef DATATOOLS_UI_BASIC_SHELL_H
#define DATATOOLS_UI_BASIC_SHELL_H

// Standard libraries:
#include <cstdlib>
#include <string>
#include <iostream>
#include <sstream>
#include <exception>
#include <vector>
#include <memory>

// Third Party:
// - Boost:
#include <boost/optional.hpp>
#include <boost/utility.hpp>

// This project:
#include <datatools/logger.h>
#include <datatools/command_utils.h>
#include <datatools/service_manager.h>
#include <datatools/properties.h>
#include <datatools/version_id.h>
#include <datatools/handle.h>
#include <datatools/multi_properties.h>
#include <datatools/i_tree_dump.h>
#include <datatools/bit_mask.h>
#include <datatools/ui/ihs.h>
#include <datatools/ui/target_command_interface.h>

namespace datatools {

  namespace ui {

    class shell_command_interface;

    class basic_shell
      : public datatools::i_tree_dumpable
      , private boost::noncopyable
    {
    public:

      typedef target_command_interface<basic_shell> shell_command_interface_type;

      enum run_core_flags {
        RC_NONE             = 0, 
        RC_INHIBIT_HISTORY  = datatools::bit_mask::bit00, 
        RC_INHIBIT_READLINE = datatools::bit_mask::bit01, 
        RC_EXIT_ON_ERROR    = datatools::bit_mask::bit02  
      };

      static const unsigned int DEFAULT_HISTORY_TRUNCATE = 200;

      static const std::string & system_interface_name();

      static const std::string & default_prompt();

      static const std::string & default_continuation_prompt();

      basic_shell(const std::string & name_ = "");

      virtual ~basic_shell();

      datatools::logger::priority get_logging() const;

      void set_logging(datatools::logger::priority);

      bool has_name() const;

      void set_name(const std::string &);

      const std::string & get_name() const;

      bool has_title() const;

      void set_title(const std::string &);

      const std::string & get_title() const;

      bool has_version() const;

      void set_version(const ::datatools::version_id &);

      const ::datatools::version_id & get_version() const;

      void set_prompt(const std::string &);

      const std::string & get_prompt() const;

      void set_continuation_prompt(const std::string &);

      const std::string & get_continuation_prompt() const;

      std::string get_effective_prompt() const;

      std::string get_effective_continuation_prompt() const;

      bool has_user() const;

      void set_user(const std::string &);

      const std::string & get_user() const;

      bool has_host() const;

      void set_host(const std::string &);

      const std::string & get_host() const;

      void set_exit_on_error(bool);

      bool is_exit_on_error() const;

      void set_using_splash(bool);

      bool is_using_splash() const;

      void set_using_readline(bool);

      bool is_using_readline() const;

      void set_using_history(bool);

      bool is_using_history() const;

      void set_history_filename(const std::string &);

      const std::string & get_history_filename() const;

      void set_history_truncate(unsigned int);

      unsigned int get_history_truncate();

      void set_history_add_only_on_success(bool);

      bool is_history_add_only_on_success() const;

      bool has_default_path() const;

      void set_default_path(const std::string &);

      const std::string & get_default_path() const;

      bool has_current_path() const;

      void set_current_path(const std::string & p_);

      const std::string & get_current_path() const;

      bool has_services() const;

      void set_services(::datatools::service_manager & services_);

      ::datatools::service_manager & grab_services();

      const ::datatools::service_manager & get_services() const;

      void reset_services();

      bool has_ihs() const;

      void set_ihs(ihs & ihs_);

      ihs & grab_ihs();

      const ihs & get_ihs() const;

      void builtin_command_names(std::vector<std::string> & cmd_names_) const;

      bool has_builtin_command(const std::string & cmd_name_) const;

      const base_command & get_builtin_command(const std::string & cmd_name_) const;

      bool is_initialized() const;

      void initialize_simple();

      void initialize(const datatools::properties &);

      void reset();

      int run(std::istream * in_ = nullptr);

      static void make_title_upper(const std::string & title_,
                                   std::string & upper_);

      std::string canonical_path(const std::string & path_) const;

      bool is_absolute_path(const std::string & path_) const;

      bool is_stop_requested() const;

      void set_stop_requested();

      void load_macro(const std::string & macro_, uint32_t flags_ = 0);

      void build_current_list_of_interfaces(std::vector<std::string> & names_,
                                            uint32_t flags_ = 0,
                                            std::size_t depth_ = 0) const;

      bool has_system_interface() const;

      void set_system_interface(shell_command_interface_type &);

      virtual void print_tree(std::ostream & out_ = std::clog,
                              const boost::property_tree::ptree & options_ = datatools::i_tree_dumpable::empty_options()) const;

    protected:

      void _set_defaults();

      void _expand_prompt(const std::string &, std::string &) const;

      void _print_splash(std::ostream & out_ = std::cout);

      void _print_help(std::ostream & out_ = std::cout);

      virtual void _at_init(const datatools::properties & config_);

      virtual void _at_reset();

      virtual void _at_run_start();

      datatools::command::returned_info _run_core(std::istream * in_ = nullptr,
                                                  uint32_t flags_ = RC_NONE);

      datatools::command::returned_info _run_command(const std::string & command_line_);

      virtual void _at_run_stop();

      shell_command_interface_type & _grab_system_interface();

      const shell_command_interface_type & _get_system_interface() const;

      virtual bool _compute_continue_condition();

    private:

      // Control/management:
      bool _initialized_;                    
      datatools::logger::priority _logging_; 

      // Configuration:
      std::string _name_;                    
      std::string _title_;                   
      boost::optional<version_id> _version_; 
      std::string _prompt_;                  
      std::string _continuation_prompt_;     
      std::string _default_path_;            
      std::string _user_;                    
      std::string _host_;                    
      bool        _exit_on_error_;           
      bool        _using_splash_;            
      bool        _using_readline_;          
      bool        _using_history_;           
      bool        _history_add_only_on_success_; 
      std::string _history_filename_;            
      unsigned int _history_truncate_;           
      datatools::service_manager * _services_;   

      // Working data:
      ihs * _ihs_; 
      std::string _current_working_path_; 
      std::unique_ptr<shell_command_interface_type> _system_interface_; 
      shell_command_interface_type * _external_system_interface_; 

      // Private data:
      struct pimpl_type;
      std::unique_ptr<pimpl_type> _pimpl_;

      pimpl_type & _grab_pimpl();

      const pimpl_type & _get_pimpl() const;

      // Shell command interface has special priviledeges:
      // friend class shell_command_interface;

    };

  } // namespace ui

} // namespace datatools

#endif // DATATOOLS_UI_BASIC_SHELL_H

// Local Variables: --
// mode: c++ --
// c-file-style: "gnu" --
// tab-width: 2 --
// End: --