// CalendarTask.cpp - CalendarTask class functions
//
// (c) 2016-2017 Xestia Software Development.
//
// This file is part of Xestia Calendar.
//
// Xestia Calendar is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by the
// Free Software Foundation, version 3 of the license.
//
// Xestia Calendar is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with Xestia Calendar. If not, see <http://www.gnu.org/licenses/>

#include "CalendarTask.h"

using namespace std;

CalendarObjectValidResult CalendarTaskObject::ValidObject(){

	bool ValidBegin = false;
	bool ValidEnd = false;
	bool ValidDateTimeStamp = false;
	bool ValidUniqueID = false;
	int SeekCount = 0;
	string PropertyName;
	
	// Look for BEGIN:VTODO.
	
	for (vector<string>::iterator iter = ObjectName.begin();
		iter != ObjectName.end(); iter++){
	
		if (ObjectName[SeekCount] == "BEGIN" &&
			ObjectData[SeekCount] == "VTODO"){
			
			if (ValidBegin == false){
				ValidBegin = true;
			} else {
				return CALENDAROBJECTVALID_INVALIDFORMAT;
			}
				
		}
		
		if (ObjectName[SeekCount] == "END" &&
			ObjectData[SeekCount] == "VTODO" &&
			ValidBegin == false){
		
			return CALENDAROBJECTVALID_INVALIDFORMAT;
				
		}
		
		SeekCount++;
			
	}
	
	SeekCount = 0;
	
	// Look for DTSTAMP.
	
	for (vector<string>::iterator iter = ObjectName.begin();
		iter != ObjectName.end(); iter++){
			
		try{
			PropertyName = ObjectName[SeekCount].substr(0,7);
		}
			
		catch(const out_of_range& oor){
			continue;
		}
		
		if (PropertyName == "DTSTAMP"){
			
			if (ValidDateTimeStamp == false){
				ValidDateTimeStamp = true;
			} else {
				return CALENDAROBJECTVALID_INVALIDFORMAT;
			}
				
		}
			
		SeekCount++;

	}
	
	SeekCount = 0;
	
	// Look for UID.
	
	for (vector<string>::iterator iter = ObjectName.begin();
		iter != ObjectName.end(); iter++){
	
		try{
			PropertyName = ObjectName[SeekCount].substr(0,3);
		}
		
		catch(const out_of_range& oor){
			continue;
		}
			
		if (PropertyName == "UID"){
			
			if (ValidUniqueID == false){
				ValidUniqueID = true;
			} else {
				return CALENDAROBJECTVALID_INVALIDFORMAT;
			}
				
		}
			
		SeekCount++;
			
	}
	
	SeekCount = 0;
		
	// Look for END:VTODO.
	
	for (vector<string>::iterator iter = ObjectName.begin();
		iter != ObjectName.end(); iter++){
	
		if (ObjectName[SeekCount] == "END" &&
			ObjectData[SeekCount] == "VTODO"){
			
			if (ValidEnd == false){
				ValidEnd = true;
			} else {
				return CALENDAROBJECTVALID_INVALIDFORMAT;
			}
				
		}
			
		SeekCount++;
			
	}
	
	// Check if the VTODO is valid.
	
	if (ValidBegin == true && 
		ValidEnd == true && 
		ValidDateTimeStamp == true &&
		ValidUniqueID == true){
			
		return CALENDAROBJECTVALID_OK;
			
	} else {
		
		return CALENDAROBJECTVALID_INVALIDFORMAT;
		
	}
	
}

void CalendarTaskObject::ProcessData(){

	// Process the data.
	
	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");
	
	// Process the data from DTSTAMP.
	
	if (DataReceived.begin() != DataReceived.end()){
	
		try {
			DateTimeStampTokens = DataReceived.begin()->first.substr(8);
		}
		
		catch(const out_of_range &oor){
			// Do nothing as there is no data.
		}		
		
		DateTimeStampData = DataReceived.begin()->second;
		
	}
	
	// Get the Unique ID (UID).
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "UID");
	
	// Process the data from UID.
	
	if (DataReceived.begin() != DataReceived.end()){
	
		try {
			UniqueIDTokens = DataReceived.begin()->first.substr(4);
		}
		
		catch(const out_of_range &oor){
			// Do nothing as there is no data.
		}		
		
		UniqueID = DataReceived.begin()->second;
		
	}
	
	// Process the data from CLASS.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "CLASS");
	
	if (DataReceived.begin() != DataReceived.end()){
	
		try {
			ClassDataTokens = DataReceived.begin()->first.substr(6);
		}
		
		catch(const out_of_range &oor){
			// Do nothing as there is no data.
		}		
		
		ClassData = DataReceived.begin()->second;
		
	}
	
	// Process the data from COMPLETED.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "COMPLETED");
	
	if (DataReceived.begin() != DataReceived.end()){
	
		try {
			CompletedDataTokens = DataReceived.begin()->first.substr(10);
		}
		
		catch(const out_of_range &oor){
			// Do nothing as there is no data.
		}		
		
		CompletedData = DataReceived.begin()->second;
		
	}
	
	// Process the data from CREATED.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "CREATED");
	
	if (DataReceived.begin() != DataReceived.end()){
	
		try {
			DateTimeCreatedTokens = DataReceived.begin()->first.substr(8);
		}
		
		catch(const out_of_range &oor){
			// Do nothing as there is no data.
		}		
		
		DateTimeCreatedData = DataReceived.begin()->second;
		
	}
	
	// Process the data from DESCRIPTION.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "DESCRIPTION");
	
	if (DataReceived.begin() != DataReceived.end()){
	
		bool TokenData = false;
		string PropertyTokens;
		
		PropertyNameData = (string*)&DataReceived.begin()->first;
		
		PropertyData = SplitValues(*PropertyNameData);
		
		for(map<string,string>::iterator iter = PropertyData.begin();
			iter != PropertyData.end(); iter++){
			
			if (iter->first == "ALTREP"){
				
				DescriptionListAltRep.clear();
				DescriptionListAltRep.push_back(iter->second);
				
			} else if (iter->first == "LANGUAGE"){
				
				DescriptionListLanguage.clear();
				DescriptionListLanguage.push_back(iter->second);
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += iter->first;
				PropertyTokens += "=";
				PropertyTokens += iter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			DescriptionListTokens.clear();
			DescriptionListTokens.push_back(PropertyTokens);
		}
		
		DescriptionList.clear();
		DescriptionList.push_back(DataReceived.begin()->second);
		
	}
	
	// Get the Date Time Start value.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "DTSTART");
	
	// Process the data from DTSTART.
	
	if (DataReceived.begin() != DataReceived.end()){
	
		bool TokenData = false;
		string PropertyTokens;
		
		PropertyNameData = (string*)&DataReceived.begin()->first;
		
		PropertyData = SplitValues(*PropertyNameData);
		
		for(map<string,string>::iterator iter = PropertyData.begin();
			iter != PropertyData.end(); iter++){
			
			if (iter->first == "VALUE"){
				
				DateTimeStartDataValue = iter->second;
				
			} else if (iter->first == "TZID"){
				
				DateTimeStartDataTimeZoneID = iter->second;
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += iter->first;
				PropertyTokens += "=";
				PropertyTokens += iter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			DateTimeStartDataTokens = PropertyTokens;
		}
		
		DateTimeStartData = DataReceived.begin()->second;
		
	}
	
	// Process the data from GEO.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "GEO");
	
	if (DataReceived.begin() != DataReceived.end()){
	
		try {
			GeographicTokens = DataReceived.begin()->first.substr(4);
		}
		
		catch(const out_of_range &oor){
			// Do nothing as there is no data.
		}		
		
		GeographicData = DataReceived.begin()->second;
		
	}
	
	// Process the data from LAST-MODIFIED.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "LAST-MODIFIED");
	
	if (DataReceived.begin() != DataReceived.end()){
	
		try {
			LastModifiedTokens = DataReceived.begin()->first.substr(14);
		}
		
		catch(const out_of_range &oor){
			// Do nothing as there is no data.
		}		
		
		LastModifiedData = DataReceived.begin()->second;
		
	}
	
	// Process the data from LOCATION.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "LOCATION");
	
	if (DataReceived.begin() != DataReceived.end()){
	
		bool TokenData = false;
		string PropertyTokens;
		
		PropertyNameData = (string*)&DataReceived.begin()->first;
		
		PropertyData = SplitValues(*PropertyNameData);
		
		for(map<string,string>::iterator iter = PropertyData.begin();
			iter != PropertyData.end(); iter++){
			
			if (iter->first == "ALTREP"){
				
				LocationDataAltRep = iter->second;
				
			} else if (iter->first == "LANGUAGE"){
				
				LocationDataLanguage = iter->second;
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += iter->first;
				PropertyTokens += "=";
				PropertyTokens += iter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			
			LocationDataTokens = PropertyTokens;
			
		}
		
		LocationData = DataReceived.begin()->second;
		
	}
	
	// Process the data from ORGANIZER.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "ORGANIZER");
	
	if (DataReceived.begin() != DataReceived.end()){
	
		bool TokenData = false;
		string PropertyTokens;
		
		PropertyNameData = (string*)&DataReceived.begin()->first;
		
		PropertyData = SplitValues(*PropertyNameData);
		
		for(map<string,string>::iterator iter = PropertyData.begin();
			iter != PropertyData.end(); iter++){
			
			if (iter->first == "CN"){
				
				OrganiserDataCommonName = iter->second;
				
			} else if (iter->first == "DIR"){
				
				OrganiserDataDirectoryEntry = iter->second;
				
			} else if (iter->first == "SENT-BY"){
				
				OrganiserDataSentByParam = iter->second;
				
			} else if (iter->first == "LANGUAGE"){
				
				OrganiserDataLanguage = iter->second;
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += iter->first;
				PropertyTokens += "=";
				PropertyTokens += iter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			
			OrganiserDataTokens = PropertyTokens;
			
		}
		
		OrganiserData = DataReceived.begin()->second;
		
	}
	
	// Process the data from PERCENT-COMPLETE.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "PERCENT-COMPLETE");
	
	if (DataReceived.begin() != DataReceived.end()){
	
		try {
			PercentCompleteTokens = DataReceived.begin()->first.substr(17);
		}
		
		catch(const out_of_range &oor){
			// Do nothing as there is no data.
		}
		
		PercentCompleteData = DataReceived.begin()->second;
		
	}
	
	// Process the data from PRIORITY.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "PRIORITY");
	
	if (DataReceived.begin() != DataReceived.end()){
	
		try {
			PriorityTokens = DataReceived.begin()->first.substr(9);
		}
		
		catch(const out_of_range &oor){
			// Do nothing as there is no data.
		}		
		
		try {
			PriorityData = stoi(DataReceived.begin()->second);
		}
		
		catch(const invalid_argument &oor){
			PriorityTokens.clear();
		}
		
	}
	
	// Process the data from RECURRENCE-ID.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "RECURRENCE-ID");
	
	if (DataReceived.begin() != DataReceived.end()){
	
		bool TokenData = false;
		string PropertyTokens;
		
		PropertyNameData = (string*)&DataReceived.begin()->first;
		
		PropertyData = SplitValues(*PropertyNameData);
		
		for(map<string,string>::iterator iter = PropertyData.begin();
			iter != PropertyData.end(); iter++){
			
			if (iter->first == "TZID"){
				
				RecurranceIDDataTimeZoneParam = iter->second;
				
			} else if (iter->first == "VALUE"){
				
				RecurranceIDDataValue = iter->second;
				
			} else if (iter->first == "RANGE"){
				
				RecurranceIDDataRangeParam = iter->second;
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += iter->first;
				PropertyTokens += "=";
				PropertyTokens += iter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			
			RecurranceIDDataTokens = PropertyTokens;
			
		}
		
		RecurranceIDData = DataReceived.begin()->second;
		
	}
	
	// Process the data from SEQUENCE.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "SEQUENCE");
	
	if (DataReceived.begin() != DataReceived.end()){
	
		try {
			SequenceTokens = DataReceived.begin()->first.substr(9);
		}
		
		catch(const out_of_range &oor){
			// Do nothing as there is no data.
		}		
		
		try {
			SequenceData = stoi(DataReceived.begin()->second);
		}
		
		catch(const invalid_argument &oor){
			SequenceTokens.clear();
		}
		
	}
	
	// Process the data from STATUS.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "STATUS");
	
	if (DataReceived.begin() != DataReceived.end()){
	
		bool TokenData = false;
		string PropertyTokens;
		
		PropertyNameData = (string*)&DataReceived.begin()->first;
		
		PropertyData = SplitValues(*PropertyNameData);
		
		for(map<string,string>::iterator iter = PropertyData.begin();
			iter != PropertyData.end(); iter++){
			
			if (iter->first == "LANGUAGE"){
				
				StatusLanguage = iter->second;
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += iter->first;
				PropertyTokens += "=";
				PropertyTokens += iter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			
			StatusTokens = PropertyTokens;
			
		}
		
		StatusData = DataReceived.begin()->second;
		
	}
	
	// Process the data from SUMMARY.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "SUMMARY");
	
	if (DataReceived.begin() != DataReceived.end()){
	
		bool TokenData = false;
		string PropertyTokens;
		
		PropertyNameData = (string*)&DataReceived.begin()->first;
		
		PropertyData = SplitValues(*PropertyNameData);
		
		for(map<string,string>::iterator iter = PropertyData.begin();
			iter != PropertyData.end(); iter++){
			
			if (iter->first == "ALTREP"){
				
				SummaryDataAltRep = iter->second;
				
			} else if (iter->first == "LANGUAGE"){
				
				SummaryDataLanguage = iter->second;
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += iter->first;
				PropertyTokens += "=";
				PropertyTokens += iter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			
			SummaryDataTokens = PropertyTokens;
			
		}
		
		SummaryData = DataReceived.begin()->second;
		
	}
	
	// Process the data from URL.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "URL");
	
	if (DataReceived.begin() != DataReceived.end()){
	
		try {
			URLDataTokens = DataReceived.begin()->first.substr(4);
		}
		
		catch(const out_of_range &oor){
			// Do nothing as there is no data.
		}		
		
		URLData = DataReceived.begin()->second;
		
	}
	
	// Process the data from RRULE.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "RRULE");
	
	if (DataReceived.begin() != DataReceived.end()){
	
		try {
			RecurranceRuleDataTokens = DataReceived.begin()->first.substr(6);
		}
		
		catch(const out_of_range &oor){
			// Do nothing as there is no data.
		}		
		
		RecurranceRuleData = DataReceived.begin()->second;
		
	}
	
	bool DueProcessed = false;
	
	// Process the data from DUE.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "DUE");
	
	if (DataReceived.begin() != DataReceived.end()){
	
		bool TokenData = false;
		string PropertyTokens;
		
		PropertyNameData = (string*)&DataReceived.begin()->first;
		
		PropertyData = SplitValues(*PropertyNameData);
		
		for(map<string,string>::iterator iter = PropertyData.begin();
			iter != PropertyData.end(); iter++){
			
			if (iter->first == "TZID"){
				
				DueDataTimeZoneID = iter->second;
				
			} else if (iter->first == "VALUE"){
				
				DueDataValue = iter->second;
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += iter->first;
				PropertyTokens += "=";
				PropertyTokens += iter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			
			DueDataTokens = PropertyTokens;
			
		}
		
		DueData = DataReceived.begin()->second;
		DueProcessed = true;
		
	}
	
	// If there is no DUE, then check for DURATION.
	
	if (DueProcessed == false){

		DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "DURATION");
	
		if (DataReceived.begin() != DataReceived.end()){
	
			try {
				DurationDataTokens = DataReceived.begin()->first.substr(9);
			}
		
			catch(const out_of_range &oor){
				// Do nothing as there is no data.
			}		
		
			DurationData = DataReceived.begin()->second;
		
		}
		
	}

	// Process the data from ATTACH.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "ATTACH");
	
	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("");
			
		bool TokenData = false;
		string PropertyTokens;
		
		PropertyNameData = (string*)&iter->first;
		
		PropertyData = SplitValues(*PropertyNameData);
			
		for(map<string,string>::iterator dataiter = PropertyData.begin();
			dataiter != PropertyData.end(); dataiter++){
			
			if (dataiter->first == "ENCODING"){
				
				AttachListEncoding[ObjectSeekCount] = dataiter->second;
				
			} else if (dataiter->first == "VALUE"){
				
				AttachListValue[ObjectSeekCount] = dataiter->second;
				
			} else if (dataiter->first == "FMTTYPE"){
				
				AttachListFormatType[ObjectSeekCount] = dataiter->second;
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += dataiter->first;
				PropertyTokens += "=";
				PropertyTokens += dataiter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			AttachListTokens[ObjectSeekCount] = PropertyTokens;
		}
			
		AttachList[ObjectSeekCount] = iter->second;
		
		ObjectSeekCount++;
		
	}
	
	// Process the data from ATTENDEE.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "ATTENDEE");
	
	ObjectSeekCount = 0;
	
	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;
		
		PropertyNameData = (string*)&iter->first;
		
		PropertyData = SplitValues(*PropertyNameData);
			
		for(map<string,string>::iterator dataiter = PropertyData.begin();
			dataiter != PropertyData.end(); dataiter++){
			
			if (dataiter->first == "CUTYPE"){
				
				AttendeeListCalendarUserType[ObjectSeekCount] = dataiter->second;
				
			} else if (dataiter->first == "MEMBER"){
				
				AttendeeListMember[ObjectSeekCount] = dataiter->second;
				
			} else if (dataiter->first == "ROLE"){
				
				AttendeeListRole[ObjectSeekCount] = dataiter->second;
				
			} else if (dataiter->first == "PARTSTAT"){
				
				AttendeeListParticipationStatus[ObjectSeekCount] = dataiter->second;
				
			} else if (dataiter->first == "RSVP"){
				
				AttendeeListRSVP[ObjectSeekCount] = dataiter->second;
				
			} else if (dataiter->first == "DELEGATED-TO"){
				
				AttendeeListDelegatedTo[ObjectSeekCount] = dataiter->second;
				
			} else if (dataiter->first == "DELEGATED-FROM"){
				
				AttendeeListDelegatedFrom[ObjectSeekCount] = dataiter->second;
				
			} else if (dataiter->first == "SENT-BY"){
				
				AttendeeListSentBy[ObjectSeekCount] = dataiter->second;
				
			} else if (dataiter->first == "CN"){
				
				AttendeeListCommonName[ObjectSeekCount] = dataiter->second;
				
			} else if (dataiter->first == "DIR"){
				
				AttendeeListDirectoryEntry[ObjectSeekCount] = dataiter->second;
				
			} else if (dataiter->first == "LANGUAGE"){
				
				AttendeeListLanguage[ObjectSeekCount] = dataiter->second;
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += dataiter->first;
				PropertyTokens += "=";
				PropertyTokens += dataiter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			AttendeeListTokens[ObjectSeekCount] = PropertyTokens;
		}
			
		AttendeeList[ObjectSeekCount] = iter->second;
		
		ObjectSeekCount++;
		
	}

	// Process the data from CATEGORIES.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "CATEGORIES");
	
	ObjectSeekCount = 0;
	
	for(multimap<string,string>::iterator iter = DataReceived.begin(); 
		iter != DataReceived.end(); 
		++iter){
		
		CategoriesListTokens.push_back("");
		CategoriesListLanguage.push_back("");
		CategoriesList.push_back("");
			
		bool TokenData = false;
		string PropertyTokens;
		
		PropertyNameData = (string*)&iter->first;
		
		PropertyData = SplitValues(*PropertyNameData);
			
		for(map<string,string>::iterator dataiter = PropertyData.begin();
			dataiter != PropertyData.end(); dataiter++){
			
			if (dataiter->first == "LANGUAGE"){
				
				CategoriesListLanguage[ObjectSeekCount] = dataiter->second;
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += dataiter->first;
				PropertyTokens += "=";
				PropertyTokens += dataiter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			CategoriesListTokens[ObjectSeekCount] = PropertyTokens;
		}
			
		CategoriesList[ObjectSeekCount] = iter->second;
		
		ObjectSeekCount++;
		
	}
	
	// Process the data from COMMENT.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "COMMENT");

	ObjectSeekCount = 0;
	
	for(multimap<string,string>::iterator iter = DataReceived.begin(); 
		iter != DataReceived.end(); 
		++iter){
		
		CommentListTokens.push_back("");
		CommentListAltRep.push_back("");
		CommentListLanguage.push_back("");
		CommentList.push_back("");
			
		bool TokenData = false;
		string PropertyTokens;
		
		PropertyNameData = (string*)&iter->first;
		
		PropertyData = SplitValues(*PropertyNameData);
			
		for(map<string,string>::iterator dataiter = PropertyData.begin();
			dataiter != PropertyData.end(); dataiter++){
			
			if (dataiter->first == "ALTREP"){
				
				CommentListAltRep[ObjectSeekCount] = dataiter->second;
				
			} else if (dataiter->first == "LANGUAGE"){
				
				CommentListLanguage[ObjectSeekCount] = dataiter->second;
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += dataiter->first;
				PropertyTokens += "=";
				PropertyTokens += dataiter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			CommentListTokens[ObjectSeekCount] = PropertyTokens;
		}
			
		CommentList[ObjectSeekCount] = iter->second;
		
		ObjectSeekCount++;
		
	}

	// Process the data from CONTACT.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "CONTACT");

	ObjectSeekCount = 0;
	
	for(multimap<string,string>::iterator iter = DataReceived.begin(); 
		iter != DataReceived.end(); 
		++iter){
		
		ContactListTokens.push_back("");
		ContactListAltRep.push_back("");
		ContactListLanguage.push_back("");
		ContactList.push_back("");
			
		bool TokenData = false;
		string PropertyTokens;
		
		PropertyNameData = (string*)&iter->first;
		
		PropertyData = SplitValues(*PropertyNameData);
			
		for(map<string,string>::iterator dataiter = PropertyData.begin();
			dataiter != PropertyData.end(); dataiter++){
			
			if (dataiter->first == "ALTREP"){
				
				ContactListAltRep[ObjectSeekCount] = dataiter->second;
				
			} else if (dataiter->first == "LANGUAGE"){
				
				ContactListLanguage[ObjectSeekCount] = dataiter->second;
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += dataiter->first;
				PropertyTokens += "=";
				PropertyTokens += dataiter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			ContactListTokens[ObjectSeekCount] = PropertyTokens;
		}
			
		ContactList[ObjectSeekCount] = iter->second;
		
		ObjectSeekCount++;
		
	}
	
	// Process the data from EXDATE.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "EXDATE");

	ObjectSeekCount = 0;
	
	for(multimap<string,string>::iterator iter = DataReceived.begin(); 
		iter != DataReceived.end(); 
		++iter){
		
		ExcludeDateDataTokens.push_back("");
		ExcludeDateDataValue.push_back("");
		ExcludeDateDataTimeZoneParam.push_back("");
		ExcludeDateData.push_back("");
			
		bool TokenData = false;
		string PropertyTokens;
		
		PropertyNameData = (string*)&iter->first;
		
		PropertyData = SplitValues(*PropertyNameData);
			
		for(map<string,string>::iterator dataiter = PropertyData.begin();
			dataiter != PropertyData.end(); dataiter++){
			
			if (dataiter->first == "VALUE"){
				
				ExcludeDateDataValue[ObjectSeekCount] = dataiter->second;
				
			} else if (dataiter->first == "TZID"){
				
				ExcludeDateDataTimeZoneParam[ObjectSeekCount] = dataiter->second;
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += dataiter->first;
				PropertyTokens += "=";
				PropertyTokens += dataiter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			ExcludeDateDataTokens[ObjectSeekCount] = PropertyTokens;
		}
			
		ExcludeDateData[ObjectSeekCount] = iter->second;
		
		ObjectSeekCount++;
		
	}

	// Process the data from REQUEST-STATUS.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "REQUEST-STATUS");

	ObjectSeekCount = 0;
	
	for(multimap<string,string>::iterator iter = DataReceived.begin(); 
		iter != DataReceived.end(); 
		++iter){
		
		RequestStatusTokens.push_back("");
		RequestStatusLanguage.push_back("");
		RequestStatusData.push_back("");
			
		bool TokenData = false;
		string PropertyTokens;
		
		PropertyNameData = (string*)&iter->first;
		
		PropertyData = SplitValues(*PropertyNameData);
			
		for(map<string,string>::iterator dataiter = PropertyData.begin();
			dataiter != PropertyData.end(); dataiter++){
			
			if (dataiter->first == "LANGUAGE"){
				
				RequestStatusLanguage[ObjectSeekCount] = dataiter->second;
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += dataiter->first;
				PropertyTokens += "=";
				PropertyTokens += dataiter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			RequestStatusTokens[ObjectSeekCount] = PropertyTokens;
		}
			
		RequestStatusData[ObjectSeekCount] = iter->second;
		
		ObjectSeekCount++;
		
	}
	
	// Process the data from RELATED-TO.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "RELATED-TO");

	ObjectSeekCount = 0;
	
	for(multimap<string,string>::iterator iter = DataReceived.begin(); 
		iter != DataReceived.end(); 
		++iter){
		
		RelatedToDataTokens.push_back("");
		RelatedToDataRelationType.push_back("");
		RelatedToData.push_back("");
			
		bool TokenData = false;
		string PropertyTokens;
		
		PropertyNameData = (string*)&iter->first;
		
		PropertyData = SplitValues(*PropertyNameData);
			
		for(map<string,string>::iterator dataiter = PropertyData.begin();
			dataiter != PropertyData.end(); dataiter++){
			
			if (dataiter->first == "RELTYPE"){
				
				RelatedToDataRelationType[ObjectSeekCount] = dataiter->second;
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += dataiter->first;
				PropertyTokens += "=";
				PropertyTokens += dataiter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			RelatedToDataTokens[ObjectSeekCount] = PropertyTokens;
		}
			
		RelatedToData[ObjectSeekCount] = iter->second;
		
		ObjectSeekCount++;
		
	}
	
	// Process the data from RESOURCES.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "RESOURCES");

	ObjectSeekCount = 0;
	
	for(multimap<string,string>::iterator iter = DataReceived.begin(); 
		iter != DataReceived.end(); 
		++iter){
		
		ResourcesDataTokens.push_back("");
		ResourcesDataAltRep.push_back("");
		ResourcesDataLanguage.push_back("");
		ResourcesData.push_back("");
			
		bool TokenData = false;
		string PropertyTokens;
		
		PropertyNameData = (string*)&iter->first;
		
		PropertyData = SplitValues(*PropertyNameData);
			
		for(map<string,string>::iterator dataiter = PropertyData.begin();
			dataiter != PropertyData.end(); dataiter++){
			
			if (dataiter->first == "ALTREP"){
				
				ResourcesDataAltRep[ObjectSeekCount] = dataiter->second;
				
			} else if (dataiter->first == "LANGUAGE"){
				
				ResourcesDataLanguage[ObjectSeekCount] = dataiter->second;
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += dataiter->first;
				PropertyTokens += "=";
				PropertyTokens += dataiter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			ResourcesDataTokens[ObjectSeekCount] = PropertyTokens;
		}
			
		ResourcesData[ObjectSeekCount] = iter->second;
		
		ObjectSeekCount++;
		
	}
	
	// Process the data from RDATE.
	
	DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, true, "RDATE");

	ObjectSeekCount = 0;
	
	for(multimap<string,string>::iterator iter = DataReceived.begin(); 
		iter != DataReceived.end(); 
		++iter){
		
		RecurranceDateDataTokens.push_back("");
		RecurranceDateDataValue.push_back("");
		RecurranceDateDataTimeZoneParam.push_back("");
		RecurranceDateData.push_back("");
			
		bool TokenData = false;
		string PropertyTokens;
		
		PropertyNameData = (string*)&iter->first;
		
		PropertyData = SplitValues(*PropertyNameData);
			
		for(map<string,string>::iterator dataiter = PropertyData.begin();
			dataiter != PropertyData.end(); dataiter++){
			
			if (dataiter->first == "VALUE"){
				
				RecurranceDateDataValue[ObjectSeekCount] = dataiter->second;
				
			} else if (dataiter->first == "TZID"){
				
				RecurranceDateDataTimeZoneParam[ObjectSeekCount] = dataiter->second;
				
			} else {
				
				if (TokenData == false){
					TokenData = true;
				} else {
					PropertyTokens += ";";
				}
				
				PropertyTokens += dataiter->first;
				PropertyTokens += "=";
				PropertyTokens += dataiter->second;
				
			}
				
		}
		
		if (PropertyTokens.size() > 0){
			RecurranceDateDataTokens[ObjectSeekCount] = PropertyTokens;
		}
			
		RecurranceDateData[ObjectSeekCount] = iter->second;
		
		ObjectSeekCount++;
		
	}

	// Process VALARM section.
	
	int SeekCount = 0;
	int AlarmObjectCount = 0;
	
	bool AlarmActionFound = false;
	
	for (vector<vector<string>>::iterator iter = EventAlarmName.begin();
		iter != EventAlarmName.end(); iter++){
			
		CalendarAlarmDataStruct NewAlarmData;
			
		// Process the data from ACTION.
	
		bool AlarmActionFound = false;
		bool AlarmTriggerFound = false;
		bool AlarmDurationFound = false;
		bool AlarmDescriptionFound = false;
		bool AlarmSummaryFound = false;
			
		DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], 
				&EventAlarmData[SeekCount], false, "ACTION");
	
		if (DataReceived.begin() != DataReceived.end()){
	
			try {
				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;
		
		}
		
		// Check if a value was set for AlarmAction, otherwise
		// process the next VALARM section.
		
		if (NewAlarmData.AlarmAction.size() < 1){
			
			SeekCount++;
			continue;
			
		}
		
		// Check if AlarmAction is DISPLAY, AUDIO or EMAIL.
		// Process the next VALARM section if not.
		
		if (NewAlarmData.AlarmAction == "AUDIO"){
			
			NewAlarmData.AlarmType = CALENDARALARM_AUDIO;
			
		} else if (NewAlarmData.AlarmAction == "DISPLAY"){
			
			NewAlarmData.AlarmType = CALENDARALARM_DISPLAY;
			
		} else if (NewAlarmData.AlarmAction == "EMAIL"){
			
			NewAlarmData.AlarmType = CALENDARALARM_EMAIL;
			
		} else {
		
			SeekCount++;
			continue;
			
		}
		
		// Process the data from TRIGGER.
		
		DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], false, "TRIGGER");
	
		if (DataReceived.begin() != DataReceived.end()){
	
			bool TokenData = false;
			string PropertyTokens;
		
			PropertyNameData = (string*)&DataReceived.begin()->first;
		
			PropertyData = SplitValues(*PropertyNameData);
		
			for(map<string,string>::iterator iter = PropertyData.begin();
				iter != PropertyData.end(); iter++){
			
				if (iter->first == "VALUE"){
				
					NewAlarmData.TriggerValue = iter->second;
				
				} else if (iter->first == "RELATED"){
				
					NewAlarmData.TriggerRelated = iter->second;
				
				} else {
				
					if (TokenData == false){
						TokenData = true;
					} else {
						PropertyTokens += ";";
					}
				
					PropertyTokens += iter->first;
					PropertyTokens += "=";
					PropertyTokens += iter->second;
				
				}
				
			}
		
			if (PropertyTokens.size() > 0){
				NewAlarmData.TriggerTokens = PropertyTokens;
			}
		
			NewAlarmData.TriggerData = DataReceived.begin()->second;
			AlarmTriggerFound = true;
		
		}
		
		// Process the data from DESCRIPTION.
		
		DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], false, "DESCRIPTION");
	
		if (DataReceived.begin() != DataReceived.end() &&
			(NewAlarmData.AlarmType == CALENDARALARM_DISPLAY ||
			NewAlarmData.AlarmType == CALENDARALARM_EMAIL)){
	
			bool TokenData = false;
			string PropertyTokens;
		
			PropertyNameData = (string*)&DataReceived.begin()->first;
		
			PropertyData = SplitValues(*PropertyNameData);
		
			for(map<string,string>::iterator iter = PropertyData.begin();
				iter != PropertyData.end(); iter++){
			
				if (iter->first == "ALTREP"){
				
					NewAlarmData.DescriptionAltRep = iter->second;
				
				} else if (iter->first == "LANGUAGE"){
				
					NewAlarmData.DescriptionLanguage = iter->second;
				
				} else {
				
					if (TokenData == false){
						TokenData = true;
					} else {
						PropertyTokens += ";";
					}
				
					PropertyTokens += iter->first;
					PropertyTokens += "=";
					PropertyTokens += iter->second;
				
				}
				
			}
		
			if (PropertyTokens.size() > 0){
				NewAlarmData.DescriptionTokens = PropertyTokens;
			}
		
			NewAlarmData.DescriptionData = DataReceived.begin()->second;
			AlarmDescriptionFound = true;
		
		}
		
		// Process data from SUMMARY.
		
		DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], false, "SUMMARY");
	
		if (DataReceived.begin() != DataReceived.end() &&
			NewAlarmData.AlarmType == CALENDARALARM_EMAIL){
	
			bool TokenData = false;
			string PropertyTokens;
		
			PropertyNameData = (string*)&DataReceived.begin()->first;
		
			PropertyData = SplitValues(*PropertyNameData);
		
			for(map<string,string>::iterator iter = PropertyData.begin();
				iter != PropertyData.end(); iter++){
			
				if (iter->first == "ALTREP"){
				
					NewAlarmData.SummaryAltRep = iter->second;
				
				} else if (iter->first == "LANGUAGE"){
				
					NewAlarmData.SummaryLanguage = iter->second;
				
				} else {
				
					if (TokenData == false){
						TokenData = true;
					} else {
						PropertyTokens += ";";
					}
				
					PropertyTokens += iter->first;
					PropertyTokens += "=";
					PropertyTokens += iter->second;
				
				}
				
			}
		
			if (PropertyTokens.size() > 0){
				NewAlarmData.SummaryTokens = PropertyTokens;
			}
		
			NewAlarmData.SummaryData = DataReceived.begin()->second;
			AlarmSummaryFound = true;
		
		}
		
		// Process data from DURATION.
		
		DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], false, "DURATION");
		
		if (DataReceived.begin() != DataReceived.end()){
	
			try {
				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;
		
		}
		
		// Process data from REPEAT.
		
		DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], false, "REPEAT");
		
		if (DataReceived.begin() != DataReceived.end() && AlarmDurationFound == true){
	
			try {
				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;
		
		} else {
			
			NewAlarmData.DurationData.clear();
			NewAlarmData.DurationTokens.clear();
			
		}
		
		// Process data from ATTENDEE.
		
		DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], true, "ATTENDEE");
	
		ObjectSeekCount = 0;
	
		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("");
			
			bool TokenData = false;
			string PropertyTokens;
		
			PropertyNameData = (string*)&iter->first;
		
			PropertyData = SplitValues(*PropertyNameData);
			
			for(map<string,string>::iterator dataiter = PropertyData.begin();
				dataiter != PropertyData.end(); dataiter++){
			
				if (dataiter->first == "CUTYPE"){
				
					NewAlarmData.AttendeeListCalendarUserType[ObjectSeekCount] = dataiter->second;
				
				} else if (dataiter->first == "MEMBER"){
				
					NewAlarmData.AttendeeListMember[ObjectSeekCount] = dataiter->second;
				
				} else if (dataiter->first == "ROLE"){
				
					NewAlarmData.AttendeeListRole[ObjectSeekCount] = dataiter->second;
				
				} else if (dataiter->first == "PARTSTAT"){
				
					NewAlarmData.AttendeeListParticipationStatus[ObjectSeekCount] = dataiter->second;
				
				} else if (dataiter->first == "RSVP"){
				
					NewAlarmData.AttendeeListRSVP[ObjectSeekCount] = dataiter->second;
				
				} else if (dataiter->first == "DELEGATED-TO"){
				
					NewAlarmData.AttendeeListDelegatedTo[ObjectSeekCount] = dataiter->second;
				
				} else if (dataiter->first == "DELEGATED-FROM"){
				
					NewAlarmData.AttendeeListDelegatedFrom[ObjectSeekCount] = dataiter->second;
				
				} else if (dataiter->first == "SENT-BY"){
				
					NewAlarmData.AttendeeListSentBy[ObjectSeekCount] = dataiter->second;
				
				} else if (dataiter->first == "CN"){
				
					NewAlarmData.AttendeeListCommonName[ObjectSeekCount] = dataiter->second;
				
				} else if (dataiter->first == "DIR"){
				
					NewAlarmData.AttendeeListDirectoryEntry[ObjectSeekCount] = dataiter->second;
				
				} else if (dataiter->first == "LANGUAGE"){
				
					NewAlarmData.AttendeeListLanguage[ObjectSeekCount] = dataiter->second;
				
				} else {
				
					if (TokenData == false){
						TokenData = true;
					} else {
						PropertyTokens += ";";
					}
				
					PropertyTokens += dataiter->first;
					PropertyTokens += "=";
					PropertyTokens += dataiter->second;
				
				}
				
			}
		
			if (PropertyTokens.size() > 0){
				NewAlarmData.AttendeeListTokens[ObjectSeekCount] = PropertyTokens;
			}
			
			NewAlarmData.AttendeeList[ObjectSeekCount] = iter->second;
		
			ObjectSeekCount++;
		
		}
		
		// Process data from ATTACH.
		
		DataReceived = ProcessTextVectors(&EventAlarmName[SeekCount], &EventAlarmData[SeekCount], true, "ATTACH");
	
		ObjectSeekCount = 0;
		
		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("");
			
			bool TokenData = false;
			string PropertyTokens;
		
			PropertyNameData = (string*)&iter->first;
		
			PropertyData = SplitValues(*PropertyNameData);
			
			for(map<string,string>::iterator dataiter = PropertyData.begin();
				dataiter != PropertyData.end(); dataiter++){
			
				if (dataiter->first == "ENCODING"){
				
					NewAlarmData.AttachListEncoding[ObjectSeekCount] = dataiter->second;
				
				} else if (dataiter->first == "VALUE"){
				
					NewAlarmData.AttachListValue[ObjectSeekCount] = dataiter->second;
				
				} else if (dataiter->first == "FMTTYPE"){
				
					NewAlarmData.AttachListFormatType[ObjectSeekCount] = dataiter->second;
				
				} else {
				
					if (TokenData == false){
						TokenData = true;
					} else {
						PropertyTokens += ";";
					}
				
					PropertyTokens += dataiter->first;
					PropertyTokens += "=";
					PropertyTokens += dataiter->second;
				
				}
				
			}
		
			if (PropertyTokens.size() > 0){
				NewAlarmData.AttachListTokens[ObjectSeekCount] = PropertyTokens;
			}
			
			NewAlarmData.AttachList[ObjectSeekCount] = iter->second;
		
			ObjectSeekCount++;
		
		}
		
		// Process data from X-*
		
		AlarmObjectCount = 0;
		
		for(vector<string>::iterator xtokeniter = EventAlarmName[SeekCount].begin(); 
			xtokeniter != EventAlarmName[SeekCount].end(); ++xtokeniter){
			
			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]);
				
			}
		
			AlarmObjectCount++;
		
		}
		
		if (NewAlarmData.AlarmType == CALENDARALARM_AUDIO &&
			AlarmActionFound == true &&
			AlarmTriggerFound == true){
		
			CalendarAlarmData.push_back(NewAlarmData);
			
		} else if (NewAlarmData.AlarmType == CALENDARALARM_DISPLAY &&
			AlarmActionFound == true &&
			AlarmTriggerFound == true &&
			AlarmDescriptionFound == true){

			CalendarAlarmData.push_back(NewAlarmData);
				
		} else if (NewAlarmData.AlarmType == CALENDARALARM_EMAIL &&
			AlarmActionFound == true &&
			AlarmTriggerFound == true &&
			AlarmDescriptionFound == true &&
			AlarmSummaryFound == true){
		
			CalendarAlarmData.push_back(NewAlarmData);
				
		}
			
		SeekCount++;
			
	}
	
	ObjectSeekCount = 0;
	
	// Process data from X-*
	
	for(vector<string>::iterator iter = ObjectName.begin(); 
		iter != ObjectName.end(); ++iter){
			
		bool TokenData = false;
		string PropertyTokens;
		
		if (iter->substr(0,2) == "X-" &&
			iter->size() > 2){
			
			XTokensData.push_back(ObjectData[ObjectSeekCount]);
			XTokensDataTokens.push_back(ObjectName[ObjectSeekCount]);
				
		}
		
		ObjectSeekCount++;
		
	}
	
}