chrono.h

Go to the documentation of this file.

#pragma once

 
#include "fl/stl/int.h"
#include "fl/stl/ratio.h"
 
#ifdef FASTLED_TESTING
#include "fl/stl/function.h"
#include "fl/stl/noexcept.h"
#endif
 
namespace fl {
namespace chrono {

template<typename Rep, typename Period = fl::ratio<1>>
class duration {
public:
    using rep = Rep;
    using period = Period;

    constexpr duration() FL_NOEXCEPT : mCount(0) {}

    constexpr explicit duration(const Rep& count) FL_NOEXCEPT : mCount(count) {}

    template<typename Rep2, typename Period2>
    constexpr duration(const duration<Rep2, Period2>& d) FL_NOEXCEPT
        : mCount(duration_cast_impl<Rep, Period, Rep2, Period2>(d.count())) {}

    constexpr Rep count() const FL_NOEXCEPT { return mCount; }
 
private:
    Rep mCount;

    template<typename ToRep, typename ToPeriod, typename FromRep, typename FromPeriod>
    static constexpr ToRep duration_cast_impl(FromRep count) FL_NOEXCEPT {
        // Convert from source period to destination period
        // target_count = source_count * (FromPeriod / ToPeriod)
        // Using: target = source * FromPeriod::num * ToPeriod::den / (FromPeriod::den * ToPeriod::num)
        using ratio = fl::ratio_divide<FromPeriod, ToPeriod>;
        return static_cast<ToRep>(
            static_cast<FromRep>(count) * static_cast<FromRep>(ratio::num) / static_cast<FromRep>(ratio::den)
        );
    }
};

template<typename ToDuration, typename Rep, typename Period>
constexpr ToDuration duration_cast(const duration<Rep, Period>& d) FL_NOEXCEPT {
    return ToDuration(d);
}
 
// Common duration type aliases using standard SI ratios
// These are compatible with std::chrono duration types

using nanoseconds = duration<fl::i64, fl::nano>;

using microseconds = duration<fl::i64, fl::micro>;

using milliseconds = duration<fl::i64, fl::milli>;

using seconds = duration<fl::i64>;

using minutes = duration<fl::i32, fl::ratio<60>>;

using hours = duration<fl::i32, fl::ratio<3600>>;

template<typename Clock, typename Duration = typename Clock::duration>
class time_point {
public:
    using clock = Clock;
    using duration = Duration;
    using rep = typename Duration::rep;
    using period = typename Duration::period;

    constexpr time_point() FL_NOEXCEPT : mDuration() {}

    constexpr explicit time_point(const Duration& d) FL_NOEXCEPT : mDuration(d) {}

    constexpr Duration time_since_epoch() const FL_NOEXCEPT { return mDuration; }
 
    // Comparison operators
    constexpr bool operator<=(const time_point& rhs) const FL_NOEXCEPT {
        return mDuration.count() <= rhs.mDuration.count();
    }
    constexpr bool operator<(const time_point& rhs) const FL_NOEXCEPT {
        return mDuration.count() < rhs.mDuration.count();
    }
    constexpr bool operator>=(const time_point& rhs) const FL_NOEXCEPT {
        return mDuration.count() >= rhs.mDuration.count();
    }
    constexpr bool operator>(const time_point& rhs) const FL_NOEXCEPT {
        return mDuration.count() > rhs.mDuration.count();
    }
    constexpr bool operator==(const time_point& rhs) const FL_NOEXCEPT {
        return mDuration.count() == rhs.mDuration.count();
    }
    constexpr bool operator!=(const time_point& rhs) const FL_NOEXCEPT {
        return mDuration.count() != rhs.mDuration.count();
    }

    constexpr Duration operator-(const time_point& rhs) const FL_NOEXCEPT {
        return Duration(mDuration.count() - rhs.mDuration.count());
    }

    constexpr time_point operator+(const Duration& d) const FL_NOEXCEPT {
        return time_point(Duration(mDuration.count() + d.count()));
    }

    constexpr time_point operator-(const Duration& d) const FL_NOEXCEPT {
        return time_point(Duration(mDuration.count() - d.count()));
    }
 
private:
    Duration mDuration;
};
 
// Forward declarations for clock types (now() implemented after fl::micros() declaration)
struct steady_clock;  // IWYU pragma: keep
struct system_clock;  // IWYU pragma: keep

struct steady_clock {
    using duration = microseconds;
    using rep = duration::rep;
    using period = duration::period;
    using time_point = fl::chrono::time_point<steady_clock>;
    static constexpr bool is_steady = true;

    static time_point now() FL_NOEXCEPT;
};

struct system_clock {
    using duration = microseconds;
    using rep = duration::rep;
    using period = duration::period;
    using time_point = fl::chrono::time_point<system_clock>;
    static constexpr bool is_steady = false;

    static time_point now() FL_NOEXCEPT;
};
 
} // namespace chrono


fl::u32 millis() FL_NOEXCEPT;

fl::u32 micros() FL_NOEXCEPT;
 
// Now that fl::micros() is declared, implement clock::now() methods
inline chrono::steady_clock::time_point chrono::steady_clock::now() FL_NOEXCEPT {
    return time_point(duration(static_cast<fl::i64>(fl::micros())));
}
 
inline chrono::system_clock::time_point chrono::system_clock::now() FL_NOEXCEPT {
    return time_point(duration(static_cast<fl::i64>(fl::micros())));
}

fl::u64 millis64() FL_NOEXCEPT;

inline fl::u64 time() FL_NOEXCEPT {
    return fl::millis64();
}
 
#ifdef FASTLED_TESTING

using time_provider_t = fl::function<fl::u32()>;

void inject_time_provider(const time_provider_t& provider) FL_NOEXCEPT;

void clear_time_provider() FL_NOEXCEPT;

void millis64_reset() FL_NOEXCEPT;

class MockTimeProvider {
public:
    explicit MockTimeProvider(fl::u32 initial_time = 0) FL_NOEXCEPT;

    void advance(fl::u32 milliseconds) FL_NOEXCEPT;

    void set_time(fl::u32 milliseconds) FL_NOEXCEPT;

    fl::u32 current_time() const FL_NOEXCEPT;

    fl::u32 operator()() const FL_NOEXCEPT;
 
private:
    fl::u32 mCurrentTime;
};
 
#endif // FASTLED_TESTING
 
} // namespace fl