--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/genericservices/taskscheduler/SCHSVR/SCHTIME.CPP	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,214 @@
+// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include <e32def.h>
+#include <s32strm.h>
+#include "SCHTIME.H"
+#include "SCHEXEC.H"
+
+/**
+UTC/Local Time flag value
+@internalComponent
+*/
+const TUint32 KIsUtc = 0x00000001;
+
+/** 
+Default constructor for TTsTime.
+This constructor initialises its member data to zero.
+By default this sets it to be UTC based.
+*/ 
+EXPORT_C TTsTime::TTsTime():
+	iUtcTime(0), 
+	iOffset(0), 
+	iFlags(KIsUtc)
+	{
+	}
+
+/**
+Copy constructor for TTsTime
+@param aTTsTime value to duplicate
+*/	
+EXPORT_C TTsTime::TTsTime(const TTsTime& aTTsTime)
+	{
+	*this = aTTsTime;
+	}
+		
+/** 
+Constructs a TTsTime with a TTime. 
+If the iIsUtc is ETrue, then TTsTime is UTC based time, if iIsUtc is EFalse 
+then TTsTime is local time based. This constructor will update all the member data as appropriate.	
+@param aTime The TTime value
+@param aIsUtc is Etrue when aTime is UTC and EFalse when aTime is local time.
+*/	
+EXPORT_C TTsTime::TTsTime(const TTime& aTime, TBool aIsUtc)
+	{
+	// if the time passed as argument is UTC based
+	if(aIsUtc)
+		SetUtcTime(aTime);
+		
+	// if the time passed is local time	
+	else
+		SetLocalTime(aTime);
+	}
+	
+/**
+Sets this object to a local time based value updating its parameters as appropriate.
+@param aLocalTime The local time to be set. 
+*/
+EXPORT_C void TTsTime::SetLocalTime(const TTime& aLocalTime)
+	{
+	iOffset = User::UTCOffset(); // sets the current UTC offset to iOffset
+	iUtcTime = aLocalTime - iOffset; // converts the given aLocalTime to a UTC time value
+	iFlags &= ~KIsUtc;    //set the Bit 0 to zero for Local Time
+	}
+		
+/** 
+Sets this object to a UTC time based value updating its parameters as appropriate.
+@param aUtcTime The UTC time to be set
+*/
+EXPORT_C void TTsTime::SetUtcTime(const TTime& aUtcTime)
+	{
+	iUtcTime = aUtcTime; 
+	iOffset = 0; 
+	iFlags |= KIsUtc;    //set the Bit 0 to one as TTsTime is UTC
+	}
+		
+/** 
+This function returns a home time value.
+@return Retrieves time from object in local time
+*/
+EXPORT_C const TTime TTsTime::GetLocalTime()
+	{
+	return DetermineLocalTime();
+	}
+	
+/** 
+This function returns a home time value.
+@return Retrieves time from object in local time
+*/
+EXPORT_C TTime TTsTime::GetLocalTime() const
+	{
+	return DetermineLocalTime();
+	}	
+		
+/**
+This function returns a UTC value.
+@return Returns the UTC time value.
+*/ 
+EXPORT_C const TTime& TTsTime::GetUtcTime()
+	{
+	return iUtcTime;
+	}
+	
+/**
+This function returns a UTC value.
+@return Returns the UTC time value.
+*/ 
+EXPORT_C const TTime& TTsTime::GetUtcTime() const
+	{
+	return iUtcTime;
+	}
+	
+/** 
+@return ETrue, if TTsTime object is UTC and EFalse if TTsTime object is local time
+*/
+EXPORT_C TBool TTsTime::IsUtc() const
+	{
+	return iFlags & KIsUtc ? ETrue: EFalse;
+	}
+
+	
+/**
+This function returns a home time value.
+If UTC based returns UTC time + User::UTCOffset(). If local time based returns
+local time of the object.
+@internalComponent
+*/
+TTime TTsTime::DetermineLocalTime() const
+	{
+	TTime localTime;
+	if(IsUtc())
+		localTime = iUtcTime+User::UTCOffset();
+	else
+		localTime = iUtcTime+iOffset;
+	
+	return localTime;
+	}
+	
+/** 
+This class does not explicitly update iOffSet if the system TimeZone/DST offset changes.
+When called this API will update the object if the system TimeZone/DST offset has changed. 
+Keeping the offset in objects of this class correct is the responsibility of the 
+Task Scheduler server.This applies to local time objects only. UTC objects will be unaffected.
+@internalComponent
+*/	
+void TTsTime::ProcessOffsetEvent() 
+	{
+	if(iFlags & KIsUtc)
+		return;
+			
+	TTimeIntervalSeconds kernelOffset = User::UTCOffset();
+	
+	// check if there was an offset event happened without TTsTime being updated
+	// localTime will always be the addition of UTC time and kernel offset
+	if (iOffset != kernelOffset)
+		{	
+		// If TTsTime is home time and there was a time zone change then TTsTime needs to be update.
+		// If not then TTsTime remains the same, as UTC times are the same everywhere.
+		iUtcTime = (iUtcTime+iOffset) - kernelOffset; 
+		iOffset = kernelOffset; 
+		}
+	}
+/** 
+Overloaded assignment operator for TTsTime
+@param aTsTime time value to copy
+*/
+EXPORT_C TTsTime& TTsTime::operator=(const TTsTime& aTsTime)
+	{
+	Mem::Copy(this,&aTsTime,sizeof(*this));
+	return *this;	
+	}
+	
+/** 
+Uses the standard template operator>>() to internalize the object from aStream.
+Additionally this method will ensure that the object is updated in the event that 
+the system TimeZone/DST offset changed since it was externalised.
+@internalComponent
+*/
+void TTsTime::InternalizeL(RReadStream& aStream)  
+	{
+	TInt32 offset;
+	TInt64 utcTime;
+	
+	// Updates TTsTime if local time based and the system Timezone/DST change occurred.
+	ProcessOffsetEvent();
+				
+	aStream >> utcTime;
+	iUtcTime = TTime(utcTime);
+	aStream >> offset;
+	iOffset = offset;
+	aStream >> iFlags;	
+	}
+	
+/** 
+Uses the standard template operator>>() to externalize the object to aStream
+@internalComponent
+*/
+void TTsTime::ExternalizeL(RWriteStream& aStream) const
+	{
+	aStream << iUtcTime.Int64();
+	aStream.WriteInt32L(iOffset.Int());
+	aStream.WriteUint32L(iFlags);
+	}