time.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_TIME_HEADER
#define LIBFILEZILLA_TIME_HEADER
 
#include "libfilezilla.hpp"
 
#include <chrono>
#include <ctime>
 
#include <limits>
 
#ifdef FZ_WINDOWS
#include "glue/windows.hpp"
#endif

 
namespace fz {
 
class FZ_PUBLIC_SYMBOL duration;

class FZ_PUBLIC_SYMBOL datetime final
{
public:
    enum accuracy : char {
        days,
        hours,
        minutes,
        seconds,
        milliseconds
    };

    enum zone {
        utc,
        local
    };

    datetime() noexcept = default;
 
    datetime(zone z, int year, int month, int day, int hour = -1, int minute = -1, int second = -1, int millisecond = -1);
 
    explicit datetime(time_t, accuracy a);

    explicit datetime(std::string_view const& s, zone z);
    explicit datetime(std::wstring_view const& s, zone z);
 
#ifdef FZ_WINDOWS
    explicit datetime(FILETIME const& ft, accuracy a);
#endif
 
    datetime(datetime const& op) = default;
    datetime(datetime && op) noexcept = default;
    datetime& operator=(datetime const& op) = default;
    datetime& operator=(datetime && op) noexcept = default;

    bool empty() const;
 
    explicit operator bool() const {
        return !empty();
    }

    void clear();
 
    accuracy get_accuracy() const { return a_; }

    static datetime now();

    bool operator==(datetime const& op) const;
    bool operator!=(datetime const& op) const { return !(*this == op); }
    bool operator<(datetime const& op) const;
    bool operator<=(datetime const& op) const;
    bool operator>(datetime const& op) const { return op < *this; }
    bool operator>=(datetime const& op) const { return op <= *this; }

    int compare(datetime const& op) const;

    bool earlier_than(datetime const& op) const { return compare(op) < 0; }

    bool later_than(datetime const& op) const { return compare(op) > 0; }

    datetime& operator+=(duration const& op);
    datetime operator+(duration const& op) const { datetime t(*this); t += op; return t; }
 
    datetime& operator-=(duration const& op);
    datetime operator-(duration const& op) const { datetime t(*this); t -= op; return t; }
 
    friend duration FZ_PUBLIC_SYMBOL operator-(datetime const& a, datetime const& b);

    bool set(zone z, int year, int month, int day, int hour = -1, int minute = -1, int second = -1, int millisecond = -1);

    bool set(std::string_view const& str, zone z);
    bool set(std::wstring_view const& str, zone z);
 
#ifdef FZ_WINDOWS
    bool set(FILETIME const& ft, accuracy a);
    bool set(SYSTEMTIME const& ft, accuracy a, zone z);
#endif
 
#if defined(FZ_UNIX) || defined(FZ_MAC)
    bool set(tm & t, accuracy a, zone z);
#endif

    bool imbue_time(int hour, int minute, int second = -1, int millisecond = -1);

    std::string format(std::string const& format, zone z) const;
    std::wstring format(std::wstring const& format, zone z) const;

    static bool verify_format(std::string const& fmt);
    static bool verify_format(std::wstring const& fmt);

    int get_milliseconds() const {
        int ms = static_cast<int>(t_ % 1000);
        if (ms < 0) {
            ms += 1000;
        }
        return ms;
    }

    time_t get_time_t() const;

    tm get_tm(zone z) const;
 
#ifdef FZ_WINDOWS
    FILETIME get_filetime() const;
#endif

    std::string get_rfc822() const;

    bool set_rfc822(std::string_view const& str);
    bool set_rfc822(std::wstring_view const& str);

    bool set_rfc3339(std::string_view const& str);
    bool set_rfc3339(std::wstring_view const& str);
 
private:
    int FZ_PRIVATE_SYMBOL compare_slow(datetime const& op) const;
 
    bool FZ_PRIVATE_SYMBOL clamped();
 
    enum invalid_t : int64_t {
        invalid = std::numeric_limits<int64_t>::min()
    };
 
    int64_t t_{invalid};
    accuracy a_{days};
};

class FZ_PUBLIC_SYMBOL duration final
{
public:
    duration() noexcept = default;

    int64_t get_days() const { return ms_ / 1000 / 3600 / 24; }
    int64_t get_hours() const { return ms_ / 1000 / 3600; }
    int64_t get_minutes() const { return ms_ / 1000 / 60; }
    int64_t get_seconds() const { return ms_ / 1000; }
    int64_t get_milliseconds() const { return ms_; }

    static duration from_days(int64_t m) {
        return duration(m * 1000 * 60 * 60 * 24);
    }
    static duration from_hours(int64_t m) {
        return duration(m * 1000 * 60 * 60);
    }
    static duration from_minutes(int64_t m) {
        return duration(m * 1000 * 60);
    }
    static duration from_seconds(int64_t m) {
        return duration(m * 1000);
    }
    static duration from_milliseconds(int64_t m) {
        return duration(m);
    }

    duration& operator+=(duration const& op) {
        ms_ += op.ms_;
        return *this;
    }
 
    duration& operator-=(duration const& op) {
        ms_ -= op.ms_;
        return *this;
    }
 
    duration& operator/=(int64_t op) {
        ms_ /= op;
        return *this;
    }
 
    duration operator-() const {
        return duration(-ms_);
    }
 
    explicit operator bool() const {
        return ms_ != 0;
    }
 
    duration& operator*=(int64_t op) {
        ms_ *= op;
        return *this;
    }
 
    duration absolute() const {
        return (ms_ < 0) ? duration(-ms_) : *this;
    }
 
    bool operator<(duration const& op) const { return ms_ < op.ms_; }
    bool operator<=(duration const& op) const { return ms_ <= op.ms_; }
    bool operator>(duration const& op) const { return ms_ > op.ms_; }
    bool operator>=(duration const& op) const { return ms_ >= op.ms_; }
 
    friend duration FZ_PUBLIC_SYMBOL operator-(duration const& a, duration const& b);
    friend duration FZ_PUBLIC_SYMBOL operator+(duration const& a, duration const& b);
    friend duration FZ_PUBLIC_SYMBOL operator/(duration const& a, int64_t b);
private:
    explicit FZ_PRIVATE_SYMBOL duration(int64_t ms) : ms_(ms) {}
 
    int64_t ms_{};
};
 
inline duration operator-(duration const& a, duration const& b)
{
    return duration(a) -= b;
}
 
inline duration operator+(duration const& a, duration const& b)
{
    return duration(a) += b;
}
 
inline duration operator/(duration const& a, int64_t b)
{
    return duration(a) /= b;
}

duration FZ_PUBLIC_SYMBOL operator-(datetime const& a, datetime const& b);
 
 
 

class FZ_PUBLIC_SYMBOL monotonic_clock final
{
public:
    monotonic_clock() = default;
 
    monotonic_clock(monotonic_clock const&) = default;
    monotonic_clock(monotonic_clock &&) noexcept = default;
    monotonic_clock& operator=(monotonic_clock const&) = default;
    monotonic_clock& operator=(monotonic_clock &&) noexcept = default;
 
    monotonic_clock const operator+(duration const& d) const
    {
        return monotonic_clock(*this) += d;
    }
    monotonic_clock const operator-(duration const& d) const
    {
        return monotonic_clock(*this) -= d;
    }
 
private:
    typedef std::chrono::steady_clock clock_type;
    static_assert(std::chrono::steady_clock::is_steady, "Nonconforming stdlib, your steady_clock isn't steady");
 
public:
    static monotonic_clock now() {
        return monotonic_clock(std::chrono::time_point_cast<std::chrono::milliseconds>(clock_type::now()));
    }
 
    explicit operator bool() const {
        return t_ != clock_type::time_point();
    }
 
    monotonic_clock& operator+=(duration const& d)
    {
        t_ += std::chrono::milliseconds(d.get_milliseconds());
        return *this;
    }
 
    monotonic_clock& operator-=(duration const& d)
    {
        t_ -= std::chrono::milliseconds(d.get_milliseconds());
        return *this;
    }
 
private:
    explicit FZ_PRIVATE_SYMBOL monotonic_clock(clock_type::time_point const& t)
        : t_(t)
    {}
 
    clock_type::time_point t_;
 
    friend duration operator-(monotonic_clock const& a, monotonic_clock const& b);
    friend bool operator==(monotonic_clock const& a, monotonic_clock const& b);
    friend bool operator<(monotonic_clock const& a, monotonic_clock const& b);
    friend bool operator<=(monotonic_clock const& a, monotonic_clock const& b);
    friend bool operator>(monotonic_clock const& a, monotonic_clock const& b);
    friend bool operator>=(monotonic_clock const& a, monotonic_clock const& b);
};

inline duration operator-(monotonic_clock const& a, monotonic_clock const& b)
{
    return duration::from_milliseconds(std::chrono::duration_cast<std::chrono::milliseconds>(a.t_ - b.t_).count());
}

inline bool operator==(monotonic_clock const& a, monotonic_clock const& b)
{
    return a.t_ == b.t_;
}

inline bool operator<(monotonic_clock const& a, monotonic_clock const& b)
{
    return a.t_ < b.t_;
}

inline bool operator<=(monotonic_clock const& a, monotonic_clock const& b)
{
    return a.t_ <= b.t_;
}

inline bool operator>(monotonic_clock const& a, monotonic_clock const& b)
{
    return a.t_ > b.t_;
}

inline bool operator>=(monotonic_clock const& a, monotonic_clock const& b)
{
    return a.t_ >= b.t_;
}
 
}
 
#endif