group_management.h

Go to the documentation of this file.

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

#ifndef HF_CORE_GROUP_MANAGEMENT_H
#define HF_CORE_GROUP_MANAGEMENT_H

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

#include "hanfun/core/group_table.h"

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

namespace HF
{
   // Forward declaration.
   namespace Devices
   {
      namespace Concentrator
      {
         struct IUnit0;
      } // namespace Concentrator
   }    // namespace Devices

   namespace Core
   {
      // Forward declaration.
      namespace GroupManagement
      {
         class IServer;
      }

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

      namespace GroupManagement
      {
         typedef enum _CMD
         {
            CREATE_CMD   = 0x01, 
            DELETE_CMD   = 0x02, 
            ADD_CMD      = 0x03, 
            REMOVE_CMD   = 0x04, 
            GET_INFO_CMD = 0x05, 
            __LAST_CMD__ = GET_INFO_CMD
         } CMD;

         typedef enum _Attributes
         {
            NUMBER_OF_GROUPS_ATTR = 0x01,   
            __LAST_ATTR__         = NUMBER_OF_GROUPS_ATTR
         } Attributes;

         struct GroupAddress
         {
            uint16_t                  address; 

            constexpr static uint16_t NO_ADDR    = 0x0000;  
            constexpr static uint16_t START_ADDR = 0x0001;  
            constexpr static uint16_t END_ADDR   = 0x7FFF;  

            GroupAddress(uint16_t address = 0)
            {
               this->address = address;
            }

            static constexpr uint16_t min_size = sizeof(uint16_t);   // %Group Address

            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);
         };


         // =============================================================================
         // %Group Member Entry Data structure
         // =============================================================================

         typedef Protocol::Address Member;

         // =============================================================================
         // %Group Entry Data structure
         // =============================================================================

         struct Group: public GroupAddress
         {
            typedef std::vector<Member> Container;

            std::string name; 

            protected:

            Container _members;  

            public:

            constexpr static uint16_t MAX_MEMBERS = GroupAddress::END_ADDR -
                                                    GroupAddress::START_ADDR + 1;

            Group(uint16_t address = 0, std::string name = ""):
               GroupAddress(address), name(name)
            {}

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

            const Container &members() const
            {
               return _members;
            }

            Container::iterator find_member(const Member &member);

            Container::iterator find_member(uint16_t device, uint8_t unit)
            {
               const Member member(device, unit);

               return find_member(member);
            }

            bool exists(const Member &member)
            {
               return !(find_member(member) == members().end());
            }

            bool exists(uint16_t device, uint8_t unit)
            {
               const Member member(device, unit);

               return !(find_member(member) == members().end());
            }

            bool add(const Member &member);

            bool add(uint16_t device, uint8_t unit)
            {
               const Member member(device, unit);

               return add(member);
            }

            bool reserve()
            {
               HF_ASSERT(members().size() < MAX_MEMBERS, {return false;});
               _members.push_back(Member());
               return true;
            }

            bool update(const Member &member);

            bool update(uint16_t device, uint8_t unit)
            {
               const Member member(device, unit);

               return update(member);
            }

            bool remove(const Member &member);

            bool remove(uint16_t device, uint8_t unit)
            {
               const Member member(device, unit);

               return remove(member);
            }

            // =============================================================================
            // Operators
            // =============================================================================

            bool operator==(const Group &other) const
            {
               if (this->address == other.address)
               {
                  return true;
               }
               else
               {
                  return false;
               }
            }

            bool operator!=(const Group &other) const
            {
               return !(*this == other);
            }
         };

         typedef Common::Pointer<Group> GroupPtr;

         struct CreateMessage
         {
            std::string name; 

            CreateMessage(std::string name = ""):
               name(name)
            {}

            // virtual ~CreateMessage();

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

            static constexpr uint16_t min_size = sizeof(uint8_t);          // %Group Name (length)

            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 CreateResponse: public Protocol::Response, GroupAddress
         {
            CreateResponse(uint16_t address):
               Protocol::Response(), GroupAddress(address)
            {}

            CreateResponse(Common::Result code = Common::Result::OK,
                           uint16_t address = GroupAddress::NO_ADDR):
               Protocol::Response(code), GroupAddress(address)
            {}

            // =============================================================================
            // 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);

         };

         typedef GroupAddress DeleteMessage;

         typedef Protocol::Response DeleteResponse;

         struct Message: public GroupAddress, Protocol::Address
         {
            Message(uint16_t group, uint16_t device, uint8_t unit):
               GroupAddress(group), Protocol::Address(device, unit)
            {}

            Message()
            {}

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

            static constexpr uint16_t min_size = GroupAddress::min_size
                                                 + Protocol::Address::min_size;

            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 Message AddMessage;

         typedef Protocol::Response AddResponse;

         typedef Message RemoveMessage;

         typedef Protocol::Response RemoveResponse;

         typedef GroupAddress InfoMessage;

         struct InfoResponse: public Protocol::Response
         {
            std::string         name;
            std::vector<Member> members;

            InfoResponse(const std::string &name, std::vector<Member> &members):
               Protocol::Response(), name(name), members(members)
            {}

            InfoResponse(Common::Result code, const std::string &name,
                         std::vector<Member> &members):
               Protocol::Response(code), name(name), members(members)
            {}

            InfoResponse()
            {}

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

            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 NumberOfGroups: public HF::Attributes::Attribute<uint8_t>
         {
            static constexpr uint8_t ID       = NUMBER_OF_GROUPS_ATTR; 
            static constexpr bool    WRITABLE = false;                 

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

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

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

            virtual Common::Result save(uint16_t address, const std::string &name) = 0;

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

            virtual Common::Result destroy(const uint16_t address) = 0;

            virtual GroupPtr find(const uint16_t address) const = 0;

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

            virtual uint16_t next_address() const = 0;
         };

         struct Entries: public IEntries
         {
            typedef std::map<uint16_t, Group> 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 Group &entry);

            Common::Result save(uint16_t address, const std::string &name);

            Common::Result destroy(const uint16_t address);

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

            GroupPtr find(uint16_t address) const;

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

            uint16_t next_address() 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::GROUP_MANAGEMENT>
         {
            protected:

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

         // Forward declaration.
         struct IGroupTable;

         class IServer: public ServiceRole<GroupManagement::Base, HF::Interface::SERVER_ROLE>
         {
            typedef ServiceRole<GroupManagement::Base, HF::Interface::SERVER_ROLE> Server;

            public:

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

            virtual ~IServer() {}

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

            virtual Common::Result create(Protocol::Packet &packet, CreateMessage &msg);

            virtual void created(const GroupPtr &group)
            {
               UNUSED(group);
            }

            virtual Common::Result remove(Protocol::Packet &packet, DeleteMessage &msg);

            virtual void deleted(const Group &group)
            {
               UNUSED(group);
            }

            virtual Common::Result add(Protocol::Packet &packet, const AddMessage &msg);

            virtual void added(const GroupPtr &group, const Member &member)
            {
               UNUSED(group);
               UNUSED(member);
            }

            virtual Common::Result remove(Protocol::Packet &packet, const RemoveMessage &msg);

            virtual void removed(const GroupPtr &group, const Member &member)
            {
               UNUSED(group);
               UNUSED(member);
            }

#ifdef HF_CORE_GROUP_MANAGEMENT_GET_INFO_CMD

            virtual Common::Result get_info(Protocol::Packet &packet, const InfoMessage &msg);
#endif

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

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

            HF::Devices::Concentrator::IUnit0 *unit0() const;

            virtual IEntries &entries() const = 0;

            GroupPtr entry(const uint16_t address) const
            {
               return entries().find(address);
            }

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

            uint16_t next_address() const
            {
               return entries().next_address();
            }

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

            uint8_t number_of_groups() const
            {
               return (uint8_t) entries().size();
            }

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

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

            HF::Attributes::UIDS attributes(uint8_t pack_id =
                                               HF::Attributes::Pack::MANDATORY) const
            {
               UNUSED(pack_id);
               return HF::Attributes::UIDS {NUMBER_OF_GROUPS_ATTR};
            }

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

            protected:

            virtual bool authorized(CMD member, const Protocol::Address &source,
                                    const Protocol::Address &destination)
            {
               UNUSED(member);
               UNUSED(source);
               UNUSED(destination);
               return true;
            }

            void number_of_groups_update(int8_t diff) const
            {
               uint8_t value = number_of_groups();

               NumberOfGroups old_attr(value - diff, this);
               NumberOfGroups new_attr(value, this);

               notify(old_attr, new_attr);
            }

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

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

            void added(const Protocol::Address &addr, Common::Result result,
                       const AddMessage &request, uint8_t reference);

            virtual IGroupTable &group_table() const = 0;

            friend struct IGroupTable;
         };

         struct IGroupTable: protected GroupTable::Client
         {
            IGroupTable(IServer &_server): GroupTable::Client(_server.unit()),
               server(_server)
            {}

            using GroupTable::Client::uid;
            using GroupTable::Client::handle;
            using GroupTable::Client::remove;

            virtual void add(const Protocol::Address &source, const Message &request,
                             uint8_t reference);

            protected:

            IServer &server;

            using GroupTable::Client::added;

            void added(const Protocol::Address &dest, Common::Result result,
                       const AddMessage &request, uint8_t reference)
            {
               server.added(dest, result, request, reference);
            }
         };

         struct GroupTableClient: public IGroupTable
         {
            typedef std::tuple<Protocol::Address, Message, uint8_t> Entry;

            enum Fields
            {
               ADDRESS,
               MESSAGE,
               REFERENCE,
            };

            GroupTableClient(IServer &_server): IGroupTable(_server)
            {}

            void add(const Protocol::Address &source, const AddMessage &request,
                     uint8_t reference);

            protected:

            std::forward_list<Entry> requests;

            using IGroupTable::added;

            void added(const Protocol::Address &addr, const GroupTable::Response &response);
         };

         template<typename _Entries = Entries, typename _GroupTable = GroupTableClient>
         class Server: public IServer
         {
            protected:

            _Entries _entries;
            _GroupTable _group_table;

            public:

            Server(Unit0 &unit): IServer(unit), _group_table(*this)
            {}

            Server(const Server &other):
               IServer(other._unit), _group_table(*this)
            {}

            virtual ~Server()
            {}

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

            protected:

            _GroupTable &group_table() const
            {
               return const_cast<_GroupTable &>(_group_table);
            }
         };

         typedef Server<> DefaultServer;

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

            virtual ~Client() {}

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

            void create(std::string name);

            void remove(uint16_t group);

            void add(uint16_t group, uint16_t device, uint8_t unit);

            void remove(uint16_t group, uint16_t device, uint8_t unit);

#ifdef HF_CORE_GROUP_MANAGEMENT_GET_INFO_CMD

            void get_info(uint16_t group);
#endif

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

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

            virtual void created(CreateResponse &response) = 0;

            virtual void deleted(DeleteResponse &response) = 0;

            virtual void added(AddResponse &response) = 0;

            virtual void removed(RemoveResponse &response) = 0;

            virtual void got_info(InfoResponse &response) = 0;

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

            protected:

            using ServiceRole::payload_size;

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

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

         };

      }  // namespace GroupManagement

   }  // namespace Core

}   // namespace HF

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

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

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