/*

* 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:   Implements the definition of CICalValue.

*

*/

// Class include.

#include "ICalValue.h"	// CICalValue

//debug

#include "calendarengines_debug.h"

// User includes.

#include "ICalKeyWords.h"		// Literals

#include "ICalRuleSegment.h"	// CICalRuleSegment

// Constants.

// Maximum number of characters to use for storing TInt.

// (The maximum number of characters for storing a decimal representation of

// KMaxTInt, KMinTInt or even KMaxTUint is 10 on current implementations.

// The maximum number of characters for storing a decimal representation of 

// KMaxTUint64 is 20, so using this for future proofing.)

const TInt KICalTIntWidth = 20;

// Width of "HHMMSS"

const TInt KICalTimeWidth = 6;

// Width of "YYYYMMDD"

const TInt KICalDateWidth = 8;

// Width of "YYYYMMDDTHHMMSS" (note the 'T' in the middle)

const TInt KICalDateTimeWidth = KICalDateWidth + KICalTimeWidth + 1;

// Width of a duration.

const TInt KICalDurationWidth = 25;

// Width of a short format UTC offset.

const TInt KShortFormatUtcOffsetWidth = 5;	// The width of (e.g.) +1000.

// Width of a long format UTC offset.

const TInt KLongFormatUtcOffsetWidth = 7;	// The width of (e.g.) -013045.

// Time constants.	

const TInt KICalSecondsPerMinute =     60;

const TInt KICalSecondsPerHour   =   3600; // That is:      60*60;

const TInt KICalSecondsPerDay    =  86400; // That is:   24*60*60;

const TInt KICalSecondsPerWeek   = 604800; // That is: 7*24*60*60;

// Time characters

const TUint KICalUtcChar('Z');		// UTC time.

const TUint KICalTimeChar('T');		// Date/time separator.

const TUint KICalPeriodChar('/');	// Period separator.

const TUint KICalMicroChar('.');	// Second/microsecond separator.

const TUint KICalDurationChar('P');	// Duration.

const TUint KICalWeekChar('W');		// Week.

const TUint KICalDayChar('D');		// Day.

const TUint KICalHourChar('H');		// Hour.

const TUint KICalMinuteChar('M');	// Minute.

const TUint KICalSecondChar('S');	// Second.

const TUint KICalPositiveChar('+');	// Positive values.

const TUint KICalNegativeChar('-');	// Negative values.

// Date format.

_LIT(KICalDateFormat, "%F%Y%M%D");

/**

Static factory construction.

@return A new CICalValue.

@publishedPartner

*/

EXPORT_C CICalValue* CICalValue::NewL()

	{

	TRACE_ENTRY_POINT;

	CICalValue* self  = CICalValue::NewLC();

	CleanupStack::Pop(self);

	TRACE_EXIT_POINT;

	return self;

	}

/**

Static factory construction.

@return A new CICalValue.

@publishedPartner

*/

EXPORT_C CICalValue* CICalValue::NewLC()

	{

	TRACE_ENTRY_POINT;

	CICalValue* self  = new (ELeave) CICalValue;

	CleanupStack::PushL(self);

	self->ConstructL();

	TRACE_EXIT_POINT;

	return self;

	}

/**

Destructor.

@publishedPartner

*/

CICalValue::~CICalValue()

	{

	TRACE_ENTRY_POINT;

	TRACE_EXIT_POINT;

	delete iValue;

	}

/**

Returns a copy of the value as an 8-bit string. User takes ownership of the

returned descriptor, which is also left on the Cleanup Stack. Note that each

16-bit word in the value is copied into a single 8-bit word in the returned

descriptor and any values greater than 256 are set to the value '1'. This will

not occur if the value was set using SetBinaryL().

@return An 8-bit copy of the value.

@publishedPartner

*/

EXPORT_C HBufC8* CICalValue::BinaryLC() const

	{

	TRACE_ENTRY_POINT;

	CheckNullValueL();

	HBufC8* buf = HBufC8::NewLC(iValue->Length());

	buf->Des().Copy(*iValue);

	TRACE_EXIT_POINT;

	return buf;

	}

/**

Stores an 8-bit buffer in the CICalValue. Each 8-bit value is stored within a

16-bit value internally.

@param aBuffer The 8-bit buffer to be stored.

@publishedPartner

*/

EXPORT_C void CICalValue::SetBinaryL(const TDesC8& aBuffer)

	{

	TRACE_ENTRY_POINT;

	PrepareValuePointer();

	iValue = HBufC::NewL(aBuffer.Length());

	iValue->Des().Copy(aBuffer);

	}

/**

Returns the CICalValue as a TBool. Leaves if the value cannot be read as a TBool.

@return TBool stored in the value.

@leave KErrCorrupt if value is not a valid Boolean value.

@publishedPartner

*/

EXPORT_C TBool CICalValue::BooleanL() const

	{

	TRACE_ENTRY_POINT;

	CheckNullValueL();

	if (iValue->Des() == KICalTrue)

		{

		TRACE_EXIT_POINT;

		return ETrue;

		}

	else if (iValue->Des() == KICalFalse)

		{

		TRACE_EXIT_POINT;

		return EFalse;

		}

	// Else...

	User::Leave(KErrCorrupt);

	TRACE_EXIT_POINT;

	return EFalse;	// Never reached.

	}

/**

Stores a TBool in the CICalValue.

@param aBool TBool to be stored.

@publishedPartner

*/

EXPORT_C void CICalValue::SetBooleanL(TBool aBool)

	{

	TRACE_ENTRY_POINT;

	PrepareValuePointer();

	if (aBool) // ETrue

		{

		iValue = KICalTrue().AllocL();

		}

	else	// EFalse

		{

		iValue = KICalFalse().AllocL();

		}

	TRACE_EXIT_POINT;

	}

/**

Returns the CICalValue as a date (TTime).

@param aDate TTime to store the date in.

@publishedPartner

*/

EXPORT_C void CICalValue::GetDateL(TTime& aDate) const

	{

	TRACE_ENTRY_POINT;

	CheckNullValueL();

	GetDateFromValueL(aDate);

	TRACE_EXIT_POINT;

	}

/**

Stores a date (TTime) as the value.

@param aDate TTime to be stored.

@publishedPartner

*/

EXPORT_C void CICalValue::SetDateL(const TTime& aDate)

	{

	TRACE_ENTRY_POINT;

	PrepareValuePointer();

	iValue = HBufC::NewL(KICalDateWidth);

	AppendDateToValueL(aDate);

	TRACE_EXIT_POINT;

	}

/**

Returns the CICalValue as a time (TTime).

@param aTime TTime to store the time in.

@param aTzType Enumeration showing whether the time represents local time (not

supported), UTC or a custom time zone.

@publishedPartner

*/

EXPORT_C void CICalValue::GetTimeL(TTime& aTime, TTimeZoneType& aTzType) const

	{

	TRACE_ENTRY_POINT;

	CheckNullValueL();

	GetTimeFromValueL(aTime, aTzType);

	TRACE_EXIT_POINT;

	}

/**

Stores a time (TTime) as the value.

@param aTime TTime to be stored.

@param aTzType Enumeration showing whether the time represents local time (not

supported), UTC or a custom time zone.

@publishedPartner

*/

EXPORT_C void CICalValue::SetTimeL(const TTime& aTime, TTimeZoneType aTzType)

	{

	TRACE_ENTRY_POINT;

	PrepareValuePointer();

	if (aTzType == EUtcTime)

		{

		iValue = HBufC::NewL(KICalTimeWidth + 1);

		AppendTimeToValueL(aTime);

		iValue->Des().Append(KICalUtcChar);	// Append a 'Z' to signify UTC.

		}

	else if (aTzType == ESpecifiedTimeZone || aTzType == EFloatingTime)

		{

		iValue = HBufC::NewL(KICalTimeWidth);

		AppendTimeToValueL(aTime);

		}

	TRACE_EXIT_POINT;

	}

/**

Returns the CICalValue as a date/time (TTime).

@param aDateTime TTime to store the date/time in.

@param aTzType Enumeration showing whether the time represents local time (not

supported), UTC or a custom time zone.

@param aFirstCharacterNum Skip this many characters of the internal buffer

@leave Leaves with KErrCorrupt if the value is not a valid date/time.

@publishedPartner

*/

EXPORT_C void CICalValue::GetDateTimeL(TTime& aDateTime, TTimeZoneType& aTzType, TInt aFirstCharacterNum) const

	{

	TRACE_ENTRY_POINT;

	CheckNullValueL();

	// The GetTimeFromValueL() function explicitly sets the TTime passed

	// in, so create a new TTime for the date and merge with the time later.

	TTime theDate;

	GetDateFromValueL(theDate, aFirstCharacterNum);

	// Only start looking for the time at character position KICalDateWidth

	// plus one for the 'T' separator.

	if (iValue->Length() > aFirstCharacterNum + KICalDateWidth + 1)

		{

		TTime theTime;

		if ((*iValue)[aFirstCharacterNum + KICalDateWidth] != KICalDateTimeSeparator)

			{

			User::Leave(KErrCorrupt);

			}

		GetTimeFromValueL(theTime, aTzType, aFirstCharacterNum + KICalDateWidth + 1);

		// Set the time component.

		TDateTime dateValues(theDate.DateTime());

		TDateTime combinedValues(theTime.DateTime());

		// Set the date component.

		combinedValues.SetYear(dateValues.Year());

		combinedValues.SetMonth(dateValues.Month());

		combinedValues.SetDay(dateValues.Day());

		// Set the value to return.

		aDateTime = TTime(combinedValues);

		}

	else

		{

		// There is no time component specified.  For compatibility with MS Outlook,

		// which can export RECURRENCE-ID fields with no time component, we use

		// a default time of '00:00'

		aDateTime = theDate;

		}

	TRACE_EXIT_POINT;

	}

/**

Stores a date/time (TTime) as the value.

@param aDateTime TTime to be stored.

@param aTzType Enumeration showing whether the time represents floating time,

UTC or a custom time zone.

@publishedPartner

*/

EXPORT_C void CICalValue::SetDateTimeL(const TTime& aDateTime, TTimeZoneType aTzType)

	{

	TRACE_ENTRY_POINT;

	PrepareValuePointer();

	if (aTzType == EUtcTime)

		{

		iValue = HBufC::NewL(KICalDateTimeWidth + 1);

		AppendDateToValueL(aDateTime);

		iValue->Des().Append(KICalTimeChar);

		AppendTimeToValueL(aDateTime);

		iValue->Des().Append(KICalUtcChar);	// For UTC Time.

		}

	else if (aTzType == ESpecifiedTimeZone || aTzType == EFloatingTime)

		{

		iValue = HBufC::NewL(KICalDateTimeWidth);

		AppendDateToValueL(aDateTime);

		iValue->Des().Append(KICalTimeChar);

		AppendTimeToValueL(aDateTime);

		}

	TRACE_EXIT_POINT;

	}

/**

Returns the CICalValue as a Duration (TTimeIntervalSeconds).

@return TTimeInterval containing the value's duration.

@publishedPartner

*/

EXPORT_C TTimeIntervalSeconds CICalValue::DurationL() const

	{

	TRACE_ENTRY_POINT;

	CheckNullValueL();

	TTimeIntervalSeconds theTis;

	GetTimeIntervalFromValueL(theTis);

    TRACE_EXIT_POINT;

	return theTis;

	}

/**

Stores a Duration (TTimeIntervalSeconds) as the value.

@param aDuration TTimeIntervalSeconds to be stored.

@publishedPartner

*/

EXPORT_C void CICalValue::SetDurationL(TTimeIntervalSeconds aDuration)

	{

	TRACE_ENTRY_POINT;

	// e.g. P15DT5H0M20S

	PrepareValuePointer();

	iValue = HBufC::NewL(KICalDurationWidth);

	TInt durInt(aDuration.Int());

	if (durInt < 0)

		{

		// First character is a '-' for negative values

		iValue->Des().Append(KICalNegativeChar);

		// Now we've set the sign, change the durInt to +ve

		durInt =- durInt;

		}

	iValue->Des().Append(KICalDurationChar);

	// Add day portion.

	TInt numDays(durInt / KICalSecondsPerDay);

	durInt -= (numDays * KICalSecondsPerDay);

	iValue->Des().AppendNum(numDays);

	iValue->Des().Append(KICalDayChar);

	iValue->Des().Append(KICalTimeChar);

	// Add hour portion.

	TInt numHours(durInt / KICalSecondsPerHour);

	durInt -= (numHours * KICalSecondsPerHour);

	iValue->Des().AppendNum(numHours);

	iValue->Des().Append(KICalHourChar);

	// Add minute portion.

	TInt numMinutes(durInt / KICalSecondsPerMinute);

	durInt -= (numMinutes * KICalSecondsPerMinute);

	iValue->Des().AppendNum(numMinutes);

	iValue->Des().Append(KICalMinuteChar);

	// Add second portion.

	TInt numSeconds(durInt);

	iValue->Des().AppendNum(numSeconds);

	iValue->Des().Append(KICalSecondChar);

    TRACE_EXIT_POINT;

	}

/**

Returns the CICalValue as a Float (TReal).

@param aFloat The value to return.

@leave Leaves if there is an error reading a float.

@publishedPartner

*/

EXPORT_C void CICalValue::GetFloatL(TReal& aFloat) const

	{

    TRACE_ENTRY_POINT;

	CheckNullValueL();

	TLex stringLex(iValue->Des());

	User::LeaveIfError(stringLex.Val(aFloat));

	TRACE_EXIT_POINT;

	}

/**

Stores a float (TReal) as the value.

@param aFloat The value to store.

@publishedPartner

*/

EXPORT_C void CICalValue::SetFloatL(const TReal& aFloat)

	{

	TRACE_ENTRY_POINT;

	PrepareValuePointer();

	iValue = HBufC::NewL(KDefaultRealWidth);

	TRealFormat format;

	iValue->Des().Num(aFloat, format);

	TRACE_EXIT_POINT;

	}

/**

Returns the CICalValue as an Integer.

@return The integer requested.

@publishedPartner

*/

EXPORT_C TInt CICalValue::IntegerL() const

	{

	TRACE_ENTRY_POINT;

	CheckNullValueL();

	TRACE_EXIT_POINT;

	return ReadIntL(iValue->Des());

	}

/**

Stores an Integer as the value.

@param aInt The integer to be stored.

@publishedPartner

*/

EXPORT_C void CICalValue::SetIntegerL(TInt aInt)

	{

	TRACE_ENTRY_POINT;

	PrepareValuePointer();

	iValue = HBufC::NewL(KICalTIntWidth);

	iValue->Des().Num(aInt);

	TRACE_EXIT_POINT;

	}

/**

Returns the CICalValue as a Period (two TTimes).

@param aStartTime TTime marking the beginning of the period.

@param aStartTzType Enumeration showing whether the start time represents local

time (not supported), UTC or a custom time zone.

@param aEndTime TTime marking the end of the period.

@param aEndTzType Enumeration showing whether the end time represents local

time (not supported), UTC or a custom time zone.

@publishedPartner

*/

EXPORT_C void CICalValue::GetPeriodL(

	TTime& aStartTime, 

	TTimeZoneType& aStartTzType, 

	TTime& aEndTime,