js/src/builtin/temporal/PlainDateTime.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_PlainDateTime_h
   8 #define builtin_temporal_PlainDateTime_h
   9
  10 #include "mozilla/Assertions.h"
  11
  12 #include <stdint.h>
  13
  14 #include "builtin/temporal/Calendar.h"
  15 #include "builtin/temporal/TemporalTypes.h"
  16 #include "builtin/temporal/Wrapped.h"
  17 #include "js/RootingAPI.h"
  18 #include "js/TypeDecls.h"
  19 #include "js/Value.h"
  20 #include "vm/NativeObject.h"
  21
  22 class JS_PUBLIC_API JSTracer;
  23
  24 namespace js {
  25 struct ClassSpec;
  26 class PlainObject;
  27 }  // namespace js
  28
  29 namespace js::temporal {
  30
  31 class PlainDateTimeObject : public NativeObject {
  32  public:
  33   static const JSClass class_;
  34   static const JSClass& protoClass_;
  35
  36   // TODO: Consider compacting fields to reduce object size.
  37   //
  38   // See also PlainDateObject and PlainTimeObject.
  39
  40   static constexpr uint32_t ISO_YEAR_SLOT = 0;
  41   static constexpr uint32_t ISO_MONTH_SLOT = 1;
  42   static constexpr uint32_t ISO_DAY_SLOT = 2;
  43   static constexpr uint32_t ISO_HOUR_SLOT = 3;
  44   static constexpr uint32_t ISO_MINUTE_SLOT = 4;
  45   static constexpr uint32_t ISO_SECOND_SLOT = 5;
  46   static constexpr uint32_t ISO_MILLISECOND_SLOT = 6;
  47   static constexpr uint32_t ISO_MICROSECOND_SLOT = 7;
  48   static constexpr uint32_t ISO_NANOSECOND_SLOT = 8;
  49   static constexpr uint32_t CALENDAR_SLOT = 9;
  50   static constexpr uint32_t SLOT_COUNT = 10;
  51
  52   int32_t isoYear() const { return getFixedSlot(ISO_YEAR_SLOT).toInt32(); }
  53
  54   int32_t isoMonth() const { return getFixedSlot(ISO_MONTH_SLOT).toInt32(); }
  55
  56   int32_t isoDay() const { return getFixedSlot(ISO_DAY_SLOT).toInt32(); }
  57
  58   int32_t isoHour() const { return getFixedSlot(ISO_HOUR_SLOT).toInt32(); }
  59
  60   int32_t isoMinute() const { return getFixedSlot(ISO_MINUTE_SLOT).toInt32(); }
  61
  62   int32_t isoSecond() const { return getFixedSlot(ISO_SECOND_SLOT).toInt32(); }
  63
  64   int32_t isoMillisecond() const {
  65     return getFixedSlot(ISO_MILLISECOND_SLOT).toInt32();
  66   }
  67
  68   int32_t isoMicrosecond() const {
  69     return getFixedSlot(ISO_MICROSECOND_SLOT).toInt32();
  70   }
  71
  72   int32_t isoNanosecond() const {
  73     return getFixedSlot(ISO_NANOSECOND_SLOT).toInt32();
  74   }
  75
  76   CalendarValue calendar() const {
  77     return CalendarValue(getFixedSlot(CALENDAR_SLOT));
  78   }
  79
  80  private:
  81   static const ClassSpec classSpec_;
  82 };
  83
  84 /**
  85  * Extract the date fields from the PlainDateTime object.
  86  */
  87 inline PlainDate ToPlainDate(const PlainDateTimeObject* dateTime) {
  88   return {dateTime->isoYear(), dateTime->isoMonth(), dateTime->isoDay()};
  89 }
  90
  91 /**
  92  * Extract the time fields from the PlainDateTime object.
  93  */
  94 inline PlainTime ToPlainTime(const PlainDateTimeObject* dateTime) {
  95   return {dateTime->isoHour(),        dateTime->isoMinute(),
  96           dateTime->isoSecond(),      dateTime->isoMillisecond(),
  97           dateTime->isoMicrosecond(), dateTime->isoNanosecond()};
  98 }
  99
 100 /**
 101  * Extract the date-time fields from the PlainDateTime object.
 102  */
 103 inline PlainDateTime ToPlainDateTime(const PlainDateTimeObject* dateTime) {
 104   return {ToPlainDate(dateTime), ToPlainTime(dateTime)};
 105 }
 106
 107 enum class TemporalUnit;
 108
 109 #ifdef DEBUG
 110 /**
 111  * IsValidISODateTime ( year, month, day, hour, minute, second, millisecond,
 112  * microsecond, nanosecond )
 113  */
 114 bool IsValidISODateTime(const PlainDateTime& dateTime);
 115 #endif
 116
 117 /**
 118  * ISODateTimeWithinLimits ( year, month, day, hour, minute, second,
 119  * millisecond, microsecond, nanosecond )
 120  */
 121 bool ISODateTimeWithinLimits(const PlainDateTime& dateTime);
 122
 123 /**
 124  * ISODateTimeWithinLimits ( year, month, day, hour, minute, second,
 125  * millisecond, microsecond, nanosecond )
 126  */
 127 bool ISODateTimeWithinLimits(const PlainDate& date);
 128
 129 /**
 130  * ISODateTimeWithinLimits ( year, month, day, hour, minute, second,
 131  * millisecond, microsecond, nanosecond )
 132  */
 133 bool ISODateTimeWithinLimits(double year, double month, double day);
 134
 135 /**
 136  * CreateTemporalDateTime ( isoYear, isoMonth, isoDay, hour, minute, second,
 137  * millisecond, microsecond, nanosecond, calendar [ , newTarget ] )
 138  */
 139 PlainDateTimeObject* CreateTemporalDateTime(JSContext* cx,
 140                                             const PlainDateTime& dateTime,
 141                                             JS::Handle<CalendarValue> calendar);
 142
 143 /**
 144  * ToTemporalDateTime ( item [ , options ] )
 145  */
 146 Wrapped<PlainDateTimeObject*> ToTemporalDateTime(JSContext* cx,
 147                                                  JS::Handle<JS::Value> item);
 148
 149 /**
 150  * ToTemporalDateTime ( item [ , options ] )
 151  */
 152 bool ToTemporalDateTime(JSContext* cx, JS::Handle<JS::Value> item,
 153                         PlainDateTime* result);
 154
 155 /**
 156  * InterpretTemporalDateTimeFields ( calendarRec, fields, options )
 157  */
 158 bool InterpretTemporalDateTimeFields(JSContext* cx,
 159                                      JS::Handle<CalendarRecord> calendar,
 160                                      JS::Handle<PlainObject*> fields,
 161                                      JS::Handle<PlainObject*> options,
 162                                      PlainDateTime* result);
 163
 164 /**
 165  * InterpretTemporalDateTimeFields ( calendarRec, fields, options )
 166  */
 167 bool InterpretTemporalDateTimeFields(JSContext* cx,
 168                                      JS::Handle<CalendarRecord> calendar,
 169                                      JS::Handle<PlainObject*> fields,
 170                                      PlainDateTime* result);
 171
 172 /**
 173  * DifferenceISODateTime ( y1, mon1, d1, h1, min1, s1, ms1, mus1, ns1, y2, mon2,
 174  * d2, h2, min2, s2, ms2, mus2, ns2, calendarRec, largestUnit, options )
 175  */
 176 bool DifferenceISODateTime(JSContext* cx, const PlainDateTime& one,
 177                            const PlainDateTime& two,
 178                            JS::Handle<CalendarRecord> calendar,
 179                            TemporalUnit largestUnit,
 180                            NormalizedDuration* result);
 181
 182 /**
 183  * DifferenceISODateTime ( y1, mon1, d1, h1, min1, s1, ms1, mus1, ns1, y2, mon2,
 184  * d2, h2, min2, s2, ms2, mus2, ns2, calendarRec, largestUnit, options )
 185  */
 186 bool DifferenceISODateTime(JSContext* cx, const PlainDateTime& one,
 187                            const PlainDateTime& two,
 188                            JS::Handle<CalendarRecord> calendar,
 189                            TemporalUnit largestUnit,
 190                            JS::Handle<PlainObject*> options,
 191                            NormalizedDuration* result);
 192
 193 class PlainDateTimeWithCalendar {
 194   PlainDateTime dateTime_;
 195   CalendarValue calendar_;
 196
 197  public:
 198   PlainDateTimeWithCalendar() = default;
 199
 200   PlainDateTimeWithCalendar(const PlainDateTime& dateTime,
 201                             const CalendarValue& calendar)
 202       : dateTime_(dateTime), calendar_(calendar) {
 203     MOZ_ASSERT(ISODateTimeWithinLimits(dateTime));
 204   }
 205
 206   explicit PlainDateTimeWithCalendar(const PlainDateTimeObject* dateTime)
 207       : PlainDateTimeWithCalendar(ToPlainDateTime(dateTime),
 208                                   dateTime->calendar()) {}
 209
 210   const auto& dateTime() const { return dateTime_; }
 211   const auto& date() const { return dateTime_.date; }
 212   const auto& time() const { return dateTime_.time; }
 213   const auto& calendar() const { return calendar_; }
 214
 215   // Allow implicit conversion to a calendar-less PlainDateTime.
 216   operator const PlainDateTime&() const { return dateTime(); }
 217
 218   void trace(JSTracer* trc) { calendar_.trace(trc); }
 219
 220   const auto* calendarDoNotUse() const { return &calendar_; }
 221 };
 222
 223 /**
 224  * Extract the date-time fields from the PlainDateTimeWithCalendar object.
 225  */
 226 inline const auto& ToPlainDateTime(const PlainDateTimeWithCalendar& dateTime) {
 227   return dateTime.dateTime();
 228 }
 229
 230 /**
 231  * CreateTemporalDateTime ( isoYear, isoMonth, isoDay, hour, minute, second,
 232  * millisecond, microsecond, nanosecond, calendar [ , newTarget ] )
 233  */
 234 bool CreateTemporalDateTime(
 235     JSContext* cx, const PlainDateTime& dateTime,
 236     JS::Handle<CalendarValue> calendar,
 237     JS::MutableHandle<PlainDateTimeWithCalendar> result);
 238
 239 } /* namespace js::temporal */
 240
 241 namespace js {
 242
 243 template <typename Wrapper>
 244 class WrappedPtrOperations<temporal::PlainDateTimeWithCalendar, Wrapper> {
 245   const auto& container() const {
 246     return static_cast<const Wrapper*>(this)->get();
 247   }
 248
 249  public:
 250   const auto& dateTime() const { return container().dateTime(); }
 251   const auto& date() const { return container().date(); }
 252   const auto& time() const { return container().time(); }
 253
 254   auto calendar() const {
 255     return JS::Handle<temporal::CalendarValue>::fromMarkedLocation(
 256         container().calendarDoNotUse());
 257   }
 258
 259   // Allow implicit conversion to a calendar-less PlainDateTime.
 260   operator const temporal::PlainDateTime&() const { return dateTime(); }
 261 };
 262
 263 }  // namespace js
 264
 265 #endif /* builtin_temporal_PlainDateTime_h */