tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

TemporalParser.h (5475B)

      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_TemporalParser_h
      8 #define builtin_temporal_TemporalParser_h
      9 
     10 #include "mozilla/Assertions.h"
     11 #include "mozilla/Attributes.h"
     12 #include "mozilla/MaybeOneOf.h"
     13 
     14 #include <cstdlib>
     15 #include <stdint.h>
     16 
     17 #include "builtin/temporal/TemporalTypes.h"
     18 #include "builtin/temporal/TemporalUnit.h"
     19 #include "js/RootingAPI.h"
     20 #include "js/TypeDecls.h"
     21 
     22 class JSLinearString;
     23 class JS_PUBLIC_API JSTracer;
     24 
     25 namespace js::temporal {
     26 
     27 struct MOZ_STACK_CLASS ParsedTimeZone final {
     28  JSLinearString* name = nullptr;
     29  int32_t offset = INT32_MIN;
     30 
     31  void trace(JSTracer* trc);
     32 
     33  static ParsedTimeZone fromName(JSLinearString* name) {
     34    MOZ_ASSERT(name);
     35    return {name, 0};
     36  }
     37 
     38  static ParsedTimeZone fromOffset(int32_t offset) {
     39    MOZ_ASSERT(std::abs(offset) < UnitsPerDay(TemporalUnit::Minute));
     40    return {nullptr, offset};
     41  }
     42 
     43  explicit operator bool() const {
     44    return name != nullptr || offset != INT32_MIN;
     45  }
     46 };
     47 
     48 struct UTCTimeZone final {};
     49 
     50 struct OffsetTimeZone final {
     51  int64_t offset = 0;
     52  bool hasSubMinutePrecision = false;
     53 };
     54 
     55 struct MOZ_STACK_CLASS ParsedZonedDateTime final {
     56  ISODateTime dateTime = {};
     57  JSLinearString* calendar = nullptr;
     58  ParsedTimeZone timeZoneAnnotation{};
     59  mozilla::MaybeOneOf<UTCTimeZone, OffsetTimeZone> timeZone{};
     60  bool isStartOfDay = false;
     61 
     62  void trace(JSTracer* trc);
     63 };
     64 
     65 /**
     66 * ParseTemporalInstantString ( isoString )
     67 */
     68 bool ParseTemporalInstantString(JSContext* cx, JS::Handle<JSString*> str,
     69                                ISODateTime* result, int64_t* offset);
     70 
     71 /**
     72 * ParseTemporalTimeZoneString ( timeZoneString )
     73 */
     74 bool ParseTemporalTimeZoneString(JSContext* cx, JS::Handle<JSString*> str,
     75                                 JS::MutableHandle<ParsedTimeZone> result);
     76 
     77 /**
     78 * ParseTimeZoneIdentifier ( identifier )
     79 */
     80 bool ParseTimeZoneIdentifier(JSContext* cx, JS::Handle<JSString*> str,
     81                             JS::MutableHandle<ParsedTimeZone> result);
     82 
     83 /**
     84 * ParseDateTimeUTCOffset ( offsetString )
     85 */
     86 bool ParseDateTimeUTCOffset(JSContext* cx, JS::Handle<JSString*> str,
     87                            int64_t* result);
     88 
     89 /**
     90 * ParseTemporalDurationString ( isoString )
     91 */
     92 bool ParseTemporalDurationString(JSContext* cx, JS::Handle<JSString*> str,
     93                                 Duration* result);
     94 
     95 /**
     96 * ParseTemporalCalendarString ( isoString )
     97 */
     98 JSLinearString* ParseTemporalCalendarString(JSContext* cx,
     99                                            JS::Handle<JSString*> str);
    100 
    101 /**
    102 * ParseTemporalTimeString ( isoString )
    103 */
    104 bool ParseTemporalTimeString(JSContext* cx, JS::Handle<JSString*> str,
    105                             Time* result);
    106 
    107 /**
    108 * ParseTemporalMonthDayString ( isoString )
    109 */
    110 bool ParseTemporalMonthDayString(JSContext* cx, JS::Handle<JSString*> str,
    111                                 ISODate* result, bool* hasYear,
    112                                 JS::MutableHandle<JSString*> calendar);
    113 
    114 /**
    115 * ParseTemporalYearMonthString ( isoString )
    116 */
    117 bool ParseTemporalYearMonthString(JSContext* cx, JS::Handle<JSString*> str,
    118                                  ISODate* result,
    119                                  JS::MutableHandle<JSString*> calendar);
    120 
    121 /**
    122 * ParseTemporalDateTimeString ( isoString )
    123 */
    124 bool ParseTemporalDateTimeString(JSContext* cx, JS::Handle<JSString*> str,
    125                                 ISODateTime* result,
    126                                 JS::MutableHandle<JSString*> calendar);
    127 
    128 /**
    129 * ParseTemporalZonedDateTimeString ( isoString )
    130 */
    131 bool ParseTemporalZonedDateTimeString(
    132    JSContext* cx, JS::Handle<JSString*> str,
    133    JS::MutableHandle<ParsedZonedDateTime> result);
    134 
    135 /**
    136 * ParseTemporalRelativeToString ( isoString )
    137 */
    138 bool ParseTemporalRelativeToString(
    139    JSContext* cx, JS::Handle<JSString*> str,
    140    JS::MutableHandle<ParsedZonedDateTime> result);
    141 
    142 } /* namespace js::temporal */
    143 
    144 namespace js {
    145 
    146 template <typename Wrapper>
    147 class WrappedPtrOperations<temporal::ParsedTimeZone, Wrapper> {
    148  const auto& object() const {
    149    return static_cast<const Wrapper*>(this)->get();
    150  }
    151 
    152 public:
    153  JS::Handle<JSLinearString*> name() const {
    154    return JS::Handle<JSLinearString*>::fromMarkedLocation(&object().name);
    155  }
    156 
    157  int32_t offset() const { return object().offset; }
    158 
    159  explicit operator bool() const { return bool(object()); }
    160 };
    161 
    162 template <typename Wrapper>
    163 class WrappedPtrOperations<temporal::ParsedZonedDateTime, Wrapper> {
    164  const auto& object() const {
    165    return static_cast<const Wrapper*>(this)->get();
    166  }
    167 
    168 public:
    169  const temporal::ISODateTime& dateTime() const { return object().dateTime; }
    170 
    171  JS::Handle<JSLinearString*> calendar() const {
    172    return JS::Handle<JSLinearString*>::fromMarkedLocation(&object().calendar);
    173  }
    174 
    175  JS::Handle<temporal::ParsedTimeZone> timeZoneAnnotation() const {
    176    return JS::Handle<temporal::ParsedTimeZone>::fromMarkedLocation(
    177        &object().timeZoneAnnotation);
    178  }
    179 
    180  const mozilla::MaybeOneOf<temporal::UTCTimeZone, temporal::OffsetTimeZone>&
    181  timeZone() const {
    182    return object().timeZone;
    183  }
    184 
    185  bool isStartOfDay() const { return object().isStartOfDay; }
    186 };
    187 
    188 } /* namespace js */
    189 
    190 #endif /* builtin_temporal_TemporalParser_h */