attribute_reporting.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_CORE_ATTRIBUTE_REPORTING_H
#define HF_CORE_ATTRIBUTE_REPORTING_H

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

#include "hanfun/attributes.h"

namespace HF
{
   namespace Core
   {
      // Forward declaration.
      namespace AttributeReporting
      {
         struct IServer;
      }  // namespace AttributeReporting

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

      namespace AttributeReporting
      {
         typedef enum _CMD
         {
            PERIODIC_REPORT_CMD    = 0x01, 
            EVENT_REPORT_CMD       = 0x02, 
            CREATE_PERIODIC_CMD    = 0x01, 
            CREATE_EVENT_CMD       = 0x02, 
            ADD_PERIODIC_ENTRY_CMD = 0x03, 
            ADD_EVENT_ENTRY_CMD    = 0x04, 
            DELETE_REPORT_CMD      = 0x05, 
            GET_PERIODIC_ENTRIES   = 0x06, 
            GET_EVENT_ENTRIES      = 0x07, 
            UPDATE_INTERVAL_CMD    = 0x08, 
            __LAST_CMD__           = UPDATE_INTERVAL_CMD
         } CMD;

         typedef enum _Attributes
         {
            REPORT_COUNT_ATTR          = 0x01, 
            PERIODIC_REPORT_COUNT_ATTR = 0x02, 
            EVENT_REPORT_COUNT_ATTR    = 0x03, 
            __LAST_ATTR__              = EVENT_REPORT_COUNT_ATTR
         } Attributes;

         typedef enum _Type
         {
            PERIODIC = 0x00, 
            EVENT    = 0x01, 
         } Type;

         struct Reference
         {
            uint8_t type : 1; 
            uint8_t id   : 7; 

            Reference(uint8_t _type = 0, uint8_t _id = 0):
               type(_type), id(_id)
            {}

            static constexpr uint16_t min_size = sizeof(uint8_t);

            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 Entry
         {
            uint8_t           unit;    
            Common::Interface itf;     

            uint8_t           pack_id; 

            static constexpr uint16_t min_size = sizeof(uint8_t)               // Unit ID.
                                                 + Common::Interface::min_size // Interface
                                                 + sizeof(uint8_t);            // Attribute Pack 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);

            protected:

            Entry() {}
         };

         struct Rule
         {
            Reference report;

            Protocol::Address destination;

            static constexpr uint16_t min_size = Reference::min_size             // Report ID.
                                                 + Protocol::Address::min_size;  // Destination 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);

            protected:

            Rule() {}

            Rule(Type type): report(type) {}
         };

         namespace Periodic
         {
            struct Entry: public AttributeReporting::Entry
            {
               HF::Attributes::UIDS uids;

               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 Rule: public AttributeReporting::Rule
            {
               typedef Common::SimpleList<Entry> Container;

               typedef Container::iterator iterator;

               typedef Container::const_iterator const_iterator;

               uint32_t interval;

               uint32_t last_time;

               Rule(uint32_t _interval = 0): AttributeReporting::Rule(PERIODIC),
                  interval(_interval),
                  last_time(0)
               {}

               static constexpr uint16_t min_size = AttributeReporting::Rule::min_size   // Parent Min. Size.
                                                    + sizeof(uint32_t)                   // Interval Value.
                                                    + sizeof(uint8_t);                   // Nr. Entries.

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

               void add(const Entry &entry)
               {
                  entries.push_front(entry);
               }

               void clear()
               {
                  entries.clear();
               }

               uint16_t entries_count()
               {
                  return std::distance(entries.begin(), entries.end());
               }


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

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

               const_iterator cbegin() const
               {
                  return entries.cbegin();
               }

               const_iterator cend() const
               {
                  return entries.cend();
               }

               protected:

               Container entries;
            };

         }  // namespace Periodic

         namespace Event
         {
            typedef enum _Type
            {
               COV = 0x00, 
               HT  = 0x01, 
               LT  = 0x02, 
               EQ  = 0x03, 
            } Type;

            struct Field
            {
               Type type;

               uint8_t attr_uid;

               Common::ByteArray value;

               Field(Type _type = COV, uint8_t _attr_uid = 0):
                  type(_type), attr_uid(_attr_uid)
               {}

               static constexpr uint16_t min_size = sizeof(uint8_t)    // Field type.
                                                    + sizeof(uint8_t); // Size of value holder or COV value.

               uint16_t size(bool with_uid) const;

               uint16_t pack(Common::ByteArray &array, uint16_t offset, bool with_uid) const;

               uint16_t unpack(const Common::ByteArray &array, uint16_t offset, bool with_uid);
            };

            struct Entry: public AttributeReporting::Entry
            {
               std::vector<Field> fields;

               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 Rule: public AttributeReporting::Rule
            {
               typedef Common::SimpleList<Entry> Container;

               typedef Container::iterator iterator;

               typedef Container::const_iterator const_iterator;

               Rule(): AttributeReporting::Rule(EVENT)
               {}

               static constexpr uint16_t min_size = AttributeReporting::Rule::min_size    // Parent Min. Size.
                                                    + sizeof(uint8_t);                    // Nr. Entries.

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

               void add(const Entry &entry)
               {
                  entries.push_front(entry);
               }

               void clear()
               {
                  entries.clear();
               }

               uint16_t entries_count()
               {
                  return std::distance(entries.begin(), entries.end());
               }

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

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

               const_iterator cbegin() const
               {
                  return entries.cbegin();
               }

               const_iterator cend() const
               {
                  return entries.cend();
               }

               protected:

               Container entries;
            };

         }  // namespace Event

         namespace Report
         {
            // =============================================================================
            // Notification API
            // =============================================================================

            typedef std::shared_ptr<HF::Attributes::IAttribute> Attribute;

            struct Abstract: public AttributeReporting::Reference
            {
               Abstract(uint8_t type = 0, uint8_t id = 0):
                  AttributeReporting::Reference(type, id)
               {}
            };

            struct Entry
            {
               static constexpr uint16_t min_size = sizeof(uint8_t)                // Unit index size.
                                                    + Common::Interface::min_size  // Interface UID size.
                                                    + sizeof(uint8_t);             // Number of attributes/fields.

               uint8_t           unit; 
               Common::Interface itf;  

               Entry(): unit(0), itf(0, 0) {}

               Entry(uint8_t _unit, Common::Interface _itf):
                  unit(_unit), itf(_itf)
               {}

               virtual ~Entry() {}

               uint16_t size() const;

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

               uint16_t unpack(HF::Attributes::FactoryGetter get_factory,
                               const Common::ByteArray &array, uint16_t offset = 0);

               protected:

               virtual uint16_t unpack(HF::Attributes::Factory factory,
                                       const Common::ByteArray &array, uint16_t offset = 0)
               {
                  UNUSED(factory);
                  UNUSED(array);
                  UNUSED(offset);

                  return 0;
               }

               virtual uint8_t count() const
               {
                  return 0;
               }
            };

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

            struct CreateMessage
            {
               Protocol::Address destination;

               static constexpr uint16_t min_size = Protocol::Address::min_size; // Destination.

               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 DeleteMessage
            {
               Reference report;

               static constexpr uint16_t min_size = Reference::min_size; // Report 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);
            };

            struct AddEntryMessage
            {
               Reference report;

               virtual ~AddEntryMessage() {}

               static constexpr uint16_t min_size = Reference::min_size // Destination.
                                                    + sizeof(uint8_t);  // Nr. Entries.

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

               protected:

               AddEntryMessage() {}

               virtual uint16_t unpack_entry(const Common::ByteArray &array, uint16_t offset = 0)
               {
                  UNUSED(array);
                  UNUSED(offset);

                  return 0;
               }

               virtual uint8_t count() const
               {
                  return 0;
               }

               virtual uint16_t entry_size() const
               {
                  return 0;
               }
            };

            struct UpdateIntervalMessage
            {
               Reference report;    
               uint32_t  interval;  

               UpdateIntervalMessage(Type report_type, uint8_t ID, uint32_t interval):
                  report(report_type, ID), interval(interval)
               {}

               UpdateIntervalMessage(void): report(), interval(0)
               {}

               static constexpr uint16_t min_size = Reference::min_size    // Report ID.
                                                    + sizeof(interval);    // Periodic interval

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

            // =============================================================================
            // Periodic Report Support
            // =============================================================================

            struct Periodic: public Abstract
            {
               struct Entry: public Report::Entry
               {
                  std::vector<Report::Attribute> attributes;

                  Entry() {}

                  Entry(uint8_t unit, Common::Interface itf): Report::Entry(unit, itf)
                  {}

                  uint16_t size() const;

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

                  void add(HF::Attributes::IAttribute * &attr);

                  using Report::Entry::unpack;

                  protected:

                  uint16_t unpack(HF::Attributes::Factory factory,
                                  const Common::ByteArray &array, uint16_t offset = 0);

                  uint8_t count() const
                  {
                     return attributes.size();
                  }
               };

               Common::SimpleList<Entry> entries;

               Periodic(uint8_t id = 0): Abstract(PERIODIC, id)
               {}

               uint16_t size() const;

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

               uint16_t unpack(HF::Attributes::FactoryGetter get_factory,
                               const Common::ByteArray &array, uint16_t offset = 0);

               void add(Entry &entry);

               // =============================================================================
               // Message API
               // =============================================================================

               struct CreateMessage: public Report::CreateMessage
               {
                  uint32_t interval;

                  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 AddEntryMessage: public Report::AddEntryMessage
               {
                  typedef Common::SimpleList<AttributeReporting::Periodic::Entry> Container;

                  typedef Container::iterator iterator;

                  typedef Container::const_iterator const_iterator;

                  AddEntryMessage()
                  {
                     report.type = PERIODIC;
                  }

                  uint16_t size() const;

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

                  void add(const AttributeReporting::Periodic::Entry &entry)
                  {
                     entries.push_front(entry);
                  }

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

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

                  const_iterator cbegin() const
                  {
                     return entries.cbegin();
                  }

                  const_iterator cend() const
                  {
                     return entries.cend();
                  }

                  protected:

                  Container entries;

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

                  uint8_t count() const
                  {
                     return std::distance(entries.begin(), entries.end());
                  }

                  uint16_t entry_size() const
                  {
                     return AttributeReporting::Periodic::Entry::min_size;
                  }
               };
            };

            // =============================================================================
            // Event Report Support
            // =============================================================================

            struct Event: public Abstract
            {
               struct Field
               {
                  static constexpr uint16_t min_size = sizeof(uint8_t)     // Event Type size.
                                                       + sizeof(uint8_t);  // Attribute UID.

                  AttributeReporting::Event::Type type;

                  Attribute attribute;

                  uint16_t size() const;

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

                  uint16_t unpack(HF::Attributes::Factory factory, const Common::ByteArray &array,
                                  uint16_t offset = 0);

                  void set_attribute(HF::Attributes::IAttribute *attr)
                  {
                     Attribute temp(attr);

                     attribute = std::move(temp);
                  }
               };

               struct Entry: public Report::Entry
               {
                  std::vector<Field> fields;

                  Entry() {}

                  Entry(uint8_t unit, Common::Interface itf): Report::Entry(unit, itf)
                  {}

                  uint16_t size() const;

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

                  void add(Field &field)
                  {
                     fields.push_back(std::move(field));
                  }

                  using Report::Entry::unpack;

                  protected:

                  uint16_t unpack(HF::Attributes::Factory factory,
                                  const Common::ByteArray &array, uint16_t offset = 0);

                  uint8_t count() const
                  {
                     return fields.size();
                  }
               };

               Common::SimpleList<Entry> entries;

               Event(uint8_t id = 0): Abstract(EVENT, id)
               {}

               uint16_t size() const;

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

               uint16_t unpack(HF::Attributes::FactoryGetter get_factory,
                               const Common::ByteArray &array, uint16_t offset = 0);

               void add(Entry &entry)
               {
                  entries.push_front(std::move(entry));
               }

               // =============================================================================
               // Message API
               // =============================================================================

               struct CreateMessage: public Report::CreateMessage
               {};

               struct AddEntryMessage: public Report::AddEntryMessage
               {
                  typedef Common::SimpleList<AttributeReporting::Event::Entry> Container;

                  typedef Container::iterator iterator;

                  typedef Container::const_iterator const_iterator;

                  AddEntryMessage()
                  {
                     report.type = EVENT;
                  }

                  uint16_t size() const;

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

                  void add(const AttributeReporting::Event::Entry &entry)
                  {
                     entries.push_front(entry);
                  }

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

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

                  const_iterator cbegin() const
                  {
                     return entries.cbegin();
                  }

                  const_iterator cend() const
                  {
                     return entries.cend();
                  }

                  protected:

                  Container entries;

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

                  uint8_t count() const
                  {
                     return std::distance(entries.begin(), entries.end());
                  }

                  uint16_t entry_size() const
                  {
                     return AttributeReporting::Event::Entry::min_size;
                  }
               };

               static Report::Event::Entry *process(
                  const AttributeReporting::Event::Entry &entry,
                  const HF::Attributes::IAttribute &old_value,
                  const HF::Attributes::IAttribute &new_value);
            };

         }  // namespace Report

         // =============================================================================
         // Message API
         // =============================================================================

         struct Response: public HF::Protocol::Response
         {
            Reference report;

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

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

         static constexpr uint8_t START_ADDR = 0x01;

         static constexpr uint8_t MAX_ADDR = 0x7E;

         static constexpr uint8_t ALL_ADDR = 0x7F;

         typedef std::vector<Periodic::Entry>::iterator periodic_iterator;
         typedef std::vector<Event::Entry>::iterator event_iterator;

         Protocol::Message *create(Protocol::Address &destination);

         Protocol::Message *create(Protocol::Address &destination, uint32_t interval);

         Protocol::Message *destroy(Type type, uint8_t report_id);

         Protocol::Message *destroy(Reference report);

         Protocol::Message *add(Reference report, periodic_iterator begin, periodic_iterator end);

         Protocol::Message *add(Reference report, event_iterator begin, event_iterator end);

         Protocol::Message *update(Reference report, uint32_t new_interval);

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

         struct Client: public HF::Interfaces::Interface<HF::Interface::ATTRIBUTE_REPORTING>
         {
            // =============================================================================
            // Interface API
            // =============================================================================

            Interface::Role role() const
            {
               return HF::Interface::CLIENT_ROLE;
            }

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

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

            virtual void report(Type type, const Protocol::Address &address,
                                const Common::ByteArray &payload, uint16_t offset)
            {
               UNUSED(type);
               UNUSED(address);
               UNUSED(payload);
               UNUSED(offset);
            }

            virtual void created(const Protocol::Address &address, const Response &response)
            {
               UNUSED(address);
               UNUSED(response);
            }

            virtual void added(const Protocol::Address &address, const Response &response)
            {
               UNUSED(address);
               UNUSED(response);
            }

            virtual void deleted(const Protocol::Address &address, const Response &response)
            {
               UNUSED(address);
               UNUSED(response);
            }

            virtual void updated(const Protocol::Address &address, const Response &response)
            {
               UNUSED(address);
               UNUSED(response);
            }

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

            protected:

            uint16_t payload_size(Protocol::Message &message) const;

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

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

         };

         struct AbstractClient: public Client
         {
            // =============================================================================
            // API
            // =============================================================================

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

            void create(Protocol::Address &destination);

            void create(Protocol::Address &destination, uint32_t interval);

            void destroy(Protocol::Address &destination, Type type, uint8_t report_id);

            void destroy(Protocol::Address &destination, Reference report);

            void add(Protocol::Address &destination, Reference report,
                     periodic_iterator begin, periodic_iterator end);

            void add(Protocol::Address &destination, Reference report,
                     event_iterator begin, event_iterator end);

            void update_interval(Protocol::Address &destination,
                                 Reference report, uint32_t interval);

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

            protected:

            virtual HF::Units::IUnit &unit() const = 0;
         };

         struct IServer: public AbstractService
         {
            IServer(Unit0 &unit):
               AbstractService(unit)
            {}

            virtual ~IServer() {}

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

            uint16_t uid() const
            {
               return HF::Interface::ATTRIBUTE_REPORTING;
            }

            Interface::Role role() const
            {
               return HF::Interface::SERVER_ROLE;
            }

            virtual void notify(uint8_t unit, const HF::Attributes::IAttribute &old_value,
                                const HF::Attributes::IAttribute &new_value)
            {
               UNUSED(unit);
               UNUSED(old_value);
               UNUSED(new_value);
            }

            virtual uint16_t count(Type type) const
            {
               UNUSED(type);
               return 0;
            }

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

            HF::Attributes::IAttribute *attribute(uint8_t uid)
            {
               return Core::create_attribute(this, uid);
            }

            HF::Attributes::UIDS attributes(uint8_t pack_id =
                                               HF::Attributes::Pack::MANDATORY) const
            {
               UNUSED(pack_id);
               return HF::Attributes::UIDS {REPORT_COUNT_ATTR, PERIODIC_REPORT_COUNT_ATTR,
                                            EVENT_REPORT_COUNT_ATTR};
            }

            protected:

            using AbstractService::notify;

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

            void response(Protocol::Packet &packet, Reference &report, Common::Result result);

            virtual bool authorized(uint8_t member, Protocol::Address &source)
            {
               UNUSED(member);
               UNUSED(source);

               return true;
            }

            bool check_uid(uint16_t uid) const
            {
               return IServer::uid() == uid;
            }
         };

         struct Server: public IServer
         {
            Common::SimpleList<Periodic::Rule> periodic_rules;     
            Common::SimpleList<Event::Rule>    event_rules;        

            Server(Unit0 &unit):
               IServer(unit), last_time(0)
            {}

            virtual ~Server() {}

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

            virtual Common::Result handle(const Report::Periodic::CreateMessage &message);

            virtual Common::Result handle(const Report::Periodic::AddEntryMessage &message);

            virtual Common::Result handle(const Report::Event::CreateMessage &message);

            virtual Common::Result handle(const Report::Event::AddEntryMessage &message);

            virtual Common::Result handle(const Report::DeleteMessage &message);

            virtual Common::Result handle(const Report::UpdateIntervalMessage &message);

            using HF::Interfaces::AbstractInterface::handle;

            void periodic(uint32_t time);

            void notify(uint8_t unit, const HF::Attributes::IAttribute &old_value,
                        const HF::Attributes::IAttribute &new_value);

            uint16_t count(Type type) const;

            protected:

            uint32_t last_time;

            using AbstractService::notify;

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

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

      }  // namespace AttributeReporting

   }  // namespace Core

}  // namespace HF

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

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

std::ostream &operator<<(std::ostream &stream,
                         const HF::Core::AttributeReporting::Attributes attribute);

#endif /* HF_CORE_ATTRIBUTE_REPORTING_H */