activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tab...@apache.org
Subject svn commit: r960088 [3/9] - in /activemq/activemq-cpp/trunk/activemq-cpp/src/main: activemq/cmsutil/ activemq/commands/ activemq/core/ activemq/io/ activemq/transport/failover/ activemq/transport/mock/ activemq/wireformat/stomp/ decaf/internal/io/ deca...
Date Fri, 02 Jul 2010 19:04:50 GMT
Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/FloatArrayBuffer.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/FloatArrayBuffer.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/FloatArrayBuffer.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/FloatArrayBuffer.cpp Fri Jul  2 19:04:44 2010
@@ -26,8 +26,7 @@ using namespace decaf::internal::util;
 using namespace decaf::nio;
 
 ///////////////////////////////////////////////////////////////////////////////
-FloatArrayBuffer::FloatArrayBuffer( int size, bool readOnly )
-    throw( decaf::lang::exceptions::IllegalArgumentException ) : FloatBuffer( size ){
+FloatArrayBuffer::FloatArrayBuffer( int size, bool readOnly ) : FloatBuffer( size ){
 
     // Allocate using the ByteArray, not read-only initially.  Take a reference to it.
     // The capacity is the given capacity times the size of the stored datatype
@@ -38,9 +37,8 @@ FloatArrayBuffer::FloatArrayBuffer( int 
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-FloatArrayBuffer::FloatArrayBuffer( float* array, int size, int offset, int length, bool readOnly )
-    throw( decaf::lang::exceptions::IndexOutOfBoundsException,
-           decaf::lang::exceptions::NullPointerException ) : FloatBuffer( length ) {
+FloatArrayBuffer::FloatArrayBuffer( float* array, int size, int offset, int length, bool readOnly ) :
+    FloatBuffer( length ) {
 
     try{
 
@@ -68,9 +66,7 @@ FloatArrayBuffer::FloatArrayBuffer( floa
 
 ///////////////////////////////////////////////////////////////////////////////
 FloatArrayBuffer::FloatArrayBuffer( const Pointer<ByteArrayAdapter>& array,
-                                    int offset, int length, bool readOnly )
-    throw( decaf::lang::exceptions::IndexOutOfBoundsException,
-           decaf::lang::exceptions::NullPointerException ) : FloatBuffer( length ) {
+                                    int offset, int length, bool readOnly ) : FloatBuffer( length ) {
 
     try{
 
@@ -117,9 +113,7 @@ FloatArrayBuffer::~FloatArrayBuffer() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-float* FloatArrayBuffer::array()
-    throw( decaf::lang::exceptions::UnsupportedOperationException,
-           decaf::nio::ReadOnlyBufferException ) {
+float* FloatArrayBuffer::array() {
 
     try{
 
@@ -144,9 +138,7 @@ float* FloatArrayBuffer::array()
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-int FloatArrayBuffer::arrayOffset()
-    throw( decaf::lang::exceptions::UnsupportedOperationException,
-           decaf::nio::ReadOnlyBufferException ) {
+int FloatArrayBuffer::arrayOffset() {
 
     try{
 
@@ -185,7 +177,7 @@ FloatBuffer* FloatArrayBuffer::asReadOnl
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-FloatBuffer& FloatArrayBuffer::compact() throw( decaf::nio::ReadOnlyBufferException ) {
+FloatBuffer& FloatArrayBuffer::compact() {
 
     try{
 
@@ -223,7 +215,7 @@ FloatBuffer* FloatArrayBuffer::duplicate
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-float FloatArrayBuffer::get() throw ( decaf::nio::BufferUnderflowException ) {
+float FloatArrayBuffer::get() {
 
     try{
         return this->get( this->_position++ );
@@ -234,8 +226,7 @@ float FloatArrayBuffer::get() throw ( de
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-float FloatArrayBuffer::get( int index ) const
-    throw ( lang::exceptions::IndexOutOfBoundsException ) {
+float FloatArrayBuffer::get( int index ) const {
 
     try{
 
@@ -253,8 +244,7 @@ float FloatArrayBuffer::get( int index )
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-FloatBuffer& FloatArrayBuffer::put( float value )
-    throw( BufferOverflowException, ReadOnlyBufferException ) {
+FloatBuffer& FloatArrayBuffer::put( float value ) {
 
     try{
 
@@ -268,9 +258,7 @@ FloatBuffer& FloatArrayBuffer::put( floa
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-FloatBuffer& FloatArrayBuffer::put( int index, float value )
-    throw( decaf::lang::exceptions::IndexOutOfBoundsException,
-           decaf::nio::ReadOnlyBufferException ) {
+FloatBuffer& FloatArrayBuffer::put( int index, float value ) {
 
     try{
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/FloatArrayBuffer.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/FloatArrayBuffer.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/FloatArrayBuffer.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/FloatArrayBuffer.h Fri Jul  2 19:04:44 2010
@@ -63,8 +63,7 @@ namespace nio{
          *
          * @throws IllegalArguementException if the capacity value is negative.
          */
-        FloatArrayBuffer( int size, bool readOnly = false )
-            throw( decaf::lang::exceptions::IllegalArgumentException );
+        FloatArrayBuffer( int size, bool readOnly = false );
 
         /**
          * Creates a FloatArrayBuffer object that wraps the given array.  If the own flag
@@ -84,9 +83,7 @@ namespace nio{
          * @throws NullPointerException if buffer is NULL
          * @throws IndexOutOfBoundsException if offset is greater than array capacity.
          */
-        FloatArrayBuffer( float* array, int size, int offset, int length, bool readOnly = false )
-            throw( decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IndexOutOfBoundsException );
+        FloatArrayBuffer( float* array, int size, int offset, int length, bool readOnly = false );
 
         /**
          * Creates a byte buffer that wraps the passed ByteArrayAdapter and
@@ -106,9 +103,7 @@ namespace nio{
          * @throws IndexOutOfBoundsException if offset + length is greater than array size.
          */
         FloatArrayBuffer( const decaf::lang::Pointer<ByteArrayAdapter>& array, int offset, int capacity,
-                          bool readOnly = false )
-            throw( decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IndexOutOfBoundsException );
+                          bool readOnly = false );
 
         /**
          * Create a FloatArrayBuffer that mirrors this one, meaning it shares a
@@ -127,16 +122,12 @@ namespace nio{
         /**
          * {@inheritDoc}
          */
-        virtual float* array()
-            throw( decaf::lang::exceptions::UnsupportedOperationException,
-                   decaf::nio::ReadOnlyBufferException );
+        virtual float* array();
 
         /**
          * {@inheritDoc}
          */
-        virtual int arrayOffset()
-            throw( decaf::lang::exceptions::UnsupportedOperationException,
-                   decaf::nio::ReadOnlyBufferException );
+        virtual int arrayOffset();
 
         /**
          * {@inheritDoc}
@@ -146,7 +137,7 @@ namespace nio{
         /**
          * {@inheritDoc}
          */
-        virtual FloatBuffer& compact() throw( decaf::nio::ReadOnlyBufferException );
+        virtual FloatBuffer& compact();
 
         /**
          * {@inheritDoc}
@@ -156,13 +147,12 @@ namespace nio{
         /**
          * {@inheritDoc}
          */
-        virtual float get() throw ( decaf::nio::BufferUnderflowException );
+        virtual float get();
 
         /**
          * {@inheritDoc}
          */
-        virtual float get( int index ) const
-            throw ( lang::exceptions::IndexOutOfBoundsException );
+        virtual float get( int index ) const;
 
         /**
          * {@inheritDoc}
@@ -179,16 +169,12 @@ namespace nio{
         /**
          * {@inheritDoc}
          */
-        virtual FloatBuffer& put( float value )
-            throw( decaf::nio::BufferOverflowException,
-                   decaf::nio::ReadOnlyBufferException );
+        virtual FloatBuffer& put( float value );
 
         /**
          * {@inheritDoc}
          */
-        virtual FloatBuffer& put( int index, float value )
-            throw( lang::exceptions::IndexOutOfBoundsException,
-                   decaf::nio::ReadOnlyBufferException );
+        virtual FloatBuffer& put( int index, float value );
 
         /**
          * {@inheritDoc}

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/IntArrayBuffer.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/IntArrayBuffer.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/IntArrayBuffer.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/IntArrayBuffer.cpp Fri Jul  2 19:04:44 2010
@@ -26,8 +26,7 @@ using namespace decaf::internal::util;
 using namespace decaf::nio;
 
 ///////////////////////////////////////////////////////////////////////////////
-IntArrayBuffer::IntArrayBuffer( int size, bool readOnly )
-    throw( decaf::lang::exceptions::IllegalArgumentException ) : IntBuffer( size ){
+IntArrayBuffer::IntArrayBuffer( int size, bool readOnly ) : IntBuffer( size ){
 
     // Allocate using the ByteArray, not read-only initially.  Take a reference to it.
     // The size is the given size times the size of the stored datatype
@@ -38,9 +37,8 @@ IntArrayBuffer::IntArrayBuffer( int size
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-IntArrayBuffer::IntArrayBuffer( int* array, int size, int offset, int length, bool readOnly )
-    throw( decaf::lang::exceptions::IndexOutOfBoundsException,
-           decaf::lang::exceptions::NullPointerException ) : IntBuffer( length ) {
+IntArrayBuffer::IntArrayBuffer( int* array, int size, int offset, int length, bool readOnly ) :
+    IntBuffer( length ) {
 
     try{
 
@@ -68,9 +66,7 @@ IntArrayBuffer::IntArrayBuffer( int* arr
 
 ///////////////////////////////////////////////////////////////////////////////
 IntArrayBuffer::IntArrayBuffer( const Pointer<ByteArrayAdapter>& array,
-                                int offset, int length, bool readOnly )
-    throw( decaf::lang::exceptions::IndexOutOfBoundsException,
-           decaf::lang::exceptions::NullPointerException ) : IntBuffer( length ) {
+                                int offset, int length, bool readOnly ) : IntBuffer( length ) {
 
     try{
 
@@ -117,9 +113,7 @@ IntArrayBuffer::~IntArrayBuffer() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-int* IntArrayBuffer::array()
-    throw( decaf::lang::exceptions::UnsupportedOperationException,
-           decaf::nio::ReadOnlyBufferException ) {
+int* IntArrayBuffer::array() {
 
     try{
 
@@ -144,9 +138,7 @@ int* IntArrayBuffer::array()
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-int IntArrayBuffer::arrayOffset()
-    throw( decaf::lang::exceptions::UnsupportedOperationException,
-           decaf::nio::ReadOnlyBufferException ) {
+int IntArrayBuffer::arrayOffset() {
 
     try{
 
@@ -185,7 +177,7 @@ IntBuffer* IntArrayBuffer::asReadOnlyBuf
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-IntBuffer& IntArrayBuffer::compact() throw( decaf::nio::ReadOnlyBufferException ) {
+IntBuffer& IntArrayBuffer::compact() {
 
     try{
 
@@ -223,7 +215,7 @@ IntBuffer* IntArrayBuffer::duplicate() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-int IntArrayBuffer::get() throw ( decaf::nio::BufferUnderflowException ) {
+int IntArrayBuffer::get() {
 
     try{
         return this->get( this->_position++ );
@@ -234,8 +226,7 @@ int IntArrayBuffer::get() throw ( decaf:
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-int IntArrayBuffer::get( int index ) const
-    throw ( lang::exceptions::IndexOutOfBoundsException ) {
+int IntArrayBuffer::get( int index ) const {
 
     try{
 
@@ -253,8 +244,7 @@ int IntArrayBuffer::get( int index ) con
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-IntBuffer& IntArrayBuffer::put( int value )
-    throw( BufferOverflowException, ReadOnlyBufferException ) {
+IntBuffer& IntArrayBuffer::put( int value ) {
 
     try{
 
@@ -268,9 +258,7 @@ IntBuffer& IntArrayBuffer::put( int valu
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-IntBuffer& IntArrayBuffer::put( int index, int value )
-    throw( decaf::lang::exceptions::IndexOutOfBoundsException,
-           decaf::nio::ReadOnlyBufferException ) {
+IntBuffer& IntArrayBuffer::put( int index, int value ) {
 
     try{
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/IntArrayBuffer.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/IntArrayBuffer.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/IntArrayBuffer.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/IntArrayBuffer.h Fri Jul  2 19:04:44 2010
@@ -63,8 +63,7 @@ namespace nio{
          *
          * @throws IllegalArguementException if the capacity value is negative.
          */
-        IntArrayBuffer( int size, bool readOnly = false )
-            throw( decaf::lang::exceptions::IllegalArgumentException );
+        IntArrayBuffer( int size, bool readOnly = false );
 
         /**
          * Creates a IntArrayBuffer object that wraps the given array.  If the own flag
@@ -84,9 +83,7 @@ namespace nio{
          * @throws NullPointerException if buffer is NULL
          * @throws IndexOutOfBoundsException if offset is greater than array capacity.
          */
-        IntArrayBuffer( int* array, int size, int offset, int length, bool readOnly = false )
-            throw( decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IndexOutOfBoundsException );
+        IntArrayBuffer( int* array, int size, int offset, int length, bool readOnly = false );
 
         /**
          * Creates a byte buffer that wraps the passed ByteArrayAdapter and
@@ -106,9 +103,7 @@ namespace nio{
          * @throws IndexOutOfBoundsException if offset + length is greater than array size.
          */
         IntArrayBuffer( const decaf::lang::Pointer<ByteArrayAdapter>& array, int offset, int length,
-                        bool readOnly = false )
-            throw( decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IndexOutOfBoundsException );
+                        bool readOnly = false );
 
         /**
          * Create a IntArrayBuffer that mirrors this one, meaning it shares a
@@ -127,16 +122,12 @@ namespace nio{
         /**
          * {@inheritDoc}
          */
-        virtual int* array()
-            throw( decaf::lang::exceptions::UnsupportedOperationException,
-                   decaf::nio::ReadOnlyBufferException );
+        virtual int* array();
 
         /**
          * {@inheritDoc}
          */
-        virtual int arrayOffset()
-            throw( decaf::lang::exceptions::UnsupportedOperationException,
-                   decaf::nio::ReadOnlyBufferException );
+        virtual int arrayOffset();
 
         /**
          * {@inheritDoc}
@@ -146,7 +137,7 @@ namespace nio{
         /**
          * {@inheritDoc}
          */
-        virtual IntBuffer& compact() throw( decaf::nio::ReadOnlyBufferException );
+        virtual IntBuffer& compact();
 
         /**
          * {@inheritDoc}
@@ -156,13 +147,12 @@ namespace nio{
         /**
          * {@inheritDoc}
          */
-        virtual int get() throw ( decaf::nio::BufferUnderflowException );
+        virtual int get();
 
         /**
          * {@inheritDoc}
          */
-        virtual int get( int index ) const
-            throw ( lang::exceptions::IndexOutOfBoundsException );
+        virtual int get( int index ) const;
 
         /**
          * {@inheritDoc}
@@ -179,16 +169,12 @@ namespace nio{
         /**
          * {@inheritDoc}
          */
-        virtual IntBuffer& put( int value )
-            throw( decaf::nio::BufferOverflowException,
-                   decaf::nio::ReadOnlyBufferException );
+        virtual IntBuffer& put( int value );
 
         /**
          * {@inheritDoc}
          */
-        virtual IntBuffer& put( int index, int value )
-            throw( lang::exceptions::IndexOutOfBoundsException,
-                   decaf::nio::ReadOnlyBufferException );
+        virtual IntBuffer& put( int index, int value );
 
         /**
          * {@inheritDoc}

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/LongArrayBuffer.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/LongArrayBuffer.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/LongArrayBuffer.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/LongArrayBuffer.cpp Fri Jul  2 19:04:44 2010
@@ -26,8 +26,7 @@ using namespace decaf::internal::util;
 using namespace decaf::nio;
 
 ///////////////////////////////////////////////////////////////////////////////
-LongArrayBuffer::LongArrayBuffer( int size, bool readOnly )
-    throw( decaf::lang::exceptions::IllegalArgumentException ) : LongBuffer( size ){
+LongArrayBuffer::LongArrayBuffer( int size, bool readOnly ) : LongBuffer( size ){
 
     // Allocate using the ByteArray, not read-only initially.  Take a reference to it.
     // The capacity is the given capacity times the size of the stored datatype
@@ -38,9 +37,8 @@ LongArrayBuffer::LongArrayBuffer( int si
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-LongArrayBuffer::LongArrayBuffer( long long* array, int size, int offset, int length, bool readOnly )
-    throw( decaf::lang::exceptions::IndexOutOfBoundsException,
-           decaf::lang::exceptions::NullPointerException ) : LongBuffer( length ) {
+LongArrayBuffer::LongArrayBuffer( long long* array, int size, int offset, int length, bool readOnly ) :
+    LongBuffer( length ) {
 
     try{
 
@@ -68,9 +66,7 @@ LongArrayBuffer::LongArrayBuffer( long l
 
 ///////////////////////////////////////////////////////////////////////////////
 LongArrayBuffer::LongArrayBuffer( const Pointer<ByteArrayAdapter>& array,
-                                  int offset, int length, bool readOnly )
-    throw( decaf::lang::exceptions::IndexOutOfBoundsException,
-           decaf::lang::exceptions::NullPointerException ) : LongBuffer( length ) {
+                                  int offset, int length, bool readOnly ) : LongBuffer( length ) {
 
     try{
 
@@ -117,9 +113,7 @@ LongArrayBuffer::~LongArrayBuffer() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-long long* LongArrayBuffer::array()
-    throw( decaf::lang::exceptions::UnsupportedOperationException,
-           decaf::nio::ReadOnlyBufferException ) {
+long long* LongArrayBuffer::array() {
 
     try{
 
@@ -144,9 +138,7 @@ long long* LongArrayBuffer::array()
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-int LongArrayBuffer::arrayOffset()
-    throw( decaf::lang::exceptions::UnsupportedOperationException,
-           decaf::nio::ReadOnlyBufferException ) {
+int LongArrayBuffer::arrayOffset() {
 
     try{
 
@@ -185,7 +177,7 @@ LongBuffer* LongArrayBuffer::asReadOnlyB
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-LongBuffer& LongArrayBuffer::compact() throw( decaf::nio::ReadOnlyBufferException ) {
+LongBuffer& LongArrayBuffer::compact() {
 
     try{
 
@@ -223,7 +215,7 @@ LongBuffer* LongArrayBuffer::duplicate()
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-long long LongArrayBuffer::get() throw ( decaf::nio::BufferUnderflowException ) {
+long long LongArrayBuffer::get() {
 
     try{
         return this->get( this->_position++ );
@@ -234,8 +226,7 @@ long long LongArrayBuffer::get() throw (
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-long long LongArrayBuffer::get( int index ) const
-    throw ( lang::exceptions::IndexOutOfBoundsException ) {
+long long LongArrayBuffer::get( int index ) const {
 
     try{
 
@@ -253,8 +244,7 @@ long long LongArrayBuffer::get( int inde
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-LongBuffer& LongArrayBuffer::put( long long value )
-    throw( BufferOverflowException, ReadOnlyBufferException ) {
+LongBuffer& LongArrayBuffer::put( long long value ) {
 
     try{
 
@@ -268,9 +258,7 @@ LongBuffer& LongArrayBuffer::put( long l
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-LongBuffer& LongArrayBuffer::put( int index, long long value )
-    throw( decaf::lang::exceptions::IndexOutOfBoundsException,
-           decaf::nio::ReadOnlyBufferException ) {
+LongBuffer& LongArrayBuffer::put( int index, long long value ) {
 
     try{
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/LongArrayBuffer.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/LongArrayBuffer.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/LongArrayBuffer.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/LongArrayBuffer.h Fri Jul  2 19:04:44 2010
@@ -63,8 +63,7 @@ namespace nio{
          *
          * @throws IllegalArguementException if the capacity value is negative.
          */
-        LongArrayBuffer( int size, bool readOnly = false )
-            throw( decaf::lang::exceptions::IllegalArgumentException );
+        LongArrayBuffer( int size, bool readOnly = false );
 
         /**
          * Creates a LongArrayBuffer object that wraps the given array.  If the own flag
@@ -84,9 +83,7 @@ namespace nio{
          * @throws NullPointerException if buffer is NULL
          * @throws IndexOutOfBoundsException if offset is greater than array capacity.
          */
-        LongArrayBuffer( long long* array, int size, int offset, int length, bool readOnly = false )
-            throw( decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IndexOutOfBoundsException );
+        LongArrayBuffer( long long* array, int size, int offset, int length, bool readOnly = false );
 
         /**
          * Creates a byte buffer that wraps the passed ByteArrayAdapter and
@@ -106,9 +103,7 @@ namespace nio{
          * @throws IndexOutOfBoundsException if offset + length is greater than array size.
          */
         LongArrayBuffer( const decaf::lang::Pointer<ByteArrayAdapter>& array, int offset, int length,
-                         bool readOnly = false )
-            throw( decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IndexOutOfBoundsException );
+                         bool readOnly = false );
 
         /**
          * Create a LongArrayBuffer that mirrors this one, meaning it shares a
@@ -127,16 +122,12 @@ namespace nio{
         /**
          * {@inheritDoc}
          */
-        virtual long long* array()
-            throw( decaf::lang::exceptions::UnsupportedOperationException,
-                   decaf::nio::ReadOnlyBufferException );
+        virtual long long* array();
 
         /**
          * {@inheritDoc}
          */
-        virtual int arrayOffset()
-            throw( decaf::lang::exceptions::UnsupportedOperationException,
-                   decaf::nio::ReadOnlyBufferException );
+        virtual int arrayOffset();
 
         /**
          * {@inheritDoc}
@@ -146,7 +137,7 @@ namespace nio{
         /**
          * {@inheritDoc}
          */
-        virtual LongBuffer& compact() throw( decaf::nio::ReadOnlyBufferException );
+        virtual LongBuffer& compact();
 
         /**
          * {@inheritDoc}
@@ -156,13 +147,12 @@ namespace nio{
         /**
          * {@inheritDoc}
          */
-        virtual long long get() throw ( decaf::nio::BufferUnderflowException );
+        virtual long long get();
 
         /**
          * {@inheritDoc}
          */
-        virtual long long get( int index ) const
-            throw ( lang::exceptions::IndexOutOfBoundsException );
+        virtual long long get( int index ) const;
 
         /**
          * {@inheritDoc}
@@ -179,16 +169,12 @@ namespace nio{
         /**
          * {@inheritDoc}
          */
-        virtual LongBuffer& put( long long value )
-            throw( decaf::nio::BufferOverflowException,
-                   decaf::nio::ReadOnlyBufferException );
+        virtual LongBuffer& put( long long value );
 
         /**
          * {@inheritDoc}
          */
-        virtual LongBuffer& put( int index, long long value )
-            throw( lang::exceptions::IndexOutOfBoundsException,
-                   decaf::nio::ReadOnlyBufferException );
+        virtual LongBuffer& put( int index, long long value );
 
         /**
          * {@inheritDoc}

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/ShortArrayBuffer.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/ShortArrayBuffer.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/ShortArrayBuffer.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/ShortArrayBuffer.cpp Fri Jul  2 19:04:44 2010
@@ -26,8 +26,7 @@ using namespace decaf::internal::util;
 using namespace decaf::nio;
 
 ///////////////////////////////////////////////////////////////////////////////
-ShortArrayBuffer::ShortArrayBuffer( int size, bool readOnly )
-    throw( decaf::lang::exceptions::IllegalArgumentException ) : ShortBuffer( size ){
+ShortArrayBuffer::ShortArrayBuffer( int size, bool readOnly ) : ShortBuffer( size ){
 
     // Allocate using the ByteArray, not read-only initially.  Take a reference to it.
     // The capacity is the given capacity times the size of the stored datatype
@@ -38,9 +37,8 @@ ShortArrayBuffer::ShortArrayBuffer( int 
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-ShortArrayBuffer::ShortArrayBuffer( short* array, int size, int offset, int length, bool readOnly )
-    throw( decaf::lang::exceptions::IndexOutOfBoundsException,
-           decaf::lang::exceptions::NullPointerException ) : ShortBuffer( length ) {
+ShortArrayBuffer::ShortArrayBuffer( short* array, int size, int offset, int length, bool readOnly ) :
+    ShortBuffer( length ) {
 
     try{
 
@@ -68,9 +66,7 @@ ShortArrayBuffer::ShortArrayBuffer( shor
 
 ///////////////////////////////////////////////////////////////////////////////
 ShortArrayBuffer::ShortArrayBuffer( const Pointer<ByteArrayAdapter>& array,
-                                    int offset, int length, bool readOnly )
-    throw( decaf::lang::exceptions::IndexOutOfBoundsException,
-           decaf::lang::exceptions::NullPointerException ) : ShortBuffer( length ) {
+                                    int offset, int length, bool readOnly ) : ShortBuffer( length ) {
 
     try{
 
@@ -117,9 +113,7 @@ ShortArrayBuffer::~ShortArrayBuffer() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-short* ShortArrayBuffer::array()
-    throw( decaf::lang::exceptions::UnsupportedOperationException,
-           decaf::nio::ReadOnlyBufferException ) {
+short* ShortArrayBuffer::array() {
 
     try{
 
@@ -144,9 +138,7 @@ short* ShortArrayBuffer::array()
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-int ShortArrayBuffer::arrayOffset()
-    throw( decaf::lang::exceptions::UnsupportedOperationException,
-           decaf::nio::ReadOnlyBufferException ) {
+int ShortArrayBuffer::arrayOffset() {
 
     try{
 
@@ -185,7 +177,7 @@ ShortBuffer* ShortArrayBuffer::asReadOnl
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-ShortBuffer& ShortArrayBuffer::compact() throw( decaf::nio::ReadOnlyBufferException ) {
+ShortBuffer& ShortArrayBuffer::compact() {
 
     try{
 
@@ -223,7 +215,7 @@ ShortBuffer* ShortArrayBuffer::duplicate
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-short ShortArrayBuffer::get() throw ( decaf::nio::BufferUnderflowException ) {
+short ShortArrayBuffer::get() {
 
     try{
         return this->get( this->_position++ );
@@ -234,8 +226,7 @@ short ShortArrayBuffer::get() throw ( de
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-short ShortArrayBuffer::get( int index ) const
-    throw ( lang::exceptions::IndexOutOfBoundsException ) {
+short ShortArrayBuffer::get( int index ) const {
 
     try{
 
@@ -253,8 +244,7 @@ short ShortArrayBuffer::get( int index )
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ShortBuffer& ShortArrayBuffer::put( short value )
-    throw( BufferOverflowException, ReadOnlyBufferException ) {
+ShortBuffer& ShortArrayBuffer::put( short value ) {
 
     try{
 
@@ -268,9 +258,7 @@ ShortBuffer& ShortArrayBuffer::put( shor
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ShortBuffer& ShortArrayBuffer::put( int index, short value )
-    throw( decaf::lang::exceptions::IndexOutOfBoundsException,
-           decaf::nio::ReadOnlyBufferException ) {
+ShortBuffer& ShortArrayBuffer::put( int index, short value ) {
 
     try{
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/ShortArrayBuffer.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/ShortArrayBuffer.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/ShortArrayBuffer.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/nio/ShortArrayBuffer.h Fri Jul  2 19:04:44 2010
@@ -63,8 +63,7 @@ namespace nio{
          *
          * @throws IllegalArguementException if the capacity value is negative.
          */
-        ShortArrayBuffer( int size, bool readOnly = false )
-            throw( decaf::lang::exceptions::IllegalArgumentException );
+        ShortArrayBuffer( int size, bool readOnly = false );
 
         /**
          * Creates a ShortArrayBuffer object that wraps the given array.  If the own flag
@@ -84,9 +83,7 @@ namespace nio{
          * @throws NullPointerException if buffer is NULL
          * @throws IndexOutOfBoundsException if offset is greater than array capacity.
          */
-        ShortArrayBuffer( short* array, int size, int offset, int length, bool readOnly = false )
-            throw( decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IndexOutOfBoundsException );
+        ShortArrayBuffer( short* array, int size, int offset, int length, bool readOnly = false );
 
         /**
          * Creates a byte buffer that wraps the passed ByteArrayAdapter and
@@ -106,9 +103,7 @@ namespace nio{
          * @throws IndexOutOfBoundsException if offset + length is greater than array size.
          */
         ShortArrayBuffer( const decaf::lang::Pointer<ByteArrayAdapter>& array, int offset, int length,
-                          bool readOnly = false )
-            throw( decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IndexOutOfBoundsException );
+                          bool readOnly = false );
 
         /**
          * Create a ShortArrayBuffer that mirrors this one, meaning it shares a
@@ -127,16 +122,12 @@ namespace nio{
         /**
          * {@inheritDoc}
          */
-        virtual short* array()
-            throw( decaf::lang::exceptions::UnsupportedOperationException,
-                   decaf::nio::ReadOnlyBufferException );
+        virtual short* array();
 
         /**
          * {@inheritDoc}
          */
-        virtual int arrayOffset()
-            throw( decaf::lang::exceptions::UnsupportedOperationException,
-                   decaf::nio::ReadOnlyBufferException );
+        virtual int arrayOffset();
 
         /**
          * {@inheritDoc}
@@ -146,7 +137,7 @@ namespace nio{
         /**
          * {@inheritDoc}
          */
-        virtual ShortBuffer& compact() throw( decaf::nio::ReadOnlyBufferException );
+        virtual ShortBuffer& compact();
 
         /**
          * {@inheritDoc}
@@ -156,13 +147,12 @@ namespace nio{
         /**
          * {@inheritDoc}
          */
-        virtual short get() throw ( decaf::nio::BufferUnderflowException );
+        virtual short get();
 
         /**
          * {@inheritDoc}
          */
-        virtual short get( int index ) const
-            throw ( lang::exceptions::IndexOutOfBoundsException );
+        virtual short get( int index ) const;
 
         /**
          * {@inheritDoc}
@@ -179,16 +169,12 @@ namespace nio{
         /**
          * {@inheritDoc}
          */
-        virtual ShortBuffer& put( short value )
-            throw( decaf::nio::BufferOverflowException,
-                   decaf::nio::ReadOnlyBufferException );
+        virtual ShortBuffer& put( short value );
 
         /**
          * {@inheritDoc}
          */
-        virtual ShortBuffer& put( int index, short value )
-            throw( lang::exceptions::IndexOutOfBoundsException,
-                   decaf::nio::ReadOnlyBufferException );
+        virtual ShortBuffer& put( int index, short value );
 
         /**
          * {@inheritDoc}

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/ByteArrayAdapter.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/ByteArrayAdapter.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/ByteArrayAdapter.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/ByteArrayAdapter.cpp Fri Jul  2 19:04:44 2010
@@ -31,8 +31,7 @@ using namespace decaf::lang;
 using namespace decaf::lang::exceptions;
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter::ByteArrayAdapter( int size )
-    throw( decaf::lang::exceptions::IllegalArgumentException ) {
+ByteArrayAdapter::ByteArrayAdapter( int size ) {
 
     try{
 
@@ -50,9 +49,7 @@ ByteArrayAdapter::ByteArrayAdapter( int 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter::ByteArrayAdapter( unsigned char* array, int size, bool own )
-    throw( decaf::lang::exceptions::NullPointerException,
-           decaf::lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter::ByteArrayAdapter( unsigned char* array, int size, bool own ) {
 
     try{
         this->initialize( array, size, own );
@@ -63,9 +60,7 @@ ByteArrayAdapter::ByteArrayAdapter( unsi
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter::ByteArrayAdapter( char* array, int size, bool own )
-    throw( decaf::lang::exceptions::NullPointerException,
-           decaf::lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter::ByteArrayAdapter( char* array, int size, bool own ) {
 
     try{
         this->initialize( reinterpret_cast<unsigned char*>( array ), size, own );
@@ -76,9 +71,7 @@ ByteArrayAdapter::ByteArrayAdapter( char
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter::ByteArrayAdapter( double* array, int size, bool own )
-    throw( decaf::lang::exceptions::NullPointerException,
-           decaf::lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter::ByteArrayAdapter( double* array, int size, bool own ) {
 
     try{
         this->initialize( reinterpret_cast<unsigned char*>( array ),
@@ -90,9 +83,7 @@ ByteArrayAdapter::ByteArrayAdapter( doub
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter::ByteArrayAdapter( float* array, int size, bool own )
-    throw( decaf::lang::exceptions::NullPointerException,
-           decaf::lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter::ByteArrayAdapter( float* array, int size, bool own ) {
 
     try{
         this->initialize( reinterpret_cast<unsigned char*>( array ),
@@ -104,9 +95,7 @@ ByteArrayAdapter::ByteArrayAdapter( floa
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter::ByteArrayAdapter( long long* array, int size, bool own )
-    throw( decaf::lang::exceptions::NullPointerException,
-           decaf::lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter::ByteArrayAdapter( long long* array, int size, bool own ) {
 
     try{
         this->initialize( reinterpret_cast<unsigned char*>( array ),
@@ -118,9 +107,7 @@ ByteArrayAdapter::ByteArrayAdapter( long
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter::ByteArrayAdapter( int* array, int size, bool own )
-    throw( decaf::lang::exceptions::NullPointerException,
-           decaf::lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter::ByteArrayAdapter( int* array, int size, bool own ) {
 
     try{
         this->initialize( reinterpret_cast<unsigned char*>( array ),
@@ -132,9 +119,7 @@ ByteArrayAdapter::ByteArrayAdapter( int*
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter::ByteArrayAdapter( short* array, int size, bool own )
-    throw( decaf::lang::exceptions::NullPointerException,
-           decaf::lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter::ByteArrayAdapter( short* array, int size, bool own ) {
 
     try{
         this->initialize( reinterpret_cast<unsigned char*>( array ),
@@ -183,8 +168,7 @@ ByteArrayAdapter::~ByteArrayAdapter() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void ByteArrayAdapter::read( unsigned char* buffer, int size, int offset, int length ) const
-    throw( IndexOutOfBoundsException, NullPointerException, BufferUnderflowException ) {
+void ByteArrayAdapter::read( unsigned char* buffer, int size, int offset, int length ) const {
 
     try{
 
@@ -229,8 +213,7 @@ void ByteArrayAdapter::read( unsigned ch
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void ByteArrayAdapter::write( unsigned char* buffer, int size, int offset, int length )
-    throw( IndexOutOfBoundsException, NullPointerException, BufferOverflowException ) {
+void ByteArrayAdapter::write( unsigned char* buffer, int size, int offset, int length ) {
 
     try{
 
@@ -276,8 +259,7 @@ void ByteArrayAdapter::write( unsigned c
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void ByteArrayAdapter::resize( int size )
-    throw ( IllegalArgumentException, InvalidStateException ) {
+void ByteArrayAdapter::resize( int size ) {
 
     try{
 
@@ -312,8 +294,7 @@ void ByteArrayAdapter::clear() throw() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-unsigned char& ByteArrayAdapter::operator[]( int index )
-    throw ( IndexOutOfBoundsException ) {
+unsigned char& ByteArrayAdapter::operator[]( int index ) {
 
     try{
 
@@ -329,8 +310,7 @@ unsigned char& ByteArrayAdapter::operato
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-const unsigned char& ByteArrayAdapter::operator[]( int index ) const
-    throw ( decaf::lang::exceptions::IndexOutOfBoundsException ) {
+const unsigned char& ByteArrayAdapter::operator[]( int index ) const {
 
     try{
 
@@ -346,8 +326,7 @@ const unsigned char& ByteArrayAdapter::o
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-unsigned char ByteArrayAdapter::get( int index ) const
-    throw ( lang::exceptions::IndexOutOfBoundsException ) {
+unsigned char ByteArrayAdapter::get( int index ) const {
 
     try{
 
@@ -365,8 +344,7 @@ unsigned char ByteArrayAdapter::get( int
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-char ByteArrayAdapter::getChar( int index ) const
-    throw( decaf::lang::exceptions::IndexOutOfBoundsException ) {
+char ByteArrayAdapter::getChar( int index ) const {
 
     try{
         return (char)this->get( index );
@@ -377,8 +355,7 @@ char ByteArrayAdapter::getChar( int inde
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-double ByteArrayAdapter::getDouble( int index ) const
-    throw ( lang::exceptions::IndexOutOfBoundsException ) {
+double ByteArrayAdapter::getDouble( int index ) const {
 
     try{
 
@@ -396,8 +373,7 @@ double ByteArrayAdapter::getDouble( int 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-double ByteArrayAdapter::getDoubleAt( int index ) const
-    throw ( lang::exceptions::IndexOutOfBoundsException ) {
+double ByteArrayAdapter::getDoubleAt( int index ) const {
 
     try{
 
@@ -410,8 +386,7 @@ double ByteArrayAdapter::getDoubleAt( in
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-float ByteArrayAdapter::getFloat( int index ) const
-    throw ( lang::exceptions::IndexOutOfBoundsException ) {
+float ByteArrayAdapter::getFloat( int index ) const {
 
     try{
 
@@ -429,8 +404,7 @@ float ByteArrayAdapter::getFloat( int in
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-float ByteArrayAdapter::getFloatAt( int index ) const
-    throw ( lang::exceptions::IndexOutOfBoundsException ) {
+float ByteArrayAdapter::getFloatAt( int index ) const {
 
     try{
 
@@ -443,8 +417,7 @@ float ByteArrayAdapter::getFloatAt( int 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-long long ByteArrayAdapter::getLong( int index ) const
-    throw ( lang::exceptions::IndexOutOfBoundsException ) {
+long long ByteArrayAdapter::getLong( int index ) const {
 
     try{
 
@@ -462,8 +435,7 @@ long long ByteArrayAdapter::getLong( int
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-long long ByteArrayAdapter::getLongAt( int index ) const
-    throw ( lang::exceptions::IndexOutOfBoundsException ) {
+long long ByteArrayAdapter::getLongAt( int index ) const {
 
     try{
 
@@ -499,8 +471,7 @@ long long ByteArrayAdapter::getLongAt( i
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-int ByteArrayAdapter::getInt( int index ) const
-    throw ( lang::exceptions::IndexOutOfBoundsException ) {
+int ByteArrayAdapter::getInt( int index ) const {
 
     try{
 
@@ -518,8 +489,7 @@ int ByteArrayAdapter::getInt( int index 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-int ByteArrayAdapter::getIntAt( int index ) const
-    throw ( lang::exceptions::IndexOutOfBoundsException ) {
+int ByteArrayAdapter::getIntAt( int index ) const {
 
     try{
 
@@ -543,8 +513,7 @@ int ByteArrayAdapter::getIntAt( int inde
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-short ByteArrayAdapter::getShort( int index ) const
-    throw ( lang::exceptions::IndexOutOfBoundsException )  {
+short ByteArrayAdapter::getShort( int index ) const {
 
     try{
 
@@ -562,8 +531,7 @@ short ByteArrayAdapter::getShort( int in
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-short ByteArrayAdapter::getShortAt( int index ) const
-    throw ( lang::exceptions::IndexOutOfBoundsException )  {
+short ByteArrayAdapter::getShortAt( int index ) const {
 
     try{
 
@@ -586,8 +554,7 @@ short ByteArrayAdapter::getShortAt( int 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter& ByteArrayAdapter::put( int index, unsigned char value )
-    throw( lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter& ByteArrayAdapter::put( int index, unsigned char value ) {
 
     try{
 
@@ -607,8 +574,7 @@ ByteArrayAdapter& ByteArrayAdapter::put(
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter& ByteArrayAdapter::putChar( int index, char value )
-    throw( lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter& ByteArrayAdapter::putChar( int index, char value ) {
 
     try{
 
@@ -621,8 +587,7 @@ ByteArrayAdapter& ByteArrayAdapter::putC
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter& ByteArrayAdapter::putDouble( int index, double value )
-    throw( lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter& ByteArrayAdapter::putDouble( int index, double value ) {
 
     try{
 
@@ -641,8 +606,7 @@ ByteArrayAdapter& ByteArrayAdapter::putD
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter& ByteArrayAdapter::putDoubleAt( int index, double value )
-    throw( lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter& ByteArrayAdapter::putDoubleAt( int index, double value ) {
 
     try{
 
@@ -655,8 +619,7 @@ ByteArrayAdapter& ByteArrayAdapter::putD
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter& ByteArrayAdapter::putFloat( int index, float value )
-    throw( lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter& ByteArrayAdapter::putFloat( int index, float value ) {
 
     try{
 
@@ -675,8 +638,7 @@ ByteArrayAdapter& ByteArrayAdapter::putF
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter& ByteArrayAdapter::putFloatAt( int index, float value )
-    throw( lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter& ByteArrayAdapter::putFloatAt( int index, float value ) {
 
     try{
 
@@ -689,8 +651,7 @@ ByteArrayAdapter& ByteArrayAdapter::putF
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter& ByteArrayAdapter::putLong( int index, long long value )
-    throw( lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter& ByteArrayAdapter::putLong( int index, long long value ) {
 
     try{
 
@@ -709,8 +670,7 @@ ByteArrayAdapter& ByteArrayAdapter::putL
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter& ByteArrayAdapter::putLongAt( int index, long long value )
-    throw( lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter& ByteArrayAdapter::putLongAt( int index, long long value ) {
 
     try{
 
@@ -735,8 +695,7 @@ ByteArrayAdapter& ByteArrayAdapter::putL
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter& ByteArrayAdapter::putInt( int index, int value )
-    throw( lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter& ByteArrayAdapter::putInt( int index, int value ) {
 
     try{
 
@@ -755,8 +714,7 @@ ByteArrayAdapter& ByteArrayAdapter::putI
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter& ByteArrayAdapter::putIntAt( int index, int value )
-    throw( lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter& ByteArrayAdapter::putIntAt( int index, int value ) {
 
     try{
 
@@ -777,8 +735,7 @@ ByteArrayAdapter& ByteArrayAdapter::putI
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter& ByteArrayAdapter::putShort( int index, short value )
-    throw( lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter& ByteArrayAdapter::putShort( int index, short value ) {
 
     try{
 
@@ -797,8 +754,7 @@ ByteArrayAdapter& ByteArrayAdapter::putS
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ByteArrayAdapter& ByteArrayAdapter::putShortAt( int index, short value )
-    throw( lang::exceptions::IndexOutOfBoundsException ) {
+ByteArrayAdapter& ByteArrayAdapter::putShortAt( int index, short value ) {
 
     try{
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/ByteArrayAdapter.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/ByteArrayAdapter.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/ByteArrayAdapter.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/ByteArrayAdapter.h Fri Jul  2 19:04:44 2010
@@ -76,7 +76,7 @@ namespace util{
          *
          * @throws IllegalArgumentException if size is negative.
          */
-        ByteArrayAdapter( int size ) throw( decaf::lang::exceptions::IllegalArgumentException );
+        ByteArrayAdapter( int size );
 
         /**
          * Creates a byte array object that wraps the given array.  If the own flag
@@ -92,9 +92,7 @@ namespace util{
          * @throws NullPointerException if buffer is NULL
          * @throws IndexOutOfBoundsException if the size is negative.
          */
-        ByteArrayAdapter( unsigned char* array, int size, bool own = false )
-            throw( decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IndexOutOfBoundsException );
+        ByteArrayAdapter( unsigned char* array, int size, bool own = false );
 
         /**
          * Creates a byte array object that wraps the given array.  If the own flag
@@ -110,9 +108,7 @@ namespace util{
          * @throws NullPointerException if buffer is NULL
          * @throws IndexOutOfBoundsException if the size is negative.
          */
-        ByteArrayAdapter( char* array, int size, bool own = false )
-            throw( decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IndexOutOfBoundsException );
+        ByteArrayAdapter( char* array, int size, bool own = false );
 
         /**
          * Creates a byte array object that wraps the given array.  If the own flag
@@ -128,9 +124,7 @@ namespace util{
          * @throws NullPointerException if buffer is NULL
          * @throws IndexOutOfBoundsException if the size is negative.
          */
-        ByteArrayAdapter( double* array, int size, bool own = false )
-            throw( decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IndexOutOfBoundsException );
+        ByteArrayAdapter( double* array, int size, bool own = false );
 
         /**
          * Creates a byte array object that wraps the given array.  If the own flag
@@ -146,9 +140,7 @@ namespace util{
          * @throws NullPointerException if buffer is NULL
          * @throws IndexOutOfBoundsException if the size is negative.
          */
-        ByteArrayAdapter( float* array, int size, bool own = false )
-            throw( decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IndexOutOfBoundsException );
+        ByteArrayAdapter( float* array, int size, bool own = false );
 
         /**
          * Creates a byte array object that wraps the given array.  If the own flag
@@ -164,9 +156,7 @@ namespace util{
          * @throws NullPointerException if buffer is NULL
          * @throws IndexOutOfBoundsException if the size is negative.
          */
-        ByteArrayAdapter( long long* array, int size, bool own = false )
-            throw( decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IndexOutOfBoundsException );
+        ByteArrayAdapter( long long* array, int size, bool own = false );
 
         /**
          * Creates a byte array object that wraps the given array.  If the own flag
@@ -182,9 +172,7 @@ namespace util{
          * @throws NullPointerException if buffer is NULL
          * @throws IndexOutOfBoundsException if the size is negative.
          */
-        ByteArrayAdapter( int* array, int size, bool own = false )
-            throw( decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IndexOutOfBoundsException );
+        ByteArrayAdapter( int* array, int size, bool own = false );
 
         /**
          * Creates a byte array object that wraps the given array.  If the own flag
@@ -200,9 +188,7 @@ namespace util{
          * @throws NullPointerException if buffer is NULL
          * @throws IndexOutOfBoundsException if the size is negative.
          */
-        ByteArrayAdapter( short* array, int size, bool own = false )
-            throw( decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IndexOutOfBoundsException );
+        ByteArrayAdapter( short* array, int size, bool own = false );
 
         virtual ~ByteArrayAdapter();
 
@@ -344,10 +330,7 @@ namespace util{
          * @throws BufferUnderflowException if there is not enough data to read
          *         because the offset or the length is greater than the size of this array.
          */
-        virtual void read( unsigned char* buffer, int size, int offset, int length ) const
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException,
-                   decaf::lang::exceptions::NullPointerException,
-                   decaf::nio::BufferUnderflowException );
+        virtual void read( unsigned char* buffer, int size, int offset, int length ) const;
 
         /**
          * Writes from the Byte array given, starting at the specified offset and writing
@@ -369,10 +352,7 @@ namespace util{
          * @throws BufferOverflowException if the amount of data to be written to this
          * array or the offset given are larger than this array's size.
          */
-        virtual void write( unsigned char* buffer, int size, int offset, int length )
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException,
-                   decaf::lang::exceptions::NullPointerException,
-                   decaf::nio::BufferOverflowException );
+        virtual void write( unsigned char* buffer, int size, int offset, int length );
 
         /**
          * Resizes the underlying array to the new given size, preserving all the
@@ -389,9 +369,7 @@ namespace util{
          * @throws IllegalArgumentException if the size parameter is negative.
          * @throws InvalidStateException if this object does not own the buffer.
          */
-        virtual void resize( int size )
-            throw( decaf::lang::exceptions::IllegalArgumentException,
-                   decaf::lang::exceptions::InvalidStateException );
+        virtual void resize( int size );
 
         /**
          * Clear all data from that Array, setting the underlying bytes to zero.
@@ -409,10 +387,8 @@ namespace util{
          *
          * @throws IndexOutOfBoundsException if the preconditions of index are not met.
          */
-        unsigned char& operator[]( int index )
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
-        const unsigned char& operator[]( int index ) const
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        unsigned char& operator[]( int index );
+        const unsigned char& operator[]( int index ) const;
 
         /**
          * Absolute get method. Reads the byte at the given index.
@@ -425,8 +401,7 @@ namespace util{
          * @throws IndexOutOfBoundsException If index is not smaller than the
          *         buffer's limit or is negative.
          */
-        virtual unsigned char get( int index ) const
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual unsigned char get( int index ) const;
 
         /**
          * Reads one byte at the given index and returns it.
@@ -439,8 +414,7 @@ namespace util{
          * @throws IndexOutOfBoundsException If index is not smaller than the
          *         buffer's limit or is negative.
          */
-        virtual char getChar( int index ) const
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual char getChar( int index ) const;
 
         /**
          * Reads eight bytes at the given index and returns it.  The index is a
@@ -456,8 +430,7 @@ namespace util{
          * @throws IndexOutOfBoundsException if there are not enough bytes remaining
          *         to fill the requested Data Type, or index is negative.
          */
-        virtual double getDouble( int index ) const
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual double getDouble( int index ) const;
 
         /**
          * Reads eight bytes at the given byte index and returns it.
@@ -470,8 +443,7 @@ namespace util{
          * @throws IndexOutOfBoundsException if there are not enough bytes remaining
          *         to fill the requested Data Type, or index is negative.
          */
-        virtual double getDoubleAt( int index ) const
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual double getDoubleAt( int index ) const;
 
         /**
          * Reads four bytes at the given index and returns it. The index is a
@@ -487,8 +459,7 @@ namespace util{
          * @throws IndexOutOfBoundsException if there are not enough bytes remaining
          *         to fill the requested Data Type, or index is negative.
          */
-        virtual float getFloat( int index ) const
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual float getFloat( int index ) const;
 
         /**
          * Reads four bytes at the given byte index and returns it
@@ -501,8 +472,7 @@ namespace util{
          * @throws IndexOutOfBoundsException if there are not enough bytes remaining
          *         to fill the requested Data Type, or index is negative.
          */
-        virtual float getFloatAt( int index ) const
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual float getFloatAt( int index ) const;
 
         /**
          * Reads eight bytes at the given index and returns it.  The index is a
@@ -518,8 +488,7 @@ namespace util{
          * @throws IndexOutOfBoundsException if there are not enough bytes remaining
          *         to fill the requested Data Type, or index is negative.
          */
-        virtual long long getLong( int index ) const
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual long long getLong( int index ) const;
 
         /**
          * Reads eight bytes at the given byte index and returns it.
@@ -532,8 +501,7 @@ namespace util{
          * @throws IndexOutOfBoundsException if there are not enough bytes remaining
          *         to fill the requested Data Type, or index is negative.
          */
-        virtual long long getLongAt( int index ) const
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual long long getLongAt( int index ) const;
 
         /**
          * Reads four bytes at the given index and returns it.  The index is a
@@ -549,8 +517,7 @@ namespace util{
          * @throws IndexOutOfBoundsException if there are not enough bytes remaining
          *         to fill the requested Data Type, or index is negative.
          */
-        virtual int getInt( int index ) const
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual int getInt( int index ) const;
 
         /**
          * Reads four bytes at the given byte index and returns it.
@@ -563,8 +530,7 @@ namespace util{
          * @throws IndexOutOfBoundsException if there are not enough bytes remaining
          *         to fill the requested Data Type, or index is negative.
          */
-        virtual int getIntAt( int index ) const
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual int getIntAt( int index ) const;
 
         /**
          * Reads two bytes at the given index and returns it. The index is a
@@ -580,8 +546,7 @@ namespace util{
          * @throws IndexOutOfBoundsException if there are not enough bytes remaining
          *         to fill the requested Data Type, or index is negative.
          */
-        virtual short getShort( int index ) const
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual short getShort( int index ) const;
 
         /**
          * Reads two bytes at the given byte index and returns it.
@@ -594,8 +559,7 @@ namespace util{
          * @throws IndexOutOfBoundsException if there are not enough bytes remaining
          *         to fill the requested Data Type, or index is negative.
          */
-        virtual short getShortAt( int index ) const
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual short getShortAt( int index ) const;
 
         /**
          * Writes the given byte into this buffer at the given index. The index is a
@@ -613,8 +577,7 @@ namespace util{
          * @throw IndexOutOfBoundsException if index greater than the buffer's limit
          *        minus the size of the type being written, or index is negative.
          */
-        virtual ByteArrayAdapter& put( int index, unsigned char value )
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual ByteArrayAdapter& put( int index, unsigned char value );
 
         /**
          * Writes one byte containing the given value, into this buffer at the
@@ -632,8 +595,7 @@ namespace util{
          * @throw IndexOutOfBoundsException if index greater than the buffer's limit
          *        minus the size of the type being written, or index is negative.
          */
-        virtual ByteArrayAdapter& putChar( int index, char value )
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual ByteArrayAdapter& putChar( int index, char value );
 
         /**
          * Writes eight bytes containing the given value, into this buffer at the
@@ -651,8 +613,7 @@ namespace util{
          * @throw IndexOutOfBoundsException if index greater than the buffer's limit
          *        minus the size of the type being written, or index is negative.
          */
-        virtual ByteArrayAdapter& putDouble( int index, double value )
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual ByteArrayAdapter& putDouble( int index, double value );
 
         /**
          * Writes eight bytes containing the given value, into this buffer at the
@@ -668,8 +629,7 @@ namespace util{
          * @throw IndexOutOfBoundsException if index greater than the buffer's limit
          *        minus the size of the type being written, or index is negative.
          */
-        virtual ByteArrayAdapter& putDoubleAt( int index, double value )
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual ByteArrayAdapter& putDoubleAt( int index, double value );
 
         /**
          * Writes four bytes containing the given value, into this buffer at the
@@ -687,8 +647,7 @@ namespace util{
          * @throw IndexOutOfBoundsException if index greater than the buffer's limit
          *        minus the size of the type being written, or index is negative.
          */
-        virtual ByteArrayAdapter& putFloat( int index, float value )
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual ByteArrayAdapter& putFloat( int index, float value );
 
         /**
          * Writes four bytes containing the given value, into this buffer at the
@@ -704,8 +663,7 @@ namespace util{
          * @throw IndexOutOfBoundsException if index greater than the buffer's limit
          *        minus the size of the type being written, or index is negative.
          */
-        virtual ByteArrayAdapter& putFloatAt( int index, float value )
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual ByteArrayAdapter& putFloatAt( int index, float value );
 
         /**
          * Writes eight bytes containing the given value, into this buffer at the
@@ -723,8 +681,7 @@ namespace util{
          * @throw IndexOutOfBoundsException if index greater than the buffer's limit
          *        minus the size of the type being written, or index is negative.
          */
-        virtual ByteArrayAdapter& putLong( int index, long long value )
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual ByteArrayAdapter& putLong( int index, long long value );
 
         /**
          * Writes eight bytes containing the given value, into this buffer at the
@@ -740,8 +697,7 @@ namespace util{
          * @throw IndexOutOfBoundsException if index greater than the buffer's limit
          *        minus the size of the type being written, or index is negative.
          */
-        virtual ByteArrayAdapter& putLongAt( int index, long long value )
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual ByteArrayAdapter& putLongAt( int index, long long value );
 
         /**
          * Writes four bytes containing the given value, into this buffer at the
@@ -759,8 +715,7 @@ namespace util{
          * @throw IndexOutOfBoundsException if index greater than the buffer's limit
          *        minus the size of the type being written, or index is negative.
          */
-        virtual ByteArrayAdapter& putInt( int index, int value )
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual ByteArrayAdapter& putInt( int index, int value );
 
         /**
          * Writes four bytes containing the given value, into this buffer at the
@@ -776,8 +731,7 @@ namespace util{
          * @throw IndexOutOfBoundsException if index greater than the buffer's limit
          *        minus the size of the type being written, or index is negative.
          */
-        virtual ByteArrayAdapter& putIntAt( int index, int value )
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual ByteArrayAdapter& putIntAt( int index, int value );
 
         /**
          * Writes two bytes containing the given value, into this buffer at the
@@ -795,8 +749,7 @@ namespace util{
          * @throw IndexOutOfBoundsException if index greater than the buffer's limit
          *        minus the size of the type being written, or index is negative.
          */
-        virtual ByteArrayAdapter& putShort( int index, short value )
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual ByteArrayAdapter& putShort( int index, short value );
 
         /**
          * Writes two bytes containing the given value, into this buffer at the
@@ -812,8 +765,7 @@ namespace util{
          * @throw IndexOutOfBoundsException if index greater than the buffer's limit
          *        minus the size of the type being written, or index is negative.
          */
-        virtual ByteArrayAdapter& putShortAt( int index, short value )
-            throw( decaf::lang::exceptions::IndexOutOfBoundsException );
+        virtual ByteArrayAdapter& putShortAt( int index, short value );
 
     private:
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/HexStringParser.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/HexStringParser.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/HexStringParser.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/HexStringParser.h Fri Jul  2 19:04:44 2010
@@ -145,7 +145,7 @@ namespace util{
         /*
          * Calculates the offset between the normalized number and unnormalized
          * number. In a normalized representation, significand is represented by the
-         * characters "0x1." followed by a lowercase hexadecimal representation of
+         * characters "0x1." followed by a lower-case hexadecimal representation of
          * the rest of the significand as a fraction.
          */
         int getOffset( const std::string& strIntegerPart,

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/SynchronizableImpl.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/SynchronizableImpl.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/SynchronizableImpl.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/SynchronizableImpl.cpp Fri Jul  2 19:04:44 2010
@@ -29,54 +29,41 @@ SynchronizableImpl::SynchronizableImpl()
 SynchronizableImpl::~SynchronizableImpl() {}
 
 ////////////////////////////////////////////////////////////////////////////////
-void SynchronizableImpl::lock() throw( decaf::lang::exceptions::RuntimeException ) {
+void SynchronizableImpl::lock() {
     mutex.lock();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool SynchronizableImpl::tryLock() throw( decaf::lang::exceptions::RuntimeException ) {
+bool SynchronizableImpl::tryLock() {
     return mutex.tryLock();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void SynchronizableImpl::unlock() throw( decaf::lang::exceptions::RuntimeException ) {
+void SynchronizableImpl::unlock() {
     mutex.unlock();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void SynchronizableImpl::wait() throw( decaf::lang::exceptions::RuntimeException,
-                                       decaf::lang::exceptions::IllegalMonitorStateException,
-                                       decaf::lang::exceptions::InterruptedException ) {
+void SynchronizableImpl::wait() {
     mutex.wait();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void SynchronizableImpl::wait( long long millisecs )
-    throw( decaf::lang::exceptions::RuntimeException,
-           decaf::lang::exceptions::IllegalMonitorStateException,
-           decaf::lang::exceptions::InterruptedException ) {
-
+void SynchronizableImpl::wait( long long millisecs ) {
     mutex.wait( millisecs );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void SynchronizableImpl::wait( long long millisecs, int nanos )
-    throw( decaf::lang::exceptions::RuntimeException,
-           decaf::lang::exceptions::IllegalArgumentException,
-           decaf::lang::exceptions::IllegalMonitorStateException,
-           decaf::lang::exceptions::InterruptedException ) {
-
+void SynchronizableImpl::wait( long long millisecs, int nanos ) {
     mutex.wait( millisecs, nanos );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void SynchronizableImpl::notify() throw( decaf::lang::exceptions::RuntimeException,
-                                        decaf::lang::exceptions::IllegalMonitorStateException ) {
+void SynchronizableImpl::notify() {
     mutex.notify();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void SynchronizableImpl::notifyAll() throw( decaf::lang::exceptions::RuntimeException,
-                                            decaf::lang::exceptions::IllegalMonitorStateException ) {
+void SynchronizableImpl::notifyAll() {
     mutex.notifyAll();
 }

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/SynchronizableImpl.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/SynchronizableImpl.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/SynchronizableImpl.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/SynchronizableImpl.h Fri Jul  2 19:04:44 2010
@@ -43,32 +43,21 @@ namespace concurrent {
         SynchronizableImpl();
         virtual ~SynchronizableImpl();
 
-        virtual void lock() throw( decaf::lang::exceptions::RuntimeException );
+        virtual void lock();
 
-        virtual bool tryLock() throw( decaf::lang::exceptions::RuntimeException );
+        virtual bool tryLock();
 
-        virtual void unlock() throw( decaf::lang::exceptions::RuntimeException );
+        virtual void unlock();
 
-        virtual void wait() throw( decaf::lang::exceptions::RuntimeException,
-                                   decaf::lang::exceptions::IllegalMonitorStateException,
-                                   decaf::lang::exceptions::InterruptedException );
+        virtual void wait();
 
-        virtual void wait( long long millisecs )
-            throw( decaf::lang::exceptions::RuntimeException,
-                   decaf::lang::exceptions::IllegalMonitorStateException,
-                   decaf::lang::exceptions::InterruptedException );
+        virtual void wait( long long millisecs );
 
-        virtual void wait( long long millisecs, int nanos )
-            throw( decaf::lang::exceptions::RuntimeException,
-                   decaf::lang::exceptions::IllegalArgumentException,
-                   decaf::lang::exceptions::IllegalMonitorStateException,
-                   decaf::lang::exceptions::InterruptedException );
+        virtual void wait( long long millisecs, int nanos );
 
-        virtual void notify() throw( decaf::lang::exceptions::RuntimeException,
-                                     decaf::lang::exceptions::IllegalMonitorStateException );
+        virtual void notify();
 
-        virtual void notifyAll() throw( decaf::lang::exceptions::RuntimeException,
-                                        decaf::lang::exceptions::IllegalMonitorStateException );
+        virtual void notifyAll();
 
     };
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/TransferQueue.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/TransferQueue.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/TransferQueue.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/TransferQueue.h Fri Jul  2 19:04:44 2010
@@ -114,17 +114,11 @@ namespace concurrent {
 
         virtual ~TransferQueue() {}
 
-        virtual void transfer( E* e, bool timed, long long nanos )
-            throw( decaf::util::concurrent::TimeoutException,
-                   decaf::lang::exceptions::InterruptedException )
-        {
+        virtual void transfer( E* e, bool timed, long long nanos ) {
 
         }
 
-        virtual E* transfer( bool timed, long long nanos )
-            throw( decaf::util::concurrent::TimeoutException,
-                   decaf::lang::exceptions::InterruptedException )
-        {
+        virtual E* transfer( bool timed, long long nanos ) {
             return NULL;
         }
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/TransferStack.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/TransferStack.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/TransferStack.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/TransferStack.h Fri Jul  2 19:04:44 2010
@@ -35,17 +35,10 @@ namespace concurrent {
         TransferStack() {}
         virtual ~TransferStack() {}
 
-        virtual void transfer( E* e, bool timed, long long nanos )
-            throw( decaf::util::concurrent::TimeoutException,
-                   decaf::lang::exceptions::InterruptedException )
-        {
-
+        virtual void transfer( E* e, bool timed, long long nanos ) {
         }
 
-        virtual E* transfer( bool timed, long long nanos )
-            throw( decaf::util::concurrent::TimeoutException,
-                   decaf::lang::exceptions::InterruptedException )
-        {
+        virtual E* transfer( bool timed, long long nanos ) {
             return NULL;
         }
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/Transferer.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/Transferer.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/Transferer.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/internal/util/concurrent/Transferer.h Fri Jul  2 19:04:44 2010
@@ -44,9 +44,7 @@ namespace concurrent {
          * @throws InterruptedException if the thread was interrupted while
          *         waiting for the consumer to accept the item offered.
          */
-        virtual void transfer( E* e, bool timed, long long nanos )
-            throw( decaf::util::concurrent::TimeoutException,
-                   decaf::lang::exceptions::InterruptedException ) = 0;
+        virtual void transfer( E* e, bool timed, long long nanos ) = 0;
 
         /**
          * Performs a take.
@@ -61,9 +59,7 @@ namespace concurrent {
          * @throws InterruptedException if the thread was interrupted while
          *         waiting for the producer to offer an item.
          */
-        virtual E* transfer( bool timed, long long nanos )
-            throw( decaf::util::concurrent::TimeoutException,
-                   decaf::lang::exceptions::InterruptedException ) = 0;
+        virtual E* transfer( bool timed, long long nanos ) = 0;
 
     };
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BlockingByteArrayInputStream.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BlockingByteArrayInputStream.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BlockingByteArrayInputStream.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BlockingByteArrayInputStream.cpp Fri Jul  2 19:04:44 2010
@@ -63,12 +63,12 @@ void BlockingByteArrayInputStream::setBy
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-int BlockingByteArrayInputStream::available() const throw ( decaf::io::IOException ){
+int BlockingByteArrayInputStream::available() const {
     return (int)std::distance( pos, buffer.end() );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void BlockingByteArrayInputStream::close() throw ( io::IOException ){
+void BlockingByteArrayInputStream::close() {
 
     synchronized( this ){
 
@@ -84,7 +84,7 @@ void BlockingByteArrayInputStream::close
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-int BlockingByteArrayInputStream::doReadByte() throw ( IOException ){
+int BlockingByteArrayInputStream::doReadByte() {
 
     try{
 
@@ -110,10 +110,7 @@ int BlockingByteArrayInputStream::doRead
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-int BlockingByteArrayInputStream::doReadArrayBounded( unsigned char* buffer, int size, int offset, int length )
-    throw ( decaf::io::IOException,
-            decaf::lang::exceptions::IndexOutOfBoundsException,
-            decaf::lang::exceptions::NullPointerException ) {
+int BlockingByteArrayInputStream::doReadArrayBounded( unsigned char* buffer, int size, int offset, int length ) {
 
     if( length == 0 ) {
         return 0;
@@ -177,8 +174,7 @@ int BlockingByteArrayInputStream::doRead
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-long long BlockingByteArrayInputStream::skip( long long num )
-    throw ( io::IOException, lang::exceptions::UnsupportedOperationException ){
+long long BlockingByteArrayInputStream::skip( long long num ) {
 
     long long ix = 0;
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BlockingByteArrayInputStream.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BlockingByteArrayInputStream.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BlockingByteArrayInputStream.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BlockingByteArrayInputStream.h Fri Jul  2 19:04:44 2010
@@ -76,28 +76,23 @@ namespace io{
         /**
          * {@inheritDoc}
          */
-        virtual int available() const throw ( decaf::io::IOException );
+        virtual int available() const;
 
         /**
          * {@inheritDoc}
          */
-        virtual void close() throw ( decaf::io::IOException );
+        virtual void close();
 
         /**
          * {@inheritDoc}
          */
-        virtual long long skip( long long num )
-            throw ( decaf::io::IOException,
-                    decaf::lang::exceptions::UnsupportedOperationException );
+        virtual long long skip( long long num );
 
     protected:
 
-        virtual int doReadByte() throw ( IOException );
+        virtual int doReadByte();
 
-        virtual int doReadArrayBounded( unsigned char* buffer, int size, int offset, int length )
-            throw ( decaf::io::IOException,
-                    decaf::lang::exceptions::IndexOutOfBoundsException,
-                    decaf::lang::exceptions::NullPointerException );
+        virtual int doReadArrayBounded( unsigned char* buffer, int size, int offset, int length );
 
     };
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BufferedInputStream.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BufferedInputStream.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BufferedInputStream.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/io/BufferedInputStream.cpp Fri Jul  2 19:04:44 2010
@@ -36,8 +36,7 @@ BufferedInputStream::BufferedInputStream
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-BufferedInputStream::BufferedInputStream( InputStream* stream, int bufferSize, bool own )
-    throw ( lang::exceptions::IllegalArgumentException ) :
+BufferedInputStream::BufferedInputStream( InputStream* stream, int bufferSize, bool own ) :
         FilterInputStream( stream, own ),
         pos(0), count(0), markLimit(-1), markPos(-1), bufferSize(bufferSize), buff(NULL), proxyBuffer(NULL) {
 
@@ -61,7 +60,7 @@ BufferedInputStream::~BufferedInputStrea
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void BufferedInputStream::close() throw( IOException ) {
+void BufferedInputStream::close() {
 
     // let parent close the inputStream
     FilterInputStream::close();
@@ -72,7 +71,7 @@ void BufferedInputStream::close() throw(
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-int BufferedInputStream::available() const throw ( IOException ) {
+int BufferedInputStream::available() const {
 
     if( this->proxyBuffer == NULL || this->isClosed() ) {
         throw IOException(
@@ -93,7 +92,7 @@ void BufferedInputStream::mark( int read
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void BufferedInputStream::reset() throw ( IOException ) {
+void BufferedInputStream::reset() {
 
     if( this->proxyBuffer == NULL ) {
         throw IOException(
@@ -111,7 +110,7 @@ void BufferedInputStream::reset() throw 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-int BufferedInputStream::doReadByte() throw ( IOException ){
+int BufferedInputStream::doReadByte() {
 
     try{
 
@@ -148,10 +147,7 @@ int BufferedInputStream::doReadByte() th
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-int BufferedInputStream::doReadArrayBounded( unsigned char* buffer, int size, int offset, int length )
-    throw ( decaf::io::IOException,
-            decaf::lang::exceptions::IndexOutOfBoundsException,
-            decaf::lang::exceptions::NullPointerException ) {
+int BufferedInputStream::doReadArrayBounded( unsigned char* buffer, int size, int offset, int length ) {
 
     try{
 
@@ -266,8 +262,7 @@ int BufferedInputStream::doReadArrayBoun
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-long long BufferedInputStream::skip( long long amount )
-    throw ( IOException, lang::exceptions::UnsupportedOperationException ){
+long long BufferedInputStream::skip( long long amount ) {
 
     try{
 
@@ -322,8 +317,7 @@ long long BufferedInputStream::skip( lon
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-int BufferedInputStream::bufferData( InputStream* inputStream, unsigned char*& buffer )
-    throw ( decaf::io::IOException ){
+int BufferedInputStream::bufferData( InputStream* inputStream, unsigned char*& buffer ) {
 
     try{
 



Mime
View raw message