timestamp.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <thread>  // For std::this_thread::sleep_for
#include <cstdint>
#include <ctime>
 
namespace commrat {
 
using Timestamp = uint64_t;
 
using Nanoseconds = std::chrono::nanoseconds;
using Microseconds = std::chrono::microseconds;
using Milliseconds = std::chrono::milliseconds;
using Seconds = std::chrono::seconds;
using Minutes = std::chrono::minutes;
using Hours = std::chrono::hours;
 
class Time {
public:
    enum class ClockSource {
        SYSTEM_CLOCK,      
        STEADY_CLOCK,      
        HIGH_RES_CLOCK,    
        REALTIME_CLOCK,    
        MONOTONIC_CLOCK    
    };
    
    static Timestamp now() noexcept {
        return get_timestamp(current_clock_source_);
    }
    
    static Timestamp get_timestamp(ClockSource source = ClockSource::STEADY_CLOCK) noexcept {
        switch (source) {
            case ClockSource::SYSTEM_CLOCK:
                return system_clock_now();
                
            case ClockSource::STEADY_CLOCK:
            case ClockSource::HIGH_RES_CLOCK:
                return steady_clock_now();
                
            case ClockSource::REALTIME_CLOCK:
                return posix_clock_now(CLOCK_REALTIME);
                
            case ClockSource::MONOTONIC_CLOCK:
                return posix_clock_now(CLOCK_MONOTONIC);
                
            default:
                return steady_clock_now();
        }
    }
    
    static void set_clock_source(ClockSource source) noexcept {
        current_clock_source_ = source;
    }
    
    template<typename Rep, typename Period>
    static constexpr Timestamp to_nanoseconds(std::chrono::duration<Rep, Period> duration) noexcept {
        return static_cast<Timestamp>(
            std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count()
        );
    }
    
    template<typename Duration>
    static constexpr Duration from_nanoseconds(Timestamp ns) noexcept {
        return std::chrono::duration_cast<Duration>(std::chrono::nanoseconds(ns));
    }
    
    static constexpr Timestamp milliseconds_to_ns(uint64_t ms) noexcept {
        return ms * 1'000'000;
    }
    
    static constexpr Timestamp microseconds_to_ns(uint64_t us) noexcept {
        return us * 1'000;
    }
    
    static constexpr uint64_t ns_to_milliseconds(Timestamp ns) noexcept {
        return ns / 1'000'000;
    }
    
    static constexpr uint64_t ns_to_microseconds(Timestamp ns) noexcept {
        return ns / 1'000;
    }
    
    static constexpr Timestamp diff(Timestamp t1, Timestamp t2) noexcept {
        return (t1 > t2) ? (t1 - t2) : (t2 - t1);
    }
    
    static constexpr bool is_within_tolerance(Timestamp timestamp, 
                                             Timestamp target,
                                             Timestamp tolerance_ns) noexcept {
        return diff(timestamp, target) <= tolerance_ns;
    }
    
    static void sleep_ns(Timestamp ns) noexcept {
        std::this_thread::sleep_for(std::chrono::nanoseconds(ns));
    }
    
    template<typename Rep, typename Period>
    static void sleep(std::chrono::duration<Rep, Period> duration) noexcept {
        std::this_thread::sleep_for(duration);
    }
 
private:
    // Implementation helpers
    static Timestamp system_clock_now() noexcept {
        auto now = std::chrono::system_clock::now();
        auto duration = now.time_since_epoch();
        return std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count();
    }
    
    static Timestamp steady_clock_now() noexcept {
        auto now = std::chrono::steady_clock::now();
        auto duration = now.time_since_epoch();
        return std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count();
    }
    
    static Timestamp posix_clock_now(clockid_t clock_id) noexcept {
        struct timespec ts;
        if (clock_gettime(clock_id, &ts) == 0) {
            return static_cast<Timestamp>(ts.tv_sec) * 1'000'000'000 + 
                   static_cast<Timestamp>(ts.tv_nsec);
        }
        // Fallback to steady clock on error
        return steady_clock_now();
    }
    
    // Default clock source (can be changed via set_clock_source)
    static inline ClockSource current_clock_source_ = ClockSource::STEADY_CLOCK;
};
 
/*
inline constexpr bool operator<(Timestamp lhs, Timestamp rhs) noexcept {
    return lhs < rhs;
}
 
inline constexpr bool operator<=(Timestamp lhs, Timestamp rhs) noexcept {
    return lhs <= rhs;
}
 
inline constexpr bool operator>(Timestamp lhs, Timestamp rhs) noexcept {
    return lhs > rhs;
}
 
inline constexpr bool operator>=(Timestamp lhs, Timestamp rhs) noexcept {
    return lhs >= rhs;
}
 
inline constexpr Timestamp operator+(Timestamp ts, uint64_t ns) noexcept {
    return ts + ns;
}
 
inline constexpr Timestamp operator-(Timestamp ts, uint64_t ns) noexcept {
    return ts - ns;
}
 
inline constexpr Timestamp operator-(Timestamp t1, Timestamp t2) noexcept {
    return t1 - t2;
}
*/
 
namespace literals {
    constexpr Timestamp operator""_ns(unsigned long long ns) noexcept {
        return static_cast<Timestamp>(ns);
    }
    
    constexpr Timestamp operator""_us(unsigned long long us) noexcept {
        return Time::microseconds_to_ns(us);
    }
    
    constexpr Timestamp operator""_ms(unsigned long long ms) noexcept {
        return Time::milliseconds_to_ns(ms);
    }
    
    constexpr Timestamp operator""_s(unsigned long long s) noexcept {
        return Time::milliseconds_to_ns(s * 1000);
    }
} // namespace literals
 
} // namespace commrat