TimePattern.h

Go to the documentation of this file.

 
#ifndef INCLUDE_HUEPLUSPLUS_TIME_PATTERN
#define INCLUDE_HUEPLUSPLUS_TIME_PATTERN
 
#include <chrono>
#include <string>
#include <cstddef>
 
namespace hueplusplus
{
namespace time
{
std::string timepointToTimestamp(std::chrono::system_clock::time_point time);
 
std::chrono::system_clock::time_point parseTimestamp(const std::string& timestamp);
 
std::chrono::system_clock::time_point parseUTCTimestamp(const std::string& timestamp);
 
std::string durationTo_hh_mm_ss(std::chrono::system_clock::duration duration);
 
std::chrono::system_clock::duration parseDuration(const std::string& hourMinSec);
 
class AbsoluteTime
{
    using clock = std::chrono::system_clock;
 
public:
    explicit AbsoluteTime(clock::time_point baseTime);
 
    clock::time_point getBaseTime() const;
 
    std::string toString() const;
 
    static AbsoluteTime parse(const std::string& s);
 
    static AbsoluteTime parseUTC(const std::string& s);
 
private:
    clock::time_point base;
};
class AbsoluteVariedTime : public AbsoluteTime
{
    using clock = std::chrono::system_clock;
 
public:
    explicit AbsoluteVariedTime(clock::time_point baseTime, clock::duration variation = std::chrono::seconds(0));
 
    clock::duration getRandomVariation() const;
 
    std::string toString() const;
 
    static AbsoluteVariedTime parse(const std::string& s);
 
private:
    clock::duration variation;
};
 
class Weekdays
{
public:
    Weekdays() : bitmask(0) { }
    explicit Weekdays(int num) : bitmask(1 << num) { }
 
    bool isNone() const;
    bool isAll() const;
    bool isMonday() const;
    bool isTuesday() const;
    bool isWednesday() const;
    bool isThursday() const;
    bool isFriday() const;
    bool isSaturday() const;
    bool isSunday() const;
 
    Weekdays unionWith(Weekdays other) const;
    Weekdays operator|(Weekdays other) const { return unionWith(other); }
 
    std::string toString() const;
 
    static Weekdays none();
    static Weekdays all();
    static Weekdays monday();
    static Weekdays tuesday();
    static Weekdays wednesday();
    static Weekdays thursday();
    static Weekdays friday();
    static Weekdays saturday();
    static Weekdays sunday();
 
    static Weekdays parse(const std::string& s);
 
    bool operator==(const Weekdays& other) const { return bitmask == other.bitmask; }
    bool operator!=(const Weekdays& other) const { return bitmask != other.bitmask; }
 
private:
    int bitmask;
};
 
class RecurringTime
{
    using clock = std::chrono::system_clock;
 
public:
    explicit RecurringTime(clock::duration daytime, Weekdays days, clock::duration variation = std::chrono::seconds(0));
 
    clock::duration getDaytime() const;
    clock::duration getRandomVariation() const;
    Weekdays getWeekdays() const;
 
    std::string toString() const;
 
private:
    clock::duration time;
    clock::duration variation;
    Weekdays days;
};
 
class TimeInterval
{
    using clock = std::chrono::system_clock;
 
public:
    TimeInterval(clock::duration start, clock::duration end, Weekdays days = Weekdays::all());
 
    clock::duration getStartTime() const;
    clock::duration getEndTime() const;
    Weekdays getWeekdays() const;
 
    std::string toString() const;
 
private:
    clock::duration start;
    clock::duration end;
    Weekdays days;
};
 
class Timer
{
    using clock = std::chrono::system_clock;
 
public:
    // \brief Used to represent infinite repetitions
    static constexpr int infiniteExecutions = 0;
 
    Timer(clock::duration duration, clock::duration variation = std::chrono::seconds(0));
    Timer(clock::duration duration, int numExecutions, clock::duration variation = std::chrono::seconds(0));
 
    bool isRecurring() const;
 
    int getNumberOfExecutions() const;
    clock::duration getExpiryTime() const;
    clock::duration getRandomVariation() const;
 
    std::string toString() const;
 
private:
    clock::duration expires;
    clock::duration variation;
    int numExecutions;
};
 
class TimePattern
{
public:
    enum class Type
    {
        undefined, 
        absolute, 
        recurring, 
        interval, 
        timer 
    };
 
    TimePattern();
    ~TimePattern();
    explicit TimePattern(const AbsoluteVariedTime& absolute);
    explicit TimePattern(const RecurringTime& recurring);
    explicit TimePattern(const TimeInterval& interval);
    explicit TimePattern(const Timer& timer);
 
    TimePattern(const TimePattern& other);
 
    TimePattern& operator=(const TimePattern& other);
 
    Type getType() const;
 
    AbsoluteVariedTime asAbsolute() const;
 
    RecurringTime asRecurring() const;
 
    TimeInterval asInterval() const;
 
    Timer asTimer() const;
 
    std::string toString() const;
 
    static TimePattern parse(const std::string& s);
 
private:
    void destroy();
 
private:
    Type type;
    union
    {
        std::nullptr_t undefined;
        AbsoluteVariedTime absolute;
        RecurringTime recurring;
        TimeInterval interval;
        Timer timer;
    };
};
} // namespace time
} // namespace hueplusplus
 
#endif