diff -r 000000000000 -r e4d67989cc36 genericservices/taskscheduler/SCHSVR/SCHINFO.CPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/genericservices/taskscheduler/SCHSVR/SCHINFO.CPP	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,485 @@
+// Copyright (c) 2004-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 "SCHINFO.H"
+#include "SCHEXEC.H"
+
+/**
+Persists flag value, used by TScheduleState2
+@internalComponent
+*/
+const TUint32 KPersists = 0x00000001;
+
+
+/**
+IsEnabled flag value, used by TScheduleState2
+@internalComponent
+*/
+const TUint32 KIsEnabled = 0x00000002;
+
+
+EXPORT_C TTaskInfo::TTaskInfo(TInt aTaskId, TName& aName, TInt aPriority, TInt aRepeat)
+				:iRepeat(aRepeat), iTaskId(aTaskId), iName(aName), iPriority(aPriority)
+/** Constructor taking the specified parameters.
+
+@param aTaskId The task Id.
+@param aName The name of the task.
+@param aPriority The task priority.
+@param aRepeat How often the task is to be repeated */
+	{
+	} 
+
+EXPORT_C TTaskInfo::TTaskInfo()
+/** Default constructor. */
+	{
+	}
+
+EXPORT_C TTaskInfo& TTaskInfo::operator=(const TTaskInfo& aTaskInfo)
+	{
+	Mem::Copy(this,&aTaskInfo,sizeof(*this));
+	return *this;
+	}
+
+EXPORT_C void TTaskInfo::ExternalizeL(RWriteStream& aWriteStream) const
+/** Externalises an object of this class to a write stream.
+	
+	The presence of this function means that the standard templated operator<<() 
+	can be used to externalise objects of this class.
+	
+	@param aStream Stream to which the object should be externalised. */
+	{
+	aWriteStream << iName;
+	aWriteStream.WriteInt32L(iTaskId);
+	aWriteStream.WriteInt32L(iRepeat);
+	aWriteStream.WriteInt32L(iPriority);
+	}
+
+EXPORT_C void TTaskInfo::InternalizeL(RReadStream& aReadStream)
+	/** Internalises an object of this class from a read stream.
+	
+	The presence of this function means that the standard templated operator>>() 
+	can be used to internalise objects of this class.
+	
+	Note that the function has assignment semantics. It replaces the old value 
+	of the object with a new value read from the read stream.
+	
+	@param aStream Stream from which the object is to be internalised. */
+	{
+	aReadStream >> iName;
+	iTaskId = aReadStream.ReadInt32L();
+	iRepeat = aReadStream.ReadInt32L();
+	iPriority = aReadStream.ReadInt32L();
+	}
+
+//
+/**
+Externalizes the ScheduleEntryInfo
+@internalComponent only used by server
+*/
+void TScheduleEntryInfo::ExternalizeL(RWriteStream& aStream) const
+	{
+	aStream.WriteInt32L(iValidityPeriod.Int());
+	aStream.WriteInt32L(iInterval);
+	aStream.WriteInt8L(iIntervalType);
+	TInt64 asInt = iStartTime.Int64();
+	aStream.WriteInt32L(I64LOW(asInt));
+	aStream.WriteInt32L(I64HIGH(asInt));
+	}
+
+/**
+Internalizes the ScheduleEntryInfo
+@internalComponent only used by server
+*/
+void TScheduleEntryInfo::InternalizeL(RReadStream& aStream)
+	{
+	iValidityPeriod = aStream.ReadInt32L();
+	iInterval = aStream.ReadInt32L();
+	iIntervalType = TIntervalType(aStream.ReadInt8L());
+	TInt64 asInt;
+	TInt lo;
+	TInt hi;
+	lo=aStream.ReadInt32L();
+	hi=aStream.ReadInt32L();
+	asInt = MAKE_TINT64(hi,lo);
+	iStartTime = asInt;
+	}
+
+
+
+/**
+TScheduleEntryInfo2 Default constructor. 
+It sets the object's members data to the following default values.
+iIntervalType : EHourly
+iStartTime : UTC time set to 0
+iInterval : 0
+iValidityPeriod : 0
+*/
+EXPORT_C TScheduleEntryInfo2::TScheduleEntryInfo2() :
+		iInterval(0),
+		iIntervalType(TIntervalType(0)),
+		iValidityPeriod(0),
+		iReserved(NULL)
+	{
+		
+	}
+	
+/**
+Copy constructor for TScheduleEntryInfo2
+Sets the parameter's data to this object.
+@param aEntryInfo The TScheduleEntryInfo2 object to be copied
+*/	
+EXPORT_C TScheduleEntryInfo2::TScheduleEntryInfo2(const TScheduleEntryInfo2& aEntryInfo)
+	{
+	*this = aEntryInfo;
+	}
+
+/**
+TScheduleEntryInfo2 constructor taking the specified parameters.
+
+@param aStartTime The first time that the entry will cause execution of tasks
+@param aIntervalType Defines the type of time-frame relative to which execution of tasks is timed; 
+for example, EHourly implies relative to the current hour, EDaily implies 
+relative to the current day
+@param aInterval The interval between execution of tasks
+For a schedule entry interval to be valid, it should be greater than or equal to 1
+@param aIntervalMinutes The period for which the entry is valid
+*/	
+EXPORT_C TScheduleEntryInfo2::TScheduleEntryInfo2(const TTsTime& aStartTime, TIntervalType aIntervalType, TInt aInterval, TTimeIntervalMinutes aValidityPeriod)
+	{
+	iStartTime = aStartTime;
+	iIntervalType = aIntervalType;
+	iInterval = aInterval;
+	iValidityPeriod = aValidityPeriod ;
+	iReserved = NULL;
+	}
+
+/**
+Returns the Interval Type
+@return The type of interval used between due times for this schedule entry.
+The type of interval used may be EHourly, EDaily, EMonthly or EYearly.
+@see TIntervalType
+*/
+EXPORT_C TIntervalType TScheduleEntryInfo2::IntervalType() const
+	{
+	return iIntervalType;	
+	}
+
+/**
+Sets the type of interval used between due times for this schedule entry.
+The type of interval used may be EHourly, EDaily, EMonthly or EYearly.
+@param aIntervalType The type of interval to be used.
+@see TIntervalType
+*/	
+EXPORT_C void TScheduleEntryInfo2::SetIntervalType(TIntervalType aIntervalType)
+	{
+	iIntervalType = aIntervalType;	
+	}
+
+/**
+Returns the first time at which the entry will cause execution of tasks.
+@return Start time - this TTsTime value may be either UTC or local time based.
+Entries with local time based start times will remain at that local time regardless of
+timezone or DST changes (ie. will float). Entries with UTC based start times, will
+remain at the given UTC time (will not float).
+@see TTsTime
+*/
+EXPORT_C const TTsTime& TScheduleEntryInfo2::StartTime() const
+	{
+	return iStartTime;	
+	}
+
+/**
+Sets the first time the entry will cause execution of tasks.
+@param aStartTime This TTsTime value may be either UTC or local time based.
+If this is a local time based value, the schedule entry will remain
+at that local time regardless of timezone and DST changes (ie. it will float)
+If the value is UTC based, the schedule entry will remain at that UTC time (will not float).
+@see TTsTime
+*/
+EXPORT_C void TScheduleEntryInfo2::SetStartTime(const TTsTime& aStartTime)
+	{
+	iStartTime = aStartTime;
+	}
+	
+/**
+Returns the interval between execution of tasks.
+@return Interval between execution of tasks. 
+For a schedule entry interval to be valid, it should be greater than or equal to 1.
+@see TScheduleEntryInfo2::SetInterval
+*/	
+EXPORT_C TInt TScheduleEntryInfo2::Interval() const
+	{
+	return 	iInterval;
+	}
+
+/**
+Sets the interval between execution of tasks.
+The way that this value is interpreted depends on the value of iIntervalType. 
+For example, if the interval is 2 and iIntervalType has a value of EMonthly, 
+then the interval is 2 months. 
+@param aInterval For a schedule entry interval to be valid, it should be greater than or equal to 1.
+*/	
+EXPORT_C void TScheduleEntryInfo2::SetInterval(TInt aInterval)
+	{
+	iInterval = aInterval;	
+	}
+
+/**
+Return the period for which the entry is valid.
+After the validity period has expired, tasks associated with the entry will 
+not be eligible for execution
+@return TTimeIntervalMinutes
+*/
+EXPORT_C TTimeIntervalMinutes TScheduleEntryInfo2::ValidityPeriod() const
+	{
+	return iValidityPeriod;	
+	}
+	
+/**
+Sets the period for which the entry is valid.
+After the validity period has expired, tasks associated with the entry will 
+not be eligible for execution
+@param aValidityPeriod, the period for which the entry is valid
+@see TTimeIntervalMinutes
+*/	
+EXPORT_C void TScheduleEntryInfo2::SetValidityPeriod(TTimeIntervalMinutes aValidityPeriod)
+	{
+	iValidityPeriod = aValidityPeriod;	
+	}
+
+
+/**
+Non exported constructor accepting a TScheduleEntryInfo parameter
+This constructor is provided for use with the deprecated APIs.
+This will assume home time in order to maintain backwards compatibility and will create a #
+TScheduleEntryInfo2 object with a local time based start time.
+@param aEntryInfo Entry info of deprecated type TScheduleEntryInfo
+@see TScheduleEntryInfo
+*/
+TScheduleEntryInfo2::TScheduleEntryInfo2(const TScheduleEntryInfo& aEntryInfo)
+	{	
+	iStartTime.SetLocalTime(aEntryInfo.iStartTime);
+	iIntervalType = aEntryInfo.iIntervalType;
+	iInterval = aEntryInfo.iInterval;
+	iValidityPeriod = aEntryInfo.iValidityPeriod ;	
+	}
+
+
+/**
+Externalises an object of this class to a write stream.
+The presence of this function means that the standard templated operator<<() 
+can be used to externalise objects of this class.
+	
+@param aStream Stream to which the object should be externalised.
+@internalComponent only used by server
+*/
+void TScheduleEntryInfo2::ExternalizeL(RWriteStream& aStream) const
+	{
+	aStream << iStartTime;
+	aStream.WriteInt32L(iIntervalType);	
+	aStream.WriteInt32L(iInterval);
+	aStream.WriteInt32L(iValidityPeriod.Int());	
+	}
+
+	
+/**
+Internalises an object of this class from a read stream.
+The presence of this function means that the standard templated operator>>() 
+can be used to internalise objects of this class.
+		
+@param aStream Stream from which the object is to be internalised.
+@internalComponent only used by server
+*/	
+void TScheduleEntryInfo2::InternalizeL(RReadStream& aStream)
+	{
+	aStream >> iStartTime;
+	iIntervalType = TIntervalType(aStream.ReadInt32L());
+	iInterval = aStream.ReadInt32L();
+	iValidityPeriod = aStream.ReadInt32L();
+	}
+	
+/**
+Calls ProcessOffsetEvent() on TScheduleEntryInfo's start time member
+@see TTsTime::ProcessOffsetEvent
+@internalComponent only used by the server
+*/
+void TScheduleEntryInfo2::ProcessOffsetEvent()
+	{
+	iStartTime.ProcessOffsetEvent();
+	}
+
+/**
+Assignment operator for TScheduleEntryInfo2
+@see Mem::Copy
+*/
+EXPORT_C TScheduleEntryInfo2& TScheduleEntryInfo2::operator=(const TScheduleEntryInfo2& aEntryInfo)
+	{
+	Mem::Copy(this,&aEntryInfo,sizeof(*this));
+	return *this;
+	}
+	
+/**
+Default Constructor for TScheduleState2.
+By default, this state: has an empty string name, is non persistent, non enabled and its due time is set to zero.
+*/
+EXPORT_C TScheduleState2::TScheduleState2():
+	iName(_L("")),
+	iFlags(0),
+	iReserved(NULL)
+	{
+		
+	}
+
+/**
+Copy constructor for TScheduleState2
+@param aScheduleState The TScheduleState2 object to be copied
+*/	
+EXPORT_C TScheduleState2::TScheduleState2(const TScheduleState2& aScheduleState)
+	{
+	*this = aScheduleState;
+	}
+
+/**
+Constructor taking the specified parameters.
+@param	aName The name of the schedule
+@param 	aDueTime The time when the schedule is next due.
+@param 	aPersists Boolean to indicate whether the schedule is persistent or not.
+if a schedule is persistent, its lifetime is not limited to the lifetime of 
+the tasks associated with it.
+If a schedule is transient, it is created together with a new scheduled task, 
+and is destroyed when the task is destroyed
+@param 	aEnabled Boolean to indicate whether the shedule is enabled or not.
+*/	
+EXPORT_C TScheduleState2::TScheduleState2(const TName& aName, const TTsTime& aDueTime, TBool aPersists, TBool aEnabled)
+	{
+	iName = aName;
+	iDueTime = aDueTime;
+	SetPersists(aPersists);
+	SetEnabled(aEnabled);
+	iReserved = NULL;
+	
+	}
+		
+/**
+@return  The name of the schedule
+*/
+EXPORT_C const TName& TScheduleState2::Name() const
+	{
+	return iName;	
+	}
+	
+/**
+Sets the name of the schedule
+@param aName The name of the schedule
+*/	
+EXPORT_C void TScheduleState2::SetName(const TName& aName)
+	{
+	iName = aName;	
+	}
+
+
+/**
+Returns the time when the schedule is next due.
+@return The time when the schedule is next due. This time could be either home time (for floating schedules) or UTC time.
+@see TTsTime
+*/
+EXPORT_C const TTsTime& TScheduleState2::DueTime() const
+	{
+	return iDueTime;	
+	}
+
+	
+/**
+Sets the time when the schedule is next due.
+@param aDueTime The time when the schedule is next due. This time could be either home time (for floating schedules) or UTC time.
+@see TTsTime
+*/	
+EXPORT_C void TScheduleState2::SetDueTime(const TTsTime& aDueTime)
+	{
+	iDueTime = aDueTime;
+	}
+
+
+/**
+Returns a boolean whether this schedule perists or not.
+@return Etrue if this schedule persists, EFalse if this schedule doen't persist.
+*/
+EXPORT_C TBool TScheduleState2::Persists() const
+	{
+	return iFlags & KPersists ? ETrue: EFalse;		
+	}
+
+	
+
+/**
+Sets a boolean whether this schedule perists or not.
+@param aPersists Etrue if this schedule persits, EFalse if this schedule doen't persist.
+*/	
+EXPORT_C void TScheduleState2::SetPersists(TBool aPersists)
+	{
+	if(aPersists )
+		iFlags |= KPersists;
+	else
+		iFlags &= ~KPersists;
+	}
+
+
+/**
+Returns information on whether this schedule is enabled or not.
+@return Etrue if the schedule is enabled, EFalse id the schedule is not enabled.
+*/
+EXPORT_C TBool TScheduleState2::Enabled() const
+	{
+	return iFlags & KIsEnabled ? ETrue: EFalse;	
+	}
+
+	
+/**
+Sets information on whether this schedule is enabled or not.
+@param aEnabled 
+*/	
+EXPORT_C void TScheduleState2::SetEnabled(TBool aEnabled)
+	{
+	if(aEnabled )
+		iFlags |= KIsEnabled;
+	else
+		iFlags &= ~KIsEnabled;	
+	}
+
+/**
+Assigns a TScheduleState2 to this object.
+@see Mem::Copy
+*/
+EXPORT_C TScheduleState2& TScheduleState2::operator=(const TScheduleState2& aScheduleState)
+	{
+	Mem::Copy(this,&aScheduleState,sizeof(*this));
+	return *this;
+	}
+
+/**
+A constructor for TScheduleState that takes a TScheduleState2 parameter,
+for use with the deprecated APIs. All TScheduleStates created will have 
+local time based iDueTime data members.
+@internalComponent
+*/
+TScheduleState::TScheduleState(const TScheduleState2& aScheduleState2)
+	{
+	iName = aScheduleState2.Name();	
+	iPersists = aScheduleState2.Persists();
+	iEnabled = aScheduleState2.Enabled();
+	
+	// iDueTime is local time based for backwards compatibility
+	iDueTime = aScheduleState2.DueTime().GetLocalTime();
+	}