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 }