// Copyright (c) 1997-2009 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:

//

#include <vrecur.h>

#include "verror.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "versit_internal.h"

#endif

//

// CWeekDayArray

//

EXPORT_C CWeekDayArray::CWeekDayArray()

: iArray(NULL)

/** Constructs an array of the days in the week. */

	{}

EXPORT_C CWeekDayArray::~CWeekDayArray()

/** Frees all resources owned by the object, prior to its destruction. */

	{

	delete iArray;

	}

EXPORT_C void CWeekDayArray::ExternalizeL(RWriteStream& aStream)

/** Externalises the array of days in the week to a write stream.

Writes the first two characters of each day name, for instance "MO TU WE".

The presence of this function means that the standard templated operator<<() 

(defined in s32strm.h) is available to externalise objects of this class.

@param aStream Stream to which the array is to be externalised. */

	{

	if (iArray)

		{

		TInt count=iArray->Count();

		for (TInt ii=0; ii<count; ii++)

			{

			switch ((*iArray)[ii])

				{

			case EMonday:

				aStream.WriteL(KVersitRecurrenceMonday8);

				break;

			case ETuesday:

				aStream.WriteL(KVersitRecurrenceTuesday8);

				break;

			case EWednesday:

				aStream.WriteL(KVersitRecurrenceWednesday8);

				break;

			case EThursday:

				aStream.WriteL(KVersitRecurrenceThursday8);

				break;

			case EFriday:

				aStream.WriteL(KVersitRecurrenceFriday8);

				break;

			case ESaturday:

				aStream.WriteL(KVersitRecurrenceSaturday8);

				break;

			case ESunday:

				aStream.WriteL(KVersitRecurrenceSunday8);

				break;

			default:

				Panic(ENoWeekdayFound);

				break;

				};

			aStream.WriteL(KVersitTokenSpace);

			}

		}

	}

//

// CVersitRecurrence

//

EXPORT_C CVersitRecurrence::CVersitRecurrence(TInt aInterval,TInt aDuration,TVersitDateTime* aEndDate)

: iInterval(aInterval),iDuration(aDuration),iEndDate(aEndDate)

/** Constructs the CVersitRecurrence object.

Initialises the interval (iInterval), duration (iDuration) and optionally, the end 

date (iEndDate).

This is invoked by the constructor of a derived class.

@param aInterval The interval between repeats.

@param aDuration The duration for the recurrence.

@param aEndDate A pointer to the end date. The object takes ownership of this 

pointer. */

	{}

EXPORT_C CVersitRecurrence::~CVersitRecurrence()

/** Frees all resources owned by the CVersitRecurrence object, prior to its destruction. */

	{

	delete iEndDate;

	}

//

// CVersitRecurrenceDaily

//

EXPORT_C CVersitRecurrenceDaily::CVersitRecurrenceDaily(TInt aInterval,TInt aDuration,TVersitDateTime* aEndDate)

: CVersitRecurrence(aInterval,aDuration,aEndDate)

/** Constructs the CVersitRecurrenceDaily object.

Sets the interval, the duration and, optionally, an end date for the repeat. 

The repeat type is set to EDaily.

If a duration and an end date are both specified, the end date takes precedence.

@param aInterval The number of days between repeats. 

@param aDuration The duration, in days, for which the event should continue 

recurring. A value of zero indicates the repeat should continue forever.

@param aEndDate Pointer to the end date for the repeat. The object takes ownership 

of this pointer. */

	{

	iRepeatType=EDaily;

	}

EXPORT_C void CVersitRecurrenceDaily::ExternalizeOccurrenceListsL(RWriteStream& /*aStream*/) const

/** This function is empty because an occurrence list is not applicable to a daily recurrence type. 

@param aStream Not used.*/

	{}

//

//	CVersitRecurrenceWeekly

//

EXPORT_C CVersitRecurrenceWeekly::CVersitRecurrenceWeekly(TInt aInterval,TInt aDuration,TVersitDateTime* aEndDate,CWeekDayArray* aArrayOfWeekdayOccurrences)

: CVersitRecurrence(aInterval,aDuration,aEndDate)

, iArrayOfWeekDayOccurrences(aArrayOfWeekdayOccurrences)

/** Constructs the CVersitRecurrenceWeekly object.

Initialises the interval, the duration, optionally, an end date for the repeat and, 

optionally, a pointer to an array of the days of the week on which the repeat 

event occurs. Sets the repeat type to EWeekly. 

@param aInterval The number of weeks between repeats.

@param aDuration The duration, in weeks, for which the event should recur.

A value of zero indicates the repeat should continue forever.

@param aEndDate Pointer to the end date for the repeat. The object takes 

ownership of this pointer.

@param aArrayOfWeekdayOccurrences Array of the days of the week on which 

the repeat event occurs. The object takes ownership of this pointer. */

	{

	iRepeatType=EWeekly;

	}

EXPORT_C CVersitRecurrenceWeekly::~CVersitRecurrenceWeekly()

/** Frees all resources owned by the object, prior to its destruction. */

	{

	delete iArrayOfWeekDayOccurrences;

	}

EXPORT_C void CVersitRecurrenceWeekly::ExternalizeOccurrenceListsL(RWriteStream& aStream) const

/** Writes the codes for the days of the week on which the event occurs (e.g. "TU 

TH") to the outgoing stream, aStream.

@param aStream The stream to which the occurrence list is to be written. */

	{

	if (iArrayOfWeekDayOccurrences)

		iArrayOfWeekDayOccurrences->ExternalizeL(aStream);

	}

//

// CVersitRecurrenceMonthlyByPos

//

EXPORT_C CVersitRecurrenceMonthlyByPos::CVersitRecurrenceMonthlyByPos(TInt aInterval,TInt aDuration,TVersitDateTime* aEndDate,CArrayPtrFlat<CMonthPosition>* aMonthPositions)

: CVersitRecurrence(aInterval,aDuration,aEndDate)

,iMonthPositions(aMonthPositions)

/** Constructs the CVersitRecurrenceMonthlyByPos object.

Sets the interval, the duration, optionally, an end date for the repeat and 

a pointer to an array of 'month positions', which specify when the event occurs. 

Also sets the repeat type to EMonthlyByPos.

If a duration and an end date are both specified, the end date takes precedence.

@param aInterval The number of months between repeats. 

@param aDuration The duration, in months, for which the event should recur. 

A value of zero indicates the repeat should continue forever.

@param aEndDate Pointer to the end date for the repeat event. The object takes 

ownership of this pointer. 

@param aMonthPositions Pointer to an array of the positions of days within 

the month. The object takes ownership of this pointer. */

	{

	iRepeatType=EMonthlyByPos;

	}

EXPORT_C CVersitRecurrenceMonthlyByPos::~CVersitRecurrenceMonthlyByPos()

/** Frees all resources owned by the object, prior to its destruction. */

	{

	if (iMonthPositions)

		{

		iMonthPositions->ResetAndDestroy();

		delete iMonthPositions;

		}

	}

EXPORT_C void CVersitRecurrenceMonthlyByPos::ExternalizeOccurrenceListsL(RWriteStream& aStream) const

/** Writes the days of the month on which the event occurs to the output stream, 

aStream.

If an event occurs on Monday and Tuesday of the first week and the second to last week 

of a month, the string written to aStream would be "1+ MO TU 2- MO TU ", with 

the plus sign indicating that the week is counted from the start of the month 

and the minus sign indicating that the week is counted from the end of the 

month.

@param aStream The stream to which the occurrence list is to be written. */

	{

	if (iMonthPositions)

		{

		const TInt count = iMonthPositions->Count();

		CMonthPosition* monthPos;

		TBuf8<1> weekNo;

		for (TInt ii = 0; ii < count; ii++)

			{

			monthPos = (*iMonthPositions)[ii];

			__ASSERT_DEBUG((monthPos->iWeekNo < 10), Panic(EWeekNoOverTen));

			weekNo.Num(monthPos->iWeekNo);

			aStream.WriteL(weekNo);

			if (monthPos->iSign == CMonthPosition::EWeeksFromEndOfMonth)

				aStream.WriteL(KVersitTokenMinus);

			else

				aStream.WriteL(KVersitTokenPlus);

			aStream.WriteL(KVersitTokenSpace);

			if (monthPos->iArrayOfWeekDays)

				monthPos->iArrayOfWeekDays->ExternalizeL(aStream);

			}

		}

	}

EXPORT_C CVersitRecurrenceMonthlyByPos::CMonthPosition::~CMonthPosition()

/** Frees all resources owned by the object, prior to its destruction. */

	{

	delete iArrayOfWeekDays;

	}

//

// CVersitRecurrenceMonthlyByDay

//

EXPORT_C CVersitRecurrenceMonthlyByDay::CVersitRecurrenceMonthlyByDay(TInt aInterval,TInt aDuration,TVersitDateTime* aEndDate,	CArrayFix<TInt>* aArrayOfOccurrencesInDaysFromStartOfMonth

		,CArrayFix<TInt>* aArrayOfOccurrencesInDaysFromEndOfMonth,TBool aLastDay)

: CVersitRecurrence(aInterval,aDuration,aEndDate)

,iArrayOfOccurrencesInDaysFromStartOfMonth(aArrayOfOccurrencesInDaysFromStartOfMonth)

,iArrayOfOccurrencesInDaysFromEndOfMonth(aArrayOfOccurrencesInDaysFromEndOfMonth)

,iLastDay(aLastDay)

/** Constructs the CVersitRecurrenceMonthlyByDay object.

Sets the repeat type to CVersitRecurrence::EMonthlyByDay. Note: if a duration and an end 

date are both specified, the end date takes precedence.

@param aInterval The number of months between repeats.

@param aDuration The duration, in months, for which the event should recur. 

A value of zero indicates the repeat should continue forever.

@param aEndDate Optional pointer to the end date for the repeat event. The object 

takes ownership of this pointer.

@param aArrayOfOccurencesInDaysFromStartOfMonth Optional pointer to an array of 

numbers, each of which can have a value between 1 and 31 inclusive, which identify 

the days, counting from the start of the month, on which the repeat event occurs. The 

object takes ownership of this pointer.

@param aArrayOfOccurrencesInDaysFromEndOfMonth Optional pointer to an array of numbers, 

each of which can have a value between 1 and 31 inclusive, which identify the days, 

counting from the end of the month, on which the repeat event occurs. (The last day of 

the month is represented by 1). The object takes ownership of this pointer.

@param aLastDay Optional - ETrue if the event occurs on the last day of the month. This 

day can then be represented in the output stream using the LD recurrence value. EFalse if not. */

	{

	iRepeatType=EMonthlyByDay;

	}

EXPORT_C CVersitRecurrenceMonthlyByDay::~CVersitRecurrenceMonthlyByDay()

/** Frees all resources owned by the object, prior to its destruction. */

	{

	delete iArrayOfOccurrencesInDaysFromStartOfMonth;

	delete iArrayOfOccurrencesInDaysFromEndOfMonth;

	}

EXPORT_C void CVersitRecurrenceMonthlyByDay::ExternalizeOccurrenceListsL(RWriteStream& aStream) const

/** Writes the days of the month on which the event occurs to the output stream, 

aStream.

For days counted from the beginning of the month, the string written to aStream 

might be "1+ 2+ 16+ 17+ ", with the plus sign indicating that the day is counted 

from the start of the month.

For days counted from the end of the month, the string written to aStream 

might be "1- 3- 4- LD ", with "LD" signifying that the event occurs on the 

last day of the month. 

@param aStream The stream to which the occurrence list is to be written. */

	{

	if (iArrayOfOccurrencesInDaysFromStartOfMonth)

		{

		TInt count = iArrayOfOccurrencesInDaysFromStartOfMonth->Count();

		TInt occurrence;

		TBuf8<KVersitDefaultBufferSize> temp;

		for (TInt ii = 0; ii < count; ii++)

			{

			occurrence = (*iArrayOfOccurrencesInDaysFromStartOfMonth)[ii];

			if ((occurrence < 32) && (occurrence > 0)) //day in month

				{

				temp.Num(occurrence);

				aStream.WriteL(temp);

				aStream.WriteL(KVersitTokenPlus);

				aStream.WriteL(KVersitTokenSpace);

				}

			}

		}

	if (iArrayOfOccurrencesInDaysFromEndOfMonth)

		{

		TInt count = iArrayOfOccurrencesInDaysFromEndOfMonth->Count();

		TInt occurrence;

		TBuf8<KVersitDefaultBufferSize> temp;

		for (TInt ii = 0; ii < count; ii++)

			{

			occurrence = (*iArrayOfOccurrencesInDaysFromEndOfMonth)[ii];

			if ((occurrence < 32) && (occurrence > 0)) //day in month

				{

				temp.Num(occurrence);

				aStream.WriteL(temp);

				aStream.WriteL(KVersitTokenMinus);

				aStream.WriteL(KVersitTokenSpace);

				}

			}

		}

	if (iLastDay)

		{

		aStream.WriteL(KVersitRecurrenceLastDay);

		aStream.WriteL(KVersitTokenSpace);

		}

	}

//

// CVersitRecurrenceYearlyByMonth

//

EXPORT_C CVersitRecurrenceYearlyByMonth::CVersitRecurrenceYearlyByMonth(TInt aInterval,TInt aDuration,TVersitDateTime* aEndDate,CArrayFix<TMonth>* aArrayOfMonthsInYearOccurrences)

: CVersitRecurrence(aInterval,aDuration,aEndDate)

, iArrayOfMonthsInYearOccurrences(aArrayOfMonthsInYearOccurrences)

/** Constructs the CVersitRecurrenceYearlyByMonth object.

Sets the repeat type to CVersitRecurrence::EYearlyByMonth.

If a duration and an end date are both specified, the end date takes precedence.

@param aInterval The number of years between repeats. 

@param aDuration The duration, in years, for which the event should recur. 

A value of zero indicates the repeat should continue forever. 

@param aEndDate Optional pointer to the end date for the repeat event. The object takes 

ownership of this pointer. 

@param aArrayOfMonthsInYearOccurrences Pointer to an array of month values. 

The object takes ownership of this pointer. */

	{

	iRepeatType=EYearlyByMonth;	

	}

EXPORT_C CVersitRecurrenceYearlyByMonth::~CVersitRecurrenceYearlyByMonth()

/** Frees all resources owned by the object, prior to its destruction. */

	{

	delete iArrayOfMonthsInYearOccurrences;

	}

EXPORT_C void CVersitRecurrenceYearlyByMonth::ExternalizeOccurrenceListsL(RWriteStream& aStream) const

/** Writes the months of the year, as month numbers, in which the event occurs to 

the output stream.

For example, if the event occurs from September to December inclusive, the 

string written to aStream would be "9 10 11 12 ".

@param aStream The stream to which the occurrence list is to be written. */

	{

	if (iArrayOfMonthsInYearOccurrences)

		{

		TInt count = iArrayOfMonthsInYearOccurrences->Count();

		TBuf8<KVersitDefaultBufferSize> temp;

		for (TInt ii = 0; ii < count; ii++)

			{

			temp.Num((*iArrayOfMonthsInYearOccurrences)[ii] + 1); // Add 1 since EJanuary = 0, not 1

			aStream.WriteL(temp);

			aStream.WriteL(KVersitTokenSpace);

			}

		}

	}

//

// CVersitRecurrenceYearlyByDay

//

EXPORT_C CVersitRecurrenceYearlyByDay::CVersitRecurrenceYearlyByDay(TInt aInterval,TInt aDuration,TVersitDateTime* aEndDate,CArrayFix<TInt>* aArrayOfDaysInYearOccurrences)

: CVersitRecurrence(aInterval,aDuration,aEndDate)

,iArrayOfDaysInYearOccurrences(aArrayOfDaysInYearOccurrences)

/** Constructs the CVersitRecurrenceYearlyByDay object.

Sets the repeat type to EYearlyByDay.

If a duration and an end date are both specified, the end date takes precedence.

@param aInterval The number of years between repeats. 

@param aDuration The duration, in years, for which the event should 

recur. A value of zero indicates the repeat should continue forever. 

@param aEndDate Optional pointer to the end date for the repeat event. The object takes 

ownership of this pointer. 

@param aArrayOfDaysInYearOccurrences Pointer to an array of integers between 

1 and 366 inclusive. Each integer represents a day on which the repeat event 

occurs. The object takes ownership of this pointer. */

	{

	iRepeatType=EYearlyByDay;

	}

EXPORT_C CVersitRecurrenceYearlyByDay::~CVersitRecurrenceYearlyByDay()

/** Frees all resources owned by the object, prior to its destruction. */

	{

	delete iArrayOfDaysInYearOccurrences;

	}

EXPORT_C void CVersitRecurrenceYearlyByDay::ExternalizeOccurrenceListsL(RWriteStream& aStream) const

/** Writes the days of the year on which the event occurs to the output stream, 

aStream.

For example, the function might write the string "10 11 12 13 14 15 ".

@param aStream The stream to which the occurrence list is to be written. */

	{

	if (iArrayOfDaysInYearOccurrences)

		{

		TInt count=iArrayOfDaysInYearOccurrences->Count();

		TInt occurrence;

		TBuf8<KVersitDefaultBufferSize> temp;

		for (TInt ii = 0; ii < count; ii++)

			{

			occurrence = (*iArrayOfDaysInYearOccurrences)[ii];

			temp.Num(occurrence);

			if ((occurrence < 366) && (occurrence > 0)) //day in year

				{

				aStream.WriteL(temp);

				aStream.WriteL(KVersitTokenSpace);

				}

			}

		}

	}

//

// CParserPropertyValueRecurrence

//

EXPORT_C CParserPropertyValueRecurrence::CParserPropertyValueRecurrence(CVersitRecurrence* aValue)

: CParserTimePropertyValue(TUid::Uid(KVCalPropertyRecurrenceUid))

, iValue(aValue)

/** Constructs a recurrence property value. 

Sets the property value's UID to KVCalPropertyRecurrenceUid.

@param aValue A pointer to the recurrence value to assign to the property 

value parser. The property value parser takes ownership of the pointer. */

	{}

EXPORT_C CParserPropertyValueRecurrence::~CParserPropertyValueRecurrence()

/** Frees all resources owned by the property value, prior to its destruction. */

	{

	delete iValue;

	}

EXPORT_C void CParserPropertyValueRecurrence::ConvertAllDateTimesToUTCL(const TTimeIntervalSeconds& /*aIncrement*/,const CVersitDaylight* /*aDaylight*/)

/** Converts the end time of the recurrence value into universal time.

The date/time is checked against the daylight saving information provided 

in aDaylight. If it falls inside the daylight saving period then the daylight 

saving offset is subtracted from the time to convert it to universal time. 

Otherwise the time is modified by aIncrement to convert it to universal time.

Note that the daylight savings offset will adjust the time both for the daylight 

saving and for the time zone.

The function has no effect if the value is already stored in universal time.

If aDaylight is a NULL pointer then aIncrement is used.

@param aIncrement A time interval in seconds which represents the negative 

of the time zone of the originating machine. For instance, if the time zone 

is +04:30 (that is 4hr 30mins ahead of UTC), aIncrement should be set to minus 

the number of seconds in 4hr 30mins..

@param aDaylight Pointer to the specification for daylight saving. If the date/time 

value is within the period for daylight saving, the value is modified by the 

daylight saving offset (which accounts for both the time zone and daylight 

saving rule). 

@deprecated since 9.1

*/

	{

	}

EXPORT_C void CParserPropertyValueRecurrence::ConvertAllUTCDateTimesToMachineLocalL(const TTimeIntervalSeconds& /*aIncrement*/)

/** Converts the end time of the recurrence value into machine-local time. 

This process involves adjusting the date/time value by the offset in aIncrement.

The function has no effect if the value is already stored in machine-local 

time.

@param aIncrement A time interval which represents the number of seconds which 

is to be added to the date/time value. This should normally be the universal 

time offset for the machine's locale. 

@deprecated since 9.1

*/

	{

	}

EXPORT_C void CParserPropertyValueRecurrence::ExternalizeL(RWriteStream& aStream,const Versit::TEncodingAndCharset& /*aEncodingCharset*/

																																,TInt /*aLengthOutput*/)

/** Externalises the recurrence property value into aStream.

The property is written to the stream in the following order:

- Repeat type, e.g. "D" is written for a daily repeat (see KVersitRecurrenceDaily).

- Repeat interval, e.g. "2" for a weekly repeat type that occurs fortnightly.

- Occurrence list (optional), e.g. the string "MO TH" is written for a weekly repeat type that recurs 

on Mondays and Thursdays.

- End date (optional) - the date on which the event should stop recurring.