group_table.h

Go to the documentation of this file.

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

#ifndef HF_CORE_GROUP_TABLE_H
#define HF_CORE_GROUP_TABLE_H

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

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

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

      namespace GroupTable
      {
         typedef enum _CMD
         {
            ADD_CMD          = 0x01, 
            REMOVE_CMD       = 0x02, 
            REMOVE_ALL_CMD   = 0x03, 
            READ_ENTRIES_CMD = 0x04, 
            __LAST_CMD__     = READ_ENTRIES_CMD
         } CMD;

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

         struct Entry
         {
            uint16_t group;   

            uint8_t  unit;    

            Entry(uint16_t _group = 0, uint8_t _unit = 0):
               group(_group), unit(_unit) {}

            Entry(const Entry &entry) = default;

            static constexpr uint16_t min_size = sizeof(uint16_t)   // Group Address
                                                 + sizeof(uint8_t); // Unit 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);
         };

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

         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::GROUP_TABLE, ID, owner, value, WRITABLE)
            {}
         };

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

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

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

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

         struct Response: public Protocol::Response, public Entry
         {
            Response(Common::Result code = Common::Result::FAIL_UNKNOWN,
                     uint16_t group = 0x0000, uint8_t unit = 0x00):
               Protocol::Response(code), Entry(group, unit) {}

            Response(Common::Result code, const Entry &entry):
               Protocol::Response(code), Entry(entry) {}

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

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

            uint16_t size() const
            {
               return Protocol::Response::size() + Entry::size();
            }

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

               uint16_t start = offset;

               offset += Protocol::Response::pack(array, offset);
               offset += Entry::pack(array, offset);

               return offset - start;
            }

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0)
            {
               HF_SERIALIZABLE_CHECK(array, offset, size());

               uint16_t start = offset;

               offset += Protocol::Response::unpack(array, offset);
               offset += Entry::unpack(array, offset);

               return offset - start;
            }
         };

         struct ReadEntries
         {
            uint8_t start; 
            uint8_t count; 

            ReadEntries(uint8_t _start = 0, uint8_t _count = 1):
               start(_start), count(_count) {}

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

            static constexpr uint16_t min_size = sizeof(uint8_t)
                                                 + sizeof(uint8_t);

            uint16_t size() const
            {
               return min_size;
            }

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

               offset += array.write(offset, start);
               offset += array.write(offset, count);

               return min_size;
            }

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0)
            {
               HF_SERIALIZABLE_CHECK(array, offset, min_size);

               offset += array.read(offset, start);
               offset += array.read(offset, count);

               return min_size;
            }
         };

         struct ReadEntriesResponse: public Protocol::Response
         {
            uint8_t            start;     

            std::vector<Entry> entries;   

            ReadEntriesResponse(Common::Result _code = Common::Result::OK,
                                uint8_t _start = 0, uint8_t _count = 0):
               Protocol::Response(_code), start(_start)
            {
               entries.reserve(_count);
            }

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

            static constexpr uint16_t min_size = Protocol::Response::min_size
                                                 + sizeof(uint8_t)
                                                 + sizeof(uint8_t);

            uint16_t size() const
            {
               uint16_t res = Protocol::Response::size()
                              + sizeof(uint8_t)
                              + sizeof(uint8_t);

               std::for_each(entries.begin(), entries.end(), [&res](const Entry &entry)
               {
                  res += entry.size();
               });

               return res;
            }

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

               uint16_t _start = offset;

               offset += Protocol::Response::pack(array, offset);

               offset += array.write(offset, start);
               offset += array.write(offset, (uint8_t) entries.size());

               std::for_each(entries.begin(), entries.end(),
                             [&array, &offset](const Entry &entry)
               {
                  offset += entry.pack(array, offset);
               });

               return offset - _start;
            }

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0)
            {
               HF_SERIALIZABLE_CHECK(array, offset, min_size);

               uint16_t _start = offset;

               offset += Protocol::Response::unpack(array, offset);

               offset += array.read(offset, start);

               uint8_t count = 0;
               offset += array.read(offset, count);

               HF_SERIALIZABLE_CHECK(array, offset, count * Entry::min_size);

               entries.reserve(count * Entry::min_size);

               for (int i = 0; i < count; ++i)
               {
                  Entry entry;
                  offset += entry.unpack(array, offset);
                  entries.push_back(entry);
               }

               return offset - _start;
            }
         };

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

         struct IEntries: public Common::IEntries<Entry>
         {
            // =============================================================================
            // API
            // =============================================================================

            virtual void clear() = 0;

            virtual void for_each(uint16_t group,
                                  std::function<void(const Entry &)> func) const = 0;

            virtual Entry const &operator[](uint8_t index) const = 0;
         };

         struct Entries: public IEntries
         {
            typedef std::vector<Entry> Container;

            uint16_t size() const;

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

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

            void clear();

            void for_each(uint16_t group, std::function<void(const Entry &)> func) const;

            Entry const &operator[](uint8_t index) const
            {
               return db.at(index);
            }

            protected:

            bool any_of(uint16_t group, uint8_t unit) const;

            Container db;  
         };

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

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

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

            uint8_t _number_of_max_entries;

            public:

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

            virtual ~IServer() {}

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

            virtual Common::Result add(const Protocol::Address &addr, const Entry &entry);

            virtual Common::Result remove(const Protocol::Address &addr, const Entry &entry);

            virtual Common::Result remove_all(const Protocol::Address &addr);

            virtual ReadEntriesResponse read_entries(const Protocol::Address &addr,
                                                     const ReadEntries &params);

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

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

            uint8_t number_of_entries() const;

            uint8_t number_of_max_entries() const;

            void number_of_max_entries(uint8_t __value);

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

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

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

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

            virtual IEntries &entries() const = 0;

            protected:

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


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

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

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

            virtual ~Server() {}

            IEntries &entries() const
            {
               return *(const_cast<_Entries *>(&db));
            }

            protected:

            _Entries db;
         };

         typedef Server<> DefaultServer;

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

            virtual ~Client() {}

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

            void add(const Protocol::Address &addr, const Entry &entry);

            void add(const uint16_t device, const Entry &entry)
            {
               Protocol::Address addr(device, 0);
               add(addr, entry);
            }

            void add(const Protocol::Address &addr, uint16_t group, uint8_t unit)
            {
               Entry entry(group, unit);

               add(addr, entry);
            }

            void add(const uint16_t device, uint16_t group, uint8_t unit)
            {
               Protocol::Address addr(device, 0);
               Entry entry(group, unit);
               add(addr, entry);
            }

            void remove(const Protocol::Address &addr, const Entry &entry);

            void remove(const uint16_t device, const Entry &entry)
            {
               Protocol::Address addr(device, 0);
               remove(addr, entry);
            }

            void remove(const Protocol::Address &addr, uint16_t group, uint8_t unit)
            {
               Entry entry(group, unit);

               remove(addr, entry);
            }

            void remove(const uint16_t device, uint16_t group, uint8_t unit)
            {
               Protocol::Address addr(device, 0);
               Entry entry(group, unit);
               remove(addr, entry);
            }

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

            void remove_all(uint16_t device)
            {
               Protocol::Address addr(device, 0);
               remove_all(addr);
            }

            void read_entries(const Protocol::Address &addr, const ReadEntries &params);

            void read_entries(const Protocol::Address &addr, const uint8_t offset,
                              const uint8_t count)
            {
               ReadEntries params(offset, count);

               read_entries(addr, params);
            }

            void read_entries(const uint16_t device, const ReadEntries &params)
            {
               Protocol::Address addr(device, 0);
               read_entries(addr, params);
            }

            void read_entries(const uint16_t device, const uint8_t offset, const uint8_t count)
            {
               Protocol::Address addr(device, 0);
               ReadEntries params(offset, count);
               read_entries(addr, params);
            }

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

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

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

            virtual void removed(const Protocol::Address &addr,
                                 const GroupTable::Response &response);

            virtual void removed_all(const Protocol::Address &addr,
                                     const Protocol::Response &response);

            virtual void read_entries(const Protocol::Address &addr,
                                      const ReadEntriesResponse &response);

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

            protected:

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


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

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

         inline bool operator==(const Entry &lhs, const Entry &rhs)
         {
            return lhs.group == rhs.group && lhs.unit == rhs.unit;
         }

         inline bool operator!=(const Entry &lhs, const Entry &rhs)
         {
            return !(lhs == rhs);
         }

      }  // namespace GroupTable

   }  // namespace Core

}   // namespace HF

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

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

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