bind_management.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_BIND_MANAGEMENT_H
#define HF_BIND_MANAGEMENT_H

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

#include "hanfun/core.h"

#include "hanfun/interface.h"

#include "hanfun/core/session_management.h"

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

namespace HF
{
   // Forward declaration.

   namespace Devices
   {
      namespace Concentrator
      {
         struct IUnit0;

      }  // namespace Concentrator

   }  // namespace Devices

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

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

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

      namespace BindManagement
      {
         typedef enum _CMD
         {
            ADD_BIND_CMD      = 0x01, 
            REMOVE_BIND_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;

         struct Entry
         {
            Protocol::Address source;           

            Protocol::Address destination;      

            Common::Interface itf;              

            Entry()
            {}

            Entry(Protocol::Address _source, Common::Interface _itf):
               source(_source), itf(_itf)
            {}

            Entry(Protocol::Address _source, Common::Interface _itf,
                  Protocol::Address _destination):
               source(_source), destination(_destination), itf(_itf)
            {}

            static constexpr uint16_t min_size = Protocol::Address::min_size     // Source Address
                                                 + Protocol::Address::min_size   // Destination Address
                                                 + Common::Interface::min_size;  // Interface 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);
         };

         typedef HF::Common::Pointer<const Entry> EntryPtr;

         struct Message: public Entry
         {};

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

         struct IEntries: public Common::IEntries<Entry>
         {
            // =============================================================================
            // API
            // =============================================================================

            using Common::IEntries<Entry>::destroy;

            virtual Common::Result destroy(uint16_t address, Protocol::Address::Type type =
                                              Protocol::Address::DEVICE) = 0;

            // =============================================================================
            // Query API
            // =============================================================================

            virtual EntryPtr find(const Protocol::Address &source, const Common::Interface &itf,
                                  const Protocol::Address &destination) const = 0;

            virtual bool any_of(Protocol::Address const &source,
                                Common::Interface const &itf) const = 0;

            virtual void for_each(Protocol::Address const &source, Common::Interface const &itf,
                                  std::function<void(const Entry &)> func) const = 0;
         };

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

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

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

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

            public:

            typedef SessionManagement::Client<Entry> SessionMgr;

            Client(HF::Core::Unit0 &unit): Service(unit), SessionMgr() {}

            virtual ~Client() {}

            SessionMgr &session()
            {
               return *this;
            }

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

            void add(const Protocol::Address &source, const Protocol::Address &destination,
                     const Common::Interface &itf);

            void remove(const Protocol::Address &source, const Protocol::Address &destination,
                        const Common::Interface &itf);

            // ======================================================================
            // 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 response(const CMD cmd, const 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;

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

            virtual Common::Result add(const Protocol::Address &source,
                                       const Protocol::Address &destination,
                                       const Common::Interface &itf) = 0;

            virtual Common::Result remove(const Protocol::Address &source,
                                          const Protocol::Address &destination,
                                          const Common::Interface &itf) = 0;

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

            virtual IEntries &entries() const = 0;

            virtual SessionManagement::IServer &sessions() = 0;

            protected:

            IServer(Unit0 &unit):
               ServiceRole<Base, HF::Interface::SERVER_ROLE>(unit)
            {}
         };

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

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

            Common::Result add(const Protocol::Address &source,
                               const Protocol::Address &destination,
                               const Common::Interface &itf);

            Common::Result remove(const Protocol::Address &source,
                                  const Protocol::Address &destination,
                                  const Common::Interface &itf);

            // =============================================================================
            // 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};
            }

            protected:

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

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

         struct Entries: public IEntries
         {
            typedef std::set<Entry> Container;
            typedef Container::iterator iterator;
            typedef Container::const_iterator const_iterator;
            typedef Container::value_type value_type;

            uint16_t size() const;

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

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

            Common::Result destroy(uint16_t address,
                                   Protocol::Address::Type type = Protocol::Address::DEVICE);

            // =============================================================================
            // Query API
            // =============================================================================

            EntryPtr find(const Protocol::Address &source, const Common::Interface &itf,
                          const Protocol::Address &destination) const;

            bool any_of(Protocol::Address const &source, Common::Interface const &itf) const;

            void for_each(Protocol::Address const &source, Common::Interface const &itf,
                          std::function<void(const Entry &)> func) const;

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

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

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

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

            std::pair<iterator, iterator> find(Protocol::Address const &source,
                                               Common::Interface const &itf) const;

            template<typename Func>
            Common::Result destroy(Func func)
            {
               Common::Result result = Common::Result::FAIL_ARG;

               for (iterator itr = db.begin(); itr != db.end();)
               {
                  if (func(*itr))
                  {
                     auto old = itr++;
                     destroy(*old);
                     result = Common::Result::OK;
                  }
                  else
                  {
                     ++itr;
                  }
               }

               return result;
            }

            protected:

            Container db;
         };

         template<typename _Entries = BindManagement::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), SessionMgr() {}

            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:

            _Entries _entries; 

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

         typedef Server<> DefaultServer;

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

         inline bool operator==(const Entry &lhs, const Entry &rhs)
         {
            return lhs.source == rhs.source && lhs.destination == rhs.destination &&
                   lhs.itf == rhs.itf;
         }

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

         inline bool operator<(const Entry &lhs, const Entry &rhs)
         {
            return lhs.source < rhs.source || (lhs.source == rhs.source
                                               && (lhs.itf < rhs.itf ||
                                                   (lhs.itf == rhs.itf &&
                                                    lhs.destination < rhs.destination)));
         }

      }  // namespace BindManagement

   }  // namespace Core

}  // namespace HF

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

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

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

#endif /* HF_BIND_MANAGEMENT_H */