interface.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_INTERFACE_H
#define HF_INTERFACE_H

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

#include "hanfun/protocol.h"

namespace HF
{
   struct Interface
   {
      typedef enum _Role
      {
         CLIENT_ROLE = 0,   
         SERVER_ROLE = 1,   
      } Role;

      typedef enum _UID
      {
         /* Core Services */
         DEVICE_MANAGEMENT        = 0x0001, 
         BIND_MANAGEMENT          = 0x0002, 
         GROUP_MANAGEMENT         = 0x0003, 
         IDENTIFY                 = 0x0004, 
         DEVICE_INFORMATION       = 0x0005, 
         ATTRIBUTE_REPORTING      = 0x0006, 
         BATCH_PROGRAM_MANAGEMENT = 0x0007, 
         EVENT_SCHEDULING         = 0x0008, 
         WEEKLY_SCHEDULING        = 0x0009, 
         GROUP_TABLE              = 0x000A, 
         TAMPER_ALERT             = 0x0101, 
         TIME                     = 0x0102, 
         POWER                    = 0x0110, 
         KEEP_ALIVE               = 0x0115, 
         RSSI                     = 0x0111, 
         SUOTA                    = 0x0400, 

         /* Functional Interfaces. */
         ALERT                 = 0x0100, 
         ON_OFF                = 0x0200, 
         LEVEL_CONTROL         = 0x0201, 
         COLOUR_CONTROL        = 0x0202, 
         SIMPLE_KEYPAD         = 0x0203, 
         SIMPLE_POWER_METER    = 0x0300, 
         SIMPLE_TEMPERATURE    = 0x0301, 
         SIMPLE_HUMIDITY       = 0x0302, 
         SIMPLE_THERMOSTAT     = 0x0303, 
         SIMPLE_BUTTON         = 0x0304, 
         SIMPLE_VISUAL_EFFECTS = 0x0305, 
         SIMPLE_AIR_PRESSURE   = 0x0306, 
         SIMPLE_LIGHT_SENSOR   = 0x0307, 

         /* Reserved */
         RESERVED = 0x7F00,              
         MAX_UID  = 0x7FFE,              
         ANY_UID  = 0x7FFF,              
      } UID;

      struct Any: public Common::Interface
      {
         Any(): Common::Interface(ANY_UID)
         {}
      };

      static constexpr uint8_t MAX_CMD_ID = 0xFF;

      virtual ~Interface() {}

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

      virtual uint16_t uid() const = 0;

      virtual Interface::Role role() const = 0;

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

      virtual void periodic(uint32_t time) = 0;

      virtual HF::Attributes::IAttribute *attribute(uint8_t uid) = 0;

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

   namespace Interfaces
   {
      struct AbstractInterface: virtual public HF::Interface
      {
         virtual ~AbstractInterface() {}

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

         void periodic(uint32_t time)
         {
            UNUSED(time);
         }

         HF::Attributes::IAttribute *attribute(uint8_t uid)
         {
            UNUSED(uid);
            return nullptr;
         }

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

         bool operator==(AbstractInterface &other)
         {
            return uid() == other.uid();
         }

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

         protected:

         virtual void send(const Protocol::Address &addr, Protocol::Message &message) = 0;

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

         Common::Result check(Protocol::Message &message, Common::ByteArray &payload,
                              uint16_t offset);

         Common::Result check_payload_size(Protocol::Message &message, Common::ByteArray &payload,
                                           uint16_t offset);

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

         virtual uint16_t payload_size(Protocol::Message::Interface &itf) const
         {
            UNUSED(itf);
            return 0;
         }

         template<typename _Message>
         uint16_t payload_size_helper() const
         {
            _Message message;

            return message.size();
         }

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

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

         virtual bool check_uid(uint16_t uid) const = 0;
      };

      template<uint16_t _uid, typename Parent = AbstractInterface>
      struct Interface: public Parent
      {
         uint16_t uid() const
         {
            return _uid;
         }

         protected:

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

      template<typename Itf, HF::Interface::Role _role>
      struct InterfaceRole: public Itf
      {
         HF::Interface::Role role() const
         {
            return _role;
         }
      };

      template<typename _Interface, typename _Proxy>
      struct Proxy: public _Interface
      {
         static_assert(std::is_base_of<Interfaces::AbstractInterface, _Interface>::value,
                       "Interface MUST be of type HF::Interfaces::AbstractInterface !");

         typedef _Interface base;

         Proxy(_Proxy &_proxy): proxy(_proxy)
         {}

         void send(const Protocol::Address &addr, Protocol::Message &message)
         {
            proxy.send(addr, message);
         }

         void notify(const HF::Attributes::IAttribute &old_value,
                     const HF::Attributes::IAttribute &new_value) const
         {
            proxy.notify(old_value, new_value);
         }

         protected:

         _Proxy &proxy;
      };

      template<typename Base, typename... Proxies>
      class Container
      {
         typedef std::tuple<Proxies...> interfaces_t;

         interfaces_t _interfaces;

         public:

         Container(Base &base): _interfaces(Proxies(base) ...)
         {}

         Common::Result handle(Protocol::Packet &packet, Common::ByteArray &payload,
                               uint16_t offset)
         {
            HF::Interface *itf = find<0, Proxies...>(packet.message.itf.id);

            if (itf != nullptr)
            {
               return itf->handle(packet, payload, offset);
            }
            else
            {
               return Common::Result::FAIL_SUPPORT;
            }
         }

         void attributes(HF::Attributes::List &attr_list, Common::Interface itf, uint8_t pack_id,
                         const HF::Attributes::UIDS &uids) const
         {
            attributes_itf<0, Proxies...>(attr_list, itf, pack_id, uids);
         }

         std::vector<Common::Interface> interfaces() const
         {
            std::vector<Common::Interface> result;
            result.reserve(sizeof ... (Proxies));

            Common::Interface temp;
            /* *INDENT-OFF* */
            for_each ([&result, &temp](HF::Interface &itf)
            {
                temp.id = itf.uid ();
                temp.role = itf.role ();
                result.push_back (temp);
            });
            /* *INDENT-ON* */

            return result;
         }

         void periodic(uint32_t time)
         {
            /* *INDENT-OFF* */
            for_each ([time](HF::Interface &itf) { itf.periodic (time);});
            /* *INDENT-ON* */
         }

         template<uint8_t N>
         const typename std::tuple_element<N, interfaces_t>::type::base *get() const
         {
            return &std::get<N>(_interfaces);
         }

         protected:

         void for_each(std::function<void(HF::Interface &)> func) const
         {
            for_each<0, Proxies...>(func);
         }

         void for_each(std::function<void(HF::Interface &)> func)
         {
            for_each<0, Proxies...>(func);
         }

         protected:

         template<uint8_t N, typename Head, typename... Tail>
         HF::Interface *find(uint16_t itf_uid) const
         {
            static_assert(std::is_base_of<HF::Interface, Head>::value,
                          "Head must be of type HF::Interface");

            const Head &head = std::get<N>(_interfaces);

            if (head.uid() == itf_uid)
            {
               return const_cast<Head *>(&head);
            }
            else
            {
               return find<N + 1, Tail...>(itf_uid);
            }
         }

         template<uint8_t N>
         HF::Interface *find(uint16_t itf_uid) const
         {
            UNUSED(itf_uid);
            return nullptr;
         }

         template<uint8_t N, typename Head, typename... Tail>
         void for_each(std::function<void(HF::Interface &)> func) const
         {
            const auto &head = std::get<N>(this->_interfaces);

            func(*(const_cast<HF::Interface *>(static_cast<const HF::Interface *>(&head))));

            for_each<N + 1, Tail...>(func);
         }

         template<uint8_t N>
         void for_each(std::function<void(HF::Interface &)> func) const
         {
            UNUSED(func);
         }

         template<uint8_t N, typename Head, typename... Tail>
         void attributes_itf(HF::Attributes::List &attrs, Common::Interface itf,
                             uint8_t pack_id, const HF::Attributes::UIDS &uids) const
         {
            const auto &head = std::get<N>(this->_interfaces);

            if (head.uid() == itf.id)
            {
               auto result = HF::Attributes::get(head, pack_id, uids);
               attrs.merge(result);
            }
            else
            {
               attributes_itf<N + 1, Tail...>(attrs, itf, pack_id, uids);
            }
         }

         template<uint8_t N>
         void attributes_itf(HF::Attributes::List &attrs, Common::Interface itf,
                             uint8_t pack_id, const HF::Attributes::UIDS &uids) const
         {
            UNUSED(attrs);
            UNUSED(itf);
            UNUSED(pack_id);
            UNUSED(uids);
         }
      };

   }  // namespace Interfaces

}  // namespace HF

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

std::ostream &operator<<(std::ostream &stream, const HF::Interface::Role role);

std::ostream &operator<<(std::ostream &stream, const HF::Interface::UID uid);

#endif /* HF_INTERFACE_H */