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 }