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                 if (dataReceived.begin() != dataReceived.end()){
 837
 838                         durationData = dataReceived.begin()->second;
 839
 840                 }
 841
 842         }
 843
 844         // Process the data from ATTACH.
 845
 846         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "ATTACH");
 847
 848         for(multimap<string,string>::iterator iter = dataReceived.begin();
 849                 iter != dataReceived.end();
 850                 ++iter){
 851
 852                 attachListEncoding.push_back("");
 853                 attachListValue.push_back("");
 854                 attachListFormatType.push_back("");
 855                 attachListTokens.push_back("");
 856                 attachList.push_back("");
 857
 858                 bool tokenData = false;
 859                 string propertyTokens;
 860
 861                 propertyNameData = (string*)&iter->first;
 862
 863                 propertyData = SplitValues(*propertyNameData);
 864
 865                 for(map<string,string>::iterator dataiter = propertyData.begin();
 866                         dataiter != propertyData.end(); dataiter++){
 867
 868                         if (dataiter->first == "ENCODING"){
 869
 870                                 attachListEncoding[objectSeekCount] = dataiter->second;
 871
 872                         } else if (dataiter->first == "VALUE"){
 873
 874                                 attachListValue[objectSeekCount] = dataiter->second;
 875
 876                         } else if (dataiter->first == "FMTTYPE"){
 877
 878                                 attachListFormatType[objectSeekCount] = dataiter->second;
 879
 880                         } else {
 881
 882                                 if (tokenData == false){
 883                                         tokenData = true;
 884                                 } else {
 885                                         propertyTokens += ";";
 886                                 }
 887
 888                                 propertyTokens += dataiter->first;
 889                                 propertyTokens += "=";
 890                                 propertyTokens += dataiter->second;
 891
 892                         }
 893
 894                 }
 895
 896                 if (propertyTokens.size() > 0){
 897                         attachListTokens[objectSeekCount] = propertyTokens;
 898                 }
 899
 900                 attachList[objectSeekCount] = iter->second;
 901
 902                 objectSeekCount++;
 903
 904         }
 905
 906         // Process the data from ATTENDEE.
 907
 908         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "ATTENDEE");
 909
 910         objectSeekCount = 0;
 911
 912         for(multimap<string,string>::iterator iter = dataReceived.begin();
 913                 iter != dataReceived.end();
 914                 ++iter){
 915
 916                 attendeeListMember.push_back("");
 917                 attendeeListDelegatedFrom.push_back("");
 918                 attendeeListDelegatedTo.push_back("");
 919                 attendeeListRole.push_back("");
 920                 attendeeListRSVP.push_back("");
 921                 attendeeListDirectoryEntry.push_back("");
 922                 attendeeListSentBy.push_back("");
 923                 attendeeListCommonName.push_back("");
 924                 attendeeListCalendarUserType.push_back("");
 925                 attendeeListParticipationStatus.push_back("");
 926                 attendeeListLanguage.push_back("");
 927                 attendeeListTokens.push_back("");
 928                 attendeeList.push_back("");
 929
 930                 bool tokenData = false;
 931                 string propertyTokens;
 932
 933                 propertyNameData = (string*)&iter->first;
 934
 935                 propertyData = SplitValues(*propertyNameData);
 936
 937                 for(map<string,string>::iterator dataiter = propertyData.begin();
 938                         dataiter != propertyData.end(); dataiter++){
 939
 940                         if (dataiter->first == "CUTYPE"){
 941
 942                                 attendeeListCalendarUserType[objectSeekCount] = dataiter->second;
 943
 944                         } else if (dataiter->first == "MEMBER"){
 945
 946                                 attendeeListMember[objectSeekCount] = dataiter->second;
 947
 948                         } else if (dataiter->first == "ROLE"){
 949
 950                                 attendeeListRole[objectSeekCount] = dataiter->second;
 951
 952                         } else if (dataiter->first == "PARTSTAT"){
 953
 954                                 attendeeListParticipationStatus[objectSeekCount] = dataiter->second;
 955
 956                         } else if (dataiter->first == "RSVP"){
 957
 958                                 attendeeListRSVP[objectSeekCount] = dataiter->second;
 959
 960                         } else if (dataiter->first == "DELEGATED-TO"){
 961
 962                                 AttendeeListDelegatedTo[ObjectSeekCount] = dataiter->second;
 963
 964                         } else if (dataiter->first == "DELEGATED-FROM"){
 965
 966                                 attendeeListDelegatedFrom[objectSeekCount] = dataiter->second;
 967
 968                         } else if (dataiter->first == "SENT-BY"){
 969
 970                                 attendeeListSentBy[objectSeekCount] = dataiter->second;
 971
 972                         } else if (dataiter->first == "CN"){
 973
 974                                 attendeeListCommonName[objectSeekCount] = dataiter->second;
 975
 976                         } else if (dataiter->first == "DIR"){
 977
 978                                 attendeeListDirectoryEntry[objectSeekCount] = dataiter->second;
 979
 980                         } else if (dataiter->first == "LANGUAGE"){
 981
 982                                 attendeeListLanguage[objectSeekCount] = dataiter->second;
 983
 984                         } else {
 985
 986                                 if (tokenData == false){
 987                                         tokenData = true;
 988                                 } else {
 989                                         propertyTokens += ";";
 990                                 }
 991
 992                                 propertyTokens += dataiter->first;
 993                                 propertyTokens += "=";
 994                                 propertyTokens += dataiter->second;
 995
 996                         }
 997
 998                 }
 999
1000                 if (propertyTokens.size() > 0){
1001                         attendeeListTokens[objectSeekCount] = propertyTokens;
1002                 }
1003
1004                 attendeeList[objectSeekCount] = iter->second;
1005
1006                 objectSeekCount++;
1007
1008         }
1009
1010         // Process the data from CATEGORIES.
1011
1012         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "CATEGORIES");
1013
1014         objectSeekCount = 0;
1015
1016         for(multimap<string,string>::iterator iter = dataReceived.begin();
1017                 iter != dataReceived.end();
1018                 ++iter){
1019
1020                 categoriesListTokens.push_back("");
1021                 categoriesListLanguage.push_back("");
1022                 categoriesList.push_back("");
1023
1024                 bool tokenData = false;
1025                 string propertyTokens;
1026
1027                 propertyNameData = (string*)&iter->first;
1028
1029                 propertyData = SplitValues(*propertyNameData);
1030
1031                 for(map<string,string>::iterator dataiter = propertyData.begin();
1032                         dataiter != propertyData.end(); dataiter++){
1033
1034                         if (dataiter->first == "LANGUAGE"){
1035
1036                                 categoriesListLanguage[objectSeekCount] = dataiter->second;
1037
1038                         } else {
1039
1040                                 if (tokenData == false){
1041                                         tokenData = true;
1042                                 } else {
1043                                         propertyTokens += ";";
1044                                 }
1045
1046                                 propertyTokens += dataiter->first;
1047                                 propertyTokens += "=";
1048                                 propertyTokens += dataiter->second;
1049
1050                         }
1051
1052                 }
1053
1054                 if (propertyTokens.size() > 0){
1055                         categoriesListTokens[objectSeekCount] = propertyTokens;
1056                 }
1057
1058                 categoriesList[objectSeekCount] = iter->second;
1059
1060                 objectSeekCount++;
1061
1062         }
1063
1064         // Process the data from COMMENT.
1065
1066         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "COMMENT");
1067
1068         objectSeekCount = 0;
1069
1070         for(multimap<string,string>::iterator iter = dataReceived.begin();
1071                 iter != dataReceived.end();
1072                 ++iter){
1073
1074                 commentListTokens.push_back("");
1075                 commentListAltRep.push_back("");
1076                 commentListLanguage.push_back("");
1077                 commentList.push_back("");
1078
1079                 bool tokenData = false;
1080                 string propertyTokens;
1081
1082                 propertyNameData = (string*)&iter->first;
1083
1084                 propertyData = SplitValues(*propertyNameData);
1085
1086                 for(map<string,string>::iterator dataiter = propertyData.begin();
1087                         dataiter != propertyData.end(); dataiter++){
1088
1089                         if (dataiter->first == "ALTREP"){
1090
1091                                 commentListAltRep[objectSeekCount] = dataiter->second;
1092
1093                         } else if (dataiter->first == "LANGUAGE"){
1094
1095                                 commentListLanguage[objectSeekCount] = dataiter->second;
1096
1097                         } else {
1098
1099                                 if (tokenData == false){
1100                                         tokenData = true;
1101                                 } else {
1102                                         propertyTokens += ";";
1103                                 }
1104
1105                                 propertyTokens += dataiter->first;
1106                                 propertyTokens += "=";
1107                                 propertyTokens += dataiter->second;
1108
1109                         }
1110
1111                 }
1112
1113                 if (propertyTokens.size() > 0){
1114                         commentListTokens[objectSeekCount] = propertyTokens;
1115                 }
1116
1117                 commentList[objectSeekCount] = iter->second;
1118
1119                 objectSeekCount++;
1120
1121         }
1122
1123         // Process the data from CONTACT.
1124
1125         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "CONTACT");
1126
1127         objectSeekCount = 0;
1128
1129         for(multimap<string,string>::iterator iter = dataReceived.begin();
1130                 iter != dataReceived.end();
1131                 ++iter){
1132
1133                 contactListTokens.push_back("");
1134                 contactListAltRep.push_back("");
1135                 contactListLanguage.push_back("");
1136                 contactList.push_back("");
1137
1138                 bool tokenData = false;
1139                 string propertyTokens;
1140
1141                 propertyNameData = (string*)&iter->first;
1142
1143                 propertyData = SplitValues(*propertyNameData);
1144
1145                 for(map<string,string>::iterator dataiter = propertyData.begin();
1146                         dataiter != propertyData.end(); dataiter++){
1147
1148                         if (dataiter->first == "ALTREP"){
1149
1150                                 contactListAltRep[objectSeekCount] = dataiter->second;
1151
1152                         } else if (dataiter->first == "LANGUAGE"){
1153
1154                                 contactListLanguage[objectSeekCount] = dataiter->second;
1155
1156                         } else {
1157
1158                                 if (tokenData == false){
1159                                         tokenData = true;
1160                                 } else {
1161                                         propertyTokens += ";";
1162                                 }
1163
1164                                 propertyTokens += dataiter->first;
1165                                 propertyTokens += "=";
1166                                 propertyTokens += dataiter->second;
1167
1168                         }
1169
1170                 }
1171
1172                 if (propertyTokens.size() > 0){
1173                         contactListTokens[objectSeekCount] = propertyTokens;
1174                 }
1175
1176                 contactList[objectSeekCount] = iter->second;
1177
1178                 objectSeekCount++;
1179
1180         }
1181
1182         // Process the data from EXDATE.
1183
1184         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "EXDATE");
1185
1186         objectSeekCount = 0;
1187
1188         for(multimap<string,string>::iterator iter = dataReceived.begin();
1189                 iter != dataReceived.end();
1190                 ++iter){
1191
1192                 excludeDateDataTokens.push_back("");
1193                 excludeDateDataValue.push_back("");
1194                 excludeDateDataTimeZoneParam.push_back("");
1195                 excludeDateData.push_back("");
1196
1197                 bool tokenData = false;
1198                 string propertyTokens;
1199
1200                 propertyNameData = (string*)&iter->first;
1201
1202                 propertyData = SplitValues(*propertyNameData);
1203
1204                 for(map<string,string>::iterator dataiter = propertyData.begin();
1205                         dataiter != propertyData.end(); dataiter++){
1206
1207                         if (dataiter->first == "VALUE"){
1208
1209                                 excludeDateDataValue[objectSeekCount] = dataiter->second;
1210
1211                         } else if (dataiter->first == "TZID"){
1212
1213                                 excludeDateDataTimeZoneParam[objectSeekCount] = dataiter->second;
1214
1215                         } else {
1216
1217                                 if (tokenData == false){
1218                                         tokenData = true;
1219                                 } else {
1220                                         propertyTokens += ";";
1221                                 }
1222
1223                                 propertyTokens += dataiter->first;
1224                                 propertyTokens += "=";
1225                                 propertyTokens += dataiter->second;
1226
1227                         }
1228
1229                 }
1230
1231                 if (propertyTokens.size() > 0){
1232                         excludeDateDataTokens[objectSeekCount] = propertyTokens;
1233                 }
1234
1235                 excludeDateData[objectSeekCount] = iter->second;
1236
1237                 objectSeekCount++;
1238
1239         }
1240
1241         // Process the data from REQUEST-STATUS.
1242
1243         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "REQUEST-STATUS");
1244
1245         objectSeekCount = 0;
1246
1247         for(multimap<string,string>::iterator iter = dataReceived.begin();
1248                 iter != dataReceived.end();
1249                 ++iter){
1250
1251                 requestStatusTokens.push_back("");
1252                 requestStatusLanguage.push_back("");
1253                 requestStatusData.push_back("");
1254
1255                 bool tokenData = false;
1256                 string propertyTokens;
1257
1258                 propertyNameData = (string*)&iter->first;
1259
1260                 propertyData = SplitValues(*propertyNameData);
1261
1262                 for(map<string,string>::iterator dataiter = propertyData.begin();
1263                         dataiter != propertyData.end(); dataiter++){
1264
1265                         if (dataiter->first == "LANGUAGE"){
1266
1267                                 requestStatusLanguage[objectSeekCount] = dataiter->second;
1268
1269                         } else {
1270
1271                                 if (tokenData == false){
1272                                         tokenData = true;
1273                                 } else {
1274                                         propertyTokens += ";";
1275                                 }
1276
1277                                 propertyTokens += dataiter->first;
1278                                 propertyTokens += "=";
1279                                 propertyTokens += dataiter->second;
1280
1281                         }
1282
1283                 }
1284
1285                 if (propertyTokens.size() > 0){
1286                         requestStatusTokens[objectSeekCount] = propertyTokens;
1287                 }
1288
1289                 requestStatusData[objectSeekCount] = iter->second;
1290
1291                 objectSeekCount++;
1292
1293         }
1294
1295         // Process the data from RELATED-TO.
1296
1297         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "RELATED-TO");
1298
1299         objectSeekCount = 0;
1300
1301         for(multimap<string,string>::iterator iter = dataReceived.begin();
1302                 iter != dataReceived.end();
1303                 ++iter){
1304
1305                 relatedToDataTokens.push_back("");
1306                 relatedToDataRelationType.push_back("");
1307                 relatedToData.push_back("");
1308
1309                 bool tokenData = false;
1310                 string propertyTokens;
1311
1312                 PropertyNameData = (string*)&iter->first;
1313
1314                 PropertyData = SplitValues(*PropertyNameData);
1315
1316                 for(map<string,string>::iterator dataiter = PropertyData.begin();
1317                         dataiter != PropertyData.end(); dataiter++){
1318
1319                         if (dataiter->first == "RELTYPE"){
1320
1321                                 RelatedToDataRelationType[ObjectSeekCount] = dataiter->second;
1322
1323                         } else {
1324
1325                                 if (TokenData == false){
1326                                         TokenData = true;
1327                                 } else {
1328                                         PropertyTokens += ";";
1329                                 }
1330
1331                                 PropertyTokens += dataiter->first;
1332                                 PropertyTokens += "=";
1333                                 PropertyTokens += dataiter->second;
1334
1335                         }
1336
1337                 }
1338
1339                 if (PropertyTokens.size() > 0){
1340                         RelatedToDataTokens[ObjectSeekCount] = PropertyTokens;
1341                 }
1342
1343                 RelatedToData[ObjectSeekCount] = iter->second;
1344
1345                 ObjectSeekCount++;
1346
1347         }
1348
1349         // Process the data from RESOURCES.
1350
1351         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "RESOURCES");
1352
1353         objectSeekCount = 0;
1354
1355         for(multimap<string,string>::iterator iter = dataReceived.begin();
1356                 iter != dataReceived.end();
1357                 ++iter){
1358
1359                 resourcesDataTokens.push_back("");
1360                 resourcesDataAltRep.push_back("");
1361                 resourcesDataLanguage.push_back("");
1362                 resourcesData.push_back("");
1363
1364                 bool tokenData = false;
1365                 string propertyTokens;
1366
1367                 propertyNameData = (string*)&iter->first;
1368
1369                 propertyData = SplitValues(*propertyNameData);
1370
1371                 for(map<string,string>::iterator dataiter = propertyData.begin();
1372                         dataiter != propertyData.end(); dataiter++){
1373
1374                         if (dataiter->first == "ALTREP"){
1375
1376                                 resourcesDataAltRep[objectSeekCount] = dataiter->second;
1377
1378                         } else if (dataiter->first == "LANGUAGE"){
1379
1380                                 resourcesDataLanguage[objectSeekCount] = dataiter->second;
1381
1382                         } else {
1383
1384                                 if (tokenData == false){
1385                                         tokenData = true;
1386                                 } else {
1387                                         propertyTokens += ";";
1388                                 }
1389
1390                                 propertyTokens += dataiter->first;
1391                                 propertyTokens += "=";
1392                                 propertyTokens += dataiter->second;
1393
1394                         }
1395
1396                 }
1397
1398                 if (propertyTokens.size() > 0){
1399                         resourcesDataTokens[objectSeekCount] = propertyTokens;
1400                 }
1401
1402                 resourcesData[objectSeekCount] = iter->second;
1403
1404                 objectSeekCount++;
1405
1406         }
1407
1408         // Process the data from RDATE.
1409
1410         dataReceived = ProcessTextVectors(&objectName, &objectData, true, "RDATE");
1411
1412         objectSeekCount = 0;
1413
1414         for(multimap<string,string>::iterator iter = dataReceived.begin();
1415                 iter != dataReceived.end();
1416                 ++iter){
1417
1418                 recurranceDateDataTokens.push_back("");
1419                 recurranceDateDataValue.push_back("");
1420                 recurranceDateDataTimeZoneParam.push_back("");
1421                 recurranceDateData.push_back("");
1422
1423                 bool tokenData = false;
1424                 string propertyTokens;
1425
1426                 propertyNameData = (string*)&iter->first;
1427
1428                 propertyData = SplitValues(*propertyNameData);
1429
1430                 for(map<string,string>::iterator dataiter = propertyData.begin();
1431                         dataiter != propertyData.end(); dataiter++){
1432
1433                         if (dataiter->first == "VALUE"){
1434
1435                                 recurranceDateDataValue[objectSeekCount] = dataiter->second;
1436
1437                         } else if (dataiter->first == "TZID"){
1438
1439                                 recurranceDateDataTimeZoneParam[objectSeekCount] = dataiter->second;
1440
1441                         } else {
1442
1443                                 if (tokenData == false){
1444                                         tokenData = true;
1445                                 } else {
1446                                         propertyTokens += ";";
1447                                 }
1448
1449                                 propertyTokens += dataiter->first;
1450                                 propertyTokens += "=";
1451                                 propertyTokens += dataiter->second;
1452
1453                         }
1454
1455                 }
1456
1457                 if (propertyTokens.size() > 0){
1458                         recurranceDateDataTokens[objectSeekCount] = propertyTokens;
1459                 }
1460
1461                 recurranceDateData[objectSeekCount] = iter->second;
1462
1463                 objectSeekCount++;
1464
1465         }
1466
1467         // Process VALARM section.
1468
1469         int seekCount = 0;
1470         int alarmObjectCount = 0;
1471
1472         bool alarmActionFound = false;
1473
1474         for (vector<vector<string>>::iterator iter = eventAlarmName.begin();
1475                 iter != eventAlarmName.end(); iter++){
1476
1477                 CalendarAlarmDataStruct newAlarmData;
1478
1479                 // Process the data from ACTION.
1480
1481                 bool alarmActionFound = false;
1482                 bool alarmTriggerFound = false;
1483                 bool alarmDurationFound = false;
1484                 bool alarmDescriptionFound = false;
1485                 bool alarmSummaryFound = false;
1486
1487                 dataReceived = ProcessTextVectors(&eventAlarmName[seekCount],
1488                                 &eventAlarmData[seekCount], false, "ACTION");
1489
1490                 if (dataReceived.begin() != dataReceived.end()){
1491
1492                         try {
1493                                 newAlarmData.alarmActionTokens = dataReceived.begin()->first.substr(7);
1494                         }
1495
1496                         catch(const out_of_range &oor){
1497                                 // Do nothing as there is no data.
1498                         }
1499
1500                         newAlarmData.alarmAction = dataReceived.begin()->second;
1501                         alarmActionFound = true;
1502
1503                 }
1504
1505                 // Check if a value was set for AlarmAction, otherwise
1506                 // process the next VALARM section.
1507
1508                 if (newAlarmData.alarmAction.size() < 1){
1509
1510                         seekCount++;
1511                         continue;
1512
1513                 }
1514
1515                 // Check if AlarmAction is DISPLAY, AUDIO or EMAIL.
1516                 // Process the next VALARM section if not.
1517
1518                 if (newAlarmData.alarmAction == "AUDIO"){
1519
1520                         newAlarmData.alarmType = CALENDARALARM_AUDIO;
1521
1522                 } else if (newAlarmData.alarmAction == "DISPLAY"){
1523
1524                         newAlarmData.alarmType = CALENDARALARM_DISPLAY;
1525
1526                 } else if (newAlarmData.alarmAction == "EMAIL"){
1527
1528                         newAlarmData.alarmType = CALENDARALARM_EMAIL;
1529
1530                 } else {
1531
1532                         seekCount++;
1533                         continue;
1534
1535                 }
1536
1537                 // Process the data from TRIGGER.
1538
1539                 dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], false, "TRIGGER");
1540
1541                 if (dataReceived.begin() != dataReceived.end()){
1542
1543                         bool tokenData = false;
1544                         string propertyTokens;
1545
1546                         propertyNameData = (string*)&dataReceived.begin()->first;
1547
1548                         propertyData = SplitValues(*propertyNameData);
1549
1550                         for(map<string,string>::iterator iter = propertyData.begin();
1551                                 iter != propertyData.end(); iter++){
1552
1553                                 if (iter->first == "VALUE"){
1554
1555                                         newAlarmData.triggerValue = iter->second;
1556
1557                                 } else if (iter->first == "RELATED"){
1558
1559                                         newAlarmData.triggerRelated = iter->second;
1560
1561                                 } else {
1562
1563                                         if (tokenData == false){
1564                                                 tokenData = true;
1565                                         } else {
1566                                                 propertyTokens += ";";
1567                                         }
1568
1569                                         propertyTokens += iter->first;
1570                                         propertyTokens += "=";
1571                                         propertyTokens += iter->second;
1572
1573                                 }
1574
1575                         }
1576
1577                         if (propertyTokens.size() > 0){
1578                                 newAlarmData.triggerTokens = propertyTokens;
1579                         }
1580
1581                         newAlarmData.triggerData = dataReceived.begin()->second;
1582                         alarmTriggerFound = true;
1583
1584                 }
1585
1586                 // Process the data from DESCRIPTION.
1587
1588                 dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], false, "DESCRIPTION");
1589
1590                 if (dataReceived.begin() != dataReceived.end() &&
1591                         (newAlarmData.alarmType == CALENDARALARM_DISPLAY ||
1592                         newAlarmData.alarmType == CALENDARALARM_EMAIL)){
1593
1594                         bool tokenData = false;
1595                         string propertyTokens;
1596
1597                         propertyNameData = (string*)&dataReceived.begin()->first;
1598
1599                         propertyData = SplitValues(*propertyNameData);
1600
1601                         for(map<string,string>::iterator iter = propertyData.begin();
1602                                 iter != propertyData.end(); iter++){
1603
1604                                 if (iter->first == "ALTREP"){
1605
1606                                         newAlarmData.descriptionAltRep = iter->second;
1607
1608                                 } else if (iter->first == "LANGUAGE"){
1609
1610                                         newAlarmData.descriptionLanguage = iter->second;
1611
1612                                 } else {
1613
1614                                         if (tokenData == false){
1615                                                 tokenData = true;
1616                                         } else {
1617                                                 propertyTokens += ";";
1618                                         }
1619
1620                                         propertyTokens += iter->first;
1621                                         propertyTokens += "=";
1622                                         propertyTokens += iter->second;
1623
1624                                 }
1625
1626                         }
1627
1628                         if (propertyTokens.size() > 0){
1629                                 newAlarmData.descriptionTokens = propertyTokens;
1630                         }
1631
1632                         newAlarmData.descriptionData = dataReceived.begin()->second;
1633                         alarmDescriptionFound = true;
1634
1635                 }
1636
1637                 // Process data from SUMMARY.
1638
1639                 dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], false, "SUMMARY");
1640
1641                 if (dataReceived.begin() != dataReceived.end() &&
1642                         newAlarmData.alarmType == CALENDARALARM_EMAIL){
1643
1644                         bool tokenData = false;
1645                         string propertyTokens;
1646
1647                         propertyNameData = (string*)&dataReceived.begin()->first;
1648
1649                         propertyData = SplitValues(*propertyNameData);
1650
1651                         for(map<string,string>::iterator iter = propertyData.begin();
1652                                 iter != propertyData.end(); iter++){
1653
1654                                 if (iter->first == "ALTREP"){
1655
1656                                         newAlarmData.summaryAltRep = iter->second;
1657
1658                                 } else if (iter->first == "LANGUAGE"){
1659
1660                                         newAlarmData.summaryLanguage = iter->second;
1661
1662                                 } else {
1663
1664                                         if (tokenData == false){
1665                                                 tokenData = true;
1666                                         } else {
1667                                                 propertyTokens += ";";
1668                                         }
1669
1670                                         propertyTokens += iter->first;
1671                                         propertyTokens += "=";
1672                                         propertyTokens += iter->second;
1673
1674                                 }
1675
1676                         }
1677
1678                         if (propertyTokens.size() > 0){
1679                                 newAlarmData.summaryTokens = propertyTokens;
1680                         }
1681
1682                         newAlarmData.summaryData = dataReceived.begin()->second;
1683                         alarmSummaryFound = true;
1684
1685                 }
1686
1687                 // Process data from DURATION.
1688
1689                 dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], false, "DURATION");
1690
1691                 if (dataReceived.begin() != dataReceived.end()){
1692
1693                         try {
1694                                 newAlarmData.durationTokens = dataReceived.begin()->first.substr(9);
1695                         }
1696
1697                         catch(const out_of_range &oor){
1698                                 // Do nothing as there is no data.
1699                         }
1700
1701                         newAlarmData.durationData = dataReceived.begin()->second;
1702                         alarmDurationFound = true;
1703
1704                 }
1705
1706                 // Process data from REPEAT.
1707
1708                 dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], false, "REPEAT");
1709
1710                 if (dataReceived.begin() != dataReceived.end() && alarmDurationFound == true){
1711
1712                         try {
1713                                 newAlarmData.repeatTokens = dataReceived.begin()->first.substr(7);
1714                         }
1715
1716                         catch(const out_of_range &oor){
1717                                 // Do nothing as there is no data.
1718                         }
1719
1720                         newAlarmData.repeatData = dataReceived.begin()->second;
1721
1722                 } else {
1723
1724                         newAlarmData.durationData.clear();
1725                         newAlarmData.durationTokens.clear();
1726
1727                 }
1728
1729                 // Process data from ATTENDEE.
1730
1731                 dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], true, "ATTENDEE");
1732
1733                 objectSeekCount = 0;
1734
1735                 for(multimap<string,string>::iterator iter = dataReceived.begin();
1736                         iter != dataReceived.end();
1737                         ++iter){
1738
1739                         newAlarmData.attendeeListMember.push_back("");
1740                         newAlarmData.attendeeListDelegatedFrom.push_back("");
1741                         newAlarmData.attendeeListDelegatedTo.push_back("");
1742                         newAlarmData.attendeeListRole.push_back("");
1743                         newAlarmData.attendeeListRSVP.push_back("");
1744                         newAlarmData.attendeeListDirectoryEntry.push_back("");
1745                         newAlarmData.attendeeListSentBy.push_back("");
1746                         newAlarmData.attendeeListCommonName.push_back("");
1747                         newAlarmData.attendeeListCalendarUserType.push_back("");
1748                         newAlarmData.attendeeListParticipationStatus.push_back("");
1749                         newAlarmData.attendeeListLanguage.push_back("");
1750                         newAlarmData.attendeeListTokens.push_back("");
1751                         newAlarmData.attendeeList.push_back("");
1752
1753                         bool tokenData = false;
1754                         string propertyTokens;
1755
1756                         propertyNameData = (string*)&iter->first;
1757
1758                         propertyData = SplitValues(*propertyNameData);
1759
1760                         for(map<string,string>::iterator dataiter = propertyData.begin();
1761                                 dataiter != propertyData.end(); dataiter++){
1762
1763                                 if (dataiter->first == "CUTYPE"){
1764
1765                                         newAlarmData.attendeeListCalendarUserType[objectSeekCount] = dataiter->second;
1766
1767                                 } else if (dataiter->first == "MEMBER"){
1768
1769                                         newAlarmData.attendeeListMember[objectSeekCount] = dataiter->second;
1770
1771                                 } else if (dataiter->first == "ROLE"){
1772
1773                                         newAlarmData.attendeeListRole[objectSeekCount] = dataiter->second;
1774
1775                                 } else if (dataiter->first == "PARTSTAT"){
1776
1777                                         newAlarmData.attendeeListParticipationStatus[objectSeekCount] = dataiter->second;
1778
1779                                 } else if (dataiter->first == "RSVP"){
1780
1781                                         newAlarmData.attendeeListRSVP[objectSeekCount] = dataiter->second;
1782
1783                                 } else if (dataiter->first == "DELEGATED-TO"){
1784
1785                                         newAlarmData.attendeeListDelegatedTo[objectSeekCount] = dataiter->second;
1786
1787                                 } else if (dataiter->first == "DELEGATED-FROM"){
1788
1789                                         newAlarmData.attendeeListDelegatedFrom[objectSeekCount] = dataiter->second;
1790
1791                                 } else if (dataiter->first == "SENT-BY"){
1792
1793                                         newAlarmData.attendeeListSentBy[objectSeekCount] = dataiter->second;
1794
1795                                 } else if (dataiter->first == "CN"){
1796
1797                                         newAlarmData.attendeeListCommonName[objectSeekCount] = dataiter->second;
1798
1799                                 } else if (dataiter->first == "DIR"){
1800
1801                                         newAlarmData.attendeeListDirectoryEntry[objectSeekCount] = dataiter->second;
1802
1803                                 } else if (dataiter->first == "LANGUAGE"){
1804
1805                                         newAlarmData.attendeeListLanguage[objectSeekCount] = dataiter->second;
1806
1807                                 } else {
1808
1809                                         if (tokenData == false){
1810                                                 tokenData = true;
1811                                         } else {
1812                                                 propertyTokens += ";";
1813                                         }
1814
1815                                         propertyTokens += dataiter->first;
1816                                         propertyTokens += "=";
1817                                         propertyTokens += dataiter->second;
1818
1819                                 }
1820
1821                         }
1822
1823                         if (propertyTokens.size() > 0){
1824                                 newAlarmData.attendeeListTokens[objectSeekCount] = PropertyTokens;
1825                         }
1826
1827                         newAlarmData.attendeeList[objectSeekCount] = iter->second;
1828
1829                         objectSeekCount++;
1830
1831                 }
1832
1833                 // Process data from ATTACH.
1834
1835                 dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], true, "ATTACH");
1836
1837                 objectSeekCount = 0;
1838
1839                 for(multimap<string,string>::iterator iter = dataReceived.begin();
1840                         iter != dataReceived.end();
1841                         ++iter){
1842
1843                         newAlarmData.attachListEncoding.push_back("");
1844                         newAlarmData.attachListValue.push_back("");
1845                         newAlarmData.attachListFormatType.push_back("");
1846                         newAlarmData.attachListTokens.push_back("");
1847                         newAlarmData.attachList.push_back("");
1848
1849                         bool tokenData = false;
1850                         string propertyTokens;
1851
1852                         propertyNameData = (string*)&iter->first;
1853
1854                         propertyData = SplitValues(*propertyNameData);
1855
1856                         for(map<string,string>::iterator dataiter = propertyData.begin();
1857                                 dataiter != propertyData.end(); dataiter++){
1858
1859                                 if (dataiter->first == "ENCODING"){
1860
1861                                         newAlarmData.attachListEncoding[objectSeekCount] = dataiter->second;
1862
1863                                 } else if (dataiter->first == "VALUE"){
1864
1865                                         newAlarmData.attachListValue[objectSeekCount] = dataiter->second;
1866
1867                                 } else if (dataiter->first == "FMTTYPE"){
1868
1869                                         newAlarmData.attachListFormatType[objectSeekCount] = dataiter->second;
1870
1871                                 } else {
1872
1873                                         if (tokenData == false){
1874                                                 tokenData = true;
1875                                         } else {
1876                                                 propertyTokens += ";";
1877                                         }
1878
1879                                         propertyTokens += dataiter->first;
1880                                         propertyTokens += "=";
1881                                         propertyTokens += dataiter->second;
1882
1883                                 }
1884
1885                         }
1886
1887                         if (propertyTokens.size() > 0){
1888                                 newAlarmData.attachListTokens[objectSeekCount] = propertyTokens;
1889                         }
1890
1891                         newAlarmData.attachList[objectSeekCount] = iter->second;
1892
1893                         objectSeekCount++;
1894
1895                 }
1896
1897                 // Process data from X-*
1898
1899                 alarmObjectCount = 0;
1900
1901                 for(vector<string>::iterator xtokeniter = eventAlarmName[seekCount].begin();
1902                         xtokeniter != eventAlarmName[seekCount].end(); ++xtokeniter){
1903
1904                         bool tokenData = false;
1905                         string propertyTokens;
1906
1907                         if (xtokeniter->substr(0,2) == "X-" &&
1908                                 xtokeniter->size() > 2){
1909
1910                                 newAlarmData.xTokensData.push_back(EventAlarmData[seekCount][alarmObjectCount]);
1911                                 newAlarmData.xTokensDataTokens.push_back(EventAlarmName[seekCount][alarmObjectCount]);
1912
1913                         }
1914
1915                         alarmObjectCount++;
1916
1917                 }
1918
1919                 if (newAlarmData.alarmType == CALENDARALARM_AUDIO &&
1920                         alarmActionFound == true &&
1921                         alarmTriggerFound == true){
1922
1923                         calendarAlarmData.push_back(newAlarmData);
1924
1925                 } else if (newAlarmData.alarmType == CALENDARALARM_DISPLAY &&
1926                         alarmActionFound == true &&
1927                         alarmTriggerFound == true &&
1928                         alarmDescriptionFound == true){
1929
1930                         calendarAlarmData.push_back(newAlarmData);
1931
1932                 } else if (newAlarmData.alarmType == CALENDARALARM_EMAIL &&
1933                         alarmActionFound == true &&
1934                         alarmTriggerFound == true &&
1935                         alarmDescriptionFound == true &&
1936                         alarmSummaryFound == true){
1937
1938                         calendarAlarmData.push_back(newAlarmData);
1939
1940                 }
1941
1942                 seekCount++;
1943
1944         }
1945
1946         objectSeekCount = 0;
1947
1948         // Process data from X-*
1949
1950         for(vector<string>::iterator iter = objectName.begin();
1951                 iter != objectName.end(); ++iter){
1952
1953                 bool tokenData = false;
1954                 string propertyTokens;
1955
1956                 if (iter->substr(0,2) == "X-" &&
1957                         iter->size() > 2){
1958
1959                         xTokensData.push_back(objectData[objectSeekCount]);
1960                         xTokensDataTokens.push_back(objectName[objectSeekCount]);
1961
1962                 }
1963
1964                 objectSeekCount++;
1965
1966         }
1967
1968 }