/**
* 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:
* Declaration of Types and Constants for Secure Backup and Restore
* 
*
*/



/**
 @file
*/
#ifndef __SBTYPES_H__
#define __SBTYPES_H__

#include <connect/sbdefs.h>
#include <e32cmn.h>
#include <f32file.h>
#include <connect/sbexternalisablearray.h>

class RApaLsSession;

namespace conn
	{
	/** Maximum length of package name
	@released
	@publishedPartner
	*/
	const TInt KMaxPackageNameLength = 128; // Arbitrary name length

	/** Length of the 128 bit Java hash in bytes
	@released
	@publishedPartner
	*/
	const TInt KJavaIdLength = 16;

	/** Used for unpacking unicode descriptors 
	@released
	@publishedPartner
	*/
	#ifdef UNICODE
	const TInt KCharWidthInBytes = 2;
	#else
	const TInt KCharWidthInBytes = 1;
	#endif // UNICODE
	
	/**
	@released
	@publishedPartner
	*/
	typedef TBufC<KMaxPackageNameLength> TPackageName;

	enum TCommonBUROptions
		/** 
		The passive backup options

		@released
		@publishedPartner
		*/
		{
		ENoOptions 				= 0x00000000, /*!< 0x00000000: no common options selected */
		EActiveBUR				= 0x00000001, /*!< 0x00000001: Does the data owner do active backup / restore? */
		EPassiveBUR				= 0x00000002, /*!< 0x00000002: Does the data owner do passive backup / restore? */
		EHasSystemFiles 		= 0x00000004, /*!< 0x00000004: Does the data owner want system files backed up? */
		ESupportsSelective		= 0x00000008, /*!< 0x00000008: Can the data owner do BUR selectively? */
		ERequiresReboot			= 0x00000010  /*!< 0x00000010: Does the data owner require reboot after restore? */
		};
	
	enum TPassiveBUROptions
		/** 
		The passive backup options

		@released
		@publishedPartner
		*/
		{
		ENoPassiveOptions 		= 0x00000000, /*!< 0x00000000: no passive options selected */
		EHasPublicFiles			= 0x00000001, /*!< 0x00000001: data owner has public files to BUR ? */
		EDeleteBeforeRestore	= 0x00000002, /*!< 0x00000002: data owner requires a delete before restore ? */
		EPassiveSupportsInc 	= 0x00000004  /*!< 0x00000004: data owner supports incremental BUR ? */
		};
	
	enum TActiveBUROptions
		/** 
		The active backup options

		@released
		@publishedPartner
		*/
		{
		ENoActiveOptions 		= 0x00000000, /*!< 0x00000000: no active backup options selected */
		EDelayToPrepareData 	= 0x00000001, /*!< 0x00000001: data owner slow to prepare active data */
		EActiveSupportsInc		= 0x00000002  /*!< 0x00000002: data owner supports incremental BUR ? */
		};
		
	/**	Common BUR Settings
	This structure will store the common backup and restore options for a SID 
	@released
	@publishedPartner	
	*/
	typedef TUint32 TCommonBURSettings;
	
	/**	Passive BUR Settings
	This structure will store the passive backup and restore options for a SID 
	@released
	@publishedPartner	
	*/	
	typedef TUint32 TPassiveBURSettings;
	
	/**	Active BUR Settings
	This structure will store the active backup and restore options for a SID 
	@released
	@publishedPartner	
	*/
	typedef TUint32 TActiveBURSettings;

	class TRestoreFileFilter
		/**
		TRestoreFileFilter packages up a file or directory name and an include or exclude flag.

		This type is used when telling a client during a restore operation which public files are
		to be restored for a specific data owner.

		@released
		@publishedPartner
		*/
		{
	public:
		/**
		Constructor
		
		@param aInclude ETrue if the file or directory is to be
						included, EFalse for exclusion
		@param aName The name of the file or directory (directory
					 names end with a slash)
		*/
		TRestoreFileFilter(TBool aInclude, const TFileName& aName)
			: iInclude(aInclude), iName(aName) {}
	public:
		TBool iInclude ; /*!< ETrue if the file or directory is to be included, EFalse for exclusion */
		TFileName iName; /*!< The name of the file or directory (directory names end with a slash) */
		};

	/** Array of TEntry objects
	@released
	@publishedPartner
	*/
	typedef RExternalisableArray<TEntry> RFileArray;

	/** Array of TRestoreFileFilter objects 
	@released
	@publishedPartner
	*/
	typedef RExternalisableArray<TRestoreFileFilter> RRestoreFileFilterArray;

	/** Array of TSecureId objects
	@released
	@publishedPartner
	*/
	typedef RExternalisableArray<TSecureId> RSIDArray;

	enum TDataOwnerStatus
		/**
		TDataOwnerStatus encapsulates the status of a data owner.

		@released
		@publishedPartner
		*/
		{
		EUnset = 0, /*!< 0x00000000: Unset - allows creation of object without incorrect status */
		EDataOwnerNotFound = 1, /*!< 0x00000001: Data owner not found in registration files */
		EDataOwnerReady = 2, /*!< 0x00000002: Data owner ready for backup / restore */
		EDataOwnerNotReady = 3, /*!< 0x00000003: Data owner not yet ready for backup / restore */
		EDataOwnerFailed = 4, /*!< 0x00000004: Data owner failed to become ready */
		EDataOwnerNotConnected = 5, /*!< 0x00000005: Data owner alive, but not fully ready */
		EDataOwnerReadyNoImpl = 6 /*!< 0x00000006: Data owner ready for backup / restore but does not provide callback implementation */
		};

	class TDataOwnerAndStatus
		/**
		TDataOwnerAndStatus encapsulates the identity and status of a data owner.
		Access to members is direct.

		@released
		@publishedPartner
		*/
		{
	public:
		/**
		Constructor
		
		@param aSID Data owner secure id - identifies the data owner
		@param aStatus Status of the data owner
		@param aDataOwnerError Error code if data owner failed to be ready
							   or KErrNone
		*/
		TDataOwnerAndStatus(TSecureId aSID, TDataOwnerStatus aStatus, TInt aDataOwnerError)
			: iSID(aSID), iStatus(aStatus), iDataOwnerError(aDataOwnerError) {}
	public:
		TSecureId iSID; /*!< Data owner secure id - identifies the data owner */
		TDataOwnerStatus iStatus; /*!< Status of the data owner */
		TInt iDataOwnerError; /*!< Error code if data owner failed to be ready or KErrNone */
		};

	/** Array of data owners with their status
	@released
	@publishedPartner
	*/
	typedef RExternalisableArray<TDataOwnerAndStatus> RSIDStatusArray;

	enum TBackupDataType
		/**
		TBackupDataType indicates whether a specific data stream or operation relates to active or
		passive backup or restore.  A specific data owner can use both active and passive and so we
		need to differentiate between operations.

		@released
		@publishedPartner
		*/
		{
		EActive = 0, /*!< 0x00000000: The backup or restore operation is active rather than passive */
		EPassive = 1 /*!< 0x00000001: The backup or restore operation is passive rather than active */
		};

	enum TTransferDataType
		/**
		TTransferDataType indicates the type of data being transferred from the Secure Backup
		Engine to the Secure Backup Server or vice versa.

		@released
		@publishedPartner
		*/
		{
		ERegistrationData = 0, /*!< 0x00000000: deprecated */
		EPassiveSnapshotData = 1, /*!< 0x00000001: The data is a snapshot for passive backup that includes file details*/
		EPassiveBaseData = 2, /*!< 0x00000002: The data is passively backup up private data with no previous history */
		EPassiveIncrementalData = 3, /*!< 0x00000003: The data is passively backed up private data as an increment on a previous base backup */
		EActiveSnapshotData = 4, /*!< 0x00000004: The data is a snapshot for active backup that includes file details*/
		EActiveBaseData = 5, /*!< 0x00000005: The data is actively backup up private data with no previous history */
		EActiveIncrementalData = 6, /*!< 0x00000006: The data is actively backed up private data as an increment on a previous base backup */
		ECentralRepositoryData = 7, /*!< 0x00000007: deprecated */
		EPublicFileListing = 8, /*!< 0x00000008: An externalised list of public file entries belonging to a single data owner */
		};
		
	enum TSBDerivedType
		/**
		Used to identify the derived type that the base generic type represents
		
		@deprecated
		@publishedPartner
		*/
		{
		ESIDDerivedType = 0, /*!< 0x00000000: SID derived type  */
		EPackageDerivedType = 1, /*!< 0x00000001: Package derived type */
		ESIDTransferDerivedType = 2, /*!< 0x00000002: SID data transfer derived type  */
		EPackageTransferDerivedType = 3, /*!< 0x00000003: Package data transfer derived type */
		EJavaDerivedType = 4, /*!< 0x00000004: Java ID derived type */
		EJavaTransferDerivedType = 5, /*!< 0x00000005: Java ID derived type */
		};
		
		/**
		Maximum number of derived types specified in TSBDerivedType

		@released
		@publishedPartner
		*/
	const TUint KMaxDerivedTypes = 6;	
		
	enum TPackageDataType
		/**
		TPackageDataType indicates the type of package data being
		transferred from the Secure Backup Engine to the Secure Backup
		Server or vice versa.

		@deprecated
		@publishedPartner
		*/
		{
		ESystemData = 0, /*!< 0x00000000: The data is system files (typically executables or resource files) */
		ESystemSnapshotData = 1, /*!< 0x00000001: The data is a snapshot for system files */
		};
		
	enum TJavaTransferType
		/**
		This enum defines the type of Java data that is being transferred and can indicate either a MIDlet 
		suite archive (Jad/Jar etc.) or data for an installed MIDlet suite
		
		@released
		@publishedPartner
		*/
		{
		EJavaMIDlet = 0,
		EJavaMIDletData = 1,
		};

	enum TTransferDirection
		/**
		TTransferDirection indicates whether a (just completed) data transfer is from the
		Secure Backup Server to a data owner or vice versa.

		@released
		@publishedPartner
		*/
		{
		EServerToDataOwner = 0, /*!< 0x00000000: The transfer is from the Secure Backup Server to a data owner */
		EDataOwnerToServer = 1/*!< 0x00000001: The transfer is from a data owner to the Secure Backup Server */
		};
		
	/** Generic Data Type is a class for representing any type of data owner so that it 
	may be passed through a common interface
		
	<H2>Introduction</H2>
	
	The CSBEClient Secure backup interface class is designed to perform backup operations 
	on many different types of data owners. This presents a problem in that the interfaces 
	sometimes require arguments that are specific to the data type in question. In addition, 
	we can't predict the new data types that may appear in future, therefore a "generic" data 
	type was proposed that could be passed through interfaces as a base class and contained 
	enough information to enable Runtime Type Identification (RTTI) to be performed.
	
	This approach means that only one interface needs to be maintained for each backup 
	operation whilst still allowing the Secure Backup Engine to determine which type was 
	originally sent by a PC client.
	
	As well as acting as an identifier for different Data Owner's (DO's), it was decided 
	to extend the usage of the class to identify Data Owner's Data as each DO may require 
	specific information to identify data being transferred (such as finished flags etc.)
	
	The identifier is transparent to the user of CSBEClient, meaning that it can be 
	extracted directly from the message sent by the PC into a generic type and passed through 
	to the SBEngine without being instantiated as a derived class.
	
	<H2>Usage</H2>
	
	The general usage of the generic data type is to extract it from a PC sent message as a 
	CSBGenericDataType object using CSBGenericDataType::NewL(const TDesC8& aDes).
	
	There are a few conventions that have been followed within the Secure Backup component 
	that a developer must bear in mind:
	
	@li Ownership of the CSBGenericDataType, CSBGenericTransferType or derived 
		object is generally passed between interfaces and as such it is the resposibility 
		of the receiving function to delete it. Unless otherwise stated in the documentation
		for an interface, this is assumed to be the case;
		
	@li When a CSBGenericDataType or CSBGenericTransferType is to be converted into 
		a derived type, it must be passed in as a parameter to the constructor of the derived 
		type. It must not be downcasted as it may never have been a derived type, and the 
		derived types contain extra member data;
		
	In order to convert a base type to a derived type, a method CSBGenericDataType::DerivedTypeL() 
	that returns a conn::TSBDerivedType can be called to query the base object for it's derived type.
	
	A typical mechanism would be to use a switch statement, switching on the return value of 
	DerivedTypeL() and taking appropriate action with regards to creating a derived object.
		
	<H2>Internal Operation</H2>
	
	<H3>Initialisation</H3>
	
	CSBGenericDataType is underneath basically a descriptor buffer. All accessor functions 
	simply extract and pack values from this descriptor. This means that the type can be 
	safely transferred via IPC between processes and safely transferred between a device 
	and a PC independently of communications bearer or transport.
	
	The base class CSBGenericDataType has ownership of the data buffer, iDataBuffer, used 
	to store the member data in and in order to keep the derived classes atomic, a running 
	total size variable is updated by the C++ constructors of each class in the inheritence 
	chain. Because of Symbian's static NewL idiom, all C++ constructors are executed before 
	CSBGenericDataType::ConstructL() is called to instantiate the buffer, hence the size 
	can be guaranteed to be big enough to hold all of the derived type's data.
	
	In order to ensure that the derived types know whereabouts in the descriptor to extract 
	and pack values, an initialisation routine, InitialiseL(TInt& aOffset), is implemented 
	by each class. Each class is responsible for calling it's parents InitialiseL(), before 
	initialising itself and passing in an offset. The job of the initialisation method is 
	to walk the descriptor, storing the offset's of it's member data. The offset is a 
	reference and is hence updated so that the child class begins unpacking after the parents 
	data ends. In this way, each class is atomic apart from having to explicitly scope it's 
	parent's InitialiseL() method.
	
	<H3>Accessing Data</H3>
	
	Data is accessed by the use of packing and unpacking bytes directly from the descriptor 
	using the UnpackType, PackType and associated function templates. These will be unpacked 
	in the endianness of the system and therefore the PC will have to ensure that this 
	is taken into account when packing the type into the message.
	
	Although this method suffers in terms of performance, for the reasons of platform 
	independence, this is the most reliable method of packing/unpacking.
	
	<H2>Byte Structure</H2>
	
	All child classes have their data following on from the parent classes so that the parent 
	classes may remain atomic with respect to the structure of their data. The binary structure 
	of this data type inside the descriptor buffer is as follows. Note that the endianness of 
	the data types specified below is determined by the platform and the PC must pack accordingly:
		
	<table border="1">
		<tr>
			<td>TSBDerivedType [4-bytes]</td>
		</tr>
	</table>


	@deprecated
	@publishedPartner
	*/
	class CSBGenericDataType : public CBase
		{
	public:
		IMPORT_C static CSBGenericDataType* NewL(const TDesC8& aDes);
		IMPORT_C ~CSBGenericDataType();
		IMPORT_C const TDesC8& Externalise() const;
		IMPORT_C TSBDerivedType DerivedTypeL() const;
		
	protected:
		CSBGenericDataType();
		void ConstructL(const TDesC8& aDes);
		void BaseConstructL();
		virtual void InitialiseL(TInt& aOffset);
		void UnpackDescriptorTypeAdvance(TDesC16& aDes, TInt& aOffset);
		void UnpackDescriptorTypeAdvance(TDesC8& aDes, TInt& aOffset);
		void UnpackTPtrAdvance(TPtrC16& aDes, TInt& aOffset);
		void UnpackTPtrAdvance(TPtrC8& aDes, TInt& aOffset);
		void PackDescriptorTypeAdvance(const TDesC16& aDes, TInt& aOffset);
		void PackDescriptorTypeAdvance(const TDesC8& aDes, TInt& aOffset);

	protected:
		/** the data buffer */
		HBufC8* iDataBuffer;

		/** Cumulative size of the derived type. All ctors in the inheritence tree increment 
		with their size */
		TInt iSize;

		/** the derived type */
		TInt iDerivedTypeOffset;
		};
		
	template<class T> inline void UnpackType(T& aType, TDesC8& aDes, TInt aOffset)
		/**
		Templated function to copy a simple type from a specified position in aDes
		defined by aOffset. aOffset is not updated on return.
		
		@param aType This pointer is set with the pointer to the type in aDes
		@param aDes The buffer that contains the type T pointed to by aPtr
		@param aOffset The running index of where the following type begins. Updated by ExtractPointer
		*/
		{
		// Set the position at which to finish copying
		TInt endOffset = aOffset + sizeof(T);
		
		TUint8* pRawType = reinterpret_cast<TUint8*>(&aType);
		TUint8* pRawSource = const_cast<TUint8*>(aDes.Ptr()) + aOffset;
		
		for (TInt offset = aOffset; offset < endOffset; offset++)
			{
			*pRawType++ = *pRawSource++;
			}
		}
		
	template<class T> inline void UnpackTypeAdvance(T& aType, TDesC8& aDes, TInt& aOffset)
		/**
		Templated function to copy a simple type from a specified position in aDes
		defined by aOffset. aOffset is advanced so that on return, the new 
		offset is stored enabling the next call to UnpackType() to point at the position 
		following this type.
		
		@param aType This pointer is set with the pointer to the type in aDes
		@param aDes The buffer that contains the type T pointed to by aPtr
		@param aOffset The running index of where the following type begins. Updated by ExtractPointer
		*/
		{
		// Set the position at which to finish copying
		TInt endOffset = aOffset + sizeof(T);
		
		TUint8* pRawType = reinterpret_cast<TUint8*>(&aType);
		TUint8* pRawSource = const_cast<TUint8*>(aDes.Ptr()) + aOffset;
		
		for (; aOffset < endOffset; aOffset++)
			{
			*pRawType++ = *pRawSource++;
			}
		}

	template<> inline void UnpackTypeAdvance(TDriveList& aType, TDesC8& aDes, TInt& aOffset)
		/**
		Templated function to copy a simple type from a specified position in aDes
		defined by aOffset. aOffset is advanced so that on return, the new 
		offset is stored enabling the next call to UnpackType() to point at the position 
		following this type.
		
		@param aType This pointer is set with the pointer to the type in aDes
		@param aDes The buffer that contains the type T pointed to by aPtr
		@param aOffset The running index of where the following type begins. Updated by ExtractPointer
		*/
		{
		TUint8* pRawSource = const_cast<TUint8*>(aDes.Ptr()) + aOffset;
		
		aType.SetMax();
		
		for (TInt index = 0; index < KMaxDrives; index++)
			{
			aType[index] = *pRawSource++;
			}

		aOffset += KMaxDrives;
		}
		
	template<class T> inline void PackType(T& aType, TDesC8& aDes, TInt aOffset)
		/**
		Templated function to copy a simple type into a specified position in aDes
		defined by aOffset. aOffset is not advanced as a result of this operation
		
		@param aType This object is overwritten with the flattened type in aDes
		@param aDes The buffer that contains the type T pointed to by aPtr
		@param aOffset The running index of where the following type begins. Updated by ExtractPointer

		@return The new offset after packing the data type
		*/
		{
		// Set the position at which to finish copying
		TInt endOffset = aOffset + sizeof(T);		
		
		TUint8* pRawType = reinterpret_cast<TUint8*>(&aType);
		TUint8* pRawBuf = const_cast<TUint8*>(aDes.Ptr()) + aOffset;
		
		for (TInt offset = aOffset; offset < endOffset; offset++)
			{
			*pRawBuf++ = *pRawType++;
			}
		}

	template<class T> inline void PackTypeAdvance(T& aType, TDesC8& aDes, TInt& aOffset)
		/**
		Templated function to copy a simple type into a specified position in aDes
		defined by aOffset. aOffset is updated to reflect the advance along aDes
		
		@param aType This object is overwritten with the flattened type in aDes
		@param aDes The buffer that contains the type T pointed to by aPtr
		@param aOffset The running index of where the following type begins. Updated by ExtractPointer

		@return The new offset after packing the data type
		*/
		{
		// Set the position at which to finish copying
		TInt endOffset = aOffset + sizeof(T);		
		
		TUint8* pRawType = reinterpret_cast<TUint8*>(&aType);
		TUint8* pRawBuf = const_cast<TUint8*>(aDes.Ptr() + aOffset);
		
		for (; aOffset < endOffset; aOffset++)
			{
			*pRawBuf++ = *pRawType++;
			}
		}
		

	/** Generic Data Type representing a data owner identified by a SecureId
	
	<H2>Byte Structure</H2>
	
	All child classes have their data following on from the parent classes so that the parent 
	classes may remain atomic with respect to the structure of their data. The binary structure 
	of this data type inside the descriptor buffer is as follows. Note that the endianness of 
	the data types specified below is determined by the platform and the PC must pack accordingly:
		
	<table border="1">
		<tr>
			<td>TSBDerivedType [4-bytes]</td>
			<td>TSecureId [4-bytes]</td>
		</tr>
	</table>
		
	@deprecated
	@publishedPartner
	*/
	class CSBSecureId : public CSBGenericDataType
		{
	public:
		IMPORT_C static CSBSecureId* NewL(TSecureId aSecureId);
		IMPORT_C static CSBSecureId* NewL(CSBGenericDataType* aGenericDataType);
		IMPORT_C ~CSBSecureId();
		IMPORT_C TSecureId SecureIdL() const;
		
	protected:
		void InitialiseL(TInt& aOffset);

	private:
		CSBSecureId();
		void ConstructL(TSecureId aSecureId);
		void ConstructL(CSBGenericDataType* aGenericDataType);
		
	private:
		/** the secure identifier */
		TInt iSecureIdOffset;
		};
		
	/** Generic Data Type representing a data owner identified by a Package Id, Secure Id and 
	Package Name. Package Id's are used to represent multiple SID's installed under a single 
	package. There would potentially be several CSBPackageId's associated with a package, each 
	detailing a single SID.

	<H2>Byte Structure</H2>
	
	All child classes have their data following on from the parent classes so that the parent 
	classes may remain atomic with respect to the structure of their data. The binary structure 
	of this data type inside the descriptor buffer is as follows. Note that the endianness of 
	the data types specified below is determined by the platform and the PC must pack accordingly:

	<table border="1">
		<tr>
			<td>TSBDerivedType [4-bytes]</td>
			<td>TUid [4-bytes]</td>
			<td>TSecureId [4-bytes]</td>
			<td>Pkg name length [4-bytes]</td>
			<td>Pkg name data [variable]</td>
		</tr>
	</table>

	@deprecated
	@publishedPartner
	*/
	class CSBPackageId : public CSBGenericDataType
		{
	public:
		IMPORT_C static CSBPackageId* NewL(TUid aPackageId, TSecureId aSecureId, const TDesC& aPackageName);
		IMPORT_C static CSBPackageId* NewL(CSBGenericDataType* aGenericDataType);
		IMPORT_C ~CSBPackageId();
		IMPORT_C TUid PackageIdL() const;
		IMPORT_C TSecureId SecureIdL() const;
		IMPORT_C TPackageName PackageNameL() const;
		
	protected:
		void InitialiseL(TInt& aOffset);
		void InitialiseL(TInt& aOffset, TInt aPackageNameLength);

	private:
		CSBPackageId();
		void ConstructL(TUid aPackageId, TSecureId aSecureId, const TDesC& aPackageName);
		void ConstructL(CSBGenericDataType* aGenericDataType);
		
	private:
		/** the package identifier */
		TInt iPackageIdOffset;
		/** the secure identifier */
		TInt iSecureIdOffset;
		/** user-readable name for the package */
		TInt iPackageNameOffset;
		};

	/** Generic Transfer Type
	
	This is also a semi-abstract class similar to the CSBGenericDataType in that logically it may 
	only be instantiated by being internalised from a descriptor. This class and classes that derive 
	from it are intended to identify a data transfer to or from a particular data owner.
	
	<H2>Byte Structure</H2>
	
	All child classes have their data following on from the parent classes so that the parent 
	classes may remain atomic with respect to the structure of their data. The binary structure 
	of this data type inside the descriptor buffer is as follows. Note that the endianness of 
	the data types specified below is determined by the platform and the PC must pack accordingly:

	<table border="1">
		<tr>
			<td>TSBDerivedType [4-bytes]</td>
			<td>TDriveNumber [4-bytes]</td>
		</tr>
	</table>
	
	@deprecated
	@publishedPartner
	*/	
	class CSBGenericTransferType : public CSBGenericDataType
		{
	public:
		IMPORT_C static CSBGenericTransferType* NewL(const TDesC8& aDes);
		IMPORT_C ~CSBGenericTransferType();
		IMPORT_C TDriveNumber DriveNumberL() const;
		
	protected:
		CSBGenericTransferType();
		virtual void InitialiseL(TInt& aOffset);
	
	protected:
		/** the drive number */
		TInt iDriveNumberOffset;		
		};

	/** SID Transfer type is used to identify data associated with a particular SID
	
	<H2>Byte Structure</H2>
	
	All child classes have their data following on from the parent classes so that the parent 
	classes may remain atomic with respect to the structure of their data. The binary structure 
	of this data type inside the descriptor buffer is as follows. Note that the endianness of 
	the data types specified below is determined by the platform and the PC must pack accordingly:

	<table border="1">
		<tr>
			<td>TSBDerivedType [4-bytes]</td>
			<td>TDriveNumber [4-bytes]</td>
			<td>TSecureId [4-bytes]</td>
			<td>TTransferDataType [4-bytes]</td>
		</tr>
	</table>

	@deprecated
	@publishedPartner
	*/
	class CSBSIDTransferType : public CSBGenericTransferType
		{
	public:
		IMPORT_C static CSBSIDTransferType* NewL(TSecureId aSecureId, TDriveNumber aDriveNumber, TTransferDataType aTransferDataType);
		IMPORT_C static CSBSIDTransferType* NewL(CSBGenericTransferType* aGenericTransferType);
		IMPORT_C ~CSBSIDTransferType();
		IMPORT_C TSecureId SecureIdL() const;
		IMPORT_C TTransferDataType DataTypeL() const;
		
	protected:
		void InitialiseL(TInt& aOffset);

	private:
		CSBSIDTransferType();
		void ConstructL(TSecureId aSecureId, TDriveNumber aDriveNumber, TTransferDataType aTransferDataType);
		void ConstructL(CSBGenericTransferType* aGenericTransferType);
		
	private:
		/** the secure identifier */
		TInt iSecureIdOffset;
		/** the transfer data type */
		TInt iTransferDataTypeOffset;
		};

	/** Package Transfer Type is used to identify data related to a particular Package ID
	
	<H2>Byte Structure</H2>
	
	All child classes have their data following on from the parent classes so that the parent 
	classes may remain atomic with respect to the structure of their data. The binary structure 
	of this data type inside the descriptor buffer is as follows. Note that the endianness of 
	the data types specified below is determined by the platform and the PC must pack accordingly:

	<table border="1">
		<tr>
			<td>TSBDerivedType [4-bytes]</td>
			<td>TDriveNumber [4-bytes]</td>
			<td>TUid [4-bytes]</td>
			<td>TPackageDataType [4-bytes]</td>
		</tr>
	</table>

	@deprecated
	@publishedPartner
	*/
	class CSBPackageTransferType : public CSBGenericTransferType
		{
	public:
		IMPORT_C static CSBPackageTransferType* NewL(TUid aPackageId, TDriveNumber aDriveNUmber, TPackageDataType aPackageDataType);
		IMPORT_C static CSBPackageTransferType* NewL(CSBGenericTransferType* aGenericTransferType);
		IMPORT_C ~CSBPackageTransferType();
		IMPORT_C TUid PackageIdL() const;
		IMPORT_C TPackageDataType DataTypeL() const;
		
	protected:
		void InitialiseL(TInt& aOffset);

	private:
		CSBPackageTransferType();
		void ConstructL(TUid aPackageId, TDriveNumber aDriveNumber, TPackageDataType aPackageDataType);
		void ConstructL(CSBGenericTransferType* aGenericTransferType);
		
	private:
		/** the package identifier */
		TInt iPackageIdOffset;
		/** the package data type */
		TInt iPackageDataTypeOffset;
		};
		
	class CDataOwnerInfo : public CBase
		/** 
		CDataOwnerInfo packages up information for the backup / restore client on an
		individual data owner.

		Access to the data members is direct.

		@deprecated
		@publishedPartner
		*/
		{
	public:								  
		IMPORT_C static CDataOwnerInfo* NewL( CSBGenericDataType* aGenericDataType,
											  TCommonBURSettings aCommonSettings,
											  TPassiveBURSettings aPassiveSettings,
											  TActiveBURSettings aActiveSettings,
											  const TDriveList& aDriveList );
											  
		IMPORT_C static CDataOwnerInfo* NewL ( const TDesC8& aFlatDataOwnerInfo );
		IMPORT_C ~CDataOwnerInfo();
		IMPORT_C CSBGenericDataType& Identifier();
		IMPORT_C const CSBGenericDataType& Identifier() const;
		IMPORT_C TCommonBURSettings CommonSettings() const;
		IMPORT_C TPassiveBURSettings PassiveSettings() const;
		IMPORT_C TActiveBURSettings ActiveSettings() const;
		IMPORT_C TDriveList& DriveList();
		IMPORT_C const TDriveList& DriveList() const;
		IMPORT_C HBufC8* ExternaliseL();
		IMPORT_C TInt Size() const;
		IMPORT_C HBufC8* ExternaliseLC();

	private:
		CDataOwnerInfo();
		void ConstructL(CSBGenericDataType* aGenericDataType, TCommonBURSettings aCommonSettings,
						TPassiveBURSettings aPassiveSettings, TActiveBURSettings aActiveSettings,
						const TDriveList& aDriveList);
		void ConstructL(const TDesC8& aFlatDataOwnerInfo);

	private:
		CSBGenericDataType* iGenericDataType; /*!< generic data type object */
		TCommonBURSettings iCommonBURSettings; /*!< flags for storing common backup and restore settings */
		TPassiveBURSettings iPassiveBURSettings; /*!< flags for storing passive backup and restore settings */
		TActiveBURSettings iActiveBURSettings; /*!< flags for storing active backup and restore settings */
		TDriveList iDriveList; /*!< List of drives that the data owner has data on */
		};

	/** Generic Data Type representing a MIDlet data owner identified by a Suite Name, Vendor Name, 
	Version and a unique MIDlet Suite Hash. The Suite Hash should be used as the unique identifier for 
	the MIDlet suite.

	<H2>Byte Structure</H2>
	
	All child classes have their data following on from the parent classes so that the parent 
	classes may remain atomic with respect to the structure of their data. The binary structure 
	of this data type inside the descriptor buffer is as follows. Note that the endianness of 
	the data types specified below is determined by the platform and the PC must pack accordingly:

	<table border="1">
		<tr>
			<td>TSBDerivedType [4-bytes]</td>
			<td>MIDlet suite name length [4-bytes]</td>
			<td>MIDlet suite name [2*length]</td>
			<td>MIDlet suite vendor length [4-bytes]</td>
			<td>MIDlet suite vendor [2*length]</td>
			<td>MIDlet suite version length [4-bytes]</td>
			<td>MIDlet suite version [2*length]</td>
			<td>MIDlet suite hash length [4-bytes] (should be 32)</td>
			<td>MIDlet suite hash [2*length]</td>
		</tr>
	</table>

	@deprecated
	@publishedPartner
	*/
	class CSBJavaId : public CSBGenericDataType
		{
	public:
		IMPORT_C static CSBJavaId* NewL(const TDesC& aSuiteName, const TDesC& aSuiteVendor,const TDesC& aSuiteVersion, const TDesC& aSuiteHash);
		IMPORT_C static CSBJavaId* NewL(CSBGenericDataType* aGenericDataType);
		IMPORT_C ~CSBJavaId();
		IMPORT_C const TDesC& SuiteNameL() const;
		IMPORT_C const TDesC& SuiteVendorL() const;
		IMPORT_C const TDesC& SuiteVersionL() const;
		IMPORT_C const TDesC& SuiteHashL() const;
		
	protected:
		void InitialiseL(TInt& aOffset);
		void InitialiseL(TInt& aOffset, const TDesC& aSuiteName, const TDesC& aSuiteVendor,const TDesC& aSuiteVersion, const TDesC& aSuiteHash);

	private:
		CSBJavaId();
		CSBJavaId(const TDesC& aSuiteName, const TDesC& aSuiteVendor,const TDesC& aSuiteVersion, const TDesC& aSuiteHash);
		void ConstructL(const TDesC& aSuiteName, const TDesC& aSuiteVendor,const TDesC& aSuiteVersion, const TDesC& aSuiteHash);
		void ConstructFromExistingL(CSBGenericDataType* aGenericDataType);
		
	private:
		/** The MIDlet suite Name */
		TPtrC iSuiteName;
		
		/** The MIDlet suite Vendor */
		TPtrC iSuiteVendor;
		
		/** The MIDlet suite Version */
		TPtrC iSuiteVersion;

		/** The MIDlet suite Hash */
		TPtrC iSuiteHash;
		};

	/** The Java Transfer Type identifies types of data belonging to particular MIDlet suites (identified 
	by the Suite Hash)
	
	<H2>Byte Structure</H2>
	
	All child classes have their data following on from the parent classes so that the parent 
	classes may remain atomic with respect to the structure of their data. The binary structure 
	of this data type inside the descriptor buffer is as follows. Note that the endianness of 
	the data types specified below is determined by the platform and the PC must pack accordingly:

	<table border="1">
		<tr>
			<td>TSBDerivedType [4-bytes]</td>
			<td>TDriveNumber [4-bytes]</td>
			<td>TJavaTransferType [4-bytes]</td>
			<td>MIDlet suite hash length [4-bytes] (should be 32)</td>
			<td>MIDlet suite hash [2*length]</td>
		</tr>
	</table>

	@deprecated
	@publishedPartner
	*/
	class CSBJavaTransferType : public CSBGenericTransferType
		{
	public:
		IMPORT_C static CSBJavaTransferType* NewL(const TDesC& aSuiteHash, TDriveNumber aDriveNumber, TJavaTransferType aTransferDataType);
		IMPORT_C static CSBJavaTransferType* NewL(CSBGenericTransferType* aGenericTransferType);
		IMPORT_C ~CSBJavaTransferType();
		IMPORT_C const TDesC& SuiteHashL() const;
		IMPORT_C TJavaTransferType DataTypeL() const;
		
	protected:
		void InitialiseL(TInt& aOffset);
		void InitialiseL(TInt& aOffset, const TDesC& aSuiteHash, TDriveNumber aDriveNumber,
			TJavaTransferType aTransferDataType);

	private:
		CSBJavaTransferType();
		CSBJavaTransferType(const TDesC& aSuiteHash);
		void ConstructL(const TDesC& aSuiteHash, TDriveNumber aDriveNumber, TJavaTransferType aTransferDataType);
		void ConstructL(CSBGenericTransferType* aGenericTransferType);
		
	private:
		/** The MIDlet suite Hash */
		TPtrC iSuiteHash;

		/** the transfer data type */
		TInt iTransferDataTypeOffset;
		};
 
	class CSBEFileEntry : public CBase
	/** This class is a more memory efficient heap based externalisable version of 
	TEntry containing just the information required for public backup. 
	TEntry contains a TFileName which is a modifiable descriptor of 512 bytes
	and therefore takes up needless memory. CSBEFileEntry on the other hand occupies
	only as much RAM as is required to represent the name and path of the file that
	it represents.
	@deprecated
	@publishedPartner
	*/
		{
	public:
		IMPORT_C static CSBEFileEntry* NewLC(const TEntry& aEntry, RApaLsSession& aSession);
		IMPORT_C static CSBEFileEntry* NewLC(const TDesC8& aStream, TInt& aBytesRead);
		IMPORT_C ~CSBEFileEntry();
		IMPORT_C HBufC8* ExternaliseLC() const;
		IMPORT_C TUint FileAttributes() const;
		IMPORT_C TInt FileSize() const;
		IMPORT_C TTime LastModified() const;
		IMPORT_C TDesC16& Filename() const;
		IMPORT_C TDesC16& MIMEType() const;
		IMPORT_C TUidType& MIMEUid();
	private:
		void ConstructL(const TEntry& aEntry, RApaLsSession& aSession);
		void InternaliseL(const TDesC8& aStream, TInt& aBytesRead);
		CSBEFileEntry();
		CSBEFileEntry(const TEntry& aEntry);
		TUint16 CalculatePackedSize() const;
	private:
	    /**
	    The individual bits within this byte indicate which attributes
	    have been set.
	    
	    @see KEntryAttNormal
		@see KEntryAttReadOnly
		@see KEntryAttHidden
	    @see KEntryAttSystem
	    */
		TUint iAtt;
		
		/**
		The size of the file in bytes.
		*/
		TInt iSize;
		
		/**
		The system time of last modification, in universal time.
		*/
		TTime iModified;

		/**
		The textual version of the file's UIDtype
		*/
		HBufC* iType;
		
		/**
		Array of UID Types corresponding to this file
		*/
		TUidType iUidType;
		
		/**
		Path and name of the file
		*/
		HBufC* iFilename;
		};
	} // end namespace
#endif