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 {
  
  class time_span : public xtd::object, public 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 xtd::int64 nanoseconds_per_tick = 100ll;
    
    static constexpr xtd::int64 ticks_per_microsecond = 10ll;
    
    static constexpr xtd::int64 ticks_per_millisecond = ticks_per_microsecond * 1'000;
    
    static constexpr xtd::int64 ticks_per_second = ticks_per_millisecond * 1'000;
    
    static constexpr xtd::int64 ticks_per_minute = ticks_per_second * 60;
    
    static constexpr xtd::int64 ticks_per_hour = ticks_per_minute * 60;
    
    static constexpr xtd::int64 ticks_per_day = ticks_per_hour * 24;
    
    static const time_span zero;
    
    
    explicit time_span(xtd::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(xtd::int32 hours, xtd::int32 minutes, xtd::int32 seconds);
    time_span(xtd::int32 days, xtd::int32 hours, xtd::int32 minutes, xtd::int32 seconds);
    time_span(xtd::int32 days, xtd::int32 hours, xtd::int32 minutes, xtd::int32 seconds, xtd::int32 milliseconds);
    time_span(xtd::int32 days, xtd::int32 hours, xtd::int32 minutes, xtd::int32 seconds, xtd::int32 milliseconds, xtd::int32 microseconds);
    time_span(xtd::int32 days, xtd::int32 hours, xtd::int32 minutes, xtd::int32 seconds, xtd::int32 milliseconds, xtd::int32 microseconds, xtd::int32 nanoseconds);
    
    time_span();
    time_span(const time_span&) = default;
    time_span(time_span&&) = default;
    time_span(xtd::uint32 hours, xtd::uint32 minutes, xtd::uint32 seconds);
    time_span(xtd::uint32 days, xtd::uint32 hours, xtd::uint32 minutes, xtd::uint32 seconds);
    time_span(xtd::uint32 days, xtd::uint32 hours, xtd::uint32 minutes, xtd::uint32 seconds, xtd::uint32 milliseconds);
    time_span(xtd::uint32 days, xtd::uint32 hours, xtd::uint32 minutes, xtd::uint32 seconds, xtd::uint32 milliseconds, xtd::uint32 microseconds);
    time_span(xtd::uint32 days, xtd::uint32 hours, xtd::uint32 minutes, xtd::uint32 seconds, xtd::uint32 milliseconds, xtd::uint32 microseconds, xtd::uint32 nanoseconds);
    
    auto operator =(const time_span&) -> time_span& = default;
    auto operator +=(const time_span& value) -> time_span&;
    auto operator -=(const time_span& value) -> time_span&;
    auto operator +(const time_span& value) const -> time_span;
    auto operator -(const time_span& value) const -> time_span;
    auto operator *(const time_span& value) const -> double;
    auto operator *(double value) const -> time_span;
    auto operator /(const time_span& value) const -> double;
    auto operator /(double value) const -> time_span;
    auto operator +() const -> time_span;
    auto operator -() const -> time_span;
    auto operator ++() -> time_span&;
    auto operator ++(int) -> time_span;
    auto operator --() -> time_span&;
    auto operator --(int) -> time_span;
    friend auto operator << (std::ostream& os, const time_span& value) -> std::ostream& {return os << value.to_string();}
    
    
    [[nodiscard]] auto days() const noexcept -> xtd::int32;
    
    [[nodiscard]] auto hours() const noexcept -> xtd::int32;
    
    [[nodiscard]] auto microseconds() const noexcept -> xtd::int32;
    
    [[nodiscard]] auto milliseconds() const noexcept -> xtd::int32;
    
    [[nodiscard]] auto minutes() const noexcept -> xtd::int32;
    
    [[nodiscard]] auto nanoseconds() const noexcept -> xtd::int32;
    
    [[nodiscard]] auto seconds() const noexcept -> xtd::int32;
    
    [[nodiscard]] auto ticks() const noexcept -> xtd::int64;
    
    [[nodiscard]] auto ticks_duration() const noexcept -> xtd::ticks;
    
    [[nodiscard]] auto total_days() const noexcept -> double;
    
    [[nodiscard]] auto total_days_duration() const noexcept -> std::chrono::days;
    
    [[nodiscard]] auto total_hours() const noexcept -> double;
    
    [[nodiscard]] auto total_hours_duration() const noexcept -> std::chrono::hours;
    
    [[nodiscard]] auto total_microseconds() const noexcept -> double;
    
    [[nodiscard]] auto total_microseconds_duration() const noexcept -> std::chrono::microseconds;
    
    [[nodiscard]] auto total_milliseconds() const noexcept -> double;
    
    [[nodiscard]] auto total_milliseconds_duration() const noexcept -> std::chrono::milliseconds;
    
    [[nodiscard]] auto total_minutes() const noexcept -> double;
    
    [[nodiscard]] auto total_minutes_duration() const noexcept -> std::chrono::minutes;
    
    [[nodiscard]] auto total_nanoseconds() const noexcept -> double;
    
    [[nodiscard]] auto total_nanoseconds_duration() const noexcept -> std::chrono::nanoseconds;
    
    [[nodiscard]] auto total_seconds() const noexcept -> double;
    
    [[nodiscard]] auto total_seconds_duration() const noexcept -> std::chrono::seconds;
    
    
    
    [[nodiscard]] auto add(const time_span& ts) const noexcept -> time_span;
    
    [[nodiscard]] auto compare_to(const time_span& value) const noexcept -> xtd::int32 override;
    
    [[nodiscard]] auto divide(const time_span& ts) const -> double;
    [[nodiscard]] auto divide(double divisor) const -> time_span;
    
    [[nodiscard]] auto duration() const noexcept -> time_span;
    
    [[nodiscard]] auto equals(const object& value) const noexcept -> bool override;
    [[nodiscard]] auto equals(const time_span& value) const noexcept -> bool override;
    
    [[nodiscard]] auto get_hash_code() const noexcept -> xtd::usize override;
    
    [[nodiscard]] auto multiply(const time_span& ts) const noexcept -> double;
    [[nodiscard]] auto multiply(double factor) const noexcept -> time_span;
    
    [[nodiscard]] auto negate() const -> time_span;
    
    static auto parse(const string& value) -> time_span;
    
    [[nodiscard]] auto subtract(const time_span& ts) const noexcept -> time_span;
    
    [[nodiscard]] auto to_string() const noexcept -> xtd::string override;
    [[nodiscard]] auto to_string(const xtd::string& format) const -> xtd::string;
    
    [[nodiscard]] auto to_string(const xtd::string& format, const xtd::globalization::culture_info& culture) const -> xtd::string override;
    
    
    [[nodiscard]] static auto equals(time_span t1, time_span t2) -> bool;
    
    [[nodiscard]] static auto from_days(double value) -> time_span;
    [[nodiscard]] static auto from_days(std::chrono::days value) -> time_span;
    
    [[nodiscard]] static auto from_hours(double value) -> time_span;
    [[nodiscard]] static auto from_hours(std::chrono::hours value) -> time_span;
    
    [[nodiscard]] static auto from_microseconds(double value) -> time_span;
    [[nodiscard]] static auto from_microseconds(std::chrono::microseconds value) -> time_span;
    
    [[nodiscard]] static auto from_milliseconds(double value) -> time_span;
    [[nodiscard]] static auto from_milliseconds(std::chrono::milliseconds value) -> time_span;
    
    [[nodiscard]] static auto from_minutes(double value) -> time_span;
    [[nodiscard]] static auto from_minutes(std::chrono::minutes value) -> time_span;
    
    [[nodiscard]] static auto from_nanoseconds(double value) -> time_span;
    [[nodiscard]] static auto from_nanoseconds(std::chrono::nanoseconds value) -> time_span;
    
    [[nodiscard]] static auto from_seconds(double value) -> time_span;
    [[nodiscard]] static auto from_seconds(std::chrono::seconds value) -> time_span;
    
    [[nodiscard]] static auto from_ticks(int64 value) -> time_span;
    [[nodiscard]] static auto from_ticks(xtd::ticks value) -> time_span;
    
    [[nodiscard]] static auto try_parse(const string& value, time_span& result) -> bool;
    
  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;
    
    [[nodiscard]] static auto interval(double value, int scale) -> time_span;
    [[nodiscard]] auto make_string_from_duration(bool constant) const -> xtd::string;
    [[nodiscard]] static auto try_parse_internal(const string& value, time_span& result) -> xtd::int32;
    
    int64 ticks_ = 0;
  };

  
  template<>
  [[nodiscard]] inline auto parse<time_span>(const std::string& str) -> xtd::time_span {return time_span::parse(str);}
}
 
#include "literals/time_span.hpp"