scheduling.h

Go to the documentation of this file.

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

#ifndef HF_CORE_SCHEDULING_H
#define HF_CORE_SCHEDULING_H

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

#include <string>
#include <map>
#include <forward_list>
#include <algorithm>

#define HF_SCHEDULING_SETTER_HELPER(_Type, _name, _value)                              \
   {                                                                                   \
      _Type::value_type old = this->_name;                                             \
                                                                                       \
      this->_name = _value;                                                            \
                                                                                       \
      _Type old_attr(static_cast<HF::Interface::UID>(this->uid()), old, this);         \
      _Type new_attr(static_cast<HF::Interface::UID>(this->uid()), this->_name, this); \
                                                                                       \
      notify(old_attr, new_attr);                                                      \
   }

namespace HF
{
   namespace Core
   {
      // Forward declaration.
      namespace Scheduling
      {
         class IServer;
      }

      HF::Attributes::IAttribute *create_attribute(Scheduling::IServer *server,
                                                   Interface::UID itf_uid, uint8_t uid);

      namespace Scheduling
      {
         typedef enum _CMD
         {
            ACTIVATE_SCHEDULER_CMD = 0x01,   
            DEFINE_EVENT_CMD       = 0x02,   
            UPDATE_STATUS_CMD      = 0x03,   
            GET_ENTRY_CMD          = 0x04,   
            DELETE_CMD             = 0x05,   
            DELETE_ALL_CMD         = 0x06,   
            __LAST_CMD__           = DELETE_ALL_CMD
         } CMD;

         typedef enum _Attributes
         {
            MAXIMUM_NUMBER_OF_ENTRIES_ATTR = 0x01, 
            NUMBER_OF_ENTRIES_ATTR         = 0x02, 
            STATUS_ATTR                    = 0x03, 
            __LAST_ATTR__                  = STATUS_ATTR
         } Attributes;

         // =============================================================================
         // Attribute Helper classes
         // =============================================================================

         struct MaximumNumberOfEntries: public HF::Attributes::Attribute<uint8_t>
         {
            static constexpr uint8_t ID       = MAXIMUM_NUMBER_OF_ENTRIES_ATTR; 
            static constexpr bool    WRITABLE = false;                          

            MaximumNumberOfEntries(Interface::UID itf, uint8_t value = 0,
                                   HF::Interface *owner = nullptr):
               Attribute<uint8_t>(itf, ID, owner, value, WRITABLE)
            {}
         };

         struct NumberOfEntries: public HF::Attributes::Attribute<uint8_t>
         {
            static constexpr uint8_t ID       = NUMBER_OF_ENTRIES_ATTR; 
            static constexpr bool    WRITABLE = false;                  

            NumberOfEntries(Interface::UID itf, uint8_t value = 0, HF::Interface *owner = nullptr):
               Attribute<uint8_t>(itf, ID, owner, value, WRITABLE)
            {}
         };

         struct Status: public HF::Attributes::Attribute<bool>
         {
            static constexpr uint8_t ID       = STATUS_ATTR; 
            static constexpr bool    WRITABLE = false;       

            Status(Interface::UID itf, bool value = false, HF::Interface *owner = nullptr):
               Attribute<bool>(itf, ID, owner, value, WRITABLE)
            {}
         };

         HF::Attributes::IAttribute *create_attribute(HF::Interface::UID itf_uid, uint8_t uid);

         template<typename _Type>
         struct Entry
         {
            uint8_t id;          
            bool    status;      
            _Type   time;        
            uint8_t pid;         

            // Helper attribute - Not included on the message entry!
            uint32_t next_run;   

            Entry(uint8_t _id, uint8_t _status, _Type _t, uint8_t _pid):
               id(_id), status(_status), time(_t), pid(_pid), next_run(time.first())
            {}

            Entry() = default;

            static constexpr uint16_t START_ID     = 0x00;  
            static constexpr uint16_t MAX_ID       = 0xFE;  
            static constexpr uint16_t AVAILABLE_ID = 0xFF;  

            bool active(uint32_t _time) const
            {
               return (status == 0x01 &&
                       time.active(_time) &&
                       _time >= next_run);
            }

            void step(void)
            {
               next_run += time.step();
            }

            static constexpr uint16_t min_size = sizeof(uint8_t)    // Event ID
                                                 + sizeof(uint8_t)  // Event Status
                                                 + _Type::min_size  // _Type min size
                                                 + sizeof(uint8_t); // Program ID

            uint16_t size() const
            {
               return min_size;
            }

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

               uint16_t start = offset;

               offset += array.write(offset, id);
               offset += array.write(offset, static_cast<uint8_t>((status << 7) & 0x80));
               offset += time.pack(array, offset);
               offset += array.write(offset, pid);

               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 += array.read(offset, id);

               uint8_t flags = 0;
               offset += array.read(offset, flags);
               status  = (flags >> 7) & 0x01;

               uint16_t size = time.unpack(array, offset);
               HF_ASSERT(size != 0, {return 0;});
               offset += size;

               offset += array.read(offset, pid);

               return (offset - start);
            }
         };

         struct ActivateScheduler
         {
            bool status;   

            ActivateScheduler(bool _status = false): status(_status)
            {}

            static constexpr uint16_t min_size = sizeof(uint8_t);     // Status

            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 Protocol::Response ActivateSchedulerResponse;

#if __cplusplus >= 201103

         template<class _Type>
         using DefineEvent = Entry<_Type>;
#endif

         struct DefineEventResponse: public HF::Protocol::Response
         {
            uint8_t event_id; 

            DefineEventResponse(Common::Result _code = Common::Result::OK,
                                uint8_t _event_id = 0x00):
               HF::Protocol::Response(_code), event_id(_event_id)
            {}

            uint16_t size() const
            {
               if (code != Common::Result::OK)
               {
                  return min_size;
               }

               return min_size + sizeof(uint8_t);
            }

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

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

         struct UpdateStatus
         {
            uint8_t event_id; 
            bool    status;   

            UpdateStatus(uint8_t _event_id = 0x00, bool _status = false):
               event_id(_event_id), status(_status)
            {}

            static constexpr uint16_t min_size = sizeof(uint8_t)     // Event ID
                                                 + sizeof(uint8_t);  // Status

            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 DefineEventResponse UpdateStatusResponse;

         struct GetEntry
         {
            uint8_t event_id; 

            GetEntry(uint8_t _event_id = 0x00):
               event_id(_event_id)
            {}

            static constexpr uint16_t min_size = sizeof(uint8_t);     // Event ID

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

         template<typename _Type>
         struct GetEntryResponse: public HF::Protocol::Response
         {
            Entry<_Type> entry;   

            GetEntryResponse(Common::Result _code,
                             Entry<_Type> _entry):
               HF::Protocol::Response(_code), entry(_entry)
            {}

            GetEntryResponse(Common::Result _code = Common::Result::FAIL_UNKNOWN):
               HF::Protocol::Response(_code)
            {}

            uint16_t size() const
            {
               if (code != Common::Result::OK)
               {
                  return min_size;
               }

               return min_size + Entry<_Type>::min_size;
            }

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

               uint8_t start = offset;

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

               if (code != Common::Result::OK)
               {
                  goto _end;
               }

               offset += entry.pack(array, offset);

               _end:
               return offset - start;
            }

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

               uint8_t start = offset;

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

               if (code != Common::Result::OK)
               {
                  goto _end;
               }

               HF_SERIALIZABLE_CHECK(array, offset, entry.size());
               offset += entry.unpack(array, offset);

               _end:
               return offset - start;
            }
         };

         typedef GetEntry DeleteEvent;

         typedef DefineEventResponse DeleteEventResponse;

         typedef HF::Protocol::Response DeleteAllResponse;

         template<typename _Type>
         struct IEntries: public Common::IEntries<Entry<_Type>>
         {
            typedef Entry<_Type> EntryType;                    
            typedef Common::Pointer<EntryType> EntryPointer;   

            virtual Common::Result save(const EntryType &entry) = 0;

            virtual void clear(void) = 0;

            virtual EntryPointer find(uint8_t id) const = 0;

            virtual uint8_t next_id() const = 0;

            virtual void for_each(std::function<void(EntryType &e)> func) = 0;
         };

         template<typename _Type>
         struct Entries: public IEntries<_Type>
         {
            typedef Entry<_Type> EntryType;
            typedef Common::Pointer<EntryType> EntryPointer;

            typedef typename Common::SimpleList<EntryType> Container;
            typedef typename Container::iterator iterator;
            typedef typename Container::const_iterator const_iterator;
            typedef typename Container::value_type value_type;

            virtual ~Entries() {}

            uint16_t size() const
            {
               return std::distance(db.begin(), db.end());
            }

            Common::Result save(const EntryType &entry)
            {
               if (exists(entry.id))
               {
                  return Common::Result::FAIL_ARG;
               }
               else
               {
                  db.push_front(entry);
                  return Common::Result::OK;
               }
            }

            Common::Result save(uint8_t id, uint8_t status, _Type &time, uint8_t pid)
            {
               EntryType entry(id, status, time, pid);
               return save(entry);
            }

            void clear(void)
            {
               db.clear();
            }

            Common::Result destroy(const uint8_t id)
            {
               if (exists(id))
               {
                  db.remove_if([id](const EntryType &e) {return e.id == id;});
                  return Common::Result::OK;
               }
               else
               {
                  return Common::Result::FAIL_ARG;
               }
            }

            Common::Result destroy(const EntryType &entry)
            {
               return destroy(entry.id);
            }

            EntryPointer find(uint8_t id) const
            {
               auto it = std::find_if(db.begin(), db.end(),
                                      [id](const EntryType &e)
                                      {return e.id == id;});

               if (it == db.end())
               {
                  return EntryPointer();
               }
               else
               {
                  return EntryPointer(const_cast<EntryType *>(&(*it)));
               }
            }

            void for_each(std::function<void(Entry<_Type> &)> func)
            {
               std::for_each(db.begin(), db.end(), func);
            }

            uint8_t next_id() const
            {
               if (std::distance(db.begin(), db.end()) > EntryType::MAX_ID)
               {
                  return EntryType::AVAILABLE_ID;
               }

               for (uint8_t id = EntryType::START_ID; id <= EntryType::MAX_ID; ++id)
               {
                  if (!exists(id))
                  {
                     return id;
                  }
               }

               return EntryType::AVAILABLE_ID;
            }

            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:

            bool exists(const uint8_t id) const
            {
               return std::any_of(db.begin(), db.end(), [id](const EntryType &e) {
                  return e.id == id;
               });
            }

            Container db;
         };


         template<Interface::UID _ITF, typename _Parent>
         struct Base: public Service<_ITF, _Parent>
         {
            protected:

            Base(Unit0 &unit):
               Service<_ITF, _Parent>(unit)
            {}
         };

         class IServer: public ServiceRole<AbstractService, HF::Interface::SERVER_ROLE>
         {
            protected:

            uint8_t _maximum_number_of_entries; 
            bool _status;                       

            IServer(Unit0 &unit):
               ServiceRole<AbstractService, HF::Interface::SERVER_ROLE>(unit),
               _maximum_number_of_entries(std::numeric_limits<uint8_t>::max()),
               _status(true)
            {}

            public:

            virtual ~IServer()
            {}

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

            virtual Common::Result activate_scheduler(const Protocol::Packet &packet,
                                                      const ActivateScheduler &msg);

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

            // ======================================================================
            // Get/Set API.
            // ======================================================================

            uint8_t maximum_number_of_entries() const;

            void maximum_number_of_entries(uint8_t __value);

            virtual uint8_t number_of_entries() const = 0;

            bool status() const;

            bool enabled() const
            {
               return status();
            }

            void status(bool __value);

            void enable(bool __value)
            {
               status(__value);
            }

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

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

            HF::Attributes::UIDS attributes(uint8_t pack_id =
                                               HF::Attributes::Pack::MANDATORY) const;

            protected:

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

         class IClient: public Interfaces::InterfaceRole<Interfaces::AbstractInterface,
                                                         HF::Interface::CLIENT_ROLE>
         {
            public:

            virtual ~IClient()
            {}

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

            void activate_scheduler(const Protocol::Address &addr,
                                    const Interface::UID itf_uid, bool enabled = true);

#ifdef HF_CORE_EVENT_SCHEDULING_UPDATE_EVENT_STATUS_CMD

            void update_event_status(const Protocol::Address &addr, const Interface::UID itf_uid,
                                     uint8_t id, bool enabled);
#endif

#ifdef HF_CORE_EVENT_SCHEDULING_GET_EVENT_ENTRY_CMD

            void get_event_entry(const Protocol::Address &addr, const Interface::UID itf_uid,
                                 uint8_t id);
#endif

            void delete_event(const Protocol::Address &addr, const Interface::UID itf_uid,
                              uint8_t id);

#ifdef HF_CORE_EVENT_SCHEDULING_DELETE_ALL_EVENTS_CMD

            void delete_all_events(const Protocol::Address &addr, const Interface::UID itf_uid);
#endif

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

      }  // namespace Scheduling

   }  // namespace Core

}   // namespace HF

// =============================================================================
// Stream Helpers
// =============================================================================
std::ostream &operator<<(std::ostream &stream, const HF::Core::Scheduling::CMD command);

std::ostream &operator<<(std::ostream &stream,
                         const HF::Core::Scheduling::Attributes attribute);
#endif /* HF_CORE_SCHEDULING_H_ */