| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef _DECAF_LANG_INTEGER_H_ |
| #define _DECAF_LANG_INTEGER_H_ |
| |
| #include <decaf/util/Config.h> |
| #include <decaf/lang/Number.h> |
| #include <decaf/lang/String.h> |
| #include <decaf/lang/Comparable.h> |
| #include <string> |
| #include <decaf/lang/exceptions/NumberFormatException.h> |
| |
| namespace decaf{ |
| namespace lang{ |
| |
| class DECAF_API Integer : public Number, |
| public Comparable<Integer>, |
| public Comparable<int> { |
| private: |
| |
| // The primitive Integer value. |
| int value; |
| |
| public: |
| |
| /** The size in bits of the primitive int type */ |
| static const int SIZE; |
| |
| /** The maximum value that the primitive type can hold */ |
| static const int MAX_VALUE; |
| |
| /** The minimum value that the primitive type can hold */ |
| static const int MIN_VALUE; |
| |
| public: |
| |
| /** |
| * @param value |
| * The primitive value to wrap in an <code>Integer</code> instance. |
| */ |
| Integer(int value); |
| |
| /** |
| * Constructs a new Integer and attempts to convert the given string to an int |
| * value, assigning it to the new object is successful or throwing a |
| * NumberFormatException if the string is not a properly formatted int. |
| * |
| * @param value |
| * The string to convert to a primitive type to wrap. |
| * |
| * @throws NumberFormatException if the string is not a a valid integer. |
| */ |
| Integer(const std::string& value); |
| |
| virtual ~Integer(); |
| |
| /** |
| * Compares this Integer instance with another. |
| * @param i - the Integer instance to be compared |
| * @return zero if this object represents the same integer value as the |
| * argument; a positive value if this object represents a value greater |
| * than the passed in value, and -1 if this object represents a value |
| * less than the passed in value. |
| */ |
| virtual int compareTo(const Integer& i) const; |
| |
| /** |
| * @param i - the Integer object to compare against. |
| * @return true if the two Integer Objects have the same value. |
| */ |
| bool equals(const Integer& i) const { |
| return this->value == i.value; |
| } |
| |
| /** |
| * Compares equality between this object and the one passed. |
| * @param i - the value to be compared to this one. |
| * @return true if this object is equal to the one passed. |
| */ |
| virtual bool operator==(const Integer& i) const { |
| return this->value == i.value; |
| } |
| |
| /** |
| * Compares this object to another and returns true if this object |
| * is considered to be less than the one passed. This |
| * @param i - the value to be compared to this one. |
| * @return true if this object is equal to the one passed. |
| */ |
| virtual bool operator<(const Integer& i) const { |
| return this->value < i.value; |
| } |
| |
| /** |
| * Compares this Integer instance with another. |
| * @param i - the Integer instance to be compared |
| * @return zero if this object represents the same integer value as the |
| * argument; a positive value if this object represents a value greater |
| * than the passed in value, and -1 if this object represents a value |
| * less than the passed in value. |
| */ |
| virtual int compareTo(const int& i) const; |
| |
| /** |
| * @param i - the Integer object to compare against. |
| * @return true if the two Integer Objects have the same value. |
| */ |
| bool equals(const int& i) const { |
| return this->value == i; |
| } |
| |
| /** |
| * Compares equality between this object and the one passed. |
| * @param i - the value to be compared to this one. |
| * @return true if this object is equal to the one passed. |
| */ |
| virtual bool operator==(const int& i) const { |
| return this->value == i; |
| } |
| |
| /** |
| * Compares this object to another and returns true if this object |
| * is considered to be less than the one passed. This |
| * @param i - the value to be compared to this one. |
| * @return true if this object is equal to the one passed. |
| */ |
| virtual bool operator<(const int& i) const { |
| return this->value < i; |
| } |
| |
| /** |
| * @return this <code>Integer</code> Object as a String Representation |
| */ |
| std::string toString() const; |
| |
| /** |
| * Answers the double value which the receiver represents |
| * @return double the value of the receiver. |
| */ |
| virtual double doubleValue() const { |
| return (double) this->value; |
| } |
| |
| /** |
| * Answers the float value which the receiver represents |
| * @return float the value of the receiver. |
| */ |
| virtual float floatValue() const { |
| return (float) this->value; |
| } |
| |
| /** |
| * Answers the byte value which the receiver represents |
| * @return int the value of the receiver. |
| */ |
| virtual unsigned char byteValue() const { |
| return (unsigned char) this->value; |
| } |
| |
| /** |
| * Answers the short value which the receiver represents |
| * @return int the value of the receiver. |
| */ |
| virtual short shortValue() const { |
| return (short) this->value; |
| } |
| |
| /** |
| * Answers the int value which the receiver represents |
| * @return int the value of the receiver. |
| */ |
| virtual int intValue() const { |
| return this->value; |
| } |
| |
| /** |
| * Answers the long value which the receiver represents |
| * @return long the value of the receiver. |
| */ |
| virtual long long longValue() const { |
| return (long long) this->value; |
| } |
| |
| public: |
| // Statics |
| |
| /** |
| * Decodes a String into a Integer. Accepts decimal, hexadecimal, and octal |
| * numbers given by the following grammar: |
| * |
| * The sequence of characters following an (optional) negative sign and/or |
| * radix specifier ("0x", "0X", "#", or leading zero) is parsed as by the |
| * Integer.parseInteger method with the indicated radix (10, 16, or 8). This |
| * sequence of characters must represent a positive value or a |
| * NumberFormatException will be thrown. The result is negated if first |
| * character of the specified String is the minus sign. No whitespace |
| * characters are permitted in the string. |
| * @param value - The string to decode |
| * @return a Integer object containing the decoded value |
| * @throws NumberFomatException if the string is not formatted correctly. |
| */ |
| static Integer decode(const String& value); |
| |
| /** |
| * Returns the value obtained by reversing the order of the bytes in the |
| * two's complement representation of the specified int value. |
| * @param value - the int whose bytes we are to reverse |
| * @return the reversed int. |
| */ |
| static int reverseBytes(int value); |
| |
| /** |
| * Returns the value obtained by reversing the order of the bits in the |
| * two's complement binary representation of the specified int value. |
| * @param value - the value whose bits are to be reversed |
| * @return the reversed bits int. |
| */ |
| static int reverse(int value); |
| |
| /** |
| * Parses the string argument as a signed int in the radix specified by |
| * the second argument. The characters in the string must all be digits, |
| * of the specified radix (as determined by whether |
| * Character.digit(char, int) returns a nonnegative value) except that the |
| * first character may be an ASCII minus sign '-' to indicate a negative |
| * value. The resulting byte value is returned. |
| * |
| * An exception of type NumberFormatException is thrown if any of the |
| * following situations occurs: |
| * * The first argument is null or is a string of length zero. |
| * * The radix is either smaller than Character.MIN_RADIX or larger than |
| * Character.MAX_RADIX. |
| * * Any character of the string is not a digit of the specified radix, |
| * except that the first character may be a minus sign '-' provided |
| * that the string is longer than length 1. |
| * * The value represented by the string is not a value of type int. |
| * |
| * @param s - the String containing the int representation to be parsed |
| * @param radix - the radix to be used while parsing s |
| * @return the int represented by the string argument in the specified radix. |
| * @throws NumberFormatException - If String does not contain a parsable int. |
| */ |
| static int parseInt(const String& s, int radix); |
| |
| /** |
| * Parses the string argument as a signed decimal int. The characters |
| * in the string must all be decimal digits, except that the first |
| * character may be an ASCII minus sign '-' to indicate a |
| * negative value. The resulting int value is returned, exactly as if |
| * the argument and the radix 10 were given as arguments to the |
| * parseInteger( const std::string, int ) method. |
| * |
| * @param s |
| * String to convert to a int |
| * |
| * @return the converted int value |
| * @throws NumberFormatException if the string is not a int. |
| */ |
| static int parseInt(const String& s); |
| |
| /** |
| * Returns a Integer instance representing the specified int value. |
| * |
| * @param value |
| * The int to wrap in an Integer object. |
| * |
| * @return the new Integer object wrapping value. |
| */ |
| static Integer valueOf(int value) { |
| return Integer(value); |
| } |
| |
| /** |
| * Returns a Integer object holding the value given by the specified |
| * std::string. The argument is interpreted as representing a signed |
| * decimal int, exactly as if the argument were given to the |
| * parseInt( std::string ) method. The result is a Integer object that |
| * represents the int value specified by the string. |
| * @param value - std::string to parse as base 10 |
| * @return new Integer Object wrapping the primitive |
| * @throws NumberFormatException if the string is not a decimal int. |
| */ |
| static Integer valueOf(const String& value); |
| |
| /** |
| * Returns a Integer object holding the value extracted from the specified |
| * std::string when parsed with the radix given by the second argument. |
| * The first argument is interpreted as representing a signed int in the |
| * radix specified by the second argument, exactly as if the argument were |
| * given to the parseInt( std::string, int ) method. The result is a |
| * Integer object that represents the int value specified by the string. |
| * @param value - std::string to parse as base ( radix ) |
| * @param radix - base of the string to parse. |
| * @return new Integer Object wrapping the primitive |
| * @throws NumberFormatException if the string is not a valid int. |
| */ |
| static Integer valueOf(const String& value, int radix); |
| |
| /** |
| * Returns the number of one-bits in the two's complement binary |
| * representation of the specified int value. This function is sometimes |
| * referred to as the population count. |
| * @param value - the int to count |
| * @return the number of one-bits in the two's complement binary |
| * representation of the specified int value. |
| */ |
| static int bitCount(int value); |
| |
| /** |
| * Converts the int to a String representation |
| * @param value |
| * The int to convert to a <code>std::string</code> instance. |
| * @return string representation |
| */ |
| static std::string toString(int value); |
| |
| /** |
| * Returns a string representation of the first argument in the radix |
| * specified by the second argument. |
| * |
| * If the radix is smaller than Character.MIN_RADIX or larger than |
| * Character.MAX_RADIX, then the radix 10 is used instead. |
| * |
| * If the first argument is negative, the first element of the result is |
| * the ASCII minus character '-'. If the first argument is not |
| * negative, no sign character appears in the result. |
| * |
| * The remaining characters of the result represent the magnitude of the |
| * first argument. If the magnitude is zero, it is represented by a single |
| * zero character '0'; otherwise, the first character of the |
| * representation of the magnitude will not be the zero character. The |
| * following ASCII characters are used as digits: |
| * |
| * 0123456789abcdefghijklmnopqrstuvwxyz |
| * |
| * @param value - the int to convert to a string |
| * @param radix - the radix to format the string in |
| * @return an int formatted to the string value of the radix given. |
| */ |
| static std::string toString(int value, int radix); |
| |
| /** |
| * Returns a string representation of the integer argument as an unsigned |
| * integer in base 16. |
| * |
| * The unsigned integer value is the argument plus 2^32 if the argument is |
| * negative; otherwise, it is equal to the argument. This value is converted |
| * to a string of ASCII digits in hexadecimal (base 16) with no extra leading |
| * 0s. If the unsigned magnitude is zero, it is represented by a single zero |
| * character '0'; otherwise, the first character of the representation of the |
| * unsigned magnitude will not be the zero character. The following characters |
| * are used as hexadecimal digits: |
| * |
| * 0123456789abcdef |
| * |
| * If uppercase letters are desired, the toUpperCase() method may be called |
| * on the result: |
| * @param value - the int to be translated to an Octal string |
| * @return the unsigned int value as a Octal string |
| */ |
| static std::string toHexString(int value); |
| |
| /** |
| * Returns a string representation of the integer argument as an unsigned |
| * integer in base 8. |
| * |
| * The unsigned integer value is the argument plus 2^32 if the argument is |
| * negative; otherwise, it is equal to the argument. This value is converted |
| * to a string of ASCII digits in octal (base 8) with no extra leading 0s. |
| * |
| * If the unsigned magnitude is zero, it is represented by a single zero |
| * character '0'; otherwise, the first character of the representation |
| * of the unsigned magnitude will not be the zero character. The following |
| * characters are used as octal digits: |
| * |
| * 01234567 |
| * |
| * @param value - the int to be translated to an Octal string |
| * @return the unsigned int value as a Octal string |
| */ |
| static std::string toOctalString(int value); |
| |
| /** |
| * Returns a string representation of the integer argument as an unsigned |
| * integer in base 2. |
| * <p> |
| * The unsigned integer value is the argument plus 2^32 if the argument is |
| * negative; otherwise it is equal to the argument. This value is converted |
| * to a string of ASCII digits in binary (base 2) with no extra leading 0s. |
| * If the unsigned magnitude is zero, it is represented by a single zero |
| * character '0'; otherwise, the first character of the representation |
| * of the unsigned magnitude will not be the zero character. |
| * <p> |
| * The characters '0' and '1' are used as binary |
| * digits. |
| * |
| * @param value - the int to be translated to a binary string |
| * @return the unsigned int value as a binary string |
| */ |
| static std::string toBinaryString(int value); |
| |
| /** |
| * Returns an int value with at most a single one-bit, in the position of |
| * the highest-order ("leftmost") one-bit in the specified int value. |
| * Returns zero if the specified value has no one-bits in its two's |
| * complement binary representation, that is, if it is equal to zero. |
| * @param value - the int to be inspected |
| * @return an int value with a single one-bit, in the position of the |
| * highest-order one-bit in the specified value, or zero if the specified |
| * value is itself equal to zero. |
| */ |
| static int highestOneBit(int value); |
| |
| /** |
| * Returns an int value with at most a single one-bit, in the position of |
| * the lowest-order ("rightmost") one-bit in the specified int value. |
| * Returns zero if the specified value has no one-bits in its two's |
| * complement binary representation, that is, if it is equal to zero. |
| * @param value - the int to be inspected |
| * @return an int value with a single one-bit, in the position of the |
| * lowest-order one-bit in the specified value, or zero if the specified |
| * value is itself equal to zero. |
| */ |
| static int lowestOneBit(int value); |
| |
| /** |
| * Returns the number of zero bits preceding the highest-order ("leftmost") |
| * one-bit in the two's complement binary representation of the specified |
| * int value. Returns 32 if the specified value has no one-bits in its two's |
| * complement representation, in other words if it is equal to zero. |
| * |
| * Note that this method is closely related to the logarithm base 2. For |
| * all positive int values x: |
| * |
| * * floor( log2(x)) = 31 - numberOfLeadingZeros(x) |
| * * ceil( log2(x)) = 32 - numberOfLeadingZeros(x - 1) |
| * |
| * @param value - the int to be inspected |
| * @return the number of zero bits preceding the highest-order ("leftmost") |
| * one-bit in the two's complement binary representation of the specified |
| * int value, or 32 if the value is equal to zero. |
| */ |
| static int numberOfLeadingZeros(int value); |
| |
| /** |
| * Returns the number of zero bits following the lowest-order ("rightmost") |
| * one-bit in the two's complement binary representation of the specified |
| * int value. Returns 32 if the specified value has no one-bits in its |
| * two's complement representation, in other words if it is equal to zero. |
| * @param value - the int to be inspected |
| * @return the number of zero bits following the lowest-order ("rightmost") |
| * one-bit in the two's complement binary representation of the specified |
| * int value, or 32 if the value is equal to zero. |
| */ |
| static int numberOfTrailingZeros(int value); |
| |
| /** |
| * Returns the value obtained by rotating the two's complement binary |
| * representation of the specified int value left by the specified number |
| * of bits. (Bits shifted out of the left hand, or high-order, side reenter |
| * on the right, or low-order.) |
| * |
| * Note that left rotation with a negative distance is equivalent to right |
| * rotation: rotateLeft(val, -distance) == rotateRight(val, distance). Note |
| * also that rotation by any multiple of 32 is a no-op, so all but the last |
| * five bits of the rotation distance can be ignored, even if the distance |
| * is negative: rotateLeft(val, distance) == rotateLeft(val, distance & 0x1F). |
| * @param value - the int to be inspected |
| * @param distance - the number of bits to rotate |
| * @return the value obtained by rotating the two's complement binary |
| * representation of the specified int value left by the specified number |
| * of bits. |
| */ |
| static int rotateLeft(int value, int distance); |
| |
| /** |
| * Returns the value obtained by rotating the two's complement binary |
| * representation of the specified int value right by the specified number |
| * of bits. (Bits shifted out of the right hand, or low-order, side reenter |
| * on the left, or high-order.) |
| * |
| * Note that right rotation with a negative distance is equivalent to left |
| * rotation: rotateRight(val, -distance) == rotateLeft(val, distance). Note |
| * also that rotation by any multiple of 32 is a no-op, so all but the last |
| * five bits of the rotation distance can be ignored, even if the distance is |
| * negative: rotateRight(val, distance) == rotateRight(val, distance & 0x1F). |
| * @param value - the int to be inspected |
| * @param distance - the number of bits to rotate |
| * @return the value obtained by rotating the two's complement binary |
| * representation of the specified int value right by the specified number |
| * of bits. |
| */ |
| static int rotateRight(int value, int distance); |
| |
| /** |
| * Returns the signum function of the specified int value. (The return value |
| * is -1 if the specified value is negative; 0 if the specified value is zero; |
| * and 1 if the specified value is positive.) |
| * @param value - the int to be inspected |
| * @return the signum function of the specified int value. |
| */ |
| static int signum(int value); |
| |
| private: |
| |
| static int parse(const String& value, int offset, int radix, bool negative); |
| |
| }; |
| |
| }} |
| |
| #endif /*_DECAF_LANG_INTEGER_H_*/ |