source/objects/calendartimezone/CalendarTimezone.cpp

   1 // CalendarTimezone.cpp - CalendarTimezone 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 "CalendarTimezone.h"
  20
  21 using namespace std;
  22
  23 CalendarObjectValidResult CalendarTimezoneObject::ValidObject(){
  24
  25         bool ValidBegin = false;
  26         bool ValidEnd = false;
  27         bool ValidTimeZoneID = false;
  28         int SeekCount = 0;
  29         string PropertyName;
  30
  31         // Look for BEGIN:VEVENT.
  32
  33         for (vector<string>::iterator iter = ObjectName.begin();
  34                 iter != ObjectName.end(); iter++){
  35
  36                 if (ObjectName[SeekCount] == "BEGIN" &&
  37                         ObjectData[SeekCount] == "VTIMEZONE"){
  38
  39                         if (ValidBegin == false){
  40                                 ValidBegin = true;
  41                         } else {
  42                                 return CALENDAROBJECTVALID_INVALIDFORMAT;
  43                         }
  44
  45                 }
  46
  47                 if (ObjectName[SeekCount] == "END" &&
  48                         ObjectData[SeekCount] == "VTIMEZONE" &&
  49                         ValidBegin == false){
  50
  51                         return CALENDAROBJECTVALID_INVALIDFORMAT;
  52
  53                 }
  54
  55                 SeekCount++;
  56
  57         }
  58
  59         SeekCount = 0;
  60
  61         // Look for TZID.
  62
  63         for (vector<string>::iterator iter = ObjectName.begin();
  64                 iter != ObjectName.end(); iter++){
  65
  66                 try{
  67                         PropertyName = ObjectName[SeekCount].substr(0,4);
  68                 }
  69
  70                 catch(const out_of_range& oor){
  71                         continue;
  72                 }
  73
  74                 if (PropertyName == "TZID"){
  75
  76                         if (ValidTimeZoneID == false){
  77                                 ValidTimeZoneID = true;
  78                         } else {
  79                                 return CALENDAROBJECTVALID_INVALIDFORMAT;
  80                         }
  81
  82                 }
  83
  84                 SeekCount++;
  85
  86         }
  87
  88         SeekCount = 0;
  89
  90         // Look for END:VEVENT.
  91
  92         for (vector<string>::iterator iter = ObjectName.begin();
  93                 iter != ObjectName.end(); iter++){
  94
  95                 if (ObjectName[SeekCount] == "END" &&
  96                         ObjectData[SeekCount] == "VTIMEZONE"){
  97
  98                         if (ValidEnd == false){
  99                                 ValidEnd = true;
 100                         } else {
 101                                 return CALENDAROBJECTVALID_INVALIDFORMAT;
 102                         }
 103
 104                 }
 105
 106                 SeekCount++;
 107
 108         }
 109
 110         // Check if the VEVENT is valid.
 111
 112         if (ValidBegin == true &&
 113                 ValidEnd == true &&
 114                 ValidTimeZoneID == true){
 115
 116                 return CALENDAROBJECTVALID_OK;
 117
 118         } else {
 119
 120                 return CALENDAROBJECTVALID_INVALIDFORMAT;
 121
 122         }
 123
 124 }
 125
 126 void CalendarTimezoneObject::ProcessData(){
 127
 128         // Process the data.
 129
 130         multimap<string,string> DataReceived;
 131         map<string,string> PropertyData;
 132         string *PropertyNameData = nullptr;
 133         int ObjectSeekCount = 0;
 134
 135         // Process the data from TZID.
 136
 137         DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "TZID");
 138
 139         if (DataReceived.begin() != DataReceived.end()){
 140
 141                 try {
 142                         TimeZoneDataTokens = DataReceived.begin()->first.substr(5);
 143                 }
 144
 145                 catch(const out_of_range &oor){
 146                         // Do nothing as there is no data.
 147                 }
 148
 149                 TimeZoneData = DataReceived.begin()->second;
 150
 151         }
 152
 153         // Process the data from LAST-MODIFIED.
 154
 155         DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "LAST-MODIFIED");
 156
 157         if (DataReceived.begin() != DataReceived.end()){
 158
 159                 try {
 160                         LastModifiedTokens = DataReceived.begin()->first.substr(14);
 161                 }
 162
 163                 catch(const out_of_range &oor){
 164                         // Do nothing as there is no data.
 165                 }
 166
 167                 LastModifiedData = DataReceived.begin()->second;
 168
 169         }
 170
 171         // Process the data from TZURL.
 172
 173         DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "TZURL");
 174
 175         if (DataReceived.begin() != DataReceived.end()){
 176
 177                 try {
 178                         TimeZoneURLTokens = DataReceived.begin()->first.substr(6);
 179                 }
 180
 181                 catch(const out_of_range &oor){
 182                         // Do nothing as there is no data.
 183                 }
 184
 185                 TimeZoneURLData = DataReceived.begin()->second;
 186
 187         }
 188
 189         // Process data from each STANDARD and DAYLIGHT.
 190
 191         ProcessStandardDaylight();
 192
 193         int TZSeekCount = 0;
 194         int SeekCount = 0;
 195
 196         for (vector<vector<string>>::iterator tzsiter = TimezoneStandardName.begin();
 197                 tzsiter != TimezoneStandardName.end(); tzsiter++){
 198
 199                 bool DateTimeStartFound = false;
 200                 bool TimeZoneOffsetToFound = false;
 201                 bool TimeZoneOffsetFromFound = false;
 202
 203                 TimezoneDataStruct NewTZData;
 204
 205                 // Process the data from DTSTART.
 206
 207                 DataReceived = ProcessTextVectors(&TimezoneStandardName[SeekCount],
 208                                 &TimezoneStandardData[SeekCount], false, "DTSTART");
 209
 210                 if (DataReceived.begin() != DataReceived.end()){
 211
 212                         try {
 213                                 NewTZData.DateTimeStartTokens = DataReceived.begin()->first.substr(8);
 214                         }
 215
 216                         catch(const out_of_range &oor){
 217                                 // Do nothing as there is no data.
 218                         }
 219
 220                         NewTZData.DateTimeStartData = DataReceived.begin()->second;
 221                         DateTimeStartFound = true;
 222
 223                 }
 224
 225                 // Process the data from TZOFFSETFROM.
 226
 227                 DataReceived = ProcessTextVectors(&TimezoneStandardName[SeekCount],
 228                                 &TimezoneStandardData[SeekCount], false, "TZOFFSETFROM");
 229
 230                 if (DataReceived.begin() != DataReceived.end()){
 231
 232                         try {
 233                                 NewTZData.TimeZoneOffsetFromTokens = DataReceived.begin()->first.substr(13);
 234                         }
 235
 236                         catch(const out_of_range &oor){
 237                                 // Do nothing as there is no data.
 238                         }
 239
 240                         NewTZData.TimeZoneOffsetFromData = DataReceived.begin()->second;
 241                         TimeZoneOffsetFromFound = true;
 242
 243                 }
 244
 245                 // Process the data from TZOFFSETTO.
 246
 247                 DataReceived = ProcessTextVectors(&TimezoneStandardName[SeekCount],
 248                                 &TimezoneStandardData[SeekCount], false, "TZOFFSETTO");
 249
 250                 if (DataReceived.begin() != DataReceived.end()){
 251
 252                         try {
 253                                 NewTZData.TimeZoneOffsetToTokens = DataReceived.begin()->first.substr(11);
 254                         }
 255
 256                         catch(const out_of_range &oor){
 257                                 // Do nothing as there is no data.
 258                         }
 259
 260                         NewTZData.TimeZoneOffsetToData = DataReceived.begin()->second;
 261                         TimeZoneOffsetToFound = true;
 262
 263                 }
 264
 265                 // Process the data from RRULE.
 266
 267                 DataReceived = ProcessTextVectors(&TimezoneStandardName[SeekCount],
 268                         &TimezoneStandardData[SeekCount], false, "RRULE");
 269
 270                 if (DataReceived.begin() != DataReceived.end()){
 271
 272                         try {
 273                                 NewTZData.RecurranceRuleDataTokens = DataReceived.begin()->first.substr(6);
 274                         }
 275
 276                         catch(const out_of_range &oor){
 277                                 // Do nothing as there is no data.
 278                         }
 279
 280                         NewTZData.RecurranceRuleData = DataReceived.begin()->second;
 281
 282                 }
 283
 284                 // Process the data from COMMENT.
 285
 286                 DataReceived = ProcessTextVectors(&TimezoneStandardName[SeekCount],
 287                         &TimezoneStandardData[SeekCount], true, "COMMENT");
 288
 289                 ObjectSeekCount = 0;
 290
 291                 for(multimap<string,string>::iterator propiter = DataReceived.begin();
 292                         propiter != DataReceived.end();
 293                         ++propiter){
 294
 295                         NewTZData.CommentListTokens.push_back("");
 296                         NewTZData.CommentListAltRep.push_back("");
 297                         NewTZData.CommentListLanguage.push_back("");
 298                         NewTZData.CommentList.push_back("");
 299
 300                         bool TokenData = false;
 301                         string PropertyTokens;
 302
 303                         PropertyNameData = (string*)&propiter->first;
 304
 305                         PropertyData = SplitValues(*PropertyNameData);
 306
 307                         for(map<string,string>::iterator propdataiter = PropertyData.begin();
 308                                 propdataiter != PropertyData.end(); propdataiter++){
 309
 310                                 if (propdataiter->first == "ALTREP"){
 311
 312                                         NewTZData.CommentListAltRep[ObjectSeekCount] = propdataiter->second;
 313
 314                                 } else if (propdataiter->first == "LANGUAGE"){
 315
 316                                         NewTZData.CommentListLanguage[ObjectSeekCount] = propdataiter->second;
 317
 318                                 } else {
 319
 320                                         if (TokenData == false){
 321                                                 TokenData = true;
 322                                         } else {
 323                                                 PropertyTokens += ";";
 324                                         }
 325
 326                                         PropertyTokens += propdataiter->first;
 327                                         PropertyTokens += "=";
 328                                         PropertyTokens += propdataiter->second;
 329
 330                                 }
 331
 332                         }
 333
 334                         if (PropertyTokens.size() > 0){
 335                                 NewTZData.CommentListTokens[ObjectSeekCount] = PropertyTokens;
 336                         }
 337
 338                         NewTZData.CommentList[ObjectSeekCount] = propiter->second;
 339
 340                         ObjectSeekCount++;
 341
 342                 }
 343
 344                 // Process the data from RDATE.
 345
 346                 DataReceived = ProcessTextVectors(&TimezoneStandardName[SeekCount],
 347                         &TimezoneStandardData[SeekCount], true, "RDATE");
 348
 349                 ObjectSeekCount = 0;
 350
 351                 for(multimap<string,string>::iterator propiter = DataReceived.begin();
 352                         propiter != DataReceived.end();
 353                         ++propiter){
 354
 355                         NewTZData.RecurranceDateDataTokens.push_back("");
 356                         NewTZData.RecurranceDateDataValue.push_back("");
 357                         NewTZData.RecurranceDateDataTimeZoneParam.push_back("");
 358                         NewTZData.RecurranceDateData.push_back("");
 359
 360                         bool TokenData = false;
 361                         string PropertyTokens;
 362
 363                         PropertyNameData = (string*)&propiter->first;
 364
 365                         PropertyData = SplitValues(*PropertyNameData);
 366
 367                         for(map<string,string>::iterator dataiter = PropertyData.begin();
 368                                 dataiter != PropertyData.end(); dataiter++){
 369
 370                                 if (dataiter->first == "VALUE"){
 371
 372                                         NewTZData.RecurranceDateDataValue[ObjectSeekCount] = dataiter->second;
 373
 374                                 } else if (dataiter->first == "TZID"){
 375
 376                                         NewTZData.RecurranceDateDataTimeZoneParam[ObjectSeekCount] = dataiter->second;
 377
 378                                 } else {
 379
 380                                         if (TokenData == false){
 381                                                 TokenData = true;
 382                                         } else {
 383                                                 PropertyTokens += ";";
 384                                         }
 385
 386                                         PropertyTokens += dataiter->first;
 387                                         PropertyTokens += "=";
 388                                         PropertyTokens += dataiter->second;
 389
 390                                 }
 391
 392                         }
 393
 394                         if (PropertyTokens.size() > 0){
 395                                 NewTZData.RecurranceDateDataTokens[ObjectSeekCount] = PropertyTokens;
 396                         }
 397
 398                         NewTZData.RecurranceDateData[ObjectSeekCount] = propiter->second;
 399
 400                         ObjectSeekCount++;
 401
 402                 }
 403
 404                 // Process the data from TZNAME.
 405
 406                 DataReceived = ProcessTextVectors(&TimezoneStandardName[SeekCount],
 407                         &TimezoneStandardData[SeekCount], true, "TZNAME");
 408
 409                 ObjectSeekCount = 0;
 410
 411                 for(multimap<string,string>::iterator propiter = DataReceived.begin();
 412                         propiter != DataReceived.end();
 413                         ++propiter){
 414
 415                         NewTZData.TimeZoneNameTokens.push_back("");
 416                         NewTZData.TimeZoneNameLanguage.push_back("");
 417                         NewTZData.TimeZoneNameData.push_back("");
 418
 419                         bool TokenData = false;
 420                         string PropertyTokens;
 421
 422                         PropertyNameData = (string*)&propiter->first;
 423
 424                         PropertyData = SplitValues(*PropertyNameData);
 425
 426                         for(map<string,string>::iterator dataiter = PropertyData.begin();
 427                                 dataiter != PropertyData.end(); dataiter++){
 428
 429                                 if (dataiter->first == "LANGUAGE"){
 430
 431                                         NewTZData.TimeZoneNameLanguage[ObjectSeekCount] = dataiter->second;
 432
 433                                 } else {
 434
 435                                         if (TokenData == false){
 436                                                 TokenData = true;
 437                                         } else {
 438                                                 PropertyTokens += ";";
 439                                         }
 440
 441                                         PropertyTokens += dataiter->first;
 442                                         PropertyTokens += "=";
 443                                         PropertyTokens += dataiter->second;
 444
 445                                 }
 446
 447                         }
 448
 449                         if (PropertyTokens.size() > 0){
 450                                 NewTZData.TimeZoneNameTokens[ObjectSeekCount] = PropertyTokens;
 451                         }
 452
 453                         NewTZData.TimeZoneNameData[ObjectSeekCount] = propiter->second;
 454
 455                         ObjectSeekCount++;
 456
 457                 }
 458
 459                 ObjectSeekCount = 0;
 460
 461                 // Process data from X-*
 462
 463                 for(vector<string>::iterator propiter = TimezoneStandardName[SeekCount].begin();
 464                         propiter != TimezoneStandardName[SeekCount].end(); ++propiter){
 465
 466                         if (propiter->substr(0,2) == "X-" &&
 467                                 propiter->size() > 2){
 468
 469                                 NewTZData.XTokensData.push_back(TimezoneStandardData[SeekCount][ObjectSeekCount]);
 470                                 NewTZData.XTokensDataTokens.push_back(TimezoneStandardName[SeekCount][ObjectSeekCount]);
 471
 472                         }
 473
 474                         ObjectSeekCount++;
 475
 476                 }
 477
 478                 // Check if the required values were given and
 479                 // insert NewTZData into the vector list of
 480                 // standard timezones.
 481
 482                 if (DateTimeStartFound == true &&
 483                         TimeZoneOffsetToFound == true &&
 484                         TimeZoneOffsetFromFound == true){
 485
 486                         TimezoneStandardCollection.push_back(NewTZData);
 487
 488                 }
 489
 490                 SeekCount++;
 491
 492         }
 493
 494         TZSeekCount = 0;
 495         SeekCount = 0;
 496
 497         for (vector<vector<string>>::iterator tzsiter = TimezoneDaylightName.begin();
 498                 tzsiter != TimezoneDaylightName.end(); tzsiter++){
 499
 500                 bool DateTimeStartFound = false;
 501                 bool TimeZoneOffsetToFound = false;
 502                 bool TimeZoneOffsetFromFound = false;
 503
 504                 TimezoneDataStruct NewTZData;
 505
 506                 // Process the data from DTSTART.
 507
 508                 DataReceived = ProcessTextVectors(&TimezoneDaylightName[SeekCount],
 509                                 &TimezoneDaylightData[SeekCount], false, "DTSTART");
 510
 511                 if (DataReceived.begin() != DataReceived.end()){
 512
 513                         try {
 514                                 NewTZData.DateTimeStartTokens = DataReceived.begin()->first.substr(8);
 515                         }
 516
 517                         catch(const out_of_range &oor){
 518                                 // Do nothing as there is no data.
 519                         }
 520
 521                         NewTZData.DateTimeStartData = DataReceived.begin()->second;
 522                         DateTimeStartFound = true;
 523
 524                 }
 525
 526                 // Process the data from TZOFFSETFROM.
 527
 528                 DataReceived = ProcessTextVectors(&TimezoneDaylightName[SeekCount],
 529                                 &TimezoneDaylightData[SeekCount], false, "TZOFFSETFROM");
 530
 531                 if (DataReceived.begin() != DataReceived.end()){
 532
 533                         try {
 534                                 NewTZData.TimeZoneOffsetFromTokens = DataReceived.begin()->first.substr(13);
 535                         }
 536
 537                         catch(const out_of_range &oor){
 538                                 // Do nothing as there is no data.
 539                         }
 540
 541                         NewTZData.TimeZoneOffsetFromData = DataReceived.begin()->second;
 542                         TimeZoneOffsetFromFound = true;
 543
 544                 }
 545
 546                 // Process the data from TZOFFSETTO.
 547
 548                 DataReceived = ProcessTextVectors(&TimezoneDaylightName[SeekCount],
 549                                 &TimezoneDaylightData[SeekCount], false, "TZOFFSETTO");
 550
 551                 if (DataReceived.begin() != DataReceived.end()){
 552
 553                         try {
 554                                 NewTZData.TimeZoneOffsetToTokens = DataReceived.begin()->first.substr(11);
 555                         }
 556
 557                         catch(const out_of_range &oor){
 558                                 // Do nothing as there is no data.
 559                         }
 560
 561                         NewTZData.TimeZoneOffsetToData = DataReceived.begin()->second;
 562                         TimeZoneOffsetToFound = true;
 563
 564                 }
 565
 566                 // Process the data from RRULE.
 567
 568                 DataReceived = ProcessTextVectors(&TimezoneDaylightName[SeekCount],
 569                         &TimezoneDaylightData[SeekCount], false, "RRULE");
 570
 571                 if (DataReceived.begin() != DataReceived.end()){
 572
 573                         try {
 574                                 NewTZData.RecurranceRuleDataTokens = DataReceived.begin()->first.substr(6);
 575                         }
 576
 577                         catch(const out_of_range &oor){
 578                                 // Do nothing as there is no data.
 579                         }
 580
 581                         NewTZData.RecurranceRuleData = DataReceived.begin()->second;
 582
 583                 }
 584
 585                 // Process the data from COMMENT.
 586
 587                 DataReceived = ProcessTextVectors(&TimezoneDaylightName[SeekCount],
 588                         &TimezoneDaylightData[SeekCount], true, "COMMENT");
 589
 590                 ObjectSeekCount = 0;
 591
 592                 for(multimap<string,string>::iterator propiter = DataReceived.begin();
 593                         propiter != DataReceived.end();
 594                         ++propiter){
 595
 596                         NewTZData.CommentListTokens.push_back("");
 597                         NewTZData.CommentListAltRep.push_back("");
 598                         NewTZData.CommentListLanguage.push_back("");
 599                         NewTZData.CommentList.push_back("");
 600
 601                         bool TokenData = false;
 602                         string PropertyTokens;
 603
 604                         PropertyNameData = (string*)&propiter->first;
 605
 606                         PropertyData = SplitValues(*PropertyNameData);
 607
 608                         for(map<string,string>::iterator propdataiter = PropertyData.begin();
 609                                 propdataiter != PropertyData.end(); propdataiter++){
 610
 611                                 if (propdataiter->first == "ALTREP"){
 612
 613                                         NewTZData.CommentListAltRep[ObjectSeekCount] = propdataiter->second;
 614
 615                                 } else if (propdataiter->first == "LANGUAGE"){
 616
 617                                         NewTZData.CommentListLanguage[ObjectSeekCount] = propdataiter->second;
 618
 619                                 } else {
 620
 621                                         if (TokenData == false){
 622                                                 TokenData = true;
 623                                         } else {
 624                                                 PropertyTokens += ";";
 625                                         }
 626
 627                                         PropertyTokens += propdataiter->first;
 628                                         PropertyTokens += "=";
 629                                         PropertyTokens += propdataiter->second;
 630
 631                                 }
 632
 633                         }
 634
 635                         if (PropertyTokens.size() > 0){
 636                                 NewTZData.CommentListTokens[ObjectSeekCount] = PropertyTokens;
 637                         }
 638
 639                         NewTZData.CommentList[ObjectSeekCount] = propiter->second;
 640
 641                         ObjectSeekCount++;
 642
 643                 }
 644
 645                 // Process the data from RDATE.
 646
 647                 DataReceived = ProcessTextVectors(&TimezoneDaylightName[SeekCount],
 648                         &TimezoneDaylightData[SeekCount], true, "RDATE");
 649
 650                 ObjectSeekCount = 0;
 651
 652                 for(multimap<string,string>::iterator propiter = DataReceived.begin();
 653                         propiter != DataReceived.end();
 654                         ++propiter){
 655
 656                         NewTZData.RecurranceDateDataTokens.push_back("");
 657                         NewTZData.RecurranceDateDataValue.push_back("");
 658                         NewTZData.RecurranceDateDataTimeZoneParam.push_back("");
 659                         NewTZData.RecurranceDateData.push_back("");
 660
 661                         bool TokenData = false;
 662                         string PropertyTokens;
 663
 664                         PropertyNameData = (string*)&propiter->first;
 665
 666                         PropertyData = SplitValues(*PropertyNameData);
 667
 668                         for(map<string,string>::iterator dataiter = PropertyData.begin();
 669                                 dataiter != PropertyData.end(); dataiter++){
 670
 671                                 if (dataiter->first == "VALUE"){
 672
 673                                         NewTZData.RecurranceDateDataValue[ObjectSeekCount] = dataiter->second;
 674
 675                                 } else if (dataiter->first == "TZID"){
 676
 677                                         NewTZData.RecurranceDateDataTimeZoneParam[ObjectSeekCount] = dataiter->second;
 678
 679                                 } else {
 680
 681                                         if (TokenData == false){
 682                                                 TokenData = true;
 683                                         } else {
 684                                                 PropertyTokens += ";";
 685                                         }
 686
 687                                         PropertyTokens += dataiter->first;
 688                                         PropertyTokens += "=";
 689                                         PropertyTokens += dataiter->second;
 690
 691                                 }
 692
 693                         }
 694
 695                         if (PropertyTokens.size() > 0){
 696                                 NewTZData.RecurranceDateDataTokens[ObjectSeekCount] = PropertyTokens;
 697                         }
 698
 699                         NewTZData.RecurranceDateData[ObjectSeekCount] = propiter->second;
 700
 701                         ObjectSeekCount++;
 702
 703                 }
 704
 705                 // Process the data from TZNAME.
 706
 707                 DataReceived = ProcessTextVectors(&TimezoneDaylightName[SeekCount],
 708                         &TimezoneDaylightData[SeekCount], true, "TZNAME");
 709
 710                 ObjectSeekCount = 0;
 711
 712                 for(multimap<string,string>::iterator propiter = DataReceived.begin();
 713                         propiter != DataReceived.end();
 714                         ++propiter){
 715
 716                         NewTZData.TimeZoneNameTokens.push_back("");
 717                         NewTZData.TimeZoneNameLanguage.push_back("");
 718                         NewTZData.TimeZoneNameData.push_back("");
 719
 720                         bool TokenData = false;
 721                         string PropertyTokens;
 722
 723                         PropertyNameData = (string*)&propiter->first;
 724
 725                         PropertyData = SplitValues(*PropertyNameData);
 726
 727                         for(map<string,string>::iterator dataiter = PropertyData.begin();
 728                                 dataiter != PropertyData.end(); dataiter++){
 729
 730                                 if (dataiter->first == "LANGUAGE"){
 731
 732                                         NewTZData.TimeZoneNameLanguage[ObjectSeekCount] = dataiter->second;
 733
 734                                 } else {
 735
 736                                         if (TokenData == false){
 737                                                 TokenData = true;
 738                                         } else {
 739                                                 PropertyTokens += ";";
 740                                         }
 741
 742                                         PropertyTokens += dataiter->first;
 743                                         PropertyTokens += "=";
 744                                         PropertyTokens += dataiter->second;
 745
 746                                 }
 747
 748                         }
 749
 750                         if (PropertyTokens.size() > 0){
 751                                 NewTZData.TimeZoneNameTokens[ObjectSeekCount] = PropertyTokens;
 752                         }
 753
 754                         NewTZData.TimeZoneNameData[ObjectSeekCount] = propiter->second;
 755
 756                         ObjectSeekCount++;
 757
 758                 }
 759
 760                 ObjectSeekCount = 0;
 761
 762                 // Process data from X-*
 763
 764                 for(vector<string>::iterator propiter = TimezoneDaylightName[SeekCount].begin();
 765                         propiter != TimezoneDaylightName[SeekCount].end(); ++propiter){
 766
 767                         if (propiter->substr(0,2) == "X-" &&
 768                                 propiter->size() > 2){
 769
 770                                 NewTZData.XTokensData.push_back(TimezoneDaylightData[SeekCount][ObjectSeekCount]);
 771                                 NewTZData.XTokensDataTokens.push_back(TimezoneDaylightName[SeekCount][ObjectSeekCount]);
 772
 773                         }
 774
 775                         ObjectSeekCount++;
 776
 777                 }
 778
 779                 // Check if the required values were given and
 780                 // insert NewTZData into the vector list of
 781                 // daylight timezones.
 782
 783                 if (DateTimeStartFound == true &&
 784                         TimeZoneOffsetToFound == true &&
 785                         TimeZoneOffsetFromFound == true){
 786
 787                         TimezoneDaylightCollection.push_back(NewTZData);
 788
 789                 }
 790
 791                 SeekCount++;
 792
 793         }
 794
 795 }
 796
 797 void CalendarTimezoneObject::ProcessStandardDaylight(){
 798
 799         int SeekCount = 0;
 800
 801         bool TZMode = false; // False = STANDARD, True = DAYLIGHT.
 802         bool ValidBegin = false;
 803         vector<string> TimezoneObjectName;
 804         vector<string> TimezoneObjectData;
 805
 806         for (vector<string>::iterator iter = ObjectName.begin();
 807                 iter != ObjectName.end(); iter++){
 808
 809                 // Check if the current name is BEGIN and
 810                 // data is either STANDARD or DAYLIGHT.
 811
 812                 if (ObjectName[SeekCount] == "BEGIN" &&
 813                         (ObjectData[SeekCount] == "STANDARD" ||
 814                         ObjectData[SeekCount] == "DAYLIGHT")){
 815
 816                         if (ValidBegin == false){
 817                                 ValidBegin = true;
 818                         } else {
 819
 820                         }
 821
 822                         if (ObjectData[SeekCount] == "STANDARD"){
 823                                 TZMode = false;
 824                         } else if (ObjectData[SeekCount] == "DAYLIGHT") {
 825                                 TZMode = true;
 826                         }
 827
 828                         SeekCount++;
 829                         continue;
 830
 831                 }
 832
 833                 // Check if current name is END and
 834                 // data is either STANDARD or DAYLIGHT.
 835
 836                 if (ObjectName[SeekCount] == "END" &&
 837                         (ObjectData[SeekCount] == "STANDARD" ||
 838                         ObjectData[SeekCount] == "DAYLIGHT") &&
 839                         ValidBegin == true){
 840
 841                         if (TZMode == false && TimezoneObjectName.size() > 0){
 842                                 TimezoneStandardName.push_back(TimezoneObjectName);
 843                                 TimezoneStandardData.push_back(TimezoneObjectData);
 844                         } else {
 845                                 TimezoneDaylightName.push_back(TimezoneObjectName);
 846                                 TimezoneDaylightData.push_back(TimezoneObjectData);
 847                         }
 848
 849                         TimezoneObjectName.clear();
 850                         TimezoneObjectData.clear();
 851
 852                         ValidBegin = false;
 853
 854                 }
 855
 856                 if (ValidBegin == true){
 857
 858                         TimezoneObjectName.push_back(ObjectName[SeekCount]);
 859                         TimezoneObjectData.push_back(ObjectData[SeekCount]);
 860
 861                 }
 862
 863                 SeekCount++;
 864
 865         }
 866
 867 }