timezone_info.h

 
#pragma once
#include <system/object.h>
#include <system/date_time.h>
#include <system/date_time_offset.h>
#include <system/timespan.h>
#include <system/iequatable.h>
#include <system/collections/read_only_collection.h>
#include <system/default.h>
#include <system/details/icu_namespace.h>
#include <system/details/lazy.h>
 
ASPOSECPP_3RD_PARTY_ICU_NAMESPACE_START{
    ASPOSECPP_3RD_PARTY_CLASS(BasicTimeZone);
}
 
namespace System {
 
class TimeZoneInfo;
typedef SharedPtr<TimeZoneInfo> TimeZoneInfoPtr;
 
class ASPOSECPP_SHARED_CLASS TimeZoneInfo final
    : public IEquatable<TimeZoneInfoPtr>
{
    RTTI_INFO(System::TimeZoneInfo, ::System::BaseTypesInfo<System::Object>)
 
public:
    class ASPOSECPP_SHARED_CLASS TransitionTime final
    {
    public:
        TransitionTime();
 
        DateTime get_TimeOfDay() const
        {
            return m_time_of_day;
        }
 
        int get_Month() const
        {
            return static_cast<int>(m_month);
        }
 
        int get_Week() const
        {
            return static_cast<int>(m_week);
        }
 
        int get_Day() const
        {
            return static_cast<int>(m_day);
        }
 
        DayOfWeek get_DayOfWeek() const
        {
            return static_cast<DayOfWeek>(m_day_of_week);
        }
 
        bool get_IsFixedDateRule() const
        {
            return m_is_fixed_date_rule;
        }
 
        static TransitionTime CreateFixedDateRule(DateTime time_of_day, int month, int day)
        {
            return TransitionTime(time_of_day, month, 1, day, DayOfWeek::Sunday, true);
        }
 
        static TransitionTime CreateFloatingDateRule(DateTime time_of_day, int month, int week, DayOfWeek day_of_week)
        {
            return TransitionTime(time_of_day, month, week, 1, day_of_week, false);
        }
 
        static TransitionTime CreateTransitionTime(DateTime time_of_day, int month, int week, int day, DayOfWeek day_of_week, bool is_fixed_date_rule)
        {
            return TransitionTime(time_of_day, month, week, day, day_of_week, is_fixed_date_rule);
        }
 
        bool operator==(const TransitionTime& other) const
        {
            return m_is_fixed_date_rule == other.m_is_fixed_date_rule
                && m_time_of_day == other.m_time_of_day
                && m_month == other.m_month
                && (m_is_fixed_date_rule
                    ? m_day == other.m_day
                    : m_week == other.m_week && m_day_of_week == other.m_day_of_week);
        }
 
        bool operator!=(const TransitionTime& other) const
        {
            return !operator==(other);
        }
 
    private:
        DateTime m_time_of_day;
        uint8_t m_month;
        uint8_t m_week;
        uint8_t m_day;
        uint8_t m_day_of_week;
        bool m_is_fixed_date_rule;
 
        ASPOSECPP_SHARED_API TransitionTime(DateTime time_of_day, int month, int week, int day, DayOfWeek day_of_week, bool is_fixed_date_rule);
 
        static void VerifyTransitionTime(DateTime time_of_day, int month, int week, int day, DayOfWeek day_of_week);
    };
 
    class AdjustmentRule;
    typedef SharedPtr<AdjustmentRule> AdjustmentRulePtr;
 
    class ASPOSECPP_SHARED_CLASS AdjustmentRule final 
        : public IEquatable<AdjustmentRulePtr>
    {
    public:
        DateTime get_DateStart() const
        {
            return m_date_start;
        }
        DateTime get_DateEnd() const
        {
            return m_date_end;
        }
        TimeSpan get_DaylightDelta() const
        {
            return m_daylight_delta;
        }
        TransitionTime get_DaylightTransitionStart() const
        {
            return m_daylight_transition_start;
        }
        TransitionTime get_DaylightTransitionEnd() const
        {
            return m_daylight_transition_end;
        }
 
        TimeSpan get_BaseUtcOffsetDelta() const
        {
            return m_base_utc_offset_delta;
        }
 
        bool get_HasDaylightSaving() const;
 
        static ASPOSECPP_SHARED_API AdjustmentRulePtr CreateAdjustmentRule(
            DateTime date_start,
            DateTime date_end,
            TimeSpan daylight_delta,
            const TransitionTime& daylight_transition_start,
            const TransitionTime& daylight_transition_end);
 
        static ASPOSECPP_SHARED_API AdjustmentRulePtr CreateAdjustmentRule(
            DateTime date_start,
            DateTime date_end,
            TimeSpan daylight_delta,
            const TransitionTime& daylight_transition_start,
            const TransitionTime& daylight_transition_end,
            TimeSpan base_utc_offset_delta,
            bool no_daylight_transitions);
 
        ASPOSECPP_SHARED_API bool Equals(AdjustmentRulePtr other) override;
        ASPOSECPP_SHARED_API int GetHashCode() const override;
 
    private:
        DateTime m_date_start;
        DateTime m_date_end;
        TimeSpan m_daylight_delta;
        TransitionTime m_daylight_transition_start;
        TransitionTime m_daylight_transition_end;
        TimeSpan m_base_utc_offset_delta;
        bool m_no_daylight_transitions;
 
        ASPOSECPP_SHARED_API AdjustmentRule(DateTime date_start, DateTime date_end, TimeSpan daylight_delta,
            const TransitionTime& daylight_transition_start, const TransitionTime& daylight_transition_end,
            TimeSpan base_utc_offset_delta, bool no_daylight_transitions);
        MEMBER_FUNCTION_MAKE_OBJECT(
            AdjustmentRule,
            CODEPORTING_ARGS(
                const DateTime& date_start,
                const DateTime& date_end,
                const TimeSpan& daylight_delta,
                const TransitionTime& daylight_transition_start,
                const TransitionTime& daylight_transition_end,
                const TimeSpan& base_utc_offset_delta,
                bool no_daylight_transitions
            ),
            CODEPORTING_ARGS(
                date_start,
                date_end,
                daylight_delta,
                daylight_transition_start,
                daylight_transition_end,
                base_utc_offset_delta,
                no_daylight_transitions
            )
        );
 
        static void VerifyAdjustmentRule(DateTime date_start, DateTime date_end, TimeSpan daylight_delta,
            const TransitionTime& daylight_transition_start, const TransitionTime& daylight_transition_end, bool no_daylight_transitions);
    };
 
    static ASPOSECPP_SHARED_API TimeZoneInfoPtr get_Utc();
    static ASPOSECPP_SHARED_API TimeZoneInfoPtr get_Local();
 
    ASPOSECPP_SHARED_API bool get_SupportsDaylightSavingTime() const;
    ASPOSECPP_SHARED_API TimeSpan get_BaseUtcOffset() const;
    ASPOSECPP_SHARED_API String get_DaylightName() const;
    ASPOSECPP_SHARED_API String get_StandardName() const;
    ASPOSECPP_SHARED_API String get_DisplayName() const;
    ASPOSECPP_SHARED_API String get_Id() const;
 
    static ASPOSECPP_SHARED_API void ClearCachedData();
    static ASPOSECPP_SHARED_API DateTime ConvertTime(DateTime date_time, const TimeZoneInfoPtr& source_time_zone, const TimeZoneInfoPtr& destination_time_zone);
    static ASPOSECPP_SHARED_API DateTimeOffset ConvertTime(const DateTimeOffset& date_time_offset, const TimeZoneInfoPtr& destination_time_zone);
    static ASPOSECPP_SHARED_API DateTime ConvertTime(DateTime date_time, const TimeZoneInfoPtr& destination_time_zone);
    static ASPOSECPP_SHARED_API DateTime ConvertTimeBySystemTimeZoneId(DateTime date_time, const String& destination_time_zone_id);
    static ASPOSECPP_SHARED_API DateTimeOffset ConvertTimeBySystemTimeZoneId(const DateTimeOffset& date_time_offset, const String& destination_time_zone_id);
    static ASPOSECPP_SHARED_API DateTime ConvertTimeBySystemTimeZoneId(DateTime date_time, const String& source_time_zone_id, const String& destination_time_zone_id);
    static ASPOSECPP_SHARED_API DateTime ConvertTimeFromUtc(DateTime date_time, const TimeZoneInfoPtr& destination_time_zone);
    static ASPOSECPP_SHARED_API DateTime ConvertTimeToUtc(DateTime date_time, const TimeZoneInfoPtr& source_time_zone);
    static ASPOSECPP_SHARED_API DateTime ConvertTimeToUtc(DateTime date_time);
    static DateTime ConvertTimeToUtcNoThrow(DateTime date_time);
    static ASPOSECPP_SHARED_API TimeZoneInfoPtr CreateCustomTimeZone(const String& id, TimeSpan base_utc_offset, const String& display_name, const String& standard_display_name, const String& daylight_display_name, const ArrayPtr<AdjustmentRulePtr>& adjustment_rules, bool disable_daylight_saving_time);
    static ASPOSECPP_SHARED_API TimeZoneInfoPtr CreateCustomTimeZone(const String& id, TimeSpan base_utc_offset, const String& display_name, const String& standard_display_name, const String& daylight_display_name, const ArrayPtr<AdjustmentRulePtr>& adjustment_rules);
    static ASPOSECPP_SHARED_API TimeZoneInfoPtr CreateCustomTimeZone(const String& id, TimeSpan base_utc_offset, const String& display_name, const String& standard_display_name);
    static ASPOSECPP_SHARED_API TimeZoneInfoPtr FindSystemTimeZoneById(const String& id);
    static ASPOSECPP_SHARED_API SharedPtr<System::Collections::ObjectModel::ReadOnlyCollection<TimeZoneInfoPtr>> GetSystemTimeZones();
 
    ASPOSECPP_SHARED_API ArrayPtr<AdjustmentRulePtr> GetAdjustmentRules() const;
    ASPOSECPP_SHARED_API ArrayPtr<TimeSpan> GetAmbiguousTimeOffsets(DateTime date_time) const;
    ASPOSECPP_SHARED_API ArrayPtr<TimeSpan> GetAmbiguousTimeOffsets(const DateTimeOffset& date_time_offset) const;
    ASPOSECPP_SHARED_API TimeSpan GetUtcOffset(DateTime date_time) const;
    TimeSpan GetUtcOffsetNoThrow(DateTime date_time) const;
    ASPOSECPP_SHARED_API TimeSpan GetUtcOffset(const DateTimeOffset& date_time_offset) const;
    ASPOSECPP_SHARED_API bool HasSameRules(const TimeZoneInfoPtr& other) const;
    ASPOSECPP_SHARED_API bool IsAmbiguousTime(DateTime date_time) const;
    ASPOSECPP_SHARED_API bool IsAmbiguousTime(const DateTimeOffset& date_time_offset) const;
    ASPOSECPP_SHARED_API bool IsDaylightSavingTime(DateTime date_time) const;
    ASPOSECPP_SHARED_API bool IsDaylightSavingTimeNoThrow(DateTime date_time) const;
    ASPOSECPP_SHARED_API bool IsDaylightSavingTime(const DateTimeOffset& date_time_offset) const;
    ASPOSECPP_SHARED_API bool IsInvalidTime(DateTime date_time) const;
 
    ASPOSECPP_SHARED_API bool Equals(SharedPtr<Object> obj) override;
    ASPOSECPP_SHARED_API bool Equals(TimeZoneInfoPtr other) override;
    ASPOSECPP_SHARED_API int GetHashCode() const override;
    ASPOSECPP_SHARED_API String ToString() const override;
 
    static TimeSpan GetUtcOffsetFromUtc(DateTime time, const TimeZoneInfoPtr& zone);
 
    static TimeSpan GetUtcOffsetFromUtc(DateTime time, const TimeZoneInfoPtr& zone, bool& is_daylight_savings, bool& is_ambiguous_local_dst);
 
    static ASPOSECPP_SHARED_API DateTime TransitionTimeToDateTime(int32_t year, const TransitionTime& transitionTime);
 
protected:
    ASPOSECPP_SHARED_API ~TimeZoneInfo() override;
    const String m_id;
    const String m_display_name;
    const String m_standard_display_name;
    const String m_daylight_display_name;
    const TimeSpan m_base_utc_offset;
    const bool m_supports_daylight_saving_time;
    mutable System::Details::Lazy<ArrayPtr<AdjustmentRulePtr>> m_adjustment_rules;
    const std::unique_ptr<const codeporting_icu::BasicTimeZone> m_icu_time_zone;
    const DateTimeKind m_time_zone_kind;
 
    TimeZoneInfo(
        const String& id,
        TimeSpan base_utc_offset,
        const String& display_name,
        const String& standard_display_name,
        const String& daylight_display_name,
        const ArrayPtr<AdjustmentRulePtr>& adjustment_rules,
        bool disable_daylight_saving_time,
        std::unique_ptr<const codeporting_icu::BasicTimeZone>&& icu_time_zone,
        DateTimeKind time_zone_kind = DateTimeKind::Unspecified);
    MEMBER_FUNCTION_MAKE_OBJECT(
        TimeZoneInfo,
        CODEPORTING_ARGS(
            const String& id,
            const TimeSpan& base_utc_offset,
            const String& display_name,
            const String& standard_display_name,
            const String& daylight_display_name,
            const ArrayPtr<AdjustmentRulePtr>& adjustment_rules,
            bool disable_daylight_saving_time,
            std::unique_ptr<const codeporting_icu::BasicTimeZone>&& icu_time_zone,
            DateTimeKind time_zone_kind = DateTimeKind::Unspecified
        ),
        CODEPORTING_ARGS(
            id,
            base_utc_offset,
            display_name,
            standard_display_name,
            daylight_display_name,
            adjustment_rules,
            disable_daylight_saving_time,
            std::forward<std::unique_ptr<const codeporting_icu::BasicTimeZone>&&>(icu_time_zone),
            time_zone_kind
        )
    );
 
    static DateTime ConvertTime(DateTime date_time, const TimeZoneInfoPtr& source_time_zone, const TimeZoneInfoPtr& destination_time_zone, bool throw_on_invalid_time);
 
    static void VerifyTimeZoneInfo(const String& id, TimeSpan base_utc_offset, const ArrayPtr<AdjustmentRulePtr>& adjustment_rules);
 
    const ArrayPtr<AdjustmentRulePtr>& AdjustmentRules() const;
 
    static TimeZoneInfoPtr CreateTimeZoneInfoFromIcuTimeZone(std::unique_ptr<const codeporting_icu::BasicTimeZone>&& time_zone, DateTimeKind time_zone_kind = DateTimeKind::Unspecified);
};
 
} // namespace System