source/objects/calendarevent/CalendarEvent.cpp

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