activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tab...@apache.org
Subject svn commit: r1360895 [1/2] - in /activemq/activemq-cpp/trunk/activemq-cpp/src: main/ main/decaf/lang/exceptions/ main/decaf/util/ test/ test/decaf/util/
Date Thu, 12 Jul 2012 19:59:02 GMT
Author: tabish
Date: Thu Jul 12 19:59:01 2012
New Revision: 1360895

URL: http://svn.apache.org/viewvc?rev=1360895&view=rev
Log:
Add class BitSet to be used in message audit functionality. 

Added:
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/exceptions/NegativeArraySizeException.h   (with props)
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/exceptions/OutOfMemoryError.h   (with props)
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/BitSet.cpp   (with props)
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/BitSet.h   (with props)
    activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/BitSetTest.cpp   (with props)
    activemq/activemq-cpp/trunk/activemq-cpp/src/test/decaf/util/BitSetTest.h   (with props)
Modified:
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/Makefile.am
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/Config.h
    activemq/activemq-cpp/trunk/activemq-cpp/src/test/Makefile.am
    activemq/activemq-cpp/trunk/activemq-cpp/src/test/testRegistry.cpp

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/Makefile.am
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/Makefile.am?rev=1360895&r1=1360894&r2=1360895&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/Makefile.am (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/Makefile.am Thu Jul 12 19:59:01 2012
@@ -421,6 +421,7 @@ cc_sources = \
     decaf/util/AbstractSet.cpp \
     decaf/util/ArrayList.cpp \
     decaf/util/Arrays.cpp \
+    decaf/util/BitSet.cpp \
     decaf/util/Collection.cpp \
     decaf/util/Comparator.cpp \
     decaf/util/ConcurrentModificationException.cpp \
@@ -945,8 +946,10 @@ h_sources = \
     decaf/lang/exceptions/IndexOutOfBoundsException.h \
     decaf/lang/exceptions/InterruptedException.h \
     decaf/lang/exceptions/InvalidStateException.h \
+    decaf/lang/exceptions/NegativeArraySizeException.h \
     decaf/lang/exceptions/NullPointerException.h \
     decaf/lang/exceptions/NumberFormatException.h \
+    decaf/lang/exceptions/OutOfMemoryError.h \
     decaf/lang/exceptions/RuntimeException.h \
     decaf/lang/exceptions/UnsupportedOperationException.h \
     decaf/net/BindException.h \
@@ -1026,6 +1029,7 @@ h_sources = \
     decaf/util/AbstractSet.h \
     decaf/util/ArrayList.h \
     decaf/util/Arrays.h \
+    decaf/util/BitSet.h \
     decaf/util/Collection.h \
     decaf/util/Comparator.h \
     decaf/util/ConcurrentModificationException.h \

Added: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/exceptions/NegativeArraySizeException.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/exceptions/NegativeArraySizeException.h?rev=1360895&view=auto
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/exceptions/NegativeArraySizeException.h (added)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/exceptions/NegativeArraySizeException.h Thu Jul 12 19:59:01 2012
@@ -0,0 +1,125 @@
+/*
+ * 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_EXCEPTIONS_NEGATIVEARRAYSIZEEXCEPTION_H_
+#define _DECAF_LANG_EXCEPTIONS_NEGATIVEARRAYSIZEEXCEPTION_H_
+
+#include <decaf/lang/exceptions/RuntimeException.h>
+
+namespace decaf{
+namespace lang{
+namespace exceptions{
+
+    /*
+     * Thrown if an application tries to create an array with negative size.
+     *
+     * @since 1.0
+     */
+    class DECAF_API NegativeArraySizeException : public RuntimeException {
+    public:
+
+        /**
+         * Default Constructor
+         */
+        NegativeArraySizeException() : RuntimeException() {
+        }
+
+        /**
+         * Conversion Constructor from some other Decaf Exception
+         *
+         * @param ex
+         *      The Exception whose data is to be copied into this one.
+         */
+        NegativeArraySizeException(const Exception& ex) : RuntimeException() {
+            *(Exception*) this = ex;
+        }
+
+        /**
+         * Copy Constructor
+         *
+         * @param ex
+         *      The Exception whose data is to be copied into this one.
+         */
+        NegativeArraySizeException(const NegativeArraySizeException& ex) : RuntimeException() {
+            *(Exception*) this = ex;
+        }
+
+        /**
+         * Constructor - Initializes the file name and line number where
+         * this message occurred.  Sets the message to report, using an
+         * optional list of arguments to parse into the message
+         * @param file The file name where exception occurs
+         * @param lineNumber The line number where the exception occurred.
+         * @param cause The exception that was the cause for this one to be thrown.
+         * @param msg The message to report
+         * @param ... list of primitives that are formatted into the message
+         */
+        NegativeArraySizeException(const char* file, const int lineNumber, const std::exception* cause, const char* msg, ...) : RuntimeException(cause) {
+
+            va_list vargs;
+            va_start(vargs, msg);
+            buildMessage(msg, vargs);
+
+            // Set the first mark for this exception.
+            setMark(file, lineNumber);
+        }
+
+        /**
+         * Constructor
+         * @param cause Pointer to the exception that caused this one to
+         * be thrown, the object is cloned caller retains ownership.
+         */
+        NegativeArraySizeException(const std::exception* cause) : RuntimeException(cause) {
+        }
+
+        /**
+         * Constructor - Initializes the file name and line number where
+         * this message occurred.  Sets the message to report, using an
+         * optional list of arguments to parse into the message
+         * @param file The file name where exception occurs
+         * @param lineNumber The line number where the exception occurred.
+         * @param msg The message to report
+         * @param ... list of primitives that are formatted into the message
+         */
+        NegativeArraySizeException(const char* file, const int lineNumber, const char* msg, ...) : RuntimeException() {
+
+            va_list vargs;
+            va_start(vargs, msg);
+            buildMessage(msg, vargs);
+
+            // Set the first mark for this exception.
+            setMark(file, lineNumber);
+        }
+
+        /**
+         * Clones this exception.  This is useful for cases where you need
+         * to preserve the type of the original exception as well as the message.
+         * All subclasses should override.
+         *
+         * @return an new Exception that is a copy of this one.
+         */
+        virtual NegativeArraySizeException* clone() const {
+            return new NegativeArraySizeException(*this);
+        }
+
+        virtual ~NegativeArraySizeException() throw () {
+        }
+
+    };
+
+}}}
+
+#endif /*_DECAF_LANG_EXCEPTIONS_NEGATIVEARRAYSIZEEXCEPTION_H_*/

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/exceptions/NegativeArraySizeException.h
------------------------------------------------------------------------------
    svn:eol-style = native

Added: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/exceptions/OutOfMemoryError.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/exceptions/OutOfMemoryError.h?rev=1360895&view=auto
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/exceptions/OutOfMemoryError.h (added)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/exceptions/OutOfMemoryError.h Thu Jul 12 19:59:01 2012
@@ -0,0 +1,125 @@
+/*
+ * 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_EXCEPTIONS_OUTOFMEMORYERROR_H_
+#define _DECAF_LANG_EXCEPTIONS_OUTOFMEMORYERROR_H_
+
+#include <decaf/lang/Exception.h>
+
+namespace decaf{
+namespace lang{
+namespace exceptions{
+
+    /*
+     * Thrown when an allocation operation fails indicating not enough memory.
+     *
+     * @since 1.0
+     */
+    class DECAF_API OutOfMemoryError : public Exception {
+    public:
+
+        /**
+         * Default Constructor
+         */
+        OutOfMemoryError() : Exception() {}
+
+        /**
+         * Conversion Constructor from some other Exception
+         *
+         * @param ex
+         *      The Exception whose data is to be copied into this one.
+         */
+        OutOfMemoryError(const Exception& ex) : Exception() {
+            *(Exception*)this = ex;
+        }
+
+        /**
+         * Copy Constructor
+         *
+         * @param ex
+         *      The Exception whose data is to be copied into this one.
+         */
+        OutOfMemoryError(const OutOfMemoryError& ex) : Exception() {
+            *(Exception*) this = ex;
+        }
+
+        /**
+         * Constructor
+         * @param cause Pointer to the exception that caused this one to
+         * be thrown, the object is cloned caller retains ownership.
+         */
+        OutOfMemoryError(const std::exception* cause) : Exception( cause ) {}
+
+        /**
+         * Constructor - Initializes the file name and line number where
+         * this message occurred.  Sets the message to report, using an
+         * optional list of arguments to parse into the message
+         * @param file The file name where exception occurs
+         * @param lineNumber The line number where the exception occurred.
+         * @param msg The message to report
+         * @param ... list of primitives that are formatted into the message
+         */
+        OutOfMemoryError(const char* file, const int lineNumber,
+                           const char* msg, ...) : Exception()
+        {
+            va_list vargs;
+            va_start(vargs, msg);
+            buildMessage(msg, vargs);
+
+            // Set the first mark for this exception.
+            setMark(file, lineNumber);
+        }
+
+        /**
+         * Constructor - Initializes the file name and line number where
+         * this message occurred.  Sets the message to report, using an
+         * optional list of arguments to parse into the message
+         * @param file The file name where exception occurs
+         * @param lineNumber The line number where the exception occurred.
+         * @param cause The exception that was the cause for this one to be thrown.
+         * @param msg The message to report
+         * @param ... list of primitives that are formatted into the message
+         */
+        OutOfMemoryError(const char* file, const int lineNumber,
+                           const std::exception* cause,
+                           const char* msg, ...) : Exception( cause )
+        {
+            va_list vargs ;
+            va_start(vargs, msg);
+            buildMessage(msg, vargs);
+
+            // Set the first mark for this exception.
+            setMark(file, lineNumber);
+        }
+
+        /**
+         * Clones this exception.  This is useful for cases where you need
+         * to preserve the type of the original exception as well as the message.
+         * All subclasses should override.
+         *
+         * @return an new Exception instance that is a copy of this one.
+         */
+        virtual OutOfMemoryError* clone() const{
+            return new OutOfMemoryError( *this );
+        }
+
+        virtual ~OutOfMemoryError() throw() {}
+
+    };
+
+}}}
+
+#endif /*_DECAF_LANG_EXCEPTIONS_OUTOFMEMORYERROR_H_*/

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/exceptions/OutOfMemoryError.h
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/lang/exceptions/OutOfMemoryError.h
------------------------------------------------------------------------------
    svn:executable = *

Added: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/BitSet.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/BitSet.cpp?rev=1360895&view=auto
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/BitSet.cpp (added)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/BitSet.cpp Thu Jul 12 19:59:01 2012
@@ -0,0 +1,791 @@
+/*
+ * 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.
+ */
+
+#include "BitSet.h"
+
+#include <decaf/lang/exceptions/IndexOutOfBoundsException.h>
+#include <decaf/lang/exceptions/NegativeArraySizeException.h>
+#include <decaf/lang/exceptions/OutOfMemoryError.h>
+
+#include <decaf/lang/System.h>
+#include <decaf/lang/Integer.h>
+#include <decaf/lang/Math.h>
+
+using namespace std;
+using namespace decaf;
+using namespace decaf::lang;
+using namespace decaf::lang::exceptions;
+using namespace decaf::util;
+
+////////////////////////////////////////////////////////////////////////////////
+namespace {
+
+    static const int OFFSET = 6;
+    static const int ELM_SIZE = 1 << OFFSET;
+    static const int RIGHT_BITS = ELM_SIZE - 1;
+
+    static long long TWO_N_ARRAY[64] = {
+        0x0000000000000001ULL, 0x0000000000000002ULL, 0x0000000000000004ULL,
+        0x0000000000000008ULL, 0x0000000000000010ULL, 0x0000000000000020ULL,
+        0x0000000000000040ULL, 0x0000000000000080ULL, 0x0000000000000100ULL,
+        0x0000000000000200ULL, 0x0000000000000400ULL, 0x0000000000000800ULL,
+        0x0000000000001000ULL, 0x0000000000002000ULL, 0x0000000000004000ULL,
+        0x0000000000008000ULL, 0x0000000000010000ULL, 0x0000000000020000ULL,
+        0x0000000000040000ULL, 0x0000000000080000ULL, 0x0000000000100000ULL,
+        0x0000000000200000ULL, 0x0000000000400000ULL, 0x0000000000800000ULL,
+        0x0000000001000000ULL, 0x0000000002000000ULL, 0x0000000004000000ULL,
+        0x0000000008000000ULL, 0x0000000010000000ULL, 0x0000000020000000ULL,
+        0x0000000040000000ULL, 0x0000000080000000ULL, 0x0000000100000000ULL,
+        0x0000000200000000ULL, 0x0000000400000000ULL, 0x0000000800000000ULL,
+        0x0000001000000000ULL, 0x0000002000000000ULL, 0x0000004000000000ULL,
+        0x0000008000000000ULL, 0x0000010000000000ULL, 0x0000020000000000ULL,
+        0x0000040000000000ULL, 0x0000080000000000ULL, 0x0000100000000000ULL,
+        0x0000200000000000ULL, 0x0000400000000000ULL, 0x0000800000000000ULL,
+        0x0001000000000000ULL, 0x0002000000000000ULL, 0x0004000000000000ULL,
+        0x0008000000000000ULL, 0x0010000000000000ULL, 0x0020000000000000ULL,
+        0x0040000000000000ULL, 0x0080000000000000ULL, 0x0100000000000000ULL,
+        0x0200000000000000ULL, 0x0400000000000000ULL, 0x0800000000000000ULL,
+        0x1000000000000000ULL, 0x2000000000000000ULL, 0x4000000000000000ULL,
+        0x8000000000000000ULL };
+
+    int pop(unsigned long long x) {
+        x = x - ((x >> 1) & 0x55555555);
+        x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
+        x = (x + (x >> 4)) & 0x0f0f0f0f;
+        x = x + (x >> 8);
+        x = x + (x >> 16);
+        return (int) x & 0x0000003f;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+BitSet::BitSet() : bits(new unsigned long long[1]), bitsSize(1), needClear(false), actualArrayLength(0), isLengthActual(true) {
+    bits[0] = 0ULL;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+BitSet::BitSet(int bitCount) : bits(0), bitsSize(0), needClear(false), actualArrayLength(0), isLengthActual(true) {
+
+    if (bitCount < 0) {
+        throw NegativeArraySizeException(__FILE__, __LINE__, "");
+    }
+
+    bitsSize = (bitCount >> OFFSET) + ((bitCount & RIGHT_BITS) > 0 ? 1 : 0);
+    try {
+        bits = new unsigned long long[bitsSize];
+
+        if (bits == NULL) {
+            throw OutOfMemoryError(__FILE__, __LINE__, "Failed to allocate bit array.");
+        }
+
+        for (int i = 0; i < bitsSize; ++i) {
+            bits[i] = 0ULL;
+        }
+    } catch (std::bad_alloc& e) {
+        throw OutOfMemoryError(__FILE__, __LINE__, "Failed to allocate bit array.");
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+BitSet::BitSet(unsigned long long* bits, int bitsSize, bool needClear, int actualArrayLength, bool isLengthActual) :
+    bits(bits), bitsSize(bitsSize), needClear(needClear), actualArrayLength(actualArrayLength), isLengthActual(isLengthActual) {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+BitSet::~BitSet() {
+    try {
+        delete [] bits;
+    }
+    DECAF_CATCHALL_NOTHROW()
+}
+
+////////////////////////////////////////////////////////////////////////////////
+BitSet::BitSet(const BitSet& set) : bits(0), bitsSize(0), needClear(false), actualArrayLength(0), isLengthActual(true) {
+
+    this->actualArrayLength = set.actualArrayLength;
+    this->isLengthActual = set.isLengthActual;
+    this->needClear = set.needClear;
+    this->bitsSize = set.bitsSize;
+
+    try {
+        bits = new unsigned long long[bitsSize];
+
+        if (bits == NULL) {
+            throw OutOfMemoryError(__FILE__, __LINE__, "Failed to allocate bit array.");
+        }
+
+        System::arraycopy(set.bits, 0, bits, 0, set.bitsSize);
+
+    } catch (std::bad_alloc& e) {
+        throw OutOfMemoryError(__FILE__, __LINE__, "Failed to allocate bit array.");
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+BitSet& BitSet::operator= (const BitSet& set) {
+
+    delete [] this->bits;
+
+    this->actualArrayLength = set.actualArrayLength;
+    this->isLengthActual = set.isLengthActual;
+    this->needClear = set.needClear;
+    this->bitsSize = set.bitsSize;
+
+    try {
+        bits = new unsigned long long[bitsSize];
+
+        if (bits == NULL) {
+            throw OutOfMemoryError(__FILE__, __LINE__, "Failed to allocate bit array.");
+        }
+
+        System::arraycopy(set.bits, 0, bits, 0, set.bitsSize);
+
+    } catch (std::bad_alloc& e) {
+        throw OutOfMemoryError(__FILE__, __LINE__, "Failed to allocate bit array.");
+    }
+
+    return *this;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSet::AND(const BitSet& set) {
+
+    unsigned long long* bsBits = set.bits;
+
+    if (!needClear) {
+        return;
+    }
+
+    int length1 = actualArrayLength, length2 = set.actualArrayLength;
+    if (length1 <= length2) {
+        for (int i = 0; i < length1; i++) {
+            bits[i] &= bsBits[i];
+        }
+    } else {
+        for (int i = 0; i < length2; i++) {
+            bits[i] &= bsBits[i];
+        }
+        for (int i = length2; i < length1; i++) {
+            bits[i] = 0;
+        }
+        actualArrayLength = length2;
+    }
+    isLengthActual = !((actualArrayLength > 0) && (bits[actualArrayLength - 1] == 0));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSet::andNot(const BitSet& set) {
+	unsigned long long* bsBits = set.bits;
+
+    if (!needClear) {
+        return;
+    }
+
+    int range = actualArrayLength < set.actualArrayLength ? actualArrayLength : set.actualArrayLength;
+    for (int i = 0; i < range; i++) {
+        bits[i] &= ~bsBits[i];
+    }
+
+    if (actualArrayLength < range) {
+        actualArrayLength = range;
+    }
+
+    isLengthActual = !((actualArrayLength > 0) && (bits[actualArrayLength - 1] == 0));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int BitSet::cardinality() {
+    if (!needClear) {
+        return 0;
+    }
+    int count = 0;
+    int length = bitsSize;
+    // FIXME: need to test performance, if still not satisfied, change it to
+    // 256-bits table based
+    for (int idx = 0; idx < length; idx++) {
+        count += pop(bits[idx] & 0xffffffffL);
+        count += pop((bits[idx] >> 32));
+    }
+    return count;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSet::clear() {
+    if (needClear) {
+        for (int i = 0; i < bitsSize; i++) {
+            bits[i] = 0ULL;
+        }
+        actualArrayLength = 0;
+        isLengthActual = true;
+        needClear = false;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSet::clear(int index) {
+
+    if (index < 0) {
+        throw IndexOutOfBoundsException(__FILE__, __LINE__, "Index given was negative");
+    }
+
+    if (!needClear) {
+        return;
+    }
+    int arrayPos = index >> OFFSET;
+    if (arrayPos < actualArrayLength) {
+        bits[arrayPos] &= ~(TWO_N_ARRAY[index & RIGHT_BITS]);
+        if (bits[actualArrayLength - 1] == 0) {
+            isLengthActual = false;
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSet::clear(int fromIndex, int toIndex) {
+    if (fromIndex < 0 || toIndex < 0 || toIndex < fromIndex) {
+        throw IndexOutOfBoundsException(__FILE__, __LINE__, "Invalid from or to index given");
+    }
+
+    if (!needClear) {
+        return;
+    }
+
+    int last = (actualArrayLength << OFFSET);
+    if (fromIndex >= last || fromIndex == toIndex) {
+        return;
+    }
+    if (toIndex > last) {
+        toIndex = last;
+    }
+
+    int idx1 = fromIndex >> OFFSET;
+    int idx2 = (toIndex - 1) >> OFFSET;
+    unsigned long long factor1 = (~0ULL) << (fromIndex & RIGHT_BITS);
+    unsigned long long factor2 = (~0ULL) >> (ELM_SIZE - (toIndex & RIGHT_BITS));
+
+    if (idx1 == idx2) {
+        bits[idx1] &= ~(factor1 & factor2);
+    } else {
+        bits[idx1] &= ~factor1;
+        bits[idx2] &= ~factor2;
+        for (int i = idx1 + 1; i < idx2; i++) {
+            bits[i] = 0ULL;
+        }
+    }
+
+    if ((actualArrayLength > 0) && (bits[actualArrayLength - 1] == 0)) {
+        isLengthActual = false;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSet::OR(const BitSet& set) {
+    int setActualLen = set.getActualArrayLength();
+
+    if (setActualLen > bitsSize) {
+        unsigned long long* tempBits = new unsigned long long[setActualLen];
+        System::arraycopy(set.bits, 0, tempBits, 0, set.actualArrayLength);
+        for (int i = 0; i < actualArrayLength; i++) {
+            tempBits[i] |= bits[i];
+        }
+        delete [] bits;
+        bits = tempBits;
+        actualArrayLength = setActualLen;
+        isLengthActual = true;
+    } else {
+        unsigned long long* bsBits = set.bits;
+        for (int i = 0; i < setActualLen; i++) {
+            bits[i] |= bsBits[i];
+        }
+        if (setActualLen > actualArrayLength) {
+            actualArrayLength = setActualLen;
+            isLengthActual = true;
+        }
+    }
+    needClear = true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+bool BitSet::equals(const BitSet& set) const {
+
+    if (this == &set) {
+        return true;
+    }
+
+    unsigned long long* bsBits = set.bits;
+    int length1 = this->actualArrayLength;
+    int length2 = set.actualArrayLength;
+    if (this->isLengthActual && set.isLengthActual && length1 != length2) {
+        return false;
+    }
+
+    // If one of the BitSets is larger than the other, check to see if
+    // any of its extra bits are set. If so return false.
+    if (length1 <= length2) {
+        for (int i = 0; i < length1; i++) {
+            if (bits[i] != bsBits[i]) {
+                return false;
+            }
+        }
+        for (int i = length1; i < length2; i++) {
+            if (bsBits[i] != 0) {
+                return false;
+            }
+        }
+    } else {
+        for (int i = 0; i < length2; i++) {
+            if (bits[i] != bsBits[i]) {
+                return false;
+            }
+        }
+        for (int i = length2; i < length1; i++) {
+            if (bits[i] != 0) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSet::flip(int index) {
+    if (index < 0) {
+        throw IndexOutOfBoundsException(__FILE__, __LINE__, "Index given was negative");
+    }
+
+    int len = (index >> OFFSET) + 1;
+    if (len > bitsSize) {
+        ensureCapacity(len);
+    }
+    bits[len - 1] ^= TWO_N_ARRAY[index & RIGHT_BITS];
+    if (len > actualArrayLength) {
+        actualArrayLength = len;
+    }
+    isLengthActual = !((actualArrayLength > 0) && (bits[actualArrayLength - 1] == 0));
+    needClear = true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSet::flip(int fromIndex, int toIndex) {
+    if (fromIndex < 0 || toIndex < 0 || toIndex < fromIndex) {
+        throw IndexOutOfBoundsException(__FILE__, __LINE__, "Invalid from or to index given");
+    }
+
+    if (fromIndex == toIndex) {
+        return;
+    }
+    int len2 = ((toIndex - 1) >> OFFSET) + 1;
+    if (len2 > bitsSize) {
+        ensureCapacity(len2);
+    }
+
+    int idx1 = fromIndex >> OFFSET;
+    int idx2 = (toIndex - 1) >> OFFSET;
+    unsigned long long factor1 = (~0ULL) << (fromIndex & RIGHT_BITS);
+    unsigned long long factor2 = (~0ULL) >> (ELM_SIZE - (toIndex & RIGHT_BITS));
+
+    if (idx1 == idx2) {
+        bits[idx1] ^= (factor1 & factor2);
+    } else {
+        bits[idx1] ^= factor1;
+        bits[idx2] ^= factor2;
+        for (int i = idx1 + 1; i < idx2; i++) {
+            bits[i] ^= (~0ULL);
+        }
+    }
+    if (len2 > actualArrayLength) {
+        actualArrayLength = len2;
+    }
+    isLengthActual = !((actualArrayLength > 0) && (bits[actualArrayLength - 1] == 0));
+    needClear = true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+bool BitSet::get(int index) const {
+
+    if (index < 0) {
+        throw IndexOutOfBoundsException(__FILE__, __LINE__, "Index given was negative");
+    }
+
+    int arrayPos = index >> OFFSET;
+    if (arrayPos < actualArrayLength) {
+        return (bits[arrayPos] & TWO_N_ARRAY[index & RIGHT_BITS]) != 0;
+    }
+    return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+BitSet BitSet::get(int fromIndex, int toIndex) const {
+    if (fromIndex < 0 || toIndex < 0 || toIndex < fromIndex) {
+        throw IndexOutOfBoundsException(__FILE__, __LINE__, "Invalid from or to index given");
+    }
+
+    int last = actualArrayLength << OFFSET;
+    if (fromIndex >= last || fromIndex == toIndex) {
+        return BitSet(0);
+    }
+    if (toIndex > last) {
+        toIndex = last;
+    }
+
+    int idx1 = fromIndex >> OFFSET;
+    int idx2 = (toIndex - 1) >> OFFSET;
+    unsigned long long factor1 = (~0ULL) << (fromIndex & RIGHT_BITS);
+    unsigned long long factor2 = (~0ULL) >> (ELM_SIZE - (toIndex & RIGHT_BITS));
+
+    if (idx1 == idx2) {
+        unsigned long long result = (bits[idx1] & (factor1 & factor2)) >> (fromIndex % ELM_SIZE);
+        if (result == 0) {
+            return BitSet(0);
+        }
+
+        unsigned long long* newBits = new unsigned long long[1];
+        newBits[0] = result;
+        return BitSet(newBits, 1, needClear, 1, true);
+    }
+
+    int newBitsSize = idx2 - idx1 + 1;
+    unsigned long long* newbits = new unsigned long long[newBitsSize];
+
+    // first fill in the first and last indexes in the new bitset
+    newbits[0] = bits[idx1] & factor1;
+    newbits[newBitsSize - 1] = bits[idx2] & factor2;
+
+    // fill in the in between elements of the new bitset
+    for (int i = 1; i < idx2 - idx1; i++) {
+        newbits[i] = bits[idx1 + i];
+    }
+
+    // shift all the elements in the new bitset to the right by fromIndex % ELM_SIZE
+    int numBitsToShift = fromIndex & RIGHT_BITS;
+    int actualLen = newBitsSize;
+    if (numBitsToShift != 0) {
+        for (int i = 0; i < newBitsSize; i++) {
+            // shift the current element to the right regardless of sign
+            newbits[i] = newbits[i] >> (numBitsToShift);
+
+            // apply the last x bits of newbits[i+1] to the current element
+            if (i != newBitsSize - 1) {
+                newbits[i] |= newbits[i + 1] << (ELM_SIZE - (numBitsToShift));
+            }
+
+            if (newbits[i] != 0) {
+                actualLen = i + 1;
+            }
+        }
+    }
+
+    return BitSet(newbits, newBitsSize, needClear, actualLen, newbits[actualLen - 1] != 0);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+bool BitSet::intersects(const BitSet& set) const {
+	unsigned long long* bsBits = set.bits;
+    int length1 = actualArrayLength;
+    int length2 = set.actualArrayLength;
+
+    if (length1 <= length2) {
+        for (int i = 0; i < length1; i++) {
+            if ((bits[i] & bsBits[i]) != 0ULL) {
+                return true;
+            }
+        }
+    } else {
+        for (int i = 0; i < length2; i++) {
+            if ((bits[i] & bsBits[i]) != 0ULL) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+bool BitSet::isEmpty() const {
+    if (!needClear) {
+        return true;
+    }
+
+    for (int idx = 0; idx < bitsSize; idx++) {
+        if (bits[idx] != 0ULL) {
+            return false;
+        }
+    }
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int BitSet::length() const {
+
+    int idx = actualArrayLength - 1;
+    while (idx >= 0 && bits[idx] == 0) {
+        --idx;
+    }
+    actualArrayLength = idx + 1;
+    if (idx == -1) {
+        return 0;
+    }
+    int i = ELM_SIZE - 1;
+    long val = bits[idx];
+    while ((val & (TWO_N_ARRAY[i])) == 0 && i > 0) {
+        i--;
+    }
+    return (idx << OFFSET) + i + 1;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int BitSet::nextClearBit(int index) const {
+    if (index < 0) {
+        throw IndexOutOfBoundsException(__FILE__, __LINE__, "Index given was negative");
+    }
+
+    int length = actualArrayLength;
+    int bssize = length << OFFSET;
+    if (index >= bssize) {
+        return index;
+    }
+
+    int idx = index >> OFFSET;
+    // first check in the same bit set element
+    if (bits[idx] != (~0ULL)) {
+        for (int j = index % ELM_SIZE; j < ELM_SIZE; j++) {
+            if (((bits[idx] & (TWO_N_ARRAY[j])) == 0)) {
+                return idx * ELM_SIZE + j;
+            }
+        }
+    }
+    idx++;
+    while (idx < length && bits[idx] == (~0ULL)) {
+        idx++;
+    }
+    if (idx == length) {
+        return bssize;
+    }
+
+    // we know for sure there is a bit set to true in this element
+    // since the bitset value is not 0ULL
+    for (int j = 0; j < ELM_SIZE; j++) {
+        if (((bits[idx] & (TWO_N_ARRAY[j])) == 0)) {
+            return (idx << OFFSET) + j;
+        }
+    }
+
+    return bssize;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int BitSet::nextSetBit(int index) const {
+    if (index < 0) {
+        throw IndexOutOfBoundsException(__FILE__, __LINE__, "Index given was negative");
+    }
+
+    if (index >= actualArrayLength << OFFSET) {
+        return -1;
+    }
+
+    int idx = index >> OFFSET;
+    // first check in the same bit set element
+    if (bits[idx] != 0ULL) {
+        for (int j = index & RIGHT_BITS; j < ELM_SIZE; j++) {
+            if (((bits[idx] & (TWO_N_ARRAY[j])) != 0)) {
+                return (idx << OFFSET) + j;
+            }
+        }
+    }
+
+    idx++;
+    while (idx < actualArrayLength && bits[idx] == 0ULL) {
+        idx++;
+    }
+    if (idx == actualArrayLength) {
+        return -1;
+    }
+
+    // we know for sure there is a bit set to true in this element
+    // since the bitset value is not 0ULL
+    for (int j = 0; j < ELM_SIZE; j++) {
+        if (((bits[idx] & (TWO_N_ARRAY[j])) != 0)) {
+            return (idx << OFFSET) + j;
+        }
+    }
+
+    return -1;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSet::set(int index) {
+
+    if (index < 0) {
+        throw IndexOutOfBoundsException(__FILE__, __LINE__, "Index given was negative");
+    }
+
+    int len = (index >> OFFSET) + 1;
+    if (len > bitsSize) {
+        ensureCapacity(len);
+    }
+    bits[len - 1] |= TWO_N_ARRAY[index & RIGHT_BITS];
+    if (len > actualArrayLength) {
+        actualArrayLength = len;
+        isLengthActual = true;
+    }
+
+    this->needClear = true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSet::set(int index, bool value) {
+
+    if (value) {
+        set(index);
+    } else {
+        clear(index);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSet::set(int fromIndex, int toIndex) {
+
+    if (fromIndex < 0 || toIndex < 0 || toIndex < fromIndex) {
+        throw IndexOutOfBoundsException(__FILE__, __LINE__, "Invalid from or to index given");
+    }
+
+    if (fromIndex == toIndex) {
+        return;
+    }
+    int len2 = ((toIndex - 1) >> OFFSET) + 1;
+    if (len2 > bitsSize) {
+        ensureCapacity(len2);
+    }
+
+    int idx1 = fromIndex >> OFFSET;
+    int idx2 = (toIndex - 1) >> OFFSET;
+    unsigned long long factor1 = (~0ULL) << (fromIndex & RIGHT_BITS);
+    unsigned long long factor2 = (~0ULL) >> (ELM_SIZE - (toIndex & RIGHT_BITS));
+
+    if (idx1 == idx2) {
+        bits[idx1] |= (factor1 & factor2);
+    } else {
+        bits[idx1] |= factor1;
+        bits[idx2] |= factor2;
+        for (int i = idx1 + 1; i < idx2; i++) {
+            bits[i] |= (~0ULL);
+        }
+    }
+    if (idx2 + 1 > actualArrayLength) {
+        actualArrayLength = idx2 + 1;
+        isLengthActual = true;
+    }
+
+    needClear = true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSet::set(int fromIndex, int toIndex, bool value) {
+
+    if (value) {
+        set(fromIndex, toIndex);
+    } else {
+        clear(fromIndex, toIndex);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int BitSet::size() const {
+    return bitsSize << OFFSET;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+std::string BitSet::toString() const {
+    std::string sb;
+    int bitCount = 0;
+
+    sb.append("{");
+    bool comma = false;
+    for (int i = 0; i < bitsSize; i++) {
+        if (bits[i] == 0) {
+            bitCount += ELM_SIZE;
+            continue;
+        }
+        for (int j = 0; j < ELM_SIZE; j++) {
+            if (((bits[i] & (TWO_N_ARRAY[j])) != 0)) {
+                if (comma) {
+                    sb.append(", ");
+                }
+                sb.append(Integer::toString(bitCount));
+                comma = true;
+            }
+            bitCount++;
+        }
+    }
+    sb.append("}");
+    return sb;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSet::XOR(const BitSet& set) {
+    int setActualLength = set.getActualArrayLength();
+    if (setActualLength > bitsSize) {
+    	unsigned long long* tempBits = new unsigned long long[setActualLength];
+        System::arraycopy(set.bits, 0, tempBits, 0, set.actualArrayLength);
+        for (int i = 0; i < actualArrayLength; i++) {
+            tempBits[i] ^= bits[i];
+        }
+        delete [] bits;
+        bits = tempBits;
+        actualArrayLength = setActualLength;
+        isLengthActual = !((actualArrayLength > 0) && (bits[actualArrayLength - 1] == 0));
+    } else {
+    	unsigned long long* bsBits = set.bits;
+        for (int i = 0; i < setActualLength; i++) {
+            bits[i] ^= bsBits[i];
+        }
+        if (setActualLength > actualArrayLength) {
+            actualArrayLength = setActualLength;
+            isLengthActual = true;
+        }
+    }
+
+    this->needClear = true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void BitSet::ensureCapacity(int length) {
+    int newSize = Math::max(length, bitsSize * 2);
+    unsigned long long* tempBits = new unsigned long long[newSize];
+    System::arraycopy(bits, 0, tempBits, 0, this->actualArrayLength);
+    for (int i = this->actualArrayLength; i < newSize; ++i) {
+        tempBits[i] = 0ULL;
+    }
+    delete [] bits;
+    bits = tempBits;
+    bitsSize = newSize;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int BitSet::getActualArrayLength() const {
+    if (isLengthActual) {
+        return actualArrayLength;
+    }
+    int idx = actualArrayLength - 1;
+    while (idx >= 0 && bits[idx] == 0) {
+        --idx;
+    }
+    actualArrayLength = idx + 1;
+    isLengthActual = true;
+    return actualArrayLength;
+}

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/BitSet.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Added: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/BitSet.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/BitSet.h?rev=1360895&view=auto
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/BitSet.h (added)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/BitSet.h Thu Jul 12 19:59:01 2012
@@ -0,0 +1,394 @@
+/*
+ * 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_UTIL_BITSET_H_
+#define _DECAF_UTIL_BITSET_H_
+
+#include <decaf/util/Config.h>
+
+#include <string>
+
+namespace decaf {
+namespace util {
+
+    /**
+     * This class implements a vector of bits that grows as needed. Each component of
+     * the bit set has a boolean value. The bits of a BitSet are indexed by nonnegative
+     * integers. Individual indexed bits can be examined, set, or cleared. One BitSet
+     * may be used to modify the contents of another BitSet through logical AND, logical
+     * inclusive OR, and logical exclusive OR operations.
+     *
+     * By default, all bits in the set initially have the value false.
+     *
+     * Every bit set has a current size, which is the number of bits of space currently
+     * in use by the bit set. Note that the size is related to the implementation of a
+     * bit set, so it may change with implementation. The length of a bit set relates to
+     * logical length of a bit set and is defined independently of implementation.
+     *
+     * Unless otherwise noted, passing a null parameter to any of the methods in a
+     * BitSet will result in a NullPointerException.
+     *
+     * A BitSet is not safe for multi-threaded use without external synchronization.
+     *
+     * @since 1.0
+     */
+    class DECAF_API BitSet {
+    private:
+
+        // The actual array of 64 bit bits elements
+        unsigned long long* bits;
+        int bitsSize;
+
+        // Optimization, when the array is all zero there's no need to traverse
+        bool needClear;
+
+        // Lazily maintained actual array length and state.
+        mutable int actualArrayLength;
+        mutable bool isLengthActual;
+
+    private:
+
+        BitSet(unsigned long long* bits, int bitsSize, bool needClear, int actualArrayLength, bool isLengthActual);
+
+    public:
+
+        /**
+         * Creates a new BitSet whose bits are all false.
+         */
+        BitSet();
+
+        /**
+         * Creates a bit set whose initial size is large enough to explicitly represent bits
+         * with indices in the range 0 through bitCount-1. All bits are initially false.  If the
+         * bitCount is not a multiple of 64 then the count is rounded to the next closest
+         * multiple of 64.
+         *
+         * @param bitCount
+         *      The number of bits this BitSet should hold.
+         *
+         * @throws NegativeArraySizeException if bitCount is negative.
+         */
+        BitSet(int bitCount);
+
+        /**
+         * Copy Constructor
+         */
+        BitSet(const BitSet& set);
+
+        /**
+         * Assignment
+         */
+        BitSet& operator= (const BitSet& set);
+
+        virtual ~BitSet();
+
+    public:
+
+        /**
+         * Performs a logical AND of this target bit set with the argument bit set. This bit
+         * set is modified so that each bit in it has the value true if and only if it both
+         * initially had the value true and the corresponding bit in the bit set argument
+         * also had the value true.
+         *
+         * @param set
+         *      The BitSet to perform this action against.
+         */
+        void AND(const BitSet& set);
+
+        /**
+         * Performs a logical OR of this bit set with the bit set argument. This bit set is
+         * modified so that a bit in it has the value true if and only if it either already had
+         * the value true or the corresponding bit in the bit set argument has the value true.
+         *
+         * @param set
+         *      The BitSet to perform this action against.
+         */
+        void OR(const BitSet& set);
+
+        /**
+         * Clears all of the bits in this BitSet whose corresponding bit is set in the specified BitSet.
+         *
+         * @param set
+         *      The BitSet to perform this action against.
+         */
+        void andNot(const BitSet& set);
+
+        /**
+         * Returns the number of bits set to true in this BitSet.
+         *
+         * @returns the number of bits set to true in this BitSet.
+         */
+        int cardinality();
+
+        /**
+         * Sets all of the bits in this BitSet to false.
+         */
+        void clear();
+
+        /**
+         * Sets the bit specified by the index to false.
+         *
+         * @param index
+         *      The index of the bit whose value is to be set to false
+         *
+         * @throws IndexOutOfBoundsException if the index value is negative.
+         */
+        void clear(int index);
+
+        /**
+         * Sets the bits from the specified fromIndex (inclusive) to the specified toIndex
+         * (exclusive) to false.
+         *
+         * @param fromIndex
+         *      The index (inclusive) to start setting bits to false.
+         * @param toIndex
+         *      The index (exclusive) to stop setting bits to false.
+         *
+         * @throws IndexOutOfBoundsException if fromIndex is negative, or toIndex is negative, or
+         *                                   fromIndex is larger than toIndex.
+         */
+        void clear(int fromIndex, int toIndex);
+
+        /**
+         * Compares this object against the specified object. The result is true if and only if
+         * is a Bitset object that has exactly the same set of bits set to true as this bit set.
+         * That is, for every nonnegative int index k,
+         *
+         *   set.get(k) == this->get(k)
+         *
+         * must be true. The current sizes of the two bit sets are not compared.
+         *
+         * @returns true if the sets are the same, false otherwise.
+         */
+        bool equals(const BitSet& set) const;
+
+        /**
+         * Sets the bit at the specified index to the complement of its current value.
+         *
+         * @param index
+         *      The index of the bit whose value is to be set to its compliment.
+         *
+         * @throws IndexOutOfBoundsException if the index value is negative.
+         */
+        void flip(int index);
+
+        /**
+         * Sets each bit from the specified fromIndex (inclusive) to the specified toIndex
+         * (exclusive) to the complement of its current value.
+         *
+         * @param fromIndex
+         *      The index (inclusive) to start setting bits to its compliment.
+         * @param toIndex
+         *      The index (exclusive) to stop setting bits to its compliment.
+         *
+         * @throws IndexOutOfBoundsException if fromIndex is negative, or toIndex is negative, or
+         *                                   fromIndex is larger than toIndex.
+         */
+        void flip(int fromIndex, int toIndex);
+
+        /**
+         * Returns the value of the bit with the specified index. The value is true if the bit
+         * with the given index is currently set in this BitSet; otherwise, the result is false.
+         *
+         * @param index
+         *      The index of the bit in question.
+         *
+         * @returns the value of the bit with the specified index.
+         *
+         * @throws IndexOutOfBoundsException if the index value is negative.
+         */
+        bool get(int index) const;
+
+        /**
+         * Returns a new BitSet composed of bits from this BitSet from fromIndex (inclusive) to
+         * toIndex (exclusive).
+         *
+         * @param fromIndex
+         *      The index (inclusive) to start at.
+         * @param toIndex
+         *      The index (exclusive) to stop at.
+         *
+         * @returns a new BitSet containing the specified values.
+         *
+         * @throws IndexOutOfBoundsException if fromIndex is negative, or toIndex is negative, or
+         *                                   fromIndex is larger than toIndex.
+         */
+        BitSet get(int fromIndex, int toIndex) const;
+
+        /**
+         * Returns true if the specified BitSet has any bits set to true that are also set to
+         * true in this BitSet.
+         *
+         * @param set
+         *      BitSet to intersect with.
+         *
+         * @returns boolean indicating whether this BitSet intersects the specified BitSet.
+         */
+        bool intersects(const BitSet& set) const;
+
+        /**
+         * Returns true if this BitSet contains no bits that are set to true.
+         *
+         * @returns true if the set is empty, false otherwise.
+         */
+        bool isEmpty() const;
+
+        /**
+         * Returns the "logical size" of this BitSet: the index of the highest set bit in the
+         * BitSet plus one. Returns zero if the BitSet contains no set bits.
+         *
+         * @returns the logical size of the BitSet.
+         */
+        int length() const;
+
+        /**
+         * Returns the index of the first bit that is set to false that occurs on or after the
+         * specified starting index.
+         *
+         * @param index
+         *      The index to start the search from (inclusive).
+         *
+         * @returns the index of the next clear bit.
+         *
+         * @throws IndexOutOfBoundsException if the index value is negative.
+         */
+        int nextClearBit(int index) const;
+
+        /**
+         * Returns the index of the first bit that is set to true that occurs on or after the
+         * specified starting index.
+         *
+         * @param index
+         *      The index to start the search from (inclusive).
+         *
+         * @returns the index of the next set bit.
+         *
+         * @throws IndexOutOfBoundsException if the index value is negative.
+         */
+        int nextSetBit(int index) const;
+
+        /**
+         * Sets the bit at the specified index to true.
+         *
+         * @param index
+         *      The index to set to true.
+         *
+         * @throws IndexOutOfBoundsException if the index value is negative.
+         */
+        void set(int index);
+
+        /**
+         * Sets the bit at the specified index to the specified value.
+         *
+         * @param index
+         *      The index to set.
+         * @param value
+         *      The value to assign to the given bit.
+         *
+         * @throws IndexOutOfBoundsException if the index value is negative.
+         */
+        void set(int index, bool value);
+
+        /**
+         * Sets the bits from the specified fromIndex (inclusive) to the specified toIndex
+         * (exclusive) to true.
+         *
+         * @param fromIndex
+         *      The index (inclusive) to start at.
+         * @param toIndex
+         *      The index (exclusive) to stop at.
+         *
+         * @throws IndexOutOfBoundsException if fromIndex is negative, or toIndex is negative, or
+         *                                   fromIndex is larger than toIndex.
+         */
+        void set(int fromIndex, int toIndex);
+
+        /**
+         * Sets the bits from the specified fromIndex (inclusive) to the specified toIndex
+         * (exclusive) to the value given.
+         *
+         * @param fromIndex
+         *      The index (inclusive) to start at.
+         * @param toIndex
+         *      The index (exclusive) to stop at.
+         * @param value
+         *      The boolean value to assign to the target bits.
+         *
+         * @throws IndexOutOfBoundsException if fromIndex is negative, or toIndex is negative, or
+         *                                   fromIndex is larger than toIndex.
+         */
+        void set(int fromIndex, int toIndex, bool value);
+
+        /**
+         * Returns the number of bits of space actually in use by this BitSet to represent bit
+         * values. The maximum element in the set is the size - 1st element.
+         *
+         * @returns the number of bits currently in this bit set.
+         */
+        int size() const;
+
+        /**
+         * Returns a string representation of this bit set. For every index for which this BitSet
+         * contains a bit in the set state, the decimal representation of that index is included
+         * in the result. Such indices are listed in order from lowest to highest, separated by
+         * ", " (a comma and a space) and surrounded by braces, resulting in the usual mathematical
+         * notation for a set of integers.
+         *
+         * @returns string representation of the BitSet.
+         */
+        std::string toString() const;
+
+        /**
+         * Performs a logical XOR of this bit set with the bit set argument. This bit set is modified
+         * so that a bit in it has the value true if and only if one of the following statements holds:
+         *
+         *   * The bit initially has the value true, and the corresponding bit in the argument has
+         *     the value false.
+         *   * The bit initially has the value false, and the corresponding bit in the argument has
+         *     the value true.
+         *
+         * @param set
+         *      The BitSet to use.
+         */
+        void XOR(const BitSet& set);
+
+    private:
+
+        /**
+         * Increase the size of the internal array to accommodate length bits.
+         * The new array max index will be a multiple of 64.
+         *
+         * @param length
+         *      the index the new array needs to be able to access.
+         */
+        void ensureCapacity(int length);
+
+        /**
+         * Gets the actual length of the BitSet bit array which is maintained in a
+         * sometimes lazy fashion to avoid excessive array traversals.  The actual
+         * length is the number of non-zero array elements in the physical array
+         * used to back this BitSet.
+         *
+         * @return the actual array length.
+         */
+        int getActualArrayLength() const;
+
+    };
+
+}}
+
+#endif /* _DECAF_UTIL_BITSET_H_ */

Propchange: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/BitSet.h
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/Config.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/Config.h?rev=1360895&r1=1360894&r2=1360895&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/Config.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/Config.h Thu Jul 12 19:59:01 2012
@@ -29,6 +29,10 @@
 #define DECAF_API
 #endif
 
+#ifndef NULL
+#define NULL 0
+#endif
+
 //
 // The purpose of this header is to try to detect the supported headers
 // of the platform when the ./configure script is not being used to generate

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/test/Makefile.am
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/test/Makefile.am?rev=1360895&r1=1360894&r2=1360895&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/test/Makefile.am (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/test/Makefile.am Thu Jul 12 19:59:01 2012
@@ -193,6 +193,7 @@ cc_sources = \
     decaf/util/AbstractSequentialListTest.cpp \
     decaf/util/ArrayListTest.cpp \
     decaf/util/ArraysTest.cpp \
+    decaf/util/BitSetTest.cpp \
     decaf/util/DateTest.cpp \
     decaf/util/Endian.cpp \
     decaf/util/LinkedListTest.cpp \
@@ -426,6 +427,7 @@ h_sources = \
     decaf/util/AbstractSequentialListTest.h \
     decaf/util/ArrayListTest.h \
     decaf/util/ArraysTest.h \
+    decaf/util/BitSetTest.h \
     decaf/util/DateTest.h \
     decaf/util/Endian.h \
     decaf/util/LinkedListTest.h \



Mime
View raw message