source/objects/calendarjournal/CalendarJournal-Save.cpp

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