source/objects/calendarevent/CalendarEvent.cpp

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