source/objects/calendarevent/CalendarEvent-Save.cpp

   1 // CalendarEvent.cpp - CalendarEventObject 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 "CalendarEvent.h"
  20
  21 using namespace std;
  22
  23 void CalendarEventObject::SaveObjectData(string *saveData){
  24
  25         string dataLine = "";
  26         string dataLineProcessed = "";
  27
  28         *saveData += "BEGIN:VEVENT\n";
  29
  30         // Process the UID.
  31
  32         if (uniqueID.size() > 0){
  33
  34                 if (uniqueIDTokens.size() > 0){
  35
  36                         dataLine += "UID;";
  37                         dataLine += uniqueIDTokens;
  38
  39                 } else {
  40
  41                         dataLine += "UID";
  42
  43                 }
  44
  45                 dataLine += ":";
  46                 dataLine += uniqueID;
  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 DTSTAMP.
  59
  60         if (dateTimeStampData.size() > 0){
  61
  62                 if (dateTimeStampTokens.size() > 0){
  63
  64                         dataLine += "DTSTAMP;";
  65                         dataLine += dateTimeStampTokens;
  66
  67                 } else {
  68
  69                         dataLine += "DTSTAMP";
  70
  71                 }
  72
  73                 dataLine += ":";
  74                 dataLine += dateTimeStampData;
  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 DTSTART.
  87
  88         if (dateTimeStartData.size() > 0){
  89
  90                 dataLine += "DTSTART";
  91
  92                 if (dateTimeStartDataValue.size() > 0){
  93
  94                         dataLine += ";VALUE=";
  95                         dataLine += dateTimeStartDataValue;
  96
  97                 }
  98
  99                 if (dateTimeStartDataTimeZoneID.size() > 0){
 100
 101                         dataLine += ";TZID=";
 102                         dataLine += dateTimeStartDataTimeZoneID;
 103
 104                 }
 105
 106                 if (dateTimeStartDataTokens.size() > 0){
 107
 108                         dataLine += ";";
 109                         dataLine += dateTimeStartDataTokens;
 110
 111                 }
 112
 113                 dataLine += ":";
 114                 dataLine += dateTimeStartData;
 115                 dataLine += "\n";
 116
 117                 dataLineProcessed = OutputText(&dataLine);
 118
 119                 *saveData += dataLineProcessed;
 120
 121                 dataLine.clear();
 122                 dataLineProcessed.clear();
 123
 124         }
 125
 126         // Process the DTEND.
 127
 128         if (dateTimeEndData.size() > 0){
 129
 130                 dataLine += "DTEND";
 131
 132                 if (dateTimeEndDataValue.size() > 0){
 133
 134                         dataLine += ";VALUE=";
 135                         dataLine += dateTimeEndDataValue;
 136
 137                 }
 138
 139                 if (dateTimeEndDataTimeZoneID.size() > 0){
 140
 141                         dataLine += ";TZID=";
 142                         dataLine += dateTimeEndDataTimeZoneID;
 143
 144                 }
 145
 146                 if (dateTimeEndDataTokens.size() > 0){
 147
 148                         dataLine += ";";
 149                         dataLine += dateTimeEndDataTokens;
 150
 151                 }
 152
 153                 dataLine += ":";
 154                 dataLine += dateTimeEndData;
 155                 dataLine += "\n";
 156
 157                 dataLineProcessed = OutputText(&dataLine);
 158
 159                 *saveData += dataLineProcessed;
 160
 161                 dataLine.clear();
 162                 dataLineProcessed.clear();
 163
 164         }
 165
 166         // Process the SUMMARY.
 167
 168         if (summaryData.size() > 0){
 169
 170                 dataLine += "SUMMARY";
 171
 172                 if (summaryDataAltRep.size() > 0){
 173
 174                         dataLine += ";ALTREP=\"";
 175                         dataLine += summaryDataAltRep;
 176                         dataLine += "\"";
 177
 178                 }
 179
 180                 if (summaryDataLanguage.size() > 0){
 181
 182                         dataLine += ";LANGUAGE=";
 183                         dataLine += summaryDataLanguage;
 184
 185                 }
 186
 187                 if (summaryDataTokens.size() > 0){
 188
 189                         dataLine += ";";
 190                         dataLine += summaryDataTokens;
 191
 192                 }
 193
 194                 dataLine += ":";
 195                 dataLine += summaryData;
 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 CLASS value.
 208
 209         if (classData.size() > 0){
 210
 211                 if (classDataTokens.size() > 0){
 212
 213                         dataLine += "CLASS;";
 214                         dataLine += classDataTokens;
 215
 216                 } else {
 217
 218                         dataLine += "CLASS";
 219
 220                 }
 221
 222                 dataLine += ":";
 223                 dataLine += classData;
 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 CREATED value.
 236
 237         if (dateTimeCreatedData.size() > 0){
 238
 239                 if (dateTimeCreatedTokens.size() > 0){
 240
 241                         dataLine += "CREATED;";
 242                         dataLine += dateTimeCreatedTokens;
 243
 244                 } else {
 245
 246                         dataLine += "CREATED";
 247
 248                 }
 249
 250                 dataLine += ":";
 251                 dataLine += dateTimeCreatedData;
 252                 dataLine += "\n";
 253
 254                 dataLineProcessed = OutputText(&dataLine);
 255
 256                 *saveData += dataLineProcessed;
 257
 258                 dataLine.clear();
 259                 dataLineProcessed.clear();
 260
 261         }
 262
 263         // Process the DESCRIPTION values. Write out the
 264         // first DESCRPITION only as per RFC5545 specifcation.
 265
 266         if (descriptionList.size() > 0){
 267
 268                 dataLine += "DESCRIPTION";
 269
 270                 if (descriptionListAltRep[0].size() > 0){
 271
 272                         dataLine += ";ALTREP=\"";
 273                         dataLine += descriptionListAltRep[0];
 274                         dataLine += "\"";
 275
 276                 }
 277
 278                 if (descriptionListLanguage[0].size() > 0){
 279
 280                         dataLine += ";LANGUAGE=";
 281                         dataLine += descriptionListLanguage[0];
 282
 283                 }
 284
 285                 if (descriptionListTokens[0].size() > 0){
 286
 287                         dataLine += ";";
 288                         dataLine += descriptionListTokens[0];
 289
 290                 }
 291
 292                 dataLine += ":";
 293                 dataLine += descriptionList[0];
 294                 dataLine += "\n";
 295
 296                 dataLineProcessed = OutputText(&dataLine);
 297
 298                 *saveData += dataLineProcessed;
 299
 300                 dataLine.clear();
 301                 dataLineProcessed.clear();
 302
 303         }
 304
 305         // Process the GEO value.
 306
 307         if (geographicData.size() > 0){
 308
 309                 if (geographicTokens.size() > 0){
 310
 311                         dataLine += "GEO;";
 312                         dataLine += geographicTokens;
 313
 314                 } else {
 315
 316                         dataLine += "GEO";
 317
 318                 }
 319
 320                 dataLine += ":";
 321                 dataLine += geographicData;
 322                 dataLine += "\n";
 323
 324                 dataLineProcessed = OutputText(&dataLine);
 325
 326                 *saveData += dataLineProcessed;
 327
 328                 dataLine.clear();
 329                 dataLineProcessed.clear();
 330
 331         }
 332
 333         // Process the LAST-MODIFIED value.
 334
 335         if (lastModifiedData.size() > 0){
 336
 337                 if (lastModifiedTokens.size() > 0){
 338
 339                         dataLine += "LAST-MODIFIED;";
 340                         dataLine += lastModifiedTokens;
 341
 342                 } else {
 343
 344                         dataLine += "LAST-MODIFIED";
 345
 346                 }
 347
 348                 dataLine += ":";
 349                 dataLine += lastModifiedData;
 350                 dataLine += "\n";
 351
 352                 dataLineProcessed = OutputText(&dataLine);
 353
 354                 *saveData += dataLineProcessed;
 355
 356                 dataLine.clear();
 357                 dataLineProcessed.clear();
 358
 359         }
 360
 361         // Process the LOCATION value.
 362
 363         if (locationData.size() > 0){
 364
 365                 dataLine += "LOCATION";
 366
 367                 if (locationDataAltRep.size() > 0){
 368
 369                         dataLine += ";ALTREP=\"";
 370                         dataLine += locationDataAltRep;
 371                         dataLine += "\"";
 372
 373                 }
 374
 375                 if (locationDataLanguage.size() > 0){
 376
 377                         dataLine += ";LANGUAGE=";
 378                         dataLine += locationDataLanguage;
 379
 380                 }
 381
 382                 if (locationDataTokens.size() > 0){
 383
 384                         dataLine += ";";
 385                         dataLine += locationDataTokens;
 386
 387                 }
 388
 389                 dataLine += ":";
 390                 dataLine += locationData;
 391                 dataLine += "\n";
 392
 393                 dataLineProcessed = OutputText(&dataLine);
 394
 395                 *saveData += dataLineProcessed;
 396
 397                 dataLine.clear();
 398                 dataLineProcessed.clear();
 399
 400         }
 401
 402         // Process the ORGANIZER value.
 403
 404         if (organiserData.size() > 0){
 405
 406                 dataLine += "ORGANIZER";
 407
 408                 if (organiserDataCommonName.size() > 0){
 409
 410                         dataLine += ";CN=";
 411                         dataLine += organiserDataCommonName;
 412
 413                 }
 414
 415                 if (organiserDataDirectoryEntry.size() > 0){
 416
 417                         dataLine += ";DIR=\"";
 418                         dataLine += organiserDataDirectoryEntry;
 419                         dataLine += "\"";
 420
 421                 }
 422
 423                 if (organiserDataSentByParam.size() > 0){
 424
 425                         dataLine += ";SENT-BY=\"";
 426                         dataLine += organiserDataSentByParam;
 427                         dataLine += "\"";
 428
 429                 }
 430
 431                 if (organiserDataLanguage.size() > 0){
 432
 433                         dataLine += ";LANGUAGE=";
 434                         dataLine += organiserDataLanguage;
 435
 436                 }
 437
 438                 if (organiserDataTokens.size() > 0){
 439
 440                         dataLine += ";";
 441                         dataLine += organiserDataTokens;
 442
 443                 }
 444
 445                 dataLine += ":";
 446                 dataLine += organiserData;
 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 PRIORITY value.
 459
 460         if (priorityData > -1 && priorityData < 10){
 461
 462                 dataLine += "PRIORITY";
 463
 464                 if (priorityTokens.size() > 0){
 465
 466                         dataLine += ";";
 467                         dataLine += priorityTokens;
 468
 469                 }
 470
 471                 dataLine += ":";
 472                 dataLine += to_string(priorityData);
 473                 dataLine += "\n";
 474
 475                 dataLineProcessed = OutputText(&dataLine);
 476
 477                 *saveData += dataLineProcessed;
 478
 479                 dataLine.clear();
 480                 dataLineProcessed.clear();
 481
 482         }
 483
 484         // Process the SEQUENCE value.
 485
 486         if (sequenceData > -1 && sequenceData < 10){
 487
 488                 dataLine += "SEQUENCE";
 489
 490                 if (sequenceTokens.size() > 0){
 491
 492                         dataLine += ";";
 493                         dataLine += sequenceTokens;
 494
 495                 }
 496
 497                 dataLine += ":";
 498                 dataLine += to_string(sequenceData);
 499                 dataLine += "\n";
 500
 501                 dataLineProcessed = OutputText(&dataLine);
 502
 503                 *saveData += dataLineProcessed;
 504
 505                 dataLine.clear();
 506                 dataLineProcessed.clear();
 507
 508         }
 509
 510         // Process the STATUS value.
 511
 512         if (statusData.size() > 0){
 513
 514                 dataLine += "STATUS";
 515
 516                 if (statusLanguage.size() > 0){
 517
 518                         dataLine += ";LANGUAGE=";
 519                         dataLine += StatusLanguage;
 520
 521                 }
 522
 523                 if (statusTokens.size() > 0){
 524
 525                         dataLine += ";";
 526                         dataLine += statusTokens;
 527
 528                 }
 529
 530                 dataLine += ":";
 531                 dataLine += statusData;
 532                 dataLine += "\n";
 533
 534                 dataLineProcessed = OutputText(&dataLine);
 535
 536                 *saveData += dataLineProcessed;
 537
 538                 dataLine.clear();
 539                 dataLineProcessed.clear();
 540
 541         }
 542
 543         // Process the TRANSP value.
 544
 545         if (timeTransparencyData.size() > 0){
 546
 547                 dataLine += "TRANSP";
 548
 549                 if (timeTransparencyDataTokens.size() > 0){
 550
 551                         dataLine += ";";
 552                         dataLine += timeTransparencyDataTokens;
 553
 554                 }
 555
 556                 dataLine += ":";
 557                 dataLine += timeTransparencyData;
 558                 dataLine += "\n";
 559
 560                 dataLineProcessed = OutputText(&dataLine);
 561
 562                 *saveData += dataLineProcessed;
 563
 564                 dataLine.clear();
 565                 dataLineProcessed.clear();
 566
 567         }
 568
 569         // Process the URL value.
 570
 571         if (urlData.size() > 0){
 572
 573                 dataLine += "URL";
 574
 575                 if (urlDataTokens.size() > 0){
 576
 577                         dataLine += ";";
 578                         dataLine += urlDataTokens;
 579
 580                 }
 581
 582                 dataLine += ":";
 583                 dataLine += urlData;
 584                 dataLine += "\n";
 585
 586                 dataLineProcessed = OutputText(&dataLine);
 587
 588                 *saveData += dataLineProcessed;
 589
 590                 dataLine.clear();
 591                 dataLineProcessed.clear();
 592
 593         }
 594
 595         // Process the RECURRENCE-ID value.
 596
 597         if (recurranceIDData.size() > 0){
 598
 599                 dataLine += "RECURRENCE-ID";
 600
 601                 if (recurranceIDDataTimeZoneParam.size() > 0){
 602
 603                         dataLine += ";TZID=";
 604                         dataLine += recurranceIDDataTimeZoneParam;
 605
 606                 }
 607
 608                 if (recurranceIDDataRangeParam.size() > 0){
 609
 610                         dataLine += ";RANGE=";
 611                         dataLine += recurranceIDDataRangeParam;
 612
 613                 }
 614
 615                 if (recurranceIDDataValue.size() > 0){
 616
 617                         dataLine += ";VALUE=";
 618                         dataLine += recurranceIDDataValue;
 619
 620                 }
 621
 622                 if (recurranceIDDataTokens.size() > 0){
 623
 624                         dataLine += ";";
 625                         dataLine += recurranceIDDataTokens;
 626
 627                 }
 628
 629                 dataLine += ":";
 630                 dataLine += recurranceIDData;
 631                 dataLine += "\n";
 632
 633                 dataLineProcessed = OutputText(&dataLine);
 634
 635                 *saveData += dataLineProcessed;
 636
 637                 dataLine.clear();
 638                 dataLineProcessed.clear();
 639
 640         }
 641
 642         // Process the DURATION value.
 643
 644         if (durationData.size() > 0){
 645
 646                 dataLine += "DURATION";
 647
 648                 if (durationDataTokens.size() > 0){
 649
 650                         dataLine += ";";
 651                         dataLine += durationDataTokens;
 652
 653                 }
 654
 655                 dataLine += ":";
 656                 dataLine += durationData;
 657                 dataLine += "\n";
 658
 659                 dataLineProcessed = OutputText(&dataLine);
 660
 661                 *saveData += dataLineProcessed;
 662
 663                 dataLine.clear();
 664                 dataLineProcessed.clear();
 665
 666         }
 667
 668         // Process the RRULE value.
 669
 670         if (recurranceRuleData.size() > 0){
 671
 672                 dataLine += "RRULE";
 673
 674                 if (recurranceRuleDataTokens.size() > 0){
 675
 676                         dataLine += ";";
 677                         dataLine += recurranceRuleDataTokens;
 678
 679                 }
 680
 681                 dataLine += ":";
 682                 dataLine += recurranceRuleData;
 683                 dataLine += "\n";
 684
 685                 dataLineProcessed = OutputText(&dataLine);
 686
 687                 *saveData += dataLineProcessed;
 688
 689                 dataLine.clear();
 690                 dataLineProcessed.clear();
 691
 692         }
 693
 694         // Process the ATTACH values.
 695
 696         if (attachList.size() > 0){
 697
 698                 for (int attachListSeek = 0; attachListSeek < attachList.size();
 699                         attachListSeek++){
 700
 701                         dataLine += "ATTACH";
 702
 703                         if (attachListFormatType[attachListSeek].size() > 0){
 704
 705                                 dataLine += ";FMTTYPE=";
 706                                 dataLine += attachListFormatType[attachListSeek];
 707
 708                         }
 709
 710                         if (attachListValue[attachListSeek].size() > 0){
 711
 712                                 dataLine += ";VALUE=";
 713                                 dataLine += attachListValue[attachListSeek];
 714
 715                         }
 716
 717                         if (attachListEncoding[attachListSeek].size() > 0){
 718
 719                                 dataLine += ";ENCODING=";
 720                                 dataLine += attachListEncoding[attachListSeek];
 721
 722                         }
 723
 724                         if (attachListTokens[AttachListSeek].size() > 0){
 725
 726                                 dataLine += ";";
 727                                 dataLine += attachListTokens[attachListSeek];
 728
 729                         }
 730
 731                         dataLine += ":";
 732                         dataLine += attachList[attachListSeek];
 733                         dataLine += "\n";
 734
 735                         dataLineProcessed = OutputText(&dataLine);
 736
 737                         *saveData += dataLineProcessed;
 738
 739                         dataLine.clear();
 740                         dataLineProcessed.clear();
 741
 742                 }
 743
 744         }
 745
 746         // Process the ATTENDEE value.
 747
 748         if (attendeeList.size() > 0){
 749
 750                 for (int attendeeListSeek = 0; attendeeListSeek < attendeeList.size();
 751                         attendeeListSeek++){
 752
 753                         dataLine += "ATTENDEE";
 754
 755                         if (attendeeListMember[attendeeListSeek].size() > 0){
 756
 757                                 dataLine += ";MEMBER=\"";
 758                                 dataLine += attendeeListMember[attendeeListSeek];
 759                                 dataLine += "\"";
 760
 761                         }
 762
 763                         if (attendeeListDelegatedFrom[attendeeListSeek].size() > 0){
 764
 765                                 dataLine += ";DELEGATED-FROM=\"";
 766                                 dataLine += attendeeListDelegatedFrom[attendeeListSeek];
 767                                 dataLine += "\"";
 768
 769                         }
 770
 771                         if (attendeeListDelegatedTo[attendeeListSeek].size() > 0){
 772
 773                                 dataLine += ";DELEGATED-TO=\"";
 774                                 dataLine += attendeeListDelegatedTo[attendeeListSeek];
 775                                 dataLine += "\"";
 776
 777                         }
 778
 779                         if (attendeeListRole[attendeeListSeek].size() > 0){
 780
 781                                 dataLine += ";ROLE=";
 782                                 dataLine += attendeeListRole[attendeeListSeek];
 783
 784                         }
 785
 786                         if (attendeeListRSVP[attendeeListSeek].size() > 0){
 787
 788                                 dataLine += ";RSVP=";
 789                                 dataLine += attendeeListRSVP[attendeeListSeek];
 790
 791                         }
 792
 793                         if (attendeeListDirectoryEntry[attendeeListSeek].size() > 0){
 794
 795                                 dataLine += ";DIR=\"";
 796                                 dataLine += attendeeListDirectoryEntry[attendeeListSeek];
 797                                 dataLine += "\"";
 798
 799                         }
 800
 801                         if (attendeeListSentBy[attendeeListSeek].size() > 0){
 802
 803                                 dataLine += ";SENT-BY=\"";
 804                                 dataLine += attendeeListSentBy[attendeeListSeek];
 805                                 dataLine += "\"";
 806
 807                         }
 808
 809                         if (attendeeListCommonName[attendeeListSeek].size() > 0){
 810
 811                                 dataLine += ";CN=\"";
 812                                 dataLine += attendeeListCommonName[attendeeListSeek];
 813                                 dataLine += "\"";
 814
 815                         }
 816
 817                         if (attendeeListCalendarUserType[attendeeListSeek].size() > 0){
 818
 819                                 dataLine += ";CUTYPE=";
 820                                 dataLine += attendeeListCalendarUserType[attendeeListSeek];
 821
 822                         }
 823
 824                         if (attendeeListParticipationStatus[attendeeListSeek].size() > 0){
 825
 826                                 dataLine += ";PARTSTAT=";
 827                                 dataLine += attendeeListParticipationStatus[attendeeListSeek];
 828
 829                         }
 830
 831                         if (attendeeListLanguage[attendeeListSeek].size() > 0){
 832
 833                                 dataLine += ";LANGUAGE=";
 834                                 dataLine += attendeeListLanguage[attendeeListSeek];
 835
 836                         }
 837
 838                         if (attendeeListTokens[attendeeListSeek].size() > 0){
 839
 840                                 dataLine += ";";
 841                                 dataLine += attendeeListTokens[attendeeListSeek];
 842
 843                         }
 844
 845                         dataLine += ":";
 846                         dataLine += attendeeList[attendeeListSeek];
 847                         dataLine += "\n";
 848
 849                         dataLineProcessed = OutputText(&dataLine);
 850
 851                         *saveData += dataLineProcessed;
 852
 853                         dataLine.clear();
 854                         dataLineProcessed.clear();
 855
 856                 }
 857
 858         }
 859
 860         // Process the CATEGORIES value.
 861
 862         if (categoriesList.size() > 0){
 863
 864                 for (int categoriesListSeek = 0; categoriesListSeek < categoriesList.size();
 865                         categoriesListSeek++){
 866
 867                         dataLine += "CATEGORIES";
 868
 869                         if (categoriesListLanguage[categoriesListSeek].size() > 0){
 870
 871                                 dataLine += ";LANGUAGE=";
 872                                 dataLine += categoriesListLanguage[categoriesListSeek];
 873
 874                         }
 875
 876                         if (categoriesListTokens[categoriesListSeek].size() > 0){
 877
 878                                 dataLine += ";";
 879                                 dataLine += categoriesListTokens[categoriesListSeek];
 880
 881                         }
 882
 883                         dataLine += ":";
 884                         dataLine += categoriesList[categoriesListSeek];
 885                         dataLine += "\n";
 886
 887                         dataLineProcessed = OutputText(&dataLine);
 888
 889                         *saveData += dataLineProcessed;
 890
 891                         dataLine.clear();
 892                         dataLineProcessed.clear();
 893
 894                 }
 895
 896         }
 897
 898         // Process the COMMENT value.
 899
 900         if (commentList.size() > 0){
 901
 902                 for (int commentListSeek = 0; commentListSeek < commentList.size();
 903                         commentListSeek++){
 904
 905                         dataLine += "COMMENT";
 906
 907                         if (commentListAltRep[commentListSeek].size() > 0){
 908
 909                                 dataLine += ";ALTREP=\"";
 910                                 dataLine += commentListAltRep[commentListSeek];
 911                                 dataLine += "\"";
 912
 913                         }
 914
 915                         if (commentListLanguage[commentListSeek].size() > 0){
 916
 917                                 dataLine += ";LANGUAGE=";
 918                                 dataLine += commentListLanguage[commentListSeek];
 919
 920                         }
 921
 922                         if (commentListTokens[commentListSeek].size() > 0){
 923
 924                                 dataLine += ";";
 925                                 dataLine += commentListTokens[commentListSeek];
 926
 927                         }
 928
 929                         dataLine += ":";
 930                         dataLine += commentList[commentListSeek];
 931                         dataLine += "\n";
 932
 933                         dataLineProcessed = OutputText(&dataLine);
 934
 935                         *saveData += dataLineProcessed;
 936
 937                         dataLine.clear();
 938                         dataLineProcessed.clear();
 939
 940                 }
 941
 942         }
 943
 944         // Process the CONTACT value.
 945
 946         if (contactList.size() > 0){
 947
 948                 for (int contactListSeek = 0; contactListSeek < contactList.size();
 949                         contactListSeek++){
 950
 951                         dataLine += "CONTACT";
 952
 953                         if (contactListAltRep[contactListSeek].size() > 0){
 954
 955                                 dataLine += ";ALTREP=\"";
 956                                 dataLine += contactListAltRep[contactListSeek];
 957                                 dataLine += "\"";
 958
 959                         }
 960
 961                         if (contactListLanguage[contactListSeek].size() > 0){
 962
 963                                 dataLine += ";LANGUAGE=";
 964                                 dataLine += contactListLanguage[contactListSeek];
 965
 966                         }
 967
 968                         if (contactListTokens[contactListSeek].size() > 0){
 969
 970                                 dataLine += ";";
 971                                 dataLine += contactListTokens[contactListSeek];
 972
 973                         }
 974
 975                         dataLine += ":";
 976                         dataLine += contactList[contactListSeek];
 977                         dataLine += "\n";
 978
 979                         dataLineProcessed = OutputText(&dataLine);
 980
 981                         *saveData += dataLineProcessed;
 982
 983                         dataLine.clear();
 984                         dataLineProcessed.clear();
 985
 986                 }
 987
 988         }
 989
 990         // Process the EXDATE value.
 991
 992         if (excludeDateData.size() > 0){
 993
 994                 for (int excludeDateDataSeek = 0; excludeDateDataSeek < excludeDateData.size();
 995                         excludeDateDataSeek++){
 996
 997                         dataLine += "EXDATE";
 998
 999                         if (excludeDateDataTimeZoneParam[excludeDateDataSeek].size() > 0){
1000
1001                                 dataLine += ";TZID=";
1002                                 dataLine += excludeDateDataTimeZoneParam[excludeDateDataSeek];
1003
1004                         }
1005
1006                         if (excludeDateDataValue[excludeDateDataSeek].size() > 0){
1007
1008                                 dataLine += ";VALUE=";
1009                                 dataLine += excludeDateDataValue[excludeDateDataSeek];
1010
1011                         }
1012
1013                         if (excludeDateDataTokens[excludeDateDataSeek].size() > 0){
1014
1015                                 dataLine += ";";
1016                                 dataLine += excludeDateDataTokens[excludeDateDataSeek];
1017
1018                         }
1019
1020                         dataLine += ":";
1021                         dataLine += excludeDateData[excludeDateDataSeek];
1022                         dataLine += "\n";
1023
1024                         dataLineProcessed = OutputText(&dataLine);
1025
1026                         *saveData += dataLineProcessed;
1027
1028                         dataLine.clear();
1029                         dataLineProcessed.clear();
1030
1031                 }
1032
1033         }
1034
1035         // Process the REQUEST-STATUS value.
1036
1037         if (requestStatusData.size() > 0){
1038
1039                 for (int requestStatusDataSeek = 0; requestStatusDataSeek < requestStatusData.size();
1040                         requestStatusDataSeek++){
1041
1042                         dataLine += "REQUEST-STATUS";
1043
1044                         if (requestStatusLanguage[requestStatusDataSeek].size() > 0){
1045
1046                                 dataLine += ";LANGUAGE=";
1047                                 dataLine += requestStatusLanguage[requestStatusDataSeek];
1048
1049                         }
1050
1051                         if (requestStatusTokens[requestStatusDataSeek].size() > 0){
1052
1053                                 dataLine += ";";
1054                                 dataLine += requestStatusTokens[requestStatusDataSeek];
1055
1056                         }
1057
1058                         dataLine += ":";
1059                         dataLine += requestStatusData[requestStatusDataSeek];
1060                         dataLine += "\n";
1061
1062                         dataLineProcessed = OutputText(&dataLine);
1063
1064                         *saveData += dataLineProcessed;
1065
1066                         dataLine.clear();
1067                         dataLineProcessed.clear();
1068
1069                 }
1070
1071         }
1072
1073         // Process the RELATED-TO value.
1074
1075         if (relatedToData.size() > 0){
1076
1077                 for (int requestToDataSeek = 0; requestToDataSeek < relatedToData.size();
1078                         requestToDataSeek++){
1079
1080                         dataLine += "RELATED-TO";
1081
1082                         if (relatedToDataRelationType[requestToDataSeek].size() > 0){
1083
1084                                 dataLine += ";RELTYPE=";
1085                                 dataLine += relatedToDataRelationType[requestToDataSeek];
1086
1087                         }
1088
1089                         if (relatedToDataTokens[requestToDataSeek].size() > 0){
1090
1091                                 dataLine += ";";
1092                                 dataLine += relatedToDataTokens[requestToDataSeek];
1093
1094                         }
1095
1096                         dataLine += ":";
1097                         dataLine += relatedToData[requestToDataSeek];
1098                         dataLine += "\n";
1099
1100                         dataLineProcessed = OutputText(&dataLine);
1101
1102                         *saveData += dataLineProcessed;
1103
1104                         dataLine.clear();
1105                         dataLineProcessed.clear();
1106
1107                 }
1108
1109         }
1110
1111         // Process the RESOURCES value.
1112
1113         if (resourcesData.size() > 0){
1114
1115                 for (int resourcesDataSeek = 0; resourcesDataSeek < resourcesData.size();
1116                         resourcesDataSeek++){
1117
1118                         dataLine += "RESOURCES";
1119
1120                         if (resourcesDataAltRep[resourcesDataSeek].size() > 0){
1121
1122                                 dataLine += ";ALTREP=\"";
1123                                 dataLine += resourcesDataAltRep[resourcesDataSeek];
1124                                 dataLine += "\"";
1125
1126                         }
1127
1128                         if (resourcesDataLanguage[resourcesDataSeek].size() > 0){
1129
1130                                 dataLine += ";LANGUAGE=";
1131                                 dataLine += resourcesDataLanguage[resourcesDataSeek];
1132
1133                         }
1134
1135                         if (resourcesDataTokens[resourcesDataSeek].size() > 0){
1136
1137                                 dataLine += ";";
1138                                 dataLine += resourcesDataTokens[resourcesDataSeek];
1139
1140                         }
1141
1142                         dataLine += ":";
1143                         dataLine += resourcesData[resourcesDataSeek];
1144                         dataLine += "\n";
1145
1146                         dataLineProcessed = OutputText(&dataLine);
1147
1148                         *saveData += dataLineProcessed;
1149
1150                         dataLine.clear();
1151                         dataLineProcessed.clear();
1152
1153                 }
1154
1155         }
1156
1157         // Process the RDATE value.
1158
1159         if (recurranceDateData.size() > 0){
1160
1161                 for (int recurranceDateDataSeek = 0; recurranceDateDataSeek < recurranceDateData.size();
1162                         recurranceDateDataSeek++){
1163
1164                         dataLine += "RDATE";
1165
1166                         if (recurranceDateDataValue[recurranceDateDataSeek].size() > 0){
1167
1168                                 dataLine += ";VALUE=";
1169                                 dataLine += recurranceDateDataValue[recurranceDateDataSeek];
1170
1171                         }
1172
1173                         if (recurranceDateDataTimeZoneParam[recurranceDateDataSeek].size() > 0){
1174
1175                                 dataLine += ";TZID=";
1176                                 dataLine += recurranceDateDataTimeZoneParam[recurranceDateDataSeek];
1177
1178                         }
1179
1180                         if (recurranceDateDataTokens[recurranceDateDataSeek].size() > 0){
1181
1182                                 dataLine += ";";
1183                                 dataLine += recurranceDateDataTokens[recurranceDateDataSeek];
1184
1185                         }
1186
1187                         dataLine += ":";
1188                         dataLine += recurranceDateData[recurranceDateDataSeek];
1189                         dataLine += "\n";
1190
1191                         dataLineProcessed = OutputText(&dataLine);
1192
1193                         *saveData += dataLineProcessed;
1194
1195                         dataLine.clear();
1196                         dataLineProcessed.clear();
1197
1198                 }
1199
1200         }
1201
1202         // Process the VALARMS.
1203
1204         if (calendarAlarmData.size() > 0){
1205
1206                 for (int calendarAlarmDataSeek = 0; calendarAlarmDataSeek < calendarAlarmData.size();
1207                         calendarAlarmDataSeek++){
1208
1209                         *saveData += "BEGIN:VALARM\n";
1210
1211                         // Process the ACTION VALARM value.
1212
1213                         dataLine += "ACTION";
1214
1215                         if (calendarAlarmData[calendarAlarmDataSeek].alarmActionTokens.size() > 0){
1216
1217                                 dataLine += ";";
1218                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].alarmActionTokens;
1219
1220                         }
1221
1222                         dataLine += ":";
1223                         dataLine += calendarAlarmData[calendarAlarmDataSeek].alarmAction;
1224                         dataLine += "\n";
1225
1226                         dataLineProcessed = OutputText(&dataLine);
1227
1228                         *saveData += dataLineProcessed;
1229
1230                         dataLine.clear();
1231                         dataLineProcessed.clear();
1232
1233                         // Process the TRIGGER VALARM value.
1234
1235                         if (calendarAlarmData[calendarAlarmDataSeek].triggerData.size() > 0){
1236
1237                                 dataLine += "TRIGGER";
1238
1239                                 if (calendarAlarmData[CalendarAlarmDataSeek].triggerRelated.size() > 0){
1240
1241                                         dataLine += ";RELATED=";
1242                                         dataLine += calendarAlarmData[CalendarAlarmDataSeek].triggerRelated;
1243
1244                                 }
1245
1246                                 if (calendarAlarmData[calendarAlarmDataSeek].triggerValue.size() > 0){
1247
1248                                         dataLine += ";VALUE=";
1249                                         dataLine += calendarAlarmData[calendarAlarmDataSeek].triggerValue;
1250
1251                                 }
1252
1253                                 if (calendarAlarmData[calendarAlarmDataSeek].triggerTokens.size() > 0){
1254
1255                                         dataLine += ";";
1256                                         dataLine += calendarAlarmData[calendarAlarmDataSeek].TriggerTokens;
1257
1258                                 }
1259
1260                                 dataLine += ":";
1261                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].triggerData;
1262                                 dataLine += "\n";
1263
1264                                 dataLineProcessed = OutputText(&dataLine);
1265
1266                                 *saveData += dataLineProcessed;
1267
1268                                 dataLine.clear();
1269                                 dataLineProcessed.clear();
1270
1271                         }
1272
1273                         // Process the DURATION VALARM value.
1274
1275                         if (calendarAlarmData[calendarAlarmDataSeek].durationData.size() > 0){
1276
1277                                 dataLine += "DURATION";
1278
1279                                 if (calendarAlarmData[calendarAlarmDataSeek].durationTokens.size() > 0){
1280
1281                                         dataLine += ";";
1282                                         dataLine += calendarAlarmData[CalendarAlarmDataSeek].durationTokens;
1283
1284                                 }
1285
1286                                 dataLine += ":";
1287                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].durationData;
1288                                 dataLine += "\n";
1289
1290                                 dataLineProcessed = OutputText(&dataLine);
1291
1292                                 *saveData += dataLineProcessed;
1293
1294                                 dataLine.clear();
1295                                 dataLineProcessed.clear();
1296
1297                         }
1298
1299                         // Process the DESCRIPTION VALARM value.
1300
1301                         if (calendarAlarmData[calendarAlarmDataSeek].descriptionData.size() > 0){
1302
1303                                 dataLine += "DESCRIPTION";
1304
1305                                 if (calendarAlarmData[calendarAlarmDataSeek].descriptionAltRep.size() > 0){
1306
1307                                         dataLine += ";ALTREP=\"";
1308                                         dataLine += calendarAlarmData[calendarAlarmDataSeek].descriptionAltRep;
1309                                         dataLine += "\"";
1310
1311                                 }
1312
1313                                 if (calendarAlarmData[calendarAlarmDataSeek].descriptionLanguage.size() > 0){
1314
1315                                         dataLine += ";LANGUAGE=";
1316                                         dataLine += calendarAlarmData[calendarAlarmDataSeek].descriptionLanguage;
1317
1318                                 }
1319
1320                                 if (calendarAlarmData[calendarAlarmDataSeek].descriptionTokens.size() > 0){
1321
1322                                         dataLine += ";";
1323                                         dataLine += calendarAlarmData[calendarAlarmDataSeek].descriptionTokens;
1324
1325                                 }
1326
1327                                 dataLine += ":";
1328                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].descriptionData;
1329                                 dataLine += "\n";
1330
1331                                 dataLineProcessed = OutputText(&dataLine);
1332
1333                                 *saveData += dataLineProcessed;
1334
1335                                 dataLine.clear();
1336                                 dataLineProcessed.clear();
1337
1338                         }
1339
1340                         // Process the SUMMARY VALARM value.
1341
1342                         if (calendarAlarmData[calendarAlarmDataSeek].summaryData.size() > 0){
1343
1344                                 dataLine += "SUMMARY";
1345
1346                                 if (calendarAlarmData[calendarAlarmDataSeek].summaryAltRep.size() > 0){
1347
1348                                         dataLine += ";ALTREP=\"";
1349                                         dataLine += calendarAlarmData[calendarAlarmDataSeek].summaryAltRep;
1350                                         dataLine += "\"";
1351
1352                                 }
1353
1354                                 if (calendarAlarmData[calendarAlarmDataSeek].summaryLanguage.size() > 0){
1355
1356                                         dataLine += ";LANGUAGE=";
1357                                         dataLine += calendarAlarmData[calendarAlarmDataSeek].summaryLanguage;
1358
1359                                 }
1360
1361                                 if (calendarAlarmData[calendarAlarmDataSeek].summaryTokens.size() > 0){
1362
1363                                         dataLine += ";";
1364                                         dataLine += calendarAlarmData[calendarAlarmDataSeek].summaryTokens;
1365
1366                                 }
1367
1368                                 dataLine += ":";
1369                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].summaryData;
1370                                 dataLine += "\n";
1371
1372                                 dataLineProcessed = OutputText(&dataLine);
1373
1374                                 *saveData += dataLineProcessed;
1375
1376                                 dataLine.clear();
1377                                 dataLineProcessed.clear();
1378
1379                         }
1380
1381                         // Process the REPEAT VALARM value.
1382
1383                         if (calendarAlarmData[calendarAlarmDataSeek].repeatData.size() > 0){
1384
1385                                 dataLine += "REPEAT";
1386
1387                                 if (calendarAlarmData[calendarAlarmDataSeek].repeatTokens.size() > 0){
1388
1389                                         dataLine += ";";
1390                                         dataLine += calendarAlarmData[calendarAlarmDataSeek].repeatTokens;
1391
1392                                 }
1393
1394                                 dataLine += ":";
1395                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].repeatData;
1396                                 dataLine += "\n";
1397
1398                                 dataLineProcessed = OutputText(&dataLine);
1399
1400                                 *saveData += dataLineProcessed;
1401
1402                                 dataLine.clear();
1403                                 dataLineProcessed.clear();
1404
1405                         }
1406
1407                         // Process the ATTENDEE VALARM values.
1408
1409                         if (calendarAlarmData[calendarAlarmDataSeek].attendeeList.size() > 0){
1410
1411                                 for (int attendeeListSeek = 0; attendeeListSeek < calendarAlarmData[calendarAlarmDataSeek].attendeeList.size();
1412                                         attendeeListSeek++){
1413
1414                                         dataLine += "ATTENDEE";
1415
1416                                         if (calendarAlarmData[calendarAlarmDataSeek].attendeeListMember[attendeeListSeek].size() > 0){
1417
1418                                                 dataLine += ";MEMBER=\"";
1419                                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListMember[attendeeListSeek];
1420                                                 dataLine += "\"";
1421
1422                                         }
1423
1424                                         if (calendarAlarmData[calendarAlarmDataSeek].attendeeListDelegatedFrom[attendeeListSeek].size() > 0){
1425
1426                                                 dataLine += ";DELEGATED-FROM=\"";
1427                                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListDelegatedFrom[attendeeListSeek];
1428                                                 dataLine += "\"";
1429
1430                                         }
1431
1432                                         if (calendarAlarmData[calendarAlarmDataSeek].attendeeListDelegatedTo[attendeeListSeek].size() > 0){
1433
1434                                                 dataLine += ";DELEGATED-TO=\"";
1435                                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListDelegatedTo[attendeeListSeek];
1436                                                 dataLine += "\"";
1437
1438                                         }
1439
1440                                         if (calendarAlarmData[calendarAlarmDataSeek].attendeeListRole[attendeeListSeek].size() > 0){
1441
1442                                                 dataLine += ";ROLE=";
1443                                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListRole[attendeeListSeek];
1444
1445                                         }
1446
1447                                         if (calendarAlarmData[calendarAlarmDataSeek].attendeeListRSVP[attendeeListSeek].size() > 0){
1448
1449                                                 dataLine += ";RSVP=";
1450                                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListRSVP[attendeeListSeek];
1451
1452                                         }
1453
1454                                         if (calendarAlarmData[calendarAlarmDataSeek].attendeeListDirectoryEntry[attendeeListSeek].size() > 0){
1455
1456                                                 dataLine += ";DIR=\"";
1457                                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListDirectoryEntry[attendeeListSeek];
1458                                                 dataLine += "\"";
1459
1460                                         }
1461
1462                                         if (calendarAlarmData[calendarAlarmDataSeek].attendeeListSentBy[attendeeListSeek].size() > 0){
1463
1464                                                 dataLine += ";SENT-BY=\"";
1465                                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListSentBy[attendeeListSeek];
1466                                                 dataLine += "\"";
1467
1468                                         }
1469
1470                                         if (calendarAlarmData[calendarAlarmDataSeek].attendeeListCommonName[attendeeListSeek].size() > 0){
1471
1472                                                 dataLine += ";CN=\"";
1473                                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListCommonName[attendeeListSeek];
1474                                                 dataLine += "\"";
1475
1476                                         }
1477
1478                                         if (calendarAlarmData[calendarAlarmDataSeek].attendeeListCalendarUserType[attendeeListSeek].size() > 0){
1479
1480                                                 dataLine += ";CUTYPE=";
1481                                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListCalendarUserType[attendeeListSeek];
1482
1483                                         }
1484
1485                                         if (calendarAlarmData[calendarAlarmDataSeek].attendeeListParticipationStatus[attendeeListSeek].size() > 0){
1486
1487                                                 dataLine += ";PARTSTAT=";
1488                                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListParticipationStatus[attendeeListSeek];
1489
1490                                         }
1491
1492                                         if (calendarAlarmData[calendarAlarmDataSeek].attendeeListLanguage[attendeeListSeek].size() > 0){
1493
1494                                                 dataLine += ";LANGUAGE=";
1495                                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListLanguage[attendeeListSeek];
1496
1497                                         }
1498
1499                                         if (calendarAlarmData[calendarAlarmDataSeek].attendeeListTokens[attendeeListSeek].size() > 0){
1500
1501                                                 dataLine += ";";
1502                                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListTokens[attendeeListSeek];
1503
1504                                         }
1505
1506                                         dataLine += ":";
1507                                         dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeList[attendeeListSeek];
1508                                         dataLine += "\n";
1509
1510                                         dataLineProcessed = OutputText(&dataLine);
1511
1512                                         *saveData += dataLineProcessed;
1513
1514                                         dataLine.clear();
1515                                         dataLineProcessed.clear();
1516
1517                                 }
1518
1519                         }
1520
1521                         // Process the ATTACH VALARM values.
1522
1523                         if (calendarAlarmData[calendarAlarmDataSeek].attachList.size() > 0){
1524
1525                                 for (int attachListSeek = 0; attachListSeek < calendarAlarmData[calendarAlarmDataSeek].attachList.size();
1526                                         attachListSeek++){
1527
1528                                         dataLine += "ATTACH";
1529
1530                                         if (calendarAlarmData[calendarAlarmDataSeek].attachListFormatType[attachListSeek].size() > 0){
1531
1532                                                 dataLine += ";FMTTYPE=";
1533                                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].attachListFormatType[attachListSeek];
1534
1535                                         }
1536
1537                                         if (calendarAlarmData[calendarAlarmDataSeek].attachListValue[attachListSeek].size() > 0){
1538
1539                                                 dataLine += ";VALUE=";
1540                                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].attachListValue[attachListSeek];
1541
1542                                         }
1543
1544                                         if (calendarAlarmData[calendarAlarmDataSeek].attachListEncoding[attachListSeek].size() > 0){
1545
1546                                                 dataLine += ";ENCODING=";
1547                                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].attachListEncoding[attachListSeek];
1548
1549                                         }
1550
1551                                         if (calendarAlarmData[calendarAlarmDataSeek].attachListTokens[attachListSeek].size() > 0){
1552
1553                                                 dataLine += ";";
1554                                                 dataLine += calendarAlarmData[calendarAlarmDataSeek].attachListTokens[attachListSeek];
1555
1556                                         }
1557
1558                                         dataLine += ":";
1559                                         dataLine += calendarAlarmData[calendarAlarmDataSeek].attachList[attachListSeek];
1560                                         dataLine += "\n";
1561
1562                                         dataLineProcessed = OutputText(&dataLine);
1563
1564                                         *saveData += dataLineProcessed;
1565
1566                                         dataLine.clear();
1567                                         dataLineProcessed.clear();
1568
1569                                 }
1570
1571                         }
1572
1573                         // Process the X-Token VALARM values.
1574
1575                         if (calendarAlarmData[calendarAlarmDataSeek].xTokensData.size() > 0){
1576
1577                                 for (int xTokenSeek = 0; xTokenSeek < calendarAlarmData[calendarAlarmDataSeek].xTokensData.size();
1578                                         xTokenSeek++){
1579
1580                                         dataLine += calendarAlarmData[calendarAlarmDataSeek].xTokensDataTokens[xTokenSeek];
1581                                         dataLine += ":";
1582                                         dataLine += calendarAlarmData[calendarAlarmDataSeek].xTokensData[xTokenSeek];
1583                                         dataLine += "\n";
1584
1585                                         dataLineProcessed = OutputText(&dataLine);
1586
1587                                         *saveData += dataLineProcessed;
1588
1589                                         dataLine.clear();
1590                                         dataLineProcessed.clear();
1591
1592                                 }
1593
1594                         }
1595
1596                         *saveData += "END:VALARM\n";
1597
1598                 }
1599
1600         }
1601
1602         // Process the X-Token values.
1603
1604         if (xTokensData.size() > 0){
1605
1606                 for (int xTokenSeek = 0; xTokenSeek < xTokensData.size();
1607                         xTokenSeek++){
1608
1609                         dataLine += xTokensDataTokens[xTokenSeek];
1610                         dataLine += ":";
1611                         dataLine += xTokensData[xTokenSeek];
1612                         dataLine += "\n";
1613
1614                         dataLineProcessed = OutputText(&dataLine);
1615
1616                         *saveData += dataLineProcessed;
1617
1618                         dataLine.clear();
1619                         dataLineProcessed.clear();
1620
1621                 }
1622
1623         }
1624
1625         *saveData += "END:VEVENT\n";
1626
1627 }