date_time.hpp

Go to the documentation of this file.

#pragma once
#include "chrono.hpp"
#include "date_time_kind.hpp"
#include "day_of_week.hpp"
#include "icomparable.hpp"
#include "iequatable.hpp"
#include "iformatable.hpp"
#include "month_of_year.hpp"
#include "object.hpp"
#include "ticks.hpp"
#include "time_span.hpp"
#include "string.hpp"
#include <ctime>
#if defined(__xtd__cpp_lib_format)
#include <format>
#endif

namespace xtd {
  class time_zone_info;
  
  
  class core_export_ date_time : public xtd::object, public xtd::icomparable<date_time>, public xtd::iequatable<date_time>, public xtd::iformatable {
  public:
    
    static const date_time max_value;
    static const date_time min_value;
    
    
    date_time() = default;
    explicit date_time(int64 ticks);
    explicit date_time(xtd::ticks ticks);
    date_time(int64 ticks, xtd::date_time_kind kind);
    date_time(xtd::ticks ticks, xtd::date_time_kind kind);
    date_time(uint32 year, uint32 month, uint32 day);
    date_time(uint32 year, uint32 month, uint32 day, uint32 hour, uint32 minute, uint32 second);
    date_time(uint32 year, uint32 month, uint32 day, uint32 hour, uint32 minute, uint32 second, date_time_kind kind);
    date_time(uint32 year, uint32 month, uint32 day, uint32 hour, uint32 minute, uint32 second, uint32 millisecond);
    date_time(uint32 year, uint32 month, uint32 day, uint32 hour, uint32 minute, uint32 second, uint32 millisecond, date_time_kind kind);

    template<class clock_t, class duration_t = clock_t::duration> // Can't be explicit by design.
    date_time(const std::chrono::time_point<clock_t, duration_t>& time_point) {
      using namespace std::chrono;
      *this = from_time_t(system_clock::to_time_t(system_clock::now() + duration_cast<system_clock::duration>(time_point - clock_t::now())), date_time_kind::local);
    }
    date_time(const std::chrono::time_point<clock_t, duration_t>& time_point) {…}

    template<class clock_t, class duration_t = clock_t::duration>
    date_time(const std::chrono::time_point<clock_t, duration_t>& time_point, date_time_kind kind) {
      using namespace std::chrono;
      *this = from_time_t(system_clock::to_time_t(system_clock::now() + duration_cast<system_clock::duration>(time_point - clock_t::now())), kind);
    }
    date_time(const std::chrono::time_point<clock_t, duration_t>& time_point, date_time_kind kind) {…}

    
    date_time(const date_time&) = default;
    date_time(date_time&&) = default;
    date_time& operator =(const date_time&) = default;
    
    
    
    date_time date() const noexcept;
    
    uint32 day() const noexcept;
    
    xtd::day_of_week day_of_week() const noexcept;
    
    uint32 day_of_year() const noexcept;
    
    uint32 hour() const noexcept;
    
    date_time_kind kind() const noexcept;
    
    uint32 millisecond() const noexcept;
    
    uint32 minute() const noexcept;
    
    uint32 month() const noexcept;
    
    uint32 second() const noexcept;

    int64 ticks() const noexcept;
    
    xtd::ticks ticks_duration() const noexcept;

    xtd::time_span time_of_day() const noexcept;
    
    uint32 year() const noexcept;
    
    
    date_time add(const xtd::time_span& value) const;
    
    date_time add_days(double value) const;
    
    date_time add_hours(double value) const;
    
    date_time add_milliseconds(double value) const;
    
    date_time add_minutes(double value) const;
    
    date_time add_months(int32 months) const;
    
    date_time add_seconds(double value) const;
    
    date_time add_ticks(int64 value) const;
    
    date_time add_years(int32 value) const;
    
    int32 compare_to(const date_time& value) const noexcept override;
    
    bool equals(const object& obj) const noexcept override;
    bool equals(const date_time& other) const noexcept override;

    xtd::size get_hash_code() const noexcept override;

    array<string> get_date_time_formats() const noexcept;
    
    bool is_daylight_saving_time() const noexcept;
    
    xtd::time_span subtract(const date_time& value) const;
    date_time subtract(const xtd::time_span& value) const;
    
    int64 to_binary() const;
    
    int64 to_file_time() const;

    int64 to_file_time_utc() const;
    
    date_time to_local_time() const;
    
    const xtd::string to_long_date_string() const;
    
    const xtd::string to_long_time_string() const;
    
    const xtd::string to_short_date_string() const;
    
    const xtd::string to_short_time_string() const;
    
    xtd::string to_string() const noexcept override;
    xtd::string to_string(const string& format) const;
    xtd::string to_string(const string& format, const std::locale& loc) const override;

    std::time_t to_time_t() const;
    
    std::tm to_tm() const;
    
    date_time to_universal_time() const;

    
    static date_time now() noexcept;
    
    static date_time today() noexcept;
    
    static date_time utc_now() noexcept;
    
    static int32 days_in_month(uint32 year, month_of_year month);
    
    static int32 days_in_month(uint32 year, uint32 month);
    
    static date_time from_binary(int64 date_data);
    
    static date_time from_file_time(int64 file_time);
    static date_time from_file_time_utc(int64 file_time);
    
    static date_time from_duration(const time_span& value);
    static date_time from_duration(const time_span& value, date_time_kind kind);
    
    static date_time from_time_t(std::time_t value);
    static date_time from_time_t(std::time_t value, date_time_kind kind);
    
    static date_time from_tm(const std::tm& value);
    static date_time from_tm(const std::tm& value, date_time_kind kind);
    
    static bool is_leap_year(uint32 year);
    
    static date_time parse(const xtd::string& s);
    
    static date_time specify_kind(const date_time& value, date_time_kind kind);
    
    static xtd::string sprintf(const string& format, const date_time& value);

    static bool try_parse(const string& s, date_time& result) noexcept;
    
    operator xtd::time_span() const;
    date_time operator +=(const date_time& value) = delete;
    date_time operator +=(const time_span& value);
    time_span operator -=(const date_time& value);
    time_span operator -=(const time_span& value);
    date_time operator +();
    date_time operator -();
    date_time operator +(const date_time& value) const = delete;
    date_time operator +(const time_span& value) const;
    time_span operator -(const date_time& value) const;
    date_time operator -(const time_span& value) const;
    date_time& operator ++();
    date_time operator ++(int32);
    date_time& operator --();
    date_time operator --(int32);
    
  private:
    friend class time_zone_info;
    xtd::ticks utc_offset() const;
    std::tuple<uint32, uint32, uint32, uint32, uint32, uint32, uint32, int32> get_date_time() const;
    void set_date_time(uint32 year, uint32 month, uint32 day, uint32 hour, uint32 minute, uint32 second, uint32 millisecond, date_time_kind kind);
    
    xtd::ticks value_ {0};
    date_time_kind kind_ {date_time_kind::unspecified};
  };
  class core_export_ date_time : public xtd::object, public xtd::icomparable<date_time>, public xtd::iequatable<date_time>, public xtd::iformatable {…};

}
 
/*
#if defined(__xtd__cpp_lib_format)
template <>
struct std::formatter<xtd::date_time> : std::formatter<std::string> {
  template<class format_context_t>
  constexpr auto parse(format_context_t& ctx) {
    auto iterator = ctx.begin();
    for (; iterator != ctx.end() && *iterator != '}'; ++iterator)
      format_value += *iterator;
    return iterator;
  }
  
  template<class object_t, class format_context_t>
  auto format(const object_t& obj, format_context_t& ctx) const {return std::format_to(ctx.out(), "{}", std::string {obj.to_string(format_value)});}
  
private:
  std::string format_value;
};
#endif
*/