// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "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:

 // e32\euser\us_time.cpp

 // System date and time functions

 // 

 //

 #include "us_std.h"

 // Date and time related constants

 static const TInt KMinutesToMicroSeconds = 60000000;

 static const TInt KSecondsToMicroSeconds = 1000000;

 static const TInt64 KDaysToMicroSeconds = I64LIT(86400000000);

 static const TInt64 KHoursToMicroSeconds = I64LIT(3600000000);

 // Days in each month

 LOCAL_D const TInt8 mTab[2][12]=

     {

     {31,28,31,30,31,30,31,31,30,31,30,31}, // 28 days in Feb

     {31,29,31,30,31,30,31,31,30,31,30,31}  // 29 days in Feb

     };

 // Days in year before 1st of each month

 LOCAL_D const TInt cmTab[2][12]=

 	{

 	{0,31,59,90,120,151,181,212,243,273,304,334},

 	{0,31,60,91,121,152,182,213,244,274,305,335}

 	};

 //

 // Time::FormatL overflow handler

 //

 #if defined(_UNICODE)

 NONSHARABLE_CLASS(TTimeOverflowLeave) : public TDes16Overflow

 	{

 public:

 	virtual void Overflow(TDes16 &aDes);

 	};

 void TTimeOverflowLeave::Overflow(TDes16 &/*aDes*/)

 	{

 	User::Leave(KErrOverflow);

 	}

 #else

 NONSHARABLE_CLASS(TTimeOverflowLeave) : public TDes8Overflow

 	{

 public:

 	virtual void Overflow(TDes8 &aDes);

 	};

 void TTimeOverflowLeave::Overflow(TDes8 &/*aDes*/)

 	{

 	User::Leave(KErrOverflow);

 	}

 #endif

 //

 EXPORT_C TDateTime::TDateTime(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute,TInt aSecond,TInt aMicroSecond)

 //

 // always panic on a bad date/time field

 //

 /**

 Constructs the TDateTime object with the seven fields which comprise a date 

 and time.

 @param aYear        The year. No check is made for validity.

 @param aMonth       The month. Range is EJanuary to EDecember.

 @param aDay         The day. Range is zero to number of days in month minus one.

 @param aHour        The hour. Range is 0 to 23.

 @param aMinute      The minute. Range is 0 to 59.

 @param aSecond      The second. Range is 0 to 59

 @param aMicroSecond The microsecond. Range is 0 to 999999

 @panic USER 3, if an attempt is made to set an invalid value for any of 

        the fields, except for the year. No check is made upon the validity

        of the year.

 */

 	{

 	TInt ret=Set(aYear,aMonth,aDay,aHour,aMinute,aSecond,aMicroSecond);

 	__ASSERT_ALWAYS(ret==KErrNone,Panic(ETDateTimeBadDateTime));

 	}

 EXPORT_C TInt TDateTime::Set(TInt aYear,TMonth aMonth,TInt aDay,TInt aHour,TInt aMinute,TInt aSecond,TInt aMicroSecond)

 //

 // set the various time fields checking that each is valid

 // bomb out as soon as invalid field is set to forestall causing a panic

 //

 /**

 Sets all date and time components.

 Note:

 1. When setting the day and month, subtract one because the ranges are offset 

    from zero. 

 2. If the function returns an error, only those fields preceding the field which 

    caused the error will be changed. For example, if the hour is out of range, 

    the year, month and day will be set, all other components will remain unchanged.

 @param aYear        Year. No check is made on its validity, except that if the

                     date is set to February 29th, the year can only be set to a

                     leap year, otherwise  an error is returned.

 @param aMonth       Month. The valid range is EJanuary to EDecember. If an

                     attempt is made to set an invalid month, or if the current

                     day number in the month is greater than or equal to the

                     number of days in the new month, an error is returned.

 @param aDay         The number of the day within the month, offset from zero.

                     If greater than or equal to the total number of days in

                     the month,an error is returned.

 @param aHour        Hour. Range is 0 to 23.

 @param aMinute      Minute. Range is 0 to 59.

 @param aSecond      Second. Range is 0 to 59.

 @param aMicroSecond Microsecond. Range is 0 to 999999.

 @return KErrNone if successful, KErrGeneral if not.

 */

 	{

 	iYear=aYear;

 	if (aMonth<EJanuary || aMonth>EDecember)

 		return KErrGeneral;

 	iMonth=aMonth;

 	if (aDay<0 || aDay>=Time::DaysInMonth(iYear,iMonth))

 		return KErrGeneral;

 	iDay=aDay;

 	if (aHour<0 || aHour>=24)

 		return KErrGeneral;

 	iHour=aHour;

 	if (aMinute<0 || aMinute>=60)

 		return KErrGeneral;

 	iMinute=aMinute;

 	if (aSecond<0 || aSecond>=60)

 		return KErrGeneral;

 	iSecond=aSecond;

 	if (aMicroSecond<0 || aMicroSecond>=1000000)

 		return KErrGeneral;

 	iMicroSecond=aMicroSecond;

 	return KErrNone;

 	}

 EXPORT_C TInt TDateTime::SetYear(TInt aYear)

 //

 // doesnt let you reset 29th February to non-leap year, no check on year range

 //

 /**

 Sets the year without a leap year check.

 No check is made on the validity of the year except that if the current date

 is February 29th, the year can only be changed to another leap year, otherwise

 an error is returned.

 @param aYear The year.

 @return KErrNone if successful, KErrGeneral if not.

 */

 	{

 	if (iDay>=Time::DaysInMonth(aYear,iMonth))

 		return KErrGeneral;

 	iYear=aYear;

 	return KErrNone;

 	}

 EXPORT_C TInt TDateTime::SetYearLeapCheck(TInt aYear)

 //

 // lets you reset 29th February to non-leap year(moves date to 28th/Feb), no check on year range

 //

 /**

 Sets the year with a leap year check.

 Unlike SetYear(), if the date is the 29th February, this function allows

 the year to be set to a non-leap year. In this case, the date is reset to

 the 28th February.

 @param aYear The year.

 @return KErrNone if successful, KErrGeneral if not.

 @see TDateTime::SetYear

 */

 	{

 	if (iDay>=Time::DaysInMonth(aYear,iMonth))

         iDay=27;

     iYear=aYear;

 	return KErrNone;

 	}

 EXPORT_C TInt TDateTime::SetMonth(TMonth aMonth)

 /**

 Sets the month component of the date/time.

 @param aMonth The month to be set. The range is from EJanuary to EDecember.

               If an attempt is made to set an invalid month, or if the current

               day number in the month is greater than or equal to the number of

               days in the new month, an error is returned.

 @return KErrNone if successful, KErrGeneral if not.

 */

 	{

 	if (aMonth<EJanuary || aMonth>EDecember || iDay>=Time::DaysInMonth(iYear,aMonth))

 		return KErrGeneral;

 	iMonth=aMonth;

 	return KErrNone;

 	}

 EXPORT_C TInt TDateTime::SetDay(TInt aDay)

 /**

 Sets the day component of the date/time.

 @param aDay The number of the day within the month, offset from zero. If equal 

             to or greater than the total number of days in the month, an error

             is returned.

 @return KErrNone if successful, KErrGeneral if not.

 */

 	{

 	if (aDay<0 || aDay>=Time::DaysInMonth(iYear,iMonth))

 		return KErrGeneral;

 	iDay=aDay;

 	return KErrNone;

 	}

 EXPORT_C TInt TDateTime::SetHour(TInt aHour)

 /**

 Sets the hour component of the date/time.

 @param aHour The hour. Range is 0 to 23.

 @return KErrNone if successful, KErrGeneral if not.

 */

 	{

 	if (aHour<0 || aHour>=24) // GC - bug fix

 		return KErrGeneral;

 	iHour=aHour;

 	return KErrNone;

 	}

 EXPORT_C TInt TDateTime::SetMinute(TInt aMinute)

 /**

 Sets the minute component of the date/time.

 @param aMinute The minute. Range is 0 to 59.

 @return KErrNone if successful, KErrGeneral if not.

 */

 	{

 	if (aMinute<0 || aMinute>=60)

 		return KErrGeneral;

 	iMinute=aMinute;

 	return KErrNone;

 	}

 EXPORT_C TInt TDateTime::SetSecond(TInt aSecond)

 /**

 Sets the second component of the date/time.

 @param aSecond The second. Range is 0 to 59.

 @return KErrNone if successful, KErrGeneral if not.

 */

 	{

 	if (aSecond<0 || aSecond>=60)

 		return KErrGeneral;

 	iSecond=aSecond;

 	return KErrNone;

 	}

 EXPORT_C TInt TDateTime::SetMicroSecond(TInt aMicroSecond)

 /**

 Sets the microsecond component of the date/time.

 @param aMicroSecond The microsecond. Range is 0 to 999999.

 @return KErrNone if successful, KErrGeneral if not.

 */

 	{

 	if (aMicroSecond<0 || aMicroSecond>=1000000)

 		return KErrGeneral;

 	iMicroSecond=aMicroSecond;

 	return KErrNone;

 	}

 // class TTime

 EXPORT_C TTime::TTime(const TDesC &aString)

 /**

 Constructs a TTime object with a text string.

 The string consists of up to three components, any or all of which

 may be omitted:

 1. year, month and day, followed by a colon

 2. hour, minute and second, followed by a dot

 3. microsecond

 When all three components are present, the string should take the form:

 YYYYMMDD:HHMMSS.MMMMMM

 The conversion from text to time is carried out in the same manner as that 

 used in TTime::Set().

 For a list of the range of valid values for date and time components,

 see TDateTime::Set().

 @param aString Date and time string for initializing the TTime object. 

 @panic USER 113, if the string is syntactically incorrect, for example, if 

                  neither a colon nor a dot is present, or if any component of

                  the date or time is assigned an invalid value, or the year

                  is negative.

 @see TTime::Set

 @see TDateTime::Set

 */

 	{

 	__ASSERT_ALWAYS(Set(aString)==KErrNone,Panic(ETTimeValueOutOfRange));

 	}

 EXPORT_C TTime::TTime(const TDateTime &aDateTime) : iTime(Convert(aDateTime).Int64())

 /**

 Constructs a TTime object with the seven fields which comprise a date and time.

 @param aDateTime Date and time to which to initialise the TTime object.

 */

     {}

 EXPORT_C TInt TTime::Set(const TDesC &aString)

 //

 // Convert string to time. String is in the format:

 //

 // YYYYMMDD:HHMMSS.MMMMMM

 //

 // Any part may be ommitted, but either the

 // dot or colon or both must be present

 //

 /**

 Assigns a date and time contained in a descriptor to this TTime object.

 The string consists of up to three components, any or all of which may

 be omitted:

 1. year, month and day, followed by a colon 

 2. hour, minute and second, followed by a dot 

 3. microsecond

 When all three components are present, the string should take the form:

 YYYYMMDD:HHMMSS.MMMMMM

 If omitted, the first component is set to January 1st 0 AD nominal Gregorian. 

 If either the second or third components are omitted, they are set to zero.

 Notes:

 1. The month and day values are offset from zero.

 2. The only situations in which either the colon or dot may be omitted are as 

    follows:

    2.1 If the microsecond component is omitted, the preceding dot may also

        be omitted.

    2.2 The colon can be omitted only if a dot is located at string position

        zero (indicating that the first two components are missing), or at

        string position six (indicating that the first component only is

        missing).

 @param aString The date and time to be assigned to this TTime object.

 @return KErrNone if successful,

         KErrGeneral if the string is syntactically incorrect, for example,

         if neither a colon nor a dot is present, or if any component of the

         date or time is given an invalid value, or the year is negative.

         For a list of valid values for date and time components,

         see TDateTime::Set().

         If an error occurs, the date and time will remain unchanged.

 */

 	{

 //

 // Get position of the colon and dot separators

 //

     TInt colon=aString.Locate(':');

     TInt dot=aString.Locate('.');

     if(colon==KErrNotFound && dot==KErrNotFound)

         return(KErrGeneral);

 //

 // Zero parts that aren't supplied

 //

     TInt yy=0;

     TInt mm=0;

     TInt dd=0;

     TInt hr=0;

     TInt mi=0;

     TInt se=0;

     TInt ms=0;

 //

 // Convert YYYYMMDD if present

 //

     switch(colon)

         {

         case 0:

        	    break;

         case KErrNotFound:

             if(dot!=0 && dot!=6)

                 return(KErrGeneral);

             colon=-1;

             break;

         case 8:

 	   		{

             TLex y=aString.Left(4);

             TLex m=aString.Mid(4,2);

             TLex d=aString.Mid(6,2);

             y.Val(yy);

             m.Val(mm);

             d.Val(dd);

 	    	}

             break;

         default: // Colon in wrong position - return error

             return(KErrGeneral);

         }

 //

 // Convert HHMMSS if present

 //

     if(dot==KErrNotFound)

         dot=aString.Length();

     if(dot==colon+7)

         {

         TLex h=aString.Mid(dot-6,2);

         TLex m=aString.Mid(dot-4,2);

         TLex s=aString.Mid(dot-2,2);

         h.Val(hr);

         m.Val(mi);

         s.Val(se);

         }

     else if(dot!=KErrNotFound && dot!=0 && dot!=colon+1)

     	return(KErrGeneral);

     if(dot!=KErrNotFound)

         {

         if(aString.Length()>dot+7)

             return(KErrGeneral); // microseconds is more than 6 digits

         if(dot<aString.Length())

         	{

         	TLex m=aString.Mid(dot+1);

         	m.Val(ms);

         	}

         }

 //

 // Set the time! Do not construct newtime using the values or

 // it may cause TTime::Set() to panic rather than return an error

 //

 	TDateTime newtime;

 	if(newtime.Set(yy,TMonth(mm),dd,hr,mi,se,ms)!=KErrNone)

 		return(KErrGeneral);

     (*this)=newtime;

 	return KErrNone;

 	}

 EXPORT_C TInt TTime::HomeTimeSecure()

 /**

 Sets the date and time of this TTime to the secure home time. 

 Returns KErrNoSecureTime if there is no secure time source

 */

 	{

 	TInt utOffset=0;

 	TInt r = Exec::TimeNowSecure(*(TInt64*)this,utOffset);

     operator+=(TTimeIntervalSeconds(utOffset));

 	return r;

 	}

 EXPORT_C TInt TTime::UniversalTimeSecure()

 /**

 Sets the date and time of this TTime to the secure universal time.

 */

 	{

 	TInt utOffset=0;

 	return Exec::TimeNowSecure(*(TInt64*)this,utOffset);

 	}

 EXPORT_C void TTime::HomeTime()

 /**

 Sets the date and time of this TTime to the home time.

 */

 	{

 	TInt utOffset=0;

 	Exec::TimeNow(*(TInt64*)this,utOffset);

     operator+=(TTimeIntervalSeconds(utOffset));

 	}

 EXPORT_C void TTime::UniversalTime()

 /**

 Sets the date and time of this TTime to the universal time.

 */

 	{

 	TInt utOffset=0;

 	Exec::TimeNow(*(TInt64*)this,utOffset);

 	}

 EXPORT_C void TTime::RoundUpToNextMinute()

 /**

 Rounds this TTime up to the next minute.

 Both the seconds and microseconds components are set to zero.

 */

 	{

 	if (iTime>0)

 		iTime+=59999999;

 //*	TInt64 remainder;

 //*	Int64().DivMod(60000000,remainder);

 //*	iTime-=remainder;	

 	iTime-=iTime%60000000;

 	}

 TTime TTime::Convert(const TDateTime &aDateTime)

 //

 // converts TDateTime into a TTime, doesnt check for overflows

 //

 	{

 	TInt days=365*aDateTime.Year()+Time::LeapYearsUpTo(aDateTime.Year());

 	TBool isleap=Time::IsLeapYear(aDateTime.Year());

 	days+=cmTab[isleap][aDateTime.Month()];

 	days+=aDateTime.Day();

 	TUint sum=aDateTime.MicroSecond()+aDateTime.Second()*KSecondsToMicroSeconds+aDateTime.Minute()*KMinutesToMicroSeconds;

 	return(((TInt64(days*3)<<3)+TInt64(aDateTime.Hour()))*KHoursToMicroSeconds+TInt64(sum));

 	}

 EXPORT_C TTime &TTime::operator=(const TDateTime &aDateTime)

 /**

 Assigns a TDateTime object to this TTime object.

 @param aDateTime The date and time to assign to this TTime object.

 @return This TTime object.

 */

 	{

 	iTime=Convert(aDateTime).Int64();

 	return(*this);

 	}

 EXPORT_C TDateTime TTime::DateTime() const

 //

 // converts iTime back into its TDateTime components

 //

 /**

 Converts the TTime object into a TDateTime object.

 This conversion must be done before the seven fields which comprise a date

 and time can be accessed.

 @return The components of the time, indicating year, month, day, hour, minute, 

         second, microsecond.

 */

 	{

 	TInt64 rem;

 	TInt64 daysSince0AD64(iTime);

 	rem = daysSince0AD64 % KDaysToMicroSeconds;

 	daysSince0AD64 /= KDaysToMicroSeconds;

 	TInt daysSince0AD = static_cast<TInt>(daysSince0AD64);

 	TInt year;

 	TInt daysLeft;

 	if (iTime<0)

 		{ // -1 to make daysLeft +ve and assume leap year every 4 years

 		if (rem!=TInt64(0))

 			{

 			daysSince0AD--;

 			rem=iTime-TInt64(daysSince0AD)*KDaysToMicroSeconds;

 			}

 		year=(4*daysSince0AD)/((4*365)+1);

 		if ((4*daysSince0AD)%((4*365)+1))

 			year--;

 		daysLeft=daysSince0AD-((year*365)+Time::LeapYearsUpTo(year));

 		}

 	else

 		{ // after 1600 leap years less than every four years

 		year=(4*daysSince0AD)/((4*365)+1);

 		daysLeft=daysSince0AD-((year*365)+Time::LeapYearsUpTo(year));

 		TInt daysInYear=365+Time::IsLeapYear(year);

 	    while (daysLeft>=daysInYear)

 		    {

 			year++;

 	        daysLeft-=daysInYear;

 			daysInYear=365+Time::IsLeapYear(year);

 			}

 		}

 	TDateTime result(0,EJanuary,0,0,0,0,0);

 	result.SetYear(year);

    	TBool isleap=Time::IsLeapYear(year);

     TInt month=11;

 	const TInt* pCM=&(cmTab[isleap][11])+1;

 	while(daysLeft<*--pCM)

 		month--;

 	daysLeft-=*pCM;

 	result.SetMonth((TMonth)month);

 	result.SetDay(daysLeft);

 	TInt hour = static_cast<TInt>(rem >> 10) / 3515625;	// 3515625=KHoursToMicroSeconds/1024

 	result.SetHour(hour);

 	TUint rem32=I64LOW(rem-(TInt64(hour*3515625)<<10));

 	TUint min=rem32/KMinutesToMicroSeconds;

 	result.SetMinute((TInt)min);

 	rem32-=min*KMinutesToMicroSeconds;

 	TUint sec=rem32/KSecondsToMicroSeconds;

 	result.SetSecond((TInt)sec);

 	rem32-=sec*KSecondsToMicroSeconds;

 	result.SetMicroSecond(TInt(rem32));

 	return(result);

 	}

 EXPORT_C TTimeIntervalMicroSeconds TTime::MicroSecondsFrom(TTime aTime) const

 //

 // this - aTime

 //

 /**

 Calculates the number of microseconds difference between the specified TTime

 and this TTime.

 @param aTime The time to be compared with this TTime.

 @return Difference in microseconds between the two times. If the time specified 

         in the argument is later than this TTime, this value is negative.

 */

 	{

 	TInt64 difference=iTime-aTime.Int64();

 	return(difference);

 	}

 EXPORT_C TInt TTime::SecondsFrom(TTime aTime,TTimeIntervalSeconds &aInterval) const

 //

 // this - aTime as whole seconds

 // this function may fail if difference > no of seconds that can be represented in a TInt

 //

 /**

 Calculates the number of seconds difference between the specified TTime and

 this TTime.

 The difference may be positive or negative.

 @param aTime     The time to be compared with this TTime.

 @param aInterval On return contains the difference in seconds between the two 

                  times. If the time specified in the first argument is later than

                  this TTime, then this returned value is negative.

 @return Error code. KErrNone if successful. 

                     KErrOverflow, if the calculated interval is too large for

                     a 32-bit integer.

 */

 	{

 	TInt64 diff;

 	if (iTime>aTime.Int64())

 		{

 		diff= TInt64(TUint64(iTime-aTime.Int64())/KSecondsToMicroSeconds);	

 		}

 	else 

 		{

 		diff= -TInt64(TUint64(aTime.Int64()-iTime)/KSecondsToMicroSeconds);

 		}	

 	if (diff>KMaxTInt || diff<KMinTInt)	

 	    return KErrOverflow; 

 	aInterval = static_cast<TInt>(diff);

 	return KErrNone;

 	}

 EXPORT_C TInt TTime::MinutesFrom(TTime aTime,TTimeIntervalMinutes &aInterval) const

 //

 // iTime - aTime as whole minutes

 // function may fail if difference can't be represented as a TInt

 //

 /**

 Calculates the number of minutes difference between the specified TTime and

 this TTime.

 The difference may be positive or negative.

 @param aTime     The time to be compared with this TTime.

 @param aInterval On return contains the difference in minutes between the two 

                  times. If the time specified in the first argument is later

                  than this TTime, then this returned value is negative.

 @return Error code. KErrNone if successful. 

                     KErrOverflow, if the calculated interval is too large for

                     a 32-bit integer.

 */

 	{

 	TInt64 diff;

 	if (iTime>aTime.Int64())

 		{

 		diff= TInt64(TUint64(iTime-aTime.Int64())/KMinutesToMicroSeconds);	

 		}

 	else 

 		{

 		diff= -TInt64(TUint64(aTime.Int64()-iTime)/KMinutesToMicroSeconds);

 		}	

 	if (diff>KMaxTInt || diff<KMinTInt)	

 	    return KErrOverflow; 

 	aInterval = static_cast<TInt>(diff);

 	return KErrNone; 

 	}

 EXPORT_C TInt TTime::HoursFrom(TTime aTime,TTimeIntervalHours &aInterval) const

 //

 // iTime - aTime as whole hours

 // function may fail if difference can't be represented as a TInt

 //

 /**

 Calculates the number of hours difference between the specified TTime and

 this TTime. 

 The difference may be positive or negative.

 @param aTime     The time to be compared with this TTime.

 @param aInterval On return contains the difference in hours between the two 

                  times. If the time specified in the first argument is later

                  than this TTime, then this returned value is negative.

 @return Error code. KErrNone if successful. 

                     KErrOverflow, if the calculated interval is too large for

                     a 32-bit integer.

 */

 	{

 	TInt64 diff;

 	if (iTime>aTime.Int64())

 		{

 		diff= TInt64(TUint64(iTime-aTime.Int64())/KHoursToMicroSeconds);	

 		}

 	else 

 		{

 		diff= -TInt64(TUint64(aTime.Int64()-iTime)/KHoursToMicroSeconds);

 		}

 	if (diff>KMaxTInt || diff<KMinTInt)	

 	    return KErrOverflow; 

 	aInterval = static_cast<TInt>(diff);

 	return KErrNone;

 	}  

 EXPORT_C TTimeIntervalDays TTime::DaysFrom(TTime aTime) const

 //

 // iTime - aTime as whole days

 //

 /**

 Calculates the number of days difference between the specified TTime and

 this TTime. 

 The difference may be positive or negative.

 @param aTime  The time to be compared with this TTime.

 @return Difference in days between the two times. If the time specified in 

         aTime is later than this TTime, the returned value will be negative.

 */

 	{

 	if (iTime>aTime.Int64())

 		{

 		return TInt(TUint64(iTime-aTime.Int64())/KDaysToMicroSeconds);	

 		}

 	else 

 		{

 		return -TInt(TUint64(aTime.Int64()-iTime)/KDaysToMicroSeconds);

 		}	

 	}

 EXPORT_C TTimeIntervalMonths TTime::MonthsFrom(TTime aTime) const

 //

 // iTime - aTime as whole months - ie aTime must be on a later day in the month and later in that day

 // except for last days etc eg 31st October - 30 November is one month to be consistent with other

 // functions

 //

 /**

 Calculates the number of months between the specified TTime and this TTime.

 The result may be positive or negative.

 The interval in months between two TTimes is calculated by incrementing it 

 by one each time the same day number and time in the previous or following 

 month has been reached. Exceptions to this rule occur when this TTime is on 

 the last day of the month. In this case, the following rules apply:

 When comparing this TTime with a later time:

 1. if the following month is shorter, one month is deemed to separate the times 

    when the same time on the last day of the following month is reached. In this 

    case, the two day numbers are not the same.

 When comparing this TTime with an earlier time:

 1. if the previous month is shorter, one month is deemed to separate the times 

    when the last microsecond of the previous month is reached (23:59:59.999999 

    on the last day of the month).

 2. if the previous month is longer, one month is deemed to separate the times 

    when the same time on the last day of previous month is reached. In this case, 

    the two day numbers are not the same.

 @param aTime The time to be compared with this TTime.

 @return Difference in months between the two times. If the time specified in 

         the argument is later than this TTime, the interval is negative.

 */

 	{

 	TDateTime dateTimei=DateTime();

 	TDateTime dateTimea=aTime.DateTime();

 	TInt monthsDifference=(dateTimei.Year()-dateTimea.Year())*12+(dateTimei.Month()-dateTimea.Month());

 	if (monthsDifference>0)

 		{

 		if (dateTimei.Day()<=dateTimea.Day())

 			{

 			if (iTime%KDaysToMicroSeconds<aTime.Int64()%KDaysToMicroSeconds || (dateTimei.Day()!=dateTimea.Day() && dateTimei.Day()!=DaysInMonth()-1))

 				monthsDifference--;

 			}

 		}

 	else

 		if (monthsDifference!=0)//monthsDifference<0

 			{

 			if (dateTimei.Day()>=dateTimea.Day())

 				{

 				if (iTime%KDaysToMicroSeconds>aTime.Int64()%KDaysToMicroSeconds || (dateTimei.Day()!=dateTimea.Day() && dateTimea.Day()!=aTime.DaysInMonth()-1))

 					monthsDifference++;

 				}

 			}

 	return(monthsDifference);			

 	}

 EXPORT_C TTimeIntervalYears TTime::YearsFrom(TTime aTime) const

 //

 // as above,but for twelve months

 //

 /**

 Calculates the number of years between the specified TTime and this TTime.

 The result may be positive or negative.

 Note that the interval in years between two TTimes is calculated by

 incrementing it by one each time the same day number and time in the previous

 or following year has been reached. The exception to this rule occurs when this

 TTime is the last day in February in a leap year. In this case, one year is

 deemed to have passed when the same time of day on the last day in the preceding 

 or following February has been reached.

 @param aTime The time to be compared with this TTime.

 @return Difference in years between the two times. If the time specified in 

         the argument is later than this TTime, the interval is negative.

 */

 	{

 	TTimeIntervalMonths mos= TTime::MonthsFrom(aTime);

 	TTimeIntervalYears ret=mos.Int()/12;

 	return(ret);			

 	}

 EXPORT_C TTime TTime::operator+(TTimeIntervalYears aYear) const

 /**

 Adds a time interval to this TTime, returning the result

 as a TTime.

 Note that in a leap year, when adding one year to the 29th February, the result

 is the 28th February in the following year.

 Note also that this TTime object is not changed.

 @param aYear A time interval in years. The argument is stored as a 32 bit

              signed integer. The maximum value which it can represent is

              2147483647. Any attempt to add more than this amount will

              produce incorrect results.

 @return The new time.

 */

 	{

 	return((*this)+TTimeIntervalMonths(aYear.Int()*12));

 	}

 EXPORT_C TTime TTime::operator+(TTimeIntervalMonths aMonth) const

 /**

 Adds a time interval to this TTime, returning the result

 as a TTime.

 Note that when adding one month to the last day in the month, if the following

 month is shorter, the result is the last day in the following month.

 For example, when adding one month to 31st August, the result is

 the 30th September.

 Note also that this TTime object is not changed.

 @param aMonth A time interval in months. The argument is stored as a 32 bit

               signed integer. The maximum value which it can represent is

               2147483647. Any attempt to add more than this amount will

               produce incorrect results.

 @return The new time.

 */

 	{

 	TDateTime dateTime=DateTime();

 	TInt month=dateTime.Month()+(dateTime.Year()*12)+aMonth.Int();

 	TInt day=dateTime.Day();

 	TInt year=month/12;

 	month%=12;

 	if (month<0)

 		{

 		year--;

 		month+=12;

 		}

 	TInt daysInMonth=(mTab[Time::IsLeapYear(year)][month]-1); 

 	if (day>=daysInMonth)

 		day=daysInMonth;

 	__ASSERT_ALWAYS(dateTime.Set(year,TMonth(month),day,dateTime.Hour(),dateTime.Minute(),dateTime.Second(),dateTime.MicroSecond())==KErrNone,Panic(ETDateTimeBadDateTime));

 	return(dateTime);

 	}

 EXPORT_C TTime TTime::operator+(TTimeIntervalDays aDay) const

 /**

 Adds a time interval to this TTime, returning the result

 as a TTime.

 Note that this TTime object is not changed.

 @param aDay A time interval in days. The argument is stored as a 32 bit

             signed integer. The maximum value which it can represent is

             2147483647. Any attempt to add more than this amount will

             produce incorrect results.

 @return The new time.

 */

 	{ 

 	return(iTime+TInt64(aDay.Int())*KDaysToMicroSeconds);

 	}

 EXPORT_C TTime TTime::operator+(TTimeIntervalHours aHour) const

 /**

 Adds a time interval to this TTime, returning the result

 as a TTime.

 Note that this TTime object is not changed.

 @param aHour A time interval in hours. The argument is stored as a 32 bit

              signed integer. The maximum value which it can represent is

              2147483647. Any attempt to add more than this amount will

              produce incorrect results.

 @return The new time.

 */

 	{

 	return(iTime+TInt64(aHour.Int())*KHoursToMicroSeconds);

 	}

 EXPORT_C TTime TTime::operator+(TTimeIntervalMinutes aMinute) const

 /**

 Adds a time interval to this TTime, returning the result

 as a TTime.

 Note that this TTime object is not changed.

 @param aMinute A time interval in minutes. The argument is stored as a 32 bit

                signed integer. The maximum value which it can represent is

                2147483647. Any attempt to add more than this amount will

                produce incorrect results.

 @return The new time.

 */

 	{

 	return(iTime+TInt64(aMinute.Int())*KMinutesToMicroSeconds);

 	}

 EXPORT_C TTime TTime::operator+(TTimeIntervalSeconds aSecond) const

 /**

 Adds a time interval to this TTime, returning the result

 as a TTime.

 Note that this TTime object is not changed.

 @param aSecond A time interval in seconds. The argument is stored as a 32 bit

                signed integer. The maximum value which it can represent is

                2147483647. Any attempt to add more than this amount will

                produce incorrect results.

 @return The new time.

 */

 	{

 	return(iTime+TInt64(aSecond.Int())*KSecondsToMicroSeconds);

 	}

 EXPORT_C TTime TTime::operator+(TTimeIntervalMicroSeconds aMicroSecond) const

 /**

 Adds a time interval to this TTime, returning the result

 as a TTime.

 Note that this TTime object is not changed.

 @param aMicroSecond A time interval in microseconds.

 @return The new time.

 */

 	{

 	return(iTime+(aMicroSecond.Int64()));

 	}

 EXPORT_C TTime TTime::operator+(TTimeIntervalMicroSeconds32 aMicroSecond) const

 /**

 Adds a time interval to this TTime, returning the result

 as a TTime.

 Note that this TTime object is not changed.

 @param aMicroSecond A time interval in microseconds. The argument is stored as

                     a 32 bit signed integer. The maximum value which it can

                     represent is 2147483647. Any attempt to add more than this

                     amount will produce incorrect results.

 @return The new time.

 */

 	{

 	return(iTime+aMicroSecond.Int());

 	}

 EXPORT_C TTime TTime::operator-(TTimeIntervalYears aYear) const

 /**

 Substracts a time interval from this TTime, returning the result

 as a TTime.

 Note that in a leap year, when subtracting one year from the 29th February,

 the result is 28th February in the preceding year.

 Note also that this TTime object is not changed.

 @param aYear A time interval in years. The argument is stored as

              a 32 bit signed integer. The maximum value which it can

              represent is 2147483647. Any attempt to subtract more than this

              amount will produce incorrect results.

 @return The new time.

 */

 	{

 	return((*this)-TTimeIntervalMonths(aYear.Int()*12));

 	}

 EXPORT_C TTime TTime::operator-(TTimeIntervalMonths aMonth) const

 /**

 Substracts a time interval from this TTime, returning the result

 as a TTime.

 Note that when subtracting one month from the last day in the month, if the

 preceding month is shorter, the result is the last day in the preceding month.

 For example, when subtracting 1 month from 31st October, the result is

 the 30th September.

 Note also that this TTime object is not changed.

 @param aMonth A time interval in months. The argument is stored as

               a 32 bit signed integer. The maximum value which it can

               represent is 2147483647. Any attempt to subtract more than this

               amount will produce incorrect results.

 @return The new time.

 */

 	{

 	return((*this)+TTimeIntervalMonths(aMonth.Int()*-1));

 	}

 EXPORT_C TTime TTime::operator-(TTimeIntervalDays aDay) const

 /**

 Substracts a time interval from this TTime, returning the result

 as a TTime.

 Note that this TTime object is not changed.

 @param aDay A time interval in days. The argument is stored as

             a 32 bit signed integer. The maximum value which it can

             represent is 2147483647. Any attempt to subtract more than this

             amount will produce incorrect results.

 @return The new time.

 */

 	{ 

 	return(iTime-TInt64(aDay.Int())*KDaysToMicroSeconds);

 	}

 EXPORT_C TTime TTime::operator-(TTimeIntervalHours aHour) const

 /**

 Substracts a time interval from this TTime, returning the result

 as a TTime.

 Note that this TTime object is not changed.

 @param aHour A time interval in hours. The argument is stored as

              a 32 bit signed integer. The maximum value which it can

              represent is 2147483647. Any attempt to subtract more than this

              amount will produce incorrect results.

 @return The new time.

 */

 	{

 	return(iTime-TInt64(aHour.Int())*KHoursToMicroSeconds);

 	}

 EXPORT_C TTime TTime::operator-(TTimeIntervalMinutes aMinute) const

 /**

 Substracts a time interval from this TTime, returning the result

 as a TTime.

 Note that this TTime object is not changed.

 @param aMinute A time interval in minutes. The argument is stored as

                a 32 bit signed integer. The maximum value which it can

                represent is 2147483647. Any attempt to subtract more than this

                amount will produce incorrect results.

 @return The new time.

 */

 	{

 	return(iTime-TInt64(aMinute.Int())*KMinutesToMicroSeconds);

 	}

 EXPORT_C TTime TTime::operator-(TTimeIntervalSeconds aSecond) const

 /**

 Substracts a time interval from this TTime, returning the result

 as a TTime.

 Note that this TTime object is not changed.

 @param aSecond A time interval in seconds. The argument is stored as

                a 32 bit signed integer. The maximum value which it can

                represent is 2147483647. Any attempt to subtract more than this

                amount will produce incorrect results.

 @return The new time.

 */

 	{

 	return(iTime-TInt64(aSecond.Int())*KSecondsToMicroSeconds);

 	}

 EXPORT_C TTime TTime::operator-(TTimeIntervalMicroSeconds aMicroSecond) const

 /**

 Substracts a time interval from this TTime, returning the result

 as a TTime.

 Note that this TTime object is not changed.

 @param aMicroSecond A time interval in microseconds.

 @return The new time.

 */

 	{

 	return(iTime-(aMicroSecond.Int64()));

 	}

 EXPORT_C TTime TTime::operator-(TTimeIntervalMicroSeconds32 aMicroSecond) const

 /**

 Substracts a time interval from this TTime, returning the result

 as a TTime.

 Note that this TTime object is not changed.

 @param aMicroSecond A time interval in microseconds. The argument is stored as

                     a 32 bit signed integer. The maximum value which it can

                     represent is 2147483647. Any attempt to subtract more than

                     this amount will produce incorrect results.

 @return The new time.

 */

 	{

 	return(iTime-aMicroSecond.Int());

 	}

 EXPORT_C TTime &TTime::operator+=(TTimeIntervalYears aYear)

 /**

 Adds a time interval to this TTime, returning a reference to this TTime.

 @param aYear A time interval in years.

 @return A reference to this TTime.

 */

 	{	

 	TTime tim=(*this)+aYear;

 	iTime=tim.Int64();

 	return(*this);

 	}

 EXPORT_C TTime &TTime::operator+=(TTimeIntervalMonths aMonth)

 /**

 Adds a time interval to this TTime, returning a reference to this TTime.

 @param aMonth A time interval in months.

 @return A reference to this TTime.

 */

 	{

 	TTime tim=(*this)+aMonth;

 	iTime=tim.Int64();

 	return(*this);

 	}

 EXPORT_C TTime &TTime::operator+=(TTimeIntervalDays aDay)

 /**

 Adds a time interval to this TTime, returning a reference to this TTime.

 @param aDay A time interval in days.

 @return A reference to this TTime.

 */

 	{

 	iTime+=TInt64(aDay.Int())*KDaysToMicroSeconds;

 	return(*this);

 	}

 EXPORT_C TTime &TTime::operator+=(TTimeIntervalHours aHour)

 /**

 Adds a time interval to this TTime, returning a reference to this TTime.

 @param aHour A time interval in hours.

 @return A reference to this TTime.

 */

 	{

 	iTime+=TInt64(aHour.Int())*KHoursToMicroSeconds;

 	return(*this);

 	}

 EXPORT_C TTime &TTime::operator+=(TTimeIntervalMinutes aMinute)

 /**

 Adds a time interval to this TTime, returning a reference to this TTime.

 @param aMinute A time interval in minutes.

 @return A reference to this TTime.

 */

 	{

 	iTime+=TInt64(aMinute.Int())*KMinutesToMicroSeconds;

 	return(*this);

 	}

 EXPORT_C TTime &TTime::operator+=(TTimeIntervalSeconds aSecond)

 /**

 Adds a time interval to this TTime, returning a reference to this TTime.

 @param aSecond A time interval in seconds.

 @return A reference to this TTime.

 */

 	{

 	iTime+=TInt64(aSecond.Int())*KSecondsToMicroSeconds;

 	return(*this);

 	}

 EXPORT_C TTime &TTime::operator+=(TTimeIntervalMicroSeconds aMicroSecond)

 /**

 Adds a time interval to this TTime, returning a reference to this TTime.

 @param aMicroSecond A time interval in microseconds.

 @return A reference to this TTime.

 */

 	{

 	iTime+=aMicroSecond.Int64();

 	return(*this);

 	}

 EXPORT_C TTime &TTime::operator+=(TTimeIntervalMicroSeconds32 aMicroSecond)

 /**

 Adds a time interval to this TTime, returning a reference to this TTime.

 @param aMicroSecond A time interval in microseconds, as a 32-bit integer.

 @return A reference to this TTime.

 */

 	{

 	iTime+=aMicroSecond.Int();

 	return(*this);

 	}

 EXPORT_C TTime &TTime::operator-=(TTimeIntervalYears aYear)

 /**

 Subtracts a time interval from this TTime, returning a reference to this TTime.

 @param aYear A time interval in years.

 @return A reference to this TTime.

 */

 	{	

 	TTime tim=(*this)-aYear;

 	iTime=tim.Int64();

 	return(*this);

 	}

 EXPORT_C TTime &TTime::operator-=(TTimeIntervalMonths aMonth)

 /**

 Subtracts a time interval from this TTime, returning a reference to this TTime.

 @param aMonth A time interval in months.

 @return A reference to this TTime.

 */

 	{

 	TTime tim=(*this)-aMonth;

 	iTime=tim.Int64();

 	return(*this);

 	}

 EXPORT_C TTime &TTime::operator-=(TTimeIntervalDays aDay)

 /**

 Subtracts a time interval from this TTime, returning a reference to this TTime.

 @param aDay A time interval in days.

 @return A reference to this TTime.

 */

 	{

 	iTime-=TInt64(aDay.Int())*KDaysToMicroSeconds;

 	return(*this);

 	}

 EXPORT_C TTime &TTime::operator-=(TTimeIntervalHours aHour)

 /**

 Subtracts a time interval from this TTime, returning a reference to this TTime.

 @param aHour A time interval in hours.

 @return A reference to this TTime.

 */

 	{

 	iTime-=TInt64(aHour.Int())*KHoursToMicroSeconds;

 	return(*this);

 	}

 EXPORT_C TTime &TTime::operator-=(TTimeIntervalMinutes aMinute)

 /**

 Subtracts a time interval from this TTime, returning a reference to this TTime.

 @param aMinute A time interval in minutes.

 @return A reference to this TTime.

 */

 	{

 	iTime-=TInt64(aMinute.Int())*KMinutesToMicroSeconds;

 	return(*this);

 	}

 EXPORT_C TTime &TTime::operator-=(TTimeIntervalSeconds aSecond)

 /**

 Subtracts a time interval from this TTime, returning a reference to this TTime.

 @param aSecond A time interval in seconds.

 @return A reference to this TTime.

 */

 	{

 	iTime-=TInt64(aSecond.Int())*KSecondsToMicroSeconds;

 	return(*this);

 	}

 EXPORT_C TTime &TTime::operator-=(TTimeIntervalMicroSeconds aMicroSecond)

 /**

 Subtracts a time interval from this TTime, returning a reference to this TTime.

 @param aMicroSecond A time interval in microseconds.

 @return A reference to this TTime.

 */

 	{

 	iTime-=aMicroSecond.Int64();

 	return(*this);

 	}

 EXPORT_C TTime &TTime::operator-=(TTimeIntervalMicroSeconds32 aMicroSecond)

 /**

 Subtracts a time interval from this TTime, returning a reference to this TTime.

 @param aMicroSecond A time interval in microseconds, as a 32-bit integer.

 @return A reference to this TTime.

 */

 	{

 	iTime-=aMicroSecond.Int();

 	return(*this);

 	}

 EXPORT_C TInt TTime::DaysInMonth() const

 /**

 Gets the number of days in the current month.

 @return The number of days in the month.

 */

 	{

 	TDateTime dateTime=DateTime();

 	return(Time::DaysInMonth(dateTime.Year(),dateTime.Month()));

 	}

 EXPORT_C TDay TTime::DayNoInWeek() const

 //

 // 1st January 0AD was a Monday

 //

 /**

 Gets the day number within the current week.

 This is a value in the range zero to six inclusive, and honours the 

 setting specified in TLocale::SetStartOfWeek().

 By default the first day in the week is Monday.

 @return The number of the day within the week. The range is EMonday to ESunday.

 @see TLocale::SetStartOfWeek

 */

 	{

 	TInt64 fullDays=iTime/KDaysToMicroSeconds;

 	TInt day = static_cast<TInt>(fullDays) % 7;

 	if (iTime<0)

 		{

 		if (fullDays*KDaysToMicroSeconds!=iTime)

 			day+=6;

 		else

 			if (day!=0)

 				day+=7;

 		}

 	return((TDay)day);

 	}

 EXPORT_C TInt TTime::DayNoInMonth() const

 /**

 Gets the day number in the month.

 @return The day number in the month. The first day in the month is numbered 

         zero.

 */

 	{

 	return(DateTime().Day());

 	}

 EXPORT_C TInt TTime::DayNoInYear() const

 //

 // day number in comparison to 1st January

 //

 /**

 Gets the day number in the year. 

 @return The day number in the year. The first day in the year is day one.

 */

 	{

 	TDateTime dateTime=DateTime();

 	TTime jan1st=TDateTime(dateTime.Year(),EJanuary,0,0,0,0,0);

 	return(DayNoInYear(jan1st));

 	}

 EXPORT_C TInt TTime::DayNoInYear(TTime aStartDate) const

 //

 // day number in comparison to given date, check is made to ensure first day is within a year before aDay

 //

 /**

 Gets the day number in the year when the start of the year is aStartDate. 

 If no start date is specified, the default is January 1st.

 @param aStartDate Indicates the date which is to be considered the start of 

                   the year. Default is 1st January.

 @return The day number in the year. The first day in the year is day one.

 */

 	{

 	TInt y=DateTime().Year();

 	TMonth m=aStartDate.DateTime().Month();

 	TInt d=aStartDate.DateTime().Day();

     if (d>=Time::DaysInMonth(y,m))

         d=27;

     TDateTime yearStart(y,m,d,0,0,0,0);              // LEAP YEAR PROBLEMS ???

 	aStartDate=yearStart;

 	if (aStartDate>*this)

 		{

 		yearStart.SetYearLeapCheck(y-1);

 		aStartDate=yearStart;

 		}

     return((DaysFrom(aStartDate).Int())+1) ;

     }

 EXPORT_C TInt TTime::WeekNoInYear() const

 /**

 Gets the number of the current week in the year.

 @return Week number in the year.

 */

 	{

 	return(WeekNoInYear(EFirstFourDayWeek));

 	}

 EXPORT_C TInt TTime::WeekNoInYear(TTime aStartDate) const

 /**

 Gets the number of the current week in the year when the year starts

 on aStartDate. 

 @param aStartDate If specified, indicates the date which is to be considered 

                   the start of the year. Default is 1st January.

 @return Week number in the year.

 */

 	{

     return(WeekNoInYear(aStartDate,EFirstFourDayWeek));

 	}

 EXPORT_C TInt TTime::WeekNoInYear(TFirstWeekRule aRule) const

 /**

 Finds the number of the current week in the year using the first week rule 

 specified in aRule. 

 @param aRule Determines how the first week in the year is to be calculated. 

              By default EFirstFourDayWeek.

 @return Week number in the year.

 */

 	{

 	TInt year=DateTime().Year();

 	TTime startDate=TDateTime(year,EJanuary,0,0,0,0,0);

 	return(WeekNoInYear(startDate,aRule));

 	}

 EXPORT_C TInt TTime::WeekNoInYear(TTime aStartDate,TFirstWeekRule aRule) const

 //

 // number of weeks between aTime and aStartDate according to given rule

 // the first week starts either on the week containing the first day (EFirstWeek), 

 // the first week having at least four days within the new year (EFirstFourDayWeek,

 //  default) or the first full week in the year (EFirstFullWeek)

 //

 /**

 Finds the number of the current week in the year when the year starts from 

 aStartDate and when using the start week rule aRule.

 @param aStartDate If specified, indicates the date which is to be considered 

                   the start of the year. Default is 1st January.

 @param aRule      Determines how the first week in the year is to be

                   calculated. By default EFirstFourDayWeek.

 @return Week number in the year.

 */

 	{                    

 	TInt dayNoInWeek=DayNoInWeek();

 	TInt dayNoInYear=(DayNoInYear(aStartDate))-1;    // puts start into correct year

 	TDateTime startDateTime(aStartDate.DateTime());

 	TDateTime nextYearStartDate(startDateTime);

 	nextYearStartDate.SetYearLeapCheck(DateTime().Year());    // find start of next year

 	TTime nextYearStartTime(nextYearStartDate);            // makes sure start date for year

 	if (*this>nextYearStartTime)                           // is in the very next year

 		{

 		nextYearStartDate.SetYearLeapCheck(nextYearStartDate.Year()+1);

 		nextYearStartTime=nextYearStartDate;

 		}

 	nextYearStartTime+=TTimeIntervalMicroSeconds(KDaysToMicroSeconds-1); // avoid problems if the time is not midnight

 	TLocale local;

 	TDay startOfFirstWeek=local.StartOfWeek();

 	// calculate the day-in-week number (0 to 6) based on the locale start-of-week

 	dayNoInWeek -= startOfFirstWeek;

 	if (dayNoInWeek < 0)

 		dayNoInWeek += 7;

 	// calculate the days from the start-of-week to the start-of-next-year

 	TInt daysFrom=nextYearStartTime.DaysFrom(*this).Int()+dayNoInWeek;

 	// calculate the days from start-of-year to start-of-week (note this may be negative, but never < -6)

 	TInt days=dayNoInYear-dayNoInWeek;

 	// the rule allows a certain number of week-1 days to lie in the previous year

 	TInt prevyeardays;

 	switch (aRule)

 		{

 	default:

 		return -1;

 	case EFirstWeek:

 		prevyeardays = 6;

 		break;

 	case EFirstFourDayWeek:

 		prevyeardays = 3;

 		break;

 	case EFirstFullWeek:

 		prevyeardays = 0;

 		break;

 		}

 	// check for a week which belongs to last year

 	if (days + prevyeardays < 0)

 		{

 		// in week 52 or 53 of last year, find the week # of the first day in the week

 		startDateTime.SetYearLeapCheck(startDateTime.Year()-1);

 		return (*this-TTimeIntervalDays(dayNoInWeek)).WeekNoInYear(TTime(startDateTime),aRule);

 		}

 	// check for a week which belongs to next year

 	if (daysFrom <= prevyeardays)

 		return 1;

 	// calculate the week number, accounting for the requested week-1 rule

 	return (days + 7 + prevyeardays)/7;

 	}

 EXPORT_C void TTime::FormatL(TDes &aDes,const TDesC &aFormat) const

 //

 // Fill aString with current Date and Time according to given aFormat string

 //

 /**

 Puts this TTime into a descriptor and formats it according to the format string 

 specified in the second argument.

 Many of the formatting commands use the 

 system's locale settings for the date and time, for example the characters 

 used to separate components of the date and time and the ordering of day, 

 month and year. The list of formatting commands below is divided into two 

 sections, the first of which lists the commands which operate without reference 

 to the locale's date and time settings (see class TLocale) and the second 

 table lists the commands which do use these settings.

 The following formatting commands do not honour the locale-specific system 

 settings:

 \%\% : Include a single '%' character in the string

 \%* : Abbreviate following item (the following item should not be preceded 

 by a '%' character).

 \%C : Interpret the argument as the six digit microsecond component of the 

 time. In its abbreviated form, ('%*C') this should be followed by an integer 

 between zero and six, where the integer indicates the number of digits to display.

 \%D : Interpret the argument as the two digit day number in the month. Abbreviation 

 suppresses leading zero.

 \%E : Interpret the argument as the day name. Abbreviation is language-specific 

 (e.g. English uses the first three letters).

 \%F : Use this command for locale-independent ordering of date components. 

 This orders the following day/month/year component(s) (\%D, \%M, \%Y for example) 

 according to the order in which they are specified in the string. This removes 

 the need to use \%1 to \%5 (described below).

 \%H : Interpret the argument as the one or two digit hour component of the 

 time in 24 hour time format. Abbreviation suppresses leading zero. For locale-dependent 

 hour formatting, use \%J.

 \%I : Interpret the argument as the one or two digit hour component of the 

 time in 12 hour time format. The leading zero is automatically suppressed 

 so that abbreviation has no effect. For locale-dependent hour formatting, 

 use \%J.

 \%M : Interpret the argument as the one or two digit month number. Abbreviation 

 suppresses leading zero.

 \%N : Interpret the argument as the month name. Abbreviation is language specific, e.g. 

 English uses the first three letters only. When using locale-dependent formatting, 

 (that is, \%F has not previously been specified), specifying \%N causes any 

 subsequent occurrence of a month specifier in the string to insert the month 

 as text rather than in numeric form. When using locale-independent formatting, 

 specifying \%N causes the month to be inserted as text at that position, but 

 any subsequent occurrence of \%M will cause the month to be inserted in numeric 

 form.

 \%S : Interpret the argument as the one or two digit seconds component of the 

 time. Abbreviation suppresses leading zero.

 \%T : Interpret the argument as the one or two digit minutes component of the 

 time. Abbreviation suppresses leading zero.

 \%W : Interpret the argument as the one or two digit week number in year. Abbreviation 

 suppresses leading zero.

 \%X : Interpret the argument as the date suffix. Cannot be abbreviated. When 

 using locale-dependent formatting (that is, \%F has not previously been specified), 

 \%X causes all further occurrences of the day number to be displayed with the 

 date suffix. When using locale-independent formatting, a date suffix will 

 be inserted only after the occurrence of the day number which \%X follows in 

 the format string. Any further occurrence of \%D without a following \%X will 

 insert the day number without a suffix.

 \%Y : Interpret the argument as the four digit year number. Abbreviation suppresses 

 the first two digits.

 \%Z : Interpret the argument as the one, two or three digit day number in the 

 year. Abbreviation suppresses leading zeros.

 The following formatting commands do honour the locale-specific system settings:

 \%. : Interpret the argument as the decimal separator character (as set by 

 TLocale::SetDecimalSeparator()). The decimal separator is used to separate 

 seconds and microseconds, if present.

 \%: : Interpret the argument as one of the four time separator characters (as 

 set by TLocale::SetTimeSeparator()). Must be followed by an integer between 

 zero and three inclusive to indicate which time separator character is being 

 referred to.

 \%/ : Interpret the argument as one of the four date separator characters (as 

 set by TLocale::SetDateSeparator()). Must be followed by an integer between 

 zero and three inclusive to indicate which date separator character is being 

 referred to.

 \%1 : Interpret the argument as the first component of a three component date 

 (i.e. day, month or year) where the order has been set by TLocale::SetDateFormat(). 

 When the date format is EDateEuropean, this is the day, when EDateAmerican, 

 the month, and when EDateJapanese, the year. For more information on this 

 and the following four formatting commands, see the Notes section immediately 

 below.

 \%2 : Interpret the argument as the second component of a three component date 

 where the order has been set by TLocale::SetDateFormat(). When the date format 

 is EDateEuropean, this is the month, when EDateAmerican, the day and when 

 EDateJapanese, the month.

 \%3 : Interpret the argument as the third component of a three component date 

 where the order has been set by TLocale::SetDateFormat(). When the date format 

 is EDateEuropean, or EDateAmerican this is the year and when EDateJapanese, 

 the day.

 \%4 : Interpret the argument as the first component of a two component date 

 (day and month) where the order has been set by TLocale::SetDateFormat(). 

 When the date format is EDateEuropean this is the day, and when EDateAmerican 

 or EDateJapanese, the month.

 \%5 : Interpret the argument as the second component of a two component date 

 (day and month) where the order has been set by TLocale::SetDateFormat(). 

 When the date format is EDateEuropean this is the month, and when EDateAmerican 

 or EDateJapanese, the day.

 \%A : Interpret the argument as "am" or "pm" text according to the current 

 language and time of day. Unlike the \%B formatting command (described below), 

 \%A disregards the locale's 12 or 24 hour clock setting, so that when used 

 without an inserted + or - sign, am/pm text will always be displayed. Whether 

 a space is inserted between the am/pm text and the time depends on the locale-specific 

 settings. However, if abbreviated (\%*A), no space is inserted, regardless 

 of the locale's settings. The am/pm text appears before or after the time, 

 according to the position of the \%A, regardless of the locale-specific settings. 

 For example, the following ordering of formatting commands causes am/pm text 

 to be printed after the time: \%H \%T \%S \%A. Optionally, a minus or plus sign 

 may be inserted between the "%" and the "A". This operates as follows:

 \%-A causes am/pm text to be inserted into the descriptor only if the am/pm 

 symbol position has been set in the locale to ELocaleBefore. Cannot be abbreviated 

 using asterisk.

 \%+A causes am/pm text to be inserted into the descriptor only if the am/pm 

 symbol position has been set in the locale to ELocaleAfter. Cannot be abbreviated 

 using asterisk. For example, the following formatting commands will cause 

 am/pm text to be displayed after the time if the am/pm position has been set 

 in the locale to ELocaleAfter or before the time if ELocaleBefore: \%-A \%H 

 \%T \%S \%+A.

 \%B Interpret the argument as am or pm text according to the current language 

 and time of day. Unlike the \%A command, when using \%B, am/pm text is displayed 

 only if the clock setting in the locale is 12-hour. Whether a space is inserted 

 between the am/pm text and the time depends on the locale-specific settings. 

 However, if abbreviated (\%*B), no space is inserted, regardless of the locale's 

 settings. The am/pm text appears before or after the time, according to the 

 location of the "%B", regardless of the locale-specific settings. For example, 

 the following formatting commands cause am/pm text to be printed after the 

 time: \%H \%T \%S \%B. Optionally, a minus or plus sign may be inserted between 

 the "%" and the "B". This operates as follows:

 \%-B causes am/pm text to be inserted into the descriptor only if using a 12 

 hour clock and the am/pm symbol position has been set in the locale to ELocaleBefore. 

 Cannot be abbreviated using asterisk.

 \%+B causes am/pm text to be inserted into the descriptor only if using a 12 

 hour clock and the am/pm symbol position has been set in the locale to ELocaleAfter. 

 Cannot be abbreviated using asterisk. For example, the following formatting 

 commands cause am/pm text to be printed after the time if the am/pm position 

 has been set in the locale to ELocaleAfter or before the time if ELocaleBefore: 

 \%-B \%H \%T \%S \%+B.

 \%J Interpret the argument as the hour component of the time in either 12 or 

 24 hour clock format depending on the locale's clock format setting. When 

 the clock format has been set to 12 hour, leading zeros are automatically 

 suppressed so that abbreviation has no effect. Abbreviation suppresses leading 

 zero only when using a 24 hour clock.

 Notes:

 The \%1, \%2, \%3, \%4 and \%5 formatting commands are used in conjunction with 

 \%D, \%M and \%Y to format the date locale-dependently. When formatting the date 

 locale-dependently, the order of the day, month and year components within 

 the string is determined by the order of the \%1 to \%5 formatting commands, 

 not that of \%D, \%M, \%Y.

 When formatting the date locale-independently (that is, \%F has been specified 

 in the format string), the \%1 to \%5 formatting commands are not required, 

 and should be omitted. In this case, the order of the date components is determined 

 by the order of the \%D, \%M, \%Y format commands within aFormat.

 Up to four date separators and up to four time separators can be used to separate 

 the components of a date or time. When formatting a numerical date consisting 

 of the day, month and year or a time containing hours, minutes and seconds, 

 all four separators should always be specified in the format command string. 

 Usually, the leading and trailing separators should not be displayed. In this 

 case, the first and fourth separators should still be specified, but should 

 be represented by a null character.

 The date format follows the pattern:

 DateSeparator[0] DateComponent1 DateSeparator[1] DateComponent2 DateSeparator[2] 

 DateComponent3 DateSeparator[3]

 where the ordering of date components is determined by the locale's date format 

 setting.

 The time format follows the pattern:

 TimeSeparator[0] Hours TimeSeparator[1] Minutes TimeSeparator[2] Seconds TimeSeparator[3]

 If the time includes a microseconds component, the third separator should 

 occur after the microseconds, and the seconds and microseconds should be separated 

 by the decimal separator. When formatting a two component time, the following 

 rules apply:

 if the time consists of hours and minutes, the third time delimiter should 

 be omitted 

 if the time consists of minutes and seconds, the second time delimiter should 

 be omitted

 @param aDes    Descriptor, which,  on return contains the formatted date/time string.

 @param aFormat Format string which determines the format of the date and time.

 @leave KErrOverflow The date/time string is too long for the descriptor aDes.

 @leave KErrGeneral  A formatting error has occurred.

 */

 	{

 	TLocale local;

 	FormatL(aDes,aFormat,local);

 	}

 EXPORT_C void TTime::FormatL(TDes &aDes,const TDesC &aFormat,const TLocale &aLocale) const

 //

 // Fill aString with current Date and Time according to given aFormat string

 //

 /**

 Puts this TTime into a descriptor and formats it according to the format string 

 specified in the second argument.

 Many of the formatting commands use the 

 system's locale settings for the date and time, for example the characters 

 used to separate components of the date and time and the ordering of day, 

 month and year. The list of formatting commands below is divided into two 

 sections, the first of which lists the commands which operate without reference 

 to the locale's date and time settings (see class TLocale) and the second 

 table lists the commands which do use these settings.

 The following formatting commands do not honour the locale-specific system 

 settings:

 \%\% : Include a single '%' character in the string

 \%* : Abbreviate following item (the following item should not be preceded 

 by a '%' character).

 \%C : Interpret the argument as the six digit microsecond component of the 

 time. In its abbreviated form, ('%*C') this should be followed by an integer 

 between zero and six, where the integer indicates the number of digits to display.

 \%D : Interpret the argument as the two digit day number in the month. Abbreviation 

 suppresses leading zero.

 \%E : Interpret the argument as the day name. Abbreviation is language-specific 

 (e.g. English uses the first three letters).

 \%F : Use this command for locale-independent ordering of date components. 

 This orders the following day/month/year component(s) (\%D, \%M, \%Y for example) 

 according to the order in which they are specified in the string. This removes 

 the need to use \%1 to \%5 (described below).

 \%H : Interpret the argument as the one or two digit hour component of the 

 time in 24 hour time format. Abbreviation suppresses leading zero. For locale-dependent 

 hour formatting, use \%J.

 \%I : Interpret the argument as the one or two digit hour component of the 

 time in 12 hour time format. The leading zero is automatically suppressed 

 so that abbreviation has no effect. For locale-dependent hour formatting, 

 use \%J.

 \%M : Interpret the argument as the one or two digit month number. Abbreviation 

 suppresses leading zero.

 \%N : Interpret the argument as the month name. Abbreviation is language specific, e.g. 

 English uses the first three letters only. When using locale-dependent formatting, 

 (that is, \%F has not previously been specified), specifying \%N causes any 

 subsequent occurrence of a month specifier in the string to insert the month 

 as text rather than in numeric form. When using locale-independent formatting, 

 specifying \%N causes the month to be inserted as text at that position, but 

 any subsequent occurrence of \%M will cause the month to be inserted in numeric 

 form.

 \%S : Interpret the argument as the one or two digit seconds component of the 

 time. Abbreviation suppresses leading zero.

 \%T : Interpret the argument as the one or two digit minutes component of the 

 time. Abbreviation suppresses leading zero.

 \%W : Interpret the argument as the one or two digit week number in year. Abbreviation 

 suppresses leading zero.

 \%X : Interpret the argument as the date suffix. Cannot be abbreviated. When 

 using locale-dependent formatting (that is, \%F has not previously been specified), 

 \%X causes all further occurrences of the day number to be displayed with the 

 date suffix. When using locale-independent formatting, a date suffix will 

 be inserted only after the occurrence of the day number which \%X follows in 

 the format string. Any further occurrence of \%D without a following \%X will 

 insert the day number without a suffix.

 \%Y : Interpret the argument as the four digit year number. Abbreviation suppresses 

 the first two digits.

 \%Z : Interpret the argument as the one, two or three digit day number in the 

 year. Abbreviation suppresses leading zeros.

 The following formatting commands do honour the locale-specific system settings:

 \%. : Interpret the argument as the decimal separator character (as set by 

 TLocale::SetDecimalSeparator()). The decimal separator is used to separate 

 seconds and microseconds, if present.

 \%: : Interpret the argument as one of the four time separator characters (as 

 set by TLocale::SetTimeSeparator()). Must be followed by an integer between 

 zero and three inclusive to indicate which time separator character is being 

 referred to.

 \%/ : Interpret the argument as one of the four date separator characters (as 

 set by TLocale::SetDateSeparator()). Must be followed by an integer between 

 zero and three inclusive to indicate which date separator character is being 

 referred to.

 \%1 : Interpret the argument as the first component of a three component date 

 (i.e. day, month or year) where the order has been set by TLocale::SetDateFormat(). 

 When the date format is EDateEuropean, this is the day, when EDateAmerican, 

 the month, and when EDateJapanese, the year. For more information on this 

 and the following four formatting commands, see the Notes section immediately 

 below.

 \%2 : Interpret the argument as the second component of a three component date 

 where the order has been set by TLocale::SetDateFormat(). When the date format 

 is EDateEuropean, this is the month, when EDateAmerican, the day and when 

 EDateJapanese, the month.

 \%3 : Interpret the argument as the third component of a three component date 

 where the order has been set by TLocale::SetDateFormat(). When the date format 

 is EDateEuropean, or EDateAmerican this is the year and when EDateJapanese, 

 the day.

 \%4 : Interpret the argument as the first component of a two component date 

 (day and month) where the order has been set by TLocale::SetDateFormat(). 

 When the date format is EDateEuropean this is the day, and when EDateAmerican 

 or EDateJapanese, the month.

 \%5 : Interpret the argument as the second component of a two component date 

 (day and month) where the order has been set by TLocale::SetDateFormat(). 

 When the date format is EDateEuropean this is the month, and when EDateAmerican 

 or EDateJapanese, the day.

 \%A : Interpret the argument as "am" or "pm" text according to the current 

 language and time of day. Unlike the \%B formatting command (described below), 

 \%A disregards the locale's 12 or 24 hour clock setting, so that when used 

 without an inserted + or - sign, am/pm text will always be displayed. Whether 

 a space is inserted between the am/pm text and the time depends on the locale-specific 

 settings. However, if abbreviated (\%*A), no space is inserted, regardless 

 of the locale's settings. The am/pm text appears before or after the time, 

 according to the position of the \%A, regardless of the locale-specific settings. 

 For example, the following ordering of formatting commands causes am/pm text 

 to be printed after the time: \%H \%T \%S \%A. Optionally, a minus or plus sign 

 may be inserted between the "%" and the "A". This operates as follows:

 \%-A causes am/pm text to be inserted into the descriptor only if the am/pm 

 symbol position has been set in the locale to ELocaleBefore. Cannot be abbreviated 

 using asterisk.

 \%+A causes am/pm text to be inserted into the descriptor only if the am/pm 

 symbol position has been set in the locale to ELocaleAfter. Cannot be abbreviated 

 using asterisk. For example, the following formatting commands will cause 

 am/pm text to be displayed after the time if the am/pm position has been set 

 in the locale to ELocaleAfter or before the time if ELocaleBefore: \%-A \%H 

 \%T \%S \%+A.

 \%B Interpret the argument as am or pm text according to the current language 

 and time of day. Unlike the \%A command, when using \%B, am/pm text is displayed 

 only if the clock setting in the locale is 12-hour. Whether a space is inserted 

 between the am/pm text and the time depends on the locale-specific settings. 

 However, if abbreviated (\%*B), no space is inserted, regardless of the locale's 

 settings. The am/pm text appears before or after the time, according to the 

 location of the "%B", regardless of the locale-specific settings. For example, 

 the following formatting commands cause am/pm text to be printed after the 

 time: \%H \%T \%S \%B. Optionally, a minus or plus sign may be inserted between 

 the "%" and the "B". This operates as follows:

 \%-B causes am/pm text to be inserted into the descriptor only if using a 12 

 hour clock and the am/pm symbol position has been set in the locale to ELocaleBefore. 

 Cannot be abbreviated using asterisk.

 \%+B causes am/pm text to be inserted into the descriptor only if using a 12 

 hour clock and the am/pm symbol position has been set in the locale to ELocaleAfter. 

 Cannot be abbreviated using asterisk. For example, the following formatting 

 commands cause am/pm text to be printed after the time if the am/pm position 

 has been set in the locale to ELocaleAfter or before the time if ELocaleBefore: 

 \%-B \%H \%T \%S \%+B.

 \%J Interpret the argument as the hour component of the time in either 12 or 

 24 hour clock format depending on the locale's clock format setting. When 

 the clock format has been set to 12 hour, leading zeros are automatically 

 suppressed so that abbreviation has no effect. Abbreviation suppresses leading 

 zero only when using a 24 hour clock.

 Notes:

 The \%1, \%2, \%3, \%4 and \%5 formatting commands are used in conjunction with 

 \%D, \%M and \%Y to format the date locale-dependently. When formatting the date 

 locale-dependently, the order of the day, month and year components within 

 the string is determined by the order of the \%1 to \%5 formatting commands, 

 not that of \%D, \%M, \%Y.

 When formatting the date locale-independently (that is, \%F has been specified 

 in the format string), the \%1 to \%5 formatting commands are not required, 

 and should be omitted. In this case, the order of the date components is determined 

 by the order of the \%D, \%M, \%Y format commands within aFormat.

 Up to four date separators and up to four time separators can be used to separate 

 the components of a date or time. When formatting a numerical date consisting 

 of the day, month and year or a time containing hours, minutes and seconds, 

 all four separators should always be specified in the format command string. 

 Usually, the leading and trailing separators should not be displayed. In this 

 case, the first and fourth separators should still be specified, but should 

 be represented by a null character.

 The date format follows the pattern:

 DateSeparator[0] DateComponent1 DateSeparator[1] DateComponent2 DateSeparator[2] 

 DateComponent3 DateSeparator[3]

 where the ordering of date components is determined by the locale's date format 

 setting.

 The time format follows the pattern:

 TimeSeparator[0] Hours TimeSeparator[1] Minutes TimeSeparator[2] Seconds TimeSeparator[3]

 If the time includes a microseconds component, the third separator should 

 occur after the microseconds, and the seconds and microseconds should be separated 

 by the decimal separator. When formatting a two component time, the following 

 rules apply:

 if the time consists of hours and minutes, the third time delimiter should 

 be omitted 

 if the time consists of minutes and seconds, the second time delimiter should 

 be omitted

 @param aDes    Descriptor, which,  on return contains the formatted date/time string.

 @param aFormat Format string which determines the format of the date and time.

 @param aLocale Specific locale which formatting will be based on.

 @leave KErrOverflow The date/time string is too long for the descriptor aDes.

 @leave KErrGeneral  A formatting error has occurred.

 */

 	{

 	TDateTime dateTime=DateTime();

 	aDes.Zero(); // ensure string is empty at start

  	TLex aFmt(aFormat);

 	TBool fix=EFalse; // fixed date format

 	TBool da=EFalse; // day unabreviated

 	TBool ma=EFalse; // month unabreviated

 	TBool ya=EFalse; // year unabreviated

 	TBool suff=EFalse; // default no suffix

 	TBool mnam=EFalse; // default month as a number

 	TTimeOverflowLeave overflowLeave;

    	while (!aFmt.Eos())

 		{

 		TChar ch=aFmt.Get();

 		TBool abb=EFalse;

 		const TInt NoPosSpecified=-1;

 		TInt pos=NoPosSpecified;

 		if (ch=='%')

 			ch=aFmt.Get();

 		else // not formatting,just want to add some characters to string

 			goto doAppend; 

 		if (ch=='*') // => abbreviate next field

 			{

 			abb=ETrue;

 			ch=aFmt.Get();

 			}

 		else if (ch=='+' || ch=='-') // => leading or following Am/Pm

 			{

 			pos= ((ch=='+') ? ELocaleAfter : ELocaleBefore);

 			ch=aFmt.Get();

 			if (ch!='A' && ch!='B')

 				User::Leave(KErrGeneral);

 			}

 		switch (ch)

 			{

 		case ':': // local time separator

 				{

 				if (aDes.Length()==aDes.MaxLength())

 					User::Leave(KErrOverflow);

 				ch=aFmt.Get();//Which separator?

 				if (ch<'0' || ch>='0'+KMaxTimeSeparators)

 					User::Leave(KErrGeneral);

 				ch-='0';

 				TChar separator=aLocale.TimeSeparator(ch);

 				if (separator!=0)

 					aDes.Append(separator);

 				}

 			break;

 		case '/': // local date separator

 				{

 				if (aDes.Length()==aDes.MaxLength())

 					User::Leave(KErrOverflow);

 				ch=aFmt.Get();//Which separator?

 				if (ch<'0' || ch>='0'+KMaxDateSeparators)

 					User::Leave(KErrGeneral);

 				ch-='0';

 				TChar separator=aLocale.DateSeparator(ch);

 				if (separator!=0)

 					aDes.Append(separator);

 				}

 			break;

 		case '.': // local decimal separator

 				{

 				if (aDes.Length()==aDes.MaxLength())

 					User::Leave(KErrOverflow);

 				aDes.Append(aLocale.DecimalSeparator());

 				}

 			break;

 		case '1': // 1st element of date,local order

 			switch (aLocale.DateFormat())

 				{

 			case EDateAmerican:

 				goto doMonth;

 			case EDateJapanese:

 				goto doYear;

 			default: // European

 				goto doDay;

 				}

 		case '2': // 2nd element of date,local order

 			switch (aLocale.DateFormat())

 				{

 			case EDateAmerican:

 				goto doDay;

 			default: // European and Japanese have month second

 				goto doMonth;

 				}

 		case '3': // 3rd element of date,local order

 			switch (aLocale.DateFormat())

 				{

 			case EDateJapanese:

 				goto doDay;

 			default: // European and American have year last

 				goto doYear;

 				}

 		case '4': // 1st element of date (no year),local order

 			switch (aLocale.DateFormat())

 				{

 			case EDateEuropean:

 				goto doDay;

 			default:

 				goto doMonth;

 				}

 		case '5': // 2nd element of date (no year),local order

 			switch (aLocale.DateFormat())

 				{

 			case EDateEuropean:

 				goto doMonth;

 			default:

 				goto doDay;

 				}

 		case 'A': // am/pm text

 doAmPm:

             {

             if (pos==NoPosSpecified || pos==aLocale.AmPmSymbolPosition())

 				{

 				TBuf<KMaxAmPmName+1> format(_S("%S"));

 				if (!abb && aLocale.AmPmSpaceBetween())

 					{

 					if (aLocale.AmPmSymbolPosition()==ELocaleBefore)

 						format.Append(' ');

 					else

 						{

 						if (aDes.Length()==aDes.MaxLength())

 							User::Leave(KErrOverflow);

 						aDes.Append(' ');

 						}

 					}

 				TAmPmName amPm((dateTime.Hour()<12) ? EAm : EPm);

 				aDes.AppendFormat(format,&overflowLeave,&amPm);

 				}

 			break;

             }

 		case 'B': // am/pm text if local time format is 12 hour clock

 			if (aLocale.TimeFormat()==ETime24)

 				break;

 			else

 				goto doAmPm;

 		case 'C':

 			{

 			TBuf<6> digits;

 			digits.AppendFormat(_L("%06d"),dateTime.MicroSecond());

 			TUint numChars=6;	// Default length

 			if (abb)

 				{

 				ch=aFmt.Get();

 				if (ch>='0' && ch<='6')

 					{

 					numChars=ch;

 					numChars-='0';

 					}

 				}

 			if (aDes.Length()>(TInt)(aDes.MaxLength()-numChars))

 			    User::Leave(KErrOverflow);

 			aDes.Append(digits.Left(numChars));

 			}	

 			break;

 		case 'D': // day in date

 			if (abb)

 				da=ETrue;

 			if (!fix)

 				break;

 			else

 				{

 doDay:

 				aDes.AppendFormat((da||abb) ? _L("%d"):_L("%02d"),&overflowLeave,dateTime.Day()+1);

 				if (suff)

 doSuffix:

                     {

                     TDateSuffix day(dateTime.Day());

 					aDes.AppendFormat(_L("%S"),&overflowLeave,&day);

                     }

 				break;

 				}

 		case 'E': // Day name

             {

 			TDay day=DayNoInWeek();

 			if (abb)

 				{

 	            TDayNameAbb nameAbb(day);

 				aDes.AppendFormat(_L("%S"),&overflowLeave,&nameAbb);

 				}

 			else

 				{

 	            TDayName name(day);

 				aDes.AppendFormat(_L("%S"),&overflowLeave,&name);

 				}

 			break;

             }

 		case 'F': // => user wants day,month,year order fixed

 			fix=ETrue;

 			break;

 		case 'H': // hour in 24 hour time format

 do24:

 			aDes.AppendFormat((abb) ? _L("%d"):_L("%02d"),&overflowLeave,dateTime.Hour());

 			break;

 		case 'I': // hour in 12 hour time format

 do12:

 			{

 			TInt hour=dateTime.Hour();

 			if (hour==0)

 				hour=12;

 			else if (hour>12)

 				hour-=12;

 			aDes.AppendFormat(_L("%d"),&overflowLeave,hour);

 			break;

 			}

 		case 'J': //default time format for hour

 			if (aLocale.TimeFormat()==ETime12)

 				goto do12;

 			else

 				goto do24;

 		case 'M': // month as a number (default value)

 			if (abb)

 				ma=ETrue;

 			if (fix)

 				goto doMonth;

 			break;

 		case 'N': // month as a name

 			mnam=ETrue;

 			if (abb)

 				ma=ETrue;

 			if (!fix)

 				break;

 			else

 				{

 doMonth:

 				if (mnam)

 					{

 					TMonth month=dateTime.Month();

 					if (ma || abb)

 						{

 		                TMonthNameAbb nameAbb(month);

 						aDes.AppendFormat(_L("%S"),&overflowLeave,&nameAbb);

 						}

 					else

 						{

 	                    TMonthName name(month);

 						aDes.AppendFormat(_L("%S"),&overflowLeave,&name);

 						}

 					}

 				else

 					aDes.AppendFormat((ma||abb) ? _L("%d"):_L("%02d"),&overflowLeave,dateTime.Month()+1);

 				break;

 				}

 		case 'S': // seconds

 			aDes.AppendFormat((abb) ? _L("%d"):_L("%02d"),&overflowLeave,dateTime.Second());

 			break;	

 		case 'T': // minutes	

 			aDes.AppendFormat((abb) ? _L("%d"):_L("%02d"),&overflowLeave,dateTime.Minute());

 			break;

 		case 'W': // week no in year

 			aDes.AppendFormat((abb) ? _L("%d"):_L("%02d"),&overflowLeave,WeekNoInYear());

 			break;

 		case 'X': // => wants day suffix

 			if (fix)

 				goto doSuffix;

 			else

 				{

 				suff=ETrue;

 				break;

 				}

 		case 'Y': // year

 			if (abb)

 				ya=ETrue;

 			if (!fix)

 				break;

 			else

 				{

 doYear:

 				if (ya || abb)

 					aDes.AppendFormat(_L("%02d"),&overflowLeave,((dateTime.Year())%100));

 				else

 					aDes.AppendFormat(_L("%04d"),&overflowLeave,dateTime.Year());

 				break;

 				}

 		case 'Z': // day no in year

 			aDes.AppendFormat((abb) ? _L("%d"):_L("%03d"),&overflowLeave,DayNoInYear());

 			break;

 		default:

 doAppend:

 			if (aDes.Length()==aDes.MaxLength())

 				User::Leave(KErrOverflow);

 			aDes.Append(ch);

 			break;

 			}

 		}

 	}

 EXPORT_C TTime Time::NullTTime()

 /**

 Gets a TTime with a null value.

 @return TTime object with a null value.

 */

 	{

 	return UI64LIT(0x8000000000000000);

 	}

 EXPORT_C TTime Time::MaxTTime()

 /**

 Gets the maximum time value which can be held in a TTime object.

 @return The maximum TTime value.

 */

 	{

 	return I64LIT(0x7fffffffffffffff);

 	}

 EXPORT_C TTime Time::MinTTime()

 /**

 Gets the minimum time value which can be held in a TTime object.

 @return The minimum TTime value.

 */

 	{

 	return UI64LIT(0x8000000000000001);

 	}

 EXPORT_C TInt Time::DaysInMonth(TInt aYear,TMonth aMonth)

 /**

 Gets the number of days in a month.

 @param aYear  The year. Must be specified because of leap years.

 @param aMonth Month, from EJanuary to EDecember.

 @return The number of days in the month.

 */

 	{

     __ASSERT_DEBUG(aMonth<=EDecember && aMonth>=EJanuary,::Panic(ETTimeValueOutOfRange));

     return(mTab[IsLeapYear(aYear)][aMonth]);

 	}

 EXPORT_C TBool Time::IsLeapYear(TInt aYear)

 //

 // up to and including 1600 leap years were every 4 years,since then leap years are every 4 years unless

 // the year falls on a century which is not divisible by 4 (ie 1900 wasnt,2000 will be)

 // for simplicity define year 0 as a leap year

 //

 /**

 Tests whether a year is a leap year.

 @param aYear The year of interest.

 @return True if leap year, False if not.

 */

 	{

 	if (aYear>1600)

     	return(!(aYear%4) && (aYear%100 || !(aYear%400)));

 	return(!(aYear%4));

 	}

 EXPORT_C TInt Time::LeapYearsUpTo(TInt aYear)

 //

 // from 0AD to present year according to the rule above

 //

 /**

 Gets the number of leap years between 0 AD nominal Gregorian and the specified 

 year - inclusive.

 @param aYear The final year in the range to search. If negative, the function 

              will return a negative number of leap years.

 @return The number of leap years between 0 AD nominal Gregorian and aYear.

 */

 	{

 	if (aYear<=0)

 		return(aYear/4);

 	if (aYear<=1600)

 		return(1+((aYear-1)/4));

 	TInt num=401; // 1600/4+1

 	aYear-=1601;

 	TInt century=aYear/100;

 	num+=(aYear/4-century+century/4);

 	return(num);

 	}