/*

 * Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "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: 

 * crypto parameters interface

 *

 */

 /**

  @file

  @publishedAll

  @released 

 */

 #ifndef __CRYPTOPARAMS_H__

 #define __CRYPTOPARAMS_H__

 #include <bigint.h>

 namespace CryptoSpi

 	{

 	/**

 	Abstract base class for generic crypto parameters to enable plug-in 

 	specific parameters and the externalisation of plug-ins. The type

 	of the sub-class is identified by the GetType method.

 	All sub-class contain copies of (instead of references to) the 

 	supplied values.

 	*/

 	NONSHARABLE_CLASS(CCryptoParam) : public CBase

 		{

 	public:

 		/**

 		The definition of the data type of the embedded value. 

 		Other data types may be added in future so applications 

 		should not panic if the type is not recognised.

 		*/

 		enum TParamType

 			{

 			/** 

 			RCryptoIntParam 

 			*/

 			EInt = 1,

 			/** 

 			RCryptoBigIntParam 

 			*/

 			EBigInt = 2,

 			/** 

 			RCryptoDesC8Param 

 			*/

 			EDesC8 = 3,

 			/** 

 			RCryptoDesC16Param 

 			*/

 			EDesC16 = 4,

 			};

 		/**

 		Returns the data type of the crypto parameter

 		@return The data type of the crypto parameter

 		*/

 		IMPORT_C TInt Type() const;

 		/**

 		Returns the Uid of the crypto parameter

 		@return The Uid of the crypto parameter

 		*/

 		IMPORT_C TUid Uid() const;

 		/** 

 		Destructor 

 		*/

 		IMPORT_C ~CCryptoParam();

 	protected:

 		/**

 		 * @internalComponent

 		 * 

 		 * Constructor 

 		 * @param aType	The data type identifier for the sub-class.

 		 * @param aUid	The Uid of the cryptoparam

 		 */

 		CCryptoParam(TParamType aType, TUid aUid);

 	protected:

 		/**

 		The data type of the embedded value

 		*/

 		TParamType iType;

 		/**

 		The Uid of the crypto parameter

 		*/

 		TUid iUid;

 		};

 	/**

 	CryptoParam class that wraps a TInt

 	*/

 	NONSHARABLE_CLASS(CCryptoIntParam) : public CCryptoParam

 		{

 	public: 

 		/**

 		Factory method for allocating a new CCryptoIntParam object

 		that contains a copy of the supplied TInt

 		@param aValue The TInt to be wrapped (copied)

 		@param aUid The UID of the CryptoParam

 		@return A pointer to a CCryptoIntParam instance

 		*/

 		IMPORT_C static CCryptoIntParam* NewL(TInt aValue, TUid aUid);

 		/**

 		Factory method for allocating a new CCryptoIntParam object

 		that contains a copy of the supplied TInt

 		Leaves the pointer of the CryptoParam on the cleanup stack

 		@param aValue The TInt to be wrapped (copied)

 		@param aUid The UID of the CryptoParam

 		@return A pointer to a CCryptoIntParam instance

 		*/

 		IMPORT_C static CCryptoIntParam* NewLC(TInt aValue, TUid aUid);

 		/**

 		Returns the embedded value.

 		@return The embedded integer

 		*/

 		IMPORT_C TInt Value() const;

 		/**

 		Destructor

 		*/

 		IMPORT_C ~CCryptoIntParam();

 	private:

 		/**

 		Constructor

 		@param aValue The integer to wrap

 		@param aUid	The UID of the crypto parameter

 		*/		

 		CCryptoIntParam(TInt aValue, TUid aUid);

 	private:

 		/** 

 		The embedded value 

 		*/

 		TInt iValue;

 		};

 	/**

 	Crypto param class the wraps an RInteger

 	 */

 	NONSHARABLE_CLASS(CCryptoBigIntParam) : public CCryptoParam

 		{

 	public: 

 		/**

 		Factory method for allocating a new CCryptoBigIntParam object

 		that contains a copy of the supplied TInteger object.

 		@param aValue	The TInteger to be wrapped (copied)

 		@param aUid	The UID of the CryptoParam

 		@return A pointer to a CCryptoBigIntParam instance

 		*/

 		IMPORT_C static CCryptoBigIntParam* NewL(const TInteger& aValue, TUid aUid);

 		/**

 		Factory method for allocating a new CCryptoBigIntParam object

 		that contains a copy of the supplied TInteger object.

 		Leaves the pointer of the CryptoParam onto the cleanup stack.

 		@param aValue	The TInteger to be wrapped (copied)

 		@param aUid	The UID of the CryptoParam

 		@return A pointer to a CCryptoBigIntParam instance

 		*/		

 		IMPORT_C static CCryptoBigIntParam* NewLC(const TInteger& aValue, TUid aUid);

 		/**

 		Returns the embedded value.

 		@return A reference to the embedded TInteger

 		*/

 		IMPORT_C const TInteger& Value() const;

 		/** 

 		Destructor 

 		*/

 		IMPORT_C ~CCryptoBigIntParam();

 	private:

 		/**

 		Constructor

 		*/

 		CCryptoBigIntParam();

 		/**

 		Constructor

 		@param aUid	The UID of the crypto parameter

 		*/				

 		CCryptoBigIntParam(TUid aUid);

 		/**

 		Second Phase Constructor

 		@param aValue	The TInteger to wrap

 		*/		

 		void ConstructL(const TInteger& aValue);

 	private:

 		/**

 		The copied RInteger

 		*/

 		RInteger iValue;

 		};

 	/**

 	Crypto param class that wraps an 8-bit constant descriptor

 	*/

 	NONSHARABLE_CLASS(CCryptoDesC8Param) : public CCryptoParam

 		{

 	public:

 		/**

 		Factory method for allocating a new CCryptoDesC8Param object

 		that contains a copy of the supplied RInteger object.

 		@param aValue The TDesC* to be wrapped (copied)

 		@param aUid	The Uid of the CryptoParam

 		@return A pointer to a CCryptoDesC8Param instance

 		*/

 		IMPORT_C static CCryptoDesC8Param* NewL(const TDesC8& aValue, TUid aUid);

 		/**

 		Factory method for allocating a new CCryptoDesC8Param object

 		that contains a copy of the supplied RInteger object.

 		Leaves the pointer of the CryptoParam on the cleanup stack

 		@param aValue The TDesC* to be wrapped (copied)

 		@param aUid	The Uid of the CryptoParam

 		@return A pointer to a CCryptoDesC8Param instance

 		*/

 		IMPORT_C static CCryptoDesC8Param* NewLC(const TDesC8& aValue, TUid aUid);

 		/**

 		Returns the embedded value.

 		@return A reference to the embedded TDesC8

 		*/

 		IMPORT_C const TDesC8& Value() const;

 		/**

 		Destructor

 		*/

 		IMPORT_C ~CCryptoDesC8Param();

 	private:

 		/**

 		Constructor

 		*/

 		CCryptoDesC8Param();

 		/**

 		Constructor

 		@param aUid	The UID of the crypto parameter

 		*/						

 		CCryptoDesC8Param(TUid aUid);

 		/**

 		Second Phase Constructor

 		@param aValue The DesC8 to wrap

 		*/				

 		void ConstructL(const TDesC8& aValue);

 	private:

 		/**

 		The copied descriptor

 		*/		

 		HBufC8* iValue;

 		};

 	/**

 	Crypto param class that wraps an 16-bit constant descriptor

 	*/

 	NONSHARABLE_CLASS(CCryptoDesC16Param) : public CCryptoParam

 		{

 	public:

 		/**

 		Factory method for allocating a new CCryptoDesC8Param object

 		that contains a copy of the supplied RInteger object.

 		@param aValue The TDesC* to be wrapped (copied)

 		@param aUid	The Uid of the CryptoParam

 		@return A pointer to a CCryptoDesC8Param instance

 		*/

 		IMPORT_C static CCryptoDesC16Param* NewL(const TDesC16& aValue, TUid aUid);

 		/**

 		Factory method for allocating a new CCryptoDesC16Param object

 		that contains a copy of the supplied RInteger object.

 		Leaves the pointer of the CryptoParam on the cleanup stack

 		@param aValue The TDesC* to be wrapped (copied)

 		@param aUid	The Uid of the CryptoParam

 		@return A pointer to a CCryptoDesC16Param instance

 		*/

 		IMPORT_C static CCryptoDesC16Param* NewLC(const TDesC16& aValue, TUid aUid);

 		/**

 		Returns the embedded value.

 		@return A reference to the embedded TDesC16

 		*/

 		IMPORT_C const TDesC16& Value() const;

 		/**

 		Destructor

 		*/

 		IMPORT_C ~CCryptoDesC16Param();

 	private:

 		/**

 		Constructor

 		*/

 		CCryptoDesC16Param();

 		/**

 		Constructor

 		@param aUid	The UID of the crypto parameter

 		*/						

 		CCryptoDesC16Param(TUid aUid);

 		/**

 		Second Phase Constructor

 		@param aValue The DesC16 to wrap

 		*/				

 		void ConstructL(const TDesC16& aValue);

 	private:

 		/**

 		The copied descriptor

 		*/		

 		HBufC16* iValue;

 		};

 	NONSHARABLE_CLASS(CCryptoParams) : public CBase

 		{

 	public:

 		IMPORT_C static CCryptoParams* NewL(void);

 		IMPORT_C static CCryptoParams* NewLC(void);

 		/**

 		 * Various adding methods (CCryptoParams takes a copy)

 		 */		

 		IMPORT_C void AddL(const TInteger& aParam, TUid aUid);

 		IMPORT_C void AddL(const TInt aParam, TUid aUid);

 		IMPORT_C void AddL(const TDesC8& aParam, TUid aUid);

 		IMPORT_C void AddL(const TDesC16& aParam, TUid aUid);

 		/**

 		 * Various retrieving methods

 		 */

 		IMPORT_C const TInteger& GetBigIntL(TUid aUid) const;

 		IMPORT_C TInt GetTIntL(TUid aUid) const;

 		IMPORT_C const TDesC8& GetTDesC8L(TUid aUid) const;

 		IMPORT_C const TDesC16& GetTDesC16L(TUid aUid) const;

 		IMPORT_C const RPointerArray<CCryptoParam>& GetParams() const;

 		/// Queries if a parameter with the specified uid is present

 		IMPORT_C TBool IsPresent(TUid aUid) const;

 		/// Return the count of parameters present

 		IMPORT_C TInt Count(void) const;

 		/// Copy the passed CCryptoParams

 		IMPORT_C CCryptoParams& CopyL(const CCryptoParams& aParams);

 		/// Destructor

 		IMPORT_C virtual ~CCryptoParams();

 	protected:

 		/** @internalComponent */

 		CCryptoParams();

 		/** @internalComponent */

 		void ConstructL(void);

 		/** @internalComponent */

 		CCryptoParam* GetCryptoParam(TUid aUid) const;

 		/** @internalComponent */ 

 		CCryptoParam* GetCryptoParamL(TUid aUid) const;

 	private:

 		RPointerArray<CCryptoParam> iParams;

 		};

 	} //End of namespace

 #endif // __CRYPTOPARAMS_H__