netcore/System.Private.CoreLib/shared/System/TimeZoneInfo.StringSerializer.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System.Collections.Generic;
   6 using System.Globalization;
   7 using System.Runtime.Serialization;
   8 using System.Text;
   9
  10 namespace System
  11 {
  12     public sealed partial class TimeZoneInfo
  13     {
  14         /// <summary>
  15         /// Used to serialize and deserialize TimeZoneInfo objects based on the custom string serialization format.
  16         /// </summary>
  17         private struct StringSerializer
  18         {
  19             private enum State
  20             {
  21                 Escaped = 0,
  22                 NotEscaped = 1,
  23                 StartOfToken = 2,
  24                 EndOfLine = 3
  25             }
  26
  27             private readonly string _serializedText;
  28             private int _currentTokenStartIndex;
  29             private State _state;
  30
  31             // the majority of the strings contained in the OS time zones fit in 64 chars
  32             private const int InitialCapacityForString = 64;
  33             private const char Esc = '\\';
  34             private const char Sep = ';';
  35             private const char Lhs = '[';
  36             private const char Rhs = ']';
  37             private const string DateTimeFormat = "MM:dd:yyyy";
  38             private const string TimeOfDayFormat = "HH:mm:ss.FFF";
  39
  40             /// <summary>
  41             /// Creates the custom serialized string representation of a TimeZoneInfo instance.
  42             /// </summary>
  43             public static string GetSerializedString(TimeZoneInfo zone)
  44             {
  45                 StringBuilder serializedText = StringBuilderCache.Acquire();
  46
  47                 //
  48                 // <_id>;<_baseUtcOffset>;<_displayName>;<_standardDisplayName>;<_daylightDispayName>
  49                 //
  50                 SerializeSubstitute(zone.Id, serializedText);
  51                 serializedText.Append(Sep);
  52                 serializedText.AppendSpanFormattable(zone.BaseUtcOffset.TotalMinutes, format: default, CultureInfo.InvariantCulture);
  53                 serializedText.Append(Sep);
  54                 SerializeSubstitute(zone.DisplayName, serializedText);
  55                 serializedText.Append(Sep);
  56                 SerializeSubstitute(zone.StandardName, serializedText);
  57                 serializedText.Append(Sep);
  58                 SerializeSubstitute(zone.DaylightName, serializedText);
  59                 serializedText.Append(Sep);
  60
  61                 AdjustmentRule[] rules = zone.GetAdjustmentRules();
  62                 foreach (AdjustmentRule rule in rules)
  63                 {
  64                     serializedText.Append(Lhs);
  65                     serializedText.AppendSpanFormattable(rule.DateStart, DateTimeFormat, DateTimeFormatInfo.InvariantInfo);
  66                     serializedText.Append(Sep);
  67                     serializedText.AppendSpanFormattable(rule.DateEnd, DateTimeFormat, DateTimeFormatInfo.InvariantInfo);
  68                     serializedText.Append(Sep);
  69                     serializedText.AppendSpanFormattable(rule.DaylightDelta.TotalMinutes, format: default, CultureInfo.InvariantCulture);
  70                     serializedText.Append(Sep);
  71                     // serialize the TransitionTime's
  72                     SerializeTransitionTime(rule.DaylightTransitionStart, serializedText);
  73                     serializedText.Append(Sep);
  74                     SerializeTransitionTime(rule.DaylightTransitionEnd, serializedText);
  75                     serializedText.Append(Sep);
  76                     if (rule.BaseUtcOffsetDelta != TimeSpan.Zero)
  77                     {
  78                         // Serialize it only when BaseUtcOffsetDelta has a value to reduce the impact of adding rule.BaseUtcOffsetDelta
  79                         serializedText.AppendSpanFormattable(rule.BaseUtcOffsetDelta.TotalMinutes, format: default, CultureInfo.InvariantCulture);
  80                         serializedText.Append(Sep);
  81                     }
  82                     if (rule.NoDaylightTransitions)
  83                     {
  84                         // Serialize it only when NoDaylightTransitions is true to reduce the impact of adding rule.NoDaylightTransitions
  85                         serializedText.Append('1');
  86                         serializedText.Append(Sep);
  87                     }
  88                     serializedText.Append(Rhs);
  89                 }
  90                 serializedText.Append(Sep);
  91
  92                 return StringBuilderCache.GetStringAndRelease(serializedText);
  93             }
  94
  95             /// <summary>
  96             /// Instantiates a TimeZoneInfo from a custom serialized string.
  97             /// </summary>
  98             public static TimeZoneInfo GetDeserializedTimeZoneInfo(string source)
  99             {
 100                 StringSerializer s = new StringSerializer(source);
 101
 102                 string id = s.GetNextStringValue();
 103                 TimeSpan baseUtcOffset = s.GetNextTimeSpanValue();
 104                 string displayName = s.GetNextStringValue();
 105                 string standardName = s.GetNextStringValue();
 106                 string daylightName = s.GetNextStringValue();
 107                 AdjustmentRule[]? rules = s.GetNextAdjustmentRuleArrayValue();
 108
 109                 try
 110                 {
 111                     return new TimeZoneInfo(id, baseUtcOffset, displayName, standardName, daylightName, rules, disableDaylightSavingTime: false);
 112                 }
 113                 catch (ArgumentException ex)
 114                 {
 115                     throw new SerializationException(SR.Serialization_InvalidData, ex);
 116                 }
 117                 catch (InvalidTimeZoneException ex)
 118                 {
 119                     throw new SerializationException(SR.Serialization_InvalidData, ex);
 120                 }
 121             }
 122
 123             private StringSerializer(string str)
 124             {
 125                 _serializedText = str;
 126                 _currentTokenStartIndex = 0;
 127                 _state = State.StartOfToken;
 128             }
 129
 130             /// <summary>
 131             /// Appends the String to the StringBuilder with all of the reserved chars escaped.
 132             ///
 133             /// ";" -> "\;"
 134             /// "[" -> "\["
 135             /// "]" -> "\]"
 136             /// "\" -> "\\"
 137             /// </summary>
 138             private static void SerializeSubstitute(string text, StringBuilder serializedText)
 139             {
 140                 foreach (char c in text)
 141                 {
 142                     if (c == Esc || c == Lhs || c == Rhs || c == Sep)
 143                     {
 144                         serializedText.Append('\\');
 145                     }
 146                     serializedText.Append(c);
 147                 }
 148             }
 149
 150             /// <summary>
 151             /// Helper method to serialize a TimeZoneInfo.TransitionTime object.
 152             /// </summary>
 153             private static void SerializeTransitionTime(TransitionTime time, StringBuilder serializedText)
 154             {
 155                 serializedText.Append(Lhs);
 156                 serializedText.Append(time.IsFixedDateRule ? '1' : '0');
 157                 serializedText.Append(Sep);
 158                 serializedText.AppendSpanFormattable(time.TimeOfDay, TimeOfDayFormat, DateTimeFormatInfo.InvariantInfo);
 159                 serializedText.Append(Sep);
 160                 serializedText.AppendSpanFormattable(time.Month, format: default, CultureInfo.InvariantCulture);
 161                 serializedText.Append(Sep);
 162                 if (time.IsFixedDateRule)
 163                 {
 164                     serializedText.AppendSpanFormattable(time.Day, format: default, CultureInfo.InvariantCulture);
 165                     serializedText.Append(Sep);
 166                 }
 167                 else
 168                 {
 169                     serializedText.AppendSpanFormattable(time.Week, format: default, CultureInfo.InvariantCulture);
 170                     serializedText.Append(Sep);
 171                     serializedText.AppendSpanFormattable((int)time.DayOfWeek, format: default, CultureInfo.InvariantCulture);
 172                     serializedText.Append(Sep);
 173                 }
 174                 serializedText.Append(Rhs);
 175             }
 176
 177             /// <summary>
 178             /// Helper function to determine if the passed in string token is allowed to be preceded by an escape sequence token.
 179             /// </summary>
 180             private static void VerifyIsEscapableCharacter(char c)
 181             {
 182                 if (c != Esc && c != Sep && c != Lhs && c != Rhs)
 183                 {
 184                     throw new SerializationException(SR.Format(SR.Serialization_InvalidEscapeSequence, c));
 185                 }
 186             }
 187
 188             /// <summary>
 189             /// Helper function that reads past "v.Next" data fields. Receives a "depth" parameter indicating the
 190             /// current relative nested bracket depth that _currentTokenStartIndex is at. The function ends
 191             /// successfully when "depth" returns to zero (0).
 192             /// </summary>
 193             private void SkipVersionNextDataFields(int depth /* starting depth in the nested brackets ('[', ']')*/)
 194             {
 195                 if (_currentTokenStartIndex < 0 || _currentTokenStartIndex >= _serializedText.Length)
 196                 {
 197                     throw new SerializationException(SR.Serialization_InvalidData);
 198                 }
 199                 State tokenState = State.NotEscaped;
 200
 201                 // walk the serialized text, building up the token as we go...
 202                 for (int i = _currentTokenStartIndex; i < _serializedText.Length; i++)
 203                 {
 204                     if (tokenState == State.Escaped)
 205                     {
 206                         VerifyIsEscapableCharacter(_serializedText[i]);
 207                         tokenState = State.NotEscaped;
 208                     }
 209                     else if (tokenState == State.NotEscaped)
 210                     {
 211                         switch (_serializedText[i])
 212                         {
 213                             case Esc:
 214                                 tokenState = State.Escaped;
 215                                 break;
 216
 217                             case Lhs:
 218                                 depth++;
 219                                 break;
 220                             case Rhs:
 221                                 depth--;
 222                                 if (depth == 0)
 223                                 {
 224                                     _currentTokenStartIndex = i + 1;
 225                                     if (_currentTokenStartIndex >= _serializedText.Length)
 226                                     {
 227                                         _state = State.EndOfLine;
 228                                     }
 229                                     else
 230                                     {
 231                                         _state = State.StartOfToken;
 232                                     }
 233                                     return;
 234                                 }
 235                                 break;
 236
 237                             case '\0':
 238                                 // invalid character
 239                                 throw new SerializationException(SR.Serialization_InvalidData);
 240
 241                             default:
 242                                 break;
 243                         }
 244                     }
 245                 }
 246
 247                 throw new SerializationException(SR.Serialization_InvalidData);
 248             }
 249
 250             /// <summary>
 251             /// Helper function that reads a string token from the serialized text. The function
 252             /// updates <see cref="_currentTokenStartIndex"/> to point to the next token on exit.
 253             /// Also <see cref="_state"/> is set to either <see cref="State.StartOfToken"/> or
 254             /// <see cref="State.EndOfLine"/> on exit.
 255             /// </summary>
 256             private string GetNextStringValue()
 257             {
 258                 // first verify the internal state of the object
 259                 if (_state == State.EndOfLine)
 260                 {
 261                     throw new SerializationException(SR.Serialization_InvalidData);
 262                 }
 263                 if (_currentTokenStartIndex < 0 || _currentTokenStartIndex >= _serializedText.Length)
 264                 {
 265                     throw new SerializationException(SR.Serialization_InvalidData);
 266                 }
 267                 State tokenState = State.NotEscaped;
 268                 StringBuilder token = StringBuilderCache.Acquire(InitialCapacityForString);
 269
 270                 // walk the serialized text, building up the token as we go...
 271                 for (int i = _currentTokenStartIndex; i < _serializedText.Length; i++)
 272                 {
 273                     if (tokenState == State.Escaped)
 274                     {
 275                         VerifyIsEscapableCharacter(_serializedText[i]);
 276                         token.Append(_serializedText[i]);
 277                         tokenState = State.NotEscaped;
 278                     }
 279                     else if (tokenState == State.NotEscaped)
 280                     {
 281                         switch (_serializedText[i])
 282                         {
 283                             case Esc:
 284                                 tokenState = State.Escaped;
 285                                 break;
 286
 287                             case Lhs:
 288                                 // '[' is an unexpected character
 289                                 throw new SerializationException(SR.Serialization_InvalidData);
 290
 291                             case Rhs:
 292                                 // ']' is an unexpected character
 293                                 throw new SerializationException(SR.Serialization_InvalidData);
 294
 295                             case Sep:
 296                                 _currentTokenStartIndex = i + 1;
 297                                 if (_currentTokenStartIndex >= _serializedText.Length)
 298                                 {
 299                                     _state = State.EndOfLine;
 300                                 }
 301                                 else
 302                                 {
 303                                     _state = State.StartOfToken;
 304                                 }
 305                                 return StringBuilderCache.GetStringAndRelease(token);
 306
 307                             case '\0':
 308                                 // invalid character
 309                                 throw new SerializationException(SR.Serialization_InvalidData);
 310
 311                             default:
 312                                 token.Append(_serializedText[i]);
 313                                 break;
 314                         }
 315                     }
 316                 }
 317                 //
 318                 // we are at the end of the line
 319                 //
 320                 if (tokenState == State.Escaped)
 321                 {
 322                     // we are at the end of the serialized text but we are in an escaped state
 323                     throw new SerializationException(SR.Format(SR.Serialization_InvalidEscapeSequence, string.Empty));
 324                 }
 325
 326                 throw new SerializationException(SR.Serialization_InvalidData);
 327             }
 328
 329             /// <summary>
 330             /// Helper function to read a DateTime token.
 331             /// </summary>
 332             private DateTime GetNextDateTimeValue(string format)
 333             {
 334                 string token = GetNextStringValue();
 335                 DateTime time;
 336                 if (!DateTime.TryParseExact(token, format, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.None, out time))
 337                 {
 338                     throw new SerializationException(SR.Serialization_InvalidData);
 339                 }
 340                 return time;
 341             }
 342
 343             /// <summary>
 344             /// Helper function to read a TimeSpan token.
 345             /// </summary>
 346             private TimeSpan GetNextTimeSpanValue()
 347             {
 348                 int token = GetNextInt32Value();
 349                 try
 350                 {
 351                     return new TimeSpan(hours: 0, minutes: token, seconds: 0);
 352                 }
 353                 catch (ArgumentOutOfRangeException e)
 354                 {
 355                     throw new SerializationException(SR.Serialization_InvalidData, e);
 356                 }
 357             }
 358
 359             /// <summary>
 360             /// Helper function to read an Int32 token.
 361             /// </summary>
 362             private int GetNextInt32Value()
 363             {
 364                 string token = GetNextStringValue();
 365                 int value;
 366                 if (!int.TryParse(token, NumberStyles.AllowLeadingSign /* "[sign]digits" */, CultureInfo.InvariantCulture, out value))
 367                 {
 368                     throw new SerializationException(SR.Serialization_InvalidData);
 369                 }
 370                 return value;
 371             }
 372
 373             /// <summary>
 374             /// Helper function to read an AdjustmentRule[] token.
 375             /// </summary>
 376             private AdjustmentRule[]? GetNextAdjustmentRuleArrayValue()
 377             {
 378                 List<AdjustmentRule> rules = new List<AdjustmentRule>(1);
 379                 int count = 0;
 380
 381                 // individual AdjustmentRule array elements do not require semicolons
 382                 AdjustmentRule? rule = GetNextAdjustmentRuleValue();
 383                 while (rule != null)
 384                 {
 385                     rules.Add(rule);
 386                     count++;
 387
 388                     rule = GetNextAdjustmentRuleValue();
 389                 }
 390
 391                 // the AdjustmentRule array must end with a separator
 392                 if (_state == State.EndOfLine)
 393                 {
 394                     throw new SerializationException(SR.Serialization_InvalidData);
 395                 }
 396                 if (_currentTokenStartIndex < 0 || _currentTokenStartIndex >= _serializedText.Length)
 397                 {
 398                     throw new SerializationException(SR.Serialization_InvalidData);
 399                 }
 400
 401                 return count != 0 ? rules.ToArray() : null;
 402             }
 403
 404             /// <summary>
 405             /// Helper function to read an AdjustmentRule token.
 406             /// </summary>
 407             private AdjustmentRule? GetNextAdjustmentRuleValue()
 408             {
 409                 // first verify the internal state of the object
 410                 if (_state == State.EndOfLine)
 411                 {
 412                     return null;
 413                 }
 414
 415                 if (_currentTokenStartIndex < 0 || _currentTokenStartIndex >= _serializedText.Length)
 416                 {
 417                     throw new SerializationException(SR.Serialization_InvalidData);
 418                 }
 419
 420                 // check to see if the very first token we see is the separator
 421                 if (_serializedText[_currentTokenStartIndex] == Sep)
 422                 {
 423                     return null;
 424                 }
 425
 426                 // verify the current token is a left-hand-side marker ("[")
 427                 if (_serializedText[_currentTokenStartIndex] != Lhs)
 428                 {
 429                     throw new SerializationException(SR.Serialization_InvalidData);
 430                 }
 431                 _currentTokenStartIndex++;
 432
 433                 DateTime dateStart = GetNextDateTimeValue(DateTimeFormat);
 434                 DateTime dateEnd = GetNextDateTimeValue(DateTimeFormat);
 435                 TimeSpan daylightDelta = GetNextTimeSpanValue();
 436                 TransitionTime daylightStart = GetNextTransitionTimeValue();
 437                 TransitionTime daylightEnd = GetNextTransitionTimeValue();
 438                 TimeSpan baseUtcOffsetDelta = TimeSpan.Zero;
 439                 int noDaylightTransitions = 0;
 440
 441                 // verify that the string is now at the right-hand-side marker ("]") ...
 442
 443                 if (_state == State.EndOfLine || _currentTokenStartIndex >= _serializedText.Length)
 444                 {
 445                     throw new SerializationException(SR.Serialization_InvalidData);
 446                 }
 447
 448                 // Check if we have baseUtcOffsetDelta in the serialized string and then deserialize it
 449                 if ((_serializedText[_currentTokenStartIndex] >= '0' && _serializedText[_currentTokenStartIndex] <= '9') ||
 450                     _serializedText[_currentTokenStartIndex] == '-' || _serializedText[_currentTokenStartIndex] == '+')
 451                 {
 452                     baseUtcOffsetDelta = GetNextTimeSpanValue();
 453                 }
 454
 455                 // Check if we have NoDaylightTransitions in the serialized string and then deserialize it
 456                 if ((_serializedText[_currentTokenStartIndex] >= '0' && _serializedText[_currentTokenStartIndex] <= '1'))
 457                 {
 458                     noDaylightTransitions = GetNextInt32Value();
 459                 }
 460
 461                 if (_state == State.EndOfLine || _currentTokenStartIndex >= _serializedText.Length)
 462                 {
 463                     throw new SerializationException(SR.Serialization_InvalidData);
 464                 }
 465
 466                 if (_serializedText[_currentTokenStartIndex] != Rhs)
 467                 {
 468                     // skip ahead of any "v.Next" data at the end of the AdjustmentRule
 469                     //
 470                     // FUTURE: if the serialization format is extended in the future then this
 471                     // code section will need to be changed to read the new fields rather
 472                     // than just skipping the data at the end of the [AdjustmentRule].
 473                     SkipVersionNextDataFields(1);
 474                 }
 475                 else
 476                 {
 477                     _currentTokenStartIndex++;
 478                 }
 479
 480                 // create the AdjustmentRule from the deserialized fields ...
 481
 482                 AdjustmentRule rule;
 483                 try
 484                 {
 485                     rule = AdjustmentRule.CreateAdjustmentRule(dateStart, dateEnd, daylightDelta, daylightStart, daylightEnd, baseUtcOffsetDelta, noDaylightTransitions > 0);
 486                 }
 487                 catch (ArgumentException e)
 488                 {
 489                     throw new SerializationException(SR.Serialization_InvalidData, e);
 490                 }
 491
 492                 // finally set the state to either EndOfLine or StartOfToken for the next caller
 493                 if (_currentTokenStartIndex >= _serializedText.Length)
 494                 {
 495                     _state = State.EndOfLine;
 496                 }
 497                 else
 498                 {
 499                     _state = State.StartOfToken;
 500                 }
 501                 return rule;
 502             }
 503
 504             /// <summary>
 505             /// Helper function to read a TransitionTime token.
 506             /// </summary>
 507             private TransitionTime GetNextTransitionTimeValue()
 508             {
 509                 // first verify the internal state of the object
 510
 511                 if (_state == State.EndOfLine ||
 512                     (_currentTokenStartIndex < _serializedText.Length && _serializedText[_currentTokenStartIndex] == Rhs))
 513                 {
 514                     //
 515                     // we are at the end of the line or we are starting at a "]" character
 516                     //
 517                     throw new SerializationException(SR.Serialization_InvalidData);
 518                 }
 519
 520                 if (_currentTokenStartIndex < 0 || _currentTokenStartIndex >= _serializedText.Length)
 521                 {
 522                     throw new SerializationException(SR.Serialization_InvalidData);
 523                 }
 524
 525                 // verify the current token is a left-hand-side marker ("[")
 526
 527                 if (_serializedText[_currentTokenStartIndex] != Lhs)
 528                 {
 529                     throw new SerializationException(SR.Serialization_InvalidData);
 530                 }
 531                 _currentTokenStartIndex++;
 532
 533                 int isFixedDate = GetNextInt32Value();
 534
 535                 if (isFixedDate != 0 && isFixedDate != 1)
 536                 {
 537                     throw new SerializationException(SR.Serialization_InvalidData);
 538                 }
 539
 540                 TransitionTime transition;
 541
 542                 DateTime timeOfDay = GetNextDateTimeValue(TimeOfDayFormat);
 543                 timeOfDay = new DateTime(1, 1, 1, timeOfDay.Hour, timeOfDay.Minute, timeOfDay.Second, timeOfDay.Millisecond);
 544
 545                 int month = GetNextInt32Value();
 546
 547                 if (isFixedDate == 1)
 548                 {
 549                     int day = GetNextInt32Value();
 550
 551                     try
 552                     {
 553                         transition = TransitionTime.CreateFixedDateRule(timeOfDay, month, day);
 554                     }
 555                     catch (ArgumentException e)
 556                     {
 557                         throw new SerializationException(SR.Serialization_InvalidData, e);
 558                     }
 559                 }
 560                 else
 561                 {
 562                     int week = GetNextInt32Value();
 563                     int dayOfWeek = GetNextInt32Value();
 564
 565                     try
 566                     {
 567                         transition = TransitionTime.CreateFloatingDateRule(timeOfDay, month, week, (DayOfWeek)dayOfWeek);
 568                     }
 569                     catch (ArgumentException e)
 570                     {
 571                         throw new SerializationException(SR.Serialization_InvalidData, e);
 572                     }
 573                 }
 574
 575                 // verify that the string is now at the right-hand-side marker ("]") ...
 576
 577                 if (_state == State.EndOfLine || _currentTokenStartIndex >= _serializedText.Length)
 578                 {
 579                     throw new SerializationException(SR.Serialization_InvalidData);
 580                 }
 581
 582                 if (_serializedText[_currentTokenStartIndex] != Rhs)
 583                 {
 584                     // skip ahead of any "v.Next" data at the end of the AdjustmentRule
 585                     //
 586                     // FUTURE: if the serialization format is extended in the future then this
 587                     // code section will need to be changed to read the new fields rather
 588                     // than just skipping the data at the end of the [TransitionTime].
 589                     SkipVersionNextDataFields(1);
 590                 }
 591                 else
 592                 {
 593                     _currentTokenStartIndex++;
 594                 }
 595
 596                 // check to see if the string is now at the separator (";") ...
 597                 bool sepFound = false;
 598                 if (_currentTokenStartIndex < _serializedText.Length &&
 599                     _serializedText[_currentTokenStartIndex] == Sep)
 600                 {
 601                     // handle the case where we ended on a ";"
 602                     _currentTokenStartIndex++;
 603                     sepFound = true;
 604                 }
 605
 606                 if (!sepFound)
 607                 {
 608                     // we MUST end on a separator
 609                     throw new SerializationException(SR.Serialization_InvalidData);
 610                 }
 611
 612                 // finally set the state to either EndOfLine or StartOfToken for the next caller
 613                 if (_currentTokenStartIndex >= _serializedText.Length)
 614                 {
 615                     _state = State.EndOfLine;
 616                 }
 617                 else
 618                 {
 619                     _state = State.StartOfToken;
 620                 }
 621                 return transition;
 622             }
 623         }
 624     }
 625 }