pdfium / pdfium / 81683d4924b14869564198f832a20f46926cbad1 / . / third_party / bigint / BigUnsignedInABase.hh

// 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 | |

BigUnsignedInABase& operator =(const BigUnsignedInABase &x) { | |

NumberlikeArray<Digit>::operator =(x); | |

base = x.base; | |

return *this; | |

} | |

// 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 |