js/src/builtin/temporal/Instant.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_Instant_h
   8 #define builtin_temporal_Instant_h
   9
  10 #include "mozilla/Assertions.h"
  11
  12 #include <stdint.h>
  13
  14 #include "builtin/temporal/TemporalTypes.h"
  15 #include "builtin/temporal/Wrapped.h"
  16 #include "js/TypeDecls.h"
  17 #include "js/Value.h"
  18 #include "vm/NativeObject.h"
  19
  20 namespace js {
  21 struct ClassSpec;
  22 }
  23
  24 namespace js::temporal {
  25
  26 class InstantObject : public NativeObject {
  27  public:
  28   static const JSClass class_;
  29   static const JSClass& protoClass_;
  30
  31   static constexpr uint32_t SECONDS_SLOT = 0;
  32   static constexpr uint32_t NANOSECONDS_SLOT = 1;
  33   static constexpr uint32_t SLOT_COUNT = 2;
  34
  35   int64_t seconds() const {
  36     double seconds = getFixedSlot(SECONDS_SLOT).toNumber();
  37     MOZ_ASSERT(-8'640'000'000'000 <= seconds && seconds <= 8'640'000'000'000);
  38     return int64_t(seconds);
  39   }
  40
  41   int32_t nanoseconds() const {
  42     int32_t nanoseconds = getFixedSlot(NANOSECONDS_SLOT).toInt32();
  43     MOZ_ASSERT(0 <= nanoseconds && nanoseconds <= 999'999'999);
  44     return nanoseconds;
  45   }
  46
  47  private:
  48   static const ClassSpec classSpec_;
  49 };
  50
  51 /**
  52  * Extract the instant fields from the Instant object.
  53  */
  54 inline Instant ToInstant(const InstantObject* instant) {
  55   return {instant->seconds(), instant->nanoseconds()};
  56 }
  57
  58 class Increment;
  59 enum class TemporalUnit;
  60 enum class TemporalRoundingMode;
  61
  62 /**
  63  * IsValidEpochNanoseconds ( epochNanoseconds )
  64  */
  65 bool IsValidEpochNanoseconds(const JS::BigInt* epochNanoseconds);
  66
  67 /**
  68  * IsValidEpochNanoseconds ( epochNanoseconds )
  69  */
  70 bool IsValidEpochInstant(const Instant& instant);
  71
  72 #ifdef DEBUG
  73 /**
  74  * Return true if the input is within the valid instant span limits.
  75  */
  76 bool IsValidInstantSpan(const InstantSpan& span);
  77 #endif
  78
  79 /**
  80  * Convert a BigInt to an instant. The input must be a valid epoch nanoseconds
  81  * value.
  82  */
  83 Instant ToInstant(const JS::BigInt* epochNanoseconds);
  84
  85 /**
  86  * Convert an instant to a BigInt. The input must be a valid epoch instant.
  87  */
  88 JS::BigInt* ToEpochNanoseconds(JSContext* cx, const Instant& instant);
  89
  90 /**
  91  * ToTemporalInstant ( item )
  92  */
  93 Wrapped<InstantObject*> ToTemporalInstant(JSContext* cx,
  94                                           JS::Handle<JS::Value> item);
  95
  96 /**
  97  * ToTemporalInstant ( item )
  98  */
  99 bool ToTemporalInstant(JSContext* cx, JS::Handle<JS::Value> item,
 100                        Instant* result);
 101
 102 /**
 103  * CreateTemporalInstant ( epochNanoseconds [ , newTarget ] )
 104  */
 105 InstantObject* CreateTemporalInstant(JSContext* cx, const Instant& instant);
 106
 107 /**
 108  * GetUTCEpochNanoseconds ( year, month, day, hour, minute, second, millisecond,
 109  * microsecond, nanosecond [ , offsetNanoseconds ] )
 110  */
 111 Instant GetUTCEpochNanoseconds(const PlainDateTime& dateTime);
 112
 113 /**
 114  * GetUTCEpochNanoseconds ( year, month, day, hour, minute, second, millisecond,
 115  * microsecond, nanosecond [ , offsetNanoseconds ] )
 116  */
 117 Instant GetUTCEpochNanoseconds(const PlainDateTime& dateTime,
 118                                const InstantSpan& offsetNanoseconds);
 119
 120 /**
 121  * RoundTemporalInstant ( ns, increment, unit, roundingMode )
 122  */
 123 Instant RoundTemporalInstant(const Instant& ns, Increment increment,
 124                              TemporalUnit unit,
 125                              TemporalRoundingMode roundingMode);
 126
 127 /**
 128  * AddNormalizedTimeDurationToEpochNanoseconds ( d, epochNs )
 129  */
 130 Instant AddNormalizedTimeDurationToEpochNanoseconds(
 131     const NormalizedTimeDuration& d, const Instant& epochNs);
 132
 133 /**
 134  * AddInstant ( epochNanoseconds, norm )
 135  */
 136 bool AddInstant(JSContext* cx, const Instant& instant,
 137                 const NormalizedTimeDuration& duration, Instant* result);
 138
 139 /**
 140  * DifferenceInstant ( ns1, ns2, roundingIncrement, smallestUnit, roundingMode )
 141  */
 142 NormalizedTimeDuration DifferenceInstant(const Instant& ns1, const Instant& ns2,
 143                                          Increment roundingIncrement,
 144                                          TemporalUnit smallestUnit,
 145                                          TemporalRoundingMode roundingMode);
 146
 147 } /* namespace js::temporal */
 148
 149 #endif /* builtin_temporal_Instant_h */