source/objects/calendarjournal/CalendarJournal.cpp

   1 // CalendarJournal.cpp - CalendarJournal class 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 CalendarObjectValidResult CalendarJournalObject::ValidObject(){
  24
  25         bool validBegin = false;
  26         bool validEnd = false;
  27         bool validDateTimeStamp = false;
  28         bool validUniqueID = false;
  29         int seekCount = 0;
  30         string propertyName;
  31
  32         // Look for BEGIN:VJOURNAL.
  33
  34         for (vector<string>::iterator iter = objectName.begin();
  35                 iter != objectName.end(); iter++){
  36
  37                 if (objectName[seekCount] == "BEGIN" &&
  38                         objectData[seekCount] == "VJOURNAL"){
  39
  40                         if (validBegin == false){
  41                                 validBegin = true;
  42                         } else {
  43                                 return CALENDAROBJECTVALID_INVALIDFORMAT;
  44                         }
  45
  46                 }
  47
  48                 if (objectName[seekCount] == "END" &&
  49                         objectData[seekCount] == "VJOURNAL" &&
  50                         validBegin == false){
  51
  52                         return CALENDAROBJECTVALID_INVALIDFORMAT;
  53
  54                 }
  55
  56                 seekCount++;
  57
  58         }
  59
  60         seekCount = 0;
  61
  62         // Look for DTSTAMP.
  63
  64         for (vector<string>::iterator iter = objectName.begin();
  65                 iter != objectName.end(); iter++){
  66
  67                 try{
  68                         propertyName = objectName[seekCount].substr(0,7);
  69                 }
  70
  71                 catch(const out_of_range& oor){
  72                         continue;
  73                 }
  74
  75                 if (propertyName == "DTSTAMP"){
  76
  77                         if (validDateTimeStamp == false){
  78                                 validDateTimeStamp = true;
  79                         } else {
  80                                 return CALENDAROBJECTVALID_INVALIDFORMAT;
  81                         }
  82
  83                 }
  84
  85                 seekCount++;
  86
  87         }
  88
  89         seekCount = 0;
  90
  91         // Look for UID.
  92
  93         for (vector<string>::iterator iter = objectName.begin();
  94                 iter != objectName.end(); iter++){
  95
  96                 try{
  97                         propertyName = objectName[seekCount].substr(0,3);
  98                 }
  99
 100                 catch(const out_of_range& oor){
 101                         continue;
 102                 }
 103
 104                 if (propertyName == "UID"){
 105
 106                         if (validUniqueID == false){
 107                                 validUniqueID = true;
 108                         } else {
 109                                 return CALENDAROBJECTVALID_INVALIDFORMAT;
 110                         }
 111
 112                 }
 113
 114                 seekCount++;
 115
 116         }
 117
 118         seekCount = 0;
 119
 120         // Look for END:VJOURNAL.
 121
 122         for (vector<string>::iterator iter = objectName.begin();
 123                 iter != objectName.end(); iter++){
 124
 125                 if (objectName[SeekCount] == "END" &&
 126                         objectData[SeekCount] == "VJOURNAL"){
 127
 128                         if (validEnd == false){
 129                                 validEnd = true;
 130                         } else {
 131                                 return CALENDAROBJECTVALID_INVALIDFORMAT;
 132                         }
 133
 134                 }
 135
 136                 seekCount++;
 137
 138         }
 139
 140         // Check if the VJOURNAL is valid.
 141
 142         if (validBegin == true &&
 143                 validEnd == true &&
 144                 validDateTimeStamp == true &&
 145                 validUniqueID == true){
 146
 147                 return CALENDAROBJECTVALID_OK;
 148
 149         } else {
 150
 151                 return CALENDAROBJECTVALID_INVALIDFORMAT;
 152
 153         }
 154
 155 }
 156
 157 void CalendarJournalObject::ProcessData(){
 158
 159         // Process the data.
 160
 161         multimap<string,string> dataReceived;
 162         map<string,string> propertyData;
 163         string *PropertyNameData = nullptr;
 164         int objectSeekCount = 0;
 165
 166         // Get the Date Time Stamp (DTSTAMP).
 167
 168         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "DTSTAMP");
 169
 170         // Process the data from DTSTAMP.
 171
 172         if (dataReceived.begin() != dataReceived.end()){
 173
 174                 try {
 175                         dateTimeStampTokens = dataReceived.begin()->first.substr(8);
 176                 }
 177
 178                 catch(const out_of_range &oor){
 179                         // Do nothing as there is no data.
 180                 }
 181
 182                 dateTimeStampData = dataReceived.begin()->second;
 183
 184         }
 185
 186         // Get the Unique ID (UID).
 187
 188         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "UID");
 189
 190         // Process the data from UID.
 191
 192         if (dataReceived.begin() != dataReceived.end()){
 193
 194                 try {
 195                         uniqueIDTokens = dataReceived.begin()->first.substr(4);
 196                 }
 197
 198                 catch(const out_of_range &oor){
 199                         // Do nothing as there is no data.
 200                 }
 201
 202                 uniqueID = dataReceived.begin()->second;
 203
 204         }
 205
 206         // Process the data from CLASS.
 207
 208         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "CLASS");
 209
 210         if (dataReceived.begin() != dataReceived.end()){
 211
 212                 try {
 213                         classDataTokens = dataReceived.begin()->first.substr(6);
 214                 }
 215
 216                 catch(const out_of_range &oor){
 217                         // Do nothing as there is no data.
 218                 }
 219
 220                 classData = dataReceived.begin()->second;
 221
 222         }
 223
 224         // Get the Date Time Start value.
 225
 226         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "DTSTART");
 227
 228         // Process the data from DTSTART.
 229
 230         if (dataReceived.begin() != dataReceived.end()){
 231
 232                 bool tokenData = false;
 233                 string propertyTokens;
 234
 235                 propertyNameData = (string*)&dataReceived.begin()->first;
 236
 237                 propertyData = SplitValues(*propertyNameData);
 238
 239                 for(map<string,string>::iterator iter = propertyData.begin();
 240                         iter != propertyData.end(); iter++){
 241
 242                         if (iter->first == "VALUE"){
 243
 244                                 dateTimeStartDataValue = iter->second;
 245
 246                         } else if (iter->first == "TZID"){
 247
 248                                 dateTimeStartDataTimeZoneID = iter->second;
 249
 250                         } else {
 251
 252                                 if (tokenData == false){
 253                                         tokenData = true;
 254                                 } else {
 255                                         propertyTokens += ";";
 256                                 }
 257
 258                                 propertyTokens += iter->first;
 259                                 propertyTokens += "=";
 260                                 propertyTokens += iter->second;
 261
 262                         }
 263
 264                 }
 265
 266                 if (propertyTokens.size() > 0){
 267                         dateTimeStartDataTokens = propertyTokens;
 268                 }
 269
 270                 dateTimeStartData = dataReceived.begin()->second;
 271
 272         }
 273
 274         // Process the data from LAST-MODIFIED.
 275
 276         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "LAST-MODIFIED");
 277
 278         if (dataReceived.begin() != dataReceived.end()){
 279
 280                 try {
 281                         lastModifiedTokens = dataReceived.begin()->first.substr(14);
 282                 }
 283
 284                 catch(const out_of_range &oor){
 285                         // Do nothing as there is no data.
 286                 }
 287
 288                 lastModifiedData = dataReceived.begin()->second;
 289
 290         }
 291
 292         // Process the data from ORGANIZER.
 293
 294         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "ORGANIZER");
 295
 296         if (dataReceived.begin() != dataReceived.end()){
 297
 298                 bool tokenData = false;
 299                 string propertyTokens;
 300
 301                 propertyNameData = (string*)&dataReceived.begin()->first;
 302
 303                 propertyData = SplitValues(*propertyNameData);
 304
 305                 for(map<string,string>::iterator iter = propertyData.begin();
 306                         iter != propertyData.end(); iter++){
 307
 308                         if (iter->first == "CN"){
 309
 310                                 organiserDataCommonName = iter->second;
 311
 312                         } else if (iter->first == "DIR"){
 313
 314                                 organiserDataDirectoryEntry = iter->second;
 315
 316                         } else if (iter->first == "SENT-BY"){
 317
 318                                 organiserDataSentByParam = iter->second;
 319
 320                         } else if (iter->first == "LANGUAGE"){
 321
 322                                 organiserDataLanguage = iter->second;
 323
 324                         } else {
 325
 326                                 if (tokenData == false){
 327                                         tokenData = true;
 328                                 } else {
 329                                         propertyTokens += ";";
 330                                 }
 331
 332                                 propertyTokens += iter->first;
 333                                 propertyTokens += "=";
 334                                 propertyTokens += iter->second;
 335
 336                         }
 337
 338                 }
 339
 340                 if (propertyTokens.size() > 0){
 341
 342                         organiserDataTokens = propertyTokens;
 343
 344                 }
 345
 346                 organiserData = dataReceived.begin()->second;
 347
 348         }
 349
 350         // Process the data from RECURRENCE-ID.
 351
 352         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "RECURRENCE-ID");
 353
 354         if (dataReceived.begin() != dataReceived.end()){
 355
 356                 bool tokenData = false;
 357                 string propertyTokens;
 358
 359                 propertyNameData = (string*)&dataReceived.begin()->first;
 360
 361                 propertyData = SplitValues(*propertyNameData);
 362
 363                 for(map<string,string>::iterator iter = propertyData.begin();
 364                         iter != propertyData.end(); iter++){
 365
 366                         if (iter->first == "TZID"){
 367
 368                                 recurranceIDDataTimeZoneParam = iter->second;
 369
 370                         } else if (iter->first == "VALUE"){
 371
 372                                 recurranceIDDataValue = iter->second;
 373
 374                         } else if (iter->first == "RANGE"){
 375
 376                                 recurranceIDDataRangeParam = iter->second;
 377
 378                         } else {
 379
 380                                 if (tokenData == false){
 381                                         tokenData = true;
 382                                 } else {
 383                                         propertyTokens += ";";
 384                                 }
 385
 386                                 propertyTokens += iter->first;
 387                                 propertyTokens += "=";
 388                                 propertyTokens += iter->second;
 389
 390                         }
 391
 392                 }
 393
 394                 if (propertyTokens.size() > 0){
 395
 396                         recurranceIDDataTokens = propertyTokens;
 397
 398                 }
 399
 400                 recurranceIDData = dataReceived.begin()->second;
 401
 402         }
 403
 404         // Process the data from SEQUENCE.
 405
 406         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "SEQUENCE");
 407
 408         if (dataReceived.begin() != dataReceived.end()){
 409
 410                 try {
 411                         sequenceTokens = dataReceived.begin()->first.substr(9);
 412                 }
 413
 414                 catch(const out_of_range &oor){
 415                         // Do nothing as there is no data.
 416                 }
 417
 418                 try {
 419                         sequenceData = stoi(dataReceived.begin()->second);
 420                 }
 421
 422                 catch(const invalid_argument &oor){
 423                         sequenceTokens.clear();
 424                 }
 425
 426         }
 427
 428         // Process the data from STATUS.
 429
 430         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "STATUS");
 431
 432         if (dataReceived.begin() != dataReceived.end()){
 433
 434                 bool tokenData = false;
 435                 string propertyTokens;
 436
 437                 propertyNameData = (string*)&dataReceived.begin()->first;
 438
 439                 propertyData = SplitValues(*propertyNameData);
 440
 441                 for(map<string,string>::iterator iter = propertyData.begin();
 442                         iter != propertyData.end(); iter++){
 443
 444                         if (iter->first == "LANGUAGE"){
 445
 446                                 statusLanguage = iter->second;
 447
 448                         } else {
 449
 450                                 if (tokenData == false){
 451                                         tokenData = true;
 452                                 } else {
 453                                         propertyTokens += ";";
 454                                 }
 455
 456                                 propertyTokens += iter->first;
 457                                 propertyTokens += "=";
 458                                 propertyTokens += iter->second;
 459
 460                         }
 461
 462                 }
 463
 464                 if (propertyTokens.size() > 0){
 465
 466                         statusTokens = propertyTokens;
 467
 468                 }
 469
 470                 statusData = DataReceived.begin()->second;
 471
 472         }
 473
 474         // Process the data from SUMMARY.
 475
 476         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "SUMMARY");
 477
 478         if (dataReceived.begin() != dataReceived.end()){
 479
 480                 bool tokenData = false;
 481                 string propertyTokens;
 482
 483                 propertyNameData = (string*)&dataReceived.begin()->first;
 484
 485                 propertyData = SplitValues(*propertyNameData);
 486
 487                 for(map<string,string>::iterator iter = propertyData.begin();
 488                         iter != propertyData.end(); iter++){
 489
 490                         if (iter->first == "ALTREP"){
 491
 492                                 summaryDataAltRep = iter->second;
 493
 494                         } else if (iter->first == "LANGUAGE"){
 495
 496                                 summaryDataLanguage = iter->second;
 497
 498                         } else {
 499
 500                                 if (tokenData == false){
 501                                         tokenData = true;
 502                                 } else {
 503                                         propertyTokens += ";";
 504                                 }
 505
 506                                 propertyTokens += iter->first;
 507                                 propertyTokens += "=";
 508                                 propertyTokens += iter->second;
 509
 510                         }
 511
 512                 }
 513
 514                 if (propertyTokens.size() > 0){
 515
 516                         summaryDataTokens = propertyTokens;
 517
 518                 }
 519
 520                 summaryData = dataReceived.begin()->second;
 521
 522         }
 523
 524         // Process the data from URL.
 525
 526         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "URL");
 527
 528         if (dataReceived.begin() != dataReceived.end()){
 529
 530                 try {
 531                         urlDataTokens = dataReceived.begin()->first.substr(4);
 532                 }
 533
 534                 catch(const out_of_range &oor){
 535                         // Do nothing as there is no data.
 536                 }
 537
 538                 urlData = dataReceived.begin()->second;
 539
 540         }
 541
 542         // Process the data from RRULE.
 543
 544         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "RRULE");
 545
 546         if (dataReceived.begin() != dataReceived.end()){
 547
 548                 try {
 549                         recurranceRuleDataTokens = dataReceived.begin()->first.substr(6);
 550                 }
 551
 552                 catch(const out_of_range &oor){
 553                         // Do nothing as there is no data.
 554                 }
 555
 556                 recurranceRuleData = dataReceived.begin()->second;
 557
 558         }
 559
 560         // Process the data from ATTACH.
 561
 562         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "ATTACH");
 563
 564         for(multimap<string,string>::iterator iter = dataReceived.begin();
 565                 iter != dataReceived.end();
 566                 ++iter){
 567
 568                 attachListEncoding.push_back("");
 569                 attachListValue.push_back("");
 570                 attachListFormatType.push_back("");
 571                 attachListTokens.push_back("");
 572                 attachList.push_back("");
 573
 574                 bool tokenData = false;
 575                 string propertyTokens;
 576
 577                 propertyNameData = (string*)&iter->first;
 578
 579                 propertyData = SplitValues(*propertyNameData);
 580
 581                 for(map<string,string>::iterator dataiter = propertyData.begin();
 582                         dataiter != propertyData.end(); dataiter++){
 583
 584                         if (dataiter->first == "ENCODING"){
 585
 586                                 attachListEncoding[objectSeekCount] = dataiter->second;
 587
 588                         } else if (dataiter->first == "VALUE"){
 589
 590                                 attachListValue[objectSeekCount] = dataiter->second;
 591
 592                         } else if (dataiter->first == "FMTTYPE"){
 593
 594                                 attachListFormatType[objectSeekCount] = dataiter->second;
 595
 596                         } else {
 597
 598                                 if (tokenData == false){
 599                                         tokenData = true;
 600                                 } else {
 601                                         propertyTokens += ";";
 602                                 }
 603
 604                                 propertyTokens += dataiter->first;
 605                                 propertyTokens += "=";
 606                                 propertyTokens += dataiter->second;
 607
 608                         }
 609
 610                 }
 611
 612                 if (propertyTokens.size() > 0){
 613                         attachListTokens[objectSeekCount] = PropertyTokens;
 614                 }
 615
 616                 attachList[objectSeekCount] = iter->second;
 617
 618                 objectSeekCount++;
 619
 620         }
 621
 622         // Process the data from ATTENDEE.
 623
 624         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "ATTENDEE");
 625
 626         objectSeekCount = 0;
 627
 628         for(multimap<string,string>::iterator iter = dataReceived.begin();
 629                 iter != dataReceived.end();
 630                 ++iter){
 631
 632                 attendeeListMember.push_back("");
 633                 attendeeListDelegatedFrom.push_back("");
 634                 attendeeListDelegatedTo.push_back("");
 635                 attendeeListRole.push_back("");
 636                 attendeeListRSVP.push_back("");
 637                 attendeeListDirectoryEntry.push_back("");
 638                 attendeeListSentBy.push_back("");
 639                 attendeeListCommonName.push_back("");
 640                 attendeeListCalendarUserType.push_back("");
 641                 attendeeListParticipationStatus.push_back("");
 642                 attendeeListLanguage.push_back("");
 643                 attendeeListTokens.push_back("");
 644                 attendeeList.push_back("");
 645
 646                 bool tokenData = false;
 647                 string propertyTokens;
 648
 649                 propertyNameData = (string*)&iter->first;
 650
 651                 propertyData = SplitValues(*propertyNameData);
 652
 653                 for(map<string,string>::iterator dataiter = propertyData.begin();
 654                         dataiter != propertyData.end(); dataiter++){
 655
 656                         if (dataiter->first == "CUTYPE"){
 657
 658                                 attendeeListCalendarUserType[objectSeekCount] = dataiter->second;
 659
 660                         } else if (dataiter->first == "MEMBER"){
 661
 662                                 attendeeListMember[objectSeekCount] = dataiter->second;
 663
 664                         } else if (dataiter->first == "ROLE"){
 665
 666                                 attendeeListRole[objectSeekCount] = dataiter->second;
 667
 668                         } else if (dataiter->first == "PARTSTAT"){
 669
 670                                 attendeeListParticipationStatus[objectSeekCount] = dataiter->second;
 671
 672                         } else if (dataiter->first == "RSVP"){
 673
 674                                 attendeeListRSVP[objectSeekCount] = dataiter->second;
 675
 676                         } else if (dataiter->first == "DELEGATED-TO"){
 677
 678                                 attendeeListDelegatedTo[objectSeekCount] = dataiter->second;
 679
 680                         } else if (dataiter->first == "DELEGATED-FROM"){
 681
 682                                 attendeeListDelegatedFrom[objectSeekCount] = dataiter->second;
 683
 684                         } else if (dataiter->first == "SENT-BY"){
 685
 686                                 attendeeListSentBy[objectSeekCount] = dataiter->second;
 687
 688                         } else if (dataiter->first == "CN"){
 689
 690                                 attendeeListCommonName[objectSeekCount] = dataiter->second;
 691
 692                         } else if (dataiter->first == "DIR"){
 693
 694                                 attendeeListDirectoryEntry[objectSeekCount] = dataiter->second;
 695
 696                         } else if (dataiter->first == "LANGUAGE"){
 697
 698                                 attendeeListLanguage[objectSeekCount] = dataiter->second;
 699
 700                         } else {
 701
 702                                 if (tokenData == false){
 703                                         tokenData = true;
 704                                 } else {
 705                                         propertyTokens += ";";
 706                                 }
 707
 708                                 propertyTokens += dataiter->first;
 709                                 propertyTokens += "=";
 710                                 propertyTokens += dataiter->second;
 711
 712                         }
 713
 714                 }
 715
 716                 if (propertyTokens.size() > 0){
 717                         attendeeListTokens[objectSeekCount] = propertyTokens;
 718                 }
 719
 720                 attendeeList[objectSeekCount] = iter->second;
 721
 722                 objectSeekCount++;
 723
 724         }
 725
 726         // Process the data from CATEGORIES.
 727
 728         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "CATEGORIES");
 729
 730         objectSeekCount = 0;
 731
 732         for(multimap<string,string>::iterator iter = dataReceived.begin();
 733                 iter != dataReceived.end();
 734                 ++iter){
 735
 736                 categoriesListTokens.push_back("");
 737                 categoriesListLanguage.push_back("");
 738                 categoriesList.push_back("");
 739
 740                 bool tokenData = false;
 741                 string propertyTokens;
 742
 743                 propertyNameData = (string*)&iter->first;
 744
 745                 propertyData = SplitValues(*PropertyNameData);
 746
 747                 for(map<string,string>::iterator dataiter = propertyData.begin();
 748                         dataiter != propertyData.end(); dataiter++){
 749
 750                         if (dataiter->first == "LANGUAGE"){
 751
 752                                 categoriesListLanguage[objectSeekCount] = dataiter->second;
 753
 754                         } else {
 755
 756                                 if (tokenData == false){
 757                                         tokenData = true;
 758                                 } else {
 759                                         propertyTokens += ";";
 760                                 }
 761
 762                                 propertyTokens += dataiter->first;
 763                                 propertyTokens += "=";
 764                                 propertyTokens += dataiter->second;
 765
 766                         }
 767
 768                 }
 769
 770                 if (propertyTokens.size() > 0){
 771                         categoriesListTokens[objectSeekCount] = propertyTokens;
 772                 }
 773
 774                 categoriesList[objectSeekCount] = iter->second;
 775
 776                 objectSeekCount++;
 777
 778         }
 779
 780         // Process the data from COMMENT.
 781
 782         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "COMMENT");
 783
 784         objectSeekCount = 0;
 785
 786         for(multimap<string,string>::iterator iter = dataReceived.begin();
 787                 iter != dataReceived.end();
 788                 ++iter){
 789
 790                 commentListTokens.push_back("");
 791                 commentListAltRep.push_back("");
 792                 commentListLanguage.push_back("");
 793                 commentList.push_back("");
 794
 795                 bool tokenData = false;
 796                 string propertyTokens;
 797
 798                 propertyNameData = (string*)&iter->first;
 799
 800                 propertyData = SplitValues(*propertyNameData);
 801
 802                 for(map<string,string>::iterator dataiter = propertyData.begin();
 803                         dataiter != propertyData.end(); dataiter++){
 804
 805                         if (dataiter->first == "ALTREP"){
 806
 807                                 commentListAltRep[objectSeekCount] = dataiter->second;
 808
 809                         } else if (dataiter->first == "LANGUAGE"){
 810
 811                                 commentListLanguage[objectSeekCount] = dataiter->second;
 812
 813                         } else {
 814
 815                                 if (tokenData == false){
 816                                         tokenData = true;
 817                                 } else {
 818                                         propertyTokens += ";";
 819                                 }
 820
 821                                 propertyTokens += dataiter->first;
 822                                 propertyTokens += "=";
 823                                 propertyTokens += dataiter->second;
 824
 825                         }
 826
 827                 }
 828
 829                 if (propertyTokens.size() > 0){
 830                         commentListTokens[objectSeekCount] = propertyTokens;
 831                 }
 832
 833                 commentList[objectSeekCount] = iter->second;
 834
 835                 objectSeekCount++;
 836
 837         }
 838
 839         // Process the data from CONTACT.
 840
 841         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "CONTACT");
 842
 843         objectSeekCount = 0;
 844
 845         for(multimap<string,string>::iterator iter = dataReceived.begin();
 846                 iter != dataReceived.end();
 847                 ++iter){
 848
 849                 contactListTokens.push_back("");
 850                 contactListAltRep.push_back("");
 851                 contactListLanguage.push_back("");
 852                 contactList.push_back("");
 853
 854                 bool tokenData = false;
 855                 string propertyTokens;
 856
 857                 propertyNameData = (string*)&iter->first;
 858
 859                 propertyData = SplitValues(*propertyNameData);
 860
 861                 for(map<string,string>::iterator dataiter = propertyData.begin();
 862                         dataiter != propertyData.end(); dataiter++){
 863
 864                         if (dataiter->first == "ALTREP"){
 865
 866                                 contactListAltRep[objectSeekCount] = dataiter->second;
 867
 868                         } else if (dataiter->first == "LANGUAGE"){
 869
 870                                 contactListLanguage[objectSeekCount] = dataiter->second;
 871
 872                         } else {
 873
 874                                 if (tokenData == false){
 875                                         tokenData = true;
 876                                 } else {
 877                                         propertyTokens += ";";
 878                                 }
 879
 880                                 propertyTokens += dataiter->first;
 881                                 propertyTokens += "=";
 882                                 propertyTokens += dataiter->second;
 883
 884                         }
 885
 886                 }
 887
 888                 if (propertyTokens.size() > 0){
 889                         contactListTokens[objectSeekCount] = propertyTokens;
 890                 }
 891
 892                 contactList[objectSeekCount] = iter->second;
 893
 894                 objectSeekCount++;
 895
 896         }
 897
 898         // Process the data from Description.
 899
 900         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "DESCRIPTION");
 901
 902         objectSeekCount = 0;
 903
 904         for(multimap<string,string>::iterator iter = dataReceived.begin();
 905                 iter != dataReceived.end();
 906                 ++iter){
 907
 908                 descriptionListTokens.push_back("");
 909                 descriptionListAltRep.push_back("");
 910                 descriptionListLanguage.push_back("");
 911                 descriptionList.push_back("");
 912
 913                 bool tokenData = false;
 914                 string propertyTokens;
 915
 916                 propertyNameData = (string*)&iter->first;
 917
 918                 propertyData = SplitValues(*propertyNameData);
 919
 920                 for(map<string,string>::iterator dataiter = propertyData.begin();
 921                         dataiter != propertyData.end(); dataiter++){
 922
 923                         if (dataiter->first == "ALTREP"){
 924
 925                                 descriptionListAltRep[objectSeekCount] = dataiter->second;
 926
 927                         } else if (dataiter->first == "LANGUAGE"){
 928
 929                                 descriptionListLanguage[objectSeekCount] = dataiter->second;
 930
 931                         } else {
 932
 933                                 if (tokenData == false){
 934                                         tokenData = true;
 935                                 } else {
 936                                         propertyTokens += ";";
 937                                 }
 938
 939                                 propertyTokens += dataiter->first;
 940                                 propertyTokens += "=";
 941                                 propertyTokens += dataiter->second;
 942
 943                         }
 944
 945                 }
 946
 947                 if (propertyTokens.size() > 0){
 948                         descriptionListTokens[objectSeekCount] = propertyTokens;
 949                 }
 950
 951                 descriptionList[objectSeekCount] = iter->second;
 952
 953                 objectSeekCount++;
 954
 955         }
 956
 957         // Process the data from EXDATE.
 958
 959         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "EXDATE");
 960
 961         objectSeekCount = 0;
 962
 963         for(multimap<string,string>::iterator iter = dataReceived.begin();
 964                 iter != dataReceived.end();
 965                 ++iter){
 966
 967                 excludeDateDataTokens.push_back("");
 968                 excludeDateDataValue.push_back("");
 969                 excludeDateDataTimeZoneParam.push_back("");
 970                 excludeDateData.push_back("");
 971
 972                 bool tokenData = false;
 973                 string propertyTokens;
 974
 975                 propertyNameData = (string*)&iter->first;
 976
 977                 propertyData = SplitValues(*propertyNameData);
 978
 979                 for(map<string,string>::iterator dataiter = propertyData.begin();
 980                         dataiter != propertyData.end(); dataiter++){
 981
 982                         if (dataiter->first == "VALUE"){
 983
 984                                 excludeDateDataValue[objectSeekCount] = dataiter->second;
 985
 986                         } else if (dataiter->first == "TZID"){
 987
 988                                 excludeDateDataTimeZoneParam[objectSeekCount] = dataiter->second;
 989
 990                         } else {
 991
 992                                 if (tokenData == false){
 993                                         tokenData = true;
 994                                 } else {
 995                                         propertyTokens += ";";
 996                                 }
 997
 998                                 propertyTokens += dataiter->first;
 999                                 propertyTokens += "=";
1000                                 propertyTokens += dataiter->second;
1001
1002                         }
1003
1004                 }
1005
1006                 if (propertyTokens.size() > 0){
1007                         excludeDateDataTokens[objectSeekCount] = propertyTokens;
1008                 }
1009
1010                 excludeDateData[objectSeekCount] = iter->second;
1011
1012                 objectSeekCount++;
1013
1014         }
1015
1016         // Process the data from RELATED-TO.
1017
1018         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "RELATED-TO");
1019
1020         objectSeekCount = 0;
1021
1022         for(multimap<string,string>::iterator iter = dataReceived.begin();
1023                 iter != dataReceived.end();
1024                 ++iter){
1025
1026                 relatedToDataTokens.push_back("");
1027                 relatedToDataRelationType.push_back("");
1028                 relatedToData.push_back("");
1029
1030                 bool tokenData = false;
1031                 string propertyTokens;
1032
1033                 propertyNameData = (string*)&iter->first;
1034
1035                 propertyData = SplitValues(*propertyNameData);
1036
1037                 for(map<string,string>::iterator dataiter = propertyData.begin();
1038                         dataiter != propertyData.end(); dataiter++){
1039
1040                         if (dataiter->first == "RELTYPE"){
1041
1042                                 relatedToDataRelationType[objectSeekCount] = dataiter->second;
1043
1044                         } else {
1045
1046                                 if (tokenData == false){
1047                                         tokenData = true;
1048                                 } else {
1049                                         propertyTokens += ";";
1050                                 }
1051
1052                                 propertyTokens += dataiter->first;
1053                                 propertyTokens += "=";
1054                                 propertyTokens += dataiter->second;
1055
1056                         }
1057
1058                 }
1059
1060                 if (propertyTokens.size() > 0){
1061                         relatedToDataTokens[objectSeekCount] = propertyTokens;
1062                 }
1063
1064                 relatedToData[objectSeekCount] = iter->second;
1065
1066                 objectSeekCount++;
1067
1068         }
1069
1070         // Process the data from RDATE.
1071
1072         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "RDATE");
1073
1074         objectSeekCount = 0;
1075
1076         for(multimap<string,string>::iterator iter = dataReceived.begin();
1077                 iter != dataReceived.end();
1078                 ++iter){
1079
1080                 recurranceDateDataTokens.push_back("");
1081                 recurranceDateDataValue.push_back("");
1082                 recurranceDateDataTimeZoneParam.push_back("");
1083                 recurranceDateData.push_back("");
1084
1085                 bool tokenData = false;
1086                 string propertyTokens;
1087
1088                 propertyNameData = (string*)&iter->first;
1089
1090                 propertyData = SplitValues(*propertyNameData);
1091
1092                 for(map<string,string>::iterator dataiter = propertyData.begin();
1093                         dataiter != propertyData.end(); dataiter++){
1094
1095                         if (dataiter->first == "VALUE"){
1096
1097                                 recurranceDateDataValue[objectSeekCount] = dataiter->second;
1098
1099                         } else if (dataiter->first == "TZID"){
1100
1101                                 recurranceDateDataTimeZoneParam[objectSeekCount] = dataiter->second;
1102
1103                         } else {
1104
1105                                 if (tokenData == false){
1106                                         tokenData = true;
1107                                 } else {
1108                                         propertyTokens += ";";
1109                                 }
1110
1111                                 propertyTokens += dataiter->first;
1112                                 propertyTokens += "=";
1113                                 propertyTokens += dataiter->second;
1114
1115                         }
1116
1117                 }
1118
1119                 if (propertyTokens.size() > 0){
1120                         recurranceDateDataTokens[objectSeekCount] = propertyTokens;
1121                 }
1122
1123                 recurranceDateData[objectSeekCount] = iter->second;
1124
1125                 objectSeekCount++;
1126
1127         }
1128
1129         // Process the data from REQUEST-STATUS.
1130
1131         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "REQUEST-STATUS");
1132
1133         objectSeekCount = 0;
1134
1135         for(multimap<string,string>::iterator iter = dataReceived.begin();
1136                 iter != dataReceived.end();
1137                 ++iter){
1138
1139                 requestStatusTokens.push_back("");
1140                 requestStatusLanguage.push_back("");
1141                 requestStatusData.push_back("");
1142
1143                 bool tokenData = false;
1144                 string propertyTokens;
1145
1146                 propertyNameData = (string*)&iter->first;
1147
1148                 propertyData = SplitValues(*propertyNameData);
1149
1150                 for(map<string,string>::iterator dataiter = propertyData.begin();
1151                         dataiter != propertyData.end(); dataiter++){
1152
1153                         if (dataiter->first == "LANGUAGE"){
1154
1155                                 requestStatusLanguage[objectSeekCount] = dataiter->second;
1156
1157                         } else {
1158
1159                                 if (tokenData == false){
1160                                         tokenData = true;
1161                                 } else {
1162                                         propertyTokens += ";";
1163                                 }
1164
1165                                 propertyTokens += dataiter->first;
1166                                 propertyTokens += "=";
1167                                 propertyTokens += dataiter->second;
1168
1169                         }
1170
1171                 }
1172
1173                 if (propertyTokens.size() > 0){
1174                         requestStatusTokens[objectSeekCount] = propertyTokens;
1175                 }
1176
1177                 requestStatusData[objectSeekCount] = iter->second;
1178
1179                 objectSeekCount++;
1180
1181         }
1182
1183         objectSeekCount = 0;
1184
1185         // Process data from X-*
1186
1187         for(vector<string>::iterator iter = objectName.begin();
1188                 iter != objectName.end(); ++iter){
1189
1190                 bool tokenData = false;
1191                 string propertyTokens;
1192
1193                 if (iter->substr(0,2) == "X-" &&
1194                         iter->size() > 2){
1195
1196                         xTokensData.push_back(objectData[objectSeekCount]);
1197                         xTokensDataTokens.push_back(objectName[objectSeekCount]);
1198
1199                 }
1200
1201                 objectSeekCount++;
1202
1203         }
1204
1205 }