source/objects/calendartask/CalendarTask.cpp

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