/*

 * Copyright (c) 2003-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: 

 *

 */

 #include <bigint.h>

 #include <e32std.h>

 #include <random.h>

 #include "../common/inlines.h"

 /** 

  * Copy constructor

  *

  * This function performs a shallow copy, 

  * i.e. the memory holding the integer is not copied.

  */

 EXPORT_C RInteger::RInteger(const RInteger& aInteger)

 	{

 	*this = aInteger;

 	}

 /** 

  * Assignment operator

  * 

  * This function performs a shallow copy, 

  * i.e. the memory holding the integer is not copied.

  */

 EXPORT_C RInteger& RInteger::operator=(const RInteger& aInteger)

 	{

 	iSize = aInteger.iSize;

 	iPtr = aInteger.iPtr;

 	return *this;

 	}

 /** 

  * Creates a new integer representing 0.

  * 

  * @return	An RInteger by value.

  */

 EXPORT_C RInteger RInteger::NewL(void)

 	{

 	return NewL(TInteger::Zero());

 	}

 /** 

  * Creates a new integer object representing a specified value.

  * 

  * @param aValue	A descriptor containing the big-endian binary

  * 					representation of the value.

  * @return			An RInteger object representing the value.

  */

 EXPORT_C RInteger RInteger::NewL(const TDesC8& aValue)

 	{

 	RInteger self;

 	//Construct zero's memory beyond the size of aValue after construction

 	self.CreateNewL(BytesToWords(aValue.Size()));

 	self.Construct(aValue);

 	return self;

 	}

 /** 

  * Creates an exact copy of an \c aInteger object.

  * 

  * @param aInteger	The integer you wish to copy

  * @return			An RInteger object representing an exact copy of 

  *					aInteger by value.

  */

 EXPORT_C RInteger RInteger::NewL(const TInteger& aInteger)

 	{

 	RInteger self;

 	//don't need to CleanNewL as we'll copy straight from aInteger

 	self.CreateNewL(aInteger.Size());

 	self.Construct(aInteger);

 	return self;

 	}

 /** 

  * Creates a random integer uniformly distributed over [0, 2^aBits].

  * 

  * @param aBits	The number of bits you wish to randomly select.

  * @param aAttr	Enum specifying whether specific bits in the random number should

  *				be set.  See TRandomAttribute for more information.

  * @return		A random RInteger object in the range specified.

  */

 EXPORT_C RInteger RInteger::NewRandomL(TUint aBits, TRandomAttribute aAttr)

 	{

 	RInteger self;

 	self.CleanNewL(BitsToWords(aBits));

 	CleanupStack::PushL(self);

 	self.RandomizeL(aBits, aAttr);

 	CleanupStack::Pop(&self); 

 	return self;

 	}

 /** 

  * Creates a random integer uniformly distributed over [x | min <= x <= max].

  * 

  * @param aMin	The smallest possible value for the random integer (inclusive).

  * @param aMax	The largest possible value for the random integer (inclusive).

  * @return		A random RInteger object in the range specified.

  */

 EXPORT_C RInteger RInteger::NewRandomL(const TInteger& aMin,

 	const TInteger& aMax)

 	{

 	RInteger self;

 	self.CleanNewL(aMax.Size());

 	CleanupStack::PushL(self);

 	self.RandomizeL(aMin, aMax);

 	CleanupStack::Pop(&self);

 	return self;

 	}

 /** 

  * Finds a random prime integer in the range of [2, 2^aBits].

  *

  * This is done by picking a random integer and using that as a starting point

  * for a sequential search for a prime.  To verify the primality of number, 

  * this algorithm uses a probablistic primality test.  This means that it is

  * possible, although extremely improbable, that the number returned is a pseudoprime.

  *

  * @param aBits	The number of bits you wish to randomly select your prime from.

  * @param aAttr	Enum specifying whether specific bits in the random number should

  *				be set.  See TRandomAttribute for more information.

  * @return		A random RInteger representing a probable prime (with very high

  *				probablity) in the range specified.

  */

 EXPORT_C RInteger RInteger::NewPrimeL(TUint aBits, TRandomAttribute aAttr)

 	{

 	RInteger self;

 	self.CleanNewL(BitsToWords(aBits));

 	CleanupStack::PushL(self);

 	self.PrimeRandomizeL(aBits, aAttr);

 	CleanupStack::Pop(&self);

 	return self;

 	}

 /** 

  * Creates a new integer from the value represented by \c aInteger.

  * 

  * @param aInteger	A signed word sized integer.

  * @return			An RInteger representation of aInteger by value.

  */

 EXPORT_C RInteger RInteger::NewL(TInt aInteger)

 	{

 	RInteger self;

 	self.CreateNewL(2);

 	self.Construct(aInteger);

 	return self;

 	}

 /** 

  * Creates a new integer with a preallocated internal storage of \c aNumWords all

  * initialised to zero.

  *

  * The resulting RInteger object is logically equivalent to RInteger::NewL(0).

  * The only difference is that the internal storage requirements have been 

  * specified to be larger than the default. This is useful if you are about 

  * to perform an operation on this integer, that you know the resulting size

  * requirements of, and wish to avoid a heap resize.

  *

  * @param aNumWords	The number of words for to preallocated and zero fill.

  * @return			An RInteger object representing 0 with a preallocated 

  *					zero-filled internal storage of aNumWords.

  */

 EXPORT_C RInteger RInteger::NewEmptyL(TUint aNumWords)

 	{

 	RInteger self;

 	self.CleanNewL(aNumWords);

 	//There's no construct as there isn't anything to do

 	return self;

 	}

 /**

  * Creates an RInteger object with no associated internal (heap) storage.

  * 

  * All data members are initialised to zero.  It is safe (although not strictly necessary)

  * to push such an RInteger object onto the CleanupStack.  This is useful, for example, if

  * you want to pass an RInteger object by reference into a function and have it create

  * the representation of the actual integer for you.  

  *

  * Note that performing any operation on such an RInteger object other than the default

  * assignment operator or copy constructor will panic your code.

  * 

  * @return	A stack based class that has no associated internal storage and thus

  *			does not represent any number.

  */

 EXPORT_C RInteger::RInteger(void)  

 	{

 	}

 /** 

  * An overloaded TCleanupItem() allowing the RIntegers to be pushed,

  * popped, and destroyed via the CleanupStack like any other CBase derived object.

  */

 EXPORT_C RInteger::operator TCleanupItem(void)

 	{

 	return TCleanupItem(&RInteger::CallClose, this);

 	}

 /** 

  * Helper function registered with the cleanup stack that just calls Close() for

  * this RInteger object.

  * 

  * @param aPtr	A pointer to the object for which clean-up is to be performed. 

  */

 EXPORT_C void RInteger::CallClose(TAny* aPtr)

 	{

 	((RInteger*)aPtr)->Close();	

 	}

 /** 

  * Zeros and then frees any memory owned by this RInteger object.

  *  

  * An RInteger object that has been closed can safely fall off the stack.

  */

 EXPORT_C void RInteger::Close(void)

 	{

 	if (iPtr)

 		{

 		Mem::FillZ(Ptr(), Size()*4);

 		User::Free(Ptr());

 		iSize = 0;

 		iPtr = NULL;

 		}

 	}

 // Method is excluded from coverage due to the problem with BullsEye on ONB.

 // Manually verified that this method is functionally covered.

 #ifdef _BullseyeCoverage

 #pragma suppress_warnings on

 #pragma BullseyeCoverage off

 #pragma suppress_warnings off

 #endif

 /** 

  * Creates a new integer from the value represented by \c aInteger.

  *

  * @param aInteger	An unsigned word sized integer.

  * @return			An RInteger representation of aInteger by value.

  */

 EXPORT_C RInteger RInteger::NewL(TUint aInteger)

 	{

 	RInteger self;

 	self.CreateNewL(2);

 	self.Construct(aInteger);

 	return self;

 	}