device_management.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_DEVICE_MANGEMENT_H
#define HF_DEVICE_MANGEMENT_H

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

#include "hanfun/protocol.h"

#include "hanfun/core.h"
#include "hanfun/device.h"
#include "hanfun/units.h"

#include "hanfun/core/session_management.h"

namespace HF
{
   // Forward declarations

   namespace Devices
   {
      namespace Concentrator
      {
         struct IUnit0;

      }  // namespace Concentrator

   }  // namespace Devices

   namespace Core
   {
      // Forward declaration.
      namespace DeviceManagement
      {
         struct IServer;
      }  // namespace DeviceManagement

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

      namespace DeviceManagement
      {
         typedef enum _CMD
         {
            REGISTER_CMD      = 0x01, 
            DEREGISTER_CMD    = 0x02, 
            START_SESSION_CMD = 0x03, 
            END_SESSION_CMD   = 0x04, 
            GET_ENTRIES_CMD   = 0x05, 
            __LAST_CMD__      = GET_ENTRIES_CMD
         } CMD;

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

         constexpr static uint16_t START_ADDR = 0x0001;  
         constexpr static uint16_t END_ADDR   = 0x7FFE;  

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

         struct Unit
         {
            uint8_t  id;        
            uint16_t profile;   

            std::vector<Common::Interface> interfaces;

            Unit(uint8_t id = 0, uint16_t profile = 0):
               id(id), profile(profile)
            {}

            Unit(const HF::Units::IUnit &unit):
               id(unit.id()), profile(unit.uid()), interfaces(unit.interfaces())
            {}

            static constexpr uint16_t min_size = sizeof(uint8_t)     // Unit entry size.
                                                 + sizeof(uint8_t)   // Unit ID.
                                                 + sizeof(uint16_t); // Unit's profile UID.

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

            bool has_interface(uint16_t itf_uid, HF::Interface::Role role) const;
         };

         typedef Common::Pointer<const Unit> UnitPtr;

         struct Device
         {
            uint16_t          address;    
            std::vector<Unit> units;      

            uint16_t          emc;        

            HF::UID::UID      uid;        

            Device(): address(Protocol::BROADCAST_ADDR), emc(0)
            {}

            virtual ~Device()
            {}

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

            static constexpr uint16_t min_size = sizeof(uint16_t)   // Device Address.
                                                 + sizeof(uint8_t); // Number of units.

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

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

            bool operator==(Device &other)
            {
               if (this->address != other.address || this->uid != other.uid)
               {
                  return false;
               }
               else
               {
                  return true;
               }
            }

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

            // =============================================================================
            // Helpers
            // =============================================================================

            UnitPtr unit(uint16_t id) const
            {
               auto it = std::find_if(units.begin(), units.end(), [id](const Unit &unit)
               {
                  return unit.id == id;
               });

               if (it == units.end())
               {
                  return UnitPtr();
               }
               else
               {
                  return UnitPtr(*(it.base()));
               }
            }
         };

         typedef Common::Pointer<const Device> DevicePtr;

         // =============================================================================
         // Register Command Messages
         // =============================================================================

         struct RegisterMessage
         {
            uint16_t          emc;    
            std::vector<Unit> units;  

            HF::UID::UID      uid;    

            RegisterMessage(uint16_t emc = 0x0000, HF::UID::UID _uid = HF::UID::UID()):
               emc(emc), uid(_uid)
            {}

            virtual ~RegisterMessage();

            static constexpr uint16_t min_size = UID::UID_T::min_size // UID.
                                                 + sizeof(uint8_t);   // Number of units.

            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 RegisterResponse: public Protocol::Response
         {
            uint16_t address; 
            uint16_t emc;     

            RegisterResponse(uint16_t address = Protocol::BROADCAST_ADDR, uint16_t emc = 0):
               address(address & Protocol::BROADCAST_ADDR), emc(emc)
            {}

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

         // =============================================================================
         // De-register Command Messages.
         // =============================================================================

         struct DeregisterMessage
         {
            uint16_t address; 

            DeregisterMessage(uint16_t address = 0):
               address(address)
            {}

            static constexpr uint16_t min_size = sizeof(uint16_t);   // Device 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);
         };

         struct IEntries: public Common::IEntries<Device>
         {
            virtual DevicePtr find(uint16_t address) const = 0;

            virtual DevicePtr find(const HF::UID::UID &uid) const = 0;

            virtual uint16_t next_address() const = 0;
         };

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

         class Base: public Service<HF::Interface::DEVICE_MANAGEMENT>
         {
            protected:

            Base(Unit0 &unit): Service(unit) {}
         };

         class Client: public ServiceRole<Base, HF::Interface::CLIENT_ROLE>,
            protected SessionManagement::Client<Device>
         {
            typedef ServiceRole<Base, HF::Interface::CLIENT_ROLE> Service;

            protected:

            uint16_t _address; 

            public:

            typedef SessionManagement::Client<Device> SessionMgr;

            Client(Unit0 &unit):
               Service(unit), SessionMgr(), _address(Protocol::BROADCAST_ADDR)
            {}

            virtual ~Client() {}

            virtual uint16_t address() const
            {
               return _address;
            }

            SessionMgr &session()
            {
               return *this;
            }

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

            void register_device();

            void deregister(uint16_t address);

            void deregister()
            {
               deregister(_address);
            }

            // ======================================================================
            // Session Management
            // ======================================================================

            void start_session() const
            {
               SessionMgr::request<SERVER_ROLE, Interface::DEVICE_MANAGEMENT,
                                   START_SESSION_CMD>();
            }

            void get_entries(uint16_t offset, uint8_t count = 0) const
            {
               SessionMgr::get_entries<SERVER_ROLE, Interface::DEVICE_MANAGEMENT,
                                       GET_ENTRIES_CMD>(offset, count);
            }

            void end_session() const
            {
               SessionMgr::request<SERVER_ROLE, Interface::DEVICE_MANAGEMENT,
                                   END_SESSION_CMD>();
            }

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

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

            virtual void registered(RegisterResponse &response);

            virtual void deregistered(Protocol::Response &response);

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

            using Service::send;

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

            protected:

            using ServiceRole::payload_size;

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

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

         struct IServer: public ServiceRole<Base, HF::Interface::SERVER_ROLE>
         {
            virtual ~IServer() {}

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

            HF::Devices::Concentrator::IUnit0 &unit0() const;

            DevicePtr entry(uint16_t address) const;

            DevicePtr entry(const HF::UID::UID &uid) const
            {
               return entries().find(uid);
            }

            virtual IEntries &entries() const = 0;

            virtual SessionManagement::IServer &sessions() = 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 {NUMBER_OF_ENTRIES_ATTR};
            }

            virtual uint16_t next_address()
            {
               return entries().next_address();
            }

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

            virtual void registered(DevicePtr &device)
            {
               UNUSED(device);
            }

            virtual void deregistered(DevicePtr &device)
            {
               UNUSED(device);
            }

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

            protected:

            IServer(Unit0 &unit): ServiceRole(unit)
            {}
         };

         struct AbstractServer: public IServer
         {
            virtual ~AbstractServer() {}

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

            protected:

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

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

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

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

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

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

            virtual bool authorized(uint8_t member, DevicePtr &source, DevicePtr &destination);

            virtual Common::Result deregister(DevicePtr &device);

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

            using ServiceRole<Base, HF::Interface::SERVER_ROLE>::payload_size;

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

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

         struct Entries: public IEntries
         {
            typedef std::vector<Device> Container;
            typedef Container::iterator iterator;
            typedef Container::const_iterator const_iterator;
            typedef Container::value_type value_type;

            uint16_t size() const
            {
               return db.size();
            }

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

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

            DevicePtr find(uint16_t address) const;

            DevicePtr find(const HF::UID::UID &uid) const;

            uint16_t next_address() const;

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

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

            const_iterator begin() const
            {
               return db.cbegin();
            }

            const_iterator end() const
            {
               return db.cend();
            }

            protected:

            Container db;
         };

         template<typename _Entries = DeviceManagement::Entries>
         struct Server: public AbstractServer, public SessionManagement::Server<_Entries>
         {
            typedef typename SessionManagement::Server<_Entries> SessionMgr;
            typedef typename SessionMgr::Container Container;

            Server(Unit0 &unit):
               AbstractServer(unit), SessionManagement::Server<_Entries>()
            {}

            virtual ~Server()
            {}

            Container &entries() const
            {
               return SessionMgr::entries();
            }

            SessionMgr &sessions()
            {
               return *this;
            }

            using AbstractServer::send;

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

            protected:

            uint16_t payload_size(Protocol::Message::Interface &itf) const
            {
               switch (itf.member)
               {
                  case START_SESSION_CMD:
                     return SessionMgr::payload_size(SessionManagement::START);

                  case GET_ENTRIES_CMD:
                     return SessionMgr::payload_size(SessionManagement::GET);

                  case END_SESSION_CMD:
                     return SessionMgr::payload_size(SessionManagement::END);

                  default:
                     return AbstractService::payload_size(itf);
               }
            }

            Common::Result handle_command(Protocol::Packet &packet, Common::ByteArray &payload,
                                          uint16_t offset)
            {
               switch (packet.message.itf.member)
               {
                  case START_SESSION_CMD:
                     return SessionMgr::handle_command(SessionManagement::START, packet, payload,
                                                       offset);

                  case GET_ENTRIES_CMD:
                     return SessionMgr::handle_command(SessionManagement::GET, packet, payload,
                                                       offset);

                  case END_SESSION_CMD:
                     return SessionMgr::handle_command(SessionManagement::END, packet, payload,
                                                       offset);

                  default:
                     return AbstractServer::handle_command(packet, payload, offset);
               }
            }

            using SessionMgr::entries;
         };

         // =========================================================================
         // Default API Implementations
         // =========================================================================

         typedef Server<> DefaultServer;

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

         inline bool operator==(const Unit &lhs, const Unit &rhs)
         {
            if (lhs.id != rhs.id)
            {
               return false;
            }

            if (lhs.profile != rhs.profile)
            {
               return false;
            }

            if (lhs.interfaces.size() != rhs.interfaces.size())
            {
               return false;
            }

            for (uint8_t i = 0; i < lhs.interfaces.size(); i++)
            {
               if (lhs.interfaces[i] != rhs.interfaces[i])
               {
                  return false;
               }
            }

            return true;
         }

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

         inline bool operator==(const Device &lhs, const Device &rhs)
         {
            if (lhs.address != rhs.address)
            {
               return false;
            }

            if (lhs.units.size() != rhs.units.size())
            {
               return false;
            }

            for (uint8_t i = 0; i < lhs.units.size(); i++)
            {
               if (lhs.units[i] != rhs.units[i])
               {
                  return false;
               }
            }

            return true;
         }

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

      } // namespace DeviceManagement

   } // namespace Core

} // namespace HF

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

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

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

#endif /* HF_DEVICE_MANGEMENT_H */