weekly_scheduling.h

Go to the documentation of this file.

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

#ifndef HF_CORE_WEEKLY_SCHEDULING_H
#define HF_CORE_WEEKLY_SCHEDULING_H

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

#include "hanfun/core/scheduling.h"
#include "hanfun/core/time.h"

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

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

      namespace Scheduling
      {
         namespace Weekly
         {
            typedef enum _Days
            {
               MONDAY = 0x00,
               TUESDAY,
               WEDNESDAY,
               THURSDAY,
               FRIDAY,
               SATURDAY,
               SUNDAY
            } Days;

            struct Day
            {
               uint8_t day;            
               uint8_t hour;           
               uint8_t minute;         

               Day(uint8_t _day, uint8_t _hour, uint8_t _minute):
                  day(_day), hour(_hour), minute(_minute)
               {}

               Day() = default;

               static constexpr int      MINUTE = 60;
               static constexpr int      HOUR   = 60 * MINUTE;
               static constexpr int      DAY    = 24 * HOUR;
               static constexpr uint32_t WEEK   = 7 * DAY;

               // Jan, 1st 2000 was on a Saturday (UTC)
               static constexpr uint8_t DAY_OF_WEEK_BASE = SATURDAY;

               static Day               convert(const uint32_t &timestamp)
               {
                  Day result;

                  std::div_t temp = std::div(timestamp, DAY);           // get the number of days
                                                                        // since the start

                  result.day = temp.quot % 7                            // n of days MOD 7
                               + DAY_OF_WEEK_BASE;

                  result.day    = result.day % 7;

                  temp          = std::div(temp.rem, HOUR);
                  result.hour   = temp.quot;
                  temp          = std::div(temp.rem, MINUTE);
                  result.minute = temp.quot;

                  return result;
               }

               uint32_t first(uint32_t timestamp = 0) const
               {
                  uint32_t result = timestamp;

                  Day current(convert(timestamp));

                  result += (this->hour - current.hour) * 60 * 60;
                  result += (this->minute - current.minute) * 60;

                  result += (this->day - current.day) * 24 * 60 * 60;

                  if (timestamp > result)
                  {
                     result += WEEK;
                  }

                  return result;
               }

               uint32_t step() const
               {
                  return WEEK;
               }

               bool active(uint32_t _time) const
               {
                  UNUSED(_time);
                  return true;
               }

               static constexpr uint16_t min_size = sizeof(uint8_t)     // Day of Week.
                                                    + sizeof(uint8_t)   // Hour of Day.
                                                    + sizeof(uint8_t);  // Minute of Hour.

               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<Day> Entry;

            typedef Scheduling::GetEntryResponse<Day> GetEntryResponse;

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

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

            struct Status: public Scheduling::Status
            {
               Status(bool value = false, HF::Interface *owner = nullptr):
                  Scheduling::Status(HF::Interface::WEEKLY_SCHEDULING,
                                     value, owner)
               {}
            };

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

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

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

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

               virtual ~IClient() {}

               static constexpr HF::Interface::UID ITF = HF::Interface::WEEKLY_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,
                                         Day &time, uint8_t pid);

#ifdef HF_CORE_WEEKLY_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_WEEKLY_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_WEEKLY_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;

               virtual Common::Result define_event(const Protocol::Packet &packet,
                                                   Scheduling::Entry<Day> &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<Day> &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<Day>, _Entries>::value,
                             "_Entries must be of type HF::Core::Scheduling::IEntries<Day>");

               protected:

               _Entries _entries;

               public:

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

               virtual ~Server()
               {}

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

            typedef Server<Entries<Day>> DefaultServer;

         } // namespace Weekly
      }    // namespace Scheduling
   }       // namespace Core
}          // namespace HF

#endif /* HF_CORE_WEEKLY_SCHEDULING_H */