source/objects/calendarjournal/CalendarJournal-Save.cpp

   1 #include "CalendarJournal.h"
   2
   3 using namespace std;
   4
   5 void CalendarJournalObject::SaveObjectData(string *SaveData){
   6
   7         string DataLine = "";
   8         string DataLineProcessed = "";
   9
  10         *SaveData += "BEGIN:VJOURNAL\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 SUMMARY.
  69
  70         if (SummaryData.size() > 0){
  71
  72                 DataLine += "SUMMARY";
  73
  74                 if (SummaryDataAltRep.size() > 0){
  75
  76                         DataLine += ";ALTREP=\"";
  77                         DataLine += SummaryDataAltRep;
  78                         DataLine += "\"";
  79
  80                 }
  81
  82                 if (SummaryDataLanguage.size() > 0){
  83
  84                         DataLine += ";LANGUAGE=";
  85                         DataLine += SummaryDataLanguage;
  86
  87                 }
  88
  89                 if (SummaryDataTokens.size() > 0){
  90
  91                         DataLine += ";";
  92                         DataLine += SummaryDataTokens;
  93
  94                 }
  95
  96                 DataLine += ":";
  97                 DataLine += SummaryData;
  98                 DataLine += "\n";
  99
 100                 DataLineProcessed = OutputText(&DataLine);
 101
 102                 *SaveData += DataLineProcessed;
 103
 104                 DataLine.clear();
 105                 DataLineProcessed.clear();
 106
 107         }
 108
 109         // Process the CLASS.
 110
 111         if (ClassData.size() > 0){
 112
 113                 DataLine += "CLASS";
 114
 115                 if (ClassDataTokens.size() > 0){
 116
 117                         DataLine += ";";
 118                         DataLine += ClassDataTokens;
 119
 120                 }
 121
 122                 DataLine += ":";
 123                 DataLine += ClassData;
 124                 DataLine += "\n";
 125
 126                 DataLineProcessed = OutputText(&DataLine);
 127
 128                 *SaveData += DataLineProcessed;
 129
 130                 DataLine.clear();
 131                 DataLineProcessed.clear();
 132
 133         }
 134
 135         // Process the DTSTART.
 136
 137         if (DateTimeStartData.size() > 0){
 138
 139                 DataLine += "DTSTART";
 140
 141                 if (DateTimeStartDataValue.size() > 0){
 142
 143                         DataLine += ";VALUE=";
 144                         DataLine += DateTimeStartDataValue;
 145
 146                 }
 147
 148                 if (DateTimeStartDataTimeZoneID.size() > 0){
 149
 150                         DataLine += ";TZID=";
 151                         DataLine += DateTimeStartDataTimeZoneID;
 152
 153                 }
 154
 155                 if (DateTimeStartDataTokens.size() > 0){
 156
 157                         DataLine += ";";
 158                         DataLine += DateTimeStartDataTokens;
 159
 160                 }
 161
 162                 DataLine += ":";
 163                 DataLine += DateTimeStartData;
 164                 DataLine += "\n";
 165
 166                 DataLineProcessed = OutputText(&DataLine);
 167
 168                 *SaveData += DataLineProcessed;
 169
 170                 DataLine.clear();
 171                 DataLineProcessed.clear();
 172
 173         }
 174
 175         // Process the LAST-MODIFIED value.
 176
 177         if (LastModifiedData.size() > 0){
 178
 179                 if (LastModifiedTokens.size() > 0){
 180
 181                         DataLine += "LAST-MODIFIED;";
 182                         DataLine += LastModifiedTokens;
 183
 184                 } else {
 185
 186                         DataLine += "LAST-MODIFIED";
 187
 188                 }
 189
 190                 DataLine += ":";
 191                 DataLine += LastModifiedData;
 192                 DataLine += "\n";
 193
 194                 DataLineProcessed = OutputText(&DataLine);
 195
 196                 *SaveData += DataLineProcessed;
 197
 198                 DataLine.clear();
 199                 DataLineProcessed.clear();
 200
 201         }
 202
 203         // Process the ORGANIZER value.
 204
 205         if (OrganiserData.size() > 0){
 206
 207                 DataLine += "ORGANIZER";
 208
 209                 if (OrganiserDataCommonName.size() > 0){
 210
 211                         DataLine += ";CN=";
 212                         DataLine += OrganiserDataCommonName;
 213
 214                 }
 215
 216                 if (OrganiserDataDirectoryEntry.size() > 0){
 217
 218                         DataLine += ";DIR=\"";
 219                         DataLine += OrganiserDataDirectoryEntry;
 220                         DataLine += "\"";
 221
 222                 }
 223
 224                 if (OrganiserDataSentByParam.size() > 0){
 225
 226                         DataLine += ";SENT-BY=\"";
 227                         DataLine += OrganiserDataSentByParam;
 228                         DataLine += "\"";
 229
 230                 }
 231
 232                 if (OrganiserDataLanguage.size() > 0){
 233
 234                         DataLine += ";LANGUAGE=";
 235                         DataLine += OrganiserDataLanguage;
 236
 237                 }
 238
 239                 if (OrganiserDataTokens.size() > 0){
 240
 241                         DataLine += ";";
 242                         DataLine += OrganiserDataTokens;
 243
 244                 }
 245
 246                 DataLine += ":";
 247                 DataLine += OrganiserData;
 248                 DataLine += "\n";
 249
 250                 DataLineProcessed = OutputText(&DataLine);
 251
 252                 *SaveData += DataLineProcessed;
 253
 254                 DataLine.clear();
 255                 DataLineProcessed.clear();
 256
 257         }
 258
 259         // Process the RECURRENCE-ID value.
 260
 261         if (RecurranceIDData.size() > 0){
 262
 263                 DataLine += "RECURRENCE-ID";
 264
 265                 if (RecurranceIDDataTimeZoneParam.size() > 0){
 266
 267                         DataLine += ";TZID=";
 268                         DataLine += RecurranceIDDataTimeZoneParam;
 269
 270                 }
 271
 272                 if (RecurranceIDDataRangeParam.size() > 0){
 273
 274                         DataLine += ";RANGE=";
 275                         DataLine += RecurranceIDDataRangeParam;
 276
 277                 }
 278
 279                 if (RecurranceIDDataValue.size() > 0){
 280
 281                         DataLine += ";VALUE=";
 282                         DataLine += RecurranceIDDataValue;
 283
 284                 }
 285
 286                 if (RecurranceIDDataTokens.size() > 0){
 287
 288                         DataLine += ";";
 289                         DataLine += RecurranceIDDataTokens;
 290
 291                 }
 292
 293                 DataLine += ":";
 294                 DataLine += RecurranceIDData;
 295                 DataLine += "\n";
 296
 297                 DataLineProcessed = OutputText(&DataLine);
 298
 299                 *SaveData += DataLineProcessed;
 300
 301                 DataLine.clear();
 302                 DataLineProcessed.clear();
 303
 304         }
 305
 306         // Process the SEQUENCE value.
 307
 308         if (SequenceData > -1 && SequenceData < 10){
 309
 310                 DataLine += "SEQUENCE";
 311
 312                 if (SequenceTokens.size() > 0){
 313
 314                         DataLine += ";";
 315                         DataLine += SequenceTokens;
 316
 317                 }
 318
 319                 DataLine += ":";
 320                 DataLine += to_string(SequenceData);
 321                 DataLine += "\n";
 322
 323                 DataLineProcessed = OutputText(&DataLine);
 324
 325                 *SaveData += DataLineProcessed;
 326
 327                 DataLine.clear();
 328                 DataLineProcessed.clear();
 329
 330         }
 331
 332         // Process the STATUS value.
 333
 334         if (StatusData.size() > 0){
 335
 336                 DataLine += "STATUS";
 337
 338                 if (StatusLanguage.size() > 0){
 339
 340                         DataLine += ";LANGUAGE=";
 341                         DataLine += StatusLanguage;
 342
 343                 }
 344
 345                 if (StatusTokens.size() > 0){
 346
 347                         DataLine += ";";
 348                         DataLine += StatusTokens;
 349
 350                 }
 351
 352                 DataLine += ":";
 353                 DataLine += StatusData;
 354                 DataLine += "\n";
 355
 356                 DataLineProcessed = OutputText(&DataLine);
 357
 358                 *SaveData += DataLineProcessed;
 359
 360                 DataLine.clear();
 361                 DataLineProcessed.clear();
 362
 363         }
 364
 365         // Process the URL value.
 366
 367         if (URLData.size() > 0){
 368
 369                 DataLine += "URL";
 370
 371                 if (URLDataTokens.size() > 0){
 372
 373                         DataLine += ";";
 374                         DataLine += URLDataTokens;
 375
 376                 }
 377
 378                 DataLine += ":";
 379                 DataLine += URLData;
 380                 DataLine += "\n";
 381
 382                 DataLineProcessed = OutputText(&DataLine);
 383
 384                 *SaveData += DataLineProcessed;
 385
 386                 DataLine.clear();
 387                 DataLineProcessed.clear();
 388
 389         }
 390
 391         // Process the RRULE value.
 392
 393         if (RecurranceRuleData.size() > 0){
 394
 395                 DataLine += "RRULE";
 396
 397                 if (RecurranceRuleDataTokens.size() > 0){
 398
 399                         DataLine += ";";
 400                         DataLine += RecurranceRuleDataTokens;
 401
 402                 }
 403
 404                 DataLine += ":";
 405                 DataLine += RecurranceRuleData;
 406                 DataLine += "\n";
 407
 408                 DataLineProcessed = OutputText(&DataLine);
 409
 410                 *SaveData += DataLineProcessed;
 411
 412                 DataLine.clear();
 413                 DataLineProcessed.clear();
 414
 415         }
 416
 417         // Process the ATTACH values.
 418
 419         if (AttachList.size() > 0){
 420
 421                 for (int AttachListSeek = 0; AttachListSeek < AttachList.size();
 422                         AttachListSeek++){
 423
 424                         DataLine += "ATTACH";
 425
 426                         if (AttachListFormatType[AttachListSeek].size() > 0){
 427
 428                                 DataLine += ";FMTTYPE=";
 429                                 DataLine += AttachListFormatType[AttachListSeek];
 430
 431                         }
 432
 433                         if (AttachListValue[AttachListSeek].size() > 0){
 434
 435                                 DataLine += ";VALUE=";
 436                                 DataLine += AttachListValue[AttachListSeek];
 437
 438                         }
 439
 440                         if (AttachListEncoding[AttachListSeek].size() > 0){
 441
 442                                 DataLine += ";ENCODING=";
 443                                 DataLine += AttachListEncoding[AttachListSeek];
 444
 445                         }
 446
 447                         if (AttachListTokens[AttachListSeek].size() > 0){
 448
 449                                 DataLine += ";";
 450                                 DataLine += AttachListTokens[AttachListSeek];
 451
 452                         }
 453
 454                         DataLine += ":";
 455                         DataLine += AttachList[AttachListSeek];
 456                         DataLine += "\n";
 457
 458                         DataLineProcessed = OutputText(&DataLine);
 459
 460                         *SaveData += DataLineProcessed;
 461
 462                         DataLine.clear();
 463                         DataLineProcessed.clear();
 464
 465                 }
 466
 467         }
 468
 469         // Process the ATTENDEE value.
 470
 471         if (AttendeeList.size() > 0){
 472
 473                 for (int AttendeeListSeek = 0; AttendeeListSeek < AttendeeList.size();
 474                         AttendeeListSeek++){
 475
 476                         DataLine += "ATTENDEE";
 477
 478                         if (AttendeeListMember[AttendeeListSeek].size() > 0){
 479
 480                                 DataLine += ";MEMBER=\"";
 481                                 DataLine += AttendeeListMember[AttendeeListSeek];
 482                                 DataLine += "\"";
 483
 484                         }
 485
 486                         if (AttendeeListDelegatedFrom[AttendeeListSeek].size() > 0){
 487
 488                                 DataLine += ";DELEGATED-FROM=\"";
 489                                 DataLine += AttendeeListDelegatedFrom[AttendeeListSeek];
 490                                 DataLine += "\"";
 491
 492                         }
 493
 494                         if (AttendeeListDelegatedTo[AttendeeListSeek].size() > 0){
 495
 496                                 DataLine += ";DELEGATED-TO=\"";
 497                                 DataLine += AttendeeListDelegatedTo[AttendeeListSeek];
 498                                 DataLine += "\"";
 499
 500                         }
 501
 502                         if (AttendeeListRole[AttendeeListSeek].size() > 0){
 503
 504                                 DataLine += ";ROLE=";
 505                                 DataLine += AttendeeListRole[AttendeeListSeek];
 506
 507                         }
 508
 509                         if (AttendeeListRSVP[AttendeeListSeek].size() > 0){
 510
 511                                 DataLine += ";RSVP=";
 512                                 DataLine += AttendeeListRSVP[AttendeeListSeek];
 513
 514                         }
 515
 516                         if (AttendeeListDirectoryEntry[AttendeeListSeek].size() > 0){
 517
 518                                 DataLine += ";DIR=\"";
 519                                 DataLine += AttendeeListDirectoryEntry[AttendeeListSeek];
 520                                 DataLine += "\"";
 521
 522                         }
 523
 524                         if (AttendeeListSentBy[AttendeeListSeek].size() > 0){
 525
 526                                 DataLine += ";SENT-BY=\"";
 527                                 DataLine += AttendeeListSentBy[AttendeeListSeek];
 528                                 DataLine += "\"";
 529
 530                         }
 531
 532                         if (AttendeeListCommonName[AttendeeListSeek].size() > 0){
 533
 534                                 DataLine += ";CN=\"";
 535                                 DataLine += AttendeeListCommonName[AttendeeListSeek];
 536                                 DataLine += "\"";
 537
 538                         }
 539
 540                         if (AttendeeListCalendarUserType[AttendeeListSeek].size() > 0){
 541
 542                                 DataLine += ";CUTYPE=";
 543                                 DataLine += AttendeeListCalendarUserType[AttendeeListSeek];
 544
 545                         }
 546
 547                         if (AttendeeListParticipationStatus[AttendeeListSeek].size() > 0){
 548
 549                                 DataLine += ";PARTSTAT=";
 550                                 DataLine += AttendeeListParticipationStatus[AttendeeListSeek];
 551
 552                         }
 553
 554                         if (AttendeeListLanguage[AttendeeListSeek].size() > 0){
 555
 556                                 DataLine += ";LANGUAGE=";
 557                                 DataLine += AttendeeListLanguage[AttendeeListSeek];
 558
 559                         }
 560
 561                         if (AttendeeListTokens[AttendeeListSeek].size() > 0){
 562
 563                                 DataLine += ";";
 564                                 DataLine += AttendeeListTokens[AttendeeListSeek];
 565
 566                         }
 567
 568                         DataLine += ":";
 569                         DataLine += AttendeeList[AttendeeListSeek];
 570                         DataLine += "\n";
 571
 572                         DataLineProcessed = OutputText(&DataLine);
 573
 574                         *SaveData += DataLineProcessed;
 575
 576                         DataLine.clear();
 577                         DataLineProcessed.clear();
 578
 579                 }
 580
 581         }
 582
 583         // Process the CATEGORIES value.
 584
 585         if (CategoriesList.size() > 0){
 586
 587                 for (int CategoriesListSeek = 0; CategoriesListSeek < CategoriesList.size();
 588                         CategoriesListSeek++){
 589
 590                         DataLine += "CATEGORIES";
 591
 592                         if (CategoriesListLanguage[CategoriesListSeek].size() > 0){
 593
 594                                 DataLine += ";LANGUAGE=";
 595                                 DataLine += CategoriesListLanguage[CategoriesListSeek];
 596
 597                         }
 598
 599                         if (CategoriesListTokens[CategoriesListSeek].size() > 0){
 600
 601                                 DataLine += ";";
 602                                 DataLine += CategoriesListTokens[CategoriesListSeek];
 603
 604                         }
 605
 606                         DataLine += ":";
 607                         DataLine += CategoriesList[CategoriesListSeek];
 608                         DataLine += "\n";
 609
 610                         DataLineProcessed = OutputText(&DataLine);
 611
 612                         *SaveData += DataLineProcessed;
 613
 614                         DataLine.clear();
 615                         DataLineProcessed.clear();
 616
 617                 }
 618
 619         }
 620
 621         // Process the COMMENT value.
 622
 623         if (CommentList.size() > 0){
 624
 625                 for (int CommentListSeek = 0; CommentListSeek < CommentList.size();
 626                         CommentListSeek++){
 627
 628                         DataLine += "COMMENT";
 629
 630                         if (CommentListAltRep[CommentListSeek].size() > 0){
 631
 632                                 DataLine += ";ALTREP=\"";
 633                                 DataLine += CommentListAltRep[CommentListSeek];
 634                                 DataLine += "\"";
 635
 636                         }
 637
 638                         if (CommentListLanguage[CommentListSeek].size() > 0){
 639
 640                                 DataLine += ";LANGUAGE=";
 641                                 DataLine += CommentListLanguage[CommentListSeek];
 642
 643                         }
 644
 645                         if (CommentListTokens[CommentListSeek].size() > 0){
 646
 647                                 DataLine += ";";
 648                                 DataLine += CommentListTokens[CommentListSeek];
 649
 650                         }
 651
 652                         DataLine += ":";
 653                         DataLine += CommentList[CommentListSeek];
 654                         DataLine += "\n";
 655
 656                         DataLineProcessed = OutputText(&DataLine);
 657
 658                         *SaveData += DataLineProcessed;
 659
 660                         DataLine.clear();
 661                         DataLineProcessed.clear();
 662
 663                 }
 664
 665         }
 666
 667         // Process the CONTACT value.
 668
 669         if (ContactList.size() > 0){
 670
 671                 for (int ContactListSeek = 0; ContactListSeek < ContactList.size();
 672                         ContactListSeek++){
 673
 674                         DataLine += "CONTACT";
 675
 676                         if (ContactListAltRep[ContactListSeek].size() > 0){
 677
 678                                 DataLine += ";ALTREP=\"";
 679                                 DataLine += ContactListAltRep[ContactListSeek];
 680                                 DataLine += "\"";
 681
 682                         }
 683
 684                         if (ContactListLanguage[ContactListSeek].size() > 0){
 685
 686                                 DataLine += ";LANGUAGE=";
 687                                 DataLine += ContactListLanguage[ContactListSeek];
 688
 689                         }
 690
 691                         if (ContactListTokens[ContactListSeek].size() > 0){
 692
 693                                 DataLine += ";";
 694                                 DataLine += ContactListTokens[ContactListSeek];
 695
 696                         }
 697
 698                         DataLine += ":";
 699                         DataLine += ContactList[ContactListSeek];
 700                         DataLine += "\n";
 701
 702                         DataLineProcessed = OutputText(&DataLine);
 703
 704                         *SaveData += DataLineProcessed;
 705
 706                         DataLine.clear();
 707                         DataLineProcessed.clear();
 708
 709                 }
 710
 711         }
 712
 713         // Process the DESCRIPTION values.
 714
 715         if (DescriptionList.size() > 0){
 716
 717                 for (int DescriptionListSeek = 0; DescriptionListSeek < DescriptionList.size() > 0;
 718                         DescriptionListSeek++){
 719
 720                         DataLine += "DESCRIPTION";
 721
 722                         if (DescriptionListAltRep[DescriptionListSeek].size() > 0){
 723
 724                                 DataLine += ";ALTREP=\"";
 725                                 DataLine += DescriptionListAltRep[DescriptionListSeek];
 726                                 DataLine += "\"";
 727
 728                         }
 729
 730                         if (DescriptionListLanguage[DescriptionListSeek].size() > 0){
 731
 732                                 DataLine += ";LANGUAGE=";
 733                                 DataLine += DescriptionListLanguage[DescriptionListSeek];
 734
 735                         }
 736
 737                         if (DescriptionListTokens[DescriptionListSeek].size() > 0){
 738
 739                                 DataLine += ";";
 740                                 DataLine += DescriptionListTokens[DescriptionListSeek];
 741
 742                         }
 743
 744                         DataLine += ":";
 745                         DataLine += DescriptionList[DescriptionListSeek];
 746                         DataLine += "\n";
 747
 748                         DataLineProcessed = OutputText(&DataLine);
 749
 750                         *SaveData += DataLineProcessed;
 751
 752                         DataLine.clear();
 753                         DataLineProcessed.clear();
 754
 755                 }
 756
 757         }
 758
 759         // Process the EXDATE value.
 760
 761         if (ExcludeDateData.size() > 0){
 762
 763                 for (int ExcludeDateDataSeek = 0; ExcludeDateDataSeek < ExcludeDateData.size();
 764                         ExcludeDateDataSeek++){
 765
 766                         DataLine += "EXDATE";
 767
 768                         if (ExcludeDateDataTimeZoneParam[ExcludeDateDataSeek].size() > 0){
 769
 770                                 DataLine += ";TZID=";
 771                                 DataLine += ExcludeDateDataTimeZoneParam[ExcludeDateDataSeek];
 772
 773                         }
 774
 775                         if (ExcludeDateDataValue[ExcludeDateDataSeek].size() > 0){
 776
 777                                 DataLine += ";VALUE=";
 778                                 DataLine += ExcludeDateDataValue[ExcludeDateDataSeek];
 779
 780                         }
 781
 782                         if (ExcludeDateDataTokens[ExcludeDateDataSeek].size() > 0){
 783
 784                                 DataLine += ";";
 785                                 DataLine += ExcludeDateDataTokens[ExcludeDateDataSeek];
 786
 787                         }
 788
 789                         DataLine += ":";
 790                         DataLine += ExcludeDateData[ExcludeDateDataSeek];
 791                         DataLine += "\n";
 792
 793                         DataLineProcessed = OutputText(&DataLine);
 794
 795                         *SaveData += DataLineProcessed;
 796
 797                         DataLine.clear();
 798                         DataLineProcessed.clear();
 799
 800                 }
 801
 802         }
 803
 804         // Process the RELATED-TO value.
 805
 806         if (RelatedToData.size() > 0){
 807
 808                 for (int RequestToDataSeek = 0; RequestToDataSeek < RelatedToData.size();
 809                         RequestToDataSeek++){
 810
 811                         DataLine += "RELATED-TO";
 812
 813                         if (RelatedToDataRelationType[RequestToDataSeek].size() > 0){
 814
 815                                 DataLine += ";RELTYPE=";
 816                                 DataLine += RelatedToDataRelationType[RequestToDataSeek];
 817
 818                         }
 819
 820                         if (RelatedToDataTokens[RequestToDataSeek].size() > 0){
 821
 822                                 DataLine += ";";
 823                                 DataLine += RelatedToDataTokens[RequestToDataSeek];
 824
 825                         }
 826
 827                         DataLine += ":";
 828                         DataLine += RelatedToData[RequestToDataSeek];
 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 RDATE value.
 843
 844         if (RecurranceDateData.size() > 0){
 845
 846                 for (int RecurranceDateDataSeek = 0; RecurranceDateDataSeek < RecurranceDateData.size();
 847                         RecurranceDateDataSeek++){
 848
 849                         DataLine += "RDATE";
 850
 851                         if (RecurranceDateDataValue[RecurranceDateDataSeek].size() > 0){
 852
 853                                 DataLine += ";VALUE=";
 854                                 DataLine += RecurranceDateDataValue[RecurranceDateDataSeek];
 855
 856                         }
 857
 858                         if (RecurranceDateDataTimeZoneParam[RecurranceDateDataSeek].size() > 0){
 859
 860                                 DataLine += ";TZID=";
 861                                 DataLine += RecurranceDateDataTimeZoneParam[RecurranceDateDataSeek];
 862
 863                         }
 864
 865                         if (RecurranceDateDataTokens[RecurranceDateDataSeek].size() > 0){
 866
 867                                 DataLine += ";";
 868                                 DataLine += RecurranceDateDataTokens[RecurranceDateDataSeek];
 869
 870                         }
 871
 872                         DataLine += ":";
 873                         DataLine += RecurranceDateData[RecurranceDateDataSeek];
 874                         DataLine += "\n";
 875
 876                         DataLineProcessed = OutputText(&DataLine);
 877
 878                         *SaveData += DataLineProcessed;
 879
 880                         DataLine.clear();
 881                         DataLineProcessed.clear();
 882
 883                 }
 884
 885         }
 886
 887         // Process the REQUEST-STATUS value.
 888
 889         if (RequestStatusData.size() > 0){
 890
 891                 for (int RequestStatusDataSeek = 0; RequestStatusDataSeek < RequestStatusData.size();
 892                         RequestStatusDataSeek++){
 893
 894                         DataLine += "REQUEST-STATUS";
 895
 896                         if (RequestStatusLanguage[RequestStatusDataSeek].size() > 0){
 897
 898                                 DataLine += ";LANGUAGE=";
 899                                 DataLine += RequestStatusLanguage[RequestStatusDataSeek];
 900
 901                         }
 902
 903                         if (RequestStatusTokens[RequestStatusDataSeek].size() > 0){
 904
 905                                 DataLine += ";";
 906                                 DataLine += RequestStatusTokens[RequestStatusDataSeek];
 907
 908                         }
 909
 910                         DataLine += ":";
 911                         DataLine += RequestStatusData[RequestStatusDataSeek];
 912                         DataLine += "\n";
 913
 914                         DataLineProcessed = OutputText(&DataLine);
 915
 916                         *SaveData += DataLineProcessed;
 917
 918                         DataLine.clear();
 919                         DataLineProcessed.clear();
 920
 921                 }
 922
 923         }
 924
 925         // Process the X-Token values.
 926
 927         if (XTokensData.size() > 0){
 928
 929                 for (int XTokenSeek = 0; XTokenSeek < XTokensData.size();
 930                         XTokenSeek++){
 931
 932                         DataLine += XTokensDataTokens[XTokenSeek];
 933                         DataLine += ":";
 934                         DataLine += XTokensData[XTokenSeek];
 935                         DataLine += "\n";
 936
 937                         DataLineProcessed = OutputText(&DataLine);
 938
 939                         *SaveData += DataLineProcessed;
 940
 941                         DataLine.clear();
 942                         DataLineProcessed.clear();
 943
 944                 }
 945
 946         }
 947
 948         *SaveData += "END:VJOURNAL\n";
 949
 950 }