source/objects/calendartimezone/CalendarTimezone-Save.cpp

   1 // CalendarTimezone-Save.cpp - CalendarTimezone class save functions
   2 //
   3 // (c) 2016-2017 Xestia Software Development.
   4 //
   5 // This file is part of Xestia Calendar.
   6 //
   7 // Xestia Calendar is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU General Public License as published by the
   9 // Free Software Foundation, version 3 of the license.
  10 //
  11 // Xestia Calendar is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with Xestia Calendar. If not, see <http://www.gnu.org/licenses/>
  18
  19 #include "CalendarTimezone.h"
  20
  21 using namespace std;
  22
  23 void CalendarTimezoneObject::SaveObjectData(string *SaveData){
  24
  25         string DataLine = "";
  26         string DataLineProcessed = "";
  27
  28         *SaveData += "BEGIN:VTIMEZONE\n";
  29
  30         // Process the TZID.
  31
  32         if (TimeZoneData.size() > 0){
  33
  34                 if (TimeZoneDataTokens.size() > 0){
  35
  36                         DataLine += "TZID;";
  37                         DataLine += TimeZoneDataTokens;
  38
  39                 } else {
  40
  41                         DataLine += "TZID";
  42
  43                 }
  44
  45                 DataLine += ":";
  46                 DataLine += TimeZoneData;
  47                 DataLine += "\n";
  48
  49                 DataLineProcessed = OutputText(&DataLine);
  50
  51                 *SaveData += DataLineProcessed;
  52
  53                 DataLine.clear();
  54                 DataLineProcessed.clear();
  55
  56         }
  57
  58         // Process the LAST-MODIFIED value.
  59
  60         if (LastModifiedData.size() > 0){
  61
  62                 if (LastModifiedTokens.size() > 0){
  63
  64                         DataLine += "LAST-MODIFIED;";
  65                         DataLine += LastModifiedTokens;
  66
  67                 } else {
  68
  69                         DataLine += "LAST-MODIFIED";
  70
  71                 }
  72
  73                 DataLine += ":";
  74                 DataLine += LastModifiedData;
  75                 DataLine += "\n";
  76
  77                 DataLineProcessed = OutputText(&DataLine);
  78
  79                 *SaveData += DataLineProcessed;
  80
  81                 DataLine.clear();
  82                 DataLineProcessed.clear();
  83
  84         }
  85
  86         // Process the TZURL value.
  87
  88         if (TimeZoneURLData.size() > 0){
  89
  90                 if (TimeZoneURLTokens.size() > 0){
  91
  92                         DataLine += "TZURL;";
  93                         DataLine += TimeZoneURLTokens;
  94
  95                 } else {
  96
  97                         DataLine += "TZURL";
  98
  99                 }
 100
 101                 DataLine += ":";
 102                 DataLine += TimeZoneURLData;
 103                 DataLine += "\n";
 104
 105                 DataLineProcessed = OutputText(&DataLine);
 106
 107                 *SaveData += DataLineProcessed;
 108
 109                 DataLine.clear();
 110                 DataLineProcessed.clear();
 111
 112         }
 113
 114         // Process Standard timezones.
 115
 116         if (TimezoneStandardCollection.size() > 0){
 117
 118                 for (int TimezoneStandardSeek = 0; TimezoneStandardSeek < TimezoneStandardCollection.size();
 119                         TimezoneStandardSeek++){
 120
 121                         *SaveData += "BEGIN:STANDARD\n";
 122
 123                         // Process the DTSTART value.
 124
 125                         if (TimezoneStandardCollection[TimezoneStandardSeek].DateTimeStartData.size() > 0){
 126
 127                                 if (TimezoneStandardCollection[TimezoneStandardSeek].DateTimeStartTokens.size() > 0){
 128
 129                                         DataLine += "DTSTART;";
 130                                         DataLine += TimezoneStandardCollection[TimezoneStandardSeek].DateTimeStartTokens;
 131
 132                                 } else {
 133
 134                                         DataLine += "DTSTART";
 135
 136                                 }
 137
 138                                 DataLine += ":";
 139                                 DataLine += TimezoneStandardCollection[TimezoneStandardSeek].DateTimeStartData;
 140                                 DataLine += "\n";
 141
 142                                 DataLineProcessed = OutputText(&DataLine);
 143
 144                                 *SaveData += DataLineProcessed;
 145
 146                                 DataLine.clear();
 147                                 DataLineProcessed.clear();
 148
 149                         }
 150
 151                         // Process the TZOFFSETFROM value.
 152
 153                         if (TimezoneStandardCollection[TimezoneStandardSeek].TimeZoneOffsetFromData.size() > 0){
 154
 155                                 if (TimezoneStandardCollection[TimezoneStandardSeek].TimeZoneOffsetFromTokens.size() > 0){
 156
 157                                         DataLine += "TZOFFSETFROM;";
 158                                         DataLine += TimezoneStandardCollection[TimezoneStandardSeek].TimeZoneOffsetFromTokens;
 159
 160                                 } else {
 161
 162                                         DataLine += "TZOFFSETFROM";
 163
 164                                 }
 165
 166                                 DataLine += ":";
 167                                 DataLine += TimezoneStandardCollection[TimezoneStandardSeek].TimeZoneOffsetFromData;
 168                                 DataLine += "\n";
 169
 170                                 DataLineProcessed = OutputText(&DataLine);
 171
 172                                 *SaveData += DataLineProcessed;
 173
 174                                 DataLine.clear();
 175                                 DataLineProcessed.clear();
 176
 177                         }
 178
 179                         // Process the TZOFFSETTO value.
 180
 181                         if (TimezoneStandardCollection[TimezoneStandardSeek].TimeZoneOffsetToData.size() > 0){
 182
 183                                 if (TimezoneStandardCollection[TimezoneStandardSeek].TimeZoneOffsetToTokens.size() > 0){
 184
 185                                         DataLine += "TZOFFSETTO;";
 186                                         DataLine += TimezoneStandardCollection[TimezoneStandardSeek].TimeZoneOffsetToTokens;
 187
 188                                 } else {
 189
 190                                         DataLine += "TZOFFSETTO";
 191
 192                                 }
 193
 194                                 DataLine += ":";
 195                                 DataLine += TimezoneStandardCollection[TimezoneStandardSeek].TimeZoneOffsetToData;
 196                                 DataLine += "\n";
 197
 198                                 DataLineProcessed = OutputText(&DataLine);
 199
 200                                 *SaveData += DataLineProcessed;
 201
 202                                 DataLine.clear();
 203                                 DataLineProcessed.clear();
 204
 205                         }
 206
 207                         // Process the RRULE value.
 208
 209                         if (TimezoneStandardCollection[TimezoneStandardSeek].RecurranceRuleData.size() > 0){
 210
 211                                 if (TimezoneStandardCollection[TimezoneStandardSeek].RecurranceRuleDataTokens.size() > 0){
 212
 213                                         DataLine += "RRULE;";
 214                                         DataLine += TimezoneStandardCollection[TimezoneStandardSeek].RecurranceRuleDataTokens;
 215
 216                                 } else {
 217
 218                                         DataLine += "RRULE";
 219
 220                                 }
 221
 222                                 DataLine += ":";
 223                                 DataLine += TimezoneStandardCollection[TimezoneStandardSeek].RecurranceRuleData;
 224                                 DataLine += "\n";
 225
 226                                 DataLineProcessed = OutputText(&DataLine);
 227
 228                                 *SaveData += DataLineProcessed;
 229
 230                                 DataLine.clear();
 231                                 DataLineProcessed.clear();
 232
 233                         }
 234
 235                         // Process the COMMENT value.
 236
 237                         if (TimezoneStandardCollection[TimezoneStandardSeek].CommentList.size() > 0){
 238
 239                                 for (int CommentListSeek = 0; CommentListSeek < TimezoneStandardCollection[TimezoneStandardSeek].CommentList.size();
 240                                         CommentListSeek++){
 241
 242                                         DataLine += "COMMENT";
 243
 244                                         if (TimezoneStandardCollection[TimezoneStandardSeek].CommentListAltRep[CommentListSeek].size() > 0){
 245
 246                                                 DataLine += ";ALTREP=\"";
 247                                                 DataLine += TimezoneStandardCollection[TimezoneStandardSeek].CommentListAltRep[CommentListSeek];
 248                                                 DataLine += "\"";
 249
 250                                         }
 251
 252                                         if (TimezoneStandardCollection[TimezoneStandardSeek].CommentListLanguage[CommentListSeek].size() > 0){
 253
 254                                                 DataLine += ";LANGUAGE=";
 255                                                 DataLine += TimezoneStandardCollection[TimezoneStandardSeek].CommentListLanguage[CommentListSeek];
 256
 257                                         }
 258
 259                                         if (TimezoneStandardCollection[TimezoneStandardSeek].CommentListTokens[CommentListSeek].size() > 0){
 260
 261                                                 DataLine += ";";
 262                                                 DataLine += TimezoneStandardCollection[TimezoneStandardSeek].CommentListTokens[CommentListSeek];
 263
 264                                         }
 265
 266                                         DataLine += ":";
 267                                         DataLine += TimezoneStandardCollection[TimezoneStandardSeek].CommentList[CommentListSeek];
 268                                         DataLine += "\n";
 269
 270                                         DataLineProcessed = OutputText(&DataLine);
 271
 272                                         *SaveData += DataLineProcessed;
 273
 274                                         DataLine.clear();
 275                                         DataLineProcessed.clear();
 276
 277                                 }
 278
 279                         }
 280
 281                         // Process the RDATE value.
 282
 283                         if (TimezoneStandardCollection[TimezoneStandardSeek].RecurranceDateData.size() > 0){
 284
 285                                 for (int RecurranceDataSeek = 0; RecurranceDataSeek < TimezoneStandardCollection[TimezoneStandardSeek].RecurranceDateData.size();
 286                                         RecurranceDataSeek++){
 287
 288                                         DataLine += "RDATE";
 289
 290                                         if (TimezoneStandardCollection[TimezoneStandardSeek].RecurranceDateDataValue[RecurranceDataSeek].size() > 0){
 291
 292                                                 DataLine += ";VALUE=";
 293                                                 DataLine += TimezoneStandardCollection[TimezoneStandardSeek].RecurranceDateDataValue[RecurranceDataSeek];
 294
 295                                         }
 296
 297                                         if (TimezoneStandardCollection[TimezoneStandardSeek].RecurranceDateDataTimeZoneParam[RecurranceDataSeek].size() > 0){
 298
 299                                                 DataLine += ";TZID=";
 300                                                 DataLine += TimezoneStandardCollection[TimezoneStandardSeek].RecurranceDateDataTimeZoneParam[RecurranceDataSeek];
 301
 302                                         }
 303
 304                                         if (TimezoneStandardCollection[TimezoneStandardSeek].RecurranceDateDataTokens[RecurranceDataSeek].size() > 0){
 305
 306                                                 DataLine += ";";
 307                                                 DataLine += TimezoneStandardCollection[TimezoneStandardSeek].RecurranceDateDataTokens[RecurranceDataSeek];
 308
 309                                         }
 310
 311                                         DataLine += ":";
 312                                         DataLine += TimezoneStandardCollection[TimezoneStandardSeek].RecurranceDateData[RecurranceDataSeek];
 313                                         DataLine += "\n";
 314
 315                                         DataLineProcessed = OutputText(&DataLine);
 316
 317                                         *SaveData += DataLineProcessed;
 318
 319                                         DataLine.clear();
 320                                         DataLineProcessed.clear();
 321
 322                                 }
 323
 324                         }
 325
 326                         // Process the TZNAME value.
 327
 328                         if (TimezoneStandardCollection[TimezoneStandardSeek].TimeZoneNameData.size() > 0){
 329
 330                                 for (int TimezoneNameSeek = 0; TimezoneNameSeek < TimezoneStandardCollection[TimezoneStandardSeek].TimeZoneNameData.size();
 331                                         TimezoneNameSeek++){
 332
 333                                         DataLine += "TZNAME";
 334
 335                                         if (TimezoneStandardCollection[TimezoneStandardSeek].TimeZoneNameLanguage[TimezoneNameSeek].size() > 0){
 336
 337                                                 DataLine += ";LANGUAGE=";
 338                                                 DataLine += TimezoneStandardCollection[TimezoneStandardSeek].TimeZoneNameLanguage[TimezoneNameSeek];
 339
 340                                         }
 341
 342                                         if (TimezoneStandardCollection[TimezoneStandardSeek].TimeZoneNameTokens[TimezoneNameSeek].size() > 0){
 343
 344                                                 DataLine += ";";
 345                                                 DataLine += TimezoneStandardCollection[TimezoneStandardSeek].TimeZoneNameTokens[TimezoneNameSeek];
 346
 347                                         }
 348
 349                                         DataLine += ":";
 350                                         DataLine += TimezoneStandardCollection[TimezoneStandardSeek].TimeZoneNameData[TimezoneNameSeek];
 351                                         DataLine += "\n";
 352
 353                                         DataLineProcessed = OutputText(&DataLine);
 354
 355                                         *SaveData += DataLineProcessed;
 356
 357                                         DataLine.clear();
 358                                         DataLineProcessed.clear();
 359
 360                                 }
 361
 362                         }
 363
 364                         // Process data from X-*
 365
 366                         if (TimezoneStandardCollection[TimezoneStandardSeek].XTokensData.size() > 0){
 367
 368                                 for (int TimezoneXTokenSeek = 0; TimezoneXTokenSeek < TimezoneStandardCollection[TimezoneStandardSeek].XTokensData.size();
 369                                         TimezoneXTokenSeek++){
 370
 371                                         DataLine += TimezoneStandardCollection[TimezoneStandardSeek].XTokensDataTokens[TimezoneXTokenSeek];
 372                                         DataLine += ":";
 373                                         DataLine += TimezoneStandardCollection[TimezoneStandardSeek].XTokensData[TimezoneXTokenSeek];
 374                                         DataLine += "\n";
 375
 376                                         DataLineProcessed = OutputText(&DataLine);
 377
 378                                         *SaveData += DataLineProcessed;
 379
 380                                         DataLine.clear();
 381                                         DataLineProcessed.clear();
 382
 383                                 }
 384
 385                         }
 386
 387                         *SaveData += "END:STANDARD\n";
 388
 389                 }
 390
 391         }
 392
 393         // Process Daylight timezones.
 394
 395         if (TimezoneDaylightCollection.size() > 0){
 396
 397                 for (int TimezoneDaylightSeek = 0; TimezoneDaylightSeek < TimezoneDaylightCollection.size();
 398                         TimezoneDaylightSeek++){
 399
 400                         *SaveData += "BEGIN:DAYLIGHT\n";
 401
 402                         // Process the DTSTART value.
 403
 404                         if (TimezoneDaylightCollection[TimezoneDaylightSeek].DateTimeStartData.size() > 0){
 405
 406                                 if (TimezoneStandardCollection[TimezoneDaylightSeek].DateTimeStartTokens.size() > 0){
 407
 408                                         DataLine += "DTSTART;";
 409                                         DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].DateTimeStartTokens;
 410
 411                                 } else {
 412
 413                                         DataLine += "DTSTART";
 414
 415                                 }
 416
 417                                 DataLine += ":";
 418                                 DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].DateTimeStartData;
 419                                 DataLine += "\n";
 420
 421                                 DataLineProcessed = OutputText(&DataLine);
 422
 423                                 *SaveData += DataLineProcessed;
 424
 425                                 DataLine.clear();
 426                                 DataLineProcessed.clear();
 427
 428                         }
 429
 430                         // Process the TZOFFSETFROM value.
 431
 432                         if (TimezoneDaylightCollection[TimezoneDaylightSeek].TimeZoneOffsetFromData.size() > 0){
 433
 434                                 if (TimezoneDaylightCollection[TimezoneDaylightSeek].TimeZoneOffsetFromTokens.size() > 0){
 435
 436                                         DataLine += "TZOFFSETFROM;";
 437                                         DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].TimeZoneOffsetFromTokens;
 438
 439                                 } else {
 440
 441                                         DataLine += "TZOFFSETFROM";
 442
 443                                 }
 444
 445                                 DataLine += ":";
 446                                 DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].TimeZoneOffsetFromData;
 447                                 DataLine += "\n";
 448
 449                                 DataLineProcessed = OutputText(&DataLine);
 450
 451                                 *SaveData += DataLineProcessed;
 452
 453                                 DataLine.clear();
 454                                 DataLineProcessed.clear();
 455
 456                         }
 457
 458                         // Process the TZOFFSETTO value.
 459
 460                         if (TimezoneDaylightCollection[TimezoneDaylightSeek].TimeZoneOffsetToData.size() > 0){
 461
 462                                 if (TimezoneDaylightCollection[TimezoneDaylightSeek].TimeZoneOffsetToTokens.size() > 0){
 463
 464                                         DataLine += "TZOFFSETTO;";
 465                                         DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].TimeZoneOffsetToTokens;
 466
 467                                 } else {
 468
 469                                         DataLine += "TZOFFSETTO";
 470
 471                                 }
 472
 473                                 DataLine += ":";
 474                                 DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].TimeZoneOffsetToData;
 475                                 DataLine += "\n";
 476
 477                                 DataLineProcessed = OutputText(&DataLine);
 478
 479                                 *SaveData += DataLineProcessed;
 480
 481                                 DataLine.clear();
 482                                 DataLineProcessed.clear();
 483
 484                         }
 485
 486                         // Process the RRULE value.
 487
 488                         if (TimezoneDaylightCollection[TimezoneDaylightSeek].RecurranceRuleData.size() > 0){
 489
 490                                 if (TimezoneDaylightCollection[TimezoneDaylightSeek].RecurranceRuleDataTokens.size() > 0){
 491
 492                                         DataLine += "RRULE;";
 493                                         DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].RecurranceRuleDataTokens;
 494
 495                                 } else {
 496
 497                                         DataLine += "RRULE";
 498
 499                                 }
 500
 501                                 DataLine += ":";
 502                                 DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].RecurranceRuleData;
 503                                 DataLine += "\n";
 504
 505                                 DataLineProcessed = OutputText(&DataLine);
 506
 507                                 *SaveData += DataLineProcessed;
 508
 509                                 DataLine.clear();
 510                                 DataLineProcessed.clear();
 511
 512                         }
 513
 514                         // Process the COMMENT value.
 515
 516                         if (TimezoneDaylightCollection[TimezoneDaylightSeek].CommentList.size() > 0){
 517
 518                                 for (int CommentListSeek = 0; CommentListSeek < TimezoneDaylightCollection[TimezoneDaylightSeek].CommentList.size();
 519                                         CommentListSeek++){
 520
 521                                         DataLine += "COMMENT";
 522
 523                                         if (TimezoneDaylightCollection[TimezoneDaylightSeek].CommentListAltRep[CommentListSeek].size() > 0){
 524
 525                                                 DataLine += ";ALTREP=\"";
 526                                                 DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].CommentListAltRep[CommentListSeek];
 527                                                 DataLine += "\"";
 528
 529                                         }
 530
 531                                         if (TimezoneDaylightCollection[TimezoneDaylightSeek].CommentListLanguage[CommentListSeek].size() > 0){
 532
 533                                                 DataLine += ";LANGUAGE=";
 534                                                 DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].CommentListLanguage[CommentListSeek];
 535
 536                                         }
 537
 538                                         if (TimezoneDaylightCollection[TimezoneDaylightSeek].CommentListTokens[CommentListSeek].size() > 0){
 539
 540                                                 DataLine += ";";
 541                                                 DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].CommentListTokens[CommentListSeek];
 542
 543                                         }
 544
 545                                         DataLine += ":";
 546                                         DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].CommentList[CommentListSeek];
 547                                         DataLine += "\n";
 548
 549                                         DataLineProcessed = OutputText(&DataLine);
 550
 551                                         *SaveData += DataLineProcessed;
 552
 553                                         DataLine.clear();
 554                                         DataLineProcessed.clear();
 555
 556                                 }
 557
 558                         }
 559
 560                         // Process the RDATE value.
 561
 562                         if (TimezoneDaylightCollection[TimezoneDaylightSeek].RecurranceDateData.size() > 0){
 563
 564                                 for (int RecurranceDataSeek = 0; RecurranceDataSeek < TimezoneDaylightCollection[TimezoneDaylightSeek].RecurranceDateData.size();
 565                                         RecurranceDataSeek++){
 566
 567                                         DataLine += "RDATE";
 568
 569                                         if (TimezoneDaylightCollection[TimezoneDaylightSeek].RecurranceDateDataValue[RecurranceDataSeek].size() > 0){
 570
 571                                                 DataLine += ";VALUE=";
 572                                                 DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].RecurranceDateDataValue[RecurranceDataSeek];
 573
 574                                         }
 575
 576                                         if (TimezoneDaylightCollection[TimezoneDaylightSeek].RecurranceDateDataTimeZoneParam[RecurranceDataSeek].size() > 0){
 577
 578                                                 DataLine += ";TZID=";
 579                                                 DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].RecurranceDateDataTimeZoneParam[RecurranceDataSeek];
 580
 581                                         }
 582
 583                                         if (TimezoneDaylightCollection[TimezoneDaylightSeek].RecurranceDateDataTokens[RecurranceDataSeek].size() > 0){
 584
 585                                                 DataLine += ";";
 586                                                 DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].RecurranceDateDataTokens[RecurranceDataSeek];
 587
 588                                         }
 589
 590                                         DataLine += ":";
 591                                         DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].RecurranceDateData[RecurranceDataSeek];
 592                                         DataLine += "\n";
 593
 594                                         DataLineProcessed = OutputText(&DataLine);
 595
 596                                         *SaveData += DataLineProcessed;
 597
 598                                         DataLine.clear();
 599                                         DataLineProcessed.clear();
 600
 601                                 }
 602
 603                         }
 604
 605                         // Process the TZNAME value.
 606
 607                         if (TimezoneDaylightCollection[TimezoneDaylightSeek].TimeZoneNameData.size() > 0){
 608
 609                                 for (int TimezoneNameSeek = 0; TimezoneNameSeek < TimezoneDaylightCollection[TimezoneDaylightSeek].TimeZoneNameData.size();
 610                                         TimezoneNameSeek++){
 611
 612                                         DataLine += "TZNAME";
 613
 614                                         if (TimezoneDaylightCollection[TimezoneDaylightSeek].TimeZoneNameLanguage[TimezoneNameSeek].size() > 0){
 615
 616                                                 DataLine += ";LANGUAGE=";
 617                                                 DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].TimeZoneNameLanguage[TimezoneNameSeek];
 618
 619                                         }
 620
 621                                         if (TimezoneDaylightCollection[TimezoneDaylightSeek].TimeZoneNameTokens[TimezoneNameSeek].size() > 0){
 622
 623                                                 DataLine += ";";
 624                                                 DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].TimeZoneNameTokens[TimezoneNameSeek];
 625
 626                                         }
 627
 628                                         DataLine += ":";
 629                                         DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].TimeZoneNameData[TimezoneNameSeek];
 630                                         DataLine += "\n";
 631
 632                                         DataLineProcessed = OutputText(&DataLine);
 633
 634                                         *SaveData += DataLineProcessed;
 635
 636                                         DataLine.clear();
 637                                         DataLineProcessed.clear();
 638
 639                                 }
 640
 641                         }
 642
 643                         // Process data from X-*
 644
 645                         if (TimezoneDaylightCollection[TimezoneDaylightSeek].XTokensData.size() > 0){
 646
 647                                 for (int TimezoneXTokenSeek = 0; TimezoneXTokenSeek < TimezoneDaylightCollection[TimezoneDaylightSeek].XTokensData.size();
 648                                         TimezoneXTokenSeek++){
 649
 650                                         DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].XTokensDataTokens[TimezoneXTokenSeek];
 651                                         DataLine += ":";
 652                                         DataLine += TimezoneDaylightCollection[TimezoneDaylightSeek].XTokensData[TimezoneXTokenSeek];
 653                                         DataLine += "\n";
 654
 655                                         DataLineProcessed = OutputText(&DataLine);
 656
 657                                         *SaveData += DataLineProcessed;
 658
 659                                         DataLine.clear();
 660                                         DataLineProcessed.clear();
 661
 662                                 }
 663
 664                         }
 665
 666                         *SaveData += "END:DAYLIGHT\n";
 667
 668                 }
 669
 670         }
 671
 672         *SaveData += "END:VTIMEZONE\n";
 673
 674 }