timespan.h

Go to the documentation of this file.

#ifndef CHRONO_UTILITIES_TIMESPAN_H
#define CHRONO_UTILITIES_TIMESPAN_H
 
#include "../global.h"
 
#include <cstdint>
#include <functional>
#include <limits>
#include <string>
 
namespace CppUtilities {
 
class DateTime;
 
enum class TimeSpanOutputFormat {
    Normal, 
    WithMeasures, 
    TotalSeconds, 
};
 
class CPP_UTILITIES_EXPORT TimeSpan {
    friend class DateTime;
 
public:
    using TickType = std::int64_t;
 
    explicit constexpr TimeSpan();
    explicit constexpr TimeSpan(TickType ticks);
 
    static constexpr TimeSpan fromMilliseconds(double milliseconds);
    static constexpr TimeSpan fromSeconds(double seconds);
    static constexpr TimeSpan fromMinutes(double minutes);
    static constexpr TimeSpan fromHours(double hours);
    static constexpr TimeSpan fromDays(double days);
#ifdef CHRONO_UTILITIES_TIMESPAN_INTEGER_SCALE_OVERLOADS
    static constexpr TimeSpan fromMilliseconds(TickType milliseconds);
    static constexpr TimeSpan fromSeconds(TickType seconds);
    static constexpr TimeSpan fromMinutes(TickType minutes);
    static constexpr TimeSpan fromHours(TickType hours);
    static constexpr TimeSpan fromDays(TickType days);
#endif
    static TimeSpan fromString(const std::string &str, char separator = ':');
    static TimeSpan fromString(const char *str, char separator);
    static constexpr TimeSpan negativeInfinity();
    static constexpr TimeSpan infinity();
 
    TickType &ticks();
    constexpr TickType totalTicks() const;
    constexpr double totalMicroseconds() const;
    constexpr double totalMilliseconds() const;
    constexpr double totalSeconds() const;
    constexpr double totalMinutes() const;
    constexpr double totalHours() const;
    constexpr double totalDays() const;
 
    constexpr int nanoseconds() const;
    constexpr int microseconds() const;
    constexpr int milliseconds() const;
    constexpr int seconds() const;
    constexpr int minutes() const;
    constexpr int hours() const;
    constexpr int days() const;
 
    constexpr bool operator==(const TimeSpan &other) const;
    constexpr bool operator!=(const TimeSpan &other) const;
    constexpr bool operator<(const TimeSpan &other) const;
    constexpr bool operator>(const TimeSpan &other) const;
    constexpr bool operator<=(const TimeSpan &other) const;
    constexpr bool operator>=(const TimeSpan &other) const;
    constexpr TimeSpan operator+(const TimeSpan &other) const;
    constexpr TimeSpan operator-(const TimeSpan &other) const;
    constexpr TimeSpan operator*(double factor) const;
    constexpr TimeSpan operator/(double factor) const;
#ifdef CHRONO_UTILITIES_TIMESPAN_INTEGER_SCALE_OVERLOADS
    constexpr TimeSpan operator*(TickType factor) const;
    constexpr TimeSpan operator/(TickType factor) const;
#endif
    constexpr double operator/(TimeSpan other) const;
    TimeSpan &operator+=(const TimeSpan &other);
    TimeSpan &operator-=(const TimeSpan &other);
    TimeSpan &operator*=(double factor);
    TimeSpan &operator/=(double factor);
#ifdef CHRONO_UTILITIES_TIMESPAN_INTEGER_SCALE_OVERLOADS
    TimeSpan &operator*=(TickType factor);
    TimeSpan &operator/=(TickType factor);
#endif
 
    std::string toString(TimeSpanOutputFormat format = TimeSpanOutputFormat::Normal, bool fullSeconds = false) const;
    void toString(std::string &result, TimeSpanOutputFormat format = TimeSpanOutputFormat::Normal, bool fullSeconds = false) const;
    constexpr bool isNull() const;
    constexpr bool isNegative() const;
    constexpr bool isNegativeInfinity() const;
    constexpr bool isInfinity() const;
 
    static constexpr TickType nanosecondsPerTick = 100L;
    static constexpr TickType ticksPerMicrosecond = 10L;
    static constexpr TickType ticksPerMillisecond = 10000L;
    static constexpr TickType ticksPerSecond = 10000000L;
    static constexpr TickType ticksPerMinute = 600000000L;
    static constexpr TickType ticksPerHour = 36000000000L;
    static constexpr TickType ticksPerDay = 864000000000L;
 
private:
    TickType m_ticks;
};
 
constexpr inline TimeSpan::TimeSpan()
    : m_ticks(0)
{
}
 
constexpr inline TimeSpan::TimeSpan(TickType ticks)
    : m_ticks(ticks)
{
}
 
constexpr inline TimeSpan TimeSpan::fromMilliseconds(double milliseconds)
{
    return TimeSpan(static_cast<TickType>(milliseconds * static_cast<double>(ticksPerMillisecond)));
}
 
constexpr inline TimeSpan TimeSpan::fromSeconds(double seconds)
{
    return TimeSpan(static_cast<TickType>(seconds * static_cast<double>(ticksPerSecond)));
}
 
constexpr inline TimeSpan TimeSpan::fromMinutes(double minutes)
{
    return TimeSpan(static_cast<TickType>(minutes * static_cast<double>(ticksPerMinute)));
}
 
constexpr inline TimeSpan TimeSpan::fromHours(double hours)
{
    return TimeSpan(static_cast<TickType>(hours * static_cast<double>(ticksPerHour)));
}
 
constexpr inline TimeSpan TimeSpan::fromDays(double days)
{
    return TimeSpan(static_cast<TickType>(days * static_cast<double>(ticksPerDay)));
}
 
#ifdef CHRONO_UTILITIES_TIMESPAN_INTEGER_SCALE_OVERLOADS
constexpr inline TimeSpan TimeSpan::fromMilliseconds(TickType milliseconds)
{
    return TimeSpan(milliseconds * ticksPerMillisecond);
}
 
constexpr inline TimeSpan TimeSpan::fromSeconds(TickType seconds)
{
    return TimeSpan(seconds * ticksPerSecond);
}
 
constexpr inline TimeSpan TimeSpan::fromMinutes(TickType minutes)
{
    return TimeSpan(minutes * ticksPerMinute);
}
 
constexpr inline TimeSpan TimeSpan::fromHours(TickType hours)
{
    return TimeSpan(hours * ticksPerHour);
}
 
constexpr inline TimeSpan TimeSpan::fromDays(TickType days)
{
    return TimeSpan(days * ticksPerDay);
}
#endif
 
inline TimeSpan TimeSpan::fromString(const std::string &str, char separator)
{
    return TimeSpan::fromString(str.data(), separator);
}
 
constexpr inline TimeSpan TimeSpan::negativeInfinity()
{
    return TimeSpan(std::numeric_limits<TickType>::min());
}
 
constexpr inline TimeSpan TimeSpan::infinity()
{
    return TimeSpan(std::numeric_limits<TickType>::max());
}
 
inline TimeSpan::TickType &TimeSpan::ticks()
{
    return m_ticks;
}
 
constexpr inline TimeSpan::TickType TimeSpan::totalTicks() const
{
    return m_ticks;
}
 
constexpr double TimeSpan::totalMicroseconds() const
{
    return static_cast<double>(m_ticks) / static_cast<double>(ticksPerMicrosecond);
}
 
constexpr inline double TimeSpan::totalMilliseconds() const
{
    return static_cast<double>(m_ticks) / static_cast<double>(ticksPerMillisecond);
}
 
constexpr inline double TimeSpan::totalSeconds() const
{
    return static_cast<double>(m_ticks) / static_cast<double>(ticksPerSecond);
}
 
constexpr inline double TimeSpan::totalMinutes() const
{
    return static_cast<double>(m_ticks) / static_cast<double>(ticksPerMinute);
}
 
constexpr inline double TimeSpan::totalHours() const
{
    return static_cast<double>(m_ticks) / static_cast<double>(ticksPerHour);
}
 
constexpr inline double TimeSpan::totalDays() const
{
    return static_cast<double>(m_ticks) / static_cast<double>(ticksPerDay);
}
 
constexpr int TimeSpan::nanoseconds() const
{
    return static_cast<int>(m_ticks % 10l * TimeSpan::nanosecondsPerTick);
}
 
constexpr int TimeSpan::microseconds() const
{
    return static_cast<int>((m_ticks / ticksPerMicrosecond) % 1000l);
}
 
constexpr inline int TimeSpan::milliseconds() const
{
    return static_cast<int>((m_ticks / ticksPerMillisecond) % 1000l);
}
 
constexpr inline int TimeSpan::seconds() const
{
    return static_cast<int>((m_ticks / ticksPerSecond) % 60l);
}
 
constexpr inline int TimeSpan::minutes() const
{
    return static_cast<int>((m_ticks / ticksPerMinute) % 60l);
}
 
constexpr inline int TimeSpan::hours() const
{
    return static_cast<int>((m_ticks / ticksPerHour) % 24l);
}
 
constexpr inline int TimeSpan::days() const
{
    return static_cast<int>((m_ticks / ticksPerDay));
}
 
constexpr inline bool TimeSpan::operator==(const TimeSpan &other) const
{
    return m_ticks == other.m_ticks;
}
 
constexpr inline bool TimeSpan::operator!=(const TimeSpan &other) const
{
    return m_ticks != other.m_ticks;
}
 
constexpr inline bool TimeSpan::operator<(const TimeSpan &other) const
{
    return m_ticks < other.m_ticks;
}
 
constexpr inline bool TimeSpan::operator>(const TimeSpan &other) const
{
    return m_ticks > other.m_ticks;
}
 
constexpr inline bool TimeSpan::operator<=(const TimeSpan &other) const
{
    return m_ticks <= other.m_ticks;
}
 
constexpr inline bool TimeSpan::operator>=(const TimeSpan &other) const
{
    return m_ticks >= other.m_ticks;
}
 
constexpr inline TimeSpan TimeSpan::operator+(const TimeSpan &other) const
{
    return TimeSpan(m_ticks + other.m_ticks);
}
 
constexpr inline TimeSpan TimeSpan::operator-(const TimeSpan &other) const
{
    return TimeSpan(m_ticks - other.m_ticks);
}
 
constexpr inline TimeSpan TimeSpan::operator*(double factor) const
{
    return TimeSpan(static_cast<std::int64_t>(static_cast<double>(m_ticks) * factor));
}
 
constexpr inline TimeSpan TimeSpan::operator/(double factor) const
{
    return TimeSpan(static_cast<std::int64_t>(static_cast<double>(m_ticks) / factor));
}
 
#ifdef CHRONO_UTILITIES_TIMESPAN_INTEGER_SCALE_OVERLOADS
constexpr inline TimeSpan TimeSpan::operator*(std::int64_t factor) const
{
    return TimeSpan(m_ticks * factor);
}
 
constexpr inline TimeSpan TimeSpan::operator/(std::int64_t factor) const
{
    return TimeSpan(m_ticks / factor);
}
#endif
 
constexpr inline double TimeSpan::operator/(TimeSpan other) const
{
    return static_cast<double>(m_ticks) / static_cast<double>(other.m_ticks);
}
 
inline TimeSpan &TimeSpan::operator+=(const TimeSpan &other)
{
    m_ticks += other.m_ticks;
    return *this;
}
 
inline TimeSpan &TimeSpan::operator-=(const TimeSpan &other)
{
    m_ticks -= other.m_ticks;
    return *this;
}
 
inline TimeSpan &TimeSpan::operator*=(double factor)
{
    m_ticks = static_cast<std::int64_t>(static_cast<double>(m_ticks) * factor);
    return *this;
}
 
inline TimeSpan &TimeSpan::operator/=(double factor)
{
    m_ticks = static_cast<std::int64_t>(static_cast<double>(m_ticks) / factor);
    return *this;
}
 
#ifdef CHRONO_UTILITIES_TIMESPAN_INTEGER_SCALE_OVERLOADS
inline TimeSpan &TimeSpan::operator*=(std::int64_t factor)
{
    m_ticks *= factor;
    return *this;
}
 
inline TimeSpan &TimeSpan::operator/=(std::int64_t factor)
{
    m_ticks /= factor;
    return *this;
}
#endif
 
inline std::string TimeSpan::toString(TimeSpanOutputFormat format, bool fullSeconds) const
{
    std::string result;
    toString(result, format, fullSeconds);
    return result;
}
 
constexpr inline bool TimeSpan::isNull() const
{
    return m_ticks == 0;
}
 
constexpr inline bool TimeSpan::isNegative() const
{
    return m_ticks < 0;
}
 
constexpr inline bool TimeSpan::isNegativeInfinity() const
{
    return m_ticks == std::numeric_limits<decltype(m_ticks)>::min();
}
 
constexpr inline bool TimeSpan::isInfinity() const
{
    return m_ticks == std::numeric_limits<decltype(m_ticks)>::max();
}
} // namespace CppUtilities
 
namespace std {
template <> struct hash<CppUtilities::TimeSpan> {
    inline size_t operator()(const CppUtilities::TimeSpan &timeSpan) const
    {
        return hash<decltype(timeSpan.totalTicks())>()(timeSpan.totalTicks());
    }
};
} // namespace std
 
#endif // CHRONO_UTILITIES_TIMESPAN_H