blob: a3b8292d9a362c8671733c9538c704567fd384dd [file] [log] [blame]
/*
* Copyright (C) 2009 Google Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "DateComponents.h"
#include "ParsingUtilities.h"
#include <limits.h>
#include <wtf/ASCIICType.h>
#include <wtf/DateMath.h>
#include <wtf/MathExtras.h>
#include <wtf/text/StringConcatenateNumbers.h>
#include <wtf/text/StringParsingBuffer.h>
namespace WebCore {
// HTML defines minimum week of year is one.
static constexpr int minimumWeekNumber = 1;
// HTML defines maximum week of year is 53.
static constexpr int maximumWeekNumber = 53;
static constexpr int maximumMonthInMaximumYear = 8; // This is September, since months are 0 based.
static constexpr int maximumDayInMaximumMonth = 13;
static constexpr int maximumWeekInMaximumYear = 37; // The week of 275760-09-13
static constexpr int daysInMonth[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
static bool isLeapYear(int year)
{
if (year % 4)
return false;
if (!(year % 400))
return true;
if (!(year % 100))
return false;
return true;
}
// 'month' is 0-based.
static int maxDayOfMonth(int year, int month)
{
if (month != 1) // February?
return daysInMonth[month];
return isLeapYear(year) ? 29 : 28;
}
// 'month' is 0-based.
static int dayOfWeek(int year, int month, int day)
{
int shiftedMonth = month + 2;
// 2:January, 3:Feburuary, 4:March, ...
// Zeller's congruence
if (shiftedMonth <= 3) {
shiftedMonth += 12;
year--;
}
// 4:March, ..., 14:January, 15:February
int highYear = year / 100;
int lowYear = year % 100;
// We add 6 to make the result Sunday-origin.
int result = (day + 13 * shiftedMonth / 5 + lowYear + lowYear / 4 + highYear / 4 + 5 * highYear + 6) % 7;
return result;
}
int DateComponents::maxWeekNumberInYear() const
{
int day = dayOfWeek(m_year, 0, 1); // January 1.
return day == Thursday || (day == Wednesday && isLeapYear(m_year)) ? maximumWeekNumber : maximumWeekNumber - 1;
}
template<typename CharacterType> static unsigned countDigits(StringParsingBuffer<CharacterType> buffer)
{
auto begin = buffer.position();
skipWhile<isASCIIDigit>(buffer);
return buffer.position() - begin;
}
// Differences from parseInteger<int>: Takes StringParsingBuffer. Does not allow leading or trailing spaces. Does not allow leading "+".
template<typename CharacterType> static std::optional<int> parseInt(StringParsingBuffer<CharacterType>& buffer, unsigned maximumNumberOfDigitsToParse)
{
if (maximumNumberOfDigitsToParse > buffer.lengthRemaining() || !maximumNumberOfDigitsToParse)
return std::nullopt;
// We don't need to handle negative numbers for ISO 8601.
int value = 0;
unsigned digitsRemaining = 0;
while (digitsRemaining < maximumNumberOfDigitsToParse) {
if (!isASCIIDigit(*buffer))
return std::nullopt;
int digit = *buffer - '0';
if (value > (INT_MAX - digit) / 10) // Check for overflow.
return std::nullopt;
value = value * 10 + digit;
++digitsRemaining;
++buffer;
}
return value;
}
template<typename CharacterType> static std::optional<int> parseIntWithinLimits(StringParsingBuffer<CharacterType>& buffer, unsigned maximumNumberOfDigitsToParse, int minimumValue, int maximumValue)
{
auto value = parseInt(buffer, maximumNumberOfDigitsToParse);
if (!(value && *value >= minimumValue && *value <= maximumValue))
return std::nullopt;
return value;
}
// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#months
template<typename CharacterType> bool DateComponents::parseYear(StringParsingBuffer<CharacterType>& buffer)
{
unsigned digitsLength = countDigits(buffer);
// Needs at least 4 digits according to the standard.
if (digitsLength < 4)
return false;
auto year = parseIntWithinLimits(buffer, digitsLength, minimumYear(), maximumYear());
if (!year)
return false;
m_year = *year;
return true;
}
static bool withinHTMLDateLimits(int year, int month)
{
if (year < DateComponents::minimumYear())
return false;
if (year < DateComponents::maximumYear())
return true;
return month <= maximumMonthInMaximumYear;
}
static bool withinHTMLDateLimits(int year, int month, int monthDay)
{
if (year < DateComponents::minimumYear())
return false;
if (year < DateComponents::maximumYear())
return true;
if (month < maximumMonthInMaximumYear)
return true;
return monthDay <= maximumDayInMaximumMonth;
}
static bool withinHTMLDateLimits(int year, int month, int monthDay, int hour, int minute, int second, int millisecond)
{
if (year < DateComponents::minimumYear())
return false;
if (year < DateComponents::maximumYear())
return true;
if (month < maximumMonthInMaximumYear)
return true;
if (monthDay < maximumDayInMaximumMonth)
return true;
if (monthDay > maximumDayInMaximumMonth)
return false;
// (year, month, monthDay) = (maximumYear, maximumMonthInMaximumYear, maximumDayInMaximumMonth)
return !hour && !minute && !second && !millisecond;
}
template<typename F> static std::optional<DateComponents> createFromString(StringView source, F&& parseFunction)
{
if (source.isEmpty())
return std::nullopt;
return readCharactersForParsing(source, [&](auto buffer) -> std::optional<DateComponents> {
DateComponents date;
if (!parseFunction(buffer, date) || !buffer.atEnd())
return std::nullopt;
return date;
});
}
std::optional<DateComponents> DateComponents::fromParsingMonth(StringView source)
{
return createFromString(source, [] (auto& buffer, auto& date) {
return date.parseMonth(buffer);
});
}
std::optional<DateComponents> DateComponents::fromParsingDate(StringView source)
{
return createFromString(source, [] (auto& buffer, auto& date) {
return date.parseDate(buffer);
});
}
std::optional<DateComponents> DateComponents::fromParsingWeek(StringView source)
{
return createFromString(source, [] (auto& buffer, auto& date) {
return date.parseWeek(buffer);
});
}
std::optional<DateComponents> DateComponents::fromParsingTime(StringView source)
{
return createFromString(source, [] (auto& buffer, auto& date) {
return date.parseTime(buffer);
});
}
std::optional<DateComponents> DateComponents::fromParsingDateTimeLocal(StringView source)
{
return createFromString(source, [] (auto& buffer, auto& date) {
return date.parseDateTimeLocal(buffer);
});
}
bool DateComponents::addDay(int dayDiff)
{
ASSERT(m_monthDay);
int day = m_monthDay + dayDiff;
if (day > maxDayOfMonth(m_year, m_month)) {
day = m_monthDay;
int year = m_year;
int month = m_month;
int maxDay = maxDayOfMonth(year, month);
for (; dayDiff > 0; --dayDiff) {
++day;
if (day > maxDay) {
day = 1;
++month;
if (month >= 12) { // month is 0-origin.
month = 0;
++year;
}
maxDay = maxDayOfMonth(year, month);
}
}
if (!withinHTMLDateLimits(year, month, day))
return false;
m_year = year;
m_month = month;
} else if (day < 1) {
int month = m_month;
int year = m_year;
day = m_monthDay;
for (; dayDiff < 0; ++dayDiff) {
--day;
if (day < 1) {
--month;
if (month < 0) {
month = 11;
--year;
}
day = maxDayOfMonth(year, month);
}
}
if (!withinHTMLDateLimits(year, month, day))
return false;
m_year = year;
m_month = month;
} else {
if (!withinHTMLDateLimits(m_year, m_month, day))
return false;
}
m_monthDay = day;
return true;
}
bool DateComponents::addMinute(int minute)
{
// This function is used to adjust timezone offset. So m_year, m_month,
// m_monthDay have values between the lower and higher limits.
ASSERT(withinHTMLDateLimits(m_year, m_month, m_monthDay));
int carry;
// minute can be negative or greater than 59.
minute += m_minute;
if (minute > 59) {
carry = minute / 60;
minute = minute % 60;
} else if (minute < 0) {
carry = (59 - minute) / 60;
minute += carry * 60;
carry = -carry;
ASSERT(minute >= 0 && minute <= 59);
} else {
if (!withinHTMLDateLimits(m_year, m_month, m_monthDay, m_hour, minute, m_second, m_millisecond))
return false;
m_minute = minute;
return true;
}
int hour = m_hour + carry;
if (hour > 23) {
carry = hour / 24;
hour = hour % 24;
} else if (hour < 0) {
carry = (23 - hour) / 24;
hour += carry * 24;
carry = -carry;
ASSERT(hour >= 0 && hour <= 23);
} else {
if (!withinHTMLDateLimits(m_year, m_month, m_monthDay, hour, minute, m_second, m_millisecond))
return false;
m_minute = minute;
m_hour = hour;
return true;
}
if (!addDay(carry))
return false;
if (!withinHTMLDateLimits(m_year, m_month, m_monthDay, hour, minute, m_second, m_millisecond))
return false;
m_minute = minute;
m_hour = hour;
return true;
}
// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#time-zones
// Parses a timezone part, and adjust year, month, monthDay, hour, minute, second, millisecond.
template<typename CharacterType> bool DateComponents::parseTimeZone(StringParsingBuffer<CharacterType>& buffer)
{
if (skipExactly(buffer, 'Z'))
return true;
bool minus;
if (skipExactly(buffer, '+'))
minus = false;
else if (skipExactly(buffer, '-'))
minus = true;
else
return false;
auto hour = parseIntWithinLimits(buffer, 2, 0, 23);
if (!hour)
return false;
if (!skipExactly(buffer, ':'))
return false;
auto minute = parseIntWithinLimits(buffer, 2, 0, 59);
if (!minute)
return false;
if (minus) {
*hour = -*hour;
*minute = -*minute;
}
// Subtract the timezone offset.
if (!addMinute(-(*hour * 60 + *minute)))
return false;
return true;
}
// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#months
template<typename CharacterType> bool DateComponents::parseMonth(StringParsingBuffer<CharacterType>& buffer)
{
if (!parseYear(buffer))
return false;
if (!skipExactly(buffer, '-'))
return false;
auto month = parseIntWithinLimits(buffer, 2, 1, 12);
if (!month)
return false;
--*month;
if (!withinHTMLDateLimits(m_year, *month))
return false;
m_month = *month;
m_type = DateComponentsType::Month;
return true;
}
// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#dates
template<typename CharacterType> bool DateComponents::parseDate(StringParsingBuffer<CharacterType>& buffer)
{
if (!parseMonth(buffer))
return false;
if (!skipExactly(buffer, '-'))
return false;
auto day = parseIntWithinLimits(buffer, 2, 1, maxDayOfMonth(m_year, m_month));
if (!day)
return false;
if (!withinHTMLDateLimits(m_year, m_month, *day))
return false;
m_monthDay = *day;
m_type = DateComponentsType::Date;
return true;
}
// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#weeks
template<typename CharacterType> bool DateComponents::parseWeek(StringParsingBuffer<CharacterType>& buffer)
{
if (!parseYear(buffer))
return false;
if (!skipExactly(buffer, '-'))
return false;
if (!skipExactly(buffer, 'W'))
return false;
auto week = parseIntWithinLimits(buffer, 2, minimumWeekNumber, maxWeekNumberInYear());
if (!week)
return false;
if (m_year == maximumYear() && *week > maximumWeekInMaximumYear)
return false;
m_week = *week;
m_type = DateComponentsType::Week;
return true;
}
// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#times
template<typename CharacterType> bool DateComponents::parseTime(StringParsingBuffer<CharacterType>& buffer)
{
auto hour = parseIntWithinLimits(buffer, 2, 0, 23);
if (!hour)
return false;
if (!skipExactly(buffer, ':'))
return false;
auto minute = parseIntWithinLimits(buffer, 2, 0, 59);
if (!minute)
return false;
// Optional second part.
// Do not return with false because the part is optional.
std::optional<int> second;
std::optional<int> millisecond;
auto temporaryBuffer = buffer;
if (skipExactly(temporaryBuffer, ':')) {
second = parseIntWithinLimits(temporaryBuffer, 2, 0, 59);
if (second) {
// Only after successfully parsing and validating 'second', do we increment the real buffer.
buffer += temporaryBuffer.position() - buffer.position();
// Optional fractional second part.
if (skipExactly(temporaryBuffer, '.')) {
unsigned digitsLength = countDigits(temporaryBuffer);
if (digitsLength > 0) {
if (digitsLength == 1) {
millisecond = parseInt(temporaryBuffer, 1);
*millisecond *= 100;
} else if (digitsLength == 2) {
millisecond = parseInt(temporaryBuffer, 2);
*millisecond *= 10;
} else if (digitsLength == 3)
millisecond = parseInt(temporaryBuffer, 3);
else
return false;
// Due to the countDigits above, the parseInt calls should all be successful.
ASSERT(millisecond);
// Only after successfully parsing and validating 'millisecond', do we increment the real buffer.
buffer += 1 + digitsLength;
}
}
}
}
m_hour = *hour;
m_minute = *minute;
m_second = second.value_or(0);
m_millisecond = millisecond.value_or(0);
m_type = DateComponentsType::Time;
return true;
}
// Gecko allows both 'T' and a space as datetime-local separator (see https://github.com/whatwg/html/issues/2276).
// WPT tests also expect this behavior.
template<typename CharacterType> static bool isDateTimeLocalSeparator(CharacterType c)
{
return c == 'T' || c == ' ';
}
// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#local-dates-and-times
template<typename CharacterType> bool DateComponents::parseDateTimeLocal(StringParsingBuffer<CharacterType>& buffer)
{
if (!parseDate(buffer))
return false;
if (!skipExactly<isDateTimeLocalSeparator>(buffer))
return false;
if (!parseTime(buffer))
return false;
if (!withinHTMLDateLimits(m_year, m_month, m_monthDay, m_hour, m_minute, m_second, m_millisecond))
return false;
m_type = DateComponentsType::DateTimeLocal;
return true;
}
static inline double positiveFmod(double value, double divider)
{
double remainder = fmod(value, divider);
return remainder < 0 ? remainder + divider : remainder;
}
template<typename F> static std::optional<DateComponents> createFromTimeOffset(double timeOffset, F&& function)
{
DateComponents result;
if (!function(result, timeOffset))
return std::nullopt;
return result;
}
std::optional<DateComponents> DateComponents::fromMillisecondsSinceEpochForDate(double ms)
{
return createFromTimeOffset(ms, [] (auto& date, auto ms) {
return date.setMillisecondsSinceEpochForDate(ms);
});
}
std::optional<DateComponents> DateComponents::fromMillisecondsSinceEpochForDateTimeLocal(double ms)
{
return createFromTimeOffset(ms, [] (auto& date, auto ms) {
return date.setMillisecondsSinceEpochForDateTimeLocal(ms);
});
}
std::optional<DateComponents> DateComponents::fromMillisecondsSinceEpochForMonth(double ms)
{
return createFromTimeOffset(ms, [] (auto& date, auto ms) {
return date.setMillisecondsSinceEpochForMonth(ms);
});
}
std::optional<DateComponents> DateComponents::fromMillisecondsSinceEpochForWeek(double ms)
{
return createFromTimeOffset(ms, [] (auto& date, auto ms) {
return date.setMillisecondsSinceEpochForWeek(ms);
});
}
std::optional<DateComponents> DateComponents::fromMillisecondsSinceMidnight(double ms)
{
return createFromTimeOffset(ms, [] (auto& date, auto ms) {
return date.setMillisecondsSinceMidnight(ms);
});
}
std::optional<DateComponents> DateComponents::fromMonthsSinceEpoch(double months)
{
return createFromTimeOffset(months, [] (auto& date, auto months) {
return date.setMonthsSinceEpoch(months);
});
}
void DateComponents::setMillisecondsSinceMidnightInternal(double msInDay)
{
ASSERT(msInDay >= 0 && msInDay < msPerDay);
m_millisecond = static_cast<int>(fmod(msInDay, msPerSecond));
double value = floor(msInDay / msPerSecond);
m_second = static_cast<int>(fmod(value, secondsPerMinute));
value = floor(value / secondsPerMinute);
m_minute = static_cast<int>(fmod(value, minutesPerHour));
m_hour = static_cast<int>(value / minutesPerHour);
}
bool DateComponents::setMillisecondsSinceEpochForDateInternal(double ms)
{
m_year = msToYear(ms);
int yearDay = dayInYear(ms, m_year);
m_month = monthFromDayInYear(yearDay, isLeapYear(m_year));
m_monthDay = dayInMonthFromDayInYear(yearDay, isLeapYear(m_year));
return true;
}
bool DateComponents::setMillisecondsSinceEpochForDate(double ms)
{
m_type = DateComponentsType::Invalid;
if (!std::isfinite(ms))
return false;
if (!setMillisecondsSinceEpochForDateInternal(round(ms)))
return false;
if (!withinHTMLDateLimits(m_year, m_month, m_monthDay))
return false;
m_type = DateComponentsType::Date;
return true;
}
bool DateComponents::setMillisecondsSinceEpochForDateTimeLocal(double ms)
{
m_type = DateComponentsType::Invalid;
if (!std::isfinite(ms))
return false;
ms = round(ms);
setMillisecondsSinceMidnightInternal(positiveFmod(ms, msPerDay));
if (!setMillisecondsSinceEpochForDateInternal(ms))
return false;
if (!withinHTMLDateLimits(m_year, m_month, m_monthDay, m_hour, m_minute, m_second, m_millisecond))
return false;
m_type = DateComponentsType::DateTimeLocal;
return true;
}
bool DateComponents::setMillisecondsSinceEpochForMonth(double ms)
{
m_type = DateComponentsType::Invalid;
if (!std::isfinite(ms))
return false;
if (!setMillisecondsSinceEpochForDateInternal(round(ms)))
return false;
if (!withinHTMLDateLimits(m_year, m_month))
return false;
m_type = DateComponentsType::Month;
return true;
}
bool DateComponents::setMillisecondsSinceMidnight(double ms)
{
m_type = DateComponentsType::Invalid;
if (!std::isfinite(ms))
return false;
setMillisecondsSinceMidnightInternal(positiveFmod(round(ms), msPerDay));
m_type = DateComponentsType::Time;
return true;
}
bool DateComponents::setMonthsSinceEpoch(double months)
{
if (!std::isfinite(months))
return false;
months = round(months);
double doubleMonth = positiveFmod(months, 12);
double doubleYear = 1970 + (months - doubleMonth) / 12;
if (doubleYear < minimumYear() || maximumYear() < doubleYear)
return false;
int year = static_cast<int>(doubleYear);
int month = static_cast<int>(doubleMonth);
if (!withinHTMLDateLimits(year, month))
return false;
m_year = year;
m_month = month;
m_type = DateComponentsType::Month;
return true;
}
// Offset from January 1st to Monday of the ISO 8601's first week.
// ex. If January 1st is Friday, such Monday is 3 days later. Returns 3.
static int offsetTo1stWeekStart(int year)
{
int offsetTo1stWeekStart = 1 - dayOfWeek(year, 0, 1);
if (offsetTo1stWeekStart <= -4)
offsetTo1stWeekStart += 7;
return offsetTo1stWeekStart;
}
bool DateComponents::setMillisecondsSinceEpochForWeek(double ms)
{
m_type = DateComponentsType::Invalid;
if (!std::isfinite(ms))
return false;
ms = round(ms);
m_year = msToYear(ms);
if (m_year < minimumYear() || m_year > maximumYear())
return false;
int yearDay = dayInYear(ms, m_year);
int offset = offsetTo1stWeekStart(m_year);
if (yearDay < offset) {
// The day belongs to the last week of the previous year.
m_year--;
if (m_year <= minimumYear())
return false;
m_week = maxWeekNumberInYear();
} else {
m_week = ((yearDay - offset) / 7) + 1;
if (m_week > maxWeekNumberInYear()) {
m_year++;
m_week = 1;
}
if (m_year > maximumYear() || (m_year == maximumYear() && m_week > maximumWeekInMaximumYear))
return false;
}
m_type = DateComponentsType::Week;
return true;
}
double DateComponents::millisecondsSinceEpochForTime() const
{
ASSERT(m_type == DateComponentsType::Time || m_type == DateComponentsType::DateTimeLocal);
return ((m_hour * minutesPerHour + m_minute) * secondsPerMinute + m_second) * msPerSecond + m_millisecond;
}
double DateComponents::millisecondsSinceEpoch() const
{
switch (m_type) {
case DateComponentsType::Date:
return dateToDaysFrom1970(m_year, m_month, m_monthDay) * msPerDay;
case DateComponentsType::DateTimeLocal:
return dateToDaysFrom1970(m_year, m_month, m_monthDay) * msPerDay + millisecondsSinceEpochForTime();
case DateComponentsType::Month:
return dateToDaysFrom1970(m_year, m_month, 1) * msPerDay;
case DateComponentsType::Time:
return millisecondsSinceEpochForTime();
case DateComponentsType::Week:
return (dateToDaysFrom1970(m_year, 0, 1) + offsetTo1stWeekStart(m_year) + (m_week - 1) * 7) * msPerDay;
case DateComponentsType::Invalid:
break;
}
ASSERT_NOT_REACHED();
return invalidMilliseconds();
}
double DateComponents::monthsSinceEpoch() const
{
ASSERT(m_type == DateComponentsType::Month);
return (m_year - 1970) * 12 + m_month;
}
String DateComponents::toStringForTime(SecondFormat format) const
{
ASSERT(m_type == DateComponentsType::DateTimeLocal || m_type == DateComponentsType::Time);
SecondFormat effectiveFormat = format;
if (m_millisecond)
effectiveFormat = SecondFormat::Millisecond;
else if (format == SecondFormat::None && m_second)
effectiveFormat = SecondFormat::Second;
switch (effectiveFormat) {
default:
ASSERT_NOT_REACHED();
#if !ASSERT_ENABLED
FALLTHROUGH; // To None.
#endif
case SecondFormat::None:
return makeString(pad('0', 2, m_hour), ':', pad('0', 2, m_minute));
case SecondFormat::Second:
return makeString(pad('0', 2, m_hour), ':', pad('0', 2, m_minute), ':', pad('0', 2, m_second));
case SecondFormat::Millisecond: {
auto resultWithoutMilliseconds = makeString(pad('0', 2, m_hour), ':', pad('0', 2, m_minute), ':', pad('0', 2, m_second), '.');
if (!(m_millisecond % 100))
return makeString(resultWithoutMilliseconds, m_millisecond / 100);
if (!(m_millisecond % 10))
return makeString(resultWithoutMilliseconds, pad('0', 2, m_millisecond / 10));
return makeString(resultWithoutMilliseconds, pad('0', 3, m_millisecond));
}
}
}
String DateComponents::toString(SecondFormat format) const
{
switch (m_type) {
case DateComponentsType::Date:
return makeString(pad('0', 4, m_year), '-', pad('0', 2, m_month + 1), '-', pad('0', 2, m_monthDay));
case DateComponentsType::DateTimeLocal:
return makeString(pad('0', 4, m_year), '-', pad('0', 2, m_month + 1), '-', pad('0', 2, m_monthDay), 'T', toStringForTime(format));
case DateComponentsType::Month:
return makeString(pad('0', 4, m_year), '-', pad('0', 2, m_month + 1));
case DateComponentsType::Time:
return toStringForTime(format);
case DateComponentsType::Week:
return makeString(pad('0', 4, m_year), "-W", pad('0', 2, m_week));
case DateComponentsType::Invalid:
break;
}
ASSERT_NOT_REACHED();
return "(Invalid DateComponents)"_str;
}
} // namespace WebCore