// Copyright 2014 PDFium Authors. All rights reserved.
|
// Use of this source code is governed by a BSD-style license that can be
|
// found in the LICENSE file.
|
|
// Original code by Matt McCutchen, see the LICENSE file.
|
|
#ifndef BIGUNSIGNEDINABASE_H
|
#define BIGUNSIGNEDINABASE_H
|
|
#include "NumberlikeArray.hh"
|
#include "BigUnsigned.hh"
|
#include <string>
|
|
/*
|
* A BigUnsignedInABase object represents a nonnegative integer of size limited
|
* only by available memory, represented in a user-specified base that can fit
|
* in an `unsigned short' (most can, and this saves memory).
|
*
|
* BigUnsignedInABase is intended as an intermediary class with little
|
* functionality of its own. BigUnsignedInABase objects can be constructed
|
* from, and converted to, BigUnsigneds (requiring multiplication, mods, etc.)
|
* and `std::string's (by switching digit values for appropriate characters).
|
*
|
* BigUnsignedInABase is similar to BigUnsigned. Note the following:
|
*
|
* (1) They represent the number in exactly the same way, except that
|
* BigUnsignedInABase uses ``digits'' (or Digit) where BigUnsigned uses
|
* ``blocks'' (or Blk).
|
*
|
* (2) Both use the management features of NumberlikeArray. (In fact, my desire
|
* to add a BigUnsignedInABase class without duplicating a lot of code led me to
|
* introduce NumberlikeArray.)
|
*
|
* (3) The only arithmetic operation supported by BigUnsignedInABase is an
|
* equality test. Use BigUnsigned for arithmetic.
|
*/
|
|
class BigUnsignedInABase : protected NumberlikeArray<unsigned short> {
|
|
public:
|
// The digits of a BigUnsignedInABase are unsigned shorts.
|
typedef unsigned short Digit;
|
// That's also the type of a base.
|
typedef Digit Base;
|
|
protected:
|
// The base in which this BigUnsignedInABase is expressed
|
Base base;
|
|
// Creates a BigUnsignedInABase with a capacity; for internal use.
|
BigUnsignedInABase(int, Index c) : NumberlikeArray<Digit>(0, c) {}
|
|
// Decreases len to eliminate any leading zero digits.
|
void zapLeadingZeros() {
|
while (len > 0 && blk[len - 1] == 0)
|
len--;
|
}
|
|
public:
|
// Constructs zero in base 2.
|
BigUnsignedInABase() : NumberlikeArray<Digit>(), base(2) {}
|
|
// Copy constructor
|
BigUnsignedInABase(const BigUnsignedInABase &x) : NumberlikeArray<Digit>(x), base(x.base) {}
|
|
// Assignment operator
|
void operator =(const BigUnsignedInABase &x) {
|
NumberlikeArray<Digit>::operator =(x);
|
base = x.base;
|
}
|
|
// Constructor that copies from a given array of digits.
|
BigUnsignedInABase(const Digit *d, Index l, Base base);
|
|
// Destructor. NumberlikeArray does the delete for us.
|
~BigUnsignedInABase() {}
|
|
// LINKS TO BIGUNSIGNED
|
BigUnsignedInABase(const BigUnsigned &x, Base base);
|
operator BigUnsigned() const;
|
|
/* LINKS TO STRINGS
|
*
|
* These use the symbols ``0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'' to
|
* represent digits of 0 through 35. When parsing strings, lowercase is
|
* also accepted.
|
*
|
* All string representations are big-endian (big-place-value digits
|
* first). (Computer scientists have adopted zero-based counting; why
|
* can't they tolerate little-endian numbers?)
|
*
|
* No string representation has a ``base indicator'' like ``0x''.
|
*
|
* An exception is made for zero: it is converted to ``0'' and not the
|
* empty string.
|
*
|
* If you want different conventions, write your own routines to go
|
* between BigUnsignedInABase and strings. It's not hard.
|
*/
|
operator std::string() const;
|
BigUnsignedInABase(const std::string &s, Base base);
|
|
public:
|
|
// ACCESSORS
|
Base getBase() const { return base; }
|
|
// Expose these from NumberlikeArray directly.
|
using NumberlikeArray<Digit>::getCapacity;
|
using NumberlikeArray<Digit>::getLength;
|
|
/* Returns the requested digit, or 0 if it is beyond the length (as if
|
* the number had 0s infinitely to the left). */
|
Digit getDigit(Index i) const { return i >= len ? 0 : blk[i]; }
|
|
// The number is zero if and only if the canonical length is zero.
|
bool isZero() const { return NumberlikeArray<Digit>::isEmpty(); }
|
|
/* Equality test. For the purposes of this test, two BigUnsignedInABase
|
* values must have the same base to be equal. */
|
bool operator ==(const BigUnsignedInABase &x) const {
|
return base == x.base && NumberlikeArray<Digit>::operator ==(x);
|
}
|
bool operator !=(const BigUnsignedInABase &x) const { return !operator ==(x); }
|
|
};
|
|
#endif
|
