event_scheduling.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_CORE_EVENT_SCHEDULING_H
#define HF_CORE_EVENT_SCHEDULING_H

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

#include "hanfun/core/scheduling.h"

namespace HF
{
   namespace Core
   {
      namespace Scheduling
      {
         // Forward declaration
         namespace Event
         {
            struct IServer;
         }
      }

      HF::Attributes::IAttribute *create_attribute(Scheduling::Event::IServer *server, uint8_t uid);

      namespace Scheduling
      {
         namespace Event
         {
            struct Interval
            {
               uint32_t start;          
               uint32_t end;            
               uint32_t repeat;         

               Interval(uint32_t _start, uint32_t _end, uint32_t _repeat):
                  start(_start), end(_end), repeat(_repeat)
               {}

               Interval() = default;

               uint32_t first() const
               {
                  return start;
               }

               uint32_t step() const
               {
                  return repeat;
               }

               bool active(uint32_t _time) const
               {
                  return (start <= _time && _time <= end);
               }

               static constexpr uint16_t min_size = sizeof(uint32_t)    // Start Date.
                                                    + sizeof(uint32_t)  // End Date.
                                                    + sizeof(uint32_t); // Repeat interval.

               uint16_t size() const
               {
                  return min_size;
               }

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

               uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
            };

            typedef Scheduling::Entry<Interval> Entry;

            typedef Scheduling::GetEntryResponse<Interval> GetEntryResponse;

            struct MaximumNumberOfEntries: public Scheduling::MaximumNumberOfEntries
            {
               MaximumNumberOfEntries(uint8_t value = 0, HF::Interface *owner = nullptr):
                  Scheduling::MaximumNumberOfEntries(HF::Interface::EVENT_SCHEDULING,
                                                     value, owner)
               {}
            };

            struct NumberOfEntries: public Scheduling::NumberOfEntries
            {
               NumberOfEntries(uint8_t value = 0, HF::Interface *owner = nullptr):
                  Scheduling::NumberOfEntries(HF::Interface::EVENT_SCHEDULING, value, owner)
               {}
            };

            struct Status: public Scheduling::Status
            {
               Status(uint8_t value = 0, HF::Interface *owner = nullptr):
                  Scheduling::Status(HF::Interface::EVENT_SCHEDULING, value, owner)
               {}
            };

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

            typedef Scheduling::Base<HF::Interface::EVENT_SCHEDULING,
                                     Scheduling::IServer> IServerBase;

            typedef Interfaces::Interface<HF::Interface::EVENT_SCHEDULING,
                                          Scheduling::IClient> IClientBase;

            struct IClient: public IClientBase
            {
               IClient(): IClientBase()
               {}

               virtual ~IClient() {}

               static constexpr HF::Interface::UID ITF = HF::Interface::EVENT_SCHEDULING;

               virtual void activate_scheduler(const Protocol::Address &addr, bool enabled)
               {
                  Scheduling::IClient::activate_scheduler(addr, ITF, enabled);
               }

               virtual void define_event(const Protocol::Address &addr, uint8_t id,
                                         uint8_t status, Interval &time, uint8_t pid);

#ifdef HF_CORE_EVENT_SCHEDULING_UPDATE_EVENT_STATUS_CMD

               virtual void update_event_status(const Protocol::Address &addr,
                                                uint8_t id, bool enabled)
               {
                  Scheduling::IClient::update_event_status(addr, ITF, id, enabled);
               }
#endif

#ifdef HF_CORE_EVENT_SCHEDULING_GET_EVENT_ENTRY_CMD

               virtual void get_event_entry(const Protocol::Address &addr, uint8_t id)
               {
                  Scheduling::IClient::get_event_entry(addr, ITF, id);
               }
#endif

               virtual void delete_event(const Protocol::Address &addr, uint8_t id)
               {
                  Scheduling::IClient::delete_event(addr, ITF, id);
               }

#ifdef HF_CORE_EVENT_SCHEDULING_DELETE_ALL_EVENTS_CMD

               virtual void delete_all_events(const Protocol::Address &addr)
               {
                  Scheduling::IClient::delete_all_events(addr, ITF);
               }
#endif

               using IClientBase::send;
            };

            struct Client: public IClient
            {
               Client(): IClient()
               {}

               virtual ~Client()
               {}
            };

            struct IServer: public IServerBase
            {
               uint16_t uid() const
               {
                  return IServerBase::uid();
               }

               HF::Attributes::UIDS attributes(uint8_t uid = HF::Attributes::Pack::MANDATORY) const
               {
                  return Scheduling::IServer::attributes(uid);
               }

               uint8_t number_of_entries() const;

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

               virtual Common::Result define_event(const Protocol::Packet &packet,
                                                   Scheduling::Entry<Interval> &msg);

               virtual Common::Result update_event_status(const Protocol::Packet &packet,
                                                          const UpdateStatus &msg);

               virtual Common::Result get_event_entry(const Protocol::Packet &packet,
                                                      const GetEntry &msg);

               virtual Common::Result delete_event(const Protocol::Packet &packet,
                                                   const DeleteEvent &msg);

               virtual Common::Result delete_all_events(const Protocol::Packet &packet);

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

               void periodic(uint32_t time);

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

               virtual ~IServer() {}

               // =============================================================================
               // Entries API
               // =============================================================================

               virtual IEntries<Interval> &entries() const = 0;

               Common::Pointer<Entry> entry(const uint8_t id) const
               {
                  return entries().find(id);
               }

               uint8_t next_id() const
               {
                  return entries().next_id();
               }

               using IServerBase::notify;

               // =============================================================================
               // Protected types and methods
               // =============================================================================

               protected:

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

            };

            template<typename _Entries>
            struct Server: public IServer
            {
               static_assert(std::is_base_of<HF::Core::Scheduling::IEntries<Interval>,
                                             _Entries>::value,
                             "_Entries must be of type HF::Core::Scheduling::IEntries<Interval>");

               protected:

               _Entries _entries;

               public:

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

               virtual ~Server()
               {}

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

            typedef Server<Entries<Interval>> DefaultServer;

         } // namespace Event
      }    // namespace Scheduling
   }       // namespace Core
}          // namespace HF

#endif /* HF_CORE_EVENT_SCHEDULING_H */