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