js/src/builtin/temporal/ZonedDateTime.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set ts=8 sts=2 et sw=2 tw=80:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef builtin_temporal_ZonedDateTime_h
   8 #define builtin_temporal_ZonedDateTime_h
   9
  10 #include "mozilla/Assertions.h"
  11 #include "mozilla/Attributes.h"
  12
  13 #include <stdint.h>
  14
  15 #include "builtin/temporal/Calendar.h"
  16 #include "builtin/temporal/Instant.h"
  17 #include "builtin/temporal/TemporalTypes.h"
  18 #include "builtin/temporal/TimeZone.h"
  19 #include "js/RootingAPI.h"
  20 #include "js/TypeDecls.h"
  21 #include "js/Value.h"
  22 #include "vm/NativeObject.h"
  23
  24 class JS_PUBLIC_API JSTracer;
  25
  26 namespace js {
  27 struct ClassSpec;
  28 }
  29
  30 namespace js::temporal {
  31
  32 class ZonedDateTimeObject : public NativeObject {
  33  public:
  34   static const JSClass class_;
  35   static const JSClass& protoClass_;
  36
  37   static constexpr uint32_t SECONDS_SLOT = 0;
  38   static constexpr uint32_t NANOSECONDS_SLOT = 1;
  39   static constexpr uint32_t TIMEZONE_SLOT = 2;
  40   static constexpr uint32_t CALENDAR_SLOT = 3;
  41   static constexpr uint32_t SLOT_COUNT = 4;
  42
  43   int64_t seconds() const {
  44     double seconds = getFixedSlot(SECONDS_SLOT).toNumber();
  45     MOZ_ASSERT(-8'640'000'000'000 <= seconds && seconds <= 8'640'000'000'000);
  46     return int64_t(seconds);
  47   }
  48
  49   int32_t nanoseconds() const {
  50     int32_t nanoseconds = getFixedSlot(NANOSECONDS_SLOT).toInt32();
  51     MOZ_ASSERT(0 <= nanoseconds && nanoseconds <= 999'999'999);
  52     return nanoseconds;
  53   }
  54
  55   TimeZoneValue timeZone() const {
  56     return TimeZoneValue(getFixedSlot(TIMEZONE_SLOT));
  57   }
  58
  59   CalendarValue calendar() const {
  60     return CalendarValue(getFixedSlot(CALENDAR_SLOT));
  61   }
  62
  63  private:
  64   static const ClassSpec classSpec_;
  65 };
  66 /**
  67  * Extract the instant fields from the ZonedDateTime object.
  68  */
  69 inline Instant ToInstant(const ZonedDateTimeObject* zonedDateTime) {
  70   return {zonedDateTime->seconds(), zonedDateTime->nanoseconds()};
  71 }
  72
  73 class MOZ_STACK_CLASS ZonedDateTime final {
  74   Instant instant_;
  75   TimeZoneValue timeZone_;
  76   CalendarValue calendar_;
  77
  78  public:
  79   ZonedDateTime() = default;
  80
  81   ZonedDateTime(const Instant& instant, const TimeZoneValue& timeZone,
  82                 const CalendarValue& calendar)
  83       : instant_(instant), timeZone_(timeZone), calendar_(calendar) {
  84     MOZ_ASSERT(IsValidEpochInstant(instant));
  85     MOZ_ASSERT(timeZone);
  86     MOZ_ASSERT(calendar);
  87   }
  88
  89   explicit ZonedDateTime(const ZonedDateTimeObject* obj)
  90       : ZonedDateTime(ToInstant(obj), obj->timeZone(), obj->calendar()) {}
  91
  92   const auto& instant() const { return instant_; }
  93
  94   const auto& timeZone() const { return timeZone_; }
  95
  96   const auto& calendar() const { return calendar_; }
  97
  98   explicit operator bool() const { return !!timeZone_ && !!calendar_; }
  99
 100   void trace(JSTracer* trc) {
 101     timeZone_.trace(trc);
 102     calendar_.trace(trc);
 103   }
 104
 105   const auto* timeZoneDoNotUse() const { return &timeZone_; }
 106   const auto* calendarDoNotUse() const { return &calendar_; }
 107 };
 108
 109 enum class TemporalDisambiguation;
 110 enum class TemporalOffset;
 111 enum class TemporalOverflow;
 112 enum class TemporalUnit;
 113
 114 /**
 115  * CreateTemporalZonedDateTime ( epochNanoseconds, timeZone, calendar [ ,
 116  * newTarget ] )
 117  */
 118 ZonedDateTimeObject* CreateTemporalZonedDateTime(
 119     JSContext* cx, const Instant& instant, JS::Handle<TimeZoneValue> timeZone,
 120     JS::Handle<CalendarValue> calendar);
 121
 122 /**
 123  * AddDaysToZonedDateTime ( instant, dateTime, timeZoneRec, calendar, days [ ,
 124  * overflow ] )
 125  */
 126 bool AddDaysToZonedDateTime(JSContext* cx, const Instant& instant,
 127                             const PlainDateTime& dateTime,
 128                             JS::Handle<TimeZoneRecord> timeZone,
 129                             JS::Handle<CalendarValue> calendar, int64_t days,
 130                             TemporalOverflow overflow, Instant* result);
 131
 132 /**
 133  * AddDaysToZonedDateTime ( instant, dateTime, timeZoneRec, calendar, days [ ,
 134  * overflow ] )
 135  */
 136 bool AddDaysToZonedDateTime(JSContext* cx, const Instant& instant,
 137                             const PlainDateTime& dateTime,
 138                             JS::Handle<TimeZoneRecord> timeZone,
 139                             JS::Handle<CalendarValue> calendar, int64_t days,
 140                             Instant* result);
 141
 142 /**
 143  * AddZonedDateTime ( epochNanoseconds, timeZoneRec, calendarRec, years, months,
 144  * weeks, days, norm [ , precalculatedPlainDateTime [ , options ] ] )
 145  */
 146 bool AddZonedDateTime(JSContext* cx, const Instant& epochNanoseconds,
 147                       JS::Handle<TimeZoneRecord> timeZone,
 148                       JS::Handle<CalendarRecord> calendar,
 149                       const NormalizedDuration& duration, Instant* result);
 150
 151 /**
 152  * AddZonedDateTime ( epochNanoseconds, timeZoneRec, calendarRec, years, months,
 153  * weeks, days, norm [ , precalculatedPlainDateTime [ , options ] ] )
 154  */
 155 bool AddZonedDateTime(JSContext* cx, const Instant& epochNanoseconds,
 156                       JS::Handle<TimeZoneRecord> timeZone,
 157                       JS::Handle<CalendarRecord> calendar,
 158                       const NormalizedDuration& duration,
 159                       const PlainDateTime& dateTime, Instant* result);
 160
 161 /**
 162  * AddZonedDateTime ( epochNanoseconds, timeZoneRec, calendarRec, years, months,
 163  * weeks, days, norm [ , precalculatedPlainDateTime [ , options ] ] )
 164  */
 165 bool AddZonedDateTime(JSContext* cx, const Instant& epochNanoseconds,
 166                       JS::Handle<TimeZoneRecord> timeZone,
 167                       JS::Handle<CalendarRecord> calendar,
 168                       const DateDuration& duration, Instant* result);
 169
 170 /**
 171  * AddZonedDateTime ( epochNanoseconds, timeZoneRec, calendarRec, years, months,
 172  * weeks, days, norm [ , precalculatedPlainDateTime [ , options ] ] )
 173  */
 174 bool AddZonedDateTime(JSContext* cx, const Instant& epochNanoseconds,
 175                       JS::Handle<TimeZoneRecord> timeZone,
 176                       JS::Handle<CalendarRecord> calendar,
 177                       const DateDuration& duration,
 178                       const PlainDateTime& dateTime, Instant* result);
 179
 180 /**
 181  * DifferenceZonedDateTime ( ns1, ns2, timeZoneRec, calendarRec, largestUnit,
 182  * options, precalculatedPlainDateTime )
 183  */
 184 bool DifferenceZonedDateTime(JSContext* cx, const Instant& ns1,
 185                              const Instant& ns2,
 186                              JS::Handle<TimeZoneRecord> timeZone,
 187                              JS::Handle<CalendarRecord> calendar,
 188                              TemporalUnit largestUnit,
 189                              const PlainDateTime& precalculatedPlainDateTime,
 190                              NormalizedDuration* result);
 191
 192 struct NormalizedTimeAndDays final {
 193   int64_t days = 0;
 194   int64_t time = 0;
 195   int64_t dayLength = 0;
 196 };
 197
 198 /**
 199  * NormalizedTimeDurationToDays ( norm, zonedRelativeTo, timeZoneRec [ ,
 200  * precalculatedPlainDateTime ] )
 201  */
 202 bool NormalizedTimeDurationToDays(JSContext* cx,
 203                                   const NormalizedTimeDuration& duration,
 204                                   JS::Handle<ZonedDateTime> zonedRelativeTo,
 205                                   JS::Handle<TimeZoneRecord> timeZone,
 206                                   NormalizedTimeAndDays* result);
 207
 208 /**
 209  * NormalizedTimeDurationToDays ( norm, zonedRelativeTo, timeZoneRec [ ,
 210  * precalculatedPlainDateTime ] )
 211  */
 212 bool NormalizedTimeDurationToDays(
 213     JSContext* cx, const NormalizedTimeDuration& duration,
 214     JS::Handle<ZonedDateTime> zonedRelativeTo,
 215     JS::Handle<TimeZoneRecord> timeZone,
 216     const PlainDateTime& precalculatedPlainDateTime,
 217     NormalizedTimeAndDays* result);
 218
 219 enum class OffsetBehaviour { Option, Exact, Wall };
 220
 221 enum class MatchBehaviour { MatchExactly, MatchMinutes };
 222
 223 /**
 224  * InterpretISODateTimeOffset ( year, month, day, hour, minute, second,
 225  * millisecond, microsecond, nanosecond, offsetBehaviour, offsetNanoseconds,
 226  * timeZoneRec, disambiguation, offsetOption, matchBehaviour )
 227  */
 228 bool InterpretISODateTimeOffset(JSContext* cx, const PlainDateTime& dateTime,
 229                                 OffsetBehaviour offsetBehaviour,
 230                                 int64_t offsetNanoseconds,
 231                                 JS::Handle<TimeZoneRecord> timeZone,
 232                                 TemporalDisambiguation disambiguation,
 233                                 TemporalOffset offsetOption,
 234                                 MatchBehaviour matchBehaviour, Instant* result);
 235
 236 } /* namespace js::temporal */
 237
 238 namespace js {
 239
 240 template <typename Wrapper>
 241 class WrappedPtrOperations<temporal::ZonedDateTime, Wrapper> {
 242   const auto& container() const {
 243     return static_cast<const Wrapper*>(this)->get();
 244   }
 245
 246  public:
 247   explicit operator bool() const { return bool(container()); }
 248
 249   const auto& instant() const { return container().instant(); }
 250
 251   JS::Handle<temporal::TimeZoneValue> timeZone() const {
 252     return JS::Handle<temporal::TimeZoneValue>::fromMarkedLocation(
 253         container().timeZoneDoNotUse());
 254   }
 255
 256   JS::Handle<temporal::CalendarValue> calendar() const {
 257     return JS::Handle<temporal::CalendarValue>::fromMarkedLocation(
 258         container().calendarDoNotUse());
 259   }
 260 };
 261
 262 } /* namespace js */
 263
 264 #endif /* builtin_temporal_ZonedDateTime_h */