be_process_commandcenter.h

Go to the documentation of this file.

/*
 * This software was developed at the National Institute of Standards and
 * Technology (NIST) by employees of the Federal Government in the course
 * of their official duties. Pursuant to Title 17 Section 105 of the
 * United States Code, this software is not subject to copyright protection
 * and is in the public domain. NIST assumes no responsibility whatsoever for
 * its use by other parties, and makes no guarantees, expressed or implied,
 * about its quality, reliability, or any other characteristic.
 */
 
#ifndef __BE_PROCESS_COMMANDCENTER_H__
#define __BE_PROCESS_COMMANDCENTER_H__
 
#include <cstdio>
#include <string>
#include <vector>
 
#include <be_framework_enumeration.h>
#include <be_memory_autoarray.h>
#include <be_memory_autoarrayutility.h>
#include <be_process_messagecenter.h>
#include <be_text.h>
 
namespace BiometricEvaluation
{
        namespace Process
        {
                template <typename T,
                    typename = typename std::enable_if<std::is_enum<T>::value>>
                class CommandCenter
                {
                public:
                        class Command
                        {
                        public:
                                uint32_t clientID;
                                T command;
                                std::vector<std::string> arguments;
                        };
 
                        static_assert(std::is_enum<T>::value,
                            "Invalid templatization of CommandCenter.");
 
                         CommandCenter(
                            uint16_t port = MessageCenter::DEFAULT_PORT) :
                            _messageCenter(port)
                        {
 
                        }
 
                        ~CommandCenter() = default;
 
                        inline bool
                        hasPendingCommands()
                        {
                                return (this->_messageCenter.
                                    hasUnseenMessages());
                        }
 
                        inline bool
                        getNextCommand(
                            Command &command,
                            int numSeconds = -1,
                            std::string invalidCommandResponse = "")
                        {
                                Memory::uint8Array buffer;
                                if (!this->_messageCenter.getNextMessage(
                                    command.clientID, buffer, numSeconds))
                                        return (false);
 
                                /* Arguments are space separated */
                                command.arguments = Text::split(
                                    to_string(buffer), ' ');
                                if (command.arguments.size() == 0)
                                        return (false);
 
                                /* Remove newline from last argument */
                                std::for_each(command.arguments.begin(),
                                    command.arguments.end(),
                                    [](std::string &i) {
                                        i = Text::trimWhitespace(i);
                                });
 
                                /* Split actual command off of arguments */
                                try {
                                        command.command = BiometricEvaluation::
                                            Framework::Enumeration::to_enum<T>(
                                            command.arguments[0]);
                                } catch (const Error::ObjectDoesNotExist&) {
                                        /* 
                                         * Send implementation specific usage
                                         * if set.
                                         */
                                        if (invalidCommandResponse != "")
                                                this->sendResponse(
                                                    command.clientID,
                                                    invalidCommandResponse);
                                        else {
                                                static const std::string
                                                    INVALID = ": "
                                                    "command not recognized";
                                                this->sendResponse(
                                                    command.clientID,
                                                    command.arguments[0] +
                                                    INVALID);
                                        }
                                        return (false);
                                }
                                command.arguments.erase(
                                    command.arguments.begin());
 
                                return (true);
                        }
 
                        inline void
                        sendResponse(
                            uint32_t clientID,
                            const std::string &response,
                            const std::string prefix = ">> ",
                            const std::string suffix = "\n")
                        {
                                Memory::uint8Array message;
                                Memory::AutoArrayUtility::setString(message,
                                    prefix + response + suffix);
                                this->_messageCenter.sendResponse(clientID,
                                    message);
                        }
 
                        inline void
                        disconnectClient(
                            uint32_t clientID)
                        {
                                this->sendResponse(clientID, "Goodbye");
                                this->_messageCenter.disconnectClient(clientID);
                        }
 
                private:
                        MessageCenter _messageCenter;
                };
 
                template <typename T>
                class CommandParser : public CommandCenter<T>
                {
                public:
                        virtual void
                        parse(
                            const typename
                            CommandCenter<T>::Command &command) = 0;
 
                        inline bool
                        getNextCommand(
                            typename CommandCenter<T>::Command &command,
                            int numSeconds = -1)
                        {
                                return (CommandCenter<T>::getNextCommand(
                                    command, numSeconds, this->getUsage()));
                        }
 
                        inline void
                        setUsage(
                            const std::string &usage)
                        {
                                this->_usage = usage;
                        }
 
                        inline std::string
                        getUsage()
                            const
                        {
                                return (this->_usage);
                        }
 
                        CommandParser(
                            uint16_t port = MessageCenter::DEFAULT_PORT) :
                            CommandCenter<T>(port),
                            _usage("")
                        {
 
                        }
                        
                        virtual ~CommandParser() = default;
 
                private:
                        std::string _usage;
                };
        }
}
 
#endif /* __BE_PROCESS_COMMANDCENTER_H__ */