// 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.