diff options
Diffstat (limited to 'js/src/builtin/temporal/PlainTime.h')
-rw-r--r-- | js/src/builtin/temporal/PlainTime.h | 187 |
1 files changed, 187 insertions, 0 deletions
diff --git a/js/src/builtin/temporal/PlainTime.h b/js/src/builtin/temporal/PlainTime.h new file mode 100644 index 0000000000..b6da469913 --- /dev/null +++ b/js/src/builtin/temporal/PlainTime.h @@ -0,0 +1,187 @@ +/* -*- 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_PlainTime_h +#define builtin_temporal_PlainTime_h + +#include <stdint.h> + +#include "builtin/temporal/TemporalTypes.h" +#include "js/TypeDecls.h" +#include "js/Value.h" +#include "vm/NativeObject.h" + +namespace js { +struct ClassSpec; +} + +namespace js::temporal { + +class PlainTimeObject : public NativeObject { + public: + static const JSClass class_; + static const JSClass& protoClass_; + + // TODO: Consider compacting fields to reduce object size. + // + // ceil(log2(24)) + 2 * ceil(log2(60)) + 3 * ceil(log2(1000)) = 47 bits are + // needed to store a time value in a single int64. 47 bits can be stored as + // raw bits in a JS::Value. + + static constexpr uint32_t ISO_HOUR_SLOT = 0; + static constexpr uint32_t ISO_MINUTE_SLOT = 1; + static constexpr uint32_t ISO_SECOND_SLOT = 2; + static constexpr uint32_t ISO_MILLISECOND_SLOT = 3; + static constexpr uint32_t ISO_MICROSECOND_SLOT = 4; + static constexpr uint32_t ISO_NANOSECOND_SLOT = 5; + static constexpr uint32_t SLOT_COUNT = 6; + + int32_t isoHour() const { return getFixedSlot(ISO_HOUR_SLOT).toInt32(); } + + int32_t isoMinute() const { return getFixedSlot(ISO_MINUTE_SLOT).toInt32(); } + + int32_t isoSecond() const { return getFixedSlot(ISO_SECOND_SLOT).toInt32(); } + + int32_t isoMillisecond() const { + return getFixedSlot(ISO_MILLISECOND_SLOT).toInt32(); + } + + int32_t isoMicrosecond() const { + return getFixedSlot(ISO_MICROSECOND_SLOT).toInt32(); + } + + int32_t isoNanosecond() const { + return getFixedSlot(ISO_NANOSECOND_SLOT).toInt32(); + } + + private: + static const ClassSpec classSpec_; +}; + +/** + * Extract the time fields from the PlainTime object. + */ +inline PlainTime ToPlainTime(const PlainTimeObject* time) { + return {time->isoHour(), time->isoMinute(), + time->isoSecond(), time->isoMillisecond(), + time->isoMicrosecond(), time->isoNanosecond()}; +} + +class Increment; +enum class TemporalOverflow; +enum class TemporalRoundingMode; +enum class TemporalUnit; + +#ifdef DEBUG +/** + * IsValidTime ( hour, minute, second, millisecond, microsecond, nanosecond ) + */ +bool IsValidTime(const PlainTime& time); + +/** + * IsValidTime ( hour, minute, second, millisecond, microsecond, nanosecond ) + */ +bool IsValidTime(double hour, double minute, double second, double millisecond, + double microsecond, double nanosecond); +#endif + +/** + * IsValidTime ( hour, minute, second, millisecond, microsecond, nanosecond ) + */ +bool ThrowIfInvalidTime(JSContext* cx, const PlainTime& time); + +/** + * IsValidTime ( hour, minute, second, millisecond, microsecond, nanosecond ) + */ +bool ThrowIfInvalidTime(JSContext* cx, double hour, double minute, + double second, double millisecond, double microsecond, + double nanosecond); + +/** + * CreateTemporalTime ( hour, minute, second, millisecond, microsecond, + * nanosecond [ , newTarget ] ) + */ +PlainTimeObject* CreateTemporalTime(JSContext* cx, const PlainTime& time); + +/** + * ToTemporalTime ( item [ , overflow ] ) + */ +bool ToTemporalTime(JSContext* cx, JS::Handle<JS::Value> item, + PlainTime* result); + +/** + * AddTime ( hour, minute, second, millisecond, microsecond, nanosecond, hours, + * minutes, seconds, milliseconds, microseconds, nanoseconds ) + */ +bool AddTime(JSContext* cx, const PlainTime& time, const Duration& duration, + PlainTime* result, double* daysResult); + +/** + * DifferenceTime ( h1, min1, s1, ms1, mus1, ns1, h2, min2, s2, ms2, mus2, ns2 ) + */ +TimeDuration DifferenceTime(const PlainTime& time1, const PlainTime& time2); + +struct TimeRecord final { + double hour = 0; + double minute = 0; + double second = 0; + double millisecond = 0; + double microsecond = 0; + double nanosecond = 0; +}; + +/** + * ToTemporalTimeRecord ( temporalTimeLike [ , completeness ] ) + */ +bool ToTemporalTimeRecord(JSContext* cx, JS::Handle<JSObject*> temporalTimeLike, + TimeRecord* result); + +/** + * RegulateTime ( hour, minute, second, millisecond, microsecond, nanosecond, + * overflow ) + */ +bool RegulateTime(JSContext* cx, const TimeRecord& time, + TemporalOverflow overflow, PlainTime* result); + +/** + * CompareTemporalTime ( h1, min1, s1, ms1, mus1, ns1, h2, min2, s2, ms2, mus2, + * ns2 ) + */ +int32_t CompareTemporalTime(const PlainTime& one, const PlainTime& two); + +struct BalancedTime final { + int32_t days = 0; + PlainTime time; +}; + +/** + * BalanceTime ( hour, minute, second, millisecond, microsecond, nanosecond ) + */ +BalancedTime BalanceTime(const PlainTime& time, int64_t nanoseconds); + +struct RoundedTime final { + int64_t days = 0; + PlainTime time; +}; + +/** + * RoundTime ( hour, minute, second, millisecond, microsecond, nanosecond, + * increment, unit, roundingMode [ , dayLengthNs ] ) + */ +RoundedTime RoundTime(const PlainTime& time, Increment increment, + TemporalUnit unit, TemporalRoundingMode roundingMode); + +/** + * RoundTime ( hour, minute, second, millisecond, microsecond, nanosecond, + * increment, unit, roundingMode [ , dayLengthNs ] ) + */ +RoundedTime RoundTime(const PlainTime& time, Increment increment, + TemporalUnit unit, TemporalRoundingMode roundingMode, + const InstantSpan& dayLengthNs); + +} /* namespace js::temporal */ + +#endif /* builtin_temporal_PlainTime_h */ |