diff -r 000000000000 -r 8466d47a6819 meetingrequest/mrversit2/src/esmricalutil.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/meetingrequest/mrversit2/src/esmricalutil.cpp	Thu Dec 17 08:39:21 2009 +0200
@@ -0,0 +1,395 @@
+/*
+* Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Utility methods for mrversit2.
+*
+*/
+
+
+// Class include.
+#include "emailtrace.h"
+#include "esmricalutil.h"	// NESMRICalUtil
+
+//debug
+
+// User includes.
+#include "esmricalerrors.h"			// Error codes
+#include "esmricalkeywords.h"		// Literals
+#include "cesmricalproperty.h"		// CESMRICalProperty
+#include "cesmricalpropertyparam.h"	// CESMRICalPropertyParam
+
+namespace NESMRICalUtil
+	{
+	/**
+	Finds the first occurence of a character within a string which does not occur
+	between a pair of double quotes.
+	@param aString The string to search.
+	@param aChar The character to search for.
+	@return The position of the character within the string, or KErrNotFound.
+	@internalTechnology
+	*/
+	TInt FindFirstUnquoted(const TDesC& aString, const TChar& aChar)
+		{
+		
+		TBool quoted(EFalse);
+		
+		for (TInt pos = 0; pos < aString.Length(); ++pos)
+			{
+			TChar val(aString[pos]);
+			
+			if (val == KICalQuoteChar)
+				{
+				quoted = !quoted;
+				}
+			else if ((val == aChar) && (!quoted))
+				{
+				return pos;
+				}
+			}
+			
+		return KErrNotFound;
+		}
+
+	/**
+	Finds the first occurence of a character within a string which is not escaped
+	by a backslash character. Searching for a comma will find it in the following
+	strings: "abc," and "abc\\," but will not find it in "abc\," and "abc\\\,".
+	Note that backslash cannot exist unescaped, so cannot be searched for.
+	@param aString The string to search.
+	@param aChar The character to search for.
+	@return The position of the character within the string, or KErrNotFound.
+	@internalTechnology
+	*/
+	TInt FindFirstUnescaped(const TDesC& aString, const TChar& aChar)
+		{
+		
+		TBool escaped(EFalse);
+		
+		for (TInt pos = 0; pos < aString.Length(); ++pos)
+			{
+			TChar val(aString[pos]);
+			
+			if (val == KICalBackslashChar)
+				{
+				escaped = !escaped;
+				}
+			else 
+				{
+				if ((val == aChar) && (!escaped))
+					{
+					return pos;
+					}
+					
+				escaped = EFalse;
+				}
+			}
+		
+		return KErrNotFound;	
+		}
+
+	/**
+	Finds the first occurence of a character within a string, whether or not it
+	is escaped by a backslash character. If it was escaped, however, the
+	aWasEscaped parameter will be set to true. Note that backslash cannot exist
+	unescaped, so cannot be searched for.
+	@param aString The string to search.
+	@param aChar The character to search for.
+	@param aWasEscaped True if the character was escaped, otherwise false.
+	@return The position of the character within the string, or KErrNotFound.
+	@internalTechnology
+	*/
+	TInt FindFirstAndUnescape(const TDesC& aString, const TChar& aChar, TBool& aWasEscaped)
+		{
+		
+		aWasEscaped = EFalse;
+		TBool escaped(EFalse);
+		
+		for (TInt pos = 0; pos < aString.Length(); ++pos)
+			{
+			TChar val(aString[pos]);
+			
+			if (val == KICalBackslashChar)
+				{
+				escaped = !escaped;
+				}
+			else 
+				{
+				if (val == aChar)
+					{
+					aWasEscaped = escaped;
+					return pos;
+					}
+					
+				escaped = EFalse;
+				}
+			}
+		
+		return KErrNotFound;	
+		}
+
+	/**
+	Take a line and extract the name, parameter and value sections.
+	@param aLine A line of text in which to find the data.
+	@param aName A TPtrC referencing the section of aLine containing the name.
+	@param aParameters A TPtrC referencing the section of aLine containing the
+	parameters.
+	@param aValues A TPtrC referencing the section of aLine containing the
+	values.
+	@return An error code: either KErrNone or KErrPropertyHasNoValue - avoid
+	leaving so we can try and recover without the overhead of a trap.
+	@internalTechnology
+	*/
+	TInt ExtractSectionsL(const TDesC& aLine, TPtrC& aName, TPtrC& aParameters, TPtrC& aValues)
+		{
+		
+		// Find the value delimiter.
+		const TInt colon = FindFirstUnquoted(aLine, KICalColonChar);
+
+		// Vague check that the property has a value.
+		if ((colon == KErrNotFound) || (colon == (aLine.Length() - 1)))
+			{
+			return KErrPropertyHasNoValue;	// No value given - the property is invalid.
+			}
+
+		// Find the first parameter delimiter.
+		const TInt firstSemiColon = aLine.Locate(KICalSemiColonChar);
+			
+		// Find the characters dividing each section:
+		TUint endOfName(colon);
+
+		if ((firstSemiColon != KErrNotFound) && (firstSemiColon < colon))
+			{
+			endOfName = firstSemiColon;
+			}
+		
+		// Set the name, parameters and values:
+		aName.Set(aLine.Left(endOfName));
+	
+		if (endOfName < colon)
+			{
+			const TInt startOfParameters = endOfName + 1;
+			aParameters.Set(aLine.Mid(startOfParameters, colon - startOfParameters));
+			}
+		else
+			{
+			aParameters.Set(aLine.Left(0));	// No parameters.
+			}
+		
+		aValues.Set(aLine.Mid(colon + 1));
+		
+		return KErrNone;
+		}
+
+	/**
+	Takes two strings, representing the parameters and values of a property, and
+	the property itself, and populates the latter with the contents of the first
+	two.
+	@param aParameters A string of parameters.
+	@param aValues A string of values.
+	@param aProperty A property to add the parameters and values to.
+	@internalTechnology
+	*/
+	void ExtractPropertyL(const TDesC& aParameters, const TDesC& aValues, CESMRICalProperty& aProperty)
+		{
+		
+		ExtractParametersL(aParameters, aProperty);
+		ExtractPropertyValuesL(aValues, aProperty);
+		
+		}
+
+	/**
+	Takes a string representing the parameters of a property, and the property
+	itself, and populates the property with the contents of the string.
+	@param aParameters A string of parameters.
+	@param aProperty A property to add the parameters and values to.
+	@internalTechnology
+	*/
+	void ExtractParametersL(const TDesC& aParameters, CESMRICalProperty& aProperty)
+		{
+		
+		TPtrC remainder(aParameters);
+		
+		while (remainder.Length() > 0)
+			{
+			TInt endOfParameter(FindFirstUnquoted(remainder, KICalSemiColonChar));
+			
+			if (endOfParameter == KErrNotFound)
+				{
+				endOfParameter = remainder.Length();
+				}
+			
+			CESMRICalPropertyParam& param = aProperty.AddPropertyParamL();
+			ExtractParameterL(remainder.Left(endOfParameter), param);
+			
+			// Remove the parameter if it has no value.
+			if (param.Values().Count() == 0)
+				{
+				aProperty.RemovePropertyParamL(param);
+				}
+
+			if (endOfParameter < remainder.Length())
+				{
+				remainder.Set(remainder.Mid(endOfParameter + 1));
+				}
+			else
+				{
+				break;
+				}
+			}
+		}
+
+	/**
+	Takes a string representing a single parameter, and a class to store it in.
+	@param aParameter A string of the form <parameter>[=<value>[,value]*].
+	@param aPropertyParam A property parameter to store the data in.
+	@internalTechnology
+	*/
+	void ExtractParameterL(const TDesC& aParameter, CESMRICalPropertyParam& aPropertyParam)
+		{
+		
+		TInt firstEquals(aParameter.Locate(KICalEqualsChar));
+		TInt endOfType(aParameter.Length());
+		
+		if (firstEquals != KErrNotFound)
+			{
+			endOfType = firstEquals;
+			}
+		
+		aPropertyParam.SetTypeL(aParameter.Left(endOfType));
+		
+		if (endOfType < aParameter.Length())
+			{
+			ExtractParameterValuesL(aParameter.Mid(endOfType + 1), aPropertyParam);
+			}
+		}
+
+	/**
+	Takes a string of comma separated values and adds them to a parameter.
+	@param aValues A string of the form <value>[,<value>]*.
+	@param aPropertyParam A property parameter to store the values in.
+	@internalTechnology
+	*/
+	void ExtractParameterValuesL(const TDesC& aValues, CESMRICalPropertyParam& aPropertyParam)
+		{
+		
+		TPtrC remainder(aValues);
+		
+		while (remainder.Length() > 0)
+			{
+			TInt endOfValue(FindFirstUnquoted(remainder, KICalCommaChar));
+			
+			if (endOfValue == KErrNotFound)
+				{
+				endOfValue = remainder.Length();
+				}
+			
+			// Add value.
+			if (endOfValue > 0)
+				{
+				aPropertyParam.AddValueL(remainder.Left(endOfValue));
+				}
+			
+			if (endOfValue < remainder.Length())
+				{
+				remainder.Set(remainder.Mid(endOfValue + 1));
+				}
+			else
+				{
+				break;
+				}
+			}
+		}
+
+	/**
+	Takes a string of comma separated values and adds them to a property.
+	@param aValues A string of the form <value>[,<value>]*.
+	@param aProperty A property to store the values in.
+	@param aEscaping Used for dealing with incorrect output from other applications.
+	@leave Leaves with KErrUnknown if the value of aEscaping is not known.
+	@internalTechnology
+	*/
+	void ExtractPropertyValuesL(const TDesC& aValues, CESMRICalProperty& aProperty, TEscaping aEscaping)
+		{
+		
+		TPtrC remainder(aValues);
+		TBool wasEscaped(EFalse);
+		
+		while (remainder.Length() > 0)
+			{
+			TInt endOfValue( KErrNotFound );
+			
+			switch (aEscaping)
+				{
+				case EEscapeNormal:
+					endOfValue = FindFirstUnescaped(remainder, KICalCommaChar);
+					break;
+				case EEscapeValueSeparators:
+					endOfValue = FindFirstAndUnescape(remainder, KICalCommaChar, wasEscaped);
+					break;
+				default:
+					User::Leave(KErrUnknown);
+					break;
+				}
+			
+			if (endOfValue == KErrNotFound)
+				{
+				endOfValue = remainder.Length();
+				}
+			
+			// Add value.
+			if (endOfValue > 0)
+				{
+				aProperty.AddValueL(remainder.Left(endOfValue - (wasEscaped ? 1 : 0)));
+				}
+			
+			if (endOfValue < remainder.Length())
+				{
+				remainder.Set(remainder.Mid(endOfValue + 1));
+				}
+			else
+				{
+				break;
+				}
+			}
+		}
+		
+	/**
+	Determines if the given property has a type which holds a text value.
+	@param aProperty The property to test.
+	@return ETrue if the property value is a "text" type.
+	@internalTechnology
+	*/
+	TBool PropertyHasTextValueL(const CESMRICalProperty& aProperty)
+		{
+		
+		const TDesC& type = aProperty.Type();
+		
+		// First check if it's an X-type.
+		if ((type.Length() >= 2) && (type.Left(2).CompareF(KICalXProperty) == 0))
+			{
+			return ETrue;
+			}
+
+		// Else return ETrue if the property is PRODID, UID, CATEGORIES, COMMENT, CONTACT,
+		// DESCRIPTION, LOCATION, RELATED-TO, RESOURCES, SUMMARY, TZID or TZNAME.
+		return ((type.CompareF(KICalProdId) == 0) || (type.CompareF(KICalUid) == 0) ||
+			(type.CompareF(KICalCategories) == 0) || (type.CompareF(KICalComment) == 0) ||
+			(type.CompareF(KICalContact) == 0) || (type.CompareF(KICalDescription) == 0) || 
+			(type.CompareF(KICalLocation) == 0) || (type.CompareF(KICalRelatedto) == 0) || 
+			(type.CompareF(KICalResources) == 0) || (type.CompareF(KICalSummary) == 0) || 
+			(type.CompareF(KICalTzid) == 0) || (type.CompareF(KICalTzname) == 0));
+		}
+	}
+
+// End of File
+