activemq-cpp/src/main/decaf/lang/Integer.h - activemq-cpp - Git at Google

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