source/objects/calendarevent/CalendarEvent-Save.cpp

   1 #include "CalendarEvent.h"
   2
   3 using namespace std;
   4
   5 void CalendarEventObject::SaveObjectData(string *SaveData){
   6
   7         string DataLine = "";
   8         string DataLineProcessed = "";
   9
  10         *SaveData += "BEGIN:VEVENT\n";
  11
  12         // Process the UID.
  13
  14         if (UniqueID.size() > 0){
  15
  16                 if (UniqueIDTokens.size() > 0){
  17
  18                         DataLine += "UID;";
  19                         DataLine += UniqueIDTokens;
  20
  21                 } else {
  22
  23                         DataLine += "UID";
  24
  25                 }
  26
  27                 DataLine += ":";
  28                 DataLine += UniqueID;
  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 DTSTAMP.
  41
  42         if (DateTimeStampData.size() > 0){
  43
  44                 if (DateTimeStampTokens.size() > 0){
  45
  46                         DataLine += "DTSTAMP;";
  47                         DataLine += DateTimeStampTokens;
  48
  49                 } else {
  50
  51                         DataLine += "DTSTAMP";
  52
  53                 }
  54
  55                 DataLine += ":";
  56                 DataLine += DateTimeStampData;
  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 DTSTART.
  69
  70         if (DateTimeStartData.size() > 0){
  71
  72                 DataLine += "DTSTART";
  73
  74                 if (DateTimeStartDataValue.size() > 0){
  75
  76                         DataLine += ";VALUE=";
  77                         DataLine += DateTimeStartDataValue;
  78
  79                 }
  80
  81                 if (DateTimeStartDataTimeZoneID.size() > 0){
  82
  83                         DataLine += ";TZID=";
  84                         DataLine += DateTimeStartDataTimeZoneID;
  85
  86                 }
  87
  88                 if (DateTimeStartDataTokens.size() > 0){
  89
  90                         DataLine += ";";
  91                         DataLine += DateTimeStartDataTokens;
  92
  93                 }
  94
  95                 DataLine += ":";
  96                 DataLine += DateTimeStartData;
  97                 DataLine += "\n";
  98
  99                 DataLineProcessed = OutputText(&DataLine);
 100
 101                 *SaveData += DataLineProcessed;
 102
 103                 DataLine.clear();
 104                 DataLineProcessed.clear();
 105
 106         }
 107
 108         // Process the DTEND.
 109
 110         if (DateTimeEndData.size() > 0){
 111
 112                 DataLine += "DTEND";
 113
 114                 if (DateTimeEndDataValue.size() > 0){
 115
 116                         DataLine += ";VALUE=";
 117                         DataLine += DateTimeEndDataValue;
 118
 119                 }
 120
 121                 if (DateTimeEndDataTimeZoneID.size() > 0){
 122
 123                         DataLine += ";TZID=";
 124                         DataLine += DateTimeEndDataTimeZoneID;
 125
 126                 }
 127
 128                 if (DateTimeEndDataTokens.size() > 0){
 129
 130                         DataLine += ";";
 131                         DataLine += DateTimeEndDataTokens;
 132
 133                 }
 134
 135                 DataLine += ":";
 136                 DataLine += DateTimeEndData;
 137                 DataLine += "\n";
 138
 139                 DataLineProcessed = OutputText(&DataLine);
 140
 141                 *SaveData += DataLineProcessed;
 142
 143                 DataLine.clear();
 144                 DataLineProcessed.clear();
 145
 146         }
 147
 148         // Process the SUMMARY.
 149
 150         if (SummaryData.size() > 0){
 151
 152                 DataLine += "SUMMARY";
 153
 154                 if (SummaryDataAltRep.size() > 0){
 155
 156                         DataLine += ";ALTREP=\"";
 157                         DataLine += SummaryDataAltRep;
 158                         DataLine += "\"";
 159
 160                 }
 161
 162                 if (SummaryDataLanguage.size() > 0){
 163
 164                         DataLine += ";LANGUAGE=";
 165                         DataLine += SummaryDataLanguage;
 166
 167                 }
 168
 169                 if (SummaryDataTokens.size() > 0){
 170
 171                         DataLine += ";";
 172                         DataLine += SummaryDataTokens;
 173
 174                 }
 175
 176                 DataLine += ":";
 177                 DataLine += SummaryData;
 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 CLASS value.
 190
 191         if (ClassData.size() > 0){
 192
 193                 if (ClassDataTokens.size() > 0){
 194
 195                         DataLine += "CLASS;";
 196                         DataLine += ClassDataTokens;
 197
 198                 } else {
 199
 200                         DataLine += "CLASS";
 201
 202                 }
 203
 204                 DataLine += ":";
 205                 DataLine += ClassData;
 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 CREATED value.
 218
 219         if (DateTimeCreatedData.size() > 0){
 220
 221                 if (DateTimeCreatedTokens.size() > 0){
 222
 223                         DataLine += "CREATED;";
 224                         DataLine += DateTimeCreatedTokens;
 225
 226                 } else {
 227
 228                         DataLine += "CREATED";
 229
 230                 }
 231
 232                 DataLine += ":";
 233                 DataLine += DateTimeCreatedData;
 234                 DataLine += "\n";
 235
 236                 DataLineProcessed = OutputText(&DataLine);
 237
 238                 *SaveData += DataLineProcessed;
 239
 240                 DataLine.clear();
 241                 DataLineProcessed.clear();
 242
 243         }
 244
 245         // Process the DESCRIPTION values. Write out the
 246         // first DESCRPITION only as per RFC5545 specifcation.
 247
 248         if (DescriptionList.size() > 0){
 249
 250                 DataLine += "DESCRIPTION";
 251
 252                 if (DescriptionListAltRep[0].size() > 0){
 253
 254                         DataLine += ";ALTREP=\"";
 255                         DataLine += DescriptionListAltRep[0];
 256                         DataLine += "\"";
 257
 258                 }
 259
 260                 if (DescriptionListLanguage[0].size() > 0){
 261
 262                         DataLine += ";LANGUAGE=";
 263                         DataLine += DescriptionListLanguage[0];
 264
 265                 }
 266
 267                 if (DescriptionListTokens[0].size() > 0){
 268
 269                         DataLine += ";";
 270                         DataLine += DescriptionListTokens[0];
 271
 272                 }
 273
 274                 DataLine += ":";
 275                 DataLine += DescriptionList[0];
 276                 DataLine += "\n";
 277
 278                 DataLineProcessed = OutputText(&DataLine);
 279
 280                 *SaveData += DataLineProcessed;
 281
 282                 DataLine.clear();
 283                 DataLineProcessed.clear();
 284
 285         }
 286
 287         // Process the GEO value.
 288
 289         if (GeographicData.size() > 0){
 290
 291                 if (GeographicTokens.size() > 0){
 292
 293                         DataLine += "GEO;";
 294                         DataLine += GeographicTokens;
 295
 296                 } else {
 297
 298                         DataLine += "GEO";
 299
 300                 }
 301
 302                 DataLine += ":";
 303                 DataLine += GeographicData;
 304                 DataLine += "\n";
 305
 306                 DataLineProcessed = OutputText(&DataLine);
 307
 308                 *SaveData += DataLineProcessed;
 309
 310                 DataLine.clear();
 311                 DataLineProcessed.clear();
 312
 313         }
 314
 315         // Process the LAST-MODIFIED value.
 316
 317         if (LastModifiedData.size() > 0){
 318
 319                 if (LastModifiedTokens.size() > 0){
 320
 321                         DataLine += "LAST-MODIFIED;";
 322                         DataLine += LastModifiedTokens;
 323
 324                 } else {
 325
 326                         DataLine += "LAST-MODIFIED";
 327
 328                 }
 329
 330                 DataLine += ":";
 331                 DataLine += LastModifiedData;
 332                 DataLine += "\n";
 333
 334                 DataLineProcessed = OutputText(&DataLine);
 335
 336                 *SaveData += DataLineProcessed;
 337
 338                 DataLine.clear();
 339                 DataLineProcessed.clear();
 340
 341         }
 342
 343         // Process the LOCATION value.
 344
 345         if (LocationData.size() > 0){
 346
 347                 DataLine += "LOCATION";
 348
 349                 if (LocationDataAltRep.size() > 0){
 350
 351                         DataLine += ";ALTREP=\"";
 352                         DataLine += LocationDataAltRep;
 353                         DataLine += "\"";
 354
 355                 }
 356
 357                 if (LocationDataLanguage.size() > 0){
 358
 359                         DataLine += ";LANGUAGE=";
 360                         DataLine += LocationDataLanguage;
 361
 362                 }
 363
 364                 if (LocationDataTokens.size() > 0){
 365
 366                         DataLine += ";";
 367                         DataLine += LocationDataTokens;
 368
 369                 }
 370
 371                 DataLine += ":";
 372                 DataLine += LocationData;
 373                 DataLine += "\n";
 374
 375                 DataLineProcessed = OutputText(&DataLine);
 376
 377                 *SaveData += DataLineProcessed;
 378
 379                 DataLine.clear();
 380                 DataLineProcessed.clear();
 381
 382         }
 383
 384         // Process the ORGANIZER value.
 385
 386         if (OrganiserData.size() > 0){
 387
 388                 DataLine += "ORGANIZER";
 389
 390                 if (OrganiserDataCommonName.size() > 0){
 391
 392                         DataLine += ";CN=";
 393                         DataLine += OrganiserDataCommonName;
 394
 395                 }
 396
 397                 if (OrganiserDataDirectoryEntry.size() > 0){
 398
 399                         DataLine += ";DIR=\"";
 400                         DataLine += OrganiserDataDirectoryEntry;
 401                         DataLine += "\"";
 402
 403                 }
 404
 405                 if (OrganiserDataSentByParam.size() > 0){
 406
 407                         DataLine += ";SENT-BY=\"";
 408                         DataLine += OrganiserDataSentByParam;
 409                         DataLine += "\"";
 410
 411                 }
 412
 413                 if (OrganiserDataLanguage.size() > 0){
 414
 415                         DataLine += ";LANGUAGE=";
 416                         DataLine += OrganiserDataLanguage;
 417
 418                 }
 419
 420                 if (OrganiserDataTokens.size() > 0){
 421
 422                         DataLine += ";";
 423                         DataLine += OrganiserDataTokens;
 424
 425                 }
 426
 427                 DataLine += ":";
 428                 DataLine += OrganiserData;
 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 PRIORITY value.
 441
 442         if (PriorityData > -1 && PriorityData < 10){
 443
 444                 DataLine += "PRIORITY";
 445
 446                 if (PriorityTokens.size() > 0){
 447
 448                         DataLine += ";";
 449                         DataLine += PriorityTokens;
 450
 451                 }
 452
 453                 DataLine += ":";
 454                 DataLine += to_string(PriorityData);
 455                 DataLine += "\n";
 456
 457                 DataLineProcessed = OutputText(&DataLine);
 458
 459                 *SaveData += DataLineProcessed;
 460
 461                 DataLine.clear();
 462                 DataLineProcessed.clear();
 463
 464         }
 465
 466         // Process the SEQUENCE value.
 467
 468         if (SequenceData > -1 && SequenceData < 10){
 469
 470                 DataLine += "SEQUENCE";
 471
 472                 if (SequenceTokens.size() > 0){
 473
 474                         DataLine += ";";
 475                         DataLine += SequenceTokens;
 476
 477                 }
 478
 479                 DataLine += ":";
 480                 DataLine += to_string(SequenceData);
 481                 DataLine += "\n";
 482
 483                 DataLineProcessed = OutputText(&DataLine);
 484
 485                 *SaveData += DataLineProcessed;
 486
 487                 DataLine.clear();
 488                 DataLineProcessed.clear();
 489
 490         }
 491
 492         // Process the STATUS value.
 493
 494         if (StatusData.size() > 0){
 495
 496                 DataLine += "STATUS";
 497
 498                 if (StatusLanguage.size() > 0){
 499
 500                         DataLine += ";LANGUAGE=";
 501                         DataLine += StatusLanguage;
 502
 503                 }
 504
 505                 if (StatusTokens.size() > 0){
 506
 507                         DataLine += ";";
 508                         DataLine += StatusTokens;
 509
 510                 }
 511
 512                 DataLine += ":";
 513                 DataLine += StatusData;
 514                 DataLine += "\n";
 515
 516                 DataLineProcessed = OutputText(&DataLine);
 517
 518                 *SaveData += DataLineProcessed;
 519
 520                 DataLine.clear();
 521                 DataLineProcessed.clear();
 522
 523         }
 524
 525         // Process the TRANSP value.
 526
 527         if (TimeTransparencyData.size() > 0){
 528
 529                 DataLine += "TRANSP";
 530
 531                 if (TimeTransparencyDataTokens.size() > 0){
 532
 533                         DataLine += ";";
 534                         DataLine += TimeTransparencyDataTokens;
 535
 536                 }
 537
 538                 DataLine += ":";
 539                 DataLine += TimeTransparencyData;
 540                 DataLine += "\n";
 541
 542                 DataLineProcessed = OutputText(&DataLine);
 543
 544                 *SaveData += DataLineProcessed;
 545
 546                 DataLine.clear();
 547                 DataLineProcessed.clear();
 548
 549         }
 550
 551         // Process the URL value.
 552
 553         if (URLData.size() > 0){
 554
 555                 DataLine += "URL";
 556
 557                 if (URLDataTokens.size() > 0){
 558
 559                         DataLine += ";";
 560                         DataLine += URLDataTokens;
 561
 562                 }
 563
 564                 DataLine += ":";
 565                 DataLine += URLData;
 566                 DataLine += "\n";
 567
 568                 DataLineProcessed = OutputText(&DataLine);
 569
 570                 *SaveData += DataLineProcessed;
 571
 572                 DataLine.clear();
 573                 DataLineProcessed.clear();
 574
 575         }
 576
 577         // Process the RECURRENCE-ID value.
 578
 579         if (RecurranceIDData.size() > 0){
 580
 581                 DataLine += "RECURRENCE-ID";
 582
 583                 if (RecurranceIDDataTimeZoneParam.size() > 0){
 584
 585                         DataLine += ";TZID=";
 586                         DataLine += RecurranceIDDataTimeZoneParam;
 587
 588                 }
 589
 590                 if (RecurranceIDDataRangeParam.size() > 0){
 591
 592                         DataLine += ";RANGE=";
 593                         DataLine += RecurranceIDDataRangeParam;
 594
 595                 }
 596
 597                 if (RecurranceIDDataValue.size() > 0){
 598
 599                         DataLine += ";VALUE=";
 600                         DataLine += RecurranceIDDataValue;
 601
 602                 }
 603
 604                 if (RecurranceIDDataTokens.size() > 0){
 605
 606                         DataLine += ";";
 607                         DataLine += RecurranceIDDataTokens;
 608
 609                 }
 610
 611                 DataLine += ":";
 612                 DataLine += RecurranceIDData;
 613                 DataLine += "\n";
 614
 615                 DataLineProcessed = OutputText(&DataLine);
 616
 617                 *SaveData += DataLineProcessed;
 618
 619                 DataLine.clear();
 620                 DataLineProcessed.clear();
 621
 622         }
 623
 624         // Process the DURATION value.
 625
 626         if (DurationData.size() > 0){
 627
 628                 DataLine += "DURATION";
 629
 630                 if (DurationDataTokens.size() > 0){
 631
 632                         DataLine += ";";
 633                         DataLine += DurationDataTokens;
 634
 635                 }
 636
 637                 DataLine += ":";
 638                 DataLine += DurationData;
 639                 DataLine += "\n";
 640
 641                 DataLineProcessed = OutputText(&DataLine);
 642
 643                 *SaveData += DataLineProcessed;
 644
 645                 DataLine.clear();
 646                 DataLineProcessed.clear();
 647
 648         }
 649
 650         // Process the RRULE value.
 651
 652         if (RecurranceRuleData.size() > 0){
 653
 654                 DataLine += "RRULE";
 655
 656                 if (RecurranceRuleDataTokens.size() > 0){
 657
 658                         DataLine += ";";
 659                         DataLine += RecurranceRuleDataTokens;
 660
 661                 }
 662
 663                 DataLine += ":";
 664                 DataLine += RecurranceRuleData;
 665                 DataLine += "\n";
 666
 667                 DataLineProcessed = OutputText(&DataLine);
 668
 669                 *SaveData += DataLineProcessed;
 670
 671                 DataLine.clear();
 672                 DataLineProcessed.clear();
 673
 674         }
 675
 676         // Process the ATTACH values.
 677
 678         if (AttachList.size() > 0){
 679
 680                 for (int AttachListSeek = 0; AttachListSeek < AttachList.size();
 681                         AttachListSeek++){
 682
 683                         DataLine += "ATTACH";
 684
 685                         if (AttachListFormatType[AttachListSeek].size() > 0){
 686
 687                                 DataLine += ";FMTTYPE=";
 688                                 DataLine += AttachListFormatType[AttachListSeek];
 689
 690                         }
 691
 692                         if (AttachListValue[AttachListSeek].size() > 0){
 693
 694                                 DataLine += ";VALUE=";
 695                                 DataLine += AttachListValue[AttachListSeek];
 696
 697                         }
 698
 699                         if (AttachListEncoding[AttachListSeek].size() > 0){
 700
 701                                 DataLine += ";ENCODING=";
 702                                 DataLine += AttachListEncoding[AttachListSeek];
 703
 704                         }
 705
 706                         if (AttachListTokens[AttachListSeek].size() > 0){
 707
 708                                 DataLine += ";";
 709                                 DataLine += AttachListTokens[AttachListSeek];
 710
 711                         }
 712
 713                         DataLine += ":";
 714                         DataLine += AttachList[AttachListSeek];
 715                         DataLine += "\n";
 716
 717                         DataLineProcessed = OutputText(&DataLine);
 718
 719                         *SaveData += DataLineProcessed;
 720
 721                         DataLine.clear();
 722                         DataLineProcessed.clear();
 723
 724                 }
 725
 726         }
 727
 728         // Process the ATTENDEE value.
 729
 730         if (AttendeeList.size() > 0){
 731
 732                 for (int AttendeeListSeek = 0; AttendeeListSeek < AttendeeList.size();
 733                         AttendeeListSeek++){
 734
 735                         DataLine += "ATTENDEE";
 736
 737                         if (AttendeeListMember[AttendeeListSeek].size() > 0){
 738
 739                                 DataLine += ";MEMBER=\"";
 740                                 DataLine += AttendeeListMember[AttendeeListSeek];
 741                                 DataLine += "\"";
 742
 743                         }
 744
 745                         if (AttendeeListDelegatedFrom[AttendeeListSeek].size() > 0){
 746
 747                                 DataLine += ";DELEGATED-FROM=\"";
 748                                 DataLine += AttendeeListDelegatedFrom[AttendeeListSeek];
 749                                 DataLine += "\"";
 750
 751                         }
 752
 753                         if (AttendeeListDelegatedTo[AttendeeListSeek].size() > 0){
 754
 755                                 DataLine += ";DELEGATED-TO=\"";
 756                                 DataLine += AttendeeListDelegatedTo[AttendeeListSeek];
 757                                 DataLine += "\"";
 758
 759                         }
 760
 761                         if (AttendeeListRole[AttendeeListSeek].size() > 0){
 762
 763                                 DataLine += ";ROLE=";
 764                                 DataLine += AttendeeListRole[AttendeeListSeek];
 765
 766                         }
 767
 768                         if (AttendeeListRSVP[AttendeeListSeek].size() > 0){
 769
 770                                 DataLine += ";RSVP=";
 771                                 DataLine += AttendeeListRSVP[AttendeeListSeek];
 772
 773                         }
 774
 775                         if (AttendeeListDirectoryEntry[AttendeeListSeek].size() > 0){
 776
 777                                 DataLine += ";DIR=\"";
 778                                 DataLine += AttendeeListDirectoryEntry[AttendeeListSeek];
 779                                 DataLine += "\"";
 780
 781                         }
 782
 783                         if (AttendeeListSentBy[AttendeeListSeek].size() > 0){
 784
 785                                 DataLine += ";SENT-BY=\"";
 786                                 DataLine += AttendeeListSentBy[AttendeeListSeek];
 787                                 DataLine += "\"";
 788
 789                         }
 790
 791                         if (AttendeeListCommonName[AttendeeListSeek].size() > 0){
 792
 793                                 DataLine += ";CN=\"";
 794                                 DataLine += AttendeeListCommonName[AttendeeListSeek];
 795                                 DataLine += "\"";
 796
 797                         }
 798
 799                         if (AttendeeListCalendarUserType[AttendeeListSeek].size() > 0){
 800
 801                                 DataLine += ";CUTYPE=";
 802                                 DataLine += AttendeeListCalendarUserType[AttendeeListSeek];
 803
 804                         }
 805
 806                         if (AttendeeListParticipationStatus[AttendeeListSeek].size() > 0){
 807
 808                                 DataLine += ";PARTSTAT=";
 809                                 DataLine += AttendeeListParticipationStatus[AttendeeListSeek];
 810
 811                         }
 812
 813                         if (AttendeeListLanguage[AttendeeListSeek].size() > 0){
 814
 815                                 DataLine += ";LANGUAGE=";
 816                                 DataLine += AttendeeListLanguage[AttendeeListSeek];
 817
 818                         }
 819
 820                         if (AttendeeListTokens[AttendeeListSeek].size() > 0){
 821
 822                                 DataLine += ";";
 823                                 DataLine += AttendeeListTokens[AttendeeListSeek];
 824
 825                         }
 826
 827                         DataLine += ":";
 828                         DataLine += AttendeeList[AttendeeListSeek];
 829                         DataLine += "\n";
 830
 831                         DataLineProcessed = OutputText(&DataLine);
 832
 833                         *SaveData += DataLineProcessed;
 834
 835                         DataLine.clear();
 836                         DataLineProcessed.clear();
 837
 838                 }
 839
 840         }
 841
 842         // Process the CATEGORIES value.
 843
 844         if (CategoriesList.size() > 0){
 845
 846                 for (int CategoriesListSeek = 0; CategoriesListSeek < CategoriesList.size();
 847                         CategoriesListSeek++){
 848
 849                         DataLine += "CATEGORIES";
 850
 851                         if (CategoriesListLanguage[CategoriesListSeek].size() > 0){
 852
 853                                 DataLine += ";LANGUAGE=";
 854                                 DataLine += CategoriesListLanguage[CategoriesListSeek];
 855
 856                         }
 857
 858                         if (CategoriesListTokens[CategoriesListSeek].size() > 0){
 859
 860                                 DataLine += ";";
 861                                 DataLine += CategoriesListTokens[CategoriesListSeek];
 862
 863                         }
 864
 865                         DataLine += ":";
 866                         DataLine += CategoriesList[CategoriesListSeek];
 867                         DataLine += "\n";
 868
 869                         DataLineProcessed = OutputText(&DataLine);
 870
 871                         *SaveData += DataLineProcessed;
 872
 873                         DataLine.clear();
 874                         DataLineProcessed.clear();
 875
 876                 }
 877
 878         }
 879
 880         // Process the COMMENT value.
 881
 882         if (CommentList.size() > 0){
 883
 884                 for (int CommentListSeek = 0; CommentListSeek < CommentList.size();
 885                         CommentListSeek++){
 886
 887                         DataLine += "COMMENT";
 888
 889                         if (CommentListAltRep[CommentListSeek].size() > 0){
 890
 891                                 DataLine += ";ALTREP=\"";
 892                                 DataLine += CommentListAltRep[CommentListSeek];
 893                                 DataLine += "\"";
 894
 895                         }
 896
 897                         if (CommentListLanguage[CommentListSeek].size() > 0){
 898
 899                                 DataLine += ";LANGUAGE=";
 900                                 DataLine += CommentListLanguage[CommentListSeek];
 901
 902                         }
 903
 904                         if (CommentListTokens[CommentListSeek].size() > 0){
 905
 906                                 DataLine += ";";
 907                                 DataLine += CommentListTokens[CommentListSeek];
 908
 909                         }
 910
 911                         DataLine += ":";
 912                         DataLine += CommentList[CommentListSeek];
 913                         DataLine += "\n";
 914
 915                         DataLineProcessed = OutputText(&DataLine);
 916
 917                         *SaveData += DataLineProcessed;
 918
 919                         DataLine.clear();
 920                         DataLineProcessed.clear();
 921
 922                 }
 923
 924         }
 925
 926         // Process the CONTACT value.
 927
 928         if (ContactList.size() > 0){
 929
 930                 for (int ContactListSeek = 0; ContactListSeek < ContactList.size();
 931                         ContactListSeek++){
 932
 933                         DataLine += "CONTACT";
 934
 935                         if (ContactListAltRep[ContactListSeek].size() > 0){
 936
 937                                 DataLine += ";ALTREP=\"";
 938                                 DataLine += ContactListAltRep[ContactListSeek];
 939                                 DataLine += "\"";
 940
 941                         }
 942
 943                         if (ContactListLanguage[ContactListSeek].size() > 0){
 944
 945                                 DataLine += ";LANGUAGE=";
 946                                 DataLine += ContactListLanguage[ContactListSeek];
 947
 948                         }
 949
 950                         if (ContactListTokens[ContactListSeek].size() > 0){
 951
 952                                 DataLine += ";";
 953                                 DataLine += ContactListTokens[ContactListSeek];
 954
 955                         }
 956
 957                         DataLine += ":";
 958                         DataLine += ContactList[ContactListSeek];
 959                         DataLine += "\n";
 960
 961                         DataLineProcessed = OutputText(&DataLine);
 962
 963                         *SaveData += DataLineProcessed;
 964
 965                         DataLine.clear();
 966                         DataLineProcessed.clear();
 967
 968                 }
 969
 970         }
 971
 972         // Process the EXDATE value.
 973
 974         if (ExcludeDateData.size() > 0){
 975
 976                 for (int ExcludeDateDataSeek = 0; ExcludeDateDataSeek < ExcludeDateData.size();
 977                         ExcludeDateDataSeek++){
 978
 979                         DataLine += "EXDATE";
 980
 981                         if (ExcludeDateDataTimeZoneParam[ExcludeDateDataSeek].size() > 0){
 982
 983                                 DataLine += ";TZID=";
 984                                 DataLine += ExcludeDateDataTimeZoneParam[ExcludeDateDataSeek];
 985
 986                         }
 987
 988                         if (ExcludeDateDataValue[ExcludeDateDataSeek].size() > 0){
 989
 990                                 DataLine += ";VALUE=";
 991                                 DataLine += ExcludeDateDataValue[ExcludeDateDataSeek];
 992
 993                         }
 994
 995                         if (ExcludeDateDataTokens[ExcludeDateDataSeek].size() > 0){
 996
 997                                 DataLine += ";";
 998                                 DataLine += ExcludeDateDataTokens[ExcludeDateDataSeek];
 999
1000                         }
1001
1002                         DataLine += ":";
1003                         DataLine += ExcludeDateData[ExcludeDateDataSeek];
1004                         DataLine += "\n";
1005
1006                         DataLineProcessed = OutputText(&DataLine);
1007
1008                         *SaveData += DataLineProcessed;
1009
1010                         DataLine.clear();
1011                         DataLineProcessed.clear();
1012
1013                 }
1014
1015         }
1016
1017         // Process the REQUEST-STATUS value.
1018
1019         if (RequestStatusData.size() > 0){
1020
1021                 for (int RequestStatusDataSeek = 0; RequestStatusDataSeek < RequestStatusData.size();
1022                         RequestStatusDataSeek++){
1023
1024                         DataLine += "REQUEST-STATUS";
1025
1026                         if (RequestStatusLanguage[RequestStatusDataSeek].size() > 0){
1027
1028                                 DataLine += ";LANGUAGE=";
1029                                 DataLine += RequestStatusLanguage[RequestStatusDataSeek];
1030
1031                         }
1032
1033                         if (RequestStatusTokens[RequestStatusDataSeek].size() > 0){
1034
1035                                 DataLine += ";";
1036                                 DataLine += RequestStatusTokens[RequestStatusDataSeek];
1037
1038                         }
1039
1040                         DataLine += ":";
1041                         DataLine += RequestStatusData[RequestStatusDataSeek];
1042                         DataLine += "\n";
1043
1044                         DataLineProcessed = OutputText(&DataLine);
1045
1046                         *SaveData += DataLineProcessed;
1047
1048                         DataLine.clear();
1049                         DataLineProcessed.clear();
1050
1051                 }
1052
1053         }
1054
1055         // Process the RELATED-TO value.
1056
1057         if (RelatedToData.size() > 0){
1058
1059                 for (int RequestToDataSeek = 0; RequestToDataSeek < RelatedToData.size();
1060                         RequestToDataSeek++){
1061
1062                         DataLine += "RELATED-TO";
1063
1064                         if (RelatedToDataRelationType[RequestToDataSeek].size() > 0){
1065
1066                                 DataLine += ";RELTYPE=";
1067                                 DataLine += RelatedToDataRelationType[RequestToDataSeek];
1068
1069                         }
1070
1071                         if (RelatedToDataTokens[RequestToDataSeek].size() > 0){
1072
1073                                 DataLine += ";";
1074                                 DataLine += RelatedToDataTokens[RequestToDataSeek];
1075
1076                         }
1077
1078                         DataLine += ":";
1079                         DataLine += RelatedToData[RequestToDataSeek];
1080                         DataLine += "\n";
1081
1082                         DataLineProcessed = OutputText(&DataLine);
1083
1084                         *SaveData += DataLineProcessed;
1085
1086                         DataLine.clear();
1087                         DataLineProcessed.clear();
1088
1089                 }
1090
1091         }
1092
1093         // Process the RESOURCES value.
1094
1095         if (ResourcesData.size() > 0){
1096
1097                 for (int ResourcesDataSeek = 0; ResourcesDataSeek < ResourcesData.size();
1098                         ResourcesDataSeek++){
1099
1100                         DataLine += "RESOURCES";
1101
1102                         if (ResourcesDataAltRep[ResourcesDataSeek].size() > 0){
1103
1104                                 DataLine += ";ALTREP=\"";
1105                                 DataLine += ResourcesDataAltRep[ResourcesDataSeek];
1106                                 DataLine += "\"";
1107
1108                         }
1109
1110                         if (ResourcesDataLanguage[ResourcesDataSeek].size() > 0){
1111
1112                                 DataLine += ";LANGUAGE=";
1113                                 DataLine += ResourcesDataLanguage[ResourcesDataSeek];
1114
1115                         }
1116
1117                         if (ResourcesDataTokens[ResourcesDataSeek].size() > 0){
1118
1119                                 DataLine += ";";
1120                                 DataLine += ResourcesDataTokens[ResourcesDataSeek];
1121
1122                         }
1123
1124                         DataLine += ":";
1125                         DataLine += ResourcesData[ResourcesDataSeek];
1126                         DataLine += "\n";
1127
1128                         DataLineProcessed = OutputText(&DataLine);
1129
1130                         *SaveData += DataLineProcessed;
1131
1132                         DataLine.clear();
1133                         DataLineProcessed.clear();
1134
1135                 }
1136
1137         }
1138
1139         // Process the RDATE value.
1140
1141         if (RecurranceDateData.size() > 0){
1142
1143                 for (int RecurranceDateDataSeek = 0; RecurranceDateDataSeek < RecurranceDateData.size();
1144                         RecurranceDateDataSeek++){
1145
1146                         DataLine += "RDATE";
1147
1148                         if (RecurranceDateDataValue[RecurranceDateDataSeek].size() > 0){
1149
1150                                 DataLine += ";VALUE=";
1151                                 DataLine += RecurranceDateDataValue[RecurranceDateDataSeek];
1152
1153                         }
1154
1155                         if (RecurranceDateDataTimeZoneParam[RecurranceDateDataSeek].size() > 0){
1156
1157                                 DataLine += ";TZID=";
1158                                 DataLine += RecurranceDateDataTimeZoneParam[RecurranceDateDataSeek];
1159
1160                         }
1161
1162                         if (RecurranceDateDataTokens[RecurranceDateDataSeek].size() > 0){
1163
1164                                 DataLine += ";";
1165                                 DataLine += RecurranceDateDataTokens[RecurranceDateDataSeek];
1166
1167                         }
1168
1169                         DataLine += ":";
1170                         DataLine += RecurranceDateData[RecurranceDateDataSeek];
1171                         DataLine += "\n";
1172
1173                         DataLineProcessed = OutputText(&DataLine);
1174
1175                         *SaveData += DataLineProcessed;
1176
1177                         DataLine.clear();
1178                         DataLineProcessed.clear();
1179
1180                 }
1181
1182         }
1183
1184         // Process the VALARMS.
1185
1186         if (CalendarAlarmData.size() > 0){
1187
1188                 for (int CalendarAlarmDataSeek = 0; CalendarAlarmDataSeek < CalendarAlarmData.size();
1189                         CalendarAlarmDataSeek++){
1190
1191                         *SaveData += "BEGIN:VALARM\n";
1192
1193                         // Process the ACTION VALARM value.
1194
1195                         DataLine += "ACTION";
1196
1197                         if (CalendarAlarmData[CalendarAlarmDataSeek].AlarmActionTokens.size() > 0){
1198
1199                                 DataLine += ";";
1200                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AlarmActionTokens;
1201
1202                         }
1203
1204                         DataLine += ":";
1205                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AlarmAction;
1206                         DataLine += "\n";
1207
1208                         DataLineProcessed = OutputText(&DataLine);
1209
1210                         *SaveData += DataLineProcessed;
1211
1212                         DataLine.clear();
1213                         DataLineProcessed.clear();
1214
1215                         // Process the TRIGGER VALARM value.
1216
1217                         if (CalendarAlarmData[CalendarAlarmDataSeek].TriggerData.size() > 0){
1218
1219                                 DataLine += "TRIGGER";
1220
1221                                 if (CalendarAlarmData[CalendarAlarmDataSeek].TriggerRelated.size() > 0){
1222
1223                                         DataLine += ";RELATED=";
1224                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].TriggerRelated;
1225
1226                                 }
1227
1228                                 if (CalendarAlarmData[CalendarAlarmDataSeek].TriggerValue.size() > 0){
1229
1230                                         DataLine += ";VALUE=";
1231                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].TriggerValue;
1232
1233                                 }
1234
1235                                 if (CalendarAlarmData[CalendarAlarmDataSeek].TriggerTokens.size() > 0){
1236
1237                                         DataLine += ";";
1238                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].TriggerTokens;
1239
1240                                 }
1241
1242                                 DataLine += ":";
1243                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].TriggerData;
1244                                 DataLine += "\n";
1245
1246                                 DataLineProcessed = OutputText(&DataLine);
1247
1248                                 *SaveData += DataLineProcessed;
1249
1250                                 DataLine.clear();
1251                                 DataLineProcessed.clear();
1252
1253                         }
1254
1255                         // Process the DURATION VALARM value.
1256
1257                         if (CalendarAlarmData[CalendarAlarmDataSeek].DurationData.size() > 0){
1258
1259                                 DataLine += "DURATION";
1260
1261                                 if (CalendarAlarmData[CalendarAlarmDataSeek].DurationTokens.size() > 0){
1262
1263                                         DataLine += ";";
1264                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DurationTokens;
1265
1266                                 }
1267
1268                                 DataLine += ":";
1269                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DurationData;
1270                                 DataLine += "\n";
1271
1272                                 DataLineProcessed = OutputText(&DataLine);
1273
1274                                 *SaveData += DataLineProcessed;
1275
1276                                 DataLine.clear();
1277                                 DataLineProcessed.clear();
1278
1279                         }
1280
1281                         // Process the DESCRIPTION VALARM value.
1282
1283                         if (CalendarAlarmData[CalendarAlarmDataSeek].DescriptionData.size() > 0){
1284
1285                                 DataLine += "DESCRIPTION";
1286
1287                                 if (CalendarAlarmData[CalendarAlarmDataSeek].DescriptionAltRep.size() > 0){
1288
1289                                         DataLine += ";ALTREP=\"";
1290                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DescriptionAltRep;
1291                                         DataLine += "\"";
1292
1293                                 }
1294
1295                                 if (CalendarAlarmData[CalendarAlarmDataSeek].DescriptionLanguage.size() > 0){
1296
1297                                         DataLine += ";LANGUAGE=";
1298                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DescriptionLanguage;
1299
1300                                 }
1301
1302                                 if (CalendarAlarmData[CalendarAlarmDataSeek].DescriptionTokens.size() > 0){
1303
1304                                         DataLine += ";";
1305                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DescriptionTokens;
1306
1307                                 }
1308
1309                                 DataLine += ":";
1310                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DescriptionData;
1311                                 DataLine += "\n";
1312
1313                                 DataLineProcessed = OutputText(&DataLine);
1314
1315                                 *SaveData += DataLineProcessed;
1316
1317                                 DataLine.clear();
1318                                 DataLineProcessed.clear();
1319
1320                         }
1321
1322                         // Process the SUMMARY VALARM value.
1323
1324                         if (CalendarAlarmData[CalendarAlarmDataSeek].SummaryData.size() > 0){
1325
1326                                 DataLine += "SUMMARY";
1327
1328                                 if (CalendarAlarmData[CalendarAlarmDataSeek].SummaryAltRep.size() > 0){
1329
1330                                         DataLine += ";ALTREP=\"";
1331                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].SummaryAltRep;
1332                                         DataLine += "\"";
1333
1334                                 }
1335
1336                                 if (CalendarAlarmData[CalendarAlarmDataSeek].SummaryLanguage.size() > 0){
1337
1338                                         DataLine += ";LANGUAGE=";
1339                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].SummaryLanguage;
1340
1341                                 }
1342
1343                                 if (CalendarAlarmData[CalendarAlarmDataSeek].SummaryTokens.size() > 0){
1344
1345                                         DataLine += ";";
1346                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].SummaryTokens;
1347
1348                                 }
1349
1350                                 DataLine += ":";
1351                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].SummaryData;
1352                                 DataLine += "\n";
1353
1354                                 DataLineProcessed = OutputText(&DataLine);
1355
1356                                 *SaveData += DataLineProcessed;
1357
1358                                 DataLine.clear();
1359                                 DataLineProcessed.clear();
1360
1361                         }
1362
1363                         // Process the REPEAT VALARM value.
1364
1365                         if (CalendarAlarmData[CalendarAlarmDataSeek].RepeatData.size() > 0){
1366
1367                                 DataLine += "REPEAT";
1368
1369                                 if (CalendarAlarmData[CalendarAlarmDataSeek].RepeatTokens.size() > 0){
1370
1371                                         DataLine += ";";
1372                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].RepeatTokens;
1373
1374                                 }
1375
1376                                 DataLine += ":";
1377                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].RepeatData;
1378                                 DataLine += "\n";
1379
1380                                 DataLineProcessed = OutputText(&DataLine);
1381
1382                                 *SaveData += DataLineProcessed;
1383
1384                                 DataLine.clear();
1385                                 DataLineProcessed.clear();
1386
1387                         }
1388
1389                         // Process the ATTENDEE VALARM values.
1390
1391                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeList.size() > 0){
1392
1393                                 for (int AttendeeListSeek = 0; AttendeeListSeek < CalendarAlarmData[CalendarAlarmDataSeek].AttendeeList.size();
1394                                         AttendeeListSeek++){
1395
1396                                         DataLine += "ATTENDEE";
1397
1398                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListMember[AttendeeListSeek].size() > 0){
1399
1400                                                 DataLine += ";MEMBER=\"";
1401                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListMember[AttendeeListSeek];
1402                                                 DataLine += "\"";
1403
1404                                         }
1405
1406                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDelegatedFrom[AttendeeListSeek].size() > 0){
1407
1408                                                 DataLine += ";DELEGATED-FROM=\"";
1409                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDelegatedFrom[AttendeeListSeek];
1410                                                 DataLine += "\"";
1411
1412                                         }
1413
1414                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDelegatedTo[AttendeeListSeek].size() > 0){
1415
1416                                                 DataLine += ";DELEGATED-TO=\"";
1417                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDelegatedTo[AttendeeListSeek];
1418                                                 DataLine += "\"";
1419
1420                                         }
1421
1422                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListRole[AttendeeListSeek].size() > 0){
1423
1424                                                 DataLine += ";ROLE=";
1425                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListRole[AttendeeListSeek];
1426
1427                                         }
1428
1429                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListRSVP[AttendeeListSeek].size() > 0){
1430
1431                                                 DataLine += ";RSVP=";
1432                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListRSVP[AttendeeListSeek];
1433
1434                                         }
1435
1436                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDirectoryEntry[AttendeeListSeek].size() > 0){
1437
1438                                                 DataLine += ";DIR=\"";
1439                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDirectoryEntry[AttendeeListSeek];
1440                                                 DataLine += "\"";
1441
1442                                         }
1443
1444                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListSentBy[AttendeeListSeek].size() > 0){
1445
1446                                                 DataLine += ";SENT-BY=\"";
1447                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListSentBy[AttendeeListSeek];
1448                                                 DataLine += "\"";
1449
1450                                         }
1451
1452                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListCommonName[AttendeeListSeek].size() > 0){
1453
1454                                                 DataLine += ";CN=\"";
1455                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListCommonName[AttendeeListSeek];
1456                                                 DataLine += "\"";
1457
1458                                         }
1459
1460                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListCalendarUserType[AttendeeListSeek].size() > 0){
1461
1462                                                 DataLine += ";CUTYPE=";
1463                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListCalendarUserType[AttendeeListSeek];
1464
1465                                         }
1466
1467                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListParticipationStatus[AttendeeListSeek].size() > 0){
1468
1469                                                 DataLine += ";PARTSTAT=";
1470                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListParticipationStatus[AttendeeListSeek];
1471
1472                                         }
1473
1474                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListLanguage[AttendeeListSeek].size() > 0){
1475
1476                                                 DataLine += ";LANGUAGE=";
1477                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListLanguage[AttendeeListSeek];
1478
1479                                         }
1480
1481                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListTokens[AttendeeListSeek].size() > 0){
1482
1483                                                 DataLine += ";";
1484                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListTokens[AttendeeListSeek];
1485
1486                                         }
1487
1488                                         DataLine += ":";
1489                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeList[AttendeeListSeek];
1490                                         DataLine += "\n";
1491
1492                                         DataLineProcessed = OutputText(&DataLine);
1493
1494                                         *SaveData += DataLineProcessed;
1495
1496                                         DataLine.clear();
1497                                         DataLineProcessed.clear();
1498
1499                                 }
1500
1501                         }
1502
1503                         // Process the ATTACH VALARM values.
1504
1505                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttachList.size() > 0){
1506
1507                                 for (int AttachListSeek = 0; AttachListSeek < CalendarAlarmData[CalendarAlarmDataSeek].AttachList.size();
1508                                         AttachListSeek++){
1509
1510                                         DataLine += "ATTACH";
1511
1512                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttachListFormatType[AttachListSeek].size() > 0){
1513
1514                                                 DataLine += ";FMTTYPE=";
1515                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttachListFormatType[AttachListSeek];
1516
1517                                         }
1518
1519                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttachListValue[AttachListSeek].size() > 0){
1520
1521                                                 DataLine += ";VALUE=";
1522                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttachListValue[AttachListSeek];
1523
1524                                         }
1525
1526                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttachListEncoding[AttachListSeek].size() > 0){
1527
1528                                                 DataLine += ";ENCODING=";
1529                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttachListEncoding[AttachListSeek];
1530
1531                                         }
1532
1533                                         if (CalendarAlarmData[CalendarAlarmDataSeek].AttachListTokens[AttachListSeek].size() > 0){
1534
1535                                                 DataLine += ";";
1536                                                 DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttachListTokens[AttachListSeek];
1537
1538                                         }
1539
1540                                         DataLine += ":";
1541                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttachList[AttachListSeek];
1542                                         DataLine += "\n";
1543
1544                                         DataLineProcessed = OutputText(&DataLine);
1545
1546                                         *SaveData += DataLineProcessed;
1547
1548                                         DataLine.clear();
1549                                         DataLineProcessed.clear();
1550
1551                                 }
1552
1553                         }
1554
1555                         // Process the X-Token VALARM values.
1556
1557                         if (CalendarAlarmData[CalendarAlarmDataSeek].XTokensData.size() > 0){
1558
1559                                 for (int XTokenSeek = 0; XTokenSeek < CalendarAlarmData[CalendarAlarmDataSeek].XTokensData.size();
1560                                         XTokenSeek++){
1561
1562                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].XTokensDataTokens[XTokenSeek];
1563                                         DataLine += ":";
1564                                         DataLine += CalendarAlarmData[CalendarAlarmDataSeek].XTokensData[XTokenSeek];
1565                                         DataLine += "\n";
1566
1567                                         DataLineProcessed = OutputText(&DataLine);
1568
1569                                         *SaveData += DataLineProcessed;
1570
1571                                         DataLine.clear();
1572                                         DataLineProcessed.clear();
1573
1574                                 }
1575
1576                         }
1577
1578                         *SaveData += "END:VALARM\n";
1579
1580                 }
1581
1582         }
1583
1584         // Process the X-Token values.
1585
1586         if (XTokensData.size() > 0){
1587
1588                 for (int XTokenSeek = 0; XTokenSeek < XTokensData.size();
1589                         XTokenSeek++){
1590
1591                         DataLine += XTokensDataTokens[XTokenSeek];
1592                         DataLine += ":";
1593                         DataLine += XTokensData[XTokenSeek];
1594                         DataLine += "\n";
1595
1596                         DataLineProcessed = OutputText(&DataLine);
1597
1598                         *SaveData += DataLineProcessed;
1599
1600                         DataLine.clear();
1601                         DataLineProcessed.clear();
1602
1603                 }
1604
1605         }
1606
1607         *SaveData += "END:VEVENT\n";
1608
1609 }