Quelle  PlainDateTime.h   Sprache: C

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: set ts=8 sts=2 et sw=2 tw=80:
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef builtin_temporal_PlainDateTime_h
#define builtin_temporal_PlainDateTime_h

#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/Casting.h"

#include <stdint.h>

#include "builtin/temporal/Calendar.h"
#include "builtin/temporal/TemporalTypes.h"
#include "js/RootingAPI.h"
#include "js/TypeDecls.h"
#include "js/Value.h"
#include "vm/NativeObject.h"

class JS_PUBLIC_API JSTracer;

namespace js {
struct ClassSpec;
}  // namespace js

namespace js::temporal {

class PlainDateTimeObject : public NativeObject {
 public:
  static const JSClass class_;
  static const JSClass& protoClass_;

  static constexpr uint32_t PACKED_DATE_SLOT = 0;
  static constexpr uint32_t PACKED_TIME_SLOT = 1;
  static constexpr uint32_t CALENDAR_SLOT = 2;
  static constexpr uint32_t SLOT_COUNT = 3;

  /**
   * Extract the date fields from this PlainDateTime object.
   */
  ISODate date() const {
    auto packed = PackedDate{getFixedSlot(PACKED_DATE_SLOT).toPrivateUint32()};
    return PackedDate::unpack(packed);
  }

  /**
   * Extract the time fields from this PlainDateTime object.
   */
  Time time() const {
    auto packed = PackedTime{mozilla::BitwiseCast<uint64_t>(
        getFixedSlot(PACKED_TIME_SLOT).toDouble())};
    return PackedTime::unpack(packed);
  }

  /**
   * Extract the date-time fields from this PlainDateTime object.
   */
  ISODateTime dateTime() const { return {date(), time()}; }

  CalendarValue calendar() const {
    return CalendarValue(getFixedSlot(CALENDAR_SLOT));
  }

 private:
  static const ClassSpec classSpec_;
};

struct DifferenceSettings;
class Increment;
class CalendarFields;
enum class TemporalOverflow;
enum class TemporalRoundingMode;
enum class TemporalUnit;

#ifdef DEBUG
/**
 * IsValidISODate ( year, month, day )
 * IsValidTime ( hour, minute, second, millisecond, microsecond, nanosecond )
 */
bool IsValidISODateTime(const ISODateTime& isoDateTime);
#endif

/**
 * ISODateTimeWithinLimits ( isoDateTime )
 */
bool ISODateTimeWithinLimits(const ISODateTime& isoDateTime);

class MOZ_STACK_CLASS PlainDateTime final {
  ISODateTime dateTime_;
  CalendarValue calendar_;

 public:
  PlainDateTime() = default;

  PlainDateTime(const ISODateTime& dateTime, const CalendarValue& calendar)
      : dateTime_(dateTime), calendar_(calendar) {
    MOZ_ASSERT(ISODateTimeWithinLimits(dateTime));
  }

  explicit PlainDateTime(const PlainDateTimeObject* dateTime)
      : PlainDateTime(dateTime->dateTime(), dateTime->calendar()) {}

  const auto& dateTime() const { return dateTime_; }
  const auto& date() const { return dateTime_.date; }
  const auto& time() const { return dateTime_.time; }
  const auto& calendar() const { return calendar_; }

  // Allow implicit conversion to an ISODateTime.
  operator const ISODateTime&() const { return dateTime(); }

  void trace(JSTracer* trc) { calendar_.trace(trc); }

  const auto* calendarDoNotUse() const { return &calendar_; }
};

/**
 * CreateTemporalDateTime ( isoDateTime, calendar [ , newTarget ] )
 */
PlainDateTimeObject* CreateTemporalDateTime(JSContext* cx,
                                            const ISODateTime& dateTime,
                                            JS::Handle<CalendarValue> calendar);

/**
 * InterpretTemporalDateTimeFields ( calendar, fields, overflow )
 */
bool InterpretTemporalDateTimeFields(JSContext* cx,
                                     JS::Handle<CalendarValue> calendar,
                                     JS::Handle<CalendarFields> fields,
                                     TemporalOverflow overflow,
                                     ISODateTime* result);

/**
 * RoundISODateTime ( isoDateTime, increment, unit, roundingMode )
 */
ISODateTime RoundISODateTime(const ISODateTime& isoDateTime,
                             Increment increment, TemporalUnit unit,
                             TemporalRoundingMode roundingMode);

/**
 * DifferencePlainDateTimeWithRounding ( isoDateTime1, isoDateTime2, calendar,
 * largestUnit, roundingIncrement, smallestUnit, roundingMode )
 */
bool DifferencePlainDateTimeWithRounding(JSContext* cx,
                                         const ISODateTime& isoDateTime1,
                                         const ISODateTime& isoDateTime2,
                                         JS::Handle<CalendarValue> calendar,
                                         const DifferenceSettings& settings,
                                         InternalDuration* result);
/**
 * DifferencePlainDateTimeWithTotal ( isoDateTime1, isoDateTime2, calendar, unit
 * )
 */
bool DifferencePlainDateTimeWithTotal(JSContext* cx,
                                      const ISODateTime& isoDateTime1,
                                      const ISODateTime& isoDateTime2,
                                      JS::Handle<CalendarValue> calendar,
                                      TemporalUnit unit, double* result);

} /* namespace js::temporal */

namespace js {

template <typename Wrapper>
class WrappedPtrOperations<temporal::PlainDateTime, Wrapper> {
  const auto& container() const {
    return static_cast<const Wrapper*>(this)->get();
  }

 public:
  const auto& dateTime() const { return container().dateTime(); }
  const auto& date() const { return container().date(); }
  const auto& time() const { return container().time(); }

  auto calendar() const {
    return JS::Handle<temporal::CalendarValue>::fromMarkedLocation(
        container().calendarDoNotUse());
  }

  // Allow implicit conversion to an ISODateTime.
  operator const temporal::ISODateTime&() const { return dateTime(); }
};

}  // namespace js

#endif /* builtin_temporal_PlainDateTime_h */