lib/src/fixed_datetime_formatter.dart - convert.git - Git at Google

 // Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 /// A formatter and parser for [DateTime] in a fixed format [String] pattern.
 ///
 /// For example, calling
 /// `FixedDateTimeCodec('YYYYMMDDhhmmss').decodeToLocal('19960425050322')` has
 /// the same result as calling `DateTime(1996, 4, 25, 5, 3, 22)`.
 ///
 /// The allowed characters are
 /// * `Y`	for “calendar year”
 /// * `M`	for “calendar month”
 /// * `D`	for “calendar day”
 /// * `E`	for “decade”
 /// * `C`	for “century”
 /// * `h`	for “clock hour”
 /// * `m`	for “clock minute”
 /// * `s`	for “clock second”
 /// * `S`	for “fractional clock second”
 ///
 /// Non-allowed characters in the format [pattern] are ignored when decoding a
 /// string, in this case `YYYY kiwi MM` is the same format string as
 /// `YYYY------MM`. When encoding a datetime, the non-format characters are in
 /// the output verbatim.
 ///
 /// Note: this class differs from [DateFormat] in that here, the characters are
 /// treated literally, i.e. the format string `YYY` matching `996` would result in
 /// the same as calling `DateTime(996)`. [DateFormat] on the other hand uses the
 /// specification in https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table,
 /// the format string (or "skeleton") `YYY` specifies only the padding, so
 /// `1996` would be a valid match. This limits it's use to format strings
 /// containing delimiters, as the parser would not know how many digits to take
 /// otherwise.
 class FixedDateTimeFormatter {
   static const _powersOfTen = [0, 1, 10, 100, 1000, 10000, 100000];
   static const _validFormatCharacters = [
     _yearCode,
     _monthCode,
     _dayCode,
     _decadeCode,
     _centuryCode,
     _hourCode,
     _minuteCode,
     _secondCode,
     _fractionSecondCode,
   ];
   static const _yearCode = 0x59; /*Y*/
   static const _monthCode = 0x4D; /*M*/
   static const _dayCode = 0x44; /*D*/
   static const _decadeCode = 0x45; /*E*/
   static const _centuryCode = 0x43; /*C*/
   static const _hourCode = 0x68; /*H*/
   static const _minuteCode = 0x6D; /*m*/
   static const _secondCode = 0x73; /*s*/
   static const _fractionSecondCode = 0x53; /*S*/

   ///Store publicly in case the user wants to retrieve it
   final String pattern;

   ///Whether to use UTC or the local time zone
   final bool isUtc;
   final _blocks = _ParsedFormatBlocks();

   /// Creates a new [FixedDateTimeFormatter] with the provided [pattern].
   ///
   /// The [pattern] interprets the characters mentioned in
   /// [FixedDateTimeFormatter] to represent fields of a `DateTime` value. Other
   /// characters are not special. If [isUtc] is set to false, the DateTime is
   /// constructed with respect to the local timezone.
   ///
   /// There must at most be one sequence of each special character to ensure a
   /// single source of truth when constructing the [DateTime], so a pattern of
   /// `"CCCC-MM-DD, CC"` is invalid, because it has two separate `C` sequences.
   FixedDateTimeFormatter(this.pattern, {this.isUtc = true}) {
     int? current;
     var start = 0;
     var characters = pattern.codeUnits;
     for (var i = 0; i < characters.length; i++) {
       var char = characters[i];
       if (current != char) {
         _blocks.saveBlock(current, start, i);
         if (_validFormatCharacters.contains(char)) {
           var hasSeenBefore = _blocks.formatCharacters.indexOf(char);
           if (hasSeenBefore > -1) {
             throw FormatException(
                 "Pattern contains more than one '$char' block.\n"
                 "Previous occurrence at index ${_blocks.starts[hasSeenBefore]}",
                 pattern,
                 i);
           } else {
             start = i;
             current = char;
           }
         } else {
           current = null;
         }
       }
     }
     _blocks.saveBlock(current, start, pattern.length);
   }

   /// Convert [DateTime] to a [String] exactly as specified by the [pattern].
   String encode(DateTime datetime) {
     var buffer = StringBuffer();
     for (var i = 0; i < _blocks.length; i++) {
       var start = _blocks.starts[i];
       var end = _blocks.ends[i];
       var length = end - start;

       var previousEnd = i > 0 ? _blocks.ends[i - 1] : 0;
       if (previousEnd < start) {
         buffer.write(pattern.substring(previousEnd, start));
       }
       var formatCharacter = _blocks.formatCharacters[i];
       var number = _extractNumFromDateTime(
         formatCharacter,
         datetime,
       ).toString();
       if (number.length > length) {
         if (formatCharacter == _fractionSecondCode) {
           //Special case, as we want fractional seconds to be the leading digits
           number = number.substring(length);
         } else {
           number = number.substring(number.length - length);
         }
       } else if (number.length < length) {
         number = number.padLeft(length, '0');
       }
       buffer.write(number);
     }
     if (_blocks.length > 0) {
       var lastEnd = _blocks.ends.last;
       if (lastEnd < pattern.length) {
         buffer.write(pattern.substring(lastEnd, pattern.length));
       }
     }
     return buffer.toString();
   }

   int _extractNumFromDateTime(int? formatChar, DateTime dateTime) {
     switch (formatChar) {
       case _yearCode:
         return dateTime.year;
       case _centuryCode:
         return (dateTime.year / 100).floor();
       case _decadeCode:
         return (dateTime.year / 10).floor();
       case _monthCode:
         return dateTime.month;
       case _dayCode:
         return dateTime.day;
       case _hourCode:
         return dateTime.hour;
       case _minuteCode:
         return dateTime.minute;
       case _secondCode:
         return dateTime.second;
       case _fractionSecondCode:
         return dateTime.microsecond;
     }
     throw AssertionError("Unreachable, the key is checked in the constructor");
   }

   /// Parse a string [formattedDateTime] to a local [DateTime] as specified in the
   /// [pattern], substituting missing values with a default. Throws an exception
   /// on failure to parse.
   DateTime decode(String formattedDateTime) {
     return _decode(formattedDateTime, isUtc, true);
   }

   /// Same as [decode], but will not throw on parsing erros, instead using
   /// the default value as if the format char was not present in the [pattern].
   DateTime tryDecode(String formattedDateTime) {
     return _decode(formattedDateTime, isUtc, false);
   }

   DateTime _decode(
     String formattedDateTime,
     bool isUtc,
     bool throwOnError,
   ) {
     var characters = formattedDateTime.codeUnits;
     var year = 0;
     var century = 0;
     var decade = 0;
     var month = 1;
     var day = 1;
     var hour = 0;
     var minute = 0;
     var second = 0;
     var microsecond = 0;
     for (int i = 0; i < _blocks.length; i++) {
       var char = _blocks.formatCharacters[i];
       var number = _extractNumFromString(characters, i, throwOnError);
       if (number != null) {
         if (char == _fractionSecondCode) {
           //Special case, as we want fractional seconds to be the leading digits
           var numberLength = _blocks.ends[i] - _blocks.starts[i];
           number *= _powersOfTen[6 - numberLength + 1];
         }
         switch (char) {
           case _yearCode:
             year = number;
             break;
           case _centuryCode:
             century = number;
             break;
           case _decadeCode:
             decade = number;
             break;
           case _monthCode:
             month = number;
             break;
           case _dayCode:
             day = number;
             break;
           case _hourCode:
             hour = number;
             break;
           case _minuteCode:
             minute = number;
             break;
           case _secondCode:
             second = number;
             break;
           case _fractionSecondCode:
             microsecond = number;
             break;
         }
       }
     }
     var totalYear = year + 100 * century + 10 * decade;
     if (isUtc) {
       return DateTime.utc(
         totalYear,
         month,
         day,
         hour,
         minute,
         second,
         0,
         microsecond,
       );
     } else {
       return DateTime(
         totalYear,
         month,
         day,
         hour,
         minute,
         second,
         0,
         microsecond,
       );
     }
   }

   int? _extractNumFromString(
     List<int> characters,
     int index,
     bool throwOnError,
   ) {
     var parsed = tryParse(
       characters,
       _blocks.starts[index],
       _blocks.ends[index],
     );
     if (parsed == null && throwOnError) {
       throw FormatException(
           '${String.fromCharCodes(characters)} should only contain digits');
     }
     return parsed;
   }

   int? tryParse(List<int> characters, int start, int end) {
     int result = 0;
     for (var i = start; i < end; i++) {
       var digit = characters[i] ^ 0x30;
       if (digit <= 9) {
         result = result * 10 + digit;
       } else {
         return null;
       }
     }
     return result;
   }
 }

 class _ParsedFormatBlocks {
   final formatCharacters = <int>[];
   final starts = <int>[];
   final ends = <int>[];

   _ParsedFormatBlocks();

   int get length => formatCharacters.length;

   void saveBlock(int? char, int start, int end) {
     if (char != null) {
       formatCharacters.add(char);
       starts.add(start);
       ends.add(end);
     }
   }
 }
	// Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	/// A formatter and parser for [DateTime] in a fixed format [String] pattern.
	///
	/// For example, calling
	/// `FixedDateTimeCodec('YYYYMMDDhhmmss').decodeToLocal('19960425050322')` has
	/// the same result as calling `DateTime(1996, 4, 25, 5, 3, 22)`.
	///
	/// The allowed characters are
	/// * `Y` for “calendar year”
	/// * `M` for “calendar month”
	/// * `D` for “calendar day”
	/// * `E` for “decade”
	/// * `C` for “century”
	/// * `h` for “clock hour”
	/// * `m` for “clock minute”
	/// * `s` for “clock second”
	/// * `S` for “fractional clock second”
	///
	/// Non-allowed characters in the format [pattern] are ignored when decoding a
	/// string, in this case `YYYY kiwi MM` is the same format string as
	/// `YYYY------MM`. When encoding a datetime, the non-format characters are in
	/// the output verbatim.
	///
	/// Note: this class differs from [DateFormat] in that here, the characters are
	/// treated literally, i.e. the format string `YYY` matching `996` would result in
	/// the same as calling `DateTime(996)`. [DateFormat] on the other hand uses the
	/// specification in https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table,
	/// the format string (or "skeleton") `YYY` specifies only the padding, so
	/// `1996` would be a valid match. This limits it's use to format strings
	/// containing delimiters, as the parser would not know how many digits to take
	/// otherwise.
	class FixedDateTimeFormatter {
	static const _powersOfTen = [0, 1, 10, 100, 1000, 10000, 100000];
	static const _validFormatCharacters = [
	_yearCode,
	_monthCode,
	_dayCode,
	_decadeCode,
	_centuryCode,
	_hourCode,
	_minuteCode,
	_secondCode,
	_fractionSecondCode,
	];
	static const _yearCode = 0x59; /Y/
	static const _monthCode = 0x4D; /M/
	static const _dayCode = 0x44; /D/
	static const _decadeCode = 0x45; /E/
	static const _centuryCode = 0x43; /C/
	static const _hourCode = 0x68; /H/
	static const _minuteCode = 0x6D; /m/
	static const _secondCode = 0x73; /s/
	static const _fractionSecondCode = 0x53; /S/

	///Store publicly in case the user wants to retrieve it
	final String pattern;

	///Whether to use UTC or the local time zone
	final bool isUtc;
	final _blocks = _ParsedFormatBlocks();

	/// Creates a new [FixedDateTimeFormatter] with the provided [pattern].
	///
	/// The [pattern] interprets the characters mentioned in
	/// [FixedDateTimeFormatter] to represent fields of a `DateTime` value. Other
	/// characters are not special. If [isUtc] is set to false, the DateTime is
	/// constructed with respect to the local timezone.
	///
	/// There must at most be one sequence of each special character to ensure a
	/// single source of truth when constructing the [DateTime], so a pattern of
	/// `"CCCC-MM-DD, CC"` is invalid, because it has two separate `C` sequences.
	FixedDateTimeFormatter(this.pattern, {this.isUtc = true}) {
	int? current;
	var start = 0;
	var characters = pattern.codeUnits;
	for (var i = 0; i < characters.length; i++) {
	var char = characters[i];
	if (current != char) {
	_blocks.saveBlock(current, start, i);
	if (_validFormatCharacters.contains(char)) {
	var hasSeenBefore = _blocks.formatCharacters.indexOf(char);
	if (hasSeenBefore > -1) {
	throw FormatException(
	"Pattern contains more than one '$char' block.\n"
	"Previous occurrence at index ${_blocks.starts[hasSeenBefore]}",
	pattern,
	i);
	} else {
	start = i;
	current = char;
	}
	} else {
	current = null;
	}
	}
	}
	_blocks.saveBlock(current, start, pattern.length);
	}

	/// Convert [DateTime] to a [String] exactly as specified by the [pattern].
	String encode(DateTime datetime) {
	var buffer = StringBuffer();
	for (var i = 0; i < _blocks.length; i++) {
	var start = _blocks.starts[i];
	var end = _blocks.ends[i];
	var length = end - start;

	var previousEnd = i > 0 ? _blocks.ends[i - 1] : 0;
	if (previousEnd < start) {
	buffer.write(pattern.substring(previousEnd, start));
	}
	var formatCharacter = _blocks.formatCharacters[i];
	var number = _extractNumFromDateTime(
	formatCharacter,
	datetime,
	).toString();
	if (number.length > length) {
	if (formatCharacter == _fractionSecondCode) {
	//Special case, as we want fractional seconds to be the leading digits
	number = number.substring(length);
	} else {
	number = number.substring(number.length - length);
	}
	} else if (number.length < length) {
	number = number.padLeft(length, '0');
	}
	buffer.write(number);
	}
	if (_blocks.length > 0) {
	var lastEnd = _blocks.ends.last;
	if (lastEnd < pattern.length) {
	buffer.write(pattern.substring(lastEnd, pattern.length));
	}
	}
	return buffer.toString();
	}

	int _extractNumFromDateTime(int? formatChar, DateTime dateTime) {
	switch (formatChar) {
	case _yearCode:
	return dateTime.year;
	case _centuryCode:
	return (dateTime.year / 100).floor();
	case _decadeCode:
	return (dateTime.year / 10).floor();
	case _monthCode:
	return dateTime.month;
	case _dayCode:
	return dateTime.day;
	case _hourCode:
	return dateTime.hour;
	case _minuteCode:
	return dateTime.minute;
	case _secondCode:
	return dateTime.second;
	case _fractionSecondCode:
	return dateTime.microsecond;
	}
	throw AssertionError("Unreachable, the key is checked in the constructor");
	}

	/// Parse a string [formattedDateTime] to a local [DateTime] as specified in the
	/// [pattern], substituting missing values with a default. Throws an exception
	/// on failure to parse.
	DateTime decode(String formattedDateTime) {
	return _decode(formattedDateTime, isUtc, true);
	}

	/// Same as [decode], but will not throw on parsing erros, instead using
	/// the default value as if the format char was not present in the [pattern].
	DateTime tryDecode(String formattedDateTime) {
	return _decode(formattedDateTime, isUtc, false);
	}

	DateTime _decode(
	String formattedDateTime,
	bool isUtc,
	bool throwOnError,
	) {
	var characters = formattedDateTime.codeUnits;
	var year = 0;
	var century = 0;
	var decade = 0;
	var month = 1;
	var day = 1;
	var hour = 0;
	var minute = 0;
	var second = 0;
	var microsecond = 0;
	for (int i = 0; i < _blocks.length; i++) {
	var char = _blocks.formatCharacters[i];
	var number = _extractNumFromString(characters, i, throwOnError);
	if (number != null) {
	if (char == _fractionSecondCode) {
	//Special case, as we want fractional seconds to be the leading digits
	var numberLength = _blocks.ends[i] - _blocks.starts[i];
	number *= _powersOfTen[6 - numberLength + 1];
	}
	switch (char) {
	case _yearCode:
	year = number;
	break;
	case _centuryCode:
	century = number;
	break;
	case _decadeCode:
	decade = number;
	break;
	case _monthCode:
	month = number;
	break;
	case _dayCode:
	day = number;
	break;
	case _hourCode:
	hour = number;
	break;
	case _minuteCode:
	minute = number;
	break;
	case _secondCode:
	second = number;
	break;
	case _fractionSecondCode:
	microsecond = number;
	break;
	}
	}
	}
	var totalYear = year + 100 * century + 10 * decade;
	if (isUtc) {
	return DateTime.utc(
	totalYear,
	month,
	day,
	hour,
	minute,
	second,
	0,
	microsecond,
	);
	} else {
	return DateTime(
	totalYear,
	month,
	day,
	hour,
	minute,
	second,
	0,
	microsecond,
	);
	}
	}

	int? _extractNumFromString(
	List<int> characters,
	int index,
	bool throwOnError,
	) {
	var parsed = tryParse(
	characters,
	_blocks.starts[index],
	_blocks.ends[index],
	);
	if (parsed == null && throwOnError) {
	throw FormatException(
	'${String.fromCharCodes(characters)} should only contain digits');
	}
	return parsed;
	}

	int? tryParse(List<int> characters, int start, int end) {
	int result = 0;
	for (var i = start; i < end; i++) {
	var digit = characters[i] ^ 0x30;
	if (digit <= 9) {
	result = result * 10 + digit;
	} else {
	return null;
	}
	}
	return result;
	}
	}

	class _ParsedFormatBlocks {
	final formatCharacters = <int>[];
	final starts = <int>[];
	final ends = <int>[];

	_ParsedFormatBlocks();

	int get length => formatCharacters.length;

	void saveBlock(int? char, int start, int end) {
	if (char != null) {
	formatCharacters.add(char);
	starts.add(start);
	ends.add(end);
	}
	}
	}