time_duration.hpp

浏览该文件的文档.

#pragma once
#include <string>
#include <xcal/property/core/property.hpp>
 
namespace xcal::property {
 
class XCAL_API TimeDuration : public MProperty {
    XCAL_PROPERTY_TYPE(TimeDuration)
   private:
    Proxy<size_t> microseconds_{this, 0};  
 
   public:
    TimeDuration() : MProperty() {}
 
    explicit TimeDuration(size_t microseconds) : MProperty() {
        microseconds_ = microseconds;
    }
 
    explicit TimeDuration(float_t seconds) : MProperty() {
        set_seconds(seconds);
    }
 
    static TimeDuration from_microseconds(size_t us) {
        return TimeDuration(us);
    }
 
    static TimeDuration from_milliseconds(size_t ms) {
        return TimeDuration(ms * 1000);
    }
 
    static TimeDuration from_seconds(float_t seconds) {
        return TimeDuration(seconds);
    }
 
    static TimeDuration from_minutes(float_t minutes) {
        return TimeDuration(minutes * 60.0f);
    }
 
    static TimeDuration from_hours(float_t hours) {
        return TimeDuration(hours * 3600.0f);
    }
 
    size_t microseconds() const { return microseconds_; }
 
    size_t milliseconds() const { return microseconds_ / 1000; }
 
    float_t seconds() const {
        return static_cast<float_t>(microseconds_) / 1000000.0f;
    }
 
    float_t minutes() const {
        return static_cast<float_t>(microseconds_) / 60000000.0f;
    }
 
    float_t hours() const {
        return static_cast<float_t>(microseconds_) / 3600000000.0f;
    }
 
    void set_microseconds(size_t us) { microseconds_ = us; }
 
    void set_milliseconds(size_t ms) { microseconds_ = ms * 1000; }
 
    void set_seconds(float_t seconds) {
        microseconds_ = static_cast<size_t>(seconds * 1000000.0f);
    }
 
    void set_minutes(float_t minutes) { set_seconds(minutes * 60.0f); }
 
    void set_hours(float_t hours) { set_seconds(hours * 3600.0f); }
 
    TimeDuration operator+(const TimeDuration& other) const {
        return TimeDuration(microseconds_ + other.microseconds_);
    }
 
    TimeDuration operator-(const TimeDuration& other) const {
        return TimeDuration(microseconds_ - other.microseconds_);
    }
 
    TimeDuration operator*(size_t multiplier) const {
        return TimeDuration(microseconds_ * multiplier);
    }
 
    TimeDuration operator/(size_t divisor) const {
        return TimeDuration(microseconds_ / divisor);
    }
 
    bool operator==(const TimeDuration& other) const {
        return microseconds_ == other.microseconds_;
    }
 
    bool operator!=(const TimeDuration& other) const {
        return !(*this == other);
    }
 
    bool operator<(const TimeDuration& other) const {
        return microseconds_ < other.microseconds_;
    }
 
    bool operator>(const TimeDuration& other) const {
        return microseconds_ > other.microseconds_;
    }
 
    bool operator<=(const TimeDuration& other) const {
        return microseconds_ <= other.microseconds_;
    }
 
    bool operator>=(const TimeDuration& other) const {
        return microseconds_ >= other.microseconds_;
    }
 
    std::string to_string() const {
        if (microseconds_ < 1000) {
            return std::to_string(microseconds_) + "us";
        } else if (microseconds_ < 1000000) {
            return std::to_string(milliseconds()) + "ms";
        } else {
            return std::to_string(seconds()) + "s";
        }
    }
};
 
}  // namespace xcal::property