devices.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_DEVICES_H
#define HF_DEVICES_H

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

#include "hanfun/device.h"

#include "hanfun/core.h"
#include "hanfun/core/device_information.h"
#include "hanfun/core/device_management.h"
#include "hanfun/core/bind_management.h"
#include "hanfun/core/attribute_reporting.h"

#if HF_GROUP_SUPPORT
   #include "hanfun/core/group_table.h"
   #include "hanfun/core/group_management.h"
#endif

#if HF_TIME_SUPPORT
   #include "hanfun/core/time.h"
#endif

#if HF_BATCH_PROGRAM_SUPPORT
   #include "hanfun/core/batch_program_management.h"
#endif

#if HF_EVENT_SCHEDULING_SUPPORT
   #include "hanfun/core/event_scheduling.h"
#endif

#if HF_WEEKLY_SCHEDULING_SUPPORT
   #include "hanfun/core/weekly_scheduling.h"
#endif

#include "hanfun/transport.h"

namespace HF
{
   namespace Devices
   {
      struct AbstractDevice: public IDevice
      {
         // =============================================================================
         // IDevice API
         // =============================================================================

         const IUnits &units() const
         {
            return _units;
         }

         void add(Units::IUnit *unit)
         {
            _units.push_front(unit);
         }

         void remove(Units::IUnit *unit)
         {
            _units.remove(unit);
         }

         Units::IUnit *unit(uint8_t id) const;

         void send(Protocol::Packet &packet);

         void receive(Protocol::Packet &packet, Common::ByteArray &payload, uint16_t offset);

         void periodic(uint32_t time);

         protected:

         uint8_t next_reference;

         IUnits _units;

         Protocol::Filters::ResponseRequired response_filter;

         AbstractDevice():
            next_reference(0)
         {}

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

         virtual Transport::Link *link(uint16_t addr) const = 0;

         virtual bool to_local(const Protocol::Packet &packet) const
         {
            return packet.destination.device == address();
         }

         bool from_local(const Protocol::Packet &packet) const
         {
            return packet.source.device == address();
         }

         bool from_remote(const Protocol::Packet &packet)
         {
            return !from_local(packet);
         }

         bool is_registered()
         {
            return this->address() != Protocol::BROADCAST_ADDR;
         }
      };

      namespace Node
      {
         struct IUnit0: public HF::Core::Unit0, public HF::IDevice::IUnit0
         {
            IUnit0(HF::IDevice &device):
               HF::Core::Unit0(device)
            {}

            virtual HF::Core::DeviceManagement::Client *device_management() = 0;

            virtual HF::Core::DeviceManagement::Client *device_management() const = 0;
         };

         template<typename... ITF>
         struct Unit0: public HF::Unit0<IUnit0, ITF...>
         {
            static_assert(std::is_base_of<HF::Core::DeviceManagement::Client,
                                          typename HF::Unit0<IUnit0, ITF...>::DeviceMgt>::value,
                          "DeviceMgt must be of type HF::Core::DeviceManagement::Client");

            typedef std::tuple<ITF...> interfaces_t;

            typedef typename HF::Unit0<IUnit0, ITF...> _Parent;

            typedef typename _Parent::DeviceInfo DeviceInfo;
            typedef typename _Parent::DeviceMgt DeviceMgt;
            typedef typename _Parent::AttrReporting AttrReporting;
#if HF_GROUP_SUPPORT
            typedef typename _Parent::GroupTable GroupTable;
#endif
#if HF_TIME_SUPPORT
            typedef typename _Parent::Time Time;
#endif
#if HF_BATCH_PROGRAM_SUPPORT
            typedef typename _Parent::BatchProgram BatchProgram;
#endif
#if HF_EVENT_SCHEDULING_SUPPORT
            typedef typename _Parent::EventScheduling EventScheduling;
#endif
#if HF_WEEKLY_SCHEDULING_SUPPORT
            typedef typename _Parent::WeeklyScheduling WeeklyScheduling;
#endif

            Unit0(IDevice &device):
               HF::Unit0<IUnit0, ITF...>(device)
            {}

            DeviceInfo *device_info() const
            {
               return _Parent::device_info();
            }

            DeviceInfo *device_info()
            {
               return _Parent::device_info();
            }

            AttrReporting *attribute_reporting() const
            {
               return _Parent::attribute_reporting();
            }

            AttrReporting *attribute_reporting()
            {
               return _Parent::attribute_reporting();
            }

            DeviceMgt *device_management()
            {
               return _Parent::device_management();
            }

            DeviceMgt *device_management() const
            {
               return _Parent::device_management();
            }

#if HF_GROUP_SUPPORT

            GroupTable *group_table()
            {
               return _Parent::group_table();
            }

            GroupTable *group_table() const
            {
               return _Parent::group_table();
            }
#endif
#if HF_TIME_SUPPORT
            Time *time()
            {
               return _Parent::time();
            }

            Time *time() const
            {
               return _Parent::time();
            }
#endif

#if HF_BATCH_PROGRAM_SUPPORT
            BatchProgram *batch_program()
            {
               return _Parent::batch_program();
            }

            BatchProgram *batch_program() const
            {
               return _Parent::batch_program();
            }
#endif

#if HF_EVENT_SCHEDULING_SUPPORT
            EventScheduling *event_scheduling()
            {
               return _Parent::event_scheduling();
            }

            EventScheduling *event_scheduling() const
            {
               return _Parent::event_scheduling();
            }
#endif

#if HF_WEEKLY_SCHEDULING_SUPPORT
            WeeklyScheduling *weekly_scheduling()
            {
               return _Parent::weekly_scheduling();
            }

            WeeklyScheduling *weekly_scheduling() const
            {
               return _Parent::weekly_scheduling();
            }
#endif
         };

         typedef Unit0<Core::DeviceInformation::Server,
                       Core::DeviceManagement::Client,
                       Core::AttributeReporting::Server
#if HF_TIME_SUPPORT
                       , HF::Core::Time::Server
#endif
#if HF_BATCH_PROGRAM_SUPPORT
                       , HF::Core::BatchProgramManagement::DefaultServer
#endif
#if HF_EVENT_SCHEDULING_SUPPORT
                       , HF::Core::Scheduling::Event::DefaultServer
#endif
#if HF_WEEKLY_SCHEDULING_SUPPORT
                       , HF::Core::Scheduling::Weekly::DefaultServer
#endif
#if HF_GROUP_SUPPORT
                       , Core::GroupTable::DefaultServer
#endif
                      > DefaultUnit0;

         template<typename CoreServices = DefaultUnit0>
         class Abstract: public AbstractDevice
         {
            public:

            // =============================================================================
            // Transport::Endpoint API
            // =============================================================================

            void connected(HF::Transport::Link *link) _override
            {
               _link = link;
            }

            void disconnected(HF::Transport::Link *link) _override
            {
               if (_link == link)
               {
                  _link = nullptr;
               }
            }

            void receive(Protocol::Packet &packet, Common::ByteArray &payload,
                         uint16_t offset) _override
            {
               AbstractDevice::receive(packet, payload, offset);
            }

            // =============================================================================
            // IDevice API.
            // =============================================================================

            uint16_t address() const _override
            {
               return unit0()->device_management()->address();
            }

            CoreServices *unit0() const _override
            {
               return const_cast<CoreServices *>(&_unit0);
            }

            protected:

            HF::Transport::Link *_link;

            CoreServices _unit0;

            Abstract(): _link(nullptr), _unit0(*this)
            {}

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

            HF::Transport::Link *link(uint16_t addr) const _override
            {
               UNUSED(addr);
               return _link;
            }

            bool to_local(const Protocol::Packet &packet) const _override
            {
               return AbstractDevice::to_local(packet) ||
                      // If we are unregistered only allow packets to unit 0.
                      (address() == Protocol::BROADCAST_ADDR && packet.destination.unit == 0);
            }
         };

         typedef Abstract<> Node;

         class Transport: public HF::Transport::AbstractLayer
         {
            protected:

            HF::Transport::Link *link;

            public:

            Transport():
               link(nullptr)
            {}

            void destroy()
            {
               remove((HF::Transport::Link *) nullptr);
            }

            void add(HF::Transport::Endpoint *ep)
            {
               HF::Transport::AbstractLayer::add(ep);

               if (link != nullptr)
               {
                  ep->connected(link);
               }
            }

            void add(HF::Transport::Link *_link)
            {
               assert(_link != nullptr);

               this->link = _link;
               HF::Transport::AbstractLayer::connected(_link);
            }

            void remove(HF::Transport::Link *_link = nullptr)
            {
               if ((_link == nullptr && this->link != nullptr) || (_link == this->link))
               {
                  HF::Transport::AbstractLayer::disconnected(this->link);
                  delete this->link;
                  this->link = nullptr;
               }
            }

            using HF::Transport::AbstractLayer::remove;

            HF::Transport::Link *find(uint16_t address)
            {
               UNUSED(address);
               return link;
            }
         };

      } // namespace Node

      namespace Concentrator
      {
         struct IUnit0: public HF::Core::Unit0, public HF::IDevice::IUnit0
         {
            IUnit0(HF::IDevice &device):
               HF::Core::Unit0(device)
            {}

            virtual HF::Core::DeviceManagement::IServer *device_management() = 0;

            virtual HF::Core::DeviceManagement::IServer *device_management() const = 0;

#if HF_GROUP_SUPPORT

            virtual HF::Core::GroupManagement::IServer *group_management() = 0;

            virtual HF::Core::GroupManagement::IServer *group_management() const = 0;
#endif

            virtual HF::Core::BindManagement::IServer *bind_management() = 0;

            virtual HF::Core::BindManagement::IServer *bind_management() const = 0;

         };

         template<typename... ITF>
         struct Unit0: public HF::Unit0<IUnit0, ITF...>
         {
            static_assert(std::is_base_of<HF::Core::DeviceManagement::IServer,
                                          typename HF::Unit0<IUnit0, ITF...>::DeviceMgt>::value,
                          "DeviceMgt must be of type HF::Core::DeviceManagement::IServer");

            typedef typename HF::Unit0<IUnit0, ITF...> _Parent;

            typedef typename _Parent::DeviceInfo DeviceInfo;
            typedef typename _Parent::DeviceMgt DeviceMgt;
            typedef typename _Parent::AttrReporting AttrReporting;

            typedef std::tuple<ITF...> interfaces_t;

#if HF_GROUP_SUPPORT
            typedef typename _Parent::GroupTable GroupTable;

            static constexpr uint8_t GROUP_MGT = _Parent::GROUP_MGT;

            typedef typename std::tuple_element<GROUP_MGT, interfaces_t>::type GroupMgt;

            static_assert(std::is_base_of<HF::Core::GroupManagement::IServer, GroupMgt>::value,
                          "GroupMgt must be of type HF::Core::GroupManagement::IServer");
#endif
#if HF_TIME_SUPPORT
            typedef typename _Parent::Time Time;
#endif
#if HF_BATCH_PROGRAM_SUPPORT
            typedef typename _Parent::BatchProgram BatchProgram;
#endif
#if HF_EVENT_SCHEDULING_SUPPORT
            typedef typename _Parent::EventScheduling EventScheduling;
#endif
#if HF_WEEKLY_SCHEDULING_SUPPORT
            typedef typename _Parent::WeeklyScheduling WeeklyScheduling;
#endif
            static constexpr uint8_t BIND_MGT = _Parent::BIND_MGT;

            typedef typename std::tuple_element<BIND_MGT, interfaces_t>::type BindMgt;

            static_assert(std::is_base_of<HF::Core::BindManagement::IServer, BindMgt>::value,
                          "BindMgt must be of type HF::Core::BindManagement::IServer");

            Unit0(HF::IDevice &device):
               HF::Unit0<IUnit0, ITF...>(device)
            {}

            BindMgt *bind_management() const
            {
               return _Parent::template get<BindMgt, BIND_MGT>();
            }

            BindMgt *bind_management()
            {
               return _Parent::template get<BindMgt, BIND_MGT>();
            }

            DeviceInfo *device_info() const
            {
               return _Parent::device_info();
            }

            DeviceInfo *device_info()
            {
               return _Parent::device_info();
            }

            AttrReporting *attribute_reporting() const
            {
               return _Parent::attribute_reporting();
            }

            AttrReporting *attribute_reporting()
            {
               return _Parent::attribute_reporting();
            }

#if HF_GROUP_SUPPORT
            GroupMgt *group_management() const
            {
               return _Parent::template get<GroupMgt, GROUP_MGT>();
            }

            GroupMgt *group_management()
            {
               return _Parent::template get<GroupMgt, GROUP_MGT>();
            }

            GroupTable *group_table()
            {
               return _Parent::group_table();
            }

            GroupTable *group_table() const
            {
               return _Parent::group_table();
            }
#endif

#if HF_TIME_SUPPORT
            Time *time()
            {
               return _Parent::time();
            }

            Time *time() const
            {
               return _Parent::time();
            }
#endif
#if HF_BATCH_PROGRAM_SUPPORT
            BatchProgram *batch_program()
            {
               return _Parent::batch_program();
            }

            BatchProgram *batch_program() const
            {
               return _Parent::batch_program();
            }
#endif
#if HF_EVENT_SCHEDULING_SUPPORT
            EventScheduling *event_scheduling()
            {
               return _Parent::event_scheduling();
            }

            EventScheduling *event_scheduling() const
            {
               return _Parent::event_scheduling();
            }
#endif
#if HF_WEEKLY_SCHEDULING_SUPPORT
            WeeklyScheduling *weekly_scheduling()
            {
               return _Parent::weekly_scheduling();
            }

            WeeklyScheduling *weekly_scheduling() const
            {
               return _Parent::weekly_scheduling();
            }
#endif

         };

         typedef Unit0<Core::DeviceInformation::Server,
                       Core::DeviceManagement::DefaultServer,
                       Core::AttributeReporting::Server,
#if HF_TIME_SUPPORT
                       Core::Time::Server,
#endif
#if HF_BATCH_PROGRAM_SUPPORT
                       Core::BatchProgramManagement::DefaultServer,
#endif
#if HF_EVENT_SCHEDULING_SUPPORT
                       Core::Scheduling::Event::DefaultServer,
#endif
#if HF_WEEKLY_SCHEDULING_SUPPORT
                       Core::Scheduling::Weekly::DefaultServer,
#endif
#if HF_GROUP_SUPPORT
                       Core::GroupTable::DefaultServer,
                       Core::GroupManagement::DefaultServer,
#endif
                       Core::BindManagement::DefaultServer
                      > DefaultUnit0;

         class AbstractBase: public AbstractDevice
         {
            public:

            // =============================================================================
            // IDevice API.
            // =============================================================================

            uint16_t address() const
            {
               return 0;
            }

            // =============================================================================
            // Transport::Endpoint API
            // =============================================================================

            void connected(HF::Transport::Link *link);

            void disconnected(HF::Transport::Link *link);

            void receive(Protocol::Packet &packet, Common::ByteArray &payload, uint16_t offset);

            virtual ~AbstractBase() {}

            protected:

            Common::SimpleList<Transport::Link *> _links;

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

            HF::Transport::Link *link(uint16_t addr) const;

            virtual void route_packet(Protocol::Packet &packet, Common::ByteArray &payload,
                                      uint16_t offset);

            virtual Concentrator::IUnit0 *unit0() const = 0;
         };

         template<typename CoreServices = DefaultUnit0>
         class Abstract: public AbstractBase
         {
            public:

            CoreServices *unit0() const
            {
               return const_cast<CoreServices *>(&_unit0);
            }

            protected:

            CoreServices _unit0;

            Abstract(): AbstractBase(), _unit0(*this)
            {}
         };

         typedef Abstract<> Concentrator;

         class Transport: public HF::Transport::AbstractLayer
         {
            protected:

            Common::SimpleList<HF::Transport::Link *> links;

            public:

            virtual ~Transport()
            {
               destroy();
            }

            void destroy();

            void add(HF::Transport::Endpoint *ep)
            {
               HF::Transport::AbstractLayer::add(ep);
               /* *INDENT-OFF* */
               std::for_each(links.begin(), links.end(), [ep](HF::Transport::Link *link)
               {
                  ep->connected (link);
               });
               /* *INDENT-ON* */
            }

            void add(HF::Transport::Link *link)
            {
               assert(link != nullptr);

               links.push_front(link);
               HF::Transport::AbstractLayer::connected(link);
            }

            void remove(HF::Transport::Link *link = nullptr);

            using HF::Transport::AbstractLayer::remove;

            HF::Transport::Link *find(uint16_t address);
         };

      } // namespace Concentrator

   }  // namespace Devices

}  // namespace HF

#endif /* HF_DEVICES_H */