session_management.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_SESSION_MANAGEMENT_H
#define HF_SESSION_MANAGEMENT_H

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

namespace HF
{
   namespace Core
   {
      namespace SessionManagement
      {
         typedef enum _CMD
         {
            START,   
            GET,     
            END,     
         } CMD;

         // =============================================================================
         // Messages API
         // =============================================================================

         struct StartResponse: public Protocol::Response
         {
            uint16_t count; 

            StartResponse(uint16_t count = 0):
               count(count)
            {}

            static constexpr uint16_t min_size = Protocol::Response::min_size + sizeof(uint16_t);

            uint16_t size() const
            {
               return min_size;
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const
            {
               HF_SERIALIZABLE_CHECK(array, offset, min_size);

               offset += Protocol::Response::pack(array, offset);
               array.write(offset, count);

               return min_size;
            }

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0)
            {
               HF_SERIALIZABLE_CHECK(array, offset, min_size);

               offset += Protocol::Response::unpack(array, offset);
               array.read(offset, count);

               return min_size;
            }
         };

         struct GetEntriesMessage
         {
            uint16_t offset; 
            uint8_t  count;  


            GetEntriesMessage(uint16_t offset = 0, uint8_t count = 0):
               offset(offset), count(count)
            {}

            constexpr static uint16_t min_size = sizeof(offset) + sizeof(count);

            uint16_t size() const
            {
               return min_size;
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const
            {
               HF_SERIALIZABLE_CHECK(array, offset, min_size);

               offset += array.write(offset, this->offset);
               array.write(offset, this->count);

               return min_size;
            }

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0)
            {
               HF_SERIALIZABLE_CHECK(array, offset, min_size);

               offset += array.read(offset, this->offset);
               array.read(offset, this->count);

               return min_size;
            }
         };

         template<typename _Entry>
         struct GetEntriesResponse: public Protocol::Response
         {
            std::vector<_Entry> entries;

            static constexpr uint16_t min_size = Protocol::Response::min_size
                                                 + sizeof(uint8_t);  // Number of entries.

            uint16_t size() const
            {
               uint16_t result = min_size;

               /* *INDENT-OFF* */
               std::for_each (entries.begin (), entries.end (), [&result](const _Entry &entry)
               {
                  result += entry.size ();
               });
               /* *INDENT-ON* */

               return result;
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const
            {
               HF_SERIALIZABLE_CHECK(array, offset, size());

               uint16_t start = offset;

               offset += Protocol::Response::pack(array, offset);

               uint8_t count = entries.size();
               offset += array.write(offset, count);

               /* *INDENT-OFF* */
               std::for_each(entries.begin(), entries.end(),
                             [&offset, &array](const _Entry &entry)
               {
                  offset += entry.pack (array, offset);
               });
               /* *INDENT-ON* */

               return offset - start;
            }

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0)
            {
               HF_SERIALIZABLE_CHECK(array, offset, min_size);

               uint16_t start = offset;

               offset += Protocol::Response::unpack(array, offset);

               uint8_t count = 0;
               offset += array.read(offset, count);

               entries.clear();

               _Entry entry;

               for (uint8_t i = 0; i < count; i++)
               {
                  offset += entry.unpack(array, offset);
                  entries.push_back(entry);
               }

               return offset - start;
            }
         };

         template<>
         struct GetEntriesResponse<void>: public Protocol::Response
         {
            uint8_t count;

            GetEntriesResponse(): count(0)
            {}

            static constexpr uint16_t min_size = Protocol::Response::min_size
                                                 + sizeof(uint8_t);  // Number of entries.

            uint16_t size() const
            {
               return min_size;
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const
            {
               HF_SERIALIZABLE_CHECK(array, offset, min_size);

               offset += Protocol::Response::pack(array, offset);

               uint8_t count = 0;
               array.write(offset, count);

               return min_size;
            }

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0)
            {
               HF_SERIALIZABLE_CHECK(array, offset, min_size);

               offset += Protocol::Response::unpack(array, offset);

               uint8_t count = 0;
               array.read(offset, count);

               return min_size;
            }
         };

         typedef GetEntriesResponse<void> GetEntriesEmptyResponse;

         // =============================================================================
         // Server API
         // =============================================================================

         struct IServer
         {
            virtual void start_session(uint16_t address) = 0;

            virtual void end_session(uint16_t address) = 0;

            virtual bool exists(uint16_t address) const = 0;

            virtual bool is_valid(uint16_t address) const = 0;
         };

         class AbstractServer: public IServer
         {
            protected:

            struct Session
            {
               uint16_t address;    
               bool     valid;      

               Session(uint16_t _address = HF::Protocol::BROADCAST_ADDR, bool _valid = false):
                  address(_address), valid(_valid)
               {}
            };

            typedef std::vector<Session> Container;
            typedef Container::iterator iterator;
            typedef Container::const_iterator const_iterator;

            Container sessions;

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

            public:

            AbstractServer(): sessions(Container())
            {}

            virtual ~AbstractServer()
            {}

            void start_session(uint16_t address)
            {
               auto it = find(address);

               if (it == sessions.end())   // Session does not exist.
               {
                  sessions.push_back(Session(address, true));
               }
               else  // Session already exists. Update state.
               {
                  it->valid = true;
               }
            }

            void end_session(uint16_t address)
            {
               auto it = find(address);

               if (it != sessions.end())
               {
                  sessions.erase(it);
               }
            }

            bool exists(uint16_t address) const
            {
               return find(address) != sessions.end();
            }

            bool is_valid(uint16_t address) const
            {
               auto it = find(address);

               if (it != sessions.end())
               {
                  return it->valid;
               }

               return false;
            }

            void invalidate()
            {
               /* *INDENT-OFF* */
               std::for_each (sessions.begin (), sessions.end (), [](Session &session)
               {
                  session.valid = false;
               });
               /* *INDENT-ON* */
            }

            protected:

            Common::Result handle_command(CMD cmd, Protocol::Packet &packet,
                                          Common::ByteArray &payload, uint16_t offset = 0);

            iterator find(uint16_t address)
            {
               /* *INDENT-OFF* */
               return std::find_if (sessions.begin (), sessions.end (),
                                    [address](const Session &session)
               {
                  return address == session.address;
               });
               /* *INDENT-ON* */
            }

            const_iterator find(uint16_t address) const
            {
               /* *INDENT-OFF* */
               return std::find_if (sessions.cbegin (), sessions.cend (),
                                    [address](const Session &session)
               {
                  return address == session.address;
               });
               /* *INDENT-ON* */
            }

            uint16_t payload_size(CMD cmd) const;

            Common::Result check_offset(uint16_t offset, uint8_t &count, uint16_t size) const;

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

            virtual uint16_t entries_size() const = 0;

            virtual Common::Result entries(uint16_t offset,
                                           uint8_t count,
                                           Common::ByteArray &payload) = 0;

            Common::Result check_session(uint16_t address, Common::ByteArray &payload) const;
         };

         template<typename Parent>
         class EntriesWrapper: public Parent
         {
            AbstractServer &manager;

            public:

            typedef typename Parent::value_type value_type;

            EntriesWrapper(AbstractServer &_manager): Parent(),
               manager(_manager)
            {}

            EntriesWrapper(const EntriesWrapper &other, AbstractServer &_manager):
               Parent(other), manager(_manager)
            {}

            virtual ~EntriesWrapper()
            {}

            Common::Result save(const value_type &entry)
            {
               auto res = Parent::save(entry);

               manager.invalidate();
               return res;
            }

            Common::Result destroy(const value_type &entry)
            {
               auto res = Parent::destroy(entry);

               manager.invalidate();
               return res;
            }
         };

         template<typename _Entries>
         struct Server: public AbstractServer
         {
            typedef EntriesWrapper<_Entries> Container;

            Container &entries() const
            {
               return const_cast<Container &>(_entries);
            }

            protected:

            Server(): AbstractServer(), _entries(*this)
            {}

            virtual ~Server()
            {}

            Server(const Server &other):
               AbstractServer(other), _entries(other._entries, *this)
            {}

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

            uint16_t entries_size() const
            {
               return static_cast<uint16_t>(_entries.size());
            }

            typedef typename _Entries::value_type value_type;

            Common::Result entries(uint16_t offset, uint8_t count, Common::ByteArray &payload)
            {
               GetEntriesResponse<value_type> response;

               response.code = check_offset(offset, count, entries_size());

               if (response.code == Common::Result::OK)
               {
                  auto start = _entries.begin();
                  std::advance(start, offset);

                  auto end = start;
                  std::advance(end, count);
                  std::copy(start, end, std::back_inserter(response.entries));
               }

               payload = Common::ByteArray(response.size());

               response.pack(payload);

               return response.code;
            }

            private:

            Container _entries;
         };

         // =============================================================================
         // Client API
         // =============================================================================

         class AbstractClient
         {
            // ======================================================================
            // Commands
            // ======================================================================

            virtual void start_session() const = 0;

            virtual void end_session() const = 0;

            virtual void get_entries(uint16_t offset, uint8_t count = 0) const = 0;

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

            virtual void session_started(StartResponse &response)
            {
               UNUSED(response);
            }

            virtual void session_ended(Protocol::Response &response)
            {
               UNUSED(response);
            }

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

            protected:

            Common::Result handle_command(CMD cmd, Protocol::Packet &packet,
                                          Common::ByteArray &payload, uint16_t offset = 0);

            uint16_t payload_size(CMD cmd) const;

            template<uint8_t _role, uint16_t _uid, uint8_t _member>
            void get_entries(uint16_t offset, uint8_t count = 0) const
            {
               SessionManagement::GetEntriesMessage msg(offset, count);

               Protocol::Address addr(0, 0);
               Protocol::Message message;

               message.itf.role   = _role;
               message.itf.id     = _uid;
               message.itf.member = _member;

               message.payload    = Common::ByteArray(msg.size());

               msg.pack(message.payload);

               const_cast<AbstractClient *>(this)->send(addr, message);
            }

            template<uint8_t _role, uint16_t _uid, uint8_t _member>
            void request() const
            {
               Protocol::Address addr(0, 0);
               Protocol::Message message;

               message.itf.role   = _role;
               message.itf.id     = _uid;
               message.itf.member = _member;

               const_cast<AbstractClient *>(this)->send(addr, message);
            }

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

         template<typename _Entry>
         struct Client: public AbstractClient
         {
            // ======================================================================
            // Events
            // ======================================================================

            virtual void entries(const GetEntriesResponse<_Entry> &response)
            {
               UNUSED(response);
            }

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

            protected:

            Common::Result handle_command(CMD cmd, Protocol::Packet &packet,
                                          Common::ByteArray &payload, uint16_t offset = 0)
            {
               if (cmd == GET)
               {
                  GetEntriesResponse<_Entry> response;
                  response.unpack(payload, offset);
                  entries(response);
                  return Common::Result::OK;
               }
               else
               {
                  return AbstractClient::handle_command(cmd, packet, payload, offset);
               }
            }
         };

      }  // namespace SessionManagement

   }  // namespace Core

}  // namespace HF

#endif /* HF_SESSION_MANAGEMENT_H */