time_span.hpp

Go to the documentation of this file.

 
#pragma once
#include "chrono.hpp"
#include "icomparable.hpp"
#include "iequatable.hpp"
#include "iformatable.hpp"
#include "object.hpp"
#include "parse.hpp"
#include "ticks.hpp"
#include "types.hpp"
#include "string.hpp"
 
namespace xtd {
  
  struct time_span : public xtd::object, xtd::iequatable<time_span>, public icomparable<time_span>, public iformatable {
  public:
 
    static const time_span max_value;
    
    static const time_span min_value;
    
    static constexpr int64 nanoseconds_per_tick = 100ll;
 
    static constexpr int64 ticks_per_microsecond = 10ll;
 
    static constexpr int64 ticks_per_millisecond = ticks_per_microsecond * 1'000;
 
    static constexpr int64 ticks_per_second = ticks_per_millisecond * 1'000;
 
    static constexpr int64 ticks_per_minute = ticks_per_second * 60;
 
    static constexpr int64 ticks_per_hour = ticks_per_minute * 60;
 
    static constexpr int64 ticks_per_day = ticks_per_hour * 24;
 
    static const time_span zero;
    
    
    explicit time_span(int64 ticks);
    explicit time_span(xtd::ticks ticks);
    template<typename duration_t, typename period_t = std::ratio<1>> // Can't be explicit by design.
    time_span(const std::chrono::duration<duration_t, period_t>& value) : time_span(static_cast<int64>(std::chrono::duration_cast<xtd::ticks>(value).count())) {}
    time_span(int32 hours, int32 minutes, int32 seconds);
    time_span(int32 days, int32 hours, int32 minutes, int32 seconds);
    time_span(int32 days, int32 hours, int32 minutes, int32 seconds, int32 milliseconds);
    time_span(int32 days, int32 hours, int32 minutes, int32 seconds, int32 milliseconds, int32 microseconds);
    time_span(int32 days, int32 hours, int32 minutes, int32 seconds, int32 milliseconds, int32 microseconds, int32 nanoseconds);
 
    time_span();
    time_span(const time_span&) = default;
    time_span(time_span&&) = default;
    time_span(uint32 hours, uint32 minutes, uint32 seconds);
    time_span(uint32 days, uint32 hours, uint32 minutes, uint32 seconds);
    time_span(uint32 days, uint32 hours, uint32 minutes, uint32 seconds, uint32 milliseconds);
    time_span(uint32 days, uint32 hours, uint32 minutes, uint32 seconds, uint32 milliseconds, uint32 microseconds);
    time_span(uint32 days, uint32 hours, uint32 minutes, uint32 seconds, uint32 milliseconds, uint32 microseconds, uint32 nanoseconds);
 
    time_span& operator =(const time_span&) = default;
    time_span& operator +=(const time_span& value);
    time_span& operator -=(const time_span& value);
    time_span operator +(const time_span& value);
    time_span operator -(const time_span& value);
    double operator *(const time_span& value);
    time_span operator *(double value);
    double operator /(const time_span& value);
    time_span operator /(double value);
    time_span operator +();
    time_span operator -();
    time_span& operator ++();
    time_span operator ++(int);
    time_span& operator --();
    time_span operator --(int);
    
    
    int32 days() const noexcept;
    
    int32 hours() const noexcept;
    
    int32 microseconds() const noexcept;
    
    int32 milliseconds() const noexcept;
   
    int32 minutes() const noexcept;
    
    int32 nanoseconds() const noexcept;
 
    int32 seconds() const noexcept;
 
    int64 ticks() const noexcept;
    
    xtd::ticks ticks_duration() const noexcept;
    
    double total_days() const noexcept;
    
    std::chrono::days total_days_duration() const noexcept;
    
    double total_hours() const noexcept;
    
    std::chrono::hours total_hours_duration() const noexcept;
 
    double total_microseconds() const noexcept;
 
    std::chrono::microseconds total_microseconds_duration() const noexcept;
 
    double total_milliseconds() const noexcept;
 
    std::chrono::milliseconds total_milliseconds_duration() const noexcept;
 
    double total_minutes() const noexcept;
 
    std::chrono::minutes total_minutes_duration() const noexcept;
 
    double total_nanoseconds() const noexcept;
 
    std::chrono::nanoseconds total_nanoseconds_duration() const noexcept;
 
    double total_seconds() const noexcept;
 
    std::chrono::seconds total_seconds_duration() const noexcept;
 
 
    
    time_span add(const time_span& ts) const noexcept;
 
    int32 compare_to(const time_span& value) const noexcept override;
    
    double divide(const time_span& ts) const;
    time_span divide(double divisor) const;
 
    time_span duration() const noexcept;
    
    using object::equals;
    bool equals(const time_span& value) const noexcept override;
    
    double multiply(const time_span& ts) const noexcept;
    time_span multiply(double factor) const noexcept;
 
    time_span negate() const;
 
    static time_span parse(const string& value);
    
    time_span subtract(const time_span& ts) const noexcept;
 
    xtd::string to_string() const noexcept override;
    string to_string(const string& format) const;
 
    string to_string(const string& format, const std::locale& loc) const override;
    
    
    static bool equals(time_span t1, time_span t2);
    
    static time_span from_days(double value);
    static time_span from_days(std::chrono::days value);
    
    static time_span from_hours(double value);
    static time_span from_hours(std::chrono::hours value);
    
    static time_span from_microseconds(double value);
    static time_span from_microseconds(std::chrono::microseconds value);
    
    static time_span from_milliseconds(double value);
    static time_span from_milliseconds(std::chrono::milliseconds value);
    
    static time_span from_minutes(double value);
    static time_span from_minutes(std::chrono::minutes value);
    
    static time_span from_nanoseconds(double value);
    static time_span from_nanoseconds(std::chrono::nanoseconds value);
    
    static time_span from_seconds(double value);
    static time_span from_seconds(std::chrono::seconds value);
    
    static time_span from_ticks(int64 value);
    static time_span from_ticks(xtd::ticks value);
 
    static bool try_parse(const string& value, time_span& result);
 
  private:
    static constexpr int32 millis_per_second = 1000;
    static constexpr int32 millis_per_minute = millis_per_second * 60; //     60,000
    static constexpr int32 millis_per_hour = millis_per_minute * 60;   //  3,600,000
    static constexpr int32 millis_per_day = millis_per_hour * 24;      // 86,400,000
 
    static constexpr int32 parse_succeed = 0;
    static constexpr int32 parse_overflow = 1;
    static constexpr int32 parse_format = 2;
 
    static time_span interval(double value, int scale);
    string make_string_from_duration(bool constant) const;
    static int32 try_parse_internal(const string& value, time_span& result);
 
    int64 ticks_ = 0;
  };
 
  template<>
  inline xtd::time_span parse<time_span>(const std::string& str) {return time_span::parse(str);}
}