C++ TTime::DaysFrom方法代码示例

/*
-------------------------------------------------------------------------
-------------------------------------------------------------------------
*/
TBool CExPolicy_Server::IsTimeBeforeL(TTime& aTime,TTime& aCompare)
{
	TBool IsBefore(EFalse);
	TTimeIntervalMinutes MinInterval(0);
	TTimeIntervalHours 	 HourInterval(0);
	TTimeIntervalSeconds SecInterval(0);
	
	TTime TimeNow;
	TimeNow.HomeTime();
	
	TTimeIntervalDays DaysInterval = aTime.DaysFrom(aCompare);
	if(DaysInterval.Int() <= 0)
	{
		aTime.HoursFrom(aCompare,HourInterval);
		if(HourInterval.Int() <= 0)
		{
			aTime.MinutesFrom(aCompare,MinInterval);
			if(MinInterval.Int() <= 0)
			{
				aTime.SecondsFrom(aCompare, SecInterval);
				if(SecInterval.Int() <= 0)
				{
					IsBefore = ETrue;
				}
			}
		}
	}
	
	return IsBefore;
}

// -----------------------------------------------------------------------------
// CPIMAgnEventAdapter::ConvertRepeatToAgnL
// Makes conversion from framework PIM item repeat rule to native entry repeat.
// -----------------------------------------------------------------------------
//
void CPIMAgnEventAdapter::ConvertRepeatToAgnL(
    const MPIMEventItem& aEventItemData, CCalEntry& aAgnEntry)
{
    JELOG2(EPim);
    const MPIMRepeatRuleData* repeatRuleData = aEventItemData.GetRepeat();

    TTime eventStart = aAgnEntry.StartTimeL().TimeUtcL();

    TCalRRule agnRRule = PIMRepeatRuleConverter::ConvertSupportedRepeatToAgnL(
                             *repeatRuleData, eventStart);

    if ((aAgnEntry.EntryTypeL() == CCalEntry::EAnniv) && (agnRRule.Type()
            != TCalRRule::EYearly))
    {
        User::Leave(KErrArgument);
    }

    if (agnRRule.Type() == TCalRRule::EWeekly)
    {
        __ASSERT_ALWAYS(agnRRule.Interval() <= 2, User::Leave(KErrArgument));
    }
    else // other than weekly
    {
        __ASSERT_ALWAYS(agnRRule.Interval() == 1, User::Leave(KErrArgument));
    }

    // Use local time to check the day since UTC times provide incorrect
    // results if the compared dates are near midnight
    TTime untilLocal = agnRRule.Until().TimeLocalL();
    TTime startLocal = aAgnEntry.StartTimeL().TimeLocalL();
    // Validate that repeat rule is correct. The end of the repeat rule
    // must be greater than the event start and it must not be within
    // the same day as the start of the event
    if (untilLocal != Time::NullTTime())
    {
        __ASSERT_ALWAYS(untilLocal >= startLocal, User::Leave(KErrAbort));
        TTimeIntervalDays intervalDays = untilLocal.DaysFrom(startLocal);
        // Interval smaller than one day. Check that the day is not the same
        if (intervalDays < TTimeIntervalDays(1))
        {
            __ASSERT_ALWAYS(untilLocal.DateTime().Day()
                            != startLocal.DateTime().Day(), User::Leave(KErrAbort));
        }
    }

    // Repeat Rules OK
    aAgnEntry.SetRRuleL(agnRRule);
    CopyExceptionDatesToAgnL(*repeatRuleData, aAgnEntry);
}

// ---------------------------------------------------------------------------
// CBCTestLogger::CreateMainLogL
// ---------------------------------------------------------------------------
//
void CBCTestLogger::CreateMainLogL()
    {
    RFile mainFile;
    RFs tempServer = iEikEnv->FsSession();
    TInt err = mainFile.Create( tempServer, KMainLog, 
        EFileWrite | EFileStreamText );
    if ( err != KErrNone )
        {
        if ( err == KErrAlreadyExists )
            {
            TInt errnum = mainFile.Open( tempServer, KMainLog, 
                EFileRead | EFileStreamText );
            if ( errnum != KErrNone )
                {
                return;
                }
            }
        }    
    CleanupClosePushL( mainFile );
    
    if ( err == KErrNone )
        {
        WriteToFileL( mainFile,  iBuf );
        }
    else if ( err == KErrAlreadyExists )
        {
        TTime modifiedTime;
        TTime homeTime;
        homeTime.HomeTime();
        err = mainFile.Modified( modifiedTime );
        if ( err == KErrNone )
            {
            TTimeIntervalDays days = homeTime.DaysFrom( modifiedTime );
            TInt interval = days.Int();
            if ( interval >= KTheMaxInterval || interval <= -KTheMaxInterval )
                {
                mainFile.Close();
                mainFile.Replace( tempServer, KMainLog,
                    EFileWrite | EFileStreamText );                
                WriteToFileL( mainFile,  iBuf );
                }
            }     
        }
    
    CleanupStack::PopAndDestroy( &mainFile );
    }

void AppendTimeDifference(TDes8& aInto, TTime from, TTime now)
{
	CALLSTACKITEM_N(_CL("CLocaLogicImpl"), _CL("~CLocaLogicImpl"));


	if (from > now) {
		TTime s=from;
		from=now;
		now=s;
	}
	for(;;) {
		TTimeIntervalMinutes mins;
		if (now.MinutesFrom(from, mins)!=KErrNone) {
			mins=61;
		} 
		TTimeIntervalHours hours;
		if (now.HoursFrom(from, hours)!=KErrNone) {
			hours=25;
		} 
		TTimeIntervalDays days;
		days=now.DaysFrom(from);
		if (mins < TTimeIntervalMinutes(60)) {
			aInto.AppendNum(mins.Int());
			aInto.Append(_L8(" minutes "));
			break;
		} else if ( hours < TTimeIntervalDays(24)) {
			aInto.AppendNum(hours.Int());
			aInto.Append(_L8(" hours "));
			from+=TTimeIntervalHours(hours);
		} else {
			aInto.AppendNum(days.Int());
			aInto.Append(_L8(" days "));
			from+=TTimeIntervalDays(days);
		}
	}
}