Initial check in of big integer library, v2010.04.30
[pdfium.git] / third_party / bigint / BigUnsignedInABase.hh
1 #ifndef BIGUNSIGNEDINABASE_H
2 #define BIGUNSIGNEDINABASE_H
3
4 #include "NumberlikeArray.hh"
5 #include "BigUnsigned.hh"
6 #include <string>
7
8 /*
9  * A BigUnsignedInABase object represents a nonnegative integer of size limited
10  * only by available memory, represented in a user-specified base that can fit
11  * in an `unsigned short' (most can, and this saves memory).
12  *
13  * BigUnsignedInABase is intended as an intermediary class with little
14  * functionality of its own.  BigUnsignedInABase objects can be constructed
15  * from, and converted to, BigUnsigneds (requiring multiplication, mods, etc.)
16  * and `std::string's (by switching digit values for appropriate characters).
17  *
18  * BigUnsignedInABase is similar to BigUnsigned.  Note the following:
19  *
20  * (1) They represent the number in exactly the same way, except that
21  * BigUnsignedInABase uses ``digits'' (or Digit) where BigUnsigned uses
22  * ``blocks'' (or Blk).
23  *
24  * (2) Both use the management features of NumberlikeArray.  (In fact, my desire
25  * to add a BigUnsignedInABase class without duplicating a lot of code led me to
26  * introduce NumberlikeArray.)
27  *
28  * (3) The only arithmetic operation supported by BigUnsignedInABase is an
29  * equality test.  Use BigUnsigned for arithmetic.
30  */
31
32 class BigUnsignedInABase : protected NumberlikeArray<unsigned short> {
33
34 public:
35         // The digits of a BigUnsignedInABase are unsigned shorts.
36         typedef unsigned short Digit;
37         // That's also the type of a base.
38         typedef Digit Base;
39
40 protected:
41         // The base in which this BigUnsignedInABase is expressed
42         Base base;
43
44         // Creates a BigUnsignedInABase with a capacity; for internal use.
45         BigUnsignedInABase(int, Index c) : NumberlikeArray<Digit>(0, c) {}
46
47         // Decreases len to eliminate any leading zero digits.
48         void zapLeadingZeros() { 
49                 while (len > 0 && blk[len - 1] == 0)
50                         len--;
51         }
52
53 public:
54         // Constructs zero in base 2.
55         BigUnsignedInABase() : NumberlikeArray<Digit>(), base(2) {}
56
57         // Copy constructor
58         BigUnsignedInABase(const BigUnsignedInABase &x) : NumberlikeArray<Digit>(x), base(x.base) {}
59
60         // Assignment operator
61         void operator =(const BigUnsignedInABase &x) {
62                 NumberlikeArray<Digit>::operator =(x);
63                 base = x.base;
64         }
65
66         // Constructor that copies from a given array of digits.
67         BigUnsignedInABase(const Digit *d, Index l, Base base);
68
69         // Destructor.  NumberlikeArray does the delete for us.
70         ~BigUnsignedInABase() {}
71
72         // LINKS TO BIGUNSIGNED
73         BigUnsignedInABase(const BigUnsigned &x, Base base);
74         operator BigUnsigned() const;
75
76         /* LINKS TO STRINGS
77          *
78          * These use the symbols ``0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'' to
79          * represent digits of 0 through 35.  When parsing strings, lowercase is
80          * also accepted.
81          *
82          * All string representations are big-endian (big-place-value digits
83          * first).  (Computer scientists have adopted zero-based counting; why
84          * can't they tolerate little-endian numbers?)
85          *
86          * No string representation has a ``base indicator'' like ``0x''.
87          *
88          * An exception is made for zero: it is converted to ``0'' and not the
89          * empty string.
90          *
91          * If you want different conventions, write your own routines to go
92          * between BigUnsignedInABase and strings.  It's not hard.
93          */
94         operator std::string() const;
95         BigUnsignedInABase(const std::string &s, Base base);
96
97 public:
98
99         // ACCESSORS
100         Base getBase() const { return base; }
101
102         // Expose these from NumberlikeArray directly.
103         NumberlikeArray<Digit>::getCapacity;
104         NumberlikeArray<Digit>::getLength;
105
106         /* Returns the requested digit, or 0 if it is beyond the length (as if
107          * the number had 0s infinitely to the left). */
108         Digit getDigit(Index i) const { return i >= len ? 0 : blk[i]; }
109
110         // The number is zero if and only if the canonical length is zero.
111         bool isZero() const { return NumberlikeArray<Digit>::isEmpty(); }
112
113         /* Equality test.  For the purposes of this test, two BigUnsignedInABase
114          * values must have the same base to be equal. */ 
115         bool operator ==(const BigUnsignedInABase &x) const {
116                 return base == x.base && NumberlikeArray<Digit>::operator ==(x);
117         }
118         bool operator !=(const BigUnsignedInABase &x) const { return !operator ==(x); }
119
120 };
121
122 #endif