cli.hpp

#ifndef QOS_CPP_CLI
#define QOS_CPP_CLI
 
#include "include/types.hpp"
#include "include/list.hpp"
#include "include/util.hpp"
 
namespace qOS {
 
    class commandLineInterface;
 
    namespace cli {
 
        enum response : int16_t {
            ERROR = -32767,
            NOT_ALLOWED = -32766,
            NO_RESPONSE = 0,
            OK = 1,
            DEVID = 32765,
            NOT_FOUND = 32766,
            OUTPUT_RESPONSE = 32767,
        };
 
        constexpr response ERROR_CODE( int16_t code )
        {
            return static_cast<response>( -code );
        }
 
        enum commandType : uint16_t {
            UNDEF = 0x0000, 
            PARA = 0x0100,  
            TEST = 0x0200,  
            READ = 0x0400,  
            ACT = 0x0800,   
        };
 
        class input {
            public:
                virtual ~input() {}
            protected:
                char *storage{ nullptr };
                volatile index_t index{ 0U };
                index_t maxIndex{ 0U };
                size_t size{ 0U };
                volatile bool ready{ false };
                void flush( void );
                void operator=( input const& ) = delete;
                input() {}
        };
        #ifdef DOXYGEN
        class handler_t final {
            private:
                commandLineInterface *instance{ nullptr };
                void *Command{ nullptr };
                char *StrData{ nullptr };
                void *Data{ nullptr };
                size_t StrLen{ 0U };
                size_t NumArgs{ 0U };
                commandType Type{ UNDEF };
                _Handler( _Handler const& ) = delete;
                void operator=( _Handler const& ) = delete;
                _Handler() = default;
            public:
                inline commandType getType( void ) const
                {
                    return Type;
                }
                inline char* getStringData( void )
                {
                    return StrData;
                }
                inline void* getData( void )
                {
                    return Data;
                }
                inline size_t getStringLength( void ) const
                {
                    return StrLen;
                }
                inline size_t getNumArgs( void ) const
                {
                    return NumArgs;
                }
                char* getArgPtr( index_t n ) const;
                int getArgInt( index_t n ) const;
                float32_t getArgFloat( index_t n ) const;
                uint32_t getArgHex( index_t n ) const;
                char* getArgString( index_t n, char *pOut );
                void writeOut( const char c ) const;
                void writeOut( const char *s ) const;
                char *output{ nullptr };
                inline command& thisCommand( void ) noexcept;
            friend class qOS::commandLineInterface;
        };
        #endif
 
        class command;
        class commandHandler final {
            private:
                commandLineInterface *instance{ nullptr };
                command *Command{ nullptr };
                char *StrData{ nullptr };
                void *Data{ nullptr };
                size_t StrLen{ 0U };
                size_t NumArgs{ 0U };
                commandType Type{ UNDEF };
                commandHandler( commandHandler const& ) = delete;
                void operator=( commandHandler const& ) = delete;
                commandHandler() = default;
            public:
                inline commandType getType( void ) const
                {
                    return Type;
                }
                inline char* getStringData( void )
                {
                    return StrData;
                }
                inline void* getData( void )
                {
                    return Data;
                }
                inline size_t getStringLength( void ) const
                {
                    return StrLen;
                }
                inline size_t getNumArgs( void ) const
                {
                    return NumArgs;
                }
                inline command& self( void ) noexcept
                {
                    return *Command;
                }
                inline command& thisCommand( void ) noexcept
                {
                    return *Command;
                }
                char* getArgPtr( index_t n ) const;
                int getArgInt( index_t n ) const;
                float32_t getArgFloat( index_t n ) const;
                uint32_t getArgHex( index_t n ) const;
                char* getArgString( index_t n, char *pOut );
                void writeOut( const char c ) const;
                void writeOut( const char *s ) const;
                char *output{ nullptr };
            friend class qOS::commandLineInterface;
        };
        using handler_t = commandHandler&;
        using commandCallback_t = response (*)( handler_t );
 
        using options_t = uint16_t;
 
        class command : protected node {
            private:
                commandCallback_t cmdCallback{ nullptr };
                options_t cmdOpt{ 0U };
                size_t cmdLen{ 0U };
                void *param{ nullptr };
                char *Text{ nullptr };
                command( command const& ) = delete;
                void operator=( command const& ) = delete;
            public:
                command() = default;
                virtual ~command() {}
                inline void* getParam( void ) noexcept
                {
                    return param;
                }
            friend class qOS::commandLineInterface;
        };
    }
 
    class commandLineInterface : protected cli::input {
        private:
            list subscribed;
            cli::commandHandler handler;
            const char *ok_rsp{ "OK" };
            const char *er_rsp{ "ERROR" };
            const char *nf_rsp{ "UNKNOWN" };
            const char *id_rsp{ "" };
            const char *eol{ "\r\n" };
            char delim{ ',' };
            util::putChar_t outputFcn{ nullptr };
            size_t sizeOutput{ 0U };
            void *owner{ nullptr };
            bool notify( void );
            bool preProcessing( cli::command *cmd, char *inputBuffer );
            size_t numOfArgs( const char *str ) const;
            void handleResponse( cli::response retval );
            void (*xNotifyFcn)( commandLineInterface *arg) = { nullptr };
            commandLineInterface( commandLineInterface const& ) = delete;
            void operator=( commandLineInterface const& ) = delete;
        public:
            commandLineInterface() = default;
            virtual ~commandLineInterface() {}
            bool setup( util::putChar_t outFcn, char *pInput, const size_t sizeIn, char *pOutput, const size_t sizeOut );
            template <size_t inBufferSize, size_t outBufferSize>
            bool setup( util::putChar_t outFcn, char (&pInput)[ inBufferSize ], char (&pOutput)[ outBufferSize ] ) // skipcq : CXX-W2066
            {
                return setup( outFcn, pInput, inBufferSize, pOutput, outBufferSize );
            }
            bool add( cli::command &cmd, char *textCommand, const cli::commandCallback_t &cFcn, cli::options_t cmdOpt, void *param = nullptr );
            bool isrHandler( const char c );
            bool isrHandler( char *pData, const size_t n );
            bool raise( const char *cmd );
            bool inputFlush( void );
            cli::response exec( const char *cmd );
            bool run( void );
            inline void* getOwner( void )
            {
                return owner;
            }
            inline void setData( void *pData )
            {
                handler.Data = pData;
            }
        friend class cli::commandHandler;
        friend class core;
    };
}
 
 
#endif /*QOS_CPP_CLI*/