js/src/builtin/temporal/PlainDate.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_PlainDate_h
   8 #define builtin_temporal_PlainDate_h
   9
  10 #include "mozilla/Assertions.h"
  11
  12 #include <initializer_list>
  13 #include <stdint.h>
  14
  15 #include "builtin/temporal/Calendar.h"
  16 #include "builtin/temporal/PlainDateTime.h"
  17 #include "builtin/temporal/TemporalTypes.h"
  18 #include "builtin/temporal/Wrapped.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 class PlainObject;
  29 }  // namespace js
  30
  31 namespace js::temporal {
  32
  33 class PlainDateObject : public NativeObject {
  34  public:
  35   static const JSClass class_;
  36   static const JSClass& protoClass_;
  37
  38   // TODO: Consider compacting fields to reduce object size.
  39   //
  40   // ceil(log2(271821)) + ceil(log2(12)) + ceil(log2(31)) = 28 bits are
  41   // needed to store a date value in a single int32.
  42
  43   static constexpr uint32_t ISO_YEAR_SLOT = 0;
  44   static constexpr uint32_t ISO_MONTH_SLOT = 1;
  45   static constexpr uint32_t ISO_DAY_SLOT = 2;
  46   static constexpr uint32_t CALENDAR_SLOT = 3;
  47   static constexpr uint32_t SLOT_COUNT = 4;
  48
  49   int32_t isoYear() const { return getFixedSlot(ISO_YEAR_SLOT).toInt32(); }
  50
  51   int32_t isoMonth() const { return getFixedSlot(ISO_MONTH_SLOT).toInt32(); }
  52
  53   int32_t isoDay() const { return getFixedSlot(ISO_DAY_SLOT).toInt32(); }
  54
  55   CalendarValue calendar() const {
  56     return CalendarValue(getFixedSlot(CALENDAR_SLOT));
  57   }
  58
  59  private:
  60   static const ClassSpec classSpec_;
  61 };
  62
  63 class PlainDateWithCalendar {
  64   PlainDate date_;
  65   CalendarValue calendar_;
  66
  67  public:
  68   PlainDateWithCalendar() = default;
  69
  70   PlainDateWithCalendar(const PlainDate& date, const CalendarValue& calendar)
  71       : date_(date), calendar_(calendar) {
  72     MOZ_ASSERT(ISODateTimeWithinLimits(date));
  73   }
  74
  75   const auto& date() const { return date_; }
  76   const auto& calendar() const { return calendar_; }
  77
  78   // Allow implicit conversion to a calendar-less PlainDate.
  79   operator const PlainDate&() const { return date(); }
  80
  81   void trace(JSTracer* trc) { calendar_.trace(trc); }
  82
  83   const auto* calendarDoNotUse() const { return &calendar_; }
  84 };
  85
  86 /**
  87  * Extract the date fields from the PlainDate object.
  88  */
  89 inline PlainDate ToPlainDate(const PlainDateObject* date) {
  90   return {date->isoYear(), date->isoMonth(), date->isoDay()};
  91 }
  92
  93 enum class TemporalOverflow;
  94 enum class TemporalUnit;
  95 class DurationObject;
  96 class ZonedDateTimeObject;
  97
  98 #ifdef DEBUG
  99 /**
 100  * IsValidISODate ( year, month, day )
 101  */
 102 bool IsValidISODate(const PlainDate& date);
 103
 104 /**
 105  * IsValidISODate ( year, month, day )
 106  */
 107 bool IsValidISODate(double year, double month, double day);
 108 #endif
 109
 110 /**
 111  * IsValidISODate ( year, month, day )
 112  */
 113 bool ThrowIfInvalidISODate(JSContext* cx, const PlainDate& date);
 114
 115 /**
 116  * IsValidISODate ( year, month, day )
 117  */
 118 bool ThrowIfInvalidISODate(JSContext* cx, double year, double month,
 119                            double day);
 120
 121 /**
 122  * ToTemporalDate ( item [ , options ] )
 123  */
 124 bool ToTemporalDate(JSContext* cx, JS::Handle<JS::Value> item,
 125                     PlainDate* result);
 126
 127 /**
 128  * ToTemporalDate ( item [ , options ] )
 129  */
 130 bool ToTemporalDate(JSContext* cx, JS::Handle<JS::Value> item,
 131                     JS::MutableHandle<PlainDateWithCalendar> result);
 132
 133 /**
 134  * CreateTemporalDate ( isoYear, isoMonth, isoDay, calendar [ , newTarget ] )
 135  */
 136 PlainDateObject* CreateTemporalDate(JSContext* cx, const PlainDate& date,
 137                                     JS::Handle<CalendarValue> calendar);
 138
 139 /**
 140  * CreateTemporalDate ( isoYear, isoMonth, isoDay, calendar [ , newTarget ] )
 141  */
 142 bool CreateTemporalDate(JSContext* cx, const PlainDate& date,
 143                         JS::Handle<CalendarValue> calendar,
 144                         JS::MutableHandle<PlainDateWithCalendar> result);
 145
 146 /**
 147  * RegulateISODate ( year, month, day, overflow )
 148  */
 149 bool RegulateISODate(JSContext* cx, const PlainDate& date,
 150                      TemporalOverflow overflow, PlainDate* result);
 151
 152 struct RegulatedISODate final {
 153   double year;
 154   int32_t month;
 155   int32_t day;
 156 };
 157
 158 /**
 159  * RegulateISODate ( year, month, day, overflow )
 160  */
 161 bool RegulateISODate(JSContext* cx, double year, double month, double day,
 162                      TemporalOverflow overflow, RegulatedISODate* result);
 163
 164 /**
 165  * AddISODate ( year, month, day, years, months, weeks, days, overflow )
 166  */
 167 bool AddISODate(JSContext* cx, const PlainDate& date,
 168                 const DateDuration& duration, TemporalOverflow overflow,
 169                 PlainDate* result);
 170
 171 /**
 172  * AddDate ( calendarRec, plainDate, duration [ , options ] )
 173  */
 174 Wrapped<PlainDateObject*> AddDate(JSContext* cx,
 175                                   JS::Handle<CalendarRecord> calendar,
 176                                   JS::Handle<Wrapped<PlainDateObject*>> date,
 177                                   const Duration& duration,
 178                                   JS::Handle<JSObject*> options);
 179
 180 /**
 181  * AddDate ( calendarRec, plainDate, duration [ , options ] )
 182  */
 183 Wrapped<PlainDateObject*> AddDate(JSContext* cx,
 184                                   JS::Handle<CalendarRecord> calendar,
 185                                   JS::Handle<Wrapped<PlainDateObject*>> date,
 186                                   const Duration& duration);
 187
 188 /**
 189  * AddDate ( calendarRec, plainDate, duration [ , options ] )
 190  */
 191 Wrapped<PlainDateObject*> AddDate(
 192     JSContext* cx, JS::Handle<CalendarRecord> calendar,
 193     JS::Handle<Wrapped<PlainDateObject*>> date,
 194     JS::Handle<Wrapped<DurationObject*>> durationObj,
 195     JS::Handle<JSObject*> options);
 196
 197 /**
 198  * AddDate ( calendarRec, plainDate, duration [ , options ] )
 199  */
 200 Wrapped<PlainDateObject*> AddDate(
 201     JSContext* cx, JS::Handle<CalendarRecord> calendar,
 202     JS::Handle<Wrapped<PlainDateObject*>> date,
 203     JS::Handle<Wrapped<DurationObject*>> durationObj);
 204
 205 /**
 206  * AddDate ( calendarRec, plainDate, duration [ , options ] )
 207  */
 208 bool AddDate(JSContext* cx, JS::Handle<CalendarRecord> calendar,
 209              const PlainDate& date, const Duration& duration,
 210              JS::Handle<JSObject*> options, PlainDate* result);
 211
 212 /**
 213  * AddDate ( calendarRec, plainDate, duration [ , options ] )
 214  */
 215 bool AddDate(JSContext* cx, JS::Handle<CalendarRecord> calendar,
 216              JS::Handle<Wrapped<PlainDateObject*>> date,
 217              const Duration& duration, PlainDate* result);
 218
 219 /**
 220  * DifferenceISODate ( y1, m1, d1, y2, m2, d2, largestUnit )
 221  */
 222 DateDuration DifferenceISODate(const PlainDate& start, const PlainDate& end,
 223                                TemporalUnit largestUnit);
 224
 225 /**
 226  * DifferenceDate ( calendarRec, one, two, options )
 227  */
 228 bool DifferenceDate(JSContext* cx, JS::Handle<CalendarRecord> calendar,
 229                     JS::Handle<Wrapped<PlainDateObject*>> one,
 230                     JS::Handle<Wrapped<PlainDateObject*>> two,
 231                     JS::Handle<PlainObject*> options, Duration* result);
 232
 233 /**
 234  * DifferenceDate ( calendarRec, one, two, options )
 235  */
 236 bool DifferenceDate(JSContext* cx, JS::Handle<CalendarRecord> calendar,
 237                     JS::Handle<Wrapped<PlainDateObject*>> one,
 238                     JS::Handle<Wrapped<PlainDateObject*>> two,
 239                     TemporalUnit largestUnit, Duration* result);
 240
 241 /**
 242  * CompareISODate ( y1, m1, d1, y2, m2, d2 )
 243  */
 244 int32_t CompareISODate(const PlainDate& one, const PlainDate& two);
 245
 246 /**
 247  * BalanceISODate ( year, month, day )
 248  */
 249 bool BalanceISODate(JSContext* cx, int32_t year, int32_t month, int64_t day,
 250                     PlainDate* result);
 251
 252 /**
 253  * BalanceISODate ( year, month, day )
 254  */
 255 PlainDate BalanceISODate(int32_t year, int32_t month, int32_t day);
 256
 257 /**
 258  * BalanceISODate ( year, month, day )
 259  */
 260 PlainDate BalanceISODateNew(int32_t year, int32_t month, int32_t day);
 261
 262 /**
 263  * Return true when accessing the calendar fields |fieldNames| can be optimized.
 264  * Otherwise returns false.
 265  */
 266 bool IsBuiltinAccess(JSContext* cx, JS::Handle<PlainDateObject*> date,
 267                      std::initializer_list<CalendarField> fieldNames);
 268
 269 } /* namespace js::temporal */
 270
 271 namespace js {
 272
 273 template <typename Wrapper>
 274 class WrappedPtrOperations<temporal::PlainDateWithCalendar, Wrapper> {
 275   const auto& container() const {
 276     return static_cast<const Wrapper*>(this)->get();
 277   }
 278
 279  public:
 280   const auto& date() const { return container().date(); }
 281
 282   JS::Handle<temporal::CalendarValue> calendar() const {
 283     return JS::Handle<temporal::CalendarValue>::fromMarkedLocation(
 284         container().calendarDoNotUse());
 285   }
 286
 287   // Allow implicit conversion to a calendar-less PlainDate.
 288   operator const temporal::PlainDate&() const { return date(); }
 289 };
 290
 291 }  // namespace js
 292
 293 #endif /* builtin_temporal_PlainDate_h */