shell.h

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
#include <string_view>
 
#include "BashSpark/command.h"
#include "BashSpark/shell/shell_session.h"
#include "BashSpark/shell/shell_parser_exception.h"
#include "BashSpark/tools/shell_hash.h"
 
namespace bs {
    class shell {
    public:
        constexpr static std::size_t MAX_DEPTH = SHELL_MAX_DEPTH;
 
        constexpr static std::string_view BASH_ERROR_SYNTAX{"BASH_ERROR_SYNTAX"};
 
        constexpr static std::string_view BASH_ERROR_COMMAND_NOT_FOUND{"BASH_ERROR_COMMAND_NOT_FOUND"};
 
        constexpr static std::size_t DEFAULT_COMMAND_HASH_TABLE_SIZE = 1024;
 
    public:
        static std::unique_ptr<shell> make_default_shell();
 
    public:
        shell()
            : m_mCommands(DEFAULT_COMMAND_HASH_TABLE_SIZE) {
        }
 
        virtual ~shell() = default;
 
    public:
        static shell_status run(
            std::istream &oCommand,
            shell_session &oSession
        );
 
        static shell_status run(
            const std::string &sCommand,
            shell_session &oSession
        );
 
        static shell_status run(
            const std::string_view &sCommand,
            shell_session &oSession
        );
 
    public:
        [[nodiscard]] const command *get_command(const std::string &sCommand) const noexcept;
 
        void set_command(std::unique_ptr<command> &&pCommand);
 
        template<typename CommandT, typename... Args>
        void set_command(Args &&... args) {
            static_assert(std::is_base_of_v<command, CommandT>,
                          "Template set_command only takes command derived classes.");
            std::unique_ptr<command> pCommand(new CommandT(std::forward<Args>(args)...));
            this->set_command(std::move(pCommand));
        }
 
        [[nodiscard]] std::unique_ptr<command> remove_command(const std::string &sCommand);
 
        void erase_command(const std::string &sCommand);
 
    public:
        [[nodiscard]] bool get_stop_on_command_not_found() const noexcept;
 
        void set_stop_on_command_not_found(bool bStopOnCommandNotFound) noexcept;
 
    public:
        virtual void msg_error_command_not_found(shell_session &oSession, const std::string &sCommand) const;
 
        virtual void msg_error_invalid_function_name(shell_session &oSession, const std::string &sFunction) const;
 
        virtual void msg_error_syntax_error(
            const shell_session &oSession,
            const shell_parser_exception &oException
        ) const;
 
    private:
        std::unordered_map<std::string, std::unique_ptr<command>, shell_hash> m_mCommands;
        mutable std::mutex m_oExecutionMutex;
        bool m_bStopOnCommandNotFound = true;
    };
}