time.h

Go to the documentation of this file.

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

#ifndef HF_CORE_TIME_H
#define HF_CORE_TIME_H

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

namespace HF
{
   namespace Core
   {
      // Forward declaration.
      namespace Time
      {
         class Server;
      }

      HF::Attributes::IAttribute *create_attribute(Time::Server *server, uint8_t uid);

      namespace Time
      {
         typedef enum _Attributes
         {
            TIME_ATTR     = 1, 
            __LAST_ATTR__ = TIME_ATTR
         } Attributes;

         static constexpr uint16_t YEARS_BASE = 2000;

         static constexpr uint8_t YEARS_MIN = 0;

         static constexpr uint8_t YEARS_MAX = 136;

         static constexpr uint8_t MONTHS_MIN = 1;

         static constexpr uint8_t MONTHS_MAX = 12;

         static constexpr uint8_t DAYS_MIN = 1;

         static constexpr uint8_t DAYS_MAX = 31;

         static constexpr uint8_t HOURS_MIN = 0;

         static constexpr uint8_t HOURS_MAX = 23;

         static constexpr uint8_t MINUTES_MIN = 0;

         static constexpr uint8_t MINUTES_MAX = 59;

         static constexpr uint8_t SECONDS_MIN = 0;

         static constexpr uint8_t SECONDS_MAX = 59;

         struct Date;

         uint32_t convert(const Date &date);

         Date convert(uint32_t time);

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

         struct Value: public HF::Attributes::Attribute<uint32_t>
         {
            static constexpr uint32_t INVALID  = 0xFFFFFFFF;  
            static constexpr uint32_t MIN      = 0x00000000;  
            static constexpr uint32_t MAX      = INVALID - 1; 

            static constexpr uint8_t  ID       = TIME_ATTR; 
            static constexpr bool     WRITABLE = true;      

            Value(uint32_t value = 0, HF::Interface *owner = nullptr):
               Attribute<uint32_t>(HF::Interface::TIME, ID, owner, value, WRITABLE)
            {}
         };

         Date convert(const Value &value);

         struct Date
         {
            uint8_t year;     
            uint8_t month;    
            uint8_t day;      

            uint8_t hour;     
            uint8_t minute;   
            uint8_t second;   

            Date(uint8_t _year = 0, uint8_t _month = 0, uint8_t _day = 0,
                 uint8_t _hour = 0, uint8_t _minute = 0, uint8_t _second = 0):
               year(_year), month(_month), day(_day), hour(_hour),
               minute(_minute), second(_second)
            {}

            Date(uint32_t _time)
            {
               *this = convert(_time);
            }
         };

         static Date const Origin = Date(Value::MIN);

         static Date const End    = Date(Value::MAX);

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

         struct Base: public Service<HF::Interface::TIME>
         {
            protected:

            Base(Unit0 &unit): Service<HF::Interface::TIME>(unit) {}
         };

         class Server: public ServiceRole<Time::Base, HF::Interface::SERVER_ROLE>
         {
            protected:

            uint32_t _time;   

            public:

            Server(Unit0 &unit):
               ServiceRole<Time::Base, HF::Interface::SERVER_ROLE>(unit),
               _time(Value::INVALID) {}

            virtual ~Server() {}

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

            virtual uint32_t time() const;

            void time(uint32_t __value);

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

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

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

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

            void tick(uint32_t count = 1)
            {
               HF_ASSERT(Value::INVALID - _time > count, {_time = Value::INVALID;
                                                          return;});
               _time += count;
            }
         };

         struct Client: public ServiceRole<Time::Base, HF::Interface::CLIENT_ROLE>
         {
            Client(Unit0 &unit): ServiceRole<Time::Base, HF::Interface::CLIENT_ROLE>(unit) {}

            virtual ~Client() {}
         };

      }  // namespace Time

   }  // namespace Core

}   // namespace HF

inline bool operator==(const HF::Core::Time::Date &lhs, const HF::Core::Time::Date &rhs)
{
   return (memcmp(&lhs, &rhs, sizeof(HF::Core::Time::Date)) == 0);
}

inline bool operator!=(const HF::Core::Time::Date &lhs, const HF::Core::Time::Date &rhs)
{
   return !(lhs == rhs);
}

inline bool operator<(const HF::Core::Time::Date &lhs, const HF::Core::Time::Date &rhs)
{
   return memcmp(&lhs, &rhs, sizeof(HF::Core::Time::Date)) < 0;
}

inline bool operator<=(const HF::Core::Time::Date &lhs, const HF::Core::Time::Date &rhs)
{
   return memcmp(&lhs, &rhs, sizeof(HF::Core::Time::Date)) <= 0;
}

inline bool operator>(const HF::Core::Time::Date &lhs, const HF::Core::Time::Date &rhs)
{
   return memcmp(&lhs, &rhs, sizeof(HF::Core::Time::Date)) > 0;
}

inline bool operator>=(const HF::Core::Time::Date &lhs, const HF::Core::Time::Date &rhs)
{
   return memcmp(&lhs, &rhs, sizeof(HF::Core::Time::Date)) >= 0;
}

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


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

std::ostream &operator<<(std::ostream &stream,
                         const HF::Core::Time::Date &date);
#endif /* HF_CORE_TIME_H */