Home | News | Projects | Releases
Bugs | RFE | Repositories | Help
camelCase: Converted code in calendarevent directory
authorSteve Brokenshire <sbrokenshire@xestia.co.uk>
Sat, 28 Jan 2017 17:11:04 +0000 (17:11 +0000)
committerSteve Brokenshire <sbrokenshire@xestia.co.uk>
Sat, 28 Jan 2017 17:11:04 +0000 (17:11 +0000)
source/objects/calendarevent/CalendarEvent-Save.cpp
source/objects/calendarevent/CalendarEvent.cpp
source/objects/calendarevent/CalendarEvent.h

index 0feaf23..f65344c 100644 (file)
 
 using namespace std;
 
-void CalendarEventObject::SaveObjectData(string *SaveData){
+void CalendarEventObject::SaveObjectData(string *saveData){
 
-       string DataLine = "";
-       string DataLineProcessed = "";
+       string dataLine = "";
+       string dataLineProcessed = "";
        
-       *SaveData += "BEGIN:VEVENT\n";
+       *saveData += "BEGIN:VEVENT\n";
        
        // Process the UID.
        
-       if (UniqueID.size() > 0){
+       if (uniqueID.size() > 0){
                
-               if (UniqueIDTokens.size() > 0){
+               if (uniqueIDTokens.size() > 0){
                
-                       DataLine += "UID;";
-                       DataLine += UniqueIDTokens;
+                       dataLine += "UID;";
+                       dataLine += UniqueIDTokens;
                        
                } else {
 
-                       DataLine += "UID";
+                       dataLine += "UID";
                        
                }
 
-               DataLine += ":";
-               DataLine += UniqueID;
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += uniqueID;
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
                
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the DTSTAMP.
        
-       if (DateTimeStampData.size() > 0){
+       if (dateTimeStampData.size() > 0){
                
-               if (DateTimeStampTokens.size() > 0){
+               if (dateTimeStampTokens.size() > 0){
                
-                       DataLine += "DTSTAMP;";
-                       DataLine += DateTimeStampTokens;
+                       dataLine += "DTSTAMP;";
+                       dataLine += dateTimeStampTokens;
                        
                } else {
 
-                       DataLine += "DTSTAMP";
+                       dataLine += "DTSTAMP";
                        
                }
 
-               DataLine += ":";
-               DataLine += DateTimeStampData;
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += dateTimeStampData;
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
                
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
 
        // Process the DTSTART.
        
-       if (DateTimeStartData.size() > 0){
+       if (dateTimeStartData.size() > 0){
                
-               DataLine += "DTSTART";
+               dataLine += "DTSTART";
                
-               if (DateTimeStartDataValue.size() > 0){
+               if (dateTimeStartDataValue.size() > 0){
                
-                       DataLine += ";VALUE=";
-                       DataLine += DateTimeStartDataValue;                     
+                       dataLine += ";VALUE=";
+                       dataLine += dateTimeStartDataValue;                     
                        
                }
                
-               if (DateTimeStartDataTimeZoneID.size() > 0){
+               if (dateTimeStartDataTimeZoneID.size() > 0){
                
-                       DataLine += ";TZID=";
-                       DataLine += DateTimeStartDataTimeZoneID;                        
+                       dataLine += ";TZID=";
+                       dataLine += dateTimeStartDataTimeZoneID;                        
                        
                }
                
-               if (DateTimeStartDataTokens.size() > 0){
+               if (dateTimeStartDataTokens.size() > 0){
                
-                       DataLine += ";";
-                       DataLine += DateTimeStartDataTokens;
+                       dataLine += ";";
+                       dataLine += dateTimeStartDataTokens;
                        
                }
 
-               DataLine += ":";
-               DataLine += DateTimeStartData;
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += dateTimeStartData;
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
                
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the DTEND.
        
-       if (DateTimeEndData.size() > 0){
+       if (dateTimeEndData.size() > 0){
                
-               DataLine += "DTEND";
+               dataLine += "DTEND";
                
-               if (DateTimeEndDataValue.size() > 0){
+               if (dateTimeEndDataValue.size() > 0){
                
-                       DataLine += ";VALUE=";
-                       DataLine += DateTimeEndDataValue;                       
+                       dataLine += ";VALUE=";
+                       dataLine += dateTimeEndDataValue;
                        
                }
                
-               if (DateTimeEndDataTimeZoneID.size() > 0){
+               if (dateTimeEndDataTimeZoneID.size() > 0){
                
-                       DataLine += ";TZID=";
-                       DataLine += DateTimeEndDataTimeZoneID;                  
+                       dataLine += ";TZID=";
+                       dataLine += dateTimeEndDataTimeZoneID;                  
                        
                }
                
-               if (DateTimeEndDataTokens.size() > 0){
+               if (dateTimeEndDataTokens.size() > 0){
                
-                       DataLine += ";";
-                       DataLine += DateTimeEndDataTokens;
+                       dataLine += ";";
+                       dataLine += dateTimeEndDataTokens;
                        
                }
 
-               DataLine += ":";
-               DataLine += DateTimeEndData;
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += dateTimeEndData;
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
                
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the SUMMARY.
        
-       if (SummaryData.size() > 0){
+       if (summaryData.size() > 0){
                
-               DataLine += "SUMMARY";
+               dataLine += "SUMMARY";
                
-               if (SummaryDataAltRep.size() > 0){
+               if (summaryDataAltRep.size() > 0){
                
-                       DataLine += ";ALTREP=\"";
-                       DataLine += SummaryDataAltRep;
-                       DataLine += "\"";
+                       dataLine += ";ALTREP=\"";
+                       dataLine += summaryDataAltRep;
+                       dataLine += "\"";
                        
                }
                
-               if (SummaryDataLanguage.size() > 0){
+               if (summaryDataLanguage.size() > 0){
                
-                       DataLine += ";LANGUAGE=";
-                       DataLine += SummaryDataLanguage;                        
+                       dataLine += ";LANGUAGE=";
+                       dataLine += summaryDataLanguage;                        
                        
                }
                
-               if (SummaryDataTokens.size() > 0){
+               if (summaryDataTokens.size() > 0){
                
-                       DataLine += ";";
-                       DataLine += SummaryDataTokens;
+                       dataLine += ";";
+                       dataLine += summaryDataTokens;
                        
                }
                
-               DataLine += ":";
-               DataLine += SummaryData;
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += summaryData;
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
 
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
 
        // Process the CLASS value.
        
-       if (ClassData.size() > 0){
+       if (classData.size() > 0){
                
-               if (ClassDataTokens.size() > 0){
+               if (classDataTokens.size() > 0){
                
-                       DataLine += "CLASS;";
-                       DataLine += ClassDataTokens;
+                       dataLine += "CLASS;";
+                       dataLine += classDataTokens;
                        
                } else {
 
-                       DataLine += "CLASS";
+                       dataLine += "CLASS";
                        
                }
 
-               DataLine += ":";
-               DataLine += ClassData;
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += classData;
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
                
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the CREATED value.
        
-       if (DateTimeCreatedData.size() > 0){
+       if (dateTimeCreatedData.size() > 0){
                
-               if (DateTimeCreatedTokens.size() > 0){
+               if (dateTimeCreatedTokens.size() > 0){
                
-                       DataLine += "CREATED;";
-                       DataLine += DateTimeCreatedTokens;
+                       dataLine += "CREATED;";
+                       dataLine += dateTimeCreatedTokens;
                        
                } else {
 
-                       DataLine += "CREATED";
+                       dataLine += "CREATED";
                        
                }
 
-               DataLine += ":";
-               DataLine += DateTimeCreatedData;
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += dateTimeCreatedData;
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
                
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the DESCRIPTION values. Write out the
        // first DESCRPITION only as per RFC5545 specifcation.
        
-       if (DescriptionList.size() > 0){
+       if (descriptionList.size() > 0){
                
-               DataLine += "DESCRIPTION";
+               dataLine += "DESCRIPTION";
                
-               if (DescriptionListAltRep[0].size() > 0){
+               if (descriptionListAltRep[0].size() > 0){
                
-                       DataLine += ";ALTREP=\"";
-                       DataLine += DescriptionListAltRep[0];
-                       DataLine += "\"";
+                       dataLine += ";ALTREP=\"";
+                       dataLine += descriptionListAltRep[0];
+                       dataLine += "\"";
                        
                }
                
-               if (DescriptionListLanguage[0].size() > 0){
+               if (descriptionListLanguage[0].size() > 0){
                
-                       DataLine += ";LANGUAGE=";
-                       DataLine += DescriptionListLanguage[0];
+                       dataLine += ";LANGUAGE=";
+                       dataLine += descriptionListLanguage[0];
                        
                }
                
-               if (DescriptionListTokens[0].size() > 0){
+               if (descriptionListTokens[0].size() > 0){
                
-                       DataLine += ";";
-                       DataLine += DescriptionListTokens[0];
+                       dataLine += ";";
+                       dataLine += descriptionListTokens[0];
                        
                }
 
-               DataLine += ":";
-               DataLine += DescriptionList[0];
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += descriptionList[0];
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
                
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the GEO value.
        
-       if (GeographicData.size() > 0){
+       if (geographicData.size() > 0){
                
-               if (GeographicTokens.size() > 0){
+               if (geographicTokens.size() > 0){
                
-                       DataLine += "GEO;";
-                       DataLine += GeographicTokens;
+                       dataLine += "GEO;";
+                       dataLine += geographicTokens;
                        
                } else {
 
-                       DataLine += "GEO";
+                       dataLine += "GEO";
                        
                }
 
-               DataLine += ":";
-               DataLine += GeographicData;
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += geographicData;
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
                
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the LAST-MODIFIED value.
        
-       if (LastModifiedData.size() > 0){
+       if (lastModifiedData.size() > 0){
                
-               if (LastModifiedTokens.size() > 0){
+               if (lastModifiedTokens.size() > 0){
                
-                       DataLine += "LAST-MODIFIED;";
-                       DataLine += LastModifiedTokens;
+                       dataLine += "LAST-MODIFIED;";
+                       dataLine += lastModifiedTokens;
                        
                } else {
 
-                       DataLine += "LAST-MODIFIED";
+                       dataLine += "LAST-MODIFIED";
                        
                }
 
-               DataLine += ":";
-               DataLine += LastModifiedData;
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += lastModifiedData;
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
                
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the LOCATION value.
 
-       if (LocationData.size() > 0){
+       if (locationData.size() > 0){
                
-               DataLine += "LOCATION";
+               dataLine += "LOCATION";
                
-               if (LocationDataAltRep.size() > 0){
+               if (locationDataAltRep.size() > 0){
                
-                       DataLine += ";ALTREP=\"";
-                       DataLine += LocationDataAltRep;
-                       DataLine += "\"";
+                       dataLine += ";ALTREP=\"";
+                       dataLine += locationDataAltRep;
+                       dataLine += "\"";
                        
                }
                
-               if (LocationDataLanguage.size() > 0){
+               if (locationDataLanguage.size() > 0){
                
-                       DataLine += ";LANGUAGE=";
-                       DataLine += LocationDataLanguage;                       
+                       dataLine += ";LANGUAGE=";
+                       dataLine += locationDataLanguage;                       
                        
                }
                
-               if (LocationDataTokens.size() > 0){
+               if (locationDataTokens.size() > 0){
                
-                       DataLine += ";";
-                       DataLine += LocationDataTokens;
+                       dataLine += ";";
+                       dataLine += locationDataTokens;
                        
                }
                
-               DataLine += ":";
-               DataLine += LocationData;
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += locationData;
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
 
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the ORGANIZER value.
        
-       if (OrganiserData.size() > 0){
+       if (organiserData.size() > 0){
                
-               DataLine += "ORGANIZER";
+               dataLine += "ORGANIZER";
                
-               if (OrganiserDataCommonName.size() > 0){
+               if (organiserDataCommonName.size() > 0){
                
-                       DataLine += ";CN=";
-                       DataLine += OrganiserDataCommonName;
+                       dataLine += ";CN=";
+                       dataLine += organiserDataCommonName;
                        
                }
 
-               if (OrganiserDataDirectoryEntry.size() > 0){
+               if (organiserDataDirectoryEntry.size() > 0){
                
-                       DataLine += ";DIR=\"";
-                       DataLine += OrganiserDataDirectoryEntry;
-                       DataLine += "\"";
+                       dataLine += ";DIR=\"";
+                       dataLine += organiserDataDirectoryEntry;
+                       dataLine += "\"";
                        
                }
                
-               if (OrganiserDataSentByParam.size() > 0){
+               if (organiserDataSentByParam.size() > 0){
                
-                       DataLine += ";SENT-BY=\"";
-                       DataLine += OrganiserDataSentByParam;                   
-                       DataLine += "\"";
+                       dataLine += ";SENT-BY=\"";
+                       dataLine += organiserDataSentByParam;                   
+                       dataLine += "\"";
                        
                }
                
-               if (OrganiserDataLanguage.size() > 0){
+               if (organiserDataLanguage.size() > 0){
                
-                       DataLine += ";LANGUAGE=";
-                       DataLine += OrganiserDataLanguage;                      
+                       dataLine += ";LANGUAGE=";
+                       dataLine += organiserDataLanguage;                      
                        
                }
                
-               if (OrganiserDataTokens.size() > 0){
+               if (organiserDataTokens.size() > 0){
                
-                       DataLine += ";";
-                       DataLine += OrganiserDataTokens;
+                       dataLine += ";";
+                       dataLine += organiserDataTokens;
                        
                }
                
-               DataLine += ":";
-               DataLine += OrganiserData;
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += organiserData;
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
 
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the PRIORITY value.
        
-       if (PriorityData > -1 && PriorityData < 10){
+       if (priorityData > -1 && priorityData < 10){
                
-               DataLine += "PRIORITY";
+               dataLine += "PRIORITY";
                
-               if (PriorityTokens.size() > 0){
+               if (priorityTokens.size() > 0){
                
-                       DataLine += ";";
-                       DataLine += PriorityTokens;
+                       dataLine += ";";
+                       dataLine += priorityTokens;
                        
                }
                
-               DataLine += ":";
-               DataLine += to_string(PriorityData);
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += to_string(priorityData);
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
 
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the SEQUENCE value.
        
-       if (SequenceData > -1 && SequenceData < 10){
+       if (sequenceData > -1 && sequenceData < 10){
                
-               DataLine += "SEQUENCE";
+               dataLine += "SEQUENCE";
                
-               if (SequenceTokens.size() > 0){
+               if (sequenceTokens.size() > 0){
                
-                       DataLine += ";";
-                       DataLine += SequenceTokens;
+                       dataLine += ";";
+                       dataLine += sequenceTokens;
                        
                }
                
-               DataLine += ":";
-               DataLine += to_string(SequenceData);
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += to_string(sequenceData);
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
 
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the STATUS value.
        
-       if (StatusData.size() > 0){
+       if (statusData.size() > 0){
                
-               DataLine += "STATUS";
+               dataLine += "STATUS";
                
-               if (StatusLanguage.size() > 0){
+               if (statusLanguage.size() > 0){
                
-                       DataLine += ";LANGUAGE=";
-                       DataLine += StatusLanguage;                     
+                       dataLine += ";LANGUAGE=";
+                       dataLine += StatusLanguage;                     
                        
                }
                
-               if (StatusTokens.size() > 0){
+               if (statusTokens.size() > 0){
                
-                       DataLine += ";";
-                       DataLine += StatusTokens;
+                       dataLine += ";";
+                       dataLine += statusTokens;
                        
                }
                
-               DataLine += ":";
-               DataLine += StatusData;
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += statusData;
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
-               
-               *SaveData += DataLineProcessed;
+               dataLineProcessed = OutputText(&dataLine);
+       
+               *saveData += dataLineProcessed;
 
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the TRANSP value.
        
-       if (TimeTransparencyData.size() > 0){
+       if (timeTransparencyData.size() > 0){
                
-               DataLine += "TRANSP";
+               dataLine += "TRANSP";
 
-               if (TimeTransparencyDataTokens.size() > 0){
+               if (timeTransparencyDataTokens.size() > 0){
                
-                       DataLine += ";";
-                       DataLine += TimeTransparencyDataTokens;
+                       dataLine += ";";
+                       dataLine += timeTransparencyDataTokens;
                        
                }
                
-               DataLine += ":";
-               DataLine += TimeTransparencyData;
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += timeTransparencyData;
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
 
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the URL value.
        
-       if (URLData.size() > 0){
+       if (urlData.size() > 0){
                
-               DataLine += "URL";
+               dataLine += "URL";
 
-               if (URLDataTokens.size() > 0){
+               if (urlDataTokens.size() > 0){
                
-                       DataLine += ";";
-                       DataLine += URLDataTokens;
+                       dataLine += ";";
+                       dataLine += urlDataTokens;
                        
                }
                
-               DataLine += ":";
-               DataLine += URLData;
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += urlData;
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
 
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the RECURRENCE-ID value.
        
-       if (RecurranceIDData.size() > 0){
+       if (recurranceIDData.size() > 0){
                
-               DataLine += "RECURRENCE-ID";
+               dataLine += "RECURRENCE-ID";
 
-               if (RecurranceIDDataTimeZoneParam.size() > 0){
+               if (recurranceIDDataTimeZoneParam.size() > 0){
                
-                       DataLine += ";TZID=";
-                       DataLine += RecurranceIDDataTimeZoneParam;                      
+                       dataLine += ";TZID=";
+                       dataLine += recurranceIDDataTimeZoneParam;                      
                        
                }
                
-               if (RecurranceIDDataRangeParam.size() > 0){
+               if (recurranceIDDataRangeParam.size() > 0){
                
-                       DataLine += ";RANGE=";
-                       DataLine += RecurranceIDDataRangeParam;                 
+                       dataLine += ";RANGE=";
+                       dataLine += recurranceIDDataRangeParam;                 
                        
                }
                
-               if (RecurranceIDDataValue.size() > 0){
+               if (recurranceIDDataValue.size() > 0){
                
-                       DataLine += ";VALUE=";
-                       DataLine += RecurranceIDDataValue;                      
+                       dataLine += ";VALUE=";
+                       dataLine += recurranceIDDataValue;
                        
                }
                
-               if (RecurranceIDDataTokens.size() > 0){
+               if (recurranceIDDataTokens.size() > 0){
                
-                       DataLine += ";";
-                       DataLine += RecurranceIDDataTokens;
+                       dataLine += ";";
+                       dataLine += recurranceIDDataTokens;
                        
                }
                
-               DataLine += ":";
-               DataLine += RecurranceIDData;
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += recurranceIDData;
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
 
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the DURATION value.
        
-       if (DurationData.size() > 0){
+       if (durationData.size() > 0){
                
-               DataLine += "DURATION";
+               dataLine += "DURATION";
 
-               if (DurationDataTokens.size() > 0){
+               if (durationDataTokens.size() > 0){
                
-                       DataLine += ";";
-                       DataLine += DurationDataTokens;
+                       dataLine += ";";
+                       dataLine += durationDataTokens;
                        
                }
                
-               DataLine += ":";
-               DataLine += DurationData;
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += durationData;
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
 
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the RRULE value.
        
-       if (RecurranceRuleData.size() > 0){
+       if (recurranceRuleData.size() > 0){
                
-               DataLine += "RRULE";
+               dataLine += "RRULE";
 
-               if (RecurranceRuleDataTokens.size() > 0){
+               if (recurranceRuleDataTokens.size() > 0){
                
-                       DataLine += ";";
-                       DataLine += RecurranceRuleDataTokens;
+                       dataLine += ";";
+                       dataLine += recurranceRuleDataTokens;
                        
                }
                
-               DataLine += ":";
-               DataLine += RecurranceRuleData;
-               DataLine += "\n";
+               dataLine += ":";
+               dataLine += recurranceRuleData;
+               dataLine += "\n";
                
-               DataLineProcessed = OutputText(&DataLine);
+               dataLineProcessed = OutputText(&dataLine);
                
-               *SaveData += DataLineProcessed;
+               *saveData += dataLineProcessed;
 
-               DataLine.clear();
-               DataLineProcessed.clear();
+               dataLine.clear();
+               dataLineProcessed.clear();
                
        }
        
        // Process the ATTACH values.
        
-       if (AttachList.size() > 0){
+       if (attachList.size() > 0){
                
-               for (int AttachListSeek = 0; AttachListSeek < AttachList.size();
-                       AttachListSeek++){
+               for (int attachListSeek = 0; attachListSeek < attachList.size();
+                       attachListSeek++){
                        
-                       DataLine += "ATTACH";
+                       dataLine += "ATTACH";
 
-                       if (AttachListFormatType[AttachListSeek].size() > 0){
+                       if (attachListFormatType[attachListSeek].size() > 0){
                
-                               DataLine += ";FMTTYPE=";
-                               DataLine += AttachListFormatType[AttachListSeek];
+                               dataLine += ";FMTTYPE=";
+                               dataLine += attachListFormatType[attachListSeek];
                        
                        }
                                
-                       if (AttachListValue[AttachListSeek].size() > 0){
+                       if (attachListValue[attachListSeek].size() > 0){
                
-                               DataLine += ";VALUE=";
-                               DataLine += AttachListValue[AttachListSeek];
+                               dataLine += ";VALUE=";
+                               dataLine += attachListValue[attachListSeek];
                        
                        }
                                
-                       if (AttachListEncoding[AttachListSeek].size() > 0){
+                       if (attachListEncoding[attachListSeek].size() > 0){
                
-                               DataLine += ";ENCODING=";
-                               DataLine += AttachListEncoding[AttachListSeek];
+                               dataLine += ";ENCODING=";
+                               dataLine += attachListEncoding[attachListSeek];
                        
                        }
                                
-                       if (AttachListTokens[AttachListSeek].size() > 0){
+                       if (attachListTokens[AttachListSeek].size() > 0){
                
-                               DataLine += ";";
-                               DataLine += AttachListTokens[AttachListSeek];
+                               dataLine += ";";
+                               dataLine += attachListTokens[attachListSeek];
                        
                        }
                
-                       DataLine += ":";
-                       DataLine += AttachList[AttachListSeek];
-                       DataLine += "\n";
+                       dataLine += ":";
+                       dataLine += attachList[attachListSeek];
+                       dataLine += "\n";
                
-                       DataLineProcessed = OutputText(&DataLine);
+                       dataLineProcessed = OutputText(&dataLine);
                
-                       *SaveData += DataLineProcessed;
+                       *saveData += dataLineProcessed;
 
-                       DataLine.clear();
-                       DataLineProcessed.clear();
+                       dataLine.clear();
+                       dataLineProcessed.clear();
                                
                }
                
@@ -745,113 +745,113 @@ void CalendarEventObject::SaveObjectData(string *SaveData){
        
        // Process the ATTENDEE value.
        
-       if (AttendeeList.size() > 0){
+       if (attendeeList.size() > 0){
                
-               for (int AttendeeListSeek = 0; AttendeeListSeek < AttendeeList.size();
-                       AttendeeListSeek++){
+               for (int attendeeListSeek = 0; attendeeListSeek < attendeeList.size();
+                       attendeeListSeek++){
        
-                       DataLine += "ATTENDEE";
+                       dataLine += "ATTENDEE";
 
-                       if (AttendeeListMember[AttendeeListSeek].size() > 0){
+                       if (attendeeListMember[attendeeListSeek].size() > 0){
                
-                               DataLine += ";MEMBER=\"";
-                               DataLine += AttendeeListMember[AttendeeListSeek];
-                               DataLine += "\"";
+                               dataLine += ";MEMBER=\"";
+                               dataLine += attendeeListMember[attendeeListSeek];
+                               dataLine += "\"";
                        
                        }
                                
-                       if (AttendeeListDelegatedFrom[AttendeeListSeek].size() > 0){
+                       if (attendeeListDelegatedFrom[attendeeListSeek].size() > 0){
                
-                               DataLine += ";DELEGATED-FROM=\"";
-                               DataLine += AttendeeListDelegatedFrom[AttendeeListSeek];
-                               DataLine += "\"";
+                               dataLine += ";DELEGATED-FROM=\"";
+                               dataLine += attendeeListDelegatedFrom[attendeeListSeek];
+                               dataLine += "\"";
                        
                        }
 
-                       if (AttendeeListDelegatedTo[AttendeeListSeek].size() > 0){
+                       if (attendeeListDelegatedTo[attendeeListSeek].size() > 0){
                
-                               DataLine += ";DELEGATED-TO=\"";
-                               DataLine += AttendeeListDelegatedTo[AttendeeListSeek];
-                               DataLine += "\"";
+                               dataLine += ";DELEGATED-TO=\"";
+                               dataLine += attendeeListDelegatedTo[attendeeListSeek];
+                               dataLine += "\"";
                        
                        }
 
-                       if (AttendeeListRole[AttendeeListSeek].size() > 0){
+                       if (attendeeListRole[attendeeListSeek].size() > 0){
                
-                               DataLine += ";ROLE=";
-                               DataLine += AttendeeListRole[AttendeeListSeek];
+                               dataLine += ";ROLE=";
+                               dataLine += attendeeListRole[attendeeListSeek];
                        
                        }
                        
-                       if (AttendeeListRSVP[AttendeeListSeek].size() > 0){
+                       if (attendeeListRSVP[attendeeListSeek].size() > 0){
                
-                               DataLine += ";RSVP=";
-                               DataLine += AttendeeListRSVP[AttendeeListSeek];
+                               dataLine += ";RSVP=";
+                               dataLine += attendeeListRSVP[attendeeListSeek];
                        
                        }
                        
-                       if (AttendeeListDirectoryEntry[AttendeeListSeek].size() > 0){
+                       if (attendeeListDirectoryEntry[attendeeListSeek].size() > 0){
                
-                               DataLine += ";DIR=\"";
-                               DataLine += AttendeeListDirectoryEntry[AttendeeListSeek];
-                               DataLine += "\"";
+                               dataLine += ";DIR=\"";
+                               dataLine += attendeeListDirectoryEntry[attendeeListSeek];
+                               dataLine += "\"";
                        
                        }
                        
-                       if (AttendeeListSentBy[AttendeeListSeek].size() > 0){
+                       if (attendeeListSentBy[attendeeListSeek].size() > 0){
                                
-                               DataLine += ";SENT-BY=\"";
-                               DataLine += AttendeeListSentBy[AttendeeListSeek];
-                               DataLine += "\"";
+                               dataLine += ";SENT-BY=\"";
+                               dataLine += attendeeListSentBy[attendeeListSeek];
+                               dataLine += "\"";
                                
                        }
 
-                       if (AttendeeListCommonName[AttendeeListSeek].size() > 0){
+                       if (attendeeListCommonName[attendeeListSeek].size() > 0){
                                
-                               DataLine += ";CN=\"";
-                               DataLine += AttendeeListCommonName[AttendeeListSeek];
-                               DataLine += "\"";
+                               dataLine += ";CN=\"";
+                               dataLine += attendeeListCommonName[attendeeListSeek];
+                               dataLine += "\"";
                                
                        }
 
-                       if (AttendeeListCalendarUserType[AttendeeListSeek].size() > 0){
+                       if (attendeeListCalendarUserType[attendeeListSeek].size() > 0){
                                
-                               DataLine += ";CUTYPE=";
-                               DataLine += AttendeeListCalendarUserType[AttendeeListSeek];
+                               dataLine += ";CUTYPE=";
+                               dataLine += attendeeListCalendarUserType[attendeeListSeek];
                                
                        }
                        
-                       if (AttendeeListParticipationStatus[AttendeeListSeek].size() > 0){
+                       if (attendeeListParticipationStatus[attendeeListSeek].size() > 0){
                                
-                               DataLine += ";PARTSTAT=";
-                               DataLine += AttendeeListParticipationStatus[AttendeeListSeek];
+                               dataLine += ";PARTSTAT=";
+                               dataLine += attendeeListParticipationStatus[attendeeListSeek];
                                
                        }
                        
-                       if (AttendeeListLanguage[AttendeeListSeek].size() > 0){
+                       if (attendeeListLanguage[attendeeListSeek].size() > 0){
                                
-                               DataLine += ";LANGUAGE=";
-                               DataLine += AttendeeListLanguage[AttendeeListSeek];
+                               dataLine += ";LANGUAGE=";
+                               dataLine += attendeeListLanguage[attendeeListSeek];
                                
                        }
                        
-                       if (AttendeeListTokens[AttendeeListSeek].size() > 0){
+                       if (attendeeListTokens[attendeeListSeek].size() > 0){
                
-                               DataLine += ";";
-                               DataLine += AttendeeListTokens[AttendeeListSeek];
+                               dataLine += ";";
+                               dataLine += attendeeListTokens[attendeeListSeek];
                        
                        }
                                
-                       DataLine += ":";
-                       DataLine += AttendeeList[AttendeeListSeek];
-                       DataLine += "\n";
+                       dataLine += ":";
+                       dataLine += attendeeList[attendeeListSeek];
+                       dataLine += "\n";
                
-                       DataLineProcessed = OutputText(&DataLine);
+                       dataLineProcessed = OutputText(&dataLine);
                
-                       *SaveData += DataLineProcessed;
+                       *saveData += dataLineProcessed;
 
-                       DataLine.clear();
-                       DataLineProcessed.clear();
+                       dataLine.clear();
+                       dataLineProcessed.clear();
                                
                }
                        
@@ -859,37 +859,37 @@ void CalendarEventObject::SaveObjectData(string *SaveData){
        
        // Process the CATEGORIES value.
        
-       if (CategoriesList.size() > 0){
+       if (categoriesList.size() > 0){
                
-               for (int CategoriesListSeek = 0; CategoriesListSeek < CategoriesList.size();
-                       CategoriesListSeek++){
+               for (int categoriesListSeek = 0; categoriesListSeek < categoriesList.size();
+                       categoriesListSeek++){
        
-                       DataLine += "CATEGORIES";
+                       dataLine += "CATEGORIES";
                                
-                       if (CategoriesListLanguage[CategoriesListSeek].size() > 0){
+                       if (categoriesListLanguage[categoriesListSeek].size() > 0){
                
-                               DataLine += ";LANGUAGE=";
-                               DataLine += CategoriesListLanguage[CategoriesListSeek];
+                               dataLine += ";LANGUAGE=";
+                               dataLine += categoriesListLanguage[categoriesListSeek];
                        
                        }                       
                        
-                       if (CategoriesListTokens[CategoriesListSeek].size() > 0){
+                       if (categoriesListTokens[categoriesListSeek].size() > 0){
                
-                               DataLine += ";";
-                               DataLine += CategoriesListTokens[CategoriesListSeek];
+                               dataLine += ";";
+                               dataLine += categoriesListTokens[categoriesListSeek];
                        
                        }
                                
-                       DataLine += ":";
-                       DataLine += CategoriesList[CategoriesListSeek];
-                       DataLine += "\n";
+                       dataLine += ":";
+                       dataLine += categoriesList[categoriesListSeek];
+                       dataLine += "\n";
                
-                       DataLineProcessed = OutputText(&DataLine);
+                       dataLineProcessed = OutputText(&dataLine);
                
-                       *SaveData += DataLineProcessed;
+                       *saveData += dataLineProcessed;
 
-                       DataLine.clear();
-                       DataLineProcessed.clear();
+                       dataLine.clear();
+                       dataLineProcessed.clear();
                                
                }
                
@@ -897,45 +897,45 @@ void CalendarEventObject::SaveObjectData(string *SaveData){
        
        // Process the COMMENT value.
        
-       if (CommentList.size() > 0){
+       if (commentList.size() > 0){
                
-               for (int CommentListSeek = 0; CommentListSeek < CommentList.size();
-                       CommentListSeek++){
+               for (int commentListSeek = 0; commentListSeek < commentList.size();
+                       commentListSeek++){
        
-                       DataLine += "COMMENT";
+                       dataLine += "COMMENT";
                        
-                       if (CommentListAltRep[CommentListSeek].size() > 0){
+                       if (commentListAltRep[commentListSeek].size() > 0){
                
-                               DataLine += ";ALTREP=\"";
-                               DataLine += CommentListAltRep[CommentListSeek];
-                               DataLine += "\"";
+                               dataLine += ";ALTREP=\"";
+                               dataLine += commentListAltRep[commentListSeek];
+                               dataLine += "\"";
                        
                        }
                                
-                       if (CommentListLanguage[CommentListSeek].size() > 0){
+                       if (commentListLanguage[commentListSeek].size() > 0){
                
-                               DataLine += ";LANGUAGE=";
-                               DataLine += CommentListLanguage[CommentListSeek];
+                               dataLine += ";LANGUAGE=";
+                               dataLine += commentListLanguage[commentListSeek];
                        
                        }
                        
-                       if (CommentListTokens[CommentListSeek].size() > 0){
+                       if (commentListTokens[commentListSeek].size() > 0){
                
-                               DataLine += ";";
-                               DataLine += CommentListTokens[CommentListSeek];
+                               dataLine += ";";
+                               dataLine += commentListTokens[commentListSeek];
                        
                        }
                                
-                       DataLine += ":";
-                       DataLine += CommentList[CommentListSeek];
-                       DataLine += "\n";
+                       dataLine += ":";
+                       dataLine += commentList[commentListSeek];
+                       dataLine += "\n";
                
-                       DataLineProcessed = OutputText(&DataLine);
+                       dataLineProcessed = OutputText(&dataLine);
                
-                       *SaveData += DataLineProcessed;
+                       *saveData += dataLineProcessed;
 
-                       DataLine.clear();
-                       DataLineProcessed.clear();
+                       dataLine.clear();
+                       dataLineProcessed.clear();
                                
                }
                
@@ -943,45 +943,45 @@ void CalendarEventObject::SaveObjectData(string *SaveData){
        
        // Process the CONTACT value.
        
-       if (ContactList.size() > 0){
+       if (contactList.size() > 0){
                
-               for (int ContactListSeek = 0; ContactListSeek < ContactList.size();
-                       ContactListSeek++){
+               for (int contactListSeek = 0; contactListSeek < contactList.size();
+                       contactListSeek++){
        
-                       DataLine += "CONTACT";
-                       
-                       if (ContactListAltRep[ContactListSeek].size() > 0){
+                       dataLine += "CONTACT";
+               
+                       if (contactListAltRep[contactListSeek].size() > 0){
                
-                               DataLine += ";ALTREP=\"";
-                               DataLine += ContactListAltRep[ContactListSeek];
-                               DataLine += "\"";
+                               dataLine += ";ALTREP=\"";
+                               dataLine += contactListAltRep[contactListSeek];
+                               dataLine += "\"";
                        
                        }
                                
-                       if (ContactListLanguage[ContactListSeek].size() > 0){
+                       if (contactListLanguage[contactListSeek].size() > 0){
                
-                               DataLine += ";LANGUAGE=";
-                               DataLine += ContactListLanguage[ContactListSeek];
+                               dataLine += ";LANGUAGE=";
+                               dataLine += contactListLanguage[contactListSeek];
                        
                        }
                        
-                       if (ContactListTokens[ContactListSeek].size() > 0){
+                       if (contactListTokens[contactListSeek].size() > 0){
                
-                               DataLine += ";";
-                               DataLine += ContactListTokens[ContactListSeek];
+                               dataLine += ";";
+                               dataLine += contactListTokens[contactListSeek];
                        
                        }
                                
-                       DataLine += ":";
-                       DataLine += ContactList[ContactListSeek];
-                       DataLine += "\n";
+                       dataLine += ":";
+                       dataLine += contactList[contactListSeek];
+                       dataLine += "\n";
                
-                       DataLineProcessed = OutputText(&DataLine);
+                       dataLineProcessed = OutputText(&dataLine);
                
-                       *SaveData += DataLineProcessed;
+                       *saveData += dataLineProcessed;
 
-                       DataLine.clear();
-                       DataLineProcessed.clear();
+                       dataLine.clear();
+                       dataLineProcessed.clear();
                                
                }
                
@@ -989,44 +989,44 @@ void CalendarEventObject::SaveObjectData(string *SaveData){
        
        // Process the EXDATE value.
        
-       if (ExcludeDateData.size() > 0){
+       if (excludeDateData.size() > 0){
                
-               for (int ExcludeDateDataSeek = 0; ExcludeDateDataSeek < ExcludeDateData.size();
-                       ExcludeDateDataSeek++){
+               for (int excludeDateDataSeek = 0; excludeDateDataSeek < excludeDateData.size();
+                       excludeDateDataSeek++){
        
-                       DataLine += "EXDATE";
+                       dataLine += "EXDATE";
                                
-                       if (ExcludeDateDataTimeZoneParam[ExcludeDateDataSeek].size() > 0){
+                       if (excludeDateDataTimeZoneParam[excludeDateDataSeek].size() > 0){
                
-                               DataLine += ";TZID=";
-                               DataLine += ExcludeDateDataTimeZoneParam[ExcludeDateDataSeek];
+                               dataLine += ";TZID=";
+                               dataLine += excludeDateDataTimeZoneParam[excludeDateDataSeek];
                        
                        }
                        
-                       if (ExcludeDateDataValue[ExcludeDateDataSeek].size() > 0){
+                       if (excludeDateDataValue[excludeDateDataSeek].size() > 0){
                
-                               DataLine += ";VALUE=";
-                               DataLine += ExcludeDateDataValue[ExcludeDateDataSeek];
+                               dataLine += ";VALUE=";
+                               dataLine += excludeDateDataValue[excludeDateDataSeek];
                        
                        }
                        
-                       if (ExcludeDateDataTokens[ExcludeDateDataSeek].size() > 0){
+                       if (excludeDateDataTokens[excludeDateDataSeek].size() > 0){
                
-                               DataLine += ";";
-                               DataLine += ExcludeDateDataTokens[ExcludeDateDataSeek];
+                               dataLine += ";";
+                               dataLine += excludeDateDataTokens[excludeDateDataSeek];
                        
                        }
                                
-                       DataLine += ":";
-                       DataLine += ExcludeDateData[ExcludeDateDataSeek];
-                       DataLine += "\n";
+                       dataLine += ":";
+                       dataLine += excludeDateData[excludeDateDataSeek];
+                       dataLine += "\n";
                
-                       DataLineProcessed = OutputText(&DataLine);
+                       dataLineProcessed = OutputText(&dataLine);
                
-                       *SaveData += DataLineProcessed;
+                       *saveData += dataLineProcessed;
 
-                       DataLine.clear();
-                       DataLineProcessed.clear();
+                       dataLine.clear();
+                       dataLineProcessed.clear();
                                
                }
                
@@ -1034,37 +1034,37 @@ void CalendarEventObject::SaveObjectData(string *SaveData){
        
        // Process the REQUEST-STATUS value.
        
-       if (RequestStatusData.size() > 0){
+       if (requestStatusData.size() > 0){
                
-               for (int RequestStatusDataSeek = 0; RequestStatusDataSeek < RequestStatusData.size();
-                       RequestStatusDataSeek++){
+               for (int requestStatusDataSeek = 0; requestStatusDataSeek < requestStatusData.size();
+                       requestStatusDataSeek++){
        
-                       DataLine += "REQUEST-STATUS";
+                       dataLine += "REQUEST-STATUS";
                        
-                       if (RequestStatusLanguage[RequestStatusDataSeek].size() > 0){
+                       if (requestStatusLanguage[requestStatusDataSeek].size() > 0){
                
-                               DataLine += ";LANGUAGE=";
-                               DataLine += RequestStatusLanguage[RequestStatusDataSeek];
+                               dataLine += ";LANGUAGE=";
+                               dataLine += requestStatusLanguage[requestStatusDataSeek];
                        
                        }
                        
-                       if (RequestStatusTokens[RequestStatusDataSeek].size() > 0){
+                       if (requestStatusTokens[requestStatusDataSeek].size() > 0){
                
-                               DataLine += ";";
-                               DataLine += RequestStatusTokens[RequestStatusDataSeek];
+                               dataLine += ";";
+                               dataLine += requestStatusTokens[requestStatusDataSeek];
                        
                        }
                                
-                       DataLine += ":";
-                       DataLine += RequestStatusData[RequestStatusDataSeek];
-                       DataLine += "\n";
+                       dataLine += ":";
+                       dataLine += requestStatusData[requestStatusDataSeek];
+                       dataLine += "\n";
                
-                       DataLineProcessed = OutputText(&DataLine);
+                       dataLineProcessed = OutputText(&dataLine);
                
-                       *SaveData += DataLineProcessed;
+                       *saveData += dataLineProcessed;
 
-                       DataLine.clear();
-                       DataLineProcessed.clear();
+                       dataLine.clear();
+                       dataLineProcessed.clear();
                                
                }
                
@@ -1072,37 +1072,37 @@ void CalendarEventObject::SaveObjectData(string *SaveData){
        
        // Process the RELATED-TO value.
        
-       if (RelatedToData.size() > 0){
+       if (relatedToData.size() > 0){
                
-               for (int RequestToDataSeek = 0; RequestToDataSeek < RelatedToData.size();
-                       RequestToDataSeek++){
+               for (int requestToDataSeek = 0; requestToDataSeek < relatedToData.size();
+                       requestToDataSeek++){
        
-                       DataLine += "RELATED-TO";
+                       dataLine += "RELATED-TO";
                        
-                       if (RelatedToDataRelationType[RequestToDataSeek].size() > 0){
+                       if (relatedToDataRelationType[requestToDataSeek].size() > 0){
                
-                               DataLine += ";RELTYPE=";
-                               DataLine += RelatedToDataRelationType[RequestToDataSeek];
+                               dataLine += ";RELTYPE=";
+                               dataLine += relatedToDataRelationType[requestToDataSeek];
                        
                        }
                        
-                       if (RelatedToDataTokens[RequestToDataSeek].size() > 0){
+                       if (relatedToDataTokens[requestToDataSeek].size() > 0){
                
-                               DataLine += ";";
-                               DataLine += RelatedToDataTokens[RequestToDataSeek];
+                               dataLine += ";";
+                               dataLine += relatedToDataTokens[requestToDataSeek];
                        
                        }
                                
-                       DataLine += ":";
-                       DataLine += RelatedToData[RequestToDataSeek];
-                       DataLine += "\n";
+                       dataLine += ":";
+                       dataLine += relatedToData[requestToDataSeek];
+                       dataLine += "\n";
                
-                       DataLineProcessed = OutputText(&DataLine);
+                       dataLineProcessed = OutputText(&dataLine);
                
-                       *SaveData += DataLineProcessed;
+                       *saveData += dataLineProcessed;
 
-                       DataLine.clear();
-                       DataLineProcessed.clear();
+                       dataLine.clear();
+                       dataLineProcessed.clear();
                                
                }
                
@@ -1110,45 +1110,45 @@ void CalendarEventObject::SaveObjectData(string *SaveData){
        
        // Process the RESOURCES value.
        
-       if (ResourcesData.size() > 0){
+       if (resourcesData.size() > 0){
                
-               for (int ResourcesDataSeek = 0; ResourcesDataSeek < ResourcesData.size();
-                       ResourcesDataSeek++){
+               for (int resourcesDataSeek = 0; resourcesDataSeek < resourcesData.size();
+                       resourcesDataSeek++){
        
-                       DataLine += "RESOURCES";
+                       dataLine += "RESOURCES";
                        
-                       if (ResourcesDataAltRep[ResourcesDataSeek].size() > 0){
+                       if (resourcesDataAltRep[resourcesDataSeek].size() > 0){
                
-                               DataLine += ";ALTREP=\"";
-                               DataLine += ResourcesDataAltRep[ResourcesDataSeek];
-                               DataLine += "\"";
+                               dataLine += ";ALTREP=\"";
+                               dataLine += resourcesDataAltRep[resourcesDataSeek];
+                               dataLine += "\"";
                        
                        }
                                
-                       if (ResourcesDataLanguage[ResourcesDataSeek].size() > 0){
+                       if (resourcesDataLanguage[resourcesDataSeek].size() > 0){
                
-                               DataLine += ";LANGUAGE=";
-                               DataLine += ResourcesDataLanguage[ResourcesDataSeek];
+                               dataLine += ";LANGUAGE=";
+                               dataLine += resourcesDataLanguage[resourcesDataSeek];
                        
                        }
                        
-                       if (ResourcesDataTokens[ResourcesDataSeek].size() > 0){
+                       if (resourcesDataTokens[resourcesDataSeek].size() > 0){
                
-                               DataLine += ";";
-                               DataLine += ResourcesDataTokens[ResourcesDataSeek];
+                               dataLine += ";";
+                               dataLine += resourcesDataTokens[resourcesDataSeek];
                        
                        }
                                
-                       DataLine += ":";
-                       DataLine += ResourcesData[ResourcesDataSeek];
-                       DataLine += "\n";
+                       dataLine += ":";
+                       dataLine += resourcesData[resourcesDataSeek];
+                       dataLine += "\n";
                
-                       DataLineProcessed = OutputText(&DataLine);
+                       dataLineProcessed = OutputText(&dataLine);
                
-                       *SaveData += DataLineProcessed;
+                       *saveData += dataLineProcessed;
 
-                       DataLine.clear();
-                       DataLineProcessed.clear();
+                       dataLine.clear();
+                       dataLineProcessed.clear();
                                
                }
                
@@ -1156,44 +1156,44 @@ void CalendarEventObject::SaveObjectData(string *SaveData){
        
        // Process the RDATE value.
        
-       if (RecurranceDateData.size() > 0){
+       if (recurranceDateData.size() > 0){
                
-               for (int RecurranceDateDataSeek = 0; RecurranceDateDataSeek < RecurranceDateData.size();
-                       RecurranceDateDataSeek++){
+               for (int recurranceDateDataSeek = 0; recurranceDateDataSeek < recurranceDateData.size();
+                       recurranceDateDataSeek++){
        
-                       DataLine += "RDATE";
+                       dataLine += "RDATE";
                        
-                       if (RecurranceDateDataValue[RecurranceDateDataSeek].size() > 0){
+                       if (recurranceDateDataValue[recurranceDateDataSeek].size() > 0){
                
-                               DataLine += ";VALUE=";
-                               DataLine += RecurranceDateDataValue[RecurranceDateDataSeek];
+                               dataLine += ";VALUE=";
+                               dataLine += recurranceDateDataValue[recurranceDateDataSeek];
                        
                        }
                                
-                       if (RecurranceDateDataTimeZoneParam[RecurranceDateDataSeek].size() > 0){
+                       if (recurranceDateDataTimeZoneParam[recurranceDateDataSeek].size() > 0){
                
-                               DataLine += ";TZID=";
-                               DataLine += RecurranceDateDataTimeZoneParam[RecurranceDateDataSeek];
+                               dataLine += ";TZID=";
+                               dataLine += recurranceDateDataTimeZoneParam[recurranceDateDataSeek];
                        
                        }
                        
-                       if (RecurranceDateDataTokens[RecurranceDateDataSeek].size() > 0){
+                       if (recurranceDateDataTokens[recurranceDateDataSeek].size() > 0){
                
-                               DataLine += ";";
-                               DataLine += RecurranceDateDataTokens[RecurranceDateDataSeek];
+                               dataLine += ";";
+                               dataLine += recurranceDateDataTokens[recurranceDateDataSeek];
                        
                        }
                                
-                       DataLine += ":";
-                       DataLine += RecurranceDateData[RecurranceDateDataSeek];
-                       DataLine += "\n";
+                       dataLine += ":";
+                       dataLine += recurranceDateData[recurranceDateDataSeek];
+                       dataLine += "\n";
                
-                       DataLineProcessed = OutputText(&DataLine);
+                       dataLineProcessed = OutputText(&dataLine);
                
-                       *SaveData += DataLineProcessed;
+                       *saveData += dataLineProcessed;
 
-                       DataLine.clear();
-                       DataLineProcessed.clear();
+                       dataLine.clear();
+                       dataLineProcessed.clear();
                                
                }
                
@@ -1201,318 +1201,318 @@ void CalendarEventObject::SaveObjectData(string *SaveData){
        
        // Process the VALARMS.
        
-       if (CalendarAlarmData.size() > 0){
+       if (calendarAlarmData.size() > 0){
                
-               for (int CalendarAlarmDataSeek = 0; CalendarAlarmDataSeek < CalendarAlarmData.size();
-                       CalendarAlarmDataSeek++){
+               for (int calendarAlarmDataSeek = 0; calendarAlarmDataSeek < calendarAlarmData.size();
+                       calendarAlarmDataSeek++){
                        
-                       *SaveData += "BEGIN:VALARM\n";
+                       *saveData += "BEGIN:VALARM\n";
                        
                        // Process the ACTION VALARM value.
                                
-                       DataLine += "ACTION";
+                       dataLine += "ACTION";
 
-                       if (CalendarAlarmData[CalendarAlarmDataSeek].AlarmActionTokens.size() > 0){
+                       if (calendarAlarmData[calendarAlarmDataSeek].alarmActionTokens.size() > 0){
                
-                               DataLine += ";";
-                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AlarmActionTokens;
+                               dataLine += ";";
+                               dataLine += calendarAlarmData[calendarAlarmDataSeek].alarmActionTokens;
                        
                        }
                                
-                       DataLine += ":";
-                       DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AlarmAction;
-                       DataLine += "\n";
+                       dataLine += ":";
+                       dataLine += calendarAlarmData[calendarAlarmDataSeek].alarmAction;
+                       dataLine += "\n";
                
-                       DataLineProcessed = OutputText(&DataLine);
+                       dataLineProcessed = OutputText(&dataLine);
                
-                       *SaveData += DataLineProcessed;
+                       *saveData += dataLineProcessed;
 
-                       DataLine.clear();
-                       DataLineProcessed.clear();
+                       dataLine.clear();
+                       dataLineProcessed.clear();
                        
                        // Process the TRIGGER VALARM value.
                        
-                       if (CalendarAlarmData[CalendarAlarmDataSeek].TriggerData.size() > 0){
+                       if (calendarAlarmData[calendarAlarmDataSeek].triggerData.size() > 0){
                                
-                               DataLine += "TRIGGER";
+                               dataLine += "TRIGGER";
                                
-                               if (CalendarAlarmData[CalendarAlarmDataSeek].TriggerRelated.size() > 0){
+                               if (calendarAlarmData[CalendarAlarmDataSeek].triggerRelated.size() > 0){
                
-                                       DataLine += ";RELATED=";
-                                       DataLine += CalendarAlarmData[CalendarAlarmDataSeek].TriggerRelated;
+                                       dataLine += ";RELATED=";
+                                       dataLine += calendarAlarmData[CalendarAlarmDataSeek].triggerRelated;
                        
                                }
                                
-                               if (CalendarAlarmData[CalendarAlarmDataSeek].TriggerValue.size() > 0){
+                               if (calendarAlarmData[calendarAlarmDataSeek].triggerValue.size() > 0){
                
-                                       DataLine += ";VALUE=";
-                                       DataLine += CalendarAlarmData[CalendarAlarmDataSeek].TriggerValue;
+                                       dataLine += ";VALUE=";
+                                       dataLine += calendarAlarmData[calendarAlarmDataSeek].triggerValue;
                        
                                }
                                
-                               if (CalendarAlarmData[CalendarAlarmDataSeek].TriggerTokens.size() > 0){
+                               if (calendarAlarmData[calendarAlarmDataSeek].triggerTokens.size() > 0){
                
-                                       DataLine += ";";
-                                       DataLine += CalendarAlarmData[CalendarAlarmDataSeek].TriggerTokens;
+                                       dataLine += ";";
+                                       dataLine += calendarAlarmData[calendarAlarmDataSeek].TriggerTokens;
                        
                                }
                                
-                               DataLine += ":";
-                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].TriggerData;
-                               DataLine += "\n";
+                               dataLine += ":";
+                               dataLine += calendarAlarmData[calendarAlarmDataSeek].triggerData;
+                               dataLine += "\n";
                
-                               DataLineProcessed = OutputText(&DataLine);
+                               dataLineProcessed = OutputText(&dataLine);
                
-                               *SaveData += DataLineProcessed;
+                               *saveData += dataLineProcessed;
 
-                               DataLine.clear();
-                               DataLineProcessed.clear();                              
+                               dataLine.clear();
+                               dataLineProcessed.clear();                              
                                
                        }
                        
                        // Process the DURATION VALARM value.
                        
-                       if (CalendarAlarmData[CalendarAlarmDataSeek].DurationData.size() > 0){
+                       if (calendarAlarmData[calendarAlarmDataSeek].durationData.size() > 0){
                                
-                               DataLine += "DURATION";
+                               dataLine += "DURATION";
                                
-                               if (CalendarAlarmData[CalendarAlarmDataSeek].DurationTokens.size() > 0){
+                               if (calendarAlarmData[calendarAlarmDataSeek].durationTokens.size() > 0){
                
-                                       DataLine += ";";
-                                       DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DurationTokens;
+                                       dataLine += ";";
+                                       dataLine += calendarAlarmData[CalendarAlarmDataSeek].durationTokens;
                        
                                }
                                
-                               DataLine += ":";
-                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DurationData;
-                               DataLine += "\n";
+                               dataLine += ":";
+                               dataLine += calendarAlarmData[calendarAlarmDataSeek].durationData;
+                               dataLine += "\n";
                
-                               DataLineProcessed = OutputText(&DataLine);
+                               dataLineProcessed = OutputText(&dataLine);
                
-                               *SaveData += DataLineProcessed;
+                               *saveData += dataLineProcessed;
 
-                               DataLine.clear();
-                               DataLineProcessed.clear();                              
+                               dataLine.clear();
+                               dataLineProcessed.clear();                              
                                
                        }
                        
                        // Process the DESCRIPTION VALARM value.
                        
-                       if (CalendarAlarmData[CalendarAlarmDataSeek].DescriptionData.size() > 0){
+                       if (calendarAlarmData[calendarAlarmDataSeek].descriptionData.size() > 0){
                                
-                               DataLine += "DESCRIPTION";
+                               dataLine += "DESCRIPTION";
 
-                               if (CalendarAlarmData[CalendarAlarmDataSeek].DescriptionAltRep.size() > 0){
+                               if (calendarAlarmData[calendarAlarmDataSeek].descriptionAltRep.size() > 0){
                
-                                       DataLine += ";ALTREP=\"";
-                                       DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DescriptionAltRep;
-                                       DataLine += "\"";
+                                       dataLine += ";ALTREP=\"";
+                                       dataLine += calendarAlarmData[calendarAlarmDataSeek].descriptionAltRep;
+                                       dataLine += "\"";
                        
                                }
                                
-                               if (CalendarAlarmData[CalendarAlarmDataSeek].DescriptionLanguage.size() > 0){
+                               if (calendarAlarmData[calendarAlarmDataSeek].descriptionLanguage.size() > 0){
                
-                                       DataLine += ";LANGUAGE=";
-                                       DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DescriptionLanguage;
+                                       dataLine += ";LANGUAGE=";
+                                       dataLine += calendarAlarmData[calendarAlarmDataSeek].descriptionLanguage;
                        
                                }
                                
-                               if (CalendarAlarmData[CalendarAlarmDataSeek].DescriptionTokens.size() > 0){
+                               if (calendarAlarmData[calendarAlarmDataSeek].descriptionTokens.size() > 0){
                
-                                       DataLine += ";";
-                                       DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DescriptionTokens;
+                                       dataLine += ";";
+                                       dataLine += calendarAlarmData[calendarAlarmDataSeek].descriptionTokens;
                        
                                }
                                
-                               DataLine += ":";
-                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].DescriptionData;
-                               DataLine += "\n";
+                               dataLine += ":";
+                               dataLine += calendarAlarmData[calendarAlarmDataSeek].descriptionData;
+                               dataLine += "\n";
                
-                               DataLineProcessed = OutputText(&DataLine);
+                               dataLineProcessed = OutputText(&dataLine);
                
-                               *SaveData += DataLineProcessed;
+                               *saveData += dataLineProcessed;
 
-                               DataLine.clear();
-                               DataLineProcessed.clear();                              
+                               dataLine.clear();
+                               dataLineProcessed.clear();                              
                                
                        }
                        
                        // Process the SUMMARY VALARM value.
                        
-                       if (CalendarAlarmData[CalendarAlarmDataSeek].SummaryData.size() > 0){
+                       if (calendarAlarmData[calendarAlarmDataSeek].summaryData.size() > 0){
                                
-                               DataLine += "SUMMARY";
+                               dataLine += "SUMMARY";
 
-                               if (CalendarAlarmData[CalendarAlarmDataSeek].SummaryAltRep.size() > 0){
+                               if (calendarAlarmData[calendarAlarmDataSeek].summaryAltRep.size() > 0){
                
-                                       DataLine += ";ALTREP=\"";
-                                       DataLine += CalendarAlarmData[CalendarAlarmDataSeek].SummaryAltRep;
-                                       DataLine += "\"";
+                                       dataLine += ";ALTREP=\"";
+                                       dataLine += calendarAlarmData[calendarAlarmDataSeek].summaryAltRep;
+                                       dataLine += "\"";
                        
                                }
                                
-                               if (CalendarAlarmData[CalendarAlarmDataSeek].SummaryLanguage.size() > 0){
+                               if (calendarAlarmData[calendarAlarmDataSeek].summaryLanguage.size() > 0){
                
-                                       DataLine += ";LANGUAGE=";
-                                       DataLine += CalendarAlarmData[CalendarAlarmDataSeek].SummaryLanguage;
+                                       dataLine += ";LANGUAGE=";
+                                       dataLine += calendarAlarmData[calendarAlarmDataSeek].summaryLanguage;
                        
                                }
                                
-                               if (CalendarAlarmData[CalendarAlarmDataSeek].SummaryTokens.size() > 0){
+                               if (calendarAlarmData[calendarAlarmDataSeek].summaryTokens.size() > 0){
                
-                                       DataLine += ";";
-                                       DataLine += CalendarAlarmData[CalendarAlarmDataSeek].SummaryTokens;
+                                       dataLine += ";";
+                                       dataLine += calendarAlarmData[calendarAlarmDataSeek].summaryTokens;
                        
                                }
                                
-                               DataLine += ":";
-                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].SummaryData;
-                               DataLine += "\n";
+                               dataLine += ":";
+                               dataLine += calendarAlarmData[calendarAlarmDataSeek].summaryData;
+                               dataLine += "\n";
                
-                               DataLineProcessed = OutputText(&DataLine);
+                               dataLineProcessed = OutputText(&dataLine);
                
-                               *SaveData += DataLineProcessed;
+                               *saveData += dataLineProcessed;
 
-                               DataLine.clear();
-                               DataLineProcessed.clear();                              
+                               dataLine.clear();
+                               dataLineProcessed.clear();                              
                                
                        }
                        
                        // Process the REPEAT VALARM value.
                        
-                       if (CalendarAlarmData[CalendarAlarmDataSeek].RepeatData.size() > 0){
+                       if (calendarAlarmData[calendarAlarmDataSeek].repeatData.size() > 0){
                                
-                               DataLine += "REPEAT";
+                               dataLine += "REPEAT";
                                
-                               if (CalendarAlarmData[CalendarAlarmDataSeek].RepeatTokens.size() > 0){
+                               if (calendarAlarmData[calendarAlarmDataSeek].repeatTokens.size() > 0){
                
-                                       DataLine += ";";
-                                       DataLine += CalendarAlarmData[CalendarAlarmDataSeek].RepeatTokens;
+                                       dataLine += ";";
+                                       dataLine += calendarAlarmData[calendarAlarmDataSeek].repeatTokens;
                        
                                }
                                
-                               DataLine += ":";
-                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].RepeatData;
-                               DataLine += "\n";
+                               dataLine += ":";
+                               dataLine += calendarAlarmData[calendarAlarmDataSeek].repeatData;
+                               dataLine += "\n";
                
-                               DataLineProcessed = OutputText(&DataLine);
+                               dataLineProcessed = OutputText(&dataLine);
                
-                               *SaveData += DataLineProcessed;
+                               *saveData += dataLineProcessed;
 
-                               DataLine.clear();
-                               DataLineProcessed.clear();                              
+                               dataLine.clear();
+                               dataLineProcessed.clear();                              
                                
                        }
                        
                        // Process the ATTENDEE VALARM values.
                        
-                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeList.size() > 0){
+                       if (calendarAlarmData[calendarAlarmDataSeek].attendeeList.size() > 0){
                
-                               for (int AttendeeListSeek = 0; AttendeeListSeek < CalendarAlarmData[CalendarAlarmDataSeek].AttendeeList.size();
-                                       AttendeeListSeek++){
+                               for (int attendeeListSeek = 0; attendeeListSeek < calendarAlarmData[calendarAlarmDataSeek].attendeeList.size();
+                                       attendeeListSeek++){
        
-                                       DataLine += "ATTENDEE";
+                                       dataLine += "ATTENDEE";
 
-                                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListMember[AttendeeListSeek].size() > 0){
+                                       if (calendarAlarmData[calendarAlarmDataSeek].attendeeListMember[attendeeListSeek].size() > 0){
                
-                                               DataLine += ";MEMBER=\"";
-                                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListMember[AttendeeListSeek];
-                                               DataLine += "\"";
+                                               dataLine += ";MEMBER=\"";
+                                               dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListMember[attendeeListSeek];
+                                               dataLine += "\"";
                        
                                        }
                        
-                                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDelegatedFrom[AttendeeListSeek].size() > 0){
+                                       if (calendarAlarmData[calendarAlarmDataSeek].attendeeListDelegatedFrom[attendeeListSeek].size() > 0){
                
-                                               DataLine += ";DELEGATED-FROM=\"";
-                                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDelegatedFrom[AttendeeListSeek];
-                                               DataLine += "\"";
+                                               dataLine += ";DELEGATED-FROM=\"";
+                                               dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListDelegatedFrom[attendeeListSeek];
+                                               dataLine += "\"";
                        
                                        }
 
-                                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDelegatedTo[AttendeeListSeek].size() > 0){
+                                       if (calendarAlarmData[calendarAlarmDataSeek].attendeeListDelegatedTo[attendeeListSeek].size() > 0){
                
-                                               DataLine += ";DELEGATED-TO=\"";
-                                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDelegatedTo[AttendeeListSeek];
-                                               DataLine += "\"";
+                                               dataLine += ";DELEGATED-TO=\"";
+                                               dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListDelegatedTo[attendeeListSeek];
+                                               dataLine += "\"";
                        
                                        }
 
-                                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListRole[AttendeeListSeek].size() > 0){
+                                       if (calendarAlarmData[calendarAlarmDataSeek].attendeeListRole[attendeeListSeek].size() > 0){
                
-                                               DataLine += ";ROLE=";
-                                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListRole[AttendeeListSeek];
+                                               dataLine += ";ROLE=";
+                                               dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListRole[attendeeListSeek];
                        
                                        }
                        
-                                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListRSVP[AttendeeListSeek].size() > 0){
+                                       if (calendarAlarmData[calendarAlarmDataSeek].attendeeListRSVP[attendeeListSeek].size() > 0){
                
-                                               DataLine += ";RSVP=";
-                                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListRSVP[AttendeeListSeek];
+                                               dataLine += ";RSVP=";
+                                               dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListRSVP[attendeeListSeek];
                        
                                        }
                        
-                                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDirectoryEntry[AttendeeListSeek].size() > 0){
+                                       if (calendarAlarmData[calendarAlarmDataSeek].attendeeListDirectoryEntry[attendeeListSeek].size() > 0){
                
-                                               DataLine += ";DIR=\"";
-                                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListDirectoryEntry[AttendeeListSeek];
-                                               DataLine += "\"";
+                                               dataLine += ";DIR=\"";
+                                               dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListDirectoryEntry[attendeeListSeek];
+                                               dataLine += "\"";
                        
                                        }
                        
-                                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListSentBy[AttendeeListSeek].size() > 0){
+                                       if (calendarAlarmData[calendarAlarmDataSeek].attendeeListSentBy[attendeeListSeek].size() > 0){
                                
-                                               DataLine += ";SENT-BY=\"";
-                                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListSentBy[AttendeeListSeek];
-                                               DataLine += "\"";
+                                               dataLine += ";SENT-BY=\"";
+                                               dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListSentBy[attendeeListSeek];
+                                               dataLine += "\"";
                                
                                        }
 
-                                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListCommonName[AttendeeListSeek].size() > 0){
+                                       if (calendarAlarmData[calendarAlarmDataSeek].attendeeListCommonName[attendeeListSeek].size() > 0){
                                
-                                               DataLine += ";CN=\"";
-                                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListCommonName[AttendeeListSeek];
-                                               DataLine += "\"";
+                                               dataLine += ";CN=\"";
+                                               dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListCommonName[attendeeListSeek];
+                                               dataLine += "\"";
                                
                                        }
 
-                                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListCalendarUserType[AttendeeListSeek].size() > 0){
+                                       if (calendarAlarmData[calendarAlarmDataSeek].attendeeListCalendarUserType[attendeeListSeek].size() > 0){
                                
-                                               DataLine += ";CUTYPE=";
-                                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListCalendarUserType[AttendeeListSeek];
+                                               dataLine += ";CUTYPE=";
+                                               dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListCalendarUserType[attendeeListSeek];
                                
                                        }
                        
-                                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListParticipationStatus[AttendeeListSeek].size() > 0){
+                                       if (calendarAlarmData[calendarAlarmDataSeek].attendeeListParticipationStatus[attendeeListSeek].size() > 0){
                                
-                                               DataLine += ";PARTSTAT=";
-                                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListParticipationStatus[AttendeeListSeek];
+                                               dataLine += ";PARTSTAT=";
+                                               dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListParticipationStatus[attendeeListSeek];
                                
                                        }
                        
-                                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListLanguage[AttendeeListSeek].size() > 0){
+                                       if (calendarAlarmData[calendarAlarmDataSeek].attendeeListLanguage[attendeeListSeek].size() > 0){
                                
-                                               DataLine += ";LANGUAGE=";
-                                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListLanguage[AttendeeListSeek];
+                                               dataLine += ";LANGUAGE=";
+                                               dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListLanguage[attendeeListSeek];
                                
                                        }
                        
-                                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListTokens[AttendeeListSeek].size() > 0){
+                                       if (calendarAlarmData[calendarAlarmDataSeek].attendeeListTokens[attendeeListSeek].size() > 0){
                
-                                               DataLine += ";";
-                                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeListTokens[AttendeeListSeek];
+                                               dataLine += ";";
+                                               dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeListTokens[attendeeListSeek];
                        
                                        }
                                
-                                       DataLine += ":";
-                                       DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttendeeList[AttendeeListSeek];
-                                       DataLine += "\n";
+                                       dataLine += ":";
+                                       dataLine += calendarAlarmData[calendarAlarmDataSeek].attendeeList[attendeeListSeek];
+                                       dataLine += "\n";
                
-                                       DataLineProcessed = OutputText(&DataLine);
+                                       dataLineProcessed = OutputText(&dataLine);
                
-                                       *SaveData += DataLineProcessed;
+                                       *saveData += dataLineProcessed;
 
-                                       DataLine.clear();
-                                       DataLineProcessed.clear();
+                                       dataLine.clear();
+                                       dataLineProcessed.clear();
                                
                                }
                        
@@ -1520,51 +1520,51 @@ void CalendarEventObject::SaveObjectData(string *SaveData){
                        
                        // Process the ATTACH VALARM values.
                        
-                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttachList.size() > 0){
+                       if (calendarAlarmData[calendarAlarmDataSeek].attachList.size() > 0){
                
-                               for (int AttachListSeek = 0; AttachListSeek < CalendarAlarmData[CalendarAlarmDataSeek].AttachList.size();
-                                       AttachListSeek++){
+                               for (int attachListSeek = 0; attachListSeek < calendarAlarmData[calendarAlarmDataSeek].attachList.size();
+                                       attachListSeek++){
        
-                                       DataLine += "ATTACH";
+                                       dataLine += "ATTACH";
                                                
-                                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttachListFormatType[AttachListSeek].size() > 0){
+                                       if (calendarAlarmData[calendarAlarmDataSeek].attachListFormatType[attachListSeek].size() > 0){
                
-                                               DataLine += ";FMTTYPE=";
-                                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttachListFormatType[AttachListSeek];
+                                               dataLine += ";FMTTYPE=";
+                                               dataLine += calendarAlarmData[calendarAlarmDataSeek].attachListFormatType[attachListSeek];
                        
                                        }
                                
-                                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttachListValue[AttachListSeek].size() > 0){
+                                       if (calendarAlarmData[calendarAlarmDataSeek].attachListValue[attachListSeek].size() > 0){
                
-                                               DataLine += ";VALUE=";
-                                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttachListValue[AttachListSeek];
+                                               dataLine += ";VALUE=";
+                                               dataLine += calendarAlarmData[calendarAlarmDataSeek].attachListValue[attachListSeek];
                        
                                        }
                                
-                                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttachListEncoding[AttachListSeek].size() > 0){
+                                       if (calendarAlarmData[calendarAlarmDataSeek].attachListEncoding[attachListSeek].size() > 0){
                
-                                               DataLine += ";ENCODING=";
-                                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttachListEncoding[AttachListSeek];
+                                               dataLine += ";ENCODING=";
+                                               dataLine += calendarAlarmData[calendarAlarmDataSeek].attachListEncoding[attachListSeek];
                        
                                        }
                                
-                                       if (CalendarAlarmData[CalendarAlarmDataSeek].AttachListTokens[AttachListSeek].size() > 0){
+                                       if (calendarAlarmData[calendarAlarmDataSeek].attachListTokens[attachListSeek].size() > 0){
                
-                                               DataLine += ";";
-                                               DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttachListTokens[AttachListSeek];
+                                               dataLine += ";";
+                                               dataLine += calendarAlarmData[calendarAlarmDataSeek].attachListTokens[attachListSeek];
                        
                                        }
                
-                                       DataLine += ":";
-                                       DataLine += CalendarAlarmData[CalendarAlarmDataSeek].AttachList[AttachListSeek];
-                                       DataLine += "\n";
+                                       dataLine += ":";
+                                       dataLine += calendarAlarmData[calendarAlarmDataSeek].attachList[attachListSeek];
+                                       dataLine += "\n";
                
-                                       DataLineProcessed = OutputText(&DataLine);
+                                       dataLineProcessed = OutputText(&dataLine);
                
-                                       *SaveData += DataLineProcessed;
+                                       *saveData += dataLineProcessed;
 
-                                       DataLine.clear();
-                                       DataLineProcessed.clear();
+                                       dataLine.clear();
+                                       dataLineProcessed.clear();
                                        
                                }
                                
@@ -1572,28 +1572,28 @@ void CalendarEventObject::SaveObjectData(string *SaveData){
                        
                        // Process the X-Token VALARM values.
                        
-                       if (CalendarAlarmData[CalendarAlarmDataSeek].XTokensData.size() > 0){
+                       if (calendarAlarmData[calendarAlarmDataSeek].xTokensData.size() > 0){
                                
-                               for (int XTokenSeek = 0; XTokenSeek < CalendarAlarmData[CalendarAlarmDataSeek].XTokensData.size();
-                                       XTokenSeek++){
+                               for (int xTokenSeek = 0; xTokenSeek < calendarAlarmData[calendarAlarmDataSeek].xTokensData.size();
+                                       xTokenSeek++){
        
-                                       DataLine += CalendarAlarmData[CalendarAlarmDataSeek].XTokensDataTokens[XTokenSeek];             
-                                       DataLine += ":";
-                                       DataLine += CalendarAlarmData[CalendarAlarmDataSeek].XTokensData[XTokenSeek];
-                                       DataLine += "\n";
+                                       dataLine += calendarAlarmData[calendarAlarmDataSeek].xTokensDataTokens[xTokenSeek];             
+                                       dataLine += ":";
+                                       dataLine += calendarAlarmData[calendarAlarmDataSeek].xTokensData[xTokenSeek];
+                                       dataLine += "\n";
                
-                                       DataLineProcessed = OutputText(&DataLine);
+                                       dataLineProcessed = OutputText(&dataLine);
                
-                                       *SaveData += DataLineProcessed;
+                                       *saveData += dataLineProcessed;
 
-                                       DataLine.clear();
-                                       DataLineProcessed.clear();
+                                       dataLine.clear();
+                                       dataLineProcessed.clear();
                                        
                                }
                                
                        }
                        
-                       *SaveData += "END:VALARM\n";
+                       *saveData += "END:VALARM\n";
                        
                }
                
@@ -1601,27 +1601,27 @@ void CalendarEventObject::SaveObjectData(string *SaveData){
        
        // Process the X-Token values.
        
-       if (XTokensData.size() > 0){
+       if (xTokensData.size() > 0){
                                
-               for (int XTokenSeek = 0; XTokenSeek < XTokensData.size();
-                       XTokenSeek++){
+               for (int xTokenSeek = 0; xTokenSeek < xTokensData.size();
+                       xTokenSeek++){
        
-                       DataLine += XTokensDataTokens[XTokenSeek];              
-                       DataLine += ":";
-                       DataLine += XTokensData[XTokenSeek];
-                       DataLine += "\n";
+                       dataLine += xTokensDataTokens[xTokenSeek];              
+                       dataLine += ":";
+                       dataLine += xTokensData[xTokenSeek];
+                       dataLine += "\n";
                
-                       DataLineProcessed = OutputText(&DataLine);
+                       dataLineProcessed = OutputText(&dataLine);
        
-                       *SaveData += DataLineProcessed;
+                       *saveData += dataLineProcessed;
 
-                       DataLine.clear();
-                       DataLineProcessed.clear();
+                       dataLine.clear();
+                       dataLineProcessed.clear();
                                        
                }
                                
        }
        
-       *SaveData += "END:VEVENT\n";
+       *saveData += "END:VEVENT\n";
        
 }
\ No newline at end of file
index 72e156c..1ca0345 100644 (file)
@@ -22,164 +22,164 @@ using namespace std;
 
 CalendarObjectValidResult CalendarEventObject::ValidObject(){
  
-       bool ValidBegin = false;
-       bool ValidEnd = false;
-       bool ValidDateTimeStamp = false;
-       bool ValidUniqueID = false;
-       bool ValidDateTimeStart = false;
-       int SeekCount = 0;
-       string PropertyName;
+       bool validBegin = false;
+       bool validEnd = false;
+       bool validDateTimeStamp = false;
+       bool validUniqueID = false;
+       bool validDateTimeStart = false;
+       int seekCount = 0;
+       string propertyName;
        
        // Look for BEGIN:VEVENT.
        
-       for (vector<string>::iterator iter = ObjectName.begin();
-               iter != ObjectName.end(); iter++){
+       for (vector<string>::iterator iter = objectName.begin();
+               iter != objectName.end(); iter++){
        
-               if (ObjectName[SeekCount] == "BEGIN" &&
-                       ObjectData[SeekCount] == "VEVENT"){
+               if (objectName[seekCount] == "BEGIN" &&
+                       objectData[seekCount] == "VEVENT"){
                        
-                       if (ValidBegin == false){
-                               ValidBegin = true;
+                       if (validBegin == false){
+                               validBegin = true;
                        } else {
                                return CALENDAROBJECTVALID_INVALIDFORMAT;
                        }
                                
                }
                
-               if (ObjectName[SeekCount] == "END" &&
-                       ObjectData[SeekCount] == "VEVENT" &&
-                       ValidBegin == false){
+               if (objectName[seekCount] == "END" &&
+                       objectData[seekCount] == "VEVENT" &&
+                       validBegin == false){
                
                        return CALENDAROBJECTVALID_INVALIDFORMAT;
                                
                }
                
-               SeekCount++;
+               seekCount++;
                        
        }
        
-       SeekCount = 0;
+       seekCount = 0;
        
        // Look for DTSTAMP.
        
-       for (vector<string>::iterator iter = ObjectName.begin();
-               iter != ObjectName.end(); iter++){
+       for (vector<string>::iterator iter = objectName.begin();
+               iter != objectName.end(); iter++){
                        
                try{
-                       PropertyName = ObjectName[SeekCount].substr(0,7);
+                       propertyName = objectName[seekCount].substr(0,7);
                }
                        
                catch(const out_of_range& oor){
                        continue;
                }
                
-               if (PropertyName == "DTSTAMP"){
+               if (propertyName == "DTSTAMP"){
                        
-                       if (ValidDateTimeStamp == false){
-                               ValidDateTimeStamp = true;
+                       if (validDateTimeStamp == false){
+                               validDateTimeStamp = true;
                        } else {
                                return CALENDAROBJECTVALID_INVALIDFORMAT;
                        }
                                
                }
                        
-               SeekCount++;
+               seekCount++;
                        
        }
        
-       SeekCount = 0;
+       seekCount = 0;
        
        // Look for UID.
        
-       for (vector<string>::iterator iter = ObjectName.begin();
-               iter != ObjectName.end(); iter++){
+       for (vector<string>::iterator iter = objectName.begin();
+               iter != objectName.end(); iter++){
        
                try{
-                       PropertyName = ObjectName[SeekCount].substr(0,3);
+                       propertyName = objectName[seekCount].substr(0,3);
                }
                
                catch(const out_of_range& oor){
                        continue;
                }
                        
-               if (PropertyName == "UID"){
+               if (propertyName == "UID"){
                        
-                       if (ValidUniqueID == false){
-                               ValidUniqueID = true;
+                       if (validUniqueID == false){
+                               validUniqueID = true;
                        } else {
                                return CALENDAROBJECTVALID_INVALIDFORMAT;
                        }
                                
                }
                        
-               SeekCount++;
+               seekCount++;
                        
        }
        
-       SeekCount = 0;
+       seekCount = 0;
        
        // Look for DTSTART if nothing is set for METHOD..
        
-       if (MethodData.size() == 0){
+       if (methodData.size() == 0){
        
-               for (vector<string>::iterator iter = ObjectName.begin();
-                       iter != ObjectName.end(); iter++){
+               for (vector<string>::iterator iter = objectName.begin();
+                       iter != objectName.end(); iter++){
                        
                        try{
-                               PropertyName = ObjectName[SeekCount].substr(0,7);
+                               propertyName = objectName[seekCount].substr(0,7);
                        }
                        
                        catch(const out_of_range& oor){
                                continue;
                        }
                
-                       if (PropertyName == "DTSTART"){
+                       if (propertyName == "DTSTART"){
                        
-                               if (ValidDateTimeStart == false){
-                                       ValidDateTimeStart = true;
+                               if (validDateTimeStart == false){
+                                       validDateTimeStart = true;
                                } else {
                                        return CALENDAROBJECTVALID_INVALIDFORMAT;
                                }
                                
                        }
                        
-                       SeekCount++;
+                       seekCount++;
                        
                }
        
        } else {
-               ValidDateTimeStart = true;
+               validDateTimeStart = true;
        }
        
-       SeekCount = 0;
+       seekCount = 0;
        
        // Look for END:VEVENT.
        
-       for (vector<string>::iterator iter = ObjectName.begin();
-               iter != ObjectName.end(); iter++){
+       for (vector<string>::iterator iter = objectName.begin();
+               iter != objectName.end(); iter++){
        
-               if (ObjectName[SeekCount] == "END" &&
-                       ObjectData[SeekCount] == "VEVENT"){
+               if (objectName[SeekCount] == "END" &&
+                       objectData[SeekCount] == "VEVENT"){
                        
-                       if (ValidEnd == false){
-                               ValidEnd = true;
+                       if (validEnd == false){
+                               validEnd = true;
                        } else {
                                return CALENDAROBJECTVALID_INVALIDFORMAT;
                        }
                                
                }
                        
-               SeekCount++;
+               seekCount++;
                        
        }
        
        // Check if the VEVENT is valid.
        
-       if (ValidBegin == true && 
-               ValidEnd == true && 
-               ValidDateTimeStamp == true &&
-               ValidDateTimeStart == true &&
-               ValidUniqueID == true){
+       if (validBegin == true && 
+               validEnd == true && 
+               validDateTimeStamp == true &&
+               validDateTimeStart == true &&
+               validUniqueID == true){
                
                return CALENDAROBJECTVALID_OK;
                        
@@ -195,341 +195,341 @@ void CalendarEventObject::ProcessData(){
        
        // Process the data.
        
-       multimap<string,string> DataReceived;
-       map<string,string> PropertyData;
-       string *PropertyNameData = nullptr;
-       int ObjectSeekCount = 0;
+       multimap<string,string> dataReceived;
+       map<string,string> propertyData;
+       string *propertyNameData = nullptr;
+       int objectSeekCount = 0;
        
        // Get the Date Time Stamp (DTSTAMP).
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "DTSTAMP");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "DTSTAMP");
        
        // Process the data from DTSTAMP.
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
                try {
-                       DateTimeStampTokens = DataReceived.begin()->first.substr(8);
+                       dateTimeStampTokens = dataReceived.begin()->first.substr(8);
                }
                
                catch(const out_of_range &oor){
                        // Do nothing as there is no data.
                }               
                
-               DateTimeStampData = DataReceived.begin()->second;
+               dateTimeStampData = dataReceived.begin()->second;
                
        }
 
        // Get the Unique ID (UID).
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "UID");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "UID");
        
        // Process the data from UID.
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
                try {
-                       UniqueIDTokens = DataReceived.begin()->first.substr(4);
+                       uniqueIDTokens = dataReceived.begin()->first.substr(4);
                }
                
                catch(const out_of_range &oor){
                        // Do nothing as there is no data.
                }               
                
-               UniqueID = DataReceived.begin()->second;
+               uniqueID = dataReceived.begin()->second;
                
        }
        
        // Get the Date Time Start value.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "DTSTART");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "DTSTART");
        
        // Process the data from DTSTART.
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
-               PropertyNameData = (string*)&DataReceived.begin()->first;
+               propertyNameData = (string*)&dataReceived.begin()->first;
                
-               PropertyData = SplitValues(*PropertyNameData);
+               propertyData = SplitValues(*propertyNameData);
                
-               for(map<string,string>::iterator iter = PropertyData.begin();
-                       iter != PropertyData.end(); iter++){
+               for(map<string,string>::iterator iter = propertyData.begin();
+                       iter != propertyData.end(); iter++){
                        
                        if (iter->first == "VALUE"){
                                
-                               DateTimeStartDataValue = iter->second;
+                               dateTimeStartDataValue = iter->second;
                                
                        } else if (iter->first == "TZID"){
                                
-                               DateTimeStartDataTimeZoneID = iter->second;
+                               dateTimeStartDataTimeZoneID = iter->second;
                                
                        } else {
                                
-                               if (TokenData == false){
-                                       TokenData = true;
+                               if (tokenData == false){
+                                       tokenData = true;
                                } else {
-                                       PropertyTokens += ";";
+                                       propertyTokens += ";";
                                }
                                
-                               PropertyTokens += iter->first;
-                               PropertyTokens += "=";
-                               PropertyTokens += iter->second;
+                               propertyTokens += iter->first;
+                               propertyTokens += "=";
+                               propertyTokens += iter->second;
                                
                        }
                                
                }
                
-               if (PropertyTokens.size() > 0){
-                       DateTimeStartDataTokens = PropertyTokens;
+               if (propertyTokens.size() > 0){
+                       dateTimeStartDataTokens = propertyTokens;
                }
                
-               DateTimeStartData = DataReceived.begin()->second;
+               dateTimeStartData = dataReceived.begin()->second;
                
        }
        
        // Process the data from CLASS.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "CLASS");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "CLASS");
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
                try {
-                       ClassDataTokens = DataReceived.begin()->first.substr(6);
+                       classDataTokens = dataReceived.begin()->first.substr(6);
                }
                
                catch(const out_of_range &oor){
                        // Do nothing as there is no data.
                }               
                
-               ClassData = DataReceived.begin()->second;
+               classData = dataReceived.begin()->second;
                
        }
        
        // Process the data from CREATED.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "CREATED");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "CREATED");
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
                try {
-                       DateTimeCreatedTokens = DataReceived.begin()->first.substr(8);
+                       dateTimeCreatedTokens = dataReceived.begin()->first.substr(8);
                }
                
                catch(const out_of_range &oor){
                        // Do nothing as there is no data.
                }               
                
-               DateTimeCreatedData = DataReceived.begin()->second;
+               dateTimeCreatedData = dataReceived.begin()->second;
                
        }
        
        // Process the data from DESCRIPTION.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "DESCRIPTION");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "DESCRIPTION");
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
-               PropertyNameData = (string*)&DataReceived.begin()->first;
+               propertyNameData = (string*)&dataReceived.begin()->first;
                
-               PropertyData = SplitValues(*PropertyNameData);
+               propertyData = SplitValues(*propertyNameData);
                
-               for(map<string,string>::iterator iter = PropertyData.begin();
-                       iter != PropertyData.end(); iter++){
+               for(map<string,string>::iterator iter = propertyData.begin();
+                       iter != propertyData.end(); iter++){
                        
                        if (iter->first == "ALTREP"){
                                
-                               DescriptionListAltRep.clear();
-                               DescriptionListAltRep.push_back(iter->second);
+                               descriptionListAltRep.clear();
+                               descriptionListAltRep.push_back(iter->second);
                                
                        } else if (iter->first == "LANGUAGE"){
                                
-                               DescriptionListLanguage.clear();
-                               DescriptionListLanguage.push_back(iter->second);
+                               descriptionListLanguage.clear();
+                               descriptionListLanguage.push_back(iter->second);
                                
                        } else {
                                
-                               if (TokenData == false){
-                                       TokenData = true;
+                               if (tokenData == false){
+                                       tokenData = true;
                                } else {
-                                       PropertyTokens += ";";
+                                       propertyTokens += ";";
                                }
                                
-                               PropertyTokens += iter->first;
-                               PropertyTokens += "=";
-                               PropertyTokens += iter->second;
+                               propertyTokens += iter->first;
+                               propertyTokens += "=";
+                               propertyTokens += iter->second;
                                
                        }
                                
                }
                
-               if (PropertyTokens.size() > 0){
-                       DescriptionListTokens.clear();
-                       DescriptionListTokens.push_back(PropertyTokens);
+               if (propertyTokens.size() > 0){
+                       descriptionListTokens.clear();
+                       descriptionListTokens.push_back(propertyTokens);
                }
                
-               DescriptionList.clear();
-               DescriptionList.push_back(DataReceived.begin()->second);
+               descriptionList.clear();
+               descriptionList.push_back(dataReceived.begin()->second);
                
        }
        
        // Process the data from GEO.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "GEO");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "GEO");
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
                try {
-                       GeographicTokens = DataReceived.begin()->first.substr(4);
+                       geographicTokens = dataReceived.begin()->first.substr(4);
                }
                
                catch(const out_of_range &oor){
                        // Do nothing as there is no data.
                }               
                
-               GeographicData = DataReceived.begin()->second;
+               geographicData = dataReceived.begin()->second;
                
        }
        
        // Process the data from LAST-MODIFIED.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "LAST-MODIFIED");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "LAST-MODIFIED");
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
                try {
-                       LastModifiedTokens = DataReceived.begin()->first.substr(14);
+                       lastModifiedTokens = dataReceived.begin()->first.substr(14);
                }
                
                catch(const out_of_range &oor){
                        // Do nothing as there is no data.
                }               
                
-               LastModifiedData = DataReceived.begin()->second;
+               lastModifiedData = dataReceived.begin()->second;
                
        }
        
        // Process the data from LOCATION.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "LOCATION");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "LOCATION");
        
        if (DataReceived.begin() != DataReceived.end()){
        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
-               PropertyNameData = (string*)&DataReceived.begin()->first;
+               propertyNameData = (string*)&dataReceived.begin()->first;
                
-               PropertyData = SplitValues(*PropertyNameData);
+               propertyData = SplitValues(*propertyNameData);
                
-               for(map<string,string>::iterator iter = PropertyData.begin();
-                       iter != PropertyData.end(); iter++){
+               for(map<string,string>::iterator iter = propertyData.begin();
+                       iter != propertyData.end(); iter++){
                        
                        if (iter->first == "ALTREP"){
                                
-                               LocationDataAltRep = iter->second;
+                               locationDataAltRep = iter->second;
                                
                        } else if (iter->first == "LANGUAGE"){
                                
-                               LocationDataLanguage = iter->second;
+                               locationDataLanguage = iter->second;
                                
                        } else {
                                
-                               if (TokenData == false){
-                                       TokenData = true;
+                               if (tokenData == false){
+                                       tokenData = true;
                                } else {
-                                       PropertyTokens += ";";
+                                       propertyTokens += ";";
                                }
                                
-                               PropertyTokens += iter->first;
-                               PropertyTokens += "=";
-                               PropertyTokens += iter->second;
+                               propertyTokens += iter->first;
+                               propertyTokens += "=";
+                               propertyTokens += iter->second;
                                
                        }
                                
                }
                
-               if (PropertyTokens.size() > 0){
+               if (propertyTokens.size() > 0){
                        
-                       LocationDataTokens = PropertyTokens;
+                       locationDataTokens = propertyTokens;
                        
                }
                
-               LocationData = DataReceived.begin()->second;
+               locationData = dataReceived.begin()->second;
                
        }
        
        // Process the data from ORGANIZER.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "ORGANIZER");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "ORGANIZER");
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
-               PropertyNameData = (string*)&DataReceived.begin()->first;
+               propertyNameData = (string*)&dataReceived.begin()->first;
                
-               PropertyData = SplitValues(*PropertyNameData);
+               propertyData = SplitValues(*propertyNameData);
                
-               for(map<string,string>::iterator iter = PropertyData.begin();
-                       iter != PropertyData.end(); iter++){
+               for(map<string,string>::iterator iter = propertyData.begin();
+                       iter != propertyData.end(); iter++){
                        
                        if (iter->first == "CN"){
                                
-                               OrganiserDataCommonName = iter->second;
+                               organiserDataCommonName = iter->second;
                                
                        } else if (iter->first == "DIR"){
                                
-                               OrganiserDataDirectoryEntry = iter->second;
+                               organiserDataDirectoryEntry = iter->second;
                                
                        } else if (iter->first == "SENT-BY"){
                                
-                               OrganiserDataSentByParam = iter->second;
+                               organiserDataSentByParam = iter->second;
                                
                        } else if (iter->first == "LANGUAGE"){
                                
-                               OrganiserDataLanguage = iter->second;
+                               organiserDataLanguage = iter->second;
                                
                        } else {
                                
-                               if (TokenData == false){
-                                       TokenData = true;
+                               if (tokenData == false){
+                                       tokenData = true;
                                } else {
-                                       PropertyTokens += ";";
+                                       propertyTokens += ";";
                                }
                                
-                               PropertyTokens += iter->first;
-                               PropertyTokens += "=";
-                               PropertyTokens += iter->second;
+                               propertyTokens += iter->first;
+                               propertyTokens += "=";
+                               propertyTokens += iter->second;
                                
                        }
                                
                }
                
-               if (PropertyTokens.size() > 0){
+               if (propertyTokens.size() > 0){
                        
-                       OrganiserDataTokens = PropertyTokens;
+                       organiserDataTokens = PropertyTokens;
                        
                }
                
-               OrganiserData = DataReceived.begin()->second;
+               organiserData = dataReceived.begin()->second;
                
        }
 
        // Process the data from PRIORITY.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "PRIORITY");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "PRIORITY");
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
                try {
-                       PriorityTokens = DataReceived.begin()->first.substr(9);
+                       priorityTokens = dataReceived.begin()->first.substr(9);
                }
                
                catch(const out_of_range &oor){
@@ -537,23 +537,23 @@ void CalendarEventObject::ProcessData(){
                }               
                
                try {
-                       PriorityData = stoi(DataReceived.begin()->second);
+                       priorityData = stoi(dataReceived.begin()->second);
                }
                
                catch(const invalid_argument &oor){
-                       PriorityTokens.clear();
+                       priorityTokens.clear();
                }
                
        }
        
        // Process the data from SEQUENCE.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "SEQUENCE");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "SEQUENCE");
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
                try {
-                       SequenceTokens = DataReceived.begin()->first.substr(9);
+                       sequenceTokens = dataReceived.begin()->first.substr(9);
                }
                
                catch(const out_of_range &oor){
@@ -561,281 +561,281 @@ void CalendarEventObject::ProcessData(){
                }               
                
                try {
-                       SequenceData = stoi(DataReceived.begin()->second);
+                       sequenceData = stoi(dataReceived.begin()->second);
                }
                
                catch(const invalid_argument &oor){
-                       SequenceTokens.clear();
+                       sequenceTokens.clear();
                }
                
        }
        
        // Process the data from STATUS.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "STATUS");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "STATUS");
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
-               PropertyNameData = (string*)&DataReceived.begin()->first;
+               propertyNameData = (string*)&dataReceived.begin()->first;
                
-               PropertyData = SplitValues(*PropertyNameData);
+               propertyData = SplitValues(*propertyNameData);
                
-               for(map<string,string>::iterator iter = PropertyData.begin();
-                       iter != PropertyData.end(); iter++){
+               for(map<string,string>::iterator iter = propertyData.begin();
+                       iter != propertyData.end(); iter++){
                        
                        if (iter->first == "LANGUAGE"){
                                
-                               StatusLanguage = iter->second;
+                               statusLanguage = iter->second;
                                
                        } else {
                                
-                               if (TokenData == false){
-                                       TokenData = true;
+                               if (tokenData == false){
+                                       tokenData = true;
                                } else {
-                                       PropertyTokens += ";";
+                                       propertyTokens += ";";
                                }
                                
-                               PropertyTokens += iter->first;
-                               PropertyTokens += "=";
-                               PropertyTokens += iter->second;
+                               propertyTokens += iter->first;
+                               propertyTokens += "=";
+                               propertyTokens += iter->second;
                                
                        }
                                
                }
                
-               if (PropertyTokens.size() > 0){
+               if (propertyTokens.size() > 0){
                        
-                       StatusTokens = PropertyTokens;
+                       statusTokens = propertyTokens;
                        
                }
                
-               StatusData = DataReceived.begin()->second;
+               statusData = DataReceived.begin()->second;
                
        }
        
        // Process the data from SUMMARY.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "SUMMARY");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "SUMMARY");
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
-               PropertyNameData = (string*)&DataReceived.begin()->first;
+               propertyNameData = (string*)&dataReceived.begin()->first;
                
-               PropertyData = SplitValues(*PropertyNameData);
+               propertyData = SplitValues(*propertyNameData);
                
-               for(map<string,string>::iterator iter = PropertyData.begin();
-                       iter != PropertyData.end(); iter++){
+               for(map<string,string>::iterator iter = propertyData.begin();
+                       iter != propertyData.end(); iter++){
                        
                        if (iter->first == "ALTREP"){
                                
-                               SummaryDataAltRep = iter->second;
+                               summaryDataAltRep = iter->second;
                                
                        } else if (iter->first == "LANGUAGE"){
                                
-                               SummaryDataLanguage = iter->second;
+                               summaryDataLanguage = iter->second;
                                
                        } else {
                                
-                               if (TokenData == false){
-                                       TokenData = true;
+                               if (tokenData == false){
+                                       tokenData = true;
                                } else {
-                                       PropertyTokens += ";";
+                                       propertyTokens += ";";
                                }
                                
-                               PropertyTokens += iter->first;
-                               PropertyTokens += "=";
-                               PropertyTokens += iter->second;
+                               propertyTokens += iter->first;
+                               propertyTokens += "=";
+                               propertyTokens += iter->second;
                                
                        }
                                
                }
                
-               if (PropertyTokens.size() > 0){
+               if (propertyTokens.size() > 0){
                        
-                       SummaryDataTokens = PropertyTokens;
+                       summaryDataTokens = propertyTokens;
                        
                }
                
-               SummaryData = DataReceived.begin()->second;
+               summaryData = dataReceived.begin()->second;
                
        }
        
        // Process the data from TRANSP.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "TRANSP");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "TRANSP");
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
                try {
-                       TimeTransparencyDataTokens = DataReceived.begin()->first.substr(7);
+                       timeTransparencyDataTokens = dataReceived.begin()->first.substr(7);
                }
                
                catch(const out_of_range &oor){
                        // Do nothing as there is no data.
                }               
                
-               TimeTransparencyData = DataReceived.begin()->second;
+               timeTransparencyData = dataReceived.begin()->second;
                
        }
        
        // Process the data from URL.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "URL");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "URL");
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
                try {
-                       URLDataTokens = DataReceived.begin()->first.substr(4);
+                       urlDataTokens = dataReceived.begin()->first.substr(4);
                }
                
                catch(const out_of_range &oor){
                        // Do nothing as there is no data.
                }               
                
-               URLData = DataReceived.begin()->second;
+               urlData = dataReceived.begin()->second;
                
        }
        
        // Process the data from RECURRENCE-ID.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "RECURRENCE-ID");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "RECURRENCE-ID");
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
-               PropertyNameData = (string*)&DataReceived.begin()->first;
+               propertyNameData = (string*)&dataReceived.begin()->first;
                
-               PropertyData = SplitValues(*PropertyNameData);
+               propertyData = SplitValues(*propertyNameData);
                
-               for(map<string,string>::iterator iter = PropertyData.begin();
-                       iter != PropertyData.end(); iter++){
+               for(map<string,string>::iterator iter = propertyData.begin();
+                       iter != propertyData.end(); iter++){
                        
                        if (iter->first == "TZID"){
                                
-                               RecurranceIDDataTimeZoneParam = iter->second;
+                               recurranceIDDataTimeZoneParam = iter->second;
                                
                        } else if (iter->first == "VALUE"){
                                
-                               RecurranceIDDataValue = iter->second;
+                               recurranceIDDataValue = iter->second;
                                
                        } else if (iter->first == "RANGE"){
                                
-                               RecurranceIDDataRangeParam = iter->second;
+                               recurranceIDDataRangeParam = iter->second;
                                
                        } else {
                                
-                               if (TokenData == false){
-                                       TokenData = true;
+                               if (tokenData == false){
+                                       tokenData = true;
                                } else {
-                                       PropertyTokens += ";";
+                                       propertyTokens += ";";
                                }
                                
-                               PropertyTokens += iter->first;
-                               PropertyTokens += "=";
-                               PropertyTokens += iter->second;
+                               propertyTokens += iter->first;
+                               propertyTokens += "=";
+                               propertyTokens += iter->second;
                                
                        }
                                
                }
                
-               if (PropertyTokens.size() > 0){
+               if (propertyTokens.size() > 0){
                        
-                       RecurranceIDDataTokens = PropertyTokens;
+                       recurranceIDDataTokens = propertyTokens;
                        
                }
                
-               RecurranceIDData = DataReceived.begin()->second;
+               recurranceIDData = dataReceived.begin()->second;
                
        }
        
        // Process the data from RRULE.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "RRULE");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "RRULE");
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
                try {
-                       RecurranceRuleDataTokens = DataReceived.begin()->first.substr(6);
+                       recurranceRuleDataTokens = dataReceived.begin()->first.substr(6);
                }
                
                catch(const out_of_range &oor){
                        // Do nothing as there is no data.
                }               
                
-               RecurranceRuleData = DataReceived.begin()->second;
+               recurranceRuleData = dataReceived.begin()->second;
                
        }
        
        // Process the data from DTEND.
        
-       bool DateTimeEndProcessed = false;
+       bool dateTimeEndProcessed = false;
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "DTEND");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, false, "DTEND");
        
-       if (DataReceived.begin() != DataReceived.end()){
+       if (dataReceived.begin() != dataReceived.end()){
        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
-               PropertyNameData = (string*)&DataReceived.begin()->first;
+               propertyNameData = (string*)&dataReceived.begin()->first;
                
-               PropertyData = SplitValues(*PropertyNameData);
+               propertyData = SplitValues(*propertyNameData);
                
-               for(map<string,string>::iterator iter = PropertyData.begin();
-                       iter != PropertyData.end(); iter++){
+               for(map<string,string>::iterator iter = propertyData.begin();
+                       iter != propertyData.end(); iter++){
                        
                        if (iter->first == "VALUE"){
                                
-                               DateTimeEndDataValue = iter->second;
+                               dateTimeEndDataValue = iter->second;
                                
                        } else if (iter->first == "TZID"){
                                
-                               DateTimeEndDataTimeZoneID = iter->second;
+                               dateTimeEndDataTimeZoneID = iter->second;
                                
                        } else {
                                
-                               if (TokenData == false){
-                                       TokenData = true;
+                               if (tokenData == false){
+                                       tokenData = true;
                                } else {
-                                       PropertyTokens += ";";
+                                       propertyTokens += ";";
                                }
                                
-                               PropertyTokens += iter->first;
-                               PropertyTokens += "=";
-                               PropertyTokens += iter->second;
+                               propertyTokens += iter->first;
+                               propertyTokens += "=";
+                               propertyTokens += iter->second;
                                
                        }
                                
                }
                
-               if (PropertyTokens.size() > 0){
-                       DateTimeEndDataTokens = PropertyTokens;
+               if (propertyTokens.size() > 0){
+                       dateTimeEndDataTokens = propertyTokens;
                }
                
-               DateTimeEndData = DataReceived.begin()->second;
+               dateTimeEndData = dataReceived.begin()->second;
                
-               DateTimeEndProcessed = true;
+               dateTimeEndProcessed = true;
                
        }
        
-       if (DateTimeEndProcessed == false){
+       if (dateTimeEndProcessed == false){
                
                // Process the data from DURATION if DTEND 
                // hasn't already been processed.
                
-               DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "DURATION");
+               dataReceived = ProcessTextVectors(&objectName, &objectData, false, "DURATION");
                
-               if (DataReceived.begin() != DataReceived.end()){
+               if (dataReceived.begin() != dataReceived.end()){
                
-                       DurationData = DataReceived.begin()->second;
+                       durationData = dataReceived.begin()->second;
                
                }
                
@@ -843,119 +843,119 @@ void CalendarEventObject::ProcessData(){
        
        // Process the data from ATTACH.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "ATTACH");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, true, "ATTACH");
        
-       for(multimap<string,string>::iterator iter = DataReceived.begin(); 
-               iter != DataReceived.end(); 
+       for(multimap<string,string>::iterator iter = dataReceived.begin(); 
+               iter != dataReceived.end(); 
                ++iter){
                
-               AttachListEncoding.push_back("");
-               AttachListValue.push_back("");
-               AttachListFormatType.push_back("");
-               AttachListTokens.push_back("");
-               AttachList.push_back("");
+               attachListEncoding.push_back("");
+               attachListValue.push_back("");
+               attachListFormatType.push_back("");
+               attachListTokens.push_back("");
+               attachList.push_back("");
                        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
-               PropertyNameData = (string*)&iter->first;
+               propertyNameData = (string*)&iter->first;
                
-               PropertyData = SplitValues(*PropertyNameData);
+               propertyData = SplitValues(*propertyNameData);
                        
-               for(map<string,string>::iterator dataiter = PropertyData.begin();
-                       dataiter != PropertyData.end(); dataiter++){
+               for(map<string,string>::iterator dataiter = propertyData.begin();
+                       dataiter != propertyData.end(); dataiter++){
                        
                        if (dataiter->first == "ENCODING"){
                                
-                               AttachListEncoding[ObjectSeekCount] = dataiter->second;
+                               attachListEncoding[objectSeekCount] = dataiter->second;
                                
                        } else if (dataiter->first == "VALUE"){
                                
-                               AttachListValue[ObjectSeekCount] = dataiter->second;
+                               attachListValue[objectSeekCount] = dataiter->second;
                                
                        } else if (dataiter->first == "FMTTYPE"){
                                
-                               AttachListFormatType[ObjectSeekCount] = dataiter->second;
+                               attachListFormatType[objectSeekCount] = dataiter->second;
                                
                        } else {
                                
-                               if (TokenData == false){
-                                       TokenData = true;
+                               if (tokenData == false){
+                                       tokenData = true;
                                } else {
-                                       PropertyTokens += ";";
+                                       propertyTokens += ";";
                                }
                                
-                               PropertyTokens += dataiter->first;
-                               PropertyTokens += "=";
-                               PropertyTokens += dataiter->second;
+                               propertyTokens += dataiter->first;
+                               propertyTokens += "=";
+                               propertyTokens += dataiter->second;
                                
                        }
                                
                }
                
-               if (PropertyTokens.size() > 0){
-                       AttachListTokens[ObjectSeekCount] = PropertyTokens;
+               if (propertyTokens.size() > 0){
+                       attachListTokens[objectSeekCount] = propertyTokens;
                }
                        
-               AttachList[ObjectSeekCount] = iter->second;
+               attachList[objectSeekCount] = iter->second;
                
-               ObjectSeekCount++;
+               objectSeekCount++;
                
        }
        
        // Process the data from ATTENDEE.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "ATTENDEE");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, true, "ATTENDEE");
        
-       ObjectSeekCount = 0;
+       objectSeekCount = 0;
        
-       for(multimap<string,string>::iterator iter = DataReceived.begin(); 
-               iter != DataReceived.end(); 
+       for(multimap<string,string>::iterator iter = dataReceived.begin(); 
+               iter != dataReceived.end(); 
                ++iter){
                        
-               AttendeeListMember.push_back("");
-               AttendeeListDelegatedFrom.push_back("");
-               AttendeeListDelegatedTo.push_back("");
-               AttendeeListRole.push_back("");
-               AttendeeListRSVP.push_back("");
-               AttendeeListDirectoryEntry.push_back("");
-               AttendeeListSentBy.push_back("");
-               AttendeeListCommonName.push_back("");
-               AttendeeListCalendarUserType.push_back("");
-               AttendeeListParticipationStatus.push_back("");
-               AttendeeListLanguage.push_back("");
-               AttendeeListTokens.push_back("");
-               AttendeeList.push_back("");
-                       
-               bool TokenData = false;
-               string PropertyTokens;
+               attendeeListMember.push_back("");
+               attendeeListDelegatedFrom.push_back("");
+               attendeeListDelegatedTo.push_back("");
+               attendeeListRole.push_back("");
+               attendeeListRSVP.push_back("");
+               attendeeListDirectoryEntry.push_back("");
+               attendeeListSentBy.push_back("");
+               attendeeListCommonName.push_back("");
+               attendeeListCalendarUserType.push_back("");
+               attendeeListParticipationStatus.push_back("");
+               attendeeListLanguage.push_back("");
+               attendeeListTokens.push_back("");
+               attendeeList.push_back("");
+                       
+               bool tokenData = false;
+               string propertyTokens;
                
-               PropertyNameData = (string*)&iter->first;
+               propertyNameData = (string*)&iter->first;
                
-               PropertyData = SplitValues(*PropertyNameData);
+               propertyData = SplitValues(*propertyNameData);
                        
-               for(map<string,string>::iterator dataiter = PropertyData.begin();
-                       dataiter != PropertyData.end(); dataiter++){
+               for(map<string,string>::iterator dataiter = propertyData.begin();
+                       dataiter != propertyData.end(); dataiter++){
                        
                        if (dataiter->first == "CUTYPE"){
                                
-                               AttendeeListCalendarUserType[ObjectSeekCount] = dataiter->second;
+                               attendeeListCalendarUserType[objectSeekCount] = dataiter->second;
                                
                        } else if (dataiter->first == "MEMBER"){
                                
-                               AttendeeListMember[ObjectSeekCount] = dataiter->second;
+                               attendeeListMember[objectSeekCount] = dataiter->second;
                                
                        } else if (dataiter->first == "ROLE"){
                                
-                               AttendeeListRole[ObjectSeekCount] = dataiter->second;
+                               attendeeListRole[objectSeekCount] = dataiter->second;
                                
                        } else if (dataiter->first == "PARTSTAT"){
                                
-                               AttendeeListParticipationStatus[ObjectSeekCount] = dataiter->second;
+                               attendeeListParticipationStatus[objectSeekCount] = dataiter->second;
                                
                        } else if (dataiter->first == "RSVP"){
                                
-                               AttendeeListRSVP[ObjectSeekCount] = dataiter->second;
+                               attendeeListRSVP[objectSeekCount] = dataiter->second;
                                
                        } else if (dataiter->first == "DELEGATED-TO"){
                                
@@ -963,351 +963,351 @@ void CalendarEventObject::ProcessData(){
                                
                        } else if (dataiter->first == "DELEGATED-FROM"){
                                
-                               AttendeeListDelegatedFrom[ObjectSeekCount] = dataiter->second;
+                               attendeeListDelegatedFrom[objectSeekCount] = dataiter->second;
                                
                        } else if (dataiter->first == "SENT-BY"){
                                
-                               AttendeeListSentBy[ObjectSeekCount] = dataiter->second;
+                               attendeeListSentBy[objectSeekCount] = dataiter->second;
                                
                        } else if (dataiter->first == "CN"){
                                
-                               AttendeeListCommonName[ObjectSeekCount] = dataiter->second;
+                               attendeeListCommonName[objectSeekCount] = dataiter->second;
                                
                        } else if (dataiter->first == "DIR"){
                                
-                               AttendeeListDirectoryEntry[ObjectSeekCount] = dataiter->second;
+                               attendeeListDirectoryEntry[objectSeekCount] = dataiter->second;
                                
                        } else if (dataiter->first == "LANGUAGE"){
                                
-                               AttendeeListLanguage[ObjectSeekCount] = dataiter->second;
+                               attendeeListLanguage[objectSeekCount] = dataiter->second;
                                
                        } else {
                                
-                               if (TokenData == false){
-                                       TokenData = true;
+                               if (tokenData == false){
+                                       tokenData = true;
                                } else {
-                                       PropertyTokens += ";";
+                                       propertyTokens += ";";
                                }
                                
-                               PropertyTokens += dataiter->first;
-                               PropertyTokens += "=";
-                               PropertyTokens += dataiter->second;
+                               propertyTokens += dataiter->first;
+                               propertyTokens += "=";
+                               propertyTokens += dataiter->second;
                                
                        }
                                
                }
                
-               if (PropertyTokens.size() > 0){
-                       AttendeeListTokens[ObjectSeekCount] = PropertyTokens;
+               if (propertyTokens.size() > 0){
+                       attendeeListTokens[objectSeekCount] = propertyTokens;
                }
                        
-               AttendeeList[ObjectSeekCount] = iter->second;
+               attendeeList[objectSeekCount] = iter->second;
                
-               ObjectSeekCount++;
+               objectSeekCount++;
                
        }
 
        // Process the data from CATEGORIES.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "CATEGORIES");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, true, "CATEGORIES");
        
-       ObjectSeekCount = 0;
+       objectSeekCount = 0;
        
-       for(multimap<string,string>::iterator iter = DataReceived.begin(); 
-               iter != DataReceived.end(); 
+       for(multimap<string,string>::iterator iter = dataReceived.begin(); 
+               iter != dataReceived.end(); 
                ++iter){
                
-               CategoriesListTokens.push_back("");
-               CategoriesListLanguage.push_back("");
-               CategoriesList.push_back("");
+               categoriesListTokens.push_back("");
+               categoriesListLanguage.push_back("");
+               categoriesList.push_back("");
                        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
-               PropertyNameData = (string*)&iter->first;
+               propertyNameData = (string*)&iter->first;
                
-               PropertyData = SplitValues(*PropertyNameData);
+               propertyData = SplitValues(*propertyNameData);
                        
-               for(map<string,string>::iterator dataiter = PropertyData.begin();
-                       dataiter != PropertyData.end(); dataiter++){
+               for(map<string,string>::iterator dataiter = propertyData.begin();
+                       dataiter != propertyData.end(); dataiter++){
                        
                        if (dataiter->first == "LANGUAGE"){
                                
-                               CategoriesListLanguage[ObjectSeekCount] = dataiter->second;
+                               categoriesListLanguage[objectSeekCount] = dataiter->second;
                                
                        } else {
                                
-                               if (TokenData == false){
-                                       TokenData = true;
+                               if (tokenData == false){
+                                       tokenData = true;
                                } else {
-                                       PropertyTokens += ";";
+                                       propertyTokens += ";";
                                }
                                
-                               PropertyTokens += dataiter->first;
-                               PropertyTokens += "=";
-                               PropertyTokens += dataiter->second;
+                               propertyTokens += dataiter->first;
+                               propertyTokens += "=";
+                               propertyTokens += dataiter->second;
                                
                        }
                                
                }
                
-               if (PropertyTokens.size() > 0){
-                       CategoriesListTokens[ObjectSeekCount] = PropertyTokens;
+               if (propertyTokens.size() > 0){
+                       categoriesListTokens[objectSeekCount] = propertyTokens;
                }
                        
-               CategoriesList[ObjectSeekCount] = iter->second;
+               categoriesList[objectSeekCount] = iter->second;
                
-               ObjectSeekCount++;
+               objectSeekCount++;
                
        }
        
        // Process the data from COMMENT.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "COMMENT");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, true, "COMMENT");
 
-       ObjectSeekCount = 0;
+       objectSeekCount = 0;
        
-       for(multimap<string,string>::iterator iter = DataReceived.begin(); 
-               iter != DataReceived.end(); 
+       for(multimap<string,string>::iterator iter = dataReceived.begin(); 
+               iter != dataReceived.end(); 
                ++iter){
                
-               CommentListTokens.push_back("");
-               CommentListAltRep.push_back("");
-               CommentListLanguage.push_back("");
-               CommentList.push_back("");
+               commentListTokens.push_back("");
+               commentListAltRep.push_back("");
+               commentListLanguage.push_back("");
+               commentList.push_back("");
                        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
-               PropertyNameData = (string*)&iter->first;
+               propertyNameData = (string*)&iter->first;
                
-               PropertyData = SplitValues(*PropertyNameData);
+               propertyData = SplitValues(*propertyNameData);
                        
-               for(map<string,string>::iterator dataiter = PropertyData.begin();
-                       dataiter != PropertyData.end(); dataiter++){
+               for(map<string,string>::iterator dataiter = propertyData.begin();
+                       dataiter != propertyData.end(); dataiter++){
                        
                        if (dataiter->first == "ALTREP"){
                                
-                               CommentListAltRep[ObjectSeekCount] = dataiter->second;
+                               commentListAltRep[objectSeekCount] = dataiter->second;
                                
                        } else if (dataiter->first == "LANGUAGE"){
                                
-                               CommentListLanguage[ObjectSeekCount] = dataiter->second;
+                               commentListLanguage[objectSeekCount] = dataiter->second;
                                
                        } else {
                                
-                               if (TokenData == false){
-                                       TokenData = true;
+                               if (tokenData == false){
+                                       tokenData = true;
                                } else {
-                                       PropertyTokens += ";";
+                                       propertyTokens += ";";
                                }
                                
-                               PropertyTokens += dataiter->first;
-                               PropertyTokens += "=";
-                               PropertyTokens += dataiter->second;
+                               propertyTokens += dataiter->first;
+                               propertyTokens += "=";
+                               propertyTokens += dataiter->second;
                                
                        }
                                
                }
                
-               if (PropertyTokens.size() > 0){
-                       CommentListTokens[ObjectSeekCount] = PropertyTokens;
+               if (propertyTokens.size() > 0){
+                       commentListTokens[objectSeekCount] = propertyTokens;
                }
                        
-               CommentList[ObjectSeekCount] = iter->second;
+               commentList[objectSeekCount] = iter->second;
                
-               ObjectSeekCount++;
+               objectSeekCount++;
                
        }
        
        // Process the data from CONTACT.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "CONTACT");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, true, "CONTACT");
 
-       ObjectSeekCount = 0;
+       objectSeekCount = 0;
        
-       for(multimap<string,string>::iterator iter = DataReceived.begin(); 
-               iter != DataReceived.end(); 
+       for(multimap<string,string>::iterator iter = dataReceived.begin(); 
+               iter != dataReceived.end(); 
                ++iter){
                
-               ContactListTokens.push_back("");
-               ContactListAltRep.push_back("");
-               ContactListLanguage.push_back("");
-               ContactList.push_back("");
+               contactListTokens.push_back("");
+               contactListAltRep.push_back("");
+               contactListLanguage.push_back("");
+               contactList.push_back("");
                        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
-               PropertyNameData = (string*)&iter->first;
+               propertyNameData = (string*)&iter->first;
                
-               PropertyData = SplitValues(*PropertyNameData);
+               propertyData = SplitValues(*propertyNameData);
                        
-               for(map<string,string>::iterator dataiter = PropertyData.begin();
-                       dataiter != PropertyData.end(); dataiter++){
+               for(map<string,string>::iterator dataiter = propertyData.begin();
+                       dataiter != propertyData.end(); dataiter++){
                        
                        if (dataiter->first == "ALTREP"){
                                
-                               ContactListAltRep[ObjectSeekCount] = dataiter->second;
+                               contactListAltRep[objectSeekCount] = dataiter->second;
                                
                        } else if (dataiter->first == "LANGUAGE"){
                                
-                               ContactListLanguage[ObjectSeekCount] = dataiter->second;
+                               contactListLanguage[objectSeekCount] = dataiter->second;
                                
                        } else {
                                
-                               if (TokenData == false){
-                                       TokenData = true;
+                               if (tokenData == false){
+                                       tokenData = true;
                                } else {
-                                       PropertyTokens += ";";
+                                       propertyTokens += ";";
                                }
                                
-                               PropertyTokens += dataiter->first;
-                               PropertyTokens += "=";
-                               PropertyTokens += dataiter->second;
+                               propertyTokens += dataiter->first;
+                               propertyTokens += "=";
+                               propertyTokens += dataiter->second;
                                
                        }
                                
                }
                
-               if (PropertyTokens.size() > 0){
-                       ContactListTokens[ObjectSeekCount] = PropertyTokens;
+               if (propertyTokens.size() > 0){
+                       contactListTokens[objectSeekCount] = propertyTokens;
                }
                        
-               ContactList[ObjectSeekCount] = iter->second;
+               contactList[objectSeekCount] = iter->second;
                
-               ObjectSeekCount++;
+               objectSeekCount++;
                
        }
        
        // Process the data from EXDATE.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "EXDATE");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, true, "EXDATE");
 
-       ObjectSeekCount = 0;
+       objectSeekCount = 0;
        
-       for(multimap<string,string>::iterator iter = DataReceived.begin(); 
-               iter != DataReceived.end(); 
+       for(multimap<string,string>::iterator iter = dataReceived.begin(); 
+               iter != dataReceived.end(); 
                ++iter){
                
-               ExcludeDateDataTokens.push_back("");
-               ExcludeDateDataValue.push_back("");
-               ExcludeDateDataTimeZoneParam.push_back("");
-               ExcludeDateData.push_back("");
+               excludeDateDataTokens.push_back("");
+               excludeDateDataValue.push_back("");
+               excludeDateDataTimeZoneParam.push_back("");
+               excludeDateData.push_back("");
                        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
-               PropertyNameData = (string*)&iter->first;
+               propertyNameData = (string*)&iter->first;
                
-               PropertyData = SplitValues(*PropertyNameData);
+               propertyData = SplitValues(*propertyNameData);
                        
-               for(map<string,string>::iterator dataiter = PropertyData.begin();
-                       dataiter != PropertyData.end(); dataiter++){
+               for(map<string,string>::iterator dataiter = propertyData.begin();
+                       dataiter != propertyData.end(); dataiter++){
                        
                        if (dataiter->first == "VALUE"){
                                
-                               ExcludeDateDataValue[ObjectSeekCount] = dataiter->second;
+                               excludeDateDataValue[objectSeekCount] = dataiter->second;
                                
                        } else if (dataiter->first == "TZID"){
                                
-                               ExcludeDateDataTimeZoneParam[ObjectSeekCount] = dataiter->second;
+                               excludeDateDataTimeZoneParam[objectSeekCount] = dataiter->second;
                                
                        } else {
                                
-                               if (TokenData == false){
-                                       TokenData = true;
+                               if (tokenData == false){
+                                       tokenData = true;
                                } else {
-                                       PropertyTokens += ";";
+                                       propertyTokens += ";";
                                }
                                
-                               PropertyTokens += dataiter->first;
-                               PropertyTokens += "=";
-                               PropertyTokens += dataiter->second;
+                               propertyTokens += dataiter->first;
+                               propertyTokens += "=";
+                               propertyTokens += dataiter->second;
                                
                        }
                                
                }
                
-               if (PropertyTokens.size() > 0){
-                       ExcludeDateDataTokens[ObjectSeekCount] = PropertyTokens;
+               if (propertyTokens.size() > 0){
+                       excludeDateDataTokens[objectSeekCount] = propertyTokens;
                }
                        
-               ExcludeDateData[ObjectSeekCount] = iter->second;
+               excludeDateData[objectSeekCount] = iter->second;
                
-               ObjectSeekCount++;
+               objectSeekCount++;
                
        }
        
        // Process the data from REQUEST-STATUS.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "REQUEST-STATUS");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, true, "REQUEST-STATUS");
 
-       ObjectSeekCount = 0;
+       objectSeekCount = 0;
        
-       for(multimap<string,string>::iterator iter = DataReceived.begin(); 
-               iter != DataReceived.end(); 
+       for(multimap<string,string>::iterator iter = dataReceived.begin(); 
+               iter != dataReceived.end(); 
                ++iter){
                
-               RequestStatusTokens.push_back("");
-               RequestStatusLanguage.push_back("");
-               RequestStatusData.push_back("");
+               requestStatusTokens.push_back("");
+               requestStatusLanguage.push_back("");
+               requestStatusData.push_back("");
                        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
-               PropertyNameData = (string*)&iter->first;
+               propertyNameData = (string*)&iter->first;
                
-               PropertyData = SplitValues(*PropertyNameData);
+               propertyData = SplitValues(*propertyNameData);
                        
-               for(map<string,string>::iterator dataiter = PropertyData.begin();
-                       dataiter != PropertyData.end(); dataiter++){
+               for(map<string,string>::iterator dataiter = propertyData.begin();
+                       dataiter != propertyData.end(); dataiter++){
                        
                        if (dataiter->first == "LANGUAGE"){
                                
-                               RequestStatusLanguage[ObjectSeekCount] = dataiter->second;
+                               requestStatusLanguage[objectSeekCount] = dataiter->second;
                                
                        } else {
                                
-                               if (TokenData == false){
-                                       TokenData = true;
+                               if (tokenData == false){
+                                       tokenData = true;
                                } else {
-                                       PropertyTokens += ";";
+                                       propertyTokens += ";";
                                }
                                
-                               PropertyTokens += dataiter->first;
-                               PropertyTokens += "=";
-                               PropertyTokens += dataiter->second;
+                               propertyTokens += dataiter->first;
+                               propertyTokens += "=";
+                               propertyTokens += dataiter->second;
                                
                        }
                                
                }
                
-               if (PropertyTokens.size() > 0){
-                       RequestStatusTokens[ObjectSeekCount] = PropertyTokens;
+               if (propertyTokens.size() > 0){
+                       requestStatusTokens[objectSeekCount] = propertyTokens;
                }
                        
-               RequestStatusData[ObjectSeekCount] = iter->second;
+               requestStatusData[objectSeekCount] = iter->second;
                
-               ObjectSeekCount++;
+               objectSeekCount++;
                
        }
        
        // Process the data from RELATED-TO.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "RELATED-TO");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, true, "RELATED-TO");
 
-       ObjectSeekCount = 0;
+       objectSeekCount = 0;
        
-       for(multimap<string,string>::iterator iter = DataReceived.begin(); 
-               iter != DataReceived.end(); 
+       for(multimap<string,string>::iterator iter = dataReceived.begin(); 
+               iter != dataReceived.end(); 
                ++iter){
                
-               RelatedToDataTokens.push_back("");
-               RelatedToDataRelationType.push_back("");
-               RelatedToData.push_back("");
+               relatedToDataTokens.push_back("");
+               relatedToDataRelationType.push_back("");
+               relatedToData.push_back("");
                        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
                PropertyNameData = (string*)&iter->first;
                
@@ -1348,166 +1348,166 @@ void CalendarEventObject::ProcessData(){
 
        // Process the data from RESOURCES.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "RESOURCES");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, true, "RESOURCES");
 
-       ObjectSeekCount = 0;
+       objectSeekCount = 0;
        
-       for(multimap<string,string>::iterator iter = DataReceived.begin(); 
-               iter != DataReceived.end(); 
+       for(multimap<string,string>::iterator iter = dataReceived.begin(); 
+               iter != dataReceived.end(); 
                ++iter){
                
-               ResourcesDataTokens.push_back("");
-               ResourcesDataAltRep.push_back("");
-               ResourcesDataLanguage.push_back("");
-               ResourcesData.push_back("");
+               resourcesDataTokens.push_back("");
+               resourcesDataAltRep.push_back("");
+               resourcesDataLanguage.push_back("");
+               resourcesData.push_back("");
                        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
-               PropertyNameData = (string*)&iter->first;
+               propertyNameData = (string*)&iter->first;
                
-               PropertyData = SplitValues(*PropertyNameData);
+               propertyData = SplitValues(*propertyNameData);
                        
-               for(map<string,string>::iterator dataiter = PropertyData.begin();
-                       dataiter != PropertyData.end(); dataiter++){
+               for(map<string,string>::iterator dataiter = propertyData.begin();
+                       dataiter != propertyData.end(); dataiter++){
                        
                        if (dataiter->first == "ALTREP"){
                                
-                               ResourcesDataAltRep[ObjectSeekCount] = dataiter->second;
+                               resourcesDataAltRep[objectSeekCount] = dataiter->second;
                                
                        } else if (dataiter->first == "LANGUAGE"){
                                
-                               ResourcesDataLanguage[ObjectSeekCount] = dataiter->second;
+                               resourcesDataLanguage[objectSeekCount] = dataiter->second;
                                
                        } else {
                                
-                               if (TokenData == false){
-                                       TokenData = true;
+                               if (tokenData == false){
+                                       tokenData = true;
                                } else {
-                                       PropertyTokens += ";";
+                                       propertyTokens += ";";
                                }
                                
-                               PropertyTokens += dataiter->first;
-                               PropertyTokens += "=";
-                               PropertyTokens += dataiter->second;
+                               propertyTokens += dataiter->first;
+                               propertyTokens += "=";
+                               propertyTokens += dataiter->second;
                                
                        }
                                
                }
                
-               if (PropertyTokens.size() > 0){
-                       ResourcesDataTokens[ObjectSeekCount] = PropertyTokens;
+               if (propertyTokens.size() > 0){
+                       resourcesDataTokens[objectSeekCount] = propertyTokens;
                }
                        
-               ResourcesData[ObjectSeekCount] = iter->second;
+               resourcesData[objectSeekCount] = iter->second;
                
-               ObjectSeekCount++;
+               objectSeekCount++;
                
        }
        
        // Process the data from RDATE.
        
-       DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "RDATE");
+       dataReceived = ProcessTextVectors(&objectName, &objectData, true, "RDATE");
 
-       ObjectSeekCount = 0;
+       objectSeekCount = 0;
        
-       for(multimap<string,string>::iterator iter = DataReceived.begin(); 
-               iter != DataReceived.end(); 
+       for(multimap<string,string>::iterator iter = dataReceived.begin(); 
+               iter != dataReceived.end(); 
                ++iter){
                
-               RecurranceDateDataTokens.push_back("");
-               RecurranceDateDataValue.push_back("");
-               RecurranceDateDataTimeZoneParam.push_back("");
-               RecurranceDateData.push_back("");
+               recurranceDateDataTokens.push_back("");
+               recurranceDateDataValue.push_back("");
+               recurranceDateDataTimeZoneParam.push_back("");
+               recurranceDateData.push_back("");
                        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
-               PropertyNameData = (string*)&iter->first;
+               propertyNameData = (string*)&iter->first;
                
-               PropertyData = SplitValues(*PropertyNameData);
+               propertyData = SplitValues(*propertyNameData);
                        
-               for(map<string,string>::iterator dataiter = PropertyData.begin();
-                       dataiter != PropertyData.end(); dataiter++){
+               for(map<string,string>::iterator dataiter = propertyData.begin();
+                       dataiter != propertyData.end(); dataiter++){
                        
                        if (dataiter->first == "VALUE"){
                                
-                               RecurranceDateDataValue[ObjectSeekCount] = dataiter->second;
+                               recurranceDateDataValue[objectSeekCount] = dataiter->second;
                                
                        } else if (dataiter->first == "TZID"){
                                
-                               RecurranceDateDataTimeZoneParam[ObjectSeekCount] = dataiter->second;
+                               recurranceDateDataTimeZoneParam[objectSeekCount] = dataiter->second;
                                
                        } else {
                                
-                               if (TokenData == false){
-                                       TokenData = true;
+                               if (tokenData == false){
+                                       tokenData = true;
                                } else {
-                                       PropertyTokens += ";";
+                                       propertyTokens += ";";
                                }
                                
-                               PropertyTokens += dataiter->first;
-                               PropertyTokens += "=";
-                               PropertyTokens += dataiter->second;
+                               propertyTokens += dataiter->first;
+                               propertyTokens += "=";
+                               propertyTokens += dataiter->second;
                                
                        }
                                
                }
                
-               if (PropertyTokens.size() > 0){
-                       RecurranceDateDataTokens[ObjectSeekCount] = PropertyTokens;
+               if (propertyTokens.size() > 0){
+                       recurranceDateDataTokens[objectSeekCount] = propertyTokens;
                }
                        
-               RecurranceDateData[ObjectSeekCount] = iter->second;
+               recurranceDateData[objectSeekCount] = iter->second;
                
-               ObjectSeekCount++;
+               objectSeekCount++;
                
        }
        
        // Process VALARM section.
        
-       int SeekCount = 0;
-       int AlarmObjectCount = 0;
+       int seekCount = 0;
+       int alarmObjectCount = 0;
        
-       bool AlarmActionFound = false;
+       bool alarmActionFound = false;
        
-       for (vector<vector<string>>::iterator iter = EventAlarmName.begin();
-               iter != EventAlarmName.end(); iter++){
+       for (vector<vector<string>>::iterator iter = eventAlarmName.begin();
+               iter != eventAlarmName.end(); iter++){
                        
-               CalendarAlarmDataStruct NewAlarmData;
+               CalendarAlarmDataStruct newAlarmData;
                        
                // Process the data from ACTION.
        
-               bool AlarmActionFound = false;
-               bool AlarmTriggerFound = false;
-               bool AlarmDurationFound = false;
-               bool AlarmDescriptionFound = false;
-               bool AlarmSummaryFound = false;
+               bool alarmActionFound = false;
+               bool alarmTriggerFound = false;
+               bool alarmDurationFound = false;
+               bool alarmDescriptionFound = false;
+               bool alarmSummaryFound = false;
                        
-               DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], 
-                               &EventAlarmData[SeekCount], false, "ACTION");
+               dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], 
+                               &eventAlarmData[seekCount], false, "ACTION");
        
-               if (DataReceived.begin() != DataReceived.end()){
+               if (dataReceived.begin() != dataReceived.end()){
        
                        try {
-                               NewAlarmData.AlarmActionTokens = DataReceived.begin()->first.substr(7);
+                               newAlarmData.alarmActionTokens = dataReceived.begin()->first.substr(7);
                        }
                
                        catch(const out_of_range &oor){
                                // Do nothing as there is no data.
                        }
                
-                       NewAlarmData.AlarmAction = DataReceived.begin()->second;
-                       AlarmActionFound = true;
+                       newAlarmData.alarmAction = dataReceived.begin()->second;
+                       alarmActionFound = true;
                
                }
                
                // Check if a value was set for AlarmAction, otherwise
                // process the next VALARM section.
                
-               if (NewAlarmData.AlarmAction.size() < 1){
+               if (newAlarmData.alarmAction.size() < 1){
                        
-                       SeekCount++;
+                       seekCount++;
                        continue;
                        
                }
@@ -1515,453 +1515,453 @@ void CalendarEventObject::ProcessData(){
                // Check if AlarmAction is DISPLAY, AUDIO or EMAIL.
                // Process the next VALARM section if not.
                
-               if (NewAlarmData.AlarmAction == "AUDIO"){
+               if (newAlarmData.alarmAction == "AUDIO"){
                        
-                       NewAlarmData.AlarmType = CALENDARALARM_AUDIO;
+                       newAlarmData.alarmType = CALENDARALARM_AUDIO;
                        
-               } else if (NewAlarmData.AlarmAction == "DISPLAY"){
+               } else if (newAlarmData.alarmAction == "DISPLAY"){
                        
-                       NewAlarmData.AlarmType = CALENDARALARM_DISPLAY;
+                       newAlarmData.alarmType = CALENDARALARM_DISPLAY;
                        
-               } else if (NewAlarmData.AlarmAction == "EMAIL"){
+               } else if (newAlarmData.alarmAction == "EMAIL"){
                        
-                       NewAlarmData.AlarmType = CALENDARALARM_EMAIL;
+                       newAlarmData.alarmType = CALENDARALARM_EMAIL;
                        
                } else {
                
-                       SeekCount++;
+                       seekCount++;
                        continue;
                        
                }
                
                // Process the data from TRIGGER.
                
-               DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], false, "TRIGGER");
+               dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], false, "TRIGGER");
        
-               if (DataReceived.begin() != DataReceived.end()){
+               if (dataReceived.begin() != dataReceived.end()){
        
-                       bool TokenData = false;
-                       string PropertyTokens;
+                       bool tokenData = false;
+                       string propertyTokens;
                
-                       PropertyNameData = (string*)&DataReceived.begin()->first;
+                       propertyNameData = (string*)&dataReceived.begin()->first;
                
-                       PropertyData = SplitValues(*PropertyNameData);
+                       propertyData = SplitValues(*propertyNameData);
                
-                       for(map<string,string>::iterator iter = PropertyData.begin();
-                               iter != PropertyData.end(); iter++){
+                       for(map<string,string>::iterator iter = propertyData.begin();
+                               iter != propertyData.end(); iter++){
                        
                                if (iter->first == "VALUE"){
                                
-                                       NewAlarmData.TriggerValue = iter->second;
+                                       newAlarmData.triggerValue = iter->second;
                                
                                } else if (iter->first == "RELATED"){
                                
-                                       NewAlarmData.TriggerRelated = iter->second;
+                                       newAlarmData.triggerRelated = iter->second;
                                
                                } else {
                                
-                                       if (TokenData == false){
-                                               TokenData = true;
+                                       if (tokenData == false){
+                                               tokenData = true;
                                        } else {
-                                               PropertyTokens += ";";
+                                               propertyTokens += ";";
                                        }
                                
-                                       PropertyTokens += iter->first;
-                                       PropertyTokens += "=";
-                                       PropertyTokens += iter->second;
+                                       propertyTokens += iter->first;
+                                       propertyTokens += "=";
+                                       propertyTokens += iter->second;
                                
                                }
                                
                        }
                
-                       if (PropertyTokens.size() > 0){
-                               NewAlarmData.TriggerTokens = PropertyTokens;
+                       if (propertyTokens.size() > 0){
+                               newAlarmData.triggerTokens = propertyTokens;
                        }
                
-                       NewAlarmData.TriggerData = DataReceived.begin()->second;
-                       AlarmTriggerFound = true;
+                       newAlarmData.triggerData = dataReceived.begin()->second;
+                       alarmTriggerFound = true;
                
                }
                
                // Process the data from DESCRIPTION.
                
-               DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], false, "DESCRIPTION");
+               dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], false, "DESCRIPTION");
        
-               if (DataReceived.begin() != DataReceived.end() &&
-                       (NewAlarmData.AlarmType == CALENDARALARM_DISPLAY ||
-                       NewAlarmData.AlarmType == CALENDARALARM_EMAIL)){
+               if (dataReceived.begin() != dataReceived.end() &&
+                       (newAlarmData.alarmType == CALENDARALARM_DISPLAY ||
+                       newAlarmData.alarmType == CALENDARALARM_EMAIL)){
        
-                       bool TokenData = false;
-                       string PropertyTokens;
+                       bool tokenData = false;
+                       string propertyTokens;
                
-                       PropertyNameData = (string*)&DataReceived.begin()->first;
+                       propertyNameData = (string*)&dataReceived.begin()->first;
                
-                       PropertyData = SplitValues(*PropertyNameData);
+                       propertyData = SplitValues(*propertyNameData);
                
-                       for(map<string,string>::iterator iter = PropertyData.begin();
-                               iter != PropertyData.end(); iter++){
+                       for(map<string,string>::iterator iter = propertyData.begin();
+                               iter != propertyData.end(); iter++){
                        
                                if (iter->first == "ALTREP"){
                                
-                                       NewAlarmData.DescriptionAltRep = iter->second;
+                                       newAlarmData.descriptionAltRep = iter->second;
                                
                                } else if (iter->first == "LANGUAGE"){
                                
-                                       NewAlarmData.DescriptionLanguage = iter->second;
+                                       newAlarmData.descriptionLanguage = iter->second;
                                
                                } else {
                                
-                                       if (TokenData == false){
-                                               TokenData = true;
+                                       if (tokenData == false){
+                                               tokenData = true;
                                        } else {
-                                               PropertyTokens += ";";
+                                               propertyTokens += ";";
                                        }
                                
-                                       PropertyTokens += iter->first;
-                                       PropertyTokens += "=";
-                                       PropertyTokens += iter->second;
+                                       propertyTokens += iter->first;
+                                       propertyTokens += "=";
+                                       propertyTokens += iter->second;
                                
                                }
                                
                        }
                
-                       if (PropertyTokens.size() > 0){
-                               NewAlarmData.DescriptionTokens = PropertyTokens;
+                       if (propertyTokens.size() > 0){
+                               newAlarmData.descriptionTokens = propertyTokens;
                        }
                
-                       NewAlarmData.DescriptionData = DataReceived.begin()->second;
-                       AlarmDescriptionFound = true;
+                       newAlarmData.descriptionData = dataReceived.begin()->second;
+                       alarmDescriptionFound = true;
                
                }
                
                // Process data from SUMMARY.
                
-               DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], false, "SUMMARY");
+               dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], false, "SUMMARY");
        
-               if (DataReceived.begin() != DataReceived.end() &&
-                       NewAlarmData.AlarmType == CALENDARALARM_EMAIL){
+               if (dataReceived.begin() != dataReceived.end() &&
+                       newAlarmData.alarmType == CALENDARALARM_EMAIL){
        
-                       bool TokenData = false;
-                       string PropertyTokens;
+                       bool tokenData = false;
+                       string propertyTokens;
                
-                       PropertyNameData = (string*)&DataReceived.begin()->first;
+                       propertyNameData = (string*)&dataReceived.begin()->first;
                
-                       PropertyData = SplitValues(*PropertyNameData);
+                       propertyData = SplitValues(*propertyNameData);
                
-                       for(map<string,string>::iterator iter = PropertyData.begin();
-                               iter != PropertyData.end(); iter++){
+                       for(map<string,string>::iterator iter = propertyData.begin();
+                               iter != propertyData.end(); iter++){
                        
                                if (iter->first == "ALTREP"){
                                
-                                       NewAlarmData.SummaryAltRep = iter->second;
+                                       newAlarmData.summaryAltRep = iter->second;
                                
                                } else if (iter->first == "LANGUAGE"){
                                
-                                       NewAlarmData.SummaryLanguage = iter->second;
+                                       newAlarmData.summaryLanguage = iter->second;
                                
                                } else {
                                
-                                       if (TokenData == false){
-                                               TokenData = true;
+                                       if (tokenData == false){
+                                               tokenData = true;
                                        } else {
-                                               PropertyTokens += ";";
+                                               propertyTokens += ";";
                                        }
                                
-                                       PropertyTokens += iter->first;
-                                       PropertyTokens += "=";
-                                       PropertyTokens += iter->second;
+                                       propertyTokens += iter->first;
+                                       propertyTokens += "=";
+                                       propertyTokens += iter->second;
                                
                                }
                                
                        }
                
-                       if (PropertyTokens.size() > 0){
-                               NewAlarmData.SummaryTokens = PropertyTokens;
+                       if (propertyTokens.size() > 0){
+                               newAlarmData.summaryTokens = propertyTokens;
                        }
                
-                       NewAlarmData.SummaryData = DataReceived.begin()->second;
-                       AlarmSummaryFound = true;
+                       newAlarmData.summaryData = dataReceived.begin()->second;
+                       alarmSummaryFound = true;
                
                }
                
                // Process data from DURATION.
                
-               DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], false, "DURATION");
+               dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], false, "DURATION");
                
-               if (DataReceived.begin() != DataReceived.end()){
+               if (dataReceived.begin() != dataReceived.end()){
        
                        try {
-                               NewAlarmData.DurationTokens = DataReceived.begin()->first.substr(9);
+                               newAlarmData.durationTokens = dataReceived.begin()->first.substr(9);
                        }
                
                        catch(const out_of_range &oor){
                                // Do nothing as there is no data.
                        }               
                
-                       NewAlarmData.DurationData = DataReceived.begin()->second;
-                       AlarmDurationFound = true;
+                       newAlarmData.durationData = dataReceived.begin()->second;
+                       alarmDurationFound = true;
                
                }
                
                // Process data from REPEAT.
                
-               DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], false, "REPEAT");
+               dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], false, "REPEAT");
                
-               if (DataReceived.begin() != DataReceived.end() && AlarmDurationFound == true){
+               if (dataReceived.begin() != dataReceived.end() && alarmDurationFound == true){
        
                        try {
-                               NewAlarmData.RepeatTokens = DataReceived.begin()->first.substr(7);
+                               newAlarmData.repeatTokens = dataReceived.begin()->first.substr(7);
                        }
                
                        catch(const out_of_range &oor){
                                // Do nothing as there is no data.
                        }               
                
-                       NewAlarmData.RepeatData = DataReceived.begin()->second;
+                       newAlarmData.repeatData = dataReceived.begin()->second;
                
                } else {
                        
-                       NewAlarmData.DurationData.clear();
-                       NewAlarmData.DurationTokens.clear();
+                       newAlarmData.durationData.clear();
+                       newAlarmData.durationTokens.clear();
                        
                }
                
                // Process data from ATTENDEE.
                
-               DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], true, "ATTENDEE");
+               dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], true, "ATTENDEE");
        
-               ObjectSeekCount = 0;
+               objectSeekCount = 0;
        
-               for(multimap<string,string>::iterator iter = DataReceived.begin(); 
-                       iter != DataReceived.end(); 
+               for(multimap<string,string>::iterator iter = dataReceived.begin(); 
+                       iter != dataReceived.end(); 
                        ++iter){
                        
-                       NewAlarmData.AttendeeListMember.push_back("");
-                       NewAlarmData.AttendeeListDelegatedFrom.push_back("");
-                       NewAlarmData.AttendeeListDelegatedTo.push_back("");
-                       NewAlarmData.AttendeeListRole.push_back("");
-                       NewAlarmData.AttendeeListRSVP.push_back("");
-                       NewAlarmData.AttendeeListDirectoryEntry.push_back("");
-                       NewAlarmData.AttendeeListSentBy.push_back("");
-                       NewAlarmData.AttendeeListCommonName.push_back("");
-                       NewAlarmData.AttendeeListCalendarUserType.push_back("");
-                       NewAlarmData.AttendeeListParticipationStatus.push_back("");
-                       NewAlarmData.AttendeeListLanguage.push_back("");
-                       NewAlarmData.AttendeeListTokens.push_back("");
-                       NewAlarmData.AttendeeList.push_back("");
+                       newAlarmData.attendeeListMember.push_back("");
+                       newAlarmData.attendeeListDelegatedFrom.push_back("");
+                       newAlarmData.attendeeListDelegatedTo.push_back("");
+                       newAlarmData.attendeeListRole.push_back("");
+                       newAlarmData.attendeeListRSVP.push_back("");
+                       newAlarmData.attendeeListDirectoryEntry.push_back("");
+                       newAlarmData.attendeeListSentBy.push_back("");
+                       newAlarmData.attendeeListCommonName.push_back("");
+                       newAlarmData.attendeeListCalendarUserType.push_back("");
+                       newAlarmData.attendeeListParticipationStatus.push_back("");
+                       newAlarmData.attendeeListLanguage.push_back("");
+                       newAlarmData.attendeeListTokens.push_back("");
+                       newAlarmData.attendeeList.push_back("");
                        
-                       bool TokenData = false;
-                       string PropertyTokens;
+                       bool tokenData = false;
+                       string propertyTokens;
                
-                       PropertyNameData = (string*)&iter->first;
+                       propertyNameData = (string*)&iter->first;
                
-                       PropertyData = SplitValues(*PropertyNameData);
+                       propertyData = SplitValues(*propertyNameData);
                        
-                       for(map<string,string>::iterator dataiter = PropertyData.begin();
-                               dataiter != PropertyData.end(); dataiter++){
+                       for(map<string,string>::iterator dataiter = propertyData.begin();
+                               dataiter != propertyData.end(); dataiter++){
                        
                                if (dataiter->first == "CUTYPE"){
                                
-                                       NewAlarmData.AttendeeListCalendarUserType[ObjectSeekCount] = dataiter->second;
+                                       newAlarmData.attendeeListCalendarUserType[objectSeekCount] = dataiter->second;
                                
                                } else if (dataiter->first == "MEMBER"){
                                
-                                       NewAlarmData.AttendeeListMember[ObjectSeekCount] = dataiter->second;
+                                       newAlarmData.attendeeListMember[objectSeekCount] = dataiter->second;
                                
                                } else if (dataiter->first == "ROLE"){
                                
-                                       NewAlarmData.AttendeeListRole[ObjectSeekCount] = dataiter->second;
+                                       newAlarmData.attendeeListRole[objectSeekCount] = dataiter->second;
                                
                                } else if (dataiter->first == "PARTSTAT"){
                                
-                                       NewAlarmData.AttendeeListParticipationStatus[ObjectSeekCount] = dataiter->second;
+                                       newAlarmData.attendeeListParticipationStatus[objectSeekCount] = dataiter->second;
                                
                                } else if (dataiter->first == "RSVP"){
                                
-                                       NewAlarmData.AttendeeListRSVP[ObjectSeekCount] = dataiter->second;
+                                       newAlarmData.attendeeListRSVP[objectSeekCount] = dataiter->second;
                                
                                } else if (dataiter->first == "DELEGATED-TO"){
                                
-                                       NewAlarmData.AttendeeListDelegatedTo[ObjectSeekCount] = dataiter->second;
+                                       newAlarmData.attendeeListDelegatedTo[objectSeekCount] = dataiter->second;
                                
                                } else if (dataiter->first == "DELEGATED-FROM"){
                                
-                                       NewAlarmData.AttendeeListDelegatedFrom[ObjectSeekCount] = dataiter->second;
+                                       newAlarmData.attendeeListDelegatedFrom[objectSeekCount] = dataiter->second;
                                
                                } else if (dataiter->first == "SENT-BY"){
                                
-                                       NewAlarmData.AttendeeListSentBy[ObjectSeekCount] = dataiter->second;
+                                       newAlarmData.attendeeListSentBy[objectSeekCount] = dataiter->second;
                                
                                } else if (dataiter->first == "CN"){
                                
-                                       NewAlarmData.AttendeeListCommonName[ObjectSeekCount] = dataiter->second;
+                                       newAlarmData.attendeeListCommonName[objectSeekCount] = dataiter->second;
                                
                                } else if (dataiter->first == "DIR"){
                                
-                                       NewAlarmData.AttendeeListDirectoryEntry[ObjectSeekCount] = dataiter->second;
+                                       newAlarmData.attendeeListDirectoryEntry[objectSeekCount] = dataiter->second;
                                
                                } else if (dataiter->first == "LANGUAGE"){
                                
-                                       NewAlarmData.AttendeeListLanguage[ObjectSeekCount] = dataiter->second;
+                                       newAlarmData.attendeeListLanguage[objectSeekCount] = dataiter->second;
                                
                                } else {
                                
-                                       if (TokenData == false){
-                                               TokenData = true;
+                                       if (tokenData == false){
+                                               tokenData = true;
                                        } else {
-                                               PropertyTokens += ";";
+                                               propertyTokens += ";";
                                        }
                                
-                                       PropertyTokens += dataiter->first;
-                                       PropertyTokens += "=";
-                                       PropertyTokens += dataiter->second;
+                                       propertyTokens += dataiter->first;
+                                       propertyTokens += "=";
+                                       propertyTokens += dataiter->second;
                                
                                }
                                
                        }
                
-                       if (PropertyTokens.size() > 0){
-                               NewAlarmData.AttendeeListTokens[ObjectSeekCount] = PropertyTokens;
+                       if (propertyTokens.size() > 0){
+                               newAlarmData.attendeeListTokens[objectSeekCount] = PropertyTokens;
                        }
                        
-                       NewAlarmData.AttendeeList[ObjectSeekCount] = iter->second;
+                       newAlarmData.attendeeList[objectSeekCount] = iter->second;
                
-                       ObjectSeekCount++;
+                       objectSeekCount++;
                
                }
                
                // Process data from ATTACH.
                
-               DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], true, "ATTACH");
+               dataReceived = ProcessTextVectors(&eventAlarmName[seekCount], &eventAlarmData[seekCount], true, "ATTACH");
        
-               ObjectSeekCount = 0;
+               objectSeekCount = 0;
                
-               for(multimap<string,string>::iterator iter = DataReceived.begin(); 
-                       iter != DataReceived.end();
+               for(multimap<string,string>::iterator iter = dataReceived.begin(); 
+                       iter != dataReceived.end();
                        ++iter){
                
-                       NewAlarmData.AttachListEncoding.push_back("");
-                       NewAlarmData.AttachListValue.push_back("");
-                       NewAlarmData.AttachListFormatType.push_back("");
-                       NewAlarmData.AttachListTokens.push_back("");
-                       NewAlarmData.AttachList.push_back("");
+                       newAlarmData.attachListEncoding.push_back("");
+                       newAlarmData.attachListValue.push_back("");
+                       newAlarmData.attachListFormatType.push_back("");
+                       newAlarmData.attachListTokens.push_back("");
+                       newAlarmData.attachList.push_back("");
                        
-                       bool TokenData = false;
-                       string PropertyTokens;
+                       bool tokenData = false;
+                       string propertyTokens;
                
-                       PropertyNameData = (string*)&iter->first;
+                       propertyNameData = (string*)&iter->first;
                
-                       PropertyData = SplitValues(*PropertyNameData);
+                       propertyData = SplitValues(*propertyNameData);
                        
-                       for(map<string,string>::iterator dataiter = PropertyData.begin();
-                               dataiter != PropertyData.end(); dataiter++){
+                       for(map<string,string>::iterator dataiter = propertyData.begin();
+                               dataiter != propertyData.end(); dataiter++){
                        
                                if (dataiter->first == "ENCODING"){
                                
-                                       NewAlarmData.AttachListEncoding[ObjectSeekCount] = dataiter->second;
+                                       newAlarmData.attachListEncoding[objectSeekCount] = dataiter->second;
                                
                                } else if (dataiter->first == "VALUE"){
                                
-                                       NewAlarmData.AttachListValue[ObjectSeekCount] = dataiter->second;
+                                       newAlarmData.attachListValue[objectSeekCount] = dataiter->second;
                                
                                } else if (dataiter->first == "FMTTYPE"){
                                
-                                       NewAlarmData.AttachListFormatType[ObjectSeekCount] = dataiter->second;
+                                       newAlarmData.attachListFormatType[objectSeekCount] = dataiter->second;
                                
                                } else {
                                
-                                       if (TokenData == false){
-                                               TokenData = true;
+                                       if (tokenData == false){
+                                               tokenData = true;
                                        } else {
-                                               PropertyTokens += ";";
+                                               propertyTokens += ";";
                                        }
                                
-                                       PropertyTokens += dataiter->first;
-                                       PropertyTokens += "=";
-                                       PropertyTokens += dataiter->second;
+                                       propertyTokens += dataiter->first;
+                                       propertyTokens += "=";
+                                       propertyTokens += dataiter->second;
                                
                                }
                                
                        }
                
-                       if (PropertyTokens.size() > 0){
-                               NewAlarmData.AttachListTokens[ObjectSeekCount] = PropertyTokens;
+                       if (propertyTokens.size() > 0){
+                               newAlarmData.attachListTokens[objectSeekCount] = propertyTokens;
                        }
                        
-                       NewAlarmData.AttachList[ObjectSeekCount] = iter->second;
+                       newAlarmData.attachList[objectSeekCount] = iter->second;
                
-                       ObjectSeekCount++;
+                       objectSeekCount++;
                
                }
                
                // Process data from X-*
                
-               AlarmObjectCount = 0;
+               alarmObjectCount = 0;
                
-               for(vector<string>::iterator xtokeniter = EventAlarmName[SeekCount].begin(); 
-                       xtokeniter != EventAlarmName[SeekCount].end(); ++xtokeniter){
+               for(vector<string>::iterator xtokeniter = eventAlarmName[seekCount].begin(); 
+                       xtokeniter != eventAlarmName[seekCount].end(); ++xtokeniter){
                        
-                       bool TokenData = false;
-                       string PropertyTokens;
+                       bool tokenData = false;
+                       string propertyTokens;
                
                        if (xtokeniter->substr(0,2) == "X-" &&
                                xtokeniter->size() > 2){
                        
-                               NewAlarmData.XTokensData.push_back(EventAlarmData[SeekCount][AlarmObjectCount]);
-                               NewAlarmData.XTokensDataTokens.push_back(EventAlarmName[SeekCount][AlarmObjectCount]);
+                               newAlarmData.xTokensData.push_back(EventAlarmData[seekCount][alarmObjectCount]);
+                               newAlarmData.xTokensDataTokens.push_back(EventAlarmName[seekCount][alarmObjectCount]);
                                
                        }
                
-                       AlarmObjectCount++;
+                       alarmObjectCount++;
                
                }
                
-               if (NewAlarmData.AlarmType == CALENDARALARM_AUDIO &&
-                       AlarmActionFound == true &&
-                       AlarmTriggerFound == true){
+               if (newAlarmData.alarmType == CALENDARALARM_AUDIO &&
+                       alarmActionFound == true &&
+                       alarmTriggerFound == true){
                
-                       CalendarAlarmData.push_back(NewAlarmData);
+                       calendarAlarmData.push_back(newAlarmData);
                        
-               } else if (NewAlarmData.AlarmType == CALENDARALARM_DISPLAY &&
-                       AlarmActionFound == true &&
-                       AlarmTriggerFound == true &&
-                       AlarmDescriptionFound == true){
+               } else if (newAlarmData.alarmType == CALENDARALARM_DISPLAY &&
+                       alarmActionFound == true &&
+                       alarmTriggerFound == true &&
+                       alarmDescriptionFound == true){
 
-                       CalendarAlarmData.push_back(NewAlarmData);
+                       calendarAlarmData.push_back(newAlarmData);
                                
-               } else if (NewAlarmData.AlarmType == CALENDARALARM_EMAIL &&
-                       AlarmActionFound == true &&
-                       AlarmTriggerFound == true &&
-                       AlarmDescriptionFound == true &&
-                       AlarmSummaryFound == true){
+               } else if (newAlarmData.alarmType == CALENDARALARM_EMAIL &&
+                       alarmActionFound == true &&
+                       alarmTriggerFound == true &&
+                       alarmDescriptionFound == true &&
+                       alarmSummaryFound == true){
                
-                       CalendarAlarmData.push_back(NewAlarmData);
+                       calendarAlarmData.push_back(newAlarmData);
                                
                }
                        
-               SeekCount++;
+               seekCount++;
                        
        }
        
-       ObjectSeekCount = 0;
+       objectSeekCount = 0;
        
        // Process data from X-*
        
-       for(vector<string>::iterator iter = ObjectName.begin(); 
-               iter != ObjectName.end(); ++iter){
+       for(vector<string>::iterator iter = objectName.begin(); 
+               iter != objectName.end(); ++iter){
                        
-               bool TokenData = false;
-               string PropertyTokens;
+               bool tokenData = false;
+               string propertyTokens;
                
                if (iter->substr(0,2) == "X-" &&
                        iter->size() > 2){
                        
-                       XTokensData.push_back(ObjectData[ObjectSeekCount]);
-                       XTokensDataTokens.push_back(ObjectName[ObjectSeekCount]);
+                       xTokensData.push_back(objectData[objectSeekCount]);
+                       xTokensDataTokens.push_back(objectName[objectSeekCount]);
                                
                }
                
-               ObjectSeekCount++;
+               objectSeekCount++;
                
        }
        
index f16253b..157d620 100644 (file)
@@ -28,7 +28,7 @@ class CalendarEventObject: public CalendarObject{
        private:
        
        void ProcessData();
-       void SaveObjectData(string *SaveData);
+       void SaveObjectData(string *saveData);
        
 };
 
Xestia Software Development
Yn Maystri
© 2006 - 2019 Xestia Software Development
Software

Xestia Address Book
Xestia Calendar
Development

Xestia Gelforn
Everything else

About
News
Privacy Policy