QCA::BigInteger Class Reference

Arbitrary precision integer. More...

#include <QtCrypto>

Collaboration diagram for QCA::BigInteger:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 BigInteger ()
 BigInteger (int n)
 BigInteger (const char *c)
 BigInteger (const QString &s)
 BigInteger (const QCA::SecureArray &a)
 BigInteger (const BigInteger &from)
BigIntegeroperator= (const BigInteger &from)
BigIntegeroperator= (const QString &s)
BigIntegeroperator+= (const BigInteger &b)
BigIntegeroperator-= (const BigInteger &b)
QCA::SecureArray toArray () const
void fromArray (const QCA::SecureArray &a)
QString toString () const
bool fromString (const QString &s)
int compare (const BigInteger &n) const
bool operator== (const BigInteger &other) const
bool operator!= (const BigInteger &other) const
bool operator<= (const BigInteger &other) const
bool operator>= (const BigInteger &other) const
bool operator< (const BigInteger &other) const
bool operator> (const BigInteger &other) const

Related Functions

(Note that these are not member functions.)

QCA_EXPORT QTextStreamoperator<< (QTextStream &stream, const BigInteger &b)

Detailed Description

Arbitrary precision integer.

BigInteger provides arbitrary precision integers.

if ( BigInteger("3499543804349") == 
        BigInteger("38493290803248") + BigInteger( 343 ) )
{
        // do something
}


Constructor & Destructor Documentation

QCA::BigInteger::BigInteger  ) 
 

Constructor.

Creates a new BigInteger, initialised to zero.

QCA::BigInteger::BigInteger int  n  ) 
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:
n an alternative integer initialisation value.

QCA::BigInteger::BigInteger const char *  c  ) 
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:
c an alternative initialisation value, encoded as a character array
BigInteger b ( "9890343" );

QCA::BigInteger::BigInteger const QString s  ) 
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:
s an alternative initialisation value, encoded as a string

QCA::BigInteger::BigInteger const QCA::SecureArray a  ) 
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:
a an alternative initialisation value, encoded as SecureArray

QCA::BigInteger::BigInteger const BigInteger from  ) 
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:
from an alternative initialisation value, encoded as a BigInteger


Member Function Documentation

BigInteger& QCA::BigInteger::operator= const BigInteger from  ) 
 

Assignment operator.

Parameters:
from the BigInteger to copy from
BigInteger a; // a is zero
BigInteger b( 500 );
a = b; // a is now 500

BigInteger& QCA::BigInteger::operator= const QString s  ) 
 

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:
s the QString containing an integer representation
See also:
bool fromString(const QString &s)
Note:
it is the application's responsibility to make sure that the QString represents a valid integer (ie it only contains numbers and an optional minus sign at the start)

BigInteger& QCA::BigInteger::operator+= const BigInteger b  ) 
 

Increment in place operator.

Parameters:
b the amount to increment by
BigInteger a; // a is zero
BigInteger b( 500 );
a += b; // a is now 500
a += b; // a is now 1000

BigInteger& QCA::BigInteger::operator-= const BigInteger b  ) 
 

Decrement in place operator.

Parameters:
b the amount to decrement by
BigInteger a; // a is zero
BigInteger b( 500 );
a -= b; // a is now -500
a -= b; // a is now -1000

QCA::SecureArray QCA::BigInteger::toArray  )  const
 

Output BigInteger as a byte array, useful for storage or transmission.

The format is a binary integer in sign-extended network-byte-order.

See also:
void fromArray(const SecureArray &a);

void QCA::BigInteger::fromArray const QCA::SecureArray a  ) 
 

Assign from an array.

The input is expected to be a binary integer in sign-extended network-byte-order.

Parameters:
a a SecureArray that represents an integer
See also:
BigInteger(const SecureArray &a);

SecureArray toArray() const;

QString QCA::BigInteger::toString  )  const
 

Convert BigInteger to a QString.

QString aString;
BigInteger aBiggishInteger( 5878990 );
aString = aBiggishInteger.toString(); // aString is now "5878990"

bool QCA::BigInteger::fromString const QString s  ) 
 

Assign from a QString.

Parameters:
s a QString that represents an integer
Note:
it is the application's responsibility to make sure that the QString represents a valid integer (ie it only contains numbers and an optional minus sign at the start)
See also:
BigInteger(const QString &s)

BigInteger & operator=(const QString &s)

int QCA::BigInteger::compare const BigInteger n  )  const
 

Compare this value with another BigInteger.

Normally it is more readable to use one of the operator overloads, so you don't need to use this method directly.

Parameters:
n the BigInteger to compare with
Returns:
zero if the values are the same, negative if the argument is less than the value of this BigInteger, and positive if the argument value is greater than this BigInteger
BigInteger a( "400" );
BigInteger b( "-400" );
BigInteger c( " 200 " );
int result;
result = a.compare( b );        // return positive 400 > -400
result = a.compare( c );        // return positive,  400 > 200
result = b.compare( c );        // return negative, -400 < 200

bool QCA::BigInteger::operator== const BigInteger other  )  const [inline]
 

Equality operator.

Returns true if the two BigInteger values are the same, including having the same sign.

bool QCA::BigInteger::operator!= const BigInteger other  )  const [inline]
 

Inequality operator.

Returns true if the two BigInteger values are different in magnitude, sign or both.

bool QCA::BigInteger::operator<= const BigInteger other  )  const [inline]
 

Less than or equal operator.

Returns true if the BigInteger value on the left hand side is equal to or less than the BigInteger value on the right hand side.

bool QCA::BigInteger::operator>= const BigInteger other  )  const [inline]
 

Greater than or equal operator.

Returns true if the BigInteger value on the left hand side is equal to or greater than the BigInteger value on the right hand side.

bool QCA::BigInteger::operator< const BigInteger other  )  const [inline]
 

Less than operator.

Returns true if the BigInteger value on the left hand side is less than the BigInteger value on the right hand side.

bool QCA::BigInteger::operator> const BigInteger other  )  const [inline]
 

Greater than operator.

Returns true if the BigInteger value on the left hand side is greater than the BigInteger value on the right hand side.


Friends And Related Function Documentation

QCA_EXPORT QTextStream & operator<< QTextStream stream,
const BigInteger b
[related]
 

Stream operator.


The documentation for this class was generated from the following file:
Generated on Fri Jul 6 12:15:51 2007 for Qt Cryptographic Architecture by  doxygen 1.4.6