batch_program_management.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================

#ifndef HF_CORE_BATCH_PROGRAM_MANAGEMENT_H
#define HF_CORE_BATCH_PROGRAM_MANAGEMENT_H

#include "hanfun/protocol.h"
#include "hanfun/core.h"

#include <string>
#include <map>
#include <forward_list>

namespace HF
{
   namespace Core
   {
      // Forward declaration.
      namespace BatchProgramManagement
      {
         class IServer;
      }

      HF::Attributes::IAttribute *create_attribute(BatchProgramManagement::IServer *server,
                                                   uint8_t uid);

      namespace BatchProgramManagement
      {
         typedef enum _CMD
         {
            DEFINE_PROGRAM_CMD      = 0x01, 
            INVOKE_PROGRAM_CMD      = 0x02, 
            DELETE_PROGRAM_CMD      = 0x03, 
            DELETE_ALL_PROGRAMS_CMD = 0x04, 
            GET_PROGRAM_ACTIONS_CMD = 0x05, 
            __LAST_CMD__            = GET_PROGRAM_ACTIONS_CMD
         } CMD;

         typedef enum _Attributes
         {
            MAXIMUM_NUMBER_OF_ENTRIES_ATTR = 0x01, 
            NUMBER_OF_ENTRIES_ATTR         = 0x02, 
            __LAST_ATTR__                  = NUMBER_OF_ENTRIES_ATTR
         } Attributes;

         // =============================================================================
         // Basic memory struct
         // =============================================================================

         struct Action: public Protocol::Message
         {
            Action(uint8_t _uid, HF::Protocol::Message::Type _msg_type,
                   uint8_t _itf_type, uint16_t _itf_uid, uint8_t _itf_member,
                   Common::ByteArray &_payload)
            {
               reference  = _uid;
               type       = _msg_type;
               itf.role   = _itf_type;
               itf.id     = _itf_uid;
               itf.member = _itf_member;
               payload    = _payload;
            }

            Action(void) = default;

            // =================================================================
            // Serializable API
            // =================================================================

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;
            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);

         };

         struct Entry
         {
            uint8_t             pid;      
            std::string         name;     
            std::vector<Action> actions;  

            Entry(uint8_t _pid, std::string _name):
               pid(_pid), name(_name)
            {}

            Entry(uint8_t _pid, std::string _name, std::vector<Action> &_actions):
               pid(_pid), name(_name), actions(_actions)
            {}

            Entry(void) = default;

            static constexpr uint16_t START_PID     = 0x00;
            static constexpr uint16_t MAX_PID       = 0xFE;
            static constexpr uint16_t AVAILABLE_PID = 0xFF;

            // =================================================================
            // Serializable API
            // =================================================================
            static constexpr uint16_t min_size = sizeof(uint8_t)     // Program ID
                                                 + sizeof(uint8_t)   // Name Length
                                                 + sizeof(uint8_t);  // Number of actions

            uint16_t size() const;

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

         typedef Common::Pointer<Entry> EntryPtr;

         // =============================================================================
         // Messages
         // =============================================================================

         typedef Entry DefineProgram;

         struct DefineProgramResponse: public Protocol::Response
         {
            uint8_t pid; 

            DefineProgramResponse(Common::Result _code = Common::Result::OK,
                                  uint8_t _pid = 0):
               Protocol::Response(_code), pid(_pid)
            {}

            // =================================================================
            // Serializable API
            // =================================================================

            static constexpr uint16_t min_size = Protocol::Response::min_size;     // Response Code

            uint16_t size() const;

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

         struct InvokeProgram
         {
            uint8_t pid;    

            InvokeProgram(uint8_t _pid = 0):
               pid(_pid)
            {}

            // =================================================================
            // Serializable API
            // =================================================================

            static constexpr uint16_t min_size = sizeof(uint8_t);     // Program ID

            uint16_t size() const;

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

         typedef DefineProgramResponse InvokeProgramResponse;

         typedef InvokeProgram DeleteProgram;
         typedef InvokeProgramResponse DeleteProgramResponse;

         typedef Protocol::Response DeleteAllProgramsResponse;

         typedef InvokeProgram GetProgramActions;

         struct GetProgramActionsResponse: public Protocol::Response
         {
            Entry program;    

            GetProgramActionsResponse(Common::Result _code,
                                      Entry &_program):
               Protocol::Response(_code), program(_program)
            {}

            GetProgramActionsResponse(Common::Result _code = Common::Result::OK):
               Protocol::Response(_code)
            {}

            // =================================================================
            // Serializable API
            // =================================================================

            uint16_t size() const;

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

         // =============================================================================
         // Attribute Helper classes
         // =============================================================================

         struct MaximumNumberOfEntries: public HF::Attributes::Attribute<uint8_t>
         {
            static constexpr uint8_t ID       = MAXIMUM_NUMBER_OF_ENTRIES_ATTR; 
            static constexpr bool    WRITABLE = false;                          

            MaximumNumberOfEntries(uint8_t value = 0, HF::Interface *owner = nullptr):
               Attribute<uint8_t>(HF::Interface::BATCH_PROGRAM_MANAGEMENT, ID, owner,
                                  value, WRITABLE)
            {}
         };

         struct NumberOfEntries: public HF::Attributes::Attribute<uint8_t>
         {
            static constexpr uint8_t ID       = NUMBER_OF_ENTRIES_ATTR; 
            static constexpr bool    WRITABLE = false;                  

            NumberOfEntries(uint8_t value = 0, HF::Interface *owner = nullptr):
               Attribute<uint8_t>(HF::Interface::BATCH_PROGRAM_MANAGEMENT, ID, owner,
                                  value, WRITABLE)
            {}
         };

         HF::Attributes::IAttribute *create_attribute(uint8_t uid);

         struct IEntries: public Common::IEntries<Entry>
         {
            using Common::IEntries<Entry>::save;

            virtual Common::Result save(const uint8_t pid, const std::string &name,
                                        std::vector<Action> &actions) = 0;

            using Common::IEntries<Entry>::destroy;

            virtual Common::Result destroy(const uint8_t pid) = 0;

            virtual void clear(void) = 0;

            virtual EntryPtr find(const uint8_t pid) const = 0;

            virtual EntryPtr find(const std::string &name) const = 0;

            virtual uint8_t next_pid() const = 0;
         };

         struct Entries: public IEntries
         {
            typedef std::map<uint8_t, Entry> Container;
            typedef Container::iterator iterator;
            typedef Container::const_iterator const_iterator;
            typedef Container::value_type value_type;

            virtual ~Entries() {}

            uint16_t size() const;

            Common::Result save(const Entry &entry);

            Common::Result save(const uint8_t pid, const std::string &name,
                                std::vector<Action> &actions);

            Common::Result destroy(const uint8_t pid);

            Common::Result destroy(const Entry &entry);

            void clear(void);

            EntryPtr find(const uint8_t pid) const;

            EntryPtr find(const std::string &name) const;

            uint8_t next_pid() const;

            iterator begin()
            {
               return db.begin();
            }

            iterator end()
            {
               return db.end();
            }

            const_iterator begin() const
            {
               return db.cbegin();
            }

            const_iterator end() const
            {
               return db.cend();
            }

            protected:

            Container db;
         };

         struct Base: public Service<HF::Interface::BATCH_PROGRAM_MANAGEMENT>
         {
            protected:

            Base(Unit0 &unit): Service<HF::Interface::BATCH_PROGRAM_MANAGEMENT>(unit) {}
         };

         class IServer: public ServiceRole<BatchProgramManagement::Base,
                                           HF::Interface::SERVER_ROLE>
         {
            protected:

            uint8_t _maximum_number_of_entries; 

            public:

            IServer(Unit0 &unit): ServiceRole<BatchProgramManagement::Base,
                                              HF::Interface::SERVER_ROLE>(unit),
               _maximum_number_of_entries(std::numeric_limits<uint8_t>::max())
            {}

            virtual ~IServer() {}

            // ======================================================================

            // ======================================================================
            // Events
            // ======================================================================

            virtual Common::Result define_program(const Protocol::Packet &packet,
                                                  DefineProgram &msg);

            virtual Common::Result invoke_program(const Protocol::Packet &packet,
                                                  InvokeProgram &msg);
            virtual Common::Result delete_program(const Protocol::Packet &packet,
                                                  DeleteProgram &msg);

            virtual Common::Result delete_all_programs(const Protocol::Packet &packet);

            virtual Common::Result get_program_actions(const Protocol::Packet &packet,
                                                       GetProgramActions &msg);

            // ======================================================================


            // =============================================================================
            // API
            // =============================================================================

            virtual IEntries &entries() const = 0;

            EntryPtr entry(const uint8_t pid) const
            {
               return entries().find(pid);
            }

            EntryPtr entry(const std::string &name) const
            {
               return entries().find(name);
            }

            uint8_t next_pid() const
            {
               return entries().next_pid();
            }

            // =============================================================================
            // Get/Set API.
            // =============================================================================

            uint8_t maximum_number_of_entries() const;

            void maximum_number_of_entries(uint8_t __value);

            uint8_t number_of_entries() const;

            // =============================================================================
            // Attribute API.
            // =============================================================================

            HF::Attributes::IAttribute *attribute(uint8_t uid);

            HF::Attributes::UIDS attributes(uint8_t pack_id =
                                               HF::Attributes::Pack::MANDATORY) const;

            protected:

            Common::Result handle_command(Protocol::Packet &packet, Common::ByteArray &payload,
                                          uint16_t offset);

         };

         template<typename _Entries = Entries>
         class Server: public IServer
         {
            public:

            Server(Unit0 &unit): IServer(unit) {}

            virtual ~Server() {}

            _Entries &entries() const
            {
               return const_cast<_Entries &>(_entries);
            }

            protected:

            _Entries _entries;
         };

         typedef Server<> DefaultServer;

         struct Client: public ServiceRole<BatchProgramManagement::Base,
                                           HF::Interface::CLIENT_ROLE>
         {
            Client(Unit0 &unit): ServiceRole<BatchProgramManagement::Base,
                                             HF::Interface::CLIENT_ROLE>(unit) {}

            virtual ~Client() {}

            // ======================================================================
            // Commands
            // ======================================================================

            Common::Result define_program(const Protocol::Address &addr, const uint8_t pid,
                                          const std::string name, std::vector<Action> &actions)
            {
               DefineProgram request(pid, name, actions);

               return define_program(addr, request);
            }

            Common::Result define_program(const Protocol::Address &addr, Entry &program);

            void invoke_program(const Protocol::Address &addr, uint8_t pid);

            void delete_program(const Protocol::Address &addr, uint8_t pid);

            void delete_all_programs(const Protocol::Address &addr);

#ifdef HF_CORE_BATCH_PROGRAM_MANAGEMENT_GET_PROGRAM_ACTIONS_CMD

            void get_program_actions(const Protocol::Address &addr, uint8_t pid);
#endif

            // =============================================================================

            // ======================================================================
            // Events
            // ======================================================================

            virtual void defined(DefineProgramResponse &response) = 0;

            virtual void deleted(DeleteProgramResponse &response) = 0;

            virtual void deleted(DeleteAllProgramsResponse &response) = 0;

            virtual void invoked(InvokeProgramResponse &response) = 0;

            virtual void got_actions(GetProgramActionsResponse &response) = 0;

            // ======================================================================

            protected:

            uint16_t payload_size(Protocol::Message::Interface &itf) const;

            Common::Result handle_command(Protocol::Packet &packet, Common::ByteArray &payload,
                                          uint16_t offset);
         };

      }  // namespace BatchProgramManagement

   }  // namespace Core

}   // namespace HF

// =============================================================================
// Stream Helpers
// =============================================================================

std::ostream &operator<<(std::ostream &stream,
                         const HF::Core::BatchProgramManagement::CMD command);

std::ostream &operator<<(std::ostream &stream,
                         const HF::Core::BatchProgramManagement::Attributes attribute);
#endif /* HF_CORE_BATCH_PROGRAM_MANAGEMENT__H */