source/objects/calendartask/CalendarTask.cpp

   1 // CalendarTask.cpp - CalendarTask 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 "CalendarTask.h"
  20
  21 using namespace std;
  22
  23 CalendarObjectValidResult CalendarTaskObject::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:VTODO.
  33
  34         for (vector<string>::iterator iter = objectName.begin();
  35                 iter != objectName.end(); iter++){
  36
  37                 if (objectName[seekCount] == "BEGIN" &&
  38                         objectData[seekCount] == "VTODO"){
  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] == "VTODO" &&
  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:VTODO.
 121
 122         for (vector<string>::iterator iter = objectName.begin();
 123                 iter != objectName.end(); iter++){
 124
 125                 if (objectName[SeekCount] == "END" &&
 126                         objectData[SeekCount] == "VTODO"){
 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 VTODO 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 CalendarTaskObject::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         // Process the data from COMPLETED.
 225
 226         dataReceived = processTextVectors(&ObjectName, &ObjectData, false, "COMPLETED");
 227
 228         if (dataReceived.begin() != dataReceived.end()){
 229
 230                 try {
 231                         completedDataTokens = dataReceived.begin()->first.substr(10);
 232                 }
 233
 234                 catch(const out_of_range &oor){
 235                         // Do nothing as there is no data.
 236                 }
 237
 238                 completedData = dataReceived.begin()->second;
 239
 240         }
 241
 242         // Process the data from CREATED.
 243
 244         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "CREATED");
 245
 246         if (DataReceived.begin() != DataReceived.end()){
 247
 248                 try {
 249                         dateTimeCreatedTokens = dataReceived.begin()->first.substr(8);
 250                 }
 251
 252                 catch(const out_of_range &oor){
 253                         // Do nothing as there is no data.
 254                 }
 255
 256                 dateTimeCreatedData = dataReceived.begin()->second;
 257
 258         }
 259
 260         // Process the data from DESCRIPTION.
 261
 262         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "DESCRIPTION");
 263
 264         if (dataReceived.begin() != dataReceived.end()){
 265
 266                 bool tokenData = false;
 267                 string propertyTokens;
 268
 269                 propertyNameData = (string*)&dataReceived.begin()->first;
 270
 271                 propertyData = SplitValues(*propertyNameData);
 272
 273                 for(map<string,string>::iterator iter = propertyData.begin();
 274                         iter != propertyData.end(); iter++){
 275
 276                         if (iter->first == "ALTREP"){
 277
 278                                 descriptionListAltRep.clear();
 279                                 descriptionListAltRep.push_back(iter->second);
 280
 281                         } else if (iter->first == "LANGUAGE"){
 282
 283                                 descriptionListLanguage.clear();
 284                                 descriptionListLanguage.push_back(iter->second);
 285
 286                         } else {
 287
 288                                 if (tokenData == false){
 289                                         tokenData = true;
 290                                 } else {
 291                                         propertyTokens += ";";
 292                                 }
 293
 294                                 propertyTokens += iter->first;
 295                                 propertyTokens += "=";
 296                                 propertyTokens += iter->second;
 297
 298                         }
 299
 300                 }
 301
 302                 if (propertyTokens.size() > 0){
 303                         descriptionListTokens.clear();
 304                         descriptionListTokens.push_back(PropertyTokens);
 305                 }
 306
 307                 descriptionList.clear();
 308                 descriptionList.push_back(dataReceived.begin()->second);
 309
 310         }
 311
 312         // Get the Date Time Start value.
 313
 314         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "DTSTART");
 315
 316         // Process the data from DTSTART.
 317
 318         if (dataReceived.begin() != dataReceived.end()){
 319
 320                 bool tokenData = false;
 321                 string propertyTokens;
 322
 323                 propertyNameData = (string*)&dataReceived.begin()->first;
 324
 325                 propertyData = SplitValues(*propertyNameData);
 326
 327                 for(map<string,string>::iterator iter = propertyData.begin();
 328                         iter != propertyData.end(); iter++){
 329
 330                         if (iter->first == "VALUE"){
 331
 332                                 dateTimeStartDataValue = iter->second;
 333
 334                         } else if (iter->first == "TZID"){
 335
 336                                 dateTimeStartDataTimeZoneID = iter->second;
 337
 338                         } else {
 339
 340                                 if (tokenData == false){
 341                                         tokenData = true;
 342                                 } else {
 343                                         propertyTokens += ";";
 344                                 }
 345
 346                                 propertyTokens += iter->first;
 347                                 propertyTokens += "=";
 348                                 propertyTokens += iter->second;
 349
 350                         }
 351
 352                 }
 353
 354                 if (propertyTokens.size() > 0){
 355                         dateTimeStartDataTokens = propertyTokens;
 356                 }
 357
 358                 dateTimeStartData = dataReceived.begin()->second;
 359
 360         }
 361
 362         // Process the data from GEO.
 363
 364         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "GEO");
 365
 366         if (dataReceived.begin() != dataReceived.end()){
 367
 368                 try {
 369                         geographicTokens = dataReceived.begin()->first.substr(4);
 370                 }
 371
 372                 catch(const out_of_range &oor){
 373                         // Do nothing as there is no data.
 374                 }
 375
 376                 geographicData = dataReceived.begin()->second;
 377
 378         }
 379
 380         // Process the data from LAST-MODIFIED.
 381
 382         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "LAST-MODIFIED");
 383
 384         if (dataReceived.begin() != dataReceived.end()){
 385
 386                 try {
 387                         lastModifiedTokens = dataReceived.begin()->first.substr(14);
 388                 }
 389
 390                 catch(const out_of_range &oor){
 391                         // Do nothing as there is no data.
 392                 }
 393
 394                 lastModifiedData = dataReceived.begin()->second;
 395
 396         }
 397
 398         // Process the data from LOCATION.
 399
 400         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "LOCATION");
 401
 402         if (dataReceived.begin() != dataReceived.end()){
 403
 404                 bool tokenData = false;
 405                 string propertyTokens;
 406
 407                 propertyNameData = (string*)&dataReceived.begin()->first;
 408
 409                 propertyData = SplitValues(*propertyNameData);
 410
 411                 for(map<string,string>::iterator iter = propertyData.begin();
 412                         iter != propertyData.end(); iter++){
 413
 414                         if (iter->first == "ALTREP"){
 415
 416                                 locationDataAltRep = iter->second;
 417
 418                         } else if (iter->first == "LANGUAGE"){
 419
 420                                 locationDataLanguage = iter->second;
 421
 422                         } else {
 423
 424                                 if (tokenData == false){
 425                                         tokenData = true;
 426                                 } else {
 427                                         propertyTokens += ";";
 428                                 }
 429
 430                                 propertyTokens += iter->first;
 431                                 propertyTokens += "=";
 432                                 propertyTokens += iter->second;
 433
 434                         }
 435
 436                 }
 437
 438                 if (propertyTokens.size() > 0){
 439
 440                         locationDataTokens = propertyTokens;
 441
 442                 }
 443
 444                 locationData = dataReceived.begin()->second;
 445
 446         }
 447
 448         // Process the data from ORGANIZER.
 449
 450         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "ORGANIZER");
 451
 452         if (dataReceived.begin() != dataReceived.end()){
 453
 454                 bool tokenData = false;
 455                 string propertyTokens;
 456
 457                 propertyNameData = (string*)&dataReceived.begin()->first;
 458
 459                 propertyData = SplitValues(*propertyNameData);
 460
 461                 for(map<string,string>::iterator iter = propertyData.begin();
 462                         iter != propertyData.end(); iter++){
 463
 464                         if (iter->first == "CN"){
 465
 466                                 organiserDataCommonName = iter->second;
 467
 468                         } else if (iter->first == "DIR"){
 469
 470                                 organiserDataDirectoryEntry = iter->second;
 471
 472                         } else if (iter->first == "SENT-BY"){
 473
 474                                 organiserDataSentByParam = iter->second;
 475
 476                         } else if (iter->first == "LANGUAGE"){
 477
 478                                 organiserDataLanguage = iter->second;
 479
 480                         } else {
 481
 482                                 if (tokenData == false){
 483                                         tokenData = true;
 484                                 } else {
 485                                         propertyTokens += ";";
 486                                 }
 487
 488                                 propertyTokens += iter->first;
 489                                 propertyTokens += "=";
 490                                 propertyTokens += iter->second;
 491
 492                         }
 493
 494                 }
 495
 496                 if (propertyTokens.size() > 0){
 497
 498                         organiserDataTokens = propertyTokens;
 499
 500                 }
 501
 502                 organiserData = dataReceived.begin()->second;
 503
 504         }
 505
 506         // Process the data from PERCENT-COMPLETE.
 507
 508         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "PERCENT-COMPLETE");
 509
 510         if (dataReceived.begin() != dataReceived.end()){
 511
 512                 try {
 513                         percentCompleteTokens = dataReceived.begin()->first.substr(17);
 514                 }
 515
 516                 catch(const out_of_range &oor){
 517                         // Do nothing as there is no data.
 518                 }
 519
 520                 percentCompleteData = dataReceived.begin()->second;
 521
 522         }
 523
 524         // Process the data from PRIORITY.
 525
 526         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "PRIORITY");
 527
 528         if (dataReceived.begin() != dataReceived.end()){
 529
 530                 try {
 531                         priorityTokens = dataReceived.begin()->first.substr(9);
 532                 }
 533
 534                 catch(const out_of_range &oor){
 535                         // Do nothing as there is no data.
 536                 }
 537
 538                 try {
 539                         priorityData = stoi(dataReceived.begin()->second);
 540                 }
 541
 542                 catch(const invalid_argument &oor){
 543                         priorityTokens.clear();
 544                 }
 545
 546         }
 547
 548         // Process the data from RECURRENCE-ID.
 549
 550         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "RECURRENCE-ID");
 551
 552         if (dataReceived.begin() != dataReceived.end()){
 553
 554                 bool tokenData = false;
 555                 string propertyTokens;
 556
 557                 propertyNameData = (string*)&dataReceived.begin()->first;
 558
 559                 propertyData = SplitValues(*propertyNameData);
 560
 561                 for(map<string,string>::iterator iter = propertyData.begin();
 562                         iter != propertyData.end(); iter++){
 563
 564                         if (iter->first == "TZID"){
 565
 566                                 recurranceIDDataTimeZoneParam = iter->second;
 567
 568                         } else if (iter->first == "VALUE"){
 569
 570                                 recurranceIDDataValue = iter->second;
 571
 572                         } else if (iter->first == "RANGE"){
 573
 574                                 recurranceIDDataRangeParam = iter->second;
 575
 576                         } else {
 577
 578                                 if (tokenData == false){
 579                                         tokenData = true;
 580                                 } else {
 581                                         propertyTokens += ";";
 582                                 }
 583
 584                                 propertyTokens += iter->first;
 585                                 propertyTokens += "=";
 586                                 propertyTokens += iter->second;
 587
 588                         }
 589
 590                 }
 591
 592                 if (propertyTokens.size() > 0){
 593
 594                         recurranceIDDataTokens = propertyTokens;
 595
 596                 }
 597
 598                 recurranceIDData = dataReceived.begin()->second;
 599
 600         }
 601
 602         // Process the data from SEQUENCE.
 603
 604         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "SEQUENCE");
 605
 606         if (dataReceived.begin() != dataReceived.end()){
 607
 608                 try {
 609                         sequenceTokens = dataReceived.begin()->first.substr(9);
 610                 }
 611
 612                 catch(const out_of_range &oor){
 613                         // Do nothing as there is no data.
 614                 }
 615
 616                 try {
 617                         sequenceData = stoi(dataReceived.begin()->second);
 618                 }
 619
 620                 catch(const invalid_argument &oor){
 621                         sequenceTokens.clear();
 622                 }
 623
 624         }
 625
 626         // Process the data from STATUS.
 627
 628         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "STATUS");
 629
 630         if (dataReceived.begin() != dataReceived.end()){
 631
 632                 bool tokenData = false;
 633                 string propertyTokens;
 634
 635                 propertyNameData = (string*)&dataReceived.begin()->first;
 636
 637                 propertyData = SplitValues(*propertyNameData);
 638
 639                 for(map<string,string>::iterator iter = propertyData.begin();
 640                         iter != propertyData.end(); iter++){
 641
 642                         if (iter->first == "LANGUAGE"){
 643
 644                                 statusLanguage = iter->second;
 645
 646                         } else {
 647
 648                                 if (tokenData == false){
 649                                         tokenData = true;
 650                                 } else {
 651                                         propertyTokens += ";";
 652                                 }
 653
 654                                 propertyTokens += iter->first;
 655                                 propertyTokens += "=";
 656                                 propertyTokens += iter->second;
 657
 658                         }
 659
 660                 }
 661
 662                 if (propertyTokens.size() > 0){
 663
 664                         statusTokens = propertyTokens;
 665
 666                 }
 667
 668                 statusData = dataReceived.begin()->second;
 669
 670         }
 671
 672         // Process the data from SUMMARY.
 673
 674         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "SUMMARY");
 675
 676         if (dataReceived.begin() != dataReceived.end()){
 677
 678                 bool tokenData = false;
 679                 string propertyTokens;
 680
 681                 propertyNameData = (string*)&dataReceived.begin()->first;
 682
 683                 propertyData = SplitValues(*propertyNameData);
 684
 685                 for(map<string,string>::iterator iter = propertyData.begin();
 686                         iter != propertyData.end(); iter++){
 687
 688                         if (iter->first == "ALTREP"){
 689
 690                                 summaryDataAltRep = iter->second;
 691
 692                         } else if (iter->first == "LANGUAGE"){
 693
 694                                 summaryDataLanguage = iter->second;
 695
 696                         } else {
 697
 698                                 if (tokenData == false){
 699                                         tokenData = true;
 700                                 } else {
 701                                         propertyTokens += ";";
 702                                 }
 703
 704                                 propertyTokens += iter->first;
 705                                 propertyTokens += "=";
 706                                 propertyTokens += iter->second;
 707
 708                         }
 709
 710                 }
 711
 712                 if (propertyTokens.size() > 0){
 713
 714                         summaryDataTokens = propertyTokens;
 715
 716                 }
 717
 718                 summaryData = dataReceived.begin()->second;
 719
 720         }
 721
 722         // Process the data from URL.
 723
 724         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "URL");
 725
 726         if (dataReceived.begin() != dataReceived.end()){
 727
 728                 try {
 729                         urlDataTokens = dataReceived.begin()->first.substr(4);
 730                 }
 731
 732                 catch(const out_of_range &oor){
 733                         // Do nothing as there is no data.
 734                 }
 735
 736                 urlData = dataReceived.begin()->second;
 737
 738         }
 739
 740         // Process the data from RRULE.
 741
 742         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "RRULE");
 743
 744         if (dataReceived.begin() != dataReceived.end()){
 745
 746                 try {
 747                         recurranceRuleDataTokens = dataReceived.begin()->first.substr(6);
 748                 }
 749
 750                 catch(const out_of_range &oor){
 751                         // Do nothing as there is no data.
 752                 }
 753
 754                 recurranceRuleData = dataReceived.begin()->second;
 755
 756         }
 757
 758         bool dueProcessed = false;
 759
 760         // Process the data from DUE.
 761
 762         dataReceived = ProcessTextVectors(&objectName, &objectData, false, "DUE");
 763
 764         if (dataReceived.begin() != dataReceived.end()){
 765
 766                 bool tokenData = false;
 767                 string propertyTokens;
 768
 769                 propertyNameData = (string*)&dataReceived.begin()->first;
 770
 771                 propertyData = SplitValues(*propertyNameData);
 772
 773                 for(map<string,string>::iterator iter = propertyData.begin();
 774                         iter != propertyData.end(); iter++){
 775
 776                         if (iter->first == "TZID"){
 777
 778                                 dueDataTimeZoneID = iter->second;
 779
 780                         } else if (iter->first == "VALUE"){
 781
 782                                 dueDataValue = iter->second;
 783
 784                         } else {
 785
 786                                 if (tokenData == false){
 787                                         tokenData = true;
 788                                 } else {
 789                                         propertyTokens += ";";
 790                                 }
 791
 792                                 propertyTokens += iter->first;
 793                                 propertyTokens += "=";
 794                                 propertyTokens += iter->second;
 795
 796                         }
 797
 798                 }
 799
 800                 if (propertyTokens.size() > 0){
 801
 802                         dueDataTokens = propertyTokens;
 803
 804                 }
 805
 806                 dueData = dataReceived.begin()->second;
 807                 dueProcessed = true;
 808
 809         }
 810
 811         // If there is no DUE, then check for DURATION.
 812
 813         if (dueProcessed == false){
 814
 815                 dataReceived = ProcessTextVectors(&objectName, &objectData, false, "DURATION");
 816
 817                 if (dataReceived.begin() != dataReceived.end()){
 818
 819                         try {
 820                                 durationDataTokens = dataReceived.begin()->first.substr(9);
 821                         }
 822
 823                         catch(const out_of_range &oor){
 824                                 // Do nothing as there is no data.
 825                         }
 826
 827                         durationData = dataReceived.begin()->second;
 828
 829                 }
 830
 831         }
 832
 833         // Process the data from ATTACH.
 834
 835         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "ATTACH");
 836
 837         for(multimap<string,string>::iterator iter = dataReceived.begin();
 838                 iter != dataReceived.end();
 839                 ++iter){
 840
 841                 attachListEncoding.push_back("");
 842                 attachListValue.push_back("");
 843                 attachListFormatType.push_back("");
 844                 attachListTokens.push_back("");
 845                 attachList.push_back("");
 846
 847                 bool tokenData = false;
 848                 string propertyTokens;
 849
 850                 propertyNameData = (string*)&iter->first;
 851
 852                 propertyData = SplitValues(*propertyNameData);
 853
 854                 for(map<string,string>::iterator dataiter = propertyData.begin();
 855                         dataiter != propertyData.end(); dataiter++){
 856
 857                         if (dataiter->first == "ENCODING"){
 858
 859                                 attachListEncoding[objectSeekCount] = dataiter->second;
 860
 861                         } else if (dataiter->first == "VALUE"){
 862
 863                                 attachListValue[objectSeekCount] = dataiter->second;
 864
 865                         } else if (dataiter->first == "FMTTYPE"){
 866
 867                                 attachListFormatType[objectSeekCount] = dataiter->second;
 868
 869                         } else {
 870
 871                                 if (tokenData == false){
 872                                         tokenData = true;
 873                                 } else {
 874                                         propertyTokens += ";";
 875                                 }
 876
 877                                 propertyTokens += dataiter->first;
 878                                 propertyTokens += "=";
 879                                 propertyTokens += dataiter->second;
 880
 881                         }
 882
 883                 }
 884
 885                 if (propertyTokens.size() > 0){
 886                         attachListTokens[objectSeekCount] = propertyTokens;
 887                 }
 888
 889                 attachList[objectSeekCount] = iter->second;
 890
 891                 objectSeekCount++;
 892
 893         }
 894
 895         // Process the data from ATTENDEE.
 896
 897         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "ATTENDEE");
 898
 899         objectSeekCount = 0;
 900
 901         for(multimap<string,string>::iterator iter = dataReceived.begin();
 902                 iter != dataReceived.end();
 903                 ++iter){
 904
 905                 attendeeListMember.push_back("");
 906                 attendeeListDelegatedFrom.push_back("");
 907                 attendeeListDelegatedTo.push_back("");
 908                 attendeeListRole.push_back("");
 909                 attendeeListRSVP.push_back("");
 910                 attendeeListDirectoryEntry.push_back("");
 911                 attendeeListSentBy.push_back("");
 912                 attendeeListCommonName.push_back("");
 913                 attendeeListCalendarUserType.push_back("");
 914                 attendeeListParticipationStatus.push_back("");
 915                 attendeeListLanguage.push_back("");
 916                 attendeeListTokens.push_back("");
 917                 attendeeList.push_back("");
 918
 919                 bool tokenData = false;
 920                 string propertyTokens;
 921
 922                 propertyNameData = (string*)&iter->first;
 923
 924                 propertyData = SplitValues(*propertyNameData);
 925
 926                 for(map<string,string>::iterator dataiter = propertyData.begin();
 927                         dataiter != propertyData.end(); dataiter++){
 928
 929                         if (dataiter->first == "CUTYPE"){
 930
 931                                 attendeeListCalendarUserType[objectSeekCount] = dataiter->second;
 932
 933                         } else if (dataiter->first == "MEMBER"){
 934
 935                                 attendeeListMember[objectSeekCount] = dataiter->second;
 936
 937                         } else if (dataiter->first == "ROLE"){
 938
 939                                 attendeeListRole[objectSeekCount] = dataiter->second;
 940
 941                         } else if (dataiter->first == "PARTSTAT"){
 942
 943                                 attendeeListParticipationStatus[objectSeekCount] = dataiter->second;
 944
 945                         } else if (dataiter->first == "RSVP"){
 946
 947                                 attendeeListRSVP[objectSeekCount] = dataiter->second;
 948
 949                         } else if (dataiter->first == "DELEGATED-TO"){
 950
 951                                 attendeeListDelegatedTo[objectSeekCount] = dataiter->second;
 952
 953                         } else if (dataiter->first == "DELEGATED-FROM"){
 954
 955                                 attendeeListDelegatedFrom[objectSeekCount] = dataiter->second;
 956
 957                         } else if (dataiter->first == "SENT-BY"){
 958
 959                                 attendeeListSentBy[objectSeekCount] = dataiter->second;
 960
 961                         } else if (dataiter->first == "CN"){
 962
 963                                 attendeeListCommonName[objectSeekCount] = dataiter->second;
 964
 965                         } else if (dataiter->first == "DIR"){
 966
 967                                 attendeeListDirectoryEntry[objectSeekCount] = dataiter->second;
 968
 969                         } else if (dataiter->first == "LANGUAGE"){
 970
 971                                 attendeeListLanguage[objectSeekCount] = dataiter->second;
 972
 973                         } else {
 974
 975                                 if (tokenData == false){
 976                                         tokenData = true;
 977                                 } else {
 978                                         propertyTokens += ";";
 979                                 }
 980
 981                                 propertyTokens += dataiter->first;
 982                                 propertyTokens += "=";
 983                                 propertyTokens += dataiter->second;
 984
 985                         }
 986
 987                 }
 988
 989                 if (propertyTokens.size() > 0){
 990                         attendeeListTokens[objectSeekCount] = propertyTokens;
 991                 }
 992
 993                 attendeeList[objectSeekCount] = iter->second;
 994
 995                 objectSeekCount++;
 996
 997         }
 998
 999         // Process the data from CATEGORIES.
1000
1001         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "CATEGORIES");
1002
1003         objectSeekCount = 0;
1004
1005         for(multimap<string,string>::iterator iter = dataReceived.begin();
1006                 iter != dataReceived.end();
1007                 ++iter){
1008
1009                 categoriesListTokens.push_back("");
1010                 categoriesListLanguage.push_back("");
1011                 categoriesList.push_back("");
1012
1013                 bool tokenData = false;
1014                 string propertyTokens;
1015
1016                 propertyNameData = (string*)&iter->first;
1017
1018                 propertyData = SplitValues(*propertyNameData);
1019
1020                 for(map<string,string>::iterator dataiter = propertyData.begin();
1021                         dataiter != propertyData.end(); dataiter++){
1022
1023                         if (dataiter->first == "LANGUAGE"){
1024
1025                                 categoriesListLanguage[objectSeekCount] = dataiter->second;
1026
1027                         } else {
1028
1029                                 if (tokenData == false){
1030                                         tokenData = true;
1031                                 } else {
1032                                         propertyTokens += ";";
1033                                 }
1034
1035                                 propertyTokens += dataiter->first;
1036                                 propertyTokens += "=";
1037                                 propertyTokens += dataiter->second;
1038
1039                         }
1040
1041                 }
1042
1043                 if (propertyTokens.size() > 0){
1044                         categoriesListTokens[objectSeekCount] = propertyTokens;
1045                 }
1046
1047                 categoriesList[objectSeekCount] = iter->second;
1048
1049                 objectSeekCount++;
1050
1051         }
1052
1053         // Process the data from COMMENT.
1054
1055         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "COMMENT");
1056
1057         objectSeekCount = 0;
1058
1059         for(multimap<string,string>::iterator iter = dataReceived.begin();
1060                 iter != dataReceived.end();
1061                 ++iter){
1062
1063                 commentListTokens.push_back("");
1064                 commentListAltRep.push_back("");
1065                 commentListLanguage.push_back("");
1066                 commentList.push_back("");
1067
1068                 bool tokenData = false;
1069                 string propertyTokens;
1070
1071                 propertyNameData = (string*)&iter->first;
1072
1073                 propertyData = SplitValues(*propertyNameData);
1074
1075                 for(map<string,string>::iterator dataiter = propertyData.begin();
1076                         dataiter != propertyData.end(); dataiter++){
1077
1078                         if (dataiter->first == "ALTREP"){
1079
1080                                 commentListAltRep[objectSeekCount] = dataiter->second;
1081
1082                         } else if (dataiter->first == "LANGUAGE"){
1083
1084                                 commentListLanguage[objectSeekCount] = dataiter->second;
1085
1086                         } else {
1087
1088                                 if (tokenData == false){
1089                                         tokenData = true;
1090                                 } else {
1091                                         propertyTokens += ";";
1092                                 }
1093
1094                                 propertyTokens += dataiter->first;
1095                                 propertyTokens += "=";
1096                                 propertyTokens += dataiter->second;
1097
1098                         }
1099
1100                 }
1101
1102                 if (propertyTokens.size() > 0){
1103                         commentListTokens[objectSeekCount] = PropertyTokens;
1104                 }
1105
1106                 commentList[objectSeekCount] = iter->second;
1107
1108                 objectSeekCount++;
1109
1110         }
1111
1112         // Process the data from CONTACT.
1113
1114         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "CONTACT");
1115
1116         objectSeekCount = 0;
1117
1118         for(multimap<string,string>::iterator iter = dataReceived.begin();
1119                 iter != dataReceived.end();
1120                 ++iter){
1121
1122                 contactListTokens.push_back("");
1123                 contactListAltRep.push_back("");
1124                 contactListLanguage.push_back("");
1125                 contactList.push_back("");
1126
1127                 bool tokenData = false;
1128                 string propertyTokens;
1129
1130                 propertyNameData = (string*)&iter->first;
1131
1132                 propertyData = SplitValues(*propertyNameData);
1133
1134                 for(map<string,string>::iterator dataiter = propertyData.begin();
1135                         dataiter != propertyData.end(); dataiter++){
1136
1137                         if (dataiter->first == "ALTREP"){
1138
1139                                 contactListAltRep[objectSeekCount] = dataiter->second;
1140
1141                         } else if (dataiter->first == "LANGUAGE"){
1142
1143                                 contactListLanguage[objectSeekCount] = dataiter->second;
1144
1145                         } else {
1146
1147                                 if (tokenData == false){
1148                                         tokenData = true;
1149                                 } else {
1150                                         propertyTokens += ";";
1151                                 }
1152
1153                                 propertyTokens += dataiter->first;
1154                                 propertyTokens += "=";
1155                                 propertyTokens += dataiter->second;
1156
1157                         }
1158
1159                 }
1160
1161                 if (propertyTokens.size() > 0){
1162                         contactListTokens[objectSeekCount] = propertyTokens;
1163                 }
1164
1165                 contactList[objectSeekCount] = iter->second;
1166
1167                 objectSeekCount++;
1168
1169         }
1170
1171         // Process the data from EXDATE.
1172
1173         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "EXDATE");
1174
1175         objectSeekCount = 0;
1176
1177         for(multimap<string,string>::iterator iter = dataReceived.begin();
1178                 iter != dataReceived.end();
1179                 ++iter){
1180
1181                 excludeDateDataTokens.push_back("");
1182                 excludeDateDataValue.push_back("");
1183                 excludeDateDataTimeZoneParam.push_back("");
1184                 excludeDateData.push_back("");
1185
1186                 bool tokenData = false;
1187                 string propertyTokens;
1188
1189                 propertyNameData = (string*)&iter->first;
1190
1191                 propertyData = SplitValues(*propertyNameData);
1192
1193                 for(map<string,string>::iterator dataiter = propertyData.begin();
1194                         dataiter != propertyData.end(); dataiter++){
1195
1196                         if (dataiter->first == "VALUE"){
1197
1198                                 excludeDateDataValue[objectSeekCount] = dataiter->second;
1199
1200                         } else if (dataiter->first == "TZID"){
1201
1202                                 excludeDateDataTimeZoneParam[objectSeekCount] = dataiter->second;
1203
1204                         } else {
1205
1206                                 if (tokenData == false){
1207                                         tokenData = true;
1208                                 } else {
1209                                         propertyTokens += ";";
1210                                 }
1211
1212                                 propertyTokens += dataiter->first;
1213                                 propertyTokens += "=";
1214                                 propertyTokens += dataiter->second;
1215
1216                         }
1217
1218                 }
1219
1220                 if (propertyTokens.size() > 0){
1221                         excludeDateDataTokens[ObjectSeekCount] = propertyTokens;
1222                 }
1223
1224                 excludeDateData[objectSeekCount] = iter->second;
1225
1226                 objectSeekCount++;
1227
1228         }
1229
1230         // Process the data from REQUEST-STATUS.
1231
1232         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "REQUEST-STATUS");
1233
1234         objectSeekCount = 0;
1235
1236         for(multimap<string,string>::iterator iter = dataReceived.begin();
1237                 iter != dataReceived.end();
1238                 ++iter){
1239
1240                 requestStatusTokens.push_back("");
1241                 requestStatusLanguage.push_back("");
1242                 requestStatusData.push_back("");
1243
1244                 bool tokenData = false;
1245                 string propertyTokens;
1246
1247                 propertyNameData = (string*)&iter->first;
1248
1249                 propertyData = SplitValues(*propertyNameData);
1250
1251                 for(map<string,string>::iterator dataiter = propertyData.begin();
1252                         dataiter != propertyData.end(); dataiter++){
1253
1254                         if (dataiter->first == "LANGUAGE"){
1255
1256                                 requestStatusLanguage[objectSeekCount] = dataiter->second;
1257
1258                         } else {
1259
1260                                 if (tokenData == false){
1261                                         tokenData = true;
1262                                 } else {
1263                                         propertyTokens += ";";
1264                                 }
1265
1266                                 propertyTokens += dataiter->first;
1267                                 propertyTokens += "=";
1268                                 propertyTokens += dataiter->second;
1269
1270                         }
1271
1272                 }
1273
1274                 if (propertyTokens.size() > 0){
1275                         requestStatusTokens[objectSeekCount] = propertyTokens;
1276                 }
1277
1278                 requestStatusData[objectSeekCount] = iter->second;
1279
1280                 objectSeekCount++;
1281
1282         }
1283
1284         // Process the data from RELATED-TO.
1285
1286         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "RELATED-TO");
1287
1288         objectSeekCount = 0;
1289
1290         for(multimap<string,string>::iterator iter = dataReceived.begin();
1291                 iter != dataReceived.end();
1292                 ++iter){
1293
1294                 relatedToDataTokens.push_back("");
1295                 relatedToDataRelationType.push_back("");
1296                 relatedToData.push_back("");
1297
1298                 bool tokenData = false;
1299                 string propertyTokens;
1300
1301                 propertyNameData = (string*)&iter->first;
1302
1303                 propertyData = SplitValues(*propertyNameData);
1304
1305                 for(map<string,string>::iterator dataiter = propertyData.begin();
1306                         dataiter != propertyData.end(); dataiter++){
1307
1308                         if (dataiter->first == "RELTYPE"){
1309
1310                                 relatedToDataRelationType[objectSeekCount] = dataiter->second;
1311
1312                         } else {
1313
1314                                 if (tokenData == false){
1315                                         tokenData = true;
1316                                 } else {
1317                                         propertyTokens += ";";
1318                                 }
1319
1320                                 propertyTokens += dataiter->first;
1321                                 propertyTokens += "=";
1322                                 propertyTokens += dataiter->second;
1323
1324                         }
1325
1326                 }
1327
1328                 if (propertyTokens.size() > 0){
1329                         relatedToDataTokens[objectSeekCount] = propertyTokens;
1330                 }
1331
1332                 relatedToData[objectSeekCount] = iter->second;
1333
1334                 objectSeekCount++;
1335
1336         }
1337
1338         // Process the data from RESOURCES.
1339
1340         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "RESOURCES");
1341
1342         objectSeekCount = 0;
1343
1344         for(multimap<string,string>::iterator iter = dataReceived.begin();
1345                 iter != dataReceived.end();
1346                 ++iter){
1347
1348                 resourcesDataTokens.push_back("");
1349                 resourcesDataAltRep.push_back("");
1350                 resourcesDataLanguage.push_back("");
1351                 resourcesData.push_back("");
1352
1353                 bool tokenData = false;
1354                 string propertyTokens;
1355
1356                 propertyNameData = (string*)&iter->first;
1357
1358                 propertyData = SplitValues(*propertyNameData);
1359
1360                 for(map<string,string>::iterator dataiter = propertyData.begin();
1361                         dataiter != propertyData.end(); dataiter++){
1362
1363                         if (dataiter->first == "ALTREP"){
1364
1365                                 resourcesDataAltRep[objectSeekCount] = dataiter->second;
1366
1367                         } else if (dataiter->first == "LANGUAGE"){
1368
1369                                 resourcesDataLanguage[objectSeekCount] = dataiter->second;
1370
1371                         } else {
1372
1373                                 if (tokenData == false){
1374                                         tokenData = true;
1375                                 } else {
1376                                         propertyTokens += ";";
1377                                 }
1378
1379                                 propertyTokens += dataiter->first;
1380                                 propertyTokens += "=";
1381                                 propertyTokens += dataiter->second;
1382
1383                         }
1384
1385                 }
1386
1387                 if (propertyTokens.size() > 0){
1388                         resourcesDataTokens[objectSeekCount] = PropertyTokens;
1389                 }
1390
1391                 resourcesData[objectSeekCount] = iter->second;
1392
1393                 objectSeekCount++;
1394
1395         }
1396
1397         // Process the data from RDATE.
1398
1399         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "RDATE");
1400
1401         objectSeekCount = 0;
1402
1403         for(multimap<string,string>::iterator iter = dataReceived.begin();
1404                 iter != dataReceived.end();
1405                 ++iter){
1406
1407                 recurranceDateDataTokens.push_back("");
1408                 recurranceDateDataValue.push_back("");
1409                 recurranceDateDataTimeZoneParam.push_back("");
1410                 recurranceDateData.push_back("");
1411
1412                 bool tokenData = false;
1413                 string propertyTokens;
1414
1415                 propertyNameData = (string*)&iter->first;
1416
1417                 propertyData = SplitValues(*propertyNameData);
1418
1419                 for(map<string,string>::iterator dataiter = propertyData.begin();
1420                         dataiter != propertyData.end(); dataiter++){
1421
1422                         if (dataiter->first == "VALUE"){
1423
1424                                 recurranceDateDataValue[objectSeekCount] = dataiter->second;
1425
1426                         } else if (dataiter->first == "TZID"){
1427
1428                                 recurranceDateDataTimeZoneParam[objectSeekCount] = dataiter->second;
1429
1430                         } else {
1431
1432                                 if (tokenData == false){
1433                                         tokenData = true;
1434                                 } else {
1435                                         propertyTokens += ";";
1436                                 }
1437
1438                                 propertyTokens += dataiter->first;
1439                                 propertyTokens += "=";
1440                                 propertyTokens += dataiter->second;
1441
1442                         }
1443
1444                 }
1445
1446                 if (propertyTokens.size() > 0){
1447                         recurranceDateDataTokens[objectSeekCount] = propertyTokens;
1448                 }
1449
1450                 recurranceDateData[objectSeekCount] = iter->second;
1451
1452                 objectSeekCount++;
1453
1454         }
1455
1456         // Process VALARM section.
1457
1458         int seekCount = 0;
1459         int alarmObjectCount = 0;
1460
1461         bool alarmActionFound = false;
1462
1463         for (vector<vector<string>>::iterator iter = eventAlarmName.begin();
1464                 iter != eventAlarmName.end(); iter++){
1465
1466                 CalendarAlarmDataStruct newAlarmData;
1467
1468                 // Process the data from ACTION.
1469
1470                 bool alarmActionFound = false;
1471                 bool alarmTriggerFound = false;
1472                 bool alarmDurationFound = false;
1473                 bool alarmDescriptionFound = false;
1474                 bool alarmSummaryFound = false;
1475
1476                 dataReceived = ProcessTextVectors(&eventAlarmName[seekCount],
1477                                 &eventAlarmData[seekCount], false, "ACTION");
1478
1479                 if (dataReceived.begin() != dataReceived.end()){
1480
1481                         try {
1482                                 newAlarmData.alarmActionTokens = dataReceived.begin()->first.substr(7);
1483                         }
1484
1485                         catch(const out_of_range &oor){
1486                                 // Do nothing as there is no data.
1487                         }
1488
1489                         newAlarmData.alarmAction = dataReceived.begin()->second;
1490                         alarmActionFound = true;
1491
1492                 }
1493
1494                 // Check if a value was set for AlarmAction, otherwise
1495                 // process the next VALARM section.
1496
1497                 if (newAlarmData.alarmAction.size() < 1){
1498
1499                         seekCount++;
1500                         continue;
1501
1502                 }
1503
1504                 // Check if AlarmAction is DISPLAY, AUDIO or EMAIL.
1505                 // Process the next VALARM section if not.
1506
1507                 if (newAlarmData.alarmAction == "AUDIO"){
1508
1509                         newAlarmData.alarmType = CALENDARALARM_AUDIO;
1510
1511                 } else if (newAlarmData.alarmAction == "DISPLAY"){
1512
1513                         newAlarmData.alarmType = CALENDARALARM_DISPLAY;
1514
1515                 } else if (newAlarmData.alarmAction == "EMAIL"){
1516
1517                         newAlarmData.alarmType = CALENDARALARM_EMAIL;
1518
1519                 } else {
1520
1521                         seekCount++;
1522                         continue;
1523
1524                 }
1525
1526                 // Process the data from TRIGGER.
1527
1528                 dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], false, "TRIGGER");
1529
1530                 if (dataReceived.begin() != dataReceived.end()){
1531
1532                         bool tokenData = false;
1533                         string propertyTokens;
1534
1535                         propertyNameData = (string*)&dataReceived.begin()->first;
1536
1537                         propertyData = SplitValues(*propertyNameData);
1538
1539                         for(map<string,string>::iterator iter = propertyData.begin();
1540                                 iter != propertyData.end(); iter++){
1541
1542                                 if (iter->first == "VALUE"){
1543
1544                                         newAlarmData.triggerValue = iter->second;
1545
1546                                 } else if (iter->first == "RELATED"){
1547
1548                                         newAlarmData.triggerRelated = iter->second;
1549
1550                                 } else {
1551
1552                                         if (tokenData == false){
1553                                                 tokenData = true;
1554                                         } else {
1555                                                 propertyTokens += ";";
1556                                         }
1557
1558                                         propertyTokens += iter->first;
1559                                         propertyTokens += "=";
1560                                         propertyTokens += iter->second;
1561
1562                                 }
1563
1564                         }
1565
1566                         if (propertyTokens.size() > 0){
1567                                 newAlarmData.triggerTokens = propertyTokens;
1568                         }
1569
1570                         newAlarmData.triggerData = dataReceived.begin()->second;
1571                         alarmTriggerFound = true;
1572
1573                 }
1574
1575                 // Process the data from DESCRIPTION.
1576
1577                 dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], false, "DESCRIPTION");
1578
1579                 if (dataReceived.begin() != dataReceived.end() &&
1580                         (newAlarmData.alarmType == CALENDARALARM_DISPLAY ||
1581                         newAlarmData.alarmType == CALENDARALARM_EMAIL)){
1582
1583                         bool tokenData = false;
1584                         string propertyTokens;
1585
1586                         propertyameData = (string*)&dataReceived.begin()->first;
1587
1588                         propertyData = SplitValues(*propertyNameData);
1589
1590                         for(map<string,string>::iterator iter = propertyData.begin();
1591                                 iter != propertyData.end(); iter++){
1592
1593                                 if (iter->first == "ALTREP"){
1594
1595                                         newAlarmData.descriptionAltRep = iter->second;
1596
1597                                 } else if (iter->first == "LANGUAGE"){
1598
1599                                         newAlarmData.descriptionLanguage = iter->second;
1600
1601                                 } else {
1602
1603                                         if (tokenData == false){
1604                                                 tokenData = true;
1605                                         } else {
1606                                                 propertyTokens += ";";
1607                                         }
1608
1609                                         propertyTokens += iter->first;
1610                                         propertyTokens += "=";
1611                                         propertyTokens += iter->second;
1612
1613                                 }
1614
1615                         }
1616
1617                         if (propertyTokens.size() > 0){
1618                                 newAlarmData.descriptionTokens = propertyTokens;
1619                         }
1620
1621                         newAlarmData.descriptionData = dataReceived.begin()->second;
1622                         alarmDescriptionFound = true;
1623
1624                 }
1625
1626                 // Process data from SUMMARY.
1627
1628                 dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], false, "SUMMARY");
1629
1630                 if (dataReceived.begin() != dataReceived.end() &&
1631                         newAlarmData.alarmType == CALENDARALARM_EMAIL){
1632
1633                         bool tokenData = false;
1634                         string propertyTokens;
1635
1636                         propertyNameData = (string*)&dataReceived.begin()->first;
1637
1638                         propertyData = SplitValues(*propertyNameData);
1639
1640                         for(map<string,string>::iterator iter = propertyData.begin();
1641                                 iter != propertyData.end(); iter++){
1642
1643                                 if (iter->first == "ALTREP"){
1644
1645                                         newAlarmData.summaryAltRep = iter->second;
1646
1647                                 } else if (iter->first == "LANGUAGE"){
1648
1649                                         newAlarmData.summaryLanguage = iter->second;
1650
1651                                 } else {
1652
1653                                         if (tokenData == false){
1654                                                 tokenData = true;
1655                                         } else {
1656                                                 propertyTokens += ";";
1657                                         }
1658
1659                                         propertyTokens += iter->first;
1660                                         propertyTokens += "=";
1661                                         propertyTokens += iter->second;
1662
1663                                 }
1664
1665                         }
1666
1667                         if (propertyTokens.size() > 0){
1668                                 newAlarmData.summaryTokens = propertyTokens;
1669                         }
1670
1671                         newAlarmData.summaryData = dataReceived.begin()->second;
1672                         alarmSummaryFound = true;
1673
1674                 }
1675
1676                 // Process data from DURATION.
1677
1678                 dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], false, "DURATION");
1679
1680                 if (dataReceived.begin() != dataReceived.end()){
1681
1682                         try {
1683                                 newAlarmData.durationTokens = dataReceived.begin()->first.substr(9);
1684                         }
1685
1686                         catch(const out_of_range &oor){
1687                                 // Do nothing as there is no data.
1688                         }
1689
1690                         newAlarmData.durationData = dataReceived.begin()->second;
1691                         alarmDurationFound = true;
1692
1693                 }
1694
1695                 // Process data from REPEAT.
1696
1697                 dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], false, "REPEAT");
1698
1699                 if (dataReceived.begin() != dataReceived.end() && alarmDurationFound == true){
1700
1701                         try {
1702                                 newAlarmData.repeatTokens = dataReceived.begin()->first.substr(7);
1703                         }
1704
1705                         catch(const out_of_range &oor){
1706                                 // Do nothing as there is no data.
1707                         }
1708
1709                         newAlarmData.repeatData = dataReceived.begin()->second;
1710
1711                 } else {
1712
1713                         newAlarmData.durationData.clear();
1714                         newAlarmData.durationTokens.clear();
1715
1716                 }
1717
1718                 // Process data from ATTENDEE.
1719
1720                 dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], true, "ATTENDEE");
1721
1722                 objectSeekCount = 0;
1723
1724                 for(multimap<string,string>::iterator iter = dataReceived.begin();
1725                         iter != dataReceived.end();
1726                         ++iter){
1727
1728                         newAlarmData.attendeeListMember.push_back("");
1729                         newAlarmData.attendeeListDelegatedFrom.push_back("");
1730                         newAlarmData.attendeeListDelegatedTo.push_back("");
1731                         newAlarmData.attendeeListRole.push_back("");
1732                         newAlarmData.attendeeListRSVP.push_back("");
1733                         newAlarmData.attendeeListDirectoryEntry.push_back("");
1734                         newAlarmData.attendeeListSentBy.push_back("");
1735                         newAlarmData.attendeeListCommonName.push_back("");
1736                         newAlarmData.attendeeListCalendarUserType.push_back("");
1737                         newAlarmData.attendeeListParticipationStatus.push_back("");
1738                         newAlarmData.attendeeListLanguage.push_back("");
1739                         newAlarmData.attendeeListTokens.push_back("");
1740                         newAlarmData.attendeeList.push_back("");
1741
1742                         bool tokenData = false;
1743                         string propertyTokens;
1744
1745                         propertyNameData = (string*)&iter->first;
1746
1747                         propertyData = SplitValues(*propertyNameData);
1748
1749                         for(map<string,string>::iterator dataiter = propertyData.begin();
1750                                 dataiter != propertyData.end(); dataiter++){
1751
1752                                 if (dataiter->first == "CUTYPE"){
1753
1754                                         newAlarmData.attendeeListCalendarUserType[objectSeekCount] = dataiter->second;
1755
1756                                 } else if (dataiter->first == "MEMBER"){
1757
1758                                         newAlarmData.attendeeListMember[objectSeekCount] = dataiter->second;
1759
1760                                 } else if (dataiter->first == "ROLE"){
1761
1762                                         newAlarmData.attendeeListRole[objectSeekCount] = dataiter->second;
1763
1764                                 } else if (dataiter->first == "PARTSTAT"){
1765
1766                                         newAlarmData.attendeeListParticipationStatus[objectSeekCount] = dataiter->second;
1767
1768                                 } else if (dataiter->first == "RSVP"){
1769
1770                                         newAlarmData.attendeeListRSVP[objectSeekCount] = dataiter->second;
1771
1772                                 } else if (dataiter->first == "DELEGATED-TO"){
1773
1774                                         newAlarmData.attendeeListDelegatedTo[objectSeekCount] = dataiter->second;
1775
1776                                 } else if (dataiter->first == "DELEGATED-FROM"){
1777
1778                                         newAlarmData.attendeeListDelegatedFrom[objectSeekCount] = dataiter->second;
1779
1780                                 } else if (dataiter->first == "SENT-BY"){
1781
1782                                         newAlarmData.attendeeListSentBy[objectSeekCount] = dataiter->second;
1783
1784                                 } else if (dataiter->first == "CN"){
1785
1786                                         newAlarmData.attendeeListCommonName[objectSeekCount] = dataiter->second;
1787
1788                                 } else if (dataiter->first == "DIR"){
1789
1790                                         newAlarmData.attendeeListDirectoryEntry[objectSeekCount] = dataiter->second;
1791
1792                                 } else if (dataiter->first == "LANGUAGE"){
1793
1794                                         newAlarmData.attendeeListLanguage[objectSeekCount] = dataiter->second;
1795
1796                                 } else {
1797
1798                                         if (tokenData == false){
1799                                                 tokenData = true;
1800                                         } else {
1801                                                 propertyTokens += ";";
1802                                         }
1803
1804                                         propertyTokens += dataiter->first;
1805                                         propertyTokens += "=";
1806                                         propertyTokens += dataiter->second;
1807
1808                                 }
1809
1810                         }
1811
1812                         if (propertyTokens.size() > 0){
1813                                 newAlarmData.attendeeListTokens[objectSeekCount] = propertyTokens;
1814                         }
1815
1816                         newAlarmData.attendeeList[objectSeekCount] = iter->second;
1817
1818                         objectSeekCount++;
1819
1820                 }
1821
1822                 // Process data from ATTACH.
1823
1824                 dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], true, "ATTACH");
1825
1826                 objectSeekCount = 0;
1827
1828                 for(multimap<string,string>::iterator iter = dataReceived.begin();
1829                         iter != dataReceived.end();
1830                         ++iter){
1831
1832                         newAlarmData.attachListEncoding.push_back("");
1833                         newAlarmData.attachListValue.push_back("");
1834                         newAlarmData.attachListFormatType.push_back("");
1835                         newAlarmData.attachListTokens.push_back("");
1836                         newAlarmData.attachList.push_back("");
1837
1838                         bool tokenData = false;
1839                         string propertyTokens;
1840
1841                         propertyNameData = (string*)&iter->first;
1842
1843                         propertyData = SplitValues(*propertyNameData);
1844
1845                         for(map<string,string>::iterator dataiter = propertyData.begin();
1846                                 dataiter != propertyData.end(); dataiter++){
1847
1848                                 if (dataiter->first == "ENCODING"){
1849
1850                                         newAlarmData.attachListEncoding[objectSeekCount] = dataiter->second;
1851
1852                                 } else if (dataiter->first == "VALUE"){
1853
1854                                         newAlarmData.attachListValue[objectSeekCount] = dataiter->second;
1855
1856                                 } else if (dataiter->first == "FMTTYPE"){
1857
1858                                         newAlarmData.attachListFormatType[objectSeekCount] = dataiter->second;
1859
1860                                 } else {
1861
1862                                         if (tokenData == false){
1863                                                 tokenData = true;
1864                                         } else {
1865                                                 propertyTokens += ";";
1866                                         }
1867
1868                                         propertyTokens += dataiter->first;
1869                                         propertyTokens += "=";
1870                                         propertyTokens += dataiter->second;
1871
1872                                 }
1873
1874                         }
1875
1876                         if (propertyTokens.size() > 0){
1877                                 newAlarmData.attachListTokens[objectSeekCount] = propertyTokens;
1878                         }
1879
1880                         newAlarmData.attachList[objectSeekCount] = iter->second;
1881
1882                         objectSeekCount++;
1883
1884                 }
1885
1886                 // Process data from X-*
1887
1888                 alarmObjectCount = 0;
1889
1890                 for(vector<string>::iterator xtokeniter = eventAlarmName[seekCount].begin();
1891                         xtokeniter != eventAlarmName[seekCount].end(); ++xtokeniter){
1892
1893                         bool tokenData = false;
1894                         string propertyTokens;
1895
1896                         if (xtokeniter->substr(0,2) == "X-" &&
1897                                 xtokeniter->size() > 2){
1898
1899                                 newAlarmData.xTokensData.push_back(eventAlarmData[seekCount][alarmObjectCount]);
1900                                 newAlarmData.xTokensDataTokens.push_back(EventAlarmName[seekCount][alarmObjectCount]);
1901
1902                         }
1903
1904                         alarmObjectCount++;
1905
1906                 }
1907
1908                 if (newAlarmData.alarmType == CALENDARALARM_AUDIO &&
1909                         alarmActionFound == true &&
1910                         alarmTriggerFound == true){
1911
1912                         calendarAlarmData.push_back(newAlarmData);
1913
1914                 } else if (newAlarmData.alarmType == CALENDARALARM_DISPLAY &&
1915                         alarmActionFound == true &&
1916                         alarmTriggerFound == true &&
1917                         alarmDescriptionFound == true){
1918
1919                         calendarAlarmData.push_back(newAlarmData);
1920
1921                 } else if (newAlarmData.alarmType == CALENDARALARM_EMAIL &&
1922                         alarmActionFound == true &&
1923                         alarmTriggerFound == true &&
1924                         alarmDescriptionFound == true &&
1925                         alarmSummaryFound == true){
1926
1927                         calendarAlarmData.push_back(newAlarmData);
1928
1929                 }
1930
1931                 seekCount++;
1932
1933         }
1934
1935         objectSeekCount = 0;
1936
1937         // Process data from X-*
1938
1939         for(vector<string>::iterator iter = objectName.begin();
1940                 iter != objectName.end(); ++iter){
1941
1942                 bool tokenData = false;
1943                 string propertyTokens;
1944
1945                 if (iter->substr(0,2) == "X-" &&
1946                         iter->size() > 2){
1947
1948                         xTokensData.push_back(objectData[objectSeekCount]);
1949                         xTokensDataTokens.push_back(objectName[objectSeekCount]);
1950
1951                 }
1952
1953                 objectSeekCount++;
1954
1955         }
1956
1957 }