activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tab...@apache.org
Subject svn commit: r561325 - in /activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/lang: Integer.cpp Integer.h
Date Tue, 31 Jul 2007 13:31:48 GMT
Author: tabish
Date: Tue Jul 31 06:31:47 2007
New Revision: 561325

URL: http://svn.apache.org/viewvc?view=rev&rev=561325
Log:
http://issues.apache.org/activemq/browse/AMQCPP-103

Implementing the Primitive Wrappers fully

Modified:
    activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/lang/Integer.cpp
    activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/lang/Integer.h

Modified: activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/lang/Integer.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/lang/Integer.cpp?view=diff&rev=561325&r1=561324&r2=561325
==============================================================================
--- activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/lang/Integer.cpp (original)
+++ activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/lang/Integer.cpp Tue Jul 31 06:31:47
2007
@@ -87,8 +87,6 @@
 ////////////////////////////////////////////////////////////////////////////////
 std::string Integer::toString( int value, int radix ) {
 
-    std::string result = "";
-
     if( radix < Character::MIN_RADIX || radix > Character::MAX_RADIX ) {
         radix = 10;
     }
@@ -108,8 +106,10 @@
         count++;
     }
 
-    char* buffer = new char[count];
-    const int length = count;
+    // Save length and allocate a new buffer for the string, add one
+    // more for the null character.
+    int length = count;
+    char* buffer = new char[length + 1];
 
     do {
         int ch = 0 - ( j % radix );
@@ -125,8 +125,111 @@
         buffer[0] = '-';
     }
 
-    result.append( &buffer[0], length );
-    delete buffer;
+    // Ensure there's a null
+    buffer[length] = 0;
+    std::string result( &buffer[0] );
+    delete [] buffer;
+
+    return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+std::string toBinaryString( int value ) {
+
+    int count = 1;
+    int j = value;
+
+    if( value < 0 ) {
+        count = 32;
+    } else {
+        while ( (j >>= 1) != 0) {
+            count++;
+        }
+    }
+
+    // Save length and allocate a new buffer for the string, add one
+    // more for the null character.
+    int length = count;
+    char* buffer = new char[length + 1];
+
+    do {
+        buffer[--count] = (char)( (value & 1) + '0' );
+        value >>= 1;
+    } while( count > 0 );
+
+    // Ensure there's a null
+    buffer[length] = 0;
+    std::string result( &buffer[0] );
+    delete [] buffer;
+
+    return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+std::string toOctalString( int value ) {
+
+    int count = 1, j = value;
+
+    if( value < 0 ) {
+        count = 11;
+    } else {
+        while ( (j >>= 3) != 0 ) {
+            count++;
+        }
+    }
+
+    // Save length and allocate a new buffer for the string, add one
+    // more for the null character.
+    int length = count;
+    char* buffer = new char[length + 1];
+
+    do {
+        buffer[--count] = (char)( (value & 7) + '0' );
+        value >>= 3;
+    } while( count > 0 );
+
+    // Ensure there's a null
+    buffer[length] = 0;
+    std::string result( &buffer[0] );
+    delete [] buffer;
+
+    return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+std::string toHexString( int value ) {
+
+    int count = 1;
+    int j = value;
+
+    if( value < 0 ) {
+        count = 8;
+    } else {
+        while( (j >>= 4) != 0 ) {
+            count++;
+        }
+    }
+
+    // Save length and allocate a new buffer for the string, add one
+    // more for the null character.
+    int length = count;
+    char* buffer = new char[length + 1];
+
+    do {
+        int t = value & 15;
+        if( t > 9 ) {
+            t = t - 10 + 'a';
+        } else {
+            t += '0';
+        }
+        buffer[--count] = (char)t;
+        value >>= 4;
+    } while( count > 0 );
+
+    // Ensure there's a null
+    buffer[length] = 0;
+    std::string result( &buffer[0] );
+    delete [] buffer;
 
     return result;
 }
@@ -275,4 +378,51 @@
         }
     }
     return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int Integer::highestOneBit( int value ) {
+
+    value |= (value >> 1);
+    value |= (value >> 2);
+    value |= (value >> 4);
+    value |= (value >> 8);
+    value |= (value >> 16);
+    return ( value & ~(value >> 1));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int Integer::lowestOneBit( int value ) {
+    return ( value & (-value) );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int Integer::numberOfLeadingZeros( int value ) {
+
+    value |= value >> 1;
+    value |= value >> 2;
+    value |= value >> 4;
+    value |= value >> 8;
+    value |= value >> 16;
+    return Integer::bitCount( ~value );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int Integer::numberOfTrailingZeros( int value ) {
+    return bitCount( (value & -value) - 1 );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int Integer::rotateLeft( int value ) {
+    return value; // TODO
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int Integer::rotateRight( int value ) {
+    return value; // TODO
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int Integer::signum( int value ) {
+    return ( value == 0 ? 0 : ( value < 0 ? -1 : 1 ) );
 }

Modified: activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/lang/Integer.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/lang/Integer.h?view=diff&rev=561325&r1=561324&r2=561325
==============================================================================
--- activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/lang/Integer.h (original)
+++ activemq/activemq-cpp/trunk/src/decaf/src/main/decaf/lang/Integer.h Tue Jul 31 06:31:47
2007
@@ -285,6 +285,162 @@
          */
         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
+         * @returns 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
+         * @returns 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.
+         *
+         * 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' ('\u0030'); otherwise, the first character of the
+         * representation of the unsigned magnitude will not be the zero character.
+         * The characters '0' ('\u0030') and '1' ('\u0031') are used as binary
+         * digits.
+         * @param value - the int to be translated to a binary string
+         * @returns 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
+         * @return
+         */
+        static int rotateLeft( int value );
+
+        /**
+         * 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
+         * @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 );
+
+        /**
+         * 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 std::string& value, int offset,



Mime
View raw message