shell_session.h

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
#include <iosfwd>
#include <sstream>
#include <memory>
 
#include "shell_vtable.h"
#include "BashSpark/shell/shell_arg.h"
#include "BashSpark/shell/shell_env.h"
#include "BashSpark/shell/shell_var.h"
#include "BashSpark/shell/shell_status.h"
 
namespace bs {
    class shell;
 
    class shell_session {
    public:
        using func_type = shell_vtable::func_type;
 
    public:
        shell_session(
            const shell *pShell,
            std::istream &oStdIn,
            std::ostream &oStdOut,
            std::ostream &oStdErr
        )
            : m_pEnv(std::make_shared<shell_env>()),
              m_pArg(std::make_shared<shell_arg>()),
              m_pVar(std::make_shared<shell_var>()),
              m_pVtable(std::make_shared<shell_vtable>()),
              m_nLastCommandResult(shell_status::SHELL_SUCCESS),
              m_pShell(pShell),
              m_oStdIn(oStdIn),
              m_oStdOut(std::ref(oStdOut)),
              m_oStdErr(std::ref(oStdErr)) {
        }
 
        shell_session(
            const shell *pBash,
            std::istream &oStdIn,
            std::ostream &oStdOut,
            std::ostream &oStdErr,
            shell_env oEnv,
            shell_arg oArg
        )
            : m_pEnv(std::make_shared<shell_env>(std::move(oEnv))),
              m_pArg(std::make_shared<shell_arg>(std::move(oArg))),
              m_pVar(std::make_shared<shell_var>()),
              m_nLastCommandResult(shell_status::SHELL_SUCCESS),
              m_pShell(pBash),
              m_oStdIn(oStdIn),
              m_oStdOut(std::ref(oStdOut)),
              m_oStdErr(std::ref(oStdErr)) {
        }
 
        virtual ~shell_session() = default;
 
        // @section shell_pointer Shell Pointer
 
        [[nodiscard]] const shell *get_shell() const noexcept {
            return m_pShell;
        }
 
        // @section shell_env Environment
 
        [[nodiscard]] shell_env &env() noexcept { return *m_pEnv; }
 
        [[nodiscard]] const shell_env &env() const noexcept { return *m_pEnv; }
 
        [[nodiscard]] bool has_env(const std::string &sVariable) const noexcept {
            return m_pEnv->has_env(sVariable);
        }
 
        [[nodiscard]] std::string get_env(const std::string &sVariable) const {
            return m_pEnv->get_env(sVariable);
        }
 
        [[nodiscard]] std::string get_env_hop2(const std::string &sVariable) const {
            return m_pEnv->get_env_hop2(sVariable);
        }
 
        void set_env(const std::string &sVariable, std::string sValue) {
            m_pEnv->set_env(sVariable, std::move(sValue));
        }
 
        // @section shell_var Variables
 
        [[nodiscard]] const shell_var &var() const noexcept { return *m_pVar; }
 
        [[nodiscard]] shell_var &var() noexcept { return *m_pVar; }
 
        [[nodiscard]] bool has_var(const std::string &sVariable) const noexcept {
            return m_pVar->has_var(sVariable);
        }
 
        [[nodiscard]] std::string get_var(const std::string &sVariable) const {
            return m_pVar->get_var(sVariable);
        }
 
        [[nodiscard]] std::string get_var_hop2(const std::string &sVariable) const {
            return m_pVar->get_var_hop2(sVariable);
        }
 
        void set_var(const std::string &sVariable, std::string sValue) {
            m_pVar->set_var(sVariable, std::move(sValue));
        }
 
        // @section shell_arg Arguments
 
        [[nodiscard]] const shell_arg &arg() const noexcept { return *m_pArg; }
 
        [[nodiscard]] shell_arg &arg() noexcept { return *m_pArg; }
 
        [[nodiscard]] std::string get_arg(const std::size_t nArg) const {
            return m_pArg->get_arg(nArg);
        }
 
        [[nodiscard]] std::size_t get_arg_size() const {
            return m_pArg->get_arg_size();
        }
 
        [[nodiscard]] const std::vector<std::string> &get_args() const noexcept {
            return m_pArg->get_args();
        }
 
        // @section streams Streams
 
        [[nodiscard]] std::istream &in() const noexcept { return m_oStdIn; }
 
        [[nodiscard]] std::ostream &out() const noexcept { return m_oStdOut; }
 
        [[nodiscard]] std::ostream &err() const noexcept { return m_oStdErr; }
 
        // @section shell_status Status
 
        [[nodiscard]] shell_status get_last_command_result() const noexcept {
            return m_nLastCommandResult;
        }
 
        void set_last_command_result(const shell_status nLastCommandResult) noexcept {
            m_nLastCommandResult = nLastCommandResult;
        }
 
        // @section shell_subsession Subsession creation
 
        virtual std::unique_ptr<shell_session> make_subsession(
            std::istream &oStdIn,
            std::ostream &oStdOut,
            std::ostream &oStdErr
        ) {
            return std::unique_ptr<shell_session>(new shell_session(
                m_pShell,
                oStdIn,
                oStdOut,
                oStdErr,
                std::make_shared<shell_env>(*m_pEnv),
                m_pArg,
                std::make_shared<shell_var>(*m_pVar),
                std::make_shared<shell_vtable>(*m_pVtable)
            ));
        }
 
        virtual std::unique_ptr<shell_session> make_function_call(shell_arg oArg) {
            std::cout << "fcall " << m_pArg->get_arg(1) << std::endl;
            return std::unique_ptr<shell_session>(new shell_session(
                m_pShell, m_oStdIn, m_oStdOut, m_oStdErr,
                m_pEnv,
                std::make_shared<shell_arg>(std::move(oArg)),
                std::make_shared<shell_var>(),
                m_pVtable
            ));
        }
 
        virtual std::unique_ptr<shell_session> make_pipe_left(
            std::ostringstream &oStdOut
        ) {
            return std::unique_ptr<shell_session>(new shell_session(
                m_pShell, m_oStdIn, oStdOut, m_oStdErr,
                m_pEnv, m_pArg, m_pVar, m_pVtable
            ));
        }
 
        virtual std::unique_ptr<shell_session> make_pipe_right(
            std::istringstream &oStdIn
        ) {
            return std::unique_ptr<shell_session>(new shell_session(
                m_pShell,
                oStdIn,
                m_oStdOut,
                m_oStdErr,
                m_pEnv,
                m_pArg,
                m_pVar,
                m_pVtable
            ));
        }
 
        // @section vtable Function vtable
 
        [[nodiscard]] const func_type *get_func(const std::string &sVar) const {
            return this->m_pVtable->get_func(sVar);
        }
 
        void set_func(const std::string &sName, const func_type *pFunction) {
            this->m_pVtable->set_func(sName, pFunction);
        }
 
        [[nodiscard]] bool has_func(const std::string &sName) const noexcept {
            return this->m_pVtable->has_func(sName);
        }
 
        [[nodiscard]] std::size_t get_vtable_size() const noexcept {
            return this->m_pVtable->get_vtable_size();
        }
 
       // @section depth Shell Depth
 
    public:
        [[nodiscard]] std::size_t get_current_shell_depth() const noexcept {
            return this->m_nCurrentDepth;
        }
 
        void decrease_shell_depth() noexcept {
            if (this->m_nCurrentDepth > 0)this->m_nCurrentDepth--;
        }
 
        bool increase_shell_depth() noexcept {
            if (this->m_nCurrentDepth + 1 <= SHELL_MAX_DEPTH) {
                this->m_nCurrentDepth++;
                return true;
            }
            return false;
        }
 
    protected:
        shell_session(
            const shell *pBash,
            std::istream &oStdIn,
            std::ostream &oStdOut,
            std::ostream &oStdErr,
            std::shared_ptr<shell_env> pEnv,
            std::shared_ptr<shell_arg> pArg,
            std::shared_ptr<shell_var> pVar,
            std::shared_ptr<shell_vtable> pVtable
        )
            : m_pEnv(std::move(pEnv)),
              m_pArg(std::move(pArg)),
              m_pVar(std::move(pVar)),
              m_pVtable(std::move(pVtable)),
              m_nLastCommandResult(shell_status::SHELL_SUCCESS),
              m_pShell(pBash),
              m_oStdIn(std::ref(oStdIn)),
              m_oStdOut(std::ref(oStdOut)),
              m_oStdErr(std::ref(oStdErr)) {
        }
 
    protected:
        std::shared_ptr<shell_env> m_pEnv;
        std::shared_ptr<shell_arg> m_pArg;
        std::shared_ptr<shell_var> m_pVar;
        std::shared_ptr<shell_vtable> m_pVtable;
        shell_status m_nLastCommandResult;
 
    private:
        const shell *m_pShell;
        std::reference_wrapper<std::istream> m_oStdIn;
        std::reference_wrapper<std::ostream> m_oStdOut;
        std::reference_wrapper<std::ostream> m_oStdErr;
        std::size_t m_nCurrentDepth = 0;
    };
} // namespace bs