source/objects/calendartimezone/CalendarTimezone-Save.cpp

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