js/src/builtin/temporal/Duration.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_Duration_h
   8 #define builtin_temporal_Duration_h
   9
  10 #include <stdint.h>
  11
  12 #include "builtin/temporal/TemporalTypes.h"
  13 #include "builtin/temporal/Wrapped.h"
  14 #include "js/RootingAPI.h"
  15 #include "js/TypeDecls.h"
  16 #include "js/Value.h"
  17 #include "vm/NativeObject.h"
  18
  19 namespace js {
  20 struct ClassSpec;
  21 }
  22
  23 namespace js::temporal {
  24
  25 class DurationObject : public NativeObject {
  26  public:
  27   static const JSClass class_;
  28   static const JSClass& protoClass_;
  29
  30   static constexpr uint32_t YEARS_SLOT = 0;
  31   static constexpr uint32_t MONTHS_SLOT = 1;
  32   static constexpr uint32_t WEEKS_SLOT = 2;
  33   static constexpr uint32_t DAYS_SLOT = 3;
  34   static constexpr uint32_t HOURS_SLOT = 4;
  35   static constexpr uint32_t MINUTES_SLOT = 5;
  36   static constexpr uint32_t SECONDS_SLOT = 6;
  37   static constexpr uint32_t MILLISECONDS_SLOT = 7;
  38   static constexpr uint32_t MICROSECONDS_SLOT = 8;
  39   static constexpr uint32_t NANOSECONDS_SLOT = 9;
  40   static constexpr uint32_t SLOT_COUNT = 10;
  41
  42   double years() const { return getFixedSlot(YEARS_SLOT).toNumber(); }
  43   double months() const { return getFixedSlot(MONTHS_SLOT).toNumber(); }
  44   double weeks() const { return getFixedSlot(WEEKS_SLOT).toNumber(); }
  45   double days() const { return getFixedSlot(DAYS_SLOT).toNumber(); }
  46   double hours() const { return getFixedSlot(HOURS_SLOT).toNumber(); }
  47   double minutes() const { return getFixedSlot(MINUTES_SLOT).toNumber(); }
  48   double seconds() const { return getFixedSlot(SECONDS_SLOT).toNumber(); }
  49   double milliseconds() const {
  50     return getFixedSlot(MILLISECONDS_SLOT).toNumber();
  51   }
  52   double microseconds() const {
  53     return getFixedSlot(MICROSECONDS_SLOT).toNumber();
  54   }
  55   double nanoseconds() const {
  56     return getFixedSlot(NANOSECONDS_SLOT).toNumber();
  57   }
  58
  59  private:
  60   static const ClassSpec classSpec_;
  61 };
  62
  63 /**
  64  * Extract the duration fields from the Duration object.
  65  */
  66 inline Duration ToDuration(const DurationObject* duration) {
  67   return {
  68       duration->years(),        duration->months(),
  69       duration->weeks(),        duration->days(),
  70       duration->hours(),        duration->minutes(),
  71       duration->seconds(),      duration->milliseconds(),
  72       duration->microseconds(), duration->nanoseconds(),
  73   };
  74 }
  75
  76 class Increment;
  77 class CalendarRecord;
  78 class PlainDateObject;
  79 class TimeZoneRecord;
  80 class ZonedDateTime;
  81 class ZonedDateTimeObject;
  82 enum class TemporalRoundingMode;
  83 enum class TemporalUnit;
  84
  85 /**
  86  * DurationSign ( years, months, weeks, days, hours, minutes, seconds,
  87  * milliseconds, microseconds, nanoseconds )
  88  */
  89 int32_t DurationSign(const Duration& duration);
  90
  91 /**
  92  * IsValidDuration ( years, months, weeks, days, hours, minutes, seconds,
  93  * milliseconds, microseconds, nanoseconds )
  94  */
  95 bool IsValidDuration(const Duration& duration);
  96
  97 #ifdef DEBUG
  98 /**
  99  * IsValidDuration ( years, months, weeks, days, hours, minutes, seconds,
 100  * milliseconds, microseconds, nanoseconds )
 101  */
 102 bool IsValidDuration(const NormalizedDuration& duration);
 103 #endif
 104
 105 /**
 106  * IsValidDuration ( years, months, weeks, days, hours, minutes, seconds,
 107  * milliseconds, microseconds, nanoseconds )
 108  */
 109 bool ThrowIfInvalidDuration(JSContext* cx, const Duration& duration);
 110
 111 /**
 112  * IsValidDuration ( years, months, weeks, days, hours, minutes, seconds,
 113  * milliseconds, microseconds, nanoseconds )
 114  */
 115 inline bool IsValidNormalizedTimeDuration(
 116     const NormalizedTimeDuration& duration) {
 117   MOZ_ASSERT(0 <= duration.nanoseconds && duration.nanoseconds <= 999'999'999);
 118
 119   // Step 4.
 120   //
 121   // The absolute value of the seconds part of normalized time duration must be
 122   // less-or-equal to `2**53 - 1` and the nanoseconds part must be less or equal
 123   // to `999'999'999`.
 124   return NormalizedTimeDuration::min() <= duration &&
 125          duration <= NormalizedTimeDuration::max();
 126 }
 127
 128 /**
 129  * NormalizeTimeDuration ( hours, minutes, seconds, milliseconds, microseconds,
 130  * nanoseconds )
 131  */
 132 NormalizedTimeDuration NormalizeTimeDuration(int32_t hours, int32_t minutes,
 133                                              int32_t seconds,
 134                                              int32_t milliseconds,
 135                                              int32_t microseconds,
 136                                              int32_t nanoseconds);
 137
 138 /**
 139  * NormalizeTimeDuration ( hours, minutes, seconds, milliseconds, microseconds,
 140  * nanoseconds )
 141  */
 142 NormalizedTimeDuration NormalizeTimeDuration(const Duration& duration);
 143
 144 /**
 145  * CompareNormalizedTimeDuration ( one, two )
 146  */
 147 inline int32_t CompareNormalizedTimeDuration(
 148     const NormalizedTimeDuration& one, const NormalizedTimeDuration& two) {
 149   MOZ_ASSERT(IsValidNormalizedTimeDuration(one));
 150   MOZ_ASSERT(IsValidNormalizedTimeDuration(two));
 151
 152   // Step 1.
 153   if (one > two) {
 154     return 1;
 155   }
 156
 157   // Step 2.
 158   if (one < two) {
 159     return -1;
 160   }
 161
 162   // Step 3.
 163   return 0;
 164 }
 165
 166 /**
 167  * NormalizedTimeDurationSign ( d )
 168  */
 169 inline int32_t NormalizedTimeDurationSign(const NormalizedTimeDuration& d) {
 170   MOZ_ASSERT(IsValidNormalizedTimeDuration(d));
 171
 172   // Steps 1-3.
 173   return CompareNormalizedTimeDuration(d, NormalizedTimeDuration{});
 174 }
 175
 176 /**
 177  * Add24HourDaysToNormalizedTimeDuration ( d, days )
 178  */
 179 bool Add24HourDaysToNormalizedTimeDuration(JSContext* cx,
 180                                            const NormalizedTimeDuration& d,
 181                                            double days,
 182                                            NormalizedTimeDuration* result);
 183
 184 /**
 185  * CreateNormalizedDurationRecord ( years, months, weeks, days, norm )
 186  */
 187 inline NormalizedDuration CreateNormalizedDurationRecord(
 188     const DateDuration& date, const NormalizedTimeDuration& time) {
 189   MOZ_ASSERT(IsValidDuration(date.toDuration()));
 190   MOZ_ASSERT(IsValidNormalizedTimeDuration(time));
 191 #ifdef DEBUG
 192   int64_t dateValues = date.years | date.months | date.weeks | date.days;
 193   int32_t dateSign = dateValues ? dateValues < 0 ? -1 : 1 : 0;
 194   int32_t timeSign = NormalizedTimeDurationSign(time);
 195   MOZ_ASSERT((dateSign * timeSign) >= 0);
 196 #endif
 197
 198   return {date, time};
 199 }
 200
 201 /**
 202  * CreateNormalizedDurationRecord ( years, months, weeks, days, norm )
 203  */
 204 inline NormalizedDuration CreateNormalizedDurationRecord(
 205     const Duration& duration) {
 206   return CreateNormalizedDurationRecord(duration.toDateDuration(),
 207                                         NormalizeTimeDuration(duration));
 208 }
 209
 210 /**
 211  * CombineDateAndNormalizedTimeDuration ( dateDurationRecord, norm )
 212  */
 213 bool CombineDateAndNormalizedTimeDuration(JSContext* cx,
 214                                           const DateDuration& date,
 215                                           const NormalizedTimeDuration& time,
 216                                           NormalizedDuration* result);
 217
 218 /**
 219  * CreateNormalizedDurationRecord ( years, months, weeks, days, norm )
 220  */
 221 inline bool CreateNormalizedDurationRecord(JSContext* cx,
 222                                            const DateDuration& date,
 223                                            const NormalizedTimeDuration& time,
 224                                            NormalizedDuration* result) {
 225   return CombineDateAndNormalizedTimeDuration(cx, date, time, result);
 226 }
 227
 228 /**
 229  * NormalizedTimeDurationFromEpochNanosecondsDifference ( one, two )
 230  */
 231 NormalizedTimeDuration NormalizedTimeDurationFromEpochNanosecondsDifference(
 232     const Instant& one, const Instant& two);
 233
 234 /**
 235  * CreateTemporalDuration ( years, months, weeks, days, hours, minutes, seconds,
 236  * milliseconds, microseconds, nanoseconds [ , newTarget ] )
 237  */
 238 DurationObject* CreateTemporalDuration(JSContext* cx, const Duration& duration);
 239
 240 /**
 241  * ToTemporalDuration ( item )
 242  */
 243 Wrapped<DurationObject*> ToTemporalDuration(JSContext* cx,
 244                                             JS::Handle<JS::Value> item);
 245
 246 /**
 247  * ToTemporalDuration ( item )
 248  */
 249 bool ToTemporalDuration(JSContext* cx, JS::Handle<JS::Value> item,
 250                         Duration* result);
 251
 252 /**
 253  * ToTemporalDurationRecord ( temporalDurationLike )
 254  */
 255 bool ToTemporalDurationRecord(JSContext* cx,
 256                               JS::Handle<JS::Value> temporalDurationLike,
 257                               Duration* result);
 258
 259 /**
 260  * BalanceTimeDuration ( norm, largestUnit )
 261  */
 262 TimeDuration BalanceTimeDuration(const NormalizedTimeDuration& duration,
 263                                  TemporalUnit largestUnit);
 264
 265 /**
 266  * BalanceDateDurationRelative ( years, months, weeks, days, largestUnit,
 267  * smallestUnit, plainRelativeTo, calendarRec )
 268  */
 269 bool BalanceDateDurationRelative(
 270     JSContext* cx, const DateDuration& duration, TemporalUnit largestUnit,
 271     TemporalUnit smallestUnit,
 272     JS::Handle<Wrapped<PlainDateObject*>> plainRelativeTo,
 273     JS::Handle<CalendarRecord> calendar, DateDuration* result);
 274
 275 /**
 276  * AdjustRoundedDurationDays ( years, months, weeks, days, norm, increment,
 277  * unit, roundingMode, zonedRelativeTo, calendarRec, timeZoneRec,
 278  * precalculatedPlainDateTime )
 279  */
 280 bool AdjustRoundedDurationDays(JSContext* cx,
 281                                const NormalizedDuration& duration,
 282                                Increment increment, TemporalUnit unit,
 283                                TemporalRoundingMode roundingMode,
 284                                JS::Handle<ZonedDateTime> relativeTo,
 285                                JS::Handle<CalendarRecord> calendar,
 286                                JS::Handle<TimeZoneRecord> timeZone,
 287                                const PlainDateTime& precalculatedPlainDateTime,
 288                                NormalizedDuration* result);
 289
 290 /**
 291  * RoundDuration ( years, months, weeks, days, norm, increment, unit,
 292  * roundingMode [ , plainRelativeTo [ , calendarRec [ , zonedRelativeTo [ ,
 293  * timeZoneRec [ , precalculatedPlainDateTime ] ] ] ] ] )
 294  */
 295 NormalizedTimeDuration RoundDuration(const NormalizedTimeDuration& duration,
 296                                      Increment increment, TemporalUnit unit,
 297                                      TemporalRoundingMode roundingMode);
 298
 299 /**
 300  * RoundDuration ( years, months, weeks, days, norm, increment, unit,
 301  * roundingMode [ , plainRelativeTo [ , calendarRec [ , zonedRelativeTo [ ,
 302  * timeZoneRec [ , precalculatedPlainDateTime ] ] ] ] ] )
 303  */
 304 bool RoundDuration(JSContext* cx, const NormalizedDuration& duration,
 305                    Increment increment, TemporalUnit unit,
 306                    TemporalRoundingMode roundingMode,
 307                    JS::Handle<Wrapped<PlainDateObject*>> plainRelativeTo,
 308                    JS::Handle<CalendarRecord> calendar,
 309                    NormalizedDuration* result);
 310
 311 /**
 312  * RoundDuration ( years, months, weeks, days, norm, increment, unit,
 313  * roundingMode [ , plainRelativeTo [ , calendarRec [ , zonedRelativeTo [ ,
 314  * timeZoneRec [ , precalculatedPlainDateTime ] ] ] ] ] )
 315  */
 316 bool RoundDuration(JSContext* cx, const NormalizedDuration& duration,
 317                    Increment increment, TemporalUnit unit,
 318                    TemporalRoundingMode roundingMode,
 319                    JS::Handle<PlainDateObject*> plainRelativeTo,
 320                    JS::Handle<CalendarRecord> calendar,
 321                    JS::Handle<ZonedDateTime> zonedRelativeTo,
 322                    JS::Handle<TimeZoneRecord> timeZone,
 323                    const PlainDateTime& precalculatedPlainDateTime,
 324                    NormalizedDuration* result);
 325
 326 /**
 327  * DaysUntil ( earlier, later )
 328  */
 329 int32_t DaysUntil(const PlainDate& earlier, const PlainDate& later);
 330
 331 } /* namespace js::temporal */
 332
 333 #endif /* builtin_temporal_Duration_h */