C++ TTime类代码示例

TBMNs TBMTimeInterval::EndNs()
	{
	//
	// Now, in the reverse order
	//
	TBMTicks stamp;
	::bmTimer.Stamp(&stamp);
	TTime time;	
	time.HomeTime();
	TBMNs ns = TTimeIntervalMicroSecondsToTBMNs(time.MicroSecondsFrom(iTime));
	//
	// If the interval fits in the high-precision timer period we can use it;
	// otherwise, use the low-precision timer.
	//
	if (ns < iStampPeriodNs)
		{
		stamp = TBMTicksDelta(iStamp, stamp);
		::bmTimer.TicksToNs(&stamp, &ns);
		}
	return ns;
	}

void CMsvScheduleSend::CreateScheduleL(const TTime& aTime, const TTimeIntervalMinutes& aValidityPeriod, const CArrayFixFlat<TTaskSchedulerCondition>& aSchConditions, TBool aPendingConditions, TSchedulerItemRef& aRef)
	{
	if( aPendingConditions )
		{
		CreateScheduleL(iScheduler, aSchConditions, aTime, aRef);
	#ifndef _MSG_NO_LOGGING
		TBuf<32> bufDate;
		aTime.FormatL(bufDate, _L("%D%M%Y%/0%1%/1%2%/2%3%/3 %-B%:0%J%:1%T%:2%S%.%*C4%:3%+B"));
		SCHSENDLOG(FLog(_L("\tCreated Schedule %d for pending %d conditions or %S"), aRef.iHandle, aSchConditions.Count(), &bufDate));
	#endif		
		}
	else
		{		
		CreateScheduleL(iScheduler, *iSettings, aTime, aValidityPeriod, aRef);
	#ifndef _MSG_NO_LOGGING
		TBuf<32> bufDate;
		aTime.FormatL(bufDate, _L("%D%M%Y%/0%1%/1%2%/2%3%/3 %-B%:0%J%:1%T%:2%S%.%*C4%:3%+B"));
		SCHSENDLOG(FLog(_L("\tCreated Schedule %d for %S"), aRef.iHandle, &bufDate));
	#endif
		}
	}

EXPORT_C void CMsvScheduleSend::RoundUpToMinute(TTime& aTime)
	{
	TDateTime dt(aTime.DateTime());

	if (dt.MicroSecond() != 0 || dt.Second() != 0)
		{
		dt.SetMicroSecond(0);
		dt.SetSecond(0);
		aTime = dt;
		aTime += (TTimeIntervalMinutes) 1;
		}
	}

// -----------------------------------------------------------------------------
// CCbsMessageCleanupTimer::StartTimer
// Starts the clean up timer.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCbsMessageCleanupTimer::StartTimer()
    {    
    // Cancel a pending request
    if ( IsActive() )
        {
        Cancel();
        }

    // Get the current time
    TTime now;
    now.HomeTime();

    if ( iInterval.Int() > 0 )
        {
        TTime nextCleanup( 0 );
        nextCleanup = now + iInterval;
        
        // Start the timer
        At( nextCleanup );
        }
    }

EXPORT_C void CMemSpyEngineOutputSink::DataStreamTimeStampBeginL( const TTime& aTime )
{
    const TDateTime dt( aTime.DateTime() );

    // Build it up...
    HBufC* spec = HBufC::NewL( KMaxFileName );
    TPtr pName( spec->Des() );
    pName.Format( KMemSpyDataStreamFolderNameFormatSpec, dt.Year(), dt.Month()+1, dt.Day()+1, dt.Hour(), dt.Minute(), dt.Second());

    DataStreamTimeStampEnd();
    iDataStreamTimeStampSpecifier = spec;
}

// -----------------------------------------------------------------------------
// CHttpCacheEntry::Accessed
//
// -----------------------------------------------------------------------------
//
void CHttpCacheEntry::Accessed()
    {
    TTime now;
    now.HomeTime();
    iLastAccessed = now.Int64();

    iRef++;

    if ( iEvictionCandidate )
        {
        iEvictionHandler->Accessed( *this );
        }

#ifdef __CACHELOG__
    _LIT( KAccessFormat, "entry accessed: %d" );
    TBuf<100> buf;
    buf.Format( KAccessFormat, iRef );
    HttpCacheUtil::WriteUrlToLog( 0, buf, iUrl->Des() );
#endif // __CACHELOG__

    }

/*
-------------------------------------------------------------------------
-------------------------------------------------------------------------
*/
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;
}

void CBusyTestUnit::ThreadFunction()
	{
	// this runs in a separate thread and tries to use lots of CPU time up to percentage
	// nominally we run busy for loops for iPercentBusy/100ms, and then wait for rest of the
	// 100ms using User::After(). We keep doing this until we reach the target time, if there is
	// one
	
	const TInt KDefaultLoop = 10000;
	TTime timeAtStart; 
	timeAtStart.UniversalTime(); // time of start
	
	const TInt KLoopInterval =100000; // 100ms - loop time
	TTimeIntervalMicroSeconds32 busyInterval(KLoopInterval*iPercentBusy/100); // how much of loop time to be busy
	TTimeIntervalMicroSeconds32 quietInterval(KLoopInterval-busyInterval.Int()); // how much of loop time to be quiet
	
	while (ETrue)
		{
		// the interval, for loops for the busy bit and then a User::After()
		TTime startOfInterval;
		startOfInterval.UniversalTime();
		while (ETrue)
			{
			// the busy bit - iBusyVariable is volatile so should never be optimised out
			for (TInt i=0; i<KDefaultLoop; i++)
				{
				iBusyVariable = i;
				}
			TTime now;
			now.UniversalTime();
			if (startOfInterval + busyInterval < now)
				{
				// we're passed the time
				break;
				}
			}
		User::After(quietInterval);		
			
		if (iRunFor.Int64())
			{
			// check to see if we are passed the interval given at Start()
			TTime now;
			now.UniversalTime();
			if (timeAtStart + iRunFor < now)
				{
				// we're passed the time
				break;
				}
			}
		}
	}

void CPhoneWatcher::DoRetrieveTSYNameL()
	{
#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY
	CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);
#else
	CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);
#endif
	CleanupStack::PushL(db);

	CMDBField<TUint32>* globalSettingsField = new(ELeave) CMDBField<TUint32>(KCDTIdModemPhoneServicesSMS);
	CleanupStack::PushL(globalSettingsField);
	globalSettingsField->SetRecordId(1);
	globalSettingsField->LoadL(*db);
	TUint32 modemId = *globalSettingsField;
	CleanupStack::PopAndDestroy(globalSettingsField);
	
	CMDBField<TDesC>* tsyField = new(ELeave) CMDBField<TDesC>(KCDTIdTsyName);
	CleanupStack::PushL(tsyField);
	tsyField->SetRecordId(modemId);
	tsyField->SetMaxLengthL(KMaxTextLength);
	tsyField->LoadL(*db);
	iTSYName = *tsyField;
	CleanupStack::PopAndDestroy(tsyField);
	
	
	// Strip any file extension
	TInt pos = iTSYName.LocateReverse('.');
	if	(pos >= 0)
		iTSYName = iTSYName.Left(pos);

#ifdef WATCHER_TESTING
	{
	TTime now;
	now.UniversalTime();
	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidTestProp_ModemTableRefreshed.iUid, I64LOW(now.Int64())));
	}
#endif

	CleanupStack::PopAndDestroy(); // db or commsDatabase 
	}

bool_t GetDatePacked(datetime_t t, datepack_t *tp, bool_t Local)
{
	TDateTime Date;
    TTime ot;
	if (!tp || t == INVALID_DATETIME_T) return 0;
	
    ot = DateTimeToSymbian(t);

    if (Local) 
    {
#ifndef SYMBIAN90
        TLocale locale;
        TTimeIntervalSeconds universalTimeOffset(locale.UniversalTimeOffset());
        ot += universalTimeOffset;
        if (locale.QueryHomeHasDaylightSavingOn())
        {
            TTimeIntervalHours daylightSaving(1);
            ot += daylightSaving;
        }
#else
        RTz TzServer;
        if (TzServer.Connect()==KErrNone)
        {
            CTzConverter* Converter = CTzConverter::NewL(TzServer); 
            Converter->ConvertToLocalTime(ot);
            delete Converter;
            TzServer.Close();
        }
#endif
    }

	Date = ot.DateTime();
	tp->Year = Date.Year();
	tp->Month = (int)Date.Month() + 1;
	tp->Day = Date.Day()+1;
	tp->Hour = Date.Hour();
	tp->Minute = Date.Minute();
	tp->Second = Date.Second();
	return 1;
}

LOCAL_D void TestBKLastModifiedTimeL ()
	{
	TTime currentTime;		

	RBkDatabase db;
	db.OpenL ();
	CleanupClosePushL ( db );	
	// Create a new folder.
	RBkFolder folder = db.CreateFolderL ( KMyFolder );
	CleanupClosePushL ( folder );
	folder.SetDescriptionL ( KMyFolderDesc );

	db.CommitL(); // Commit the transaction.
	User::After ( KGeneralDelay );
	currentTime.HomeTime ();
	gTestWrapper->TEST( folder.LastModifiedL() < currentTime ); // Creation time.
	TTime newTime;
	newTime.HomeTime ();
	TRAPD( err, folder.SetLastModifiedL( newTime ) );
	// Should leave with KErrPermissionDenied error
	gTestWrapper->TESTE( err == KErrPermissionDenied, err );	

	CleanupStack::PopAndDestroy ( &folder ); // destroy/close
	// Open the above created folder.
	folder = db.OpenFolderL ( KMyFolder );
	CleanupClosePushL ( folder );
	folder.SetDescriptionL ( KMyFolderNewDesc );
 	
	db.CommitL (); 
	User::After ( KGeneralDelay );
	currentTime.HomeTime ();
	gTestWrapper->TEST( folder.LastModifiedL() < currentTime );  // Save time.
		
	Bookmark::TItemId id = folder.Id();
	CleanupStack::PopAndDestroy ( &folder );
	db.DeleteItemL ( id ); // mark for deleting	
	db.CommitL ();

	CleanupStack::PopAndDestroy ( &db );		
	}

static void testRFileSetModified(TDateTime* aDateTime, TTime* aTime, TBool validDate)
//
// Test RFile::SetModified() and RFile::Modified()
//
	{
	RFile file;
	TInt r=file.Replace(TheFs,_L("Y2KTEST.tst"),0);
	test_Value(r, r == KErrNone || r==KErrPathNotFound);	

	r=file.SetModified(*aTime);
	test_KErrNone(r);
	file.Close();
	
	TTime check;
	file.Open(TheFs,_L("Y2KTEST.tst"),EFileWrite);
	r=file.Modified(check);
	test_KErrNone(r);
	file.Close();
		
	TDateTime checkDateTime=check.DateTime();
	
	test(checkDateTime.Year()==aDateTime->Year());
	if (validDate)
		{
		test(checkDateTime.Month()==aDateTime->Month());
		test(checkDateTime.Day()==aDateTime->Day());
		}
	else
		{
		test(checkDateTime.Month()==aDateTime->Month()+1);
		test(checkDateTime.Day()==0);
		}

	check.FormatL(gDateBuf,_L("%*D%X%N%Y %1 %2 %3"));
	test.Printf(_L("Valid date: %S\n"),&gDateBuf);

	r=TheFs.Delete(_L("Y2KTEST.tst"));
	
	}	

/** Creates files

	@param aSelector Configuration in case of manual execution
*/
LOCAL_C TInt TestAll(TAny* aSelector)
	{
	TInt r = 0;
	TTime startTime;
	TTime endTime;
	TTimeIntervalSeconds timeTaken;

	Validate(aSelector);
	
	gFormat = EFalse; 	// The card won't be formatted after this test execution
	
	startTime.HomeTime();
	
	TestFileCreate(aSelector);
	
	endTime.HomeTime();
	r = endTime.SecondsFrom(startTime, timeTaken);
	FailIfError(r);
	test.Printf(_L("#~TS_Timing_%d,%d=%d\n"), gTestHarness, gTestCase, timeTaken.Int());

	return KErrNone;
	}

CIpuTestHarness::~CIpuTestHarness()
//
//	D'tor
	{
	TTime endtime;
	endtime.UniversalTime();

	// Do resource handle leak test?
	if (iDoResourceLeakTest)
		ResourceLeakTest();

	//	End of tests - see if failed or ok
	if (iFailedTests->Count())
		{
		TestHarnessFailed();
		}
	else
		{
		TestHarnessComplete();
		}

	iFailedTests->ResetAndDestroy();
	delete iFailedTests;

	//	Log finish time
	TDateTime t = endtime.DateTime();
	LogIt(_L("Ended @ %d:%d:%d:%d"),t.Hour(),t.Minute(),t.Second(),t.MicroSecond());
	TTime difftime(endtime.Int64() - iStartTime.Int64());
	t = difftime.DateTime();
	LogIt(_L("Execution time %d:%d:%d:%d"),t.Hour(),t.Minute(),t.Second(),t.MicroSecond());

	//	Close logs and test harness
	iFlogger.CloseLog();
	
	// iTest test harness performs UHEAP MARK/UNMARK check upon creation/destruction
	//   therefore, it must be destroyed last since it is created first in 
	//   CIpuTestHarness
	iTest.Close();
	}

// ---------------------------------------------------------------------------
// TPresCondValidity::ConvertToLocal()
// ---------------------------------------------------------------------------
//        
void TPresCondValidity::ConvertToLocal(TTime& aDateTime)
    {
    OPENG_DP(D_OPENG_LIT( " TPresCondValidity::ConvertToLocal()" ) );
    OPENG_DP(D_OPENG_LIT( "     ConvertToLocal aDateTime:"));
    LogDateTime(aDateTime.DateTime());

    TLocale myLocale;
    myLocale.Refresh();
    
    // getting UTC difference    
    TTimeIntervalSeconds uTCseconds = myLocale.UniversalTimeOffset();
    aDateTime = aDateTime + uTCseconds;
    }