diff -r d189ee25cf9d -r 3533d4323edc meetingrequest/mrversit2/src/cesmricalrulesegment.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/meetingrequest/mrversit2/src/cesmricalrulesegment.cpp	Wed Sep 01 12:28:57 2010 +0100
@@ -0,0 +1,341 @@
+/*
+* 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: This file implements class CESMRICalRuleSegment.
+*
+*/
+
+
+// Class include.
+#include "emailtrace.h"
+#include "cesmricalrulesegment.h"	// CESMRICalRuleSegment
+
+//debug
+
+// User includes.
+#include "esmricalkeywords.h"	// Literals
+#include "esmricalerrors.h"		// Error codes
+#include "cesmricalvalue.h"		// CESMRICalValue
+
+/**
+Static factory construction. Not exported as this class is only provided as a
+utility for breaking down recurrence rules into segments - it is only ever
+created by the CESMRICalValue class.
+@param aSource TDesC containing the rule segment information
+@return A new rule segment
+@internalTechnology
+*/
+CESMRICalRuleSegment* CESMRICalRuleSegment::NewL(const TDesC& aSource)
+	{
+    FUNC_LOG;
+	
+	CESMRICalRuleSegment* self = CESMRICalRuleSegment::NewLC(aSource);
+	CleanupStack::Pop(self);
+	
+	return self;
+	}
+
+/**
+Static factory construction. Not exported as this class is only provided as a
+utility for breaking down recurrence rules into segments - it is only ever
+created by the CESMRICalValue class.
+@param aSource TDesC containing the rule segment information
+@return A new rule segment
+@internalTechnology
+*/
+CESMRICalRuleSegment* CESMRICalRuleSegment::NewLC(const TDesC& aSource)
+	{
+    FUNC_LOG;
+	
+	CESMRICalRuleSegment* self = new (ELeave) CESMRICalRuleSegment;
+	CleanupStack::PushL(self);
+	self->ConstructL(aSource);
+	
+	return self;
+	}
+
+/**
+Destructor
+@internalTechnology
+*/
+CESMRICalRuleSegment::~CESMRICalRuleSegment()
+	{
+    FUNC_LOG;
+	
+	iValues.ResetAndDestroy();
+	delete iTypeString;
+	}
+
+/**
+Access method for the segment type as a descriptor.
+@return The segment type as a descriptor or an empty descriptor if no type is
+set.
+@publishedPartner
+*/
+EXPORT_C const TDesC& CESMRICalRuleSegment::TypeName() const
+	{
+    FUNC_LOG;
+	
+	if (iTypeString)
+		{
+		return *iTypeString;
+		}
+		
+	// Else type is not set due to SetTypeL() leaving.
+	return KNullDesC;
+	}
+
+/**
+Access method for the value array.
+@return The value array.
+@publishedPartner
+*/
+EXPORT_C const RPointerArray<CESMRICalValue>& CESMRICalRuleSegment::Values() const
+	{
+	return iValues;
+	}
+	
+/**
+Access method for the segment type as an enumeration.
+@return The segment type as an enumeration.
+@publishedPartner
+*/
+EXPORT_C CESMRICalRuleSegment::TSegmentType CESMRICalRuleSegment::Type() const
+	{
+    FUNC_LOG;
+	return iType;
+	}
+
+/**
+Access method for the segment value as a frequency enumeration. Only the first
+value is used.
+@return The segment value as a frequency.
+@leave Leaves with KErrRuleTypeNotFrequency if this rule segment does not
+contain a frequency.
+@leave Leaves with KErrRuleFrequencyUnknown if the frequency cannot be
+determined.
+@publishedPartner
+*/
+EXPORT_C CESMRICalRuleSegment::TFreq CESMRICalRuleSegment::FreqL() const
+	{
+    FUNC_LOG;
+	
+	// Type MUST be frequency if this method is called.
+	
+	if (iType != ESegFreq)
+		{
+		User::Leave(KErrRuleTypeNotFrequency);
+		}
+	
+	// The rule must have at least one value.
+	// If it has more than one then the first value is taken (for recoverability).
+	if (iValues.Count() == 0)
+		{
+		User::Leave(KErrRuleFrequencyUnknown);
+		}
+	
+	// Compare the first value.
+	const TDesC& firstValue = iValues[0]->TextL();
+	
+	if (firstValue.CompareF(KICalYearly) == 0)
+		{
+		return EFreqYearly;
+		}
+	else if (firstValue.CompareF(KICalMonthly) == 0)
+		{
+		return EFreqMonthly;
+		}
+	else if (firstValue.CompareF(KICalWeekly) == 0)
+		{
+		return EFreqWeekly;
+		}
+	else if (firstValue.CompareF(KICalDaily) == 0)
+		{
+		return EFreqDaily;
+		}
+	else if (firstValue.CompareF(KICalHourly) == 0)
+		{
+		return EFreqHourly;
+		}
+	else if (firstValue.CompareF(KICalMinutely) == 0)
+		{
+		return EFreqMinutely;
+		}
+	else if (firstValue.CompareF(KICalSecondly) == 0)
+		{
+		return EFreqSecondly;
+		}
+	
+	// Else...
+	User::Leave(KErrRuleFrequencyUnknown);
+	
+	return EFreqDaily;	// Never reached.
+	}
+	
+/**
+Constructor
+@internalTechnology
+*/
+CESMRICalRuleSegment::CESMRICalRuleSegment()
+	{
+    FUNC_LOG;
+	}
+
+/**
+Internal construction.
+@param aSource Descriptor containing details of the segment.
+@leave Leaves with KErrInvalidRuleSegment if the rule segment has no "type".
+@leave Leaves with KErrRuleSegmentHasNoValue if the rule segment has no value.
+@leave Leaves if there is an error adding a value to this rule segment.
+@internalTechnology
+*/
+void CESMRICalRuleSegment::ConstructL(const TDesC& aSource)
+	{
+    FUNC_LOG;
+	
+	// We've been passed a descriptor containing the type string followed
+	// by an equals sign followed by (one or more) comma separated values.
+	// All escaping is assumed to have been previously removed.
+	
+	// Get the position of the equals sign.
+	const TInt equalsSignPos = aSource.Locate(KICalEqualsChar);
+	
+	if (equalsSignPos < 1)	// "Type" must be at least one character long.
+		{
+		User::Leave(KErrInvalidRuleSegment);
+		}
+
+	if ((equalsSignPos + 1) >= aSource.Length())	// Value must be at least one character long.
+		{
+		User::Leave(KErrRuleSegmentHasNoValue);
+		}
+
+	// Any text before this point is the type string.
+	SetTypeL(aSource.Left(equalsSignPos));
+	
+	// Any text after this point contains value information
+	TPtrC aRemainder(aSource.Mid(equalsSignPos + 1));
+	
+	while (aRemainder.Length() > 0)
+		{
+		// Find the next comma.
+		TInt endOfValue(aRemainder.Locate(KICalCommaChar));
+		
+		if (endOfValue == KErrNotFound)
+			{
+			endOfValue = aRemainder.Length();
+			}
+		
+		// Add value.
+		if (endOfValue > 0)
+			{
+			CESMRICalValue* val = CESMRICalValue::NewLC();
+			val->SetTextL(aRemainder.Left(endOfValue));
+			User::LeaveIfError(iValues.Append(val));
+			CleanupStack::Pop(val);
+			}
+		
+		// Set the remainder.
+		if (endOfValue < (aRemainder.Length() - 1))	// Value must be at least one character long.
+			{
+			aRemainder.Set(aRemainder.Mid(endOfValue + 1));
+			}
+		else
+			{
+			break;
+			}
+		}
+	
+	}
+
+/**
+Sets the type of a rule segment.
+@param aType The type as a descriptor.
+@internalTechnology
+*/
+void CESMRICalRuleSegment::SetTypeL(const TDesC& aType)
+	{
+    FUNC_LOG;
+
+	// Set the type.
+	
+	if (aType.CompareF(KICalFreq) == 0)
+		{
+		iType = ESegFreq;
+		}
+	else if (aType.CompareF(KICalUntil) == 0)
+		{
+		iType = ESegUntil;
+		}
+	else if (aType.CompareF(KICalCount) == 0)
+		{
+		iType = ESegCount;
+		}
+	else if (aType.CompareF(KICalInterval) == 0)
+		{
+		iType = ESegInterval;
+		}
+	else if (aType.CompareF(KICalBySecond) == 0)
+		{
+		iType = ESegBySecond;
+		}
+	else if (aType.CompareF(KICalByMinute) == 0)
+		{
+		iType = ESegByMinute;
+		}
+	else if (aType.CompareF(KICalByHour) == 0)
+		{
+		iType = ESegByHour;
+		}
+	else if (aType.CompareF(KICalByDay) == 0)
+		{
+		iType = ESegByDay;
+		}
+	else if (aType.CompareF(KICalByMonthDay) == 0)
+		{
+		iType = ESegByMonthDay;
+		}
+	else if (aType.CompareF(KICalByYearDay) == 0)
+		{
+		iType = ESegByYearDay;
+		}
+	else if (aType.CompareF(KICalByWeekNo) == 0)
+		{
+		iType = ESegByWeekNo;
+		}
+	else if (aType.CompareF(KICalByMonth) == 0)
+		{
+		iType = ESegByMonth;
+		}
+	else if (aType.CompareF(KICalBySetPos) == 0)
+		{
+		iType = ESegByPos;
+		}
+	else if (aType.CompareF(KICalWkSt) == 0)
+		{
+		iType = ESegWkSt;
+		}
+	else
+		{
+		iType = ESegExtension;
+		}
+	
+	// Set the type string.
+	delete iTypeString;
+	iTypeString = NULL;
+	iTypeString = aType.AllocL();
+	
+	}
+
+// End of File
+