units.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_UNITS_H
#define HF_UNITS_H

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

#include "hanfun/device.h"

namespace HF
{
   // Forward declaration.
   namespace Core
   {
      struct IService;
   }

   namespace Units
   {
      struct IUnit: public Profiles::IProfile
      {
         virtual ~IUnit() {}

         virtual uint8_t id() const = 0;

         virtual IDevice &device() const = 0;

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

         virtual void send(const Protocol::Address &addr, Protocol::Message &message,
                           Transport::Link *link = nullptr) = 0;

         virtual std::vector<Common::Interface> interfaces() const = 0;

         virtual void periodic(uint32_t time) = 0;
      };

      class AbstractUnit: public IUnit
      {
         IDevice &_device;

         public:

         virtual ~AbstractUnit()
         {
            device().remove(this);
         }

         IDevice &device() const
         {
            return _device;
         }

         void send(const Protocol::Address &addr, Protocol::Message &message,
                   Transport::Link *link);

         std::vector<Common::Interface> interfaces() const
         {
            return std::vector<Common::Interface>();
         }

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

         protected:

         uint8_t _id;

         AbstractUnit(IDevice &device): _device(device)
         {
            device.add(this);
         }

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

      template<typename _Interface, typename _Proxy, typename = void>
      struct Proxy: public HF::Interfaces::Proxy<_Interface, _Proxy>
      {
         Proxy(_Proxy &_proxy): HF::Interfaces::Proxy<_Interface, _Proxy>(_proxy)
         {}

         HF::Units::IUnit &unit() const
         {
            return HF::Interfaces::Proxy<_Interface, _Proxy>::proxy;
         }
      };

      template<typename _Interface, typename _Proxy>
      struct Proxy<_Interface, _Proxy, EnableIf(IsParent(HF::Core::IService, _Interface))>:
         public _Interface
      {
         typedef _Interface base;

         Proxy(_Proxy &_proxy): _Interface(_proxy)
         {}
      };

      template<typename Base, typename... ITF>
      class InterfacesWrapper: public Interfaces::Container<Base, Proxy<ITF, Base>...>
      {
         typedef Interfaces::Container<Base, Proxy<ITF, Base>...> Container;

         public:

         InterfacesWrapper(Base &base): Container(base)
         {}
      };

      template<class Profile, typename... ITF>
      class Unit: public HF::Units::AbstractUnit, public virtual Profile,
         public InterfacesWrapper<HF::Units::Unit<Profile, ITF...>, ITF...>
      {
         uint8_t _id;

         typedef Unit<Profile, ITF...> Base;
         typedef InterfacesWrapper<Unit<Profile, ITF...>, ITF...> Wrapper;

         public:

         Unit(uint8_t id, IDevice &device):
            Profile(), HF::Units::AbstractUnit(device),
            Wrapper(*this), _id(id)
         {}

         uint8_t id() const
         {
            return _id;
         }

         uint16_t uid() const
         {
            return Profile::uid();
         }

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

            // Message not handled by base profile, then try extra interfaces.
            if (result == Common::Result::FAIL_ARG)
            {
               return Wrapper::handle(packet, payload, offset);
            }

            return result;
         }

         HF::Attributes::List attributes(Common::Interface itf, uint8_t pack_id,
                                         const HF::Attributes::UIDS &uids) const
         {
            auto result = Profile::attributes(itf, pack_id, uids);

            Wrapper::attributes(result, itf, pack_id, uids);

            return result;
         }

         using HF::Units::AbstractUnit::send;

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

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

         std::vector<Common::Interface> interfaces() const
         {
            return Wrapper::interfaces();
         }

         void periodic(uint32_t time)
         {
            Profile::periodic(time);
            Wrapper::periodic(time);
         }
      };

   }  // namespace Units

}  // namespace HF

#endif /* HF_UNITS_H */