activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tab...@apache.org
Subject svn commit: r960088 [8/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/util/concurrent/BlockingQueue.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/BlockingQueue.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/BlockingQueue.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/BlockingQueue.h Fri Jul  2 19:04:44 2010
@@ -177,10 +177,7 @@ namespace concurrent {
          * @throws IllegalArgumentException if some property of the specified
          *         element prevents it from being added to this queue
          */
-        virtual void put( const E& value )
-            throw( decaf::lang::exceptions::InterruptedException,
-                   decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IllegalArgumentException ) = 0;
+        virtual void put( const E& value ) = 0;
 
         /**
          * Inserts the specified element into this queue, waiting up to the specified wait
@@ -198,10 +195,7 @@ namespace concurrent {
          * @throws IllegalArgumentException if some property of the specified
          *         element prevents it from being added to this queue
          */
-        virtual bool offer( const E& e, long timeout, const TimeUnit& unit )
-            throw( decaf::lang::exceptions::InterruptedException,
-                   decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IllegalArgumentException ) = 0;
+        virtual bool offer( const E& e, long timeout, const TimeUnit& unit ) = 0;
 
         /**
          * Retrieves and removes the head of this queue, waiting if necessary until an
@@ -210,7 +204,7 @@ namespace concurrent {
          * @return the head of this queue
          * @throws InterruptedException if interrupted while waiting
          */
-        virtual E take() throw( decaf::lang::exceptions::InterruptedException ) = 0;
+        virtual E take() = 0;
 
         /**
          * Retrieves and removes the head of this queue, waiting up to the specified
@@ -225,8 +219,7 @@ namespace concurrent {
          *         waiting time elapses before an element is available.
          * @throws InterruptedException if interrupted while waiting
          */
-        virtual bool poll( E& result, long long timeout, const TimeUnit& unit )
-            throw( decaf::lang::exceptions::InterruptedException ) = 0;
+        virtual bool poll( E& result, long long timeout, const TimeUnit& unit ) = 0;
 
         /**
          * Returns the number of additional elements that this queue can ideally
@@ -261,9 +254,7 @@ namespace concurrent {
          *         queue, or some property of an element of this queue prevents
          *         it from being added to the specified collection
          */
-        virtual std::size_t drainTo( Collection<E>& c )
-            throw( decaf::lang::exceptions::UnsupportedOperationException,
-                   decaf::lang::exceptions::IllegalArgumentException ) = 0;
+        virtual std::size_t drainTo( Collection<E>& c ) = 0;
 
         /**
          * Removes at most the given number of available elements from
@@ -285,9 +276,7 @@ namespace concurrent {
          *         queue, or some property of an element of this queue prevents
          *         it from being added to the specified collection
          */
-        virtual std::size_t drainTo( Collection<E>& c, std::size_t maxElements )
-            throw( decaf::lang::exceptions::UnsupportedOperationException,
-                   decaf::lang::exceptions::IllegalArgumentException ) = 0;
+        virtual std::size_t drainTo( Collection<E>& c, std::size_t maxElements ) = 0;
 
     };
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Callable.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Callable.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Callable.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Callable.h Fri Jul  2 19:04:44 2010
@@ -47,7 +47,7 @@ namespace concurrent {
          * @throws Exception
          *      If unable to compute a result.
          */
-        virtual V call() throw ( decaf::lang::Exception ) = 0;
+        virtual V call() = 0;
 
     };
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ConcurrentMap.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ConcurrentMap.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ConcurrentMap.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ConcurrentMap.h Fri Jul  2 19:04:44 2010
@@ -64,8 +64,7 @@ namespace concurrent {
          * @throw UnsupportedOperationException
          *        if the put operation is not supported by this map
          */
-        virtual bool putIfAbsent( const K& key, const V& value )
-            throw( decaf::lang::exceptions::UnsupportedOperationException ) = 0;
+        virtual bool putIfAbsent( const K& key, const V& value ) = 0;
 
         /**
          * Remove entry for key only if currently mapped to given value.
@@ -128,8 +127,7 @@ namespace concurrent {
          *
          * @throws NoSuchElementException if there was no previous mapping.
          */
-        virtual V replace( const K& key, const V& value )
-            throw( decaf::lang::exceptions::NoSuchElementException ) = 0;
+        virtual V replace( const K& key, const V& value ) = 0;
 
     };
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ConcurrentStlMap.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ConcurrentStlMap.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ConcurrentStlMap.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ConcurrentStlMap.h Fri Jul  2 19:04:44 2010
@@ -232,8 +232,7 @@ namespace concurrent{
         /**
          * {@inheritDoc}
          */
-        virtual void put( const K& key, const V& value )
-            throw ( decaf::lang::exceptions::UnsupportedOperationException ) {
+        virtual void put( const K& key, const V& value ) {
 
             synchronized( &mutex ) {
                 valueMap[key] = value;
@@ -243,8 +242,7 @@ namespace concurrent{
         /**
          * {@inheritDoc}
          */
-        virtual void putAll( const ConcurrentStlMap<K,V,COMPARATOR>& other )
-            throw ( decaf::lang::exceptions::UnsupportedOperationException ) {
+        virtual void putAll( const ConcurrentStlMap<K,V,COMPARATOR>& other ) {
 
             synchronized( &mutex ) {
                 this->valueMap.insert( other.valueMap.begin(), other.valueMap.end() );
@@ -254,8 +252,7 @@ namespace concurrent{
         /**
          * {@inheritDoc}
          */
-        virtual void putAll( const Map<K,V,COMPARATOR>& other )
-            throw ( decaf::lang::exceptions::UnsupportedOperationException ) {
+        virtual void putAll( const Map<K,V,COMPARATOR>& other ) {
 
             synchronized( &mutex ) {
                 std::vector<K> keys = other.keySet();
@@ -270,9 +267,7 @@ namespace concurrent{
         /**
          * {@inheritDoc}
          */
-        virtual V remove( const K& key )
-            throw ( decaf::lang::exceptions::NoSuchElementException,
-                    decaf::lang::exceptions::UnsupportedOperationException ) {
+        virtual V remove( const K& key ) {
 
             V result;
 
@@ -349,8 +344,7 @@ namespace concurrent{
          * @throw UnsupportedOperationException
          *        if the put operation is not supported by this map
          */
-        bool putIfAbsent( const K& key, const V& value )
-            throw( decaf::lang::exceptions::UnsupportedOperationException ) {
+        bool putIfAbsent( const K& key, const V& value ) {
 
             synchronized( &mutex ) {
                 if( !this->containsKey( key ) ) {
@@ -441,8 +435,7 @@ namespace concurrent{
          *
          * @throws NoSuchElementException if there was no previous mapping.
          */
-        V replace( const K& key, const V& value )
-            throw( decaf::lang::exceptions::NoSuchElementException ) {
+        V replace( const K& key, const V& value ) {
 
             synchronized( &mutex ) {
                 if( this->containsKey( key ) ) {
@@ -458,51 +451,35 @@ namespace concurrent{
 
     public:
 
-        virtual void lock() throw( decaf::lang::exceptions::RuntimeException ) {
+        virtual void lock() {
             mutex.lock();
         }
 
-        virtual bool tryLock() throw( decaf::lang::exceptions::RuntimeException ) {
+        virtual bool tryLock() {
             return mutex.tryLock();
         }
 
-        virtual void unlock() throw( decaf::lang::exceptions::RuntimeException ) {
+        virtual void unlock() {
             mutex.unlock();
         }
 
-        virtual void wait() throw( decaf::lang::exceptions::RuntimeException,
-                                   decaf::lang::exceptions::IllegalMonitorStateException,
-                                   decaf::lang::exceptions::InterruptedException ) {
-
+        virtual void wait() {
             mutex.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 ) {
             mutex.wait( 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 ) {
             mutex.wait( millisecs, nanos );
         }
 
-        virtual void notify() throw( decaf::lang::exceptions::RuntimeException,
-                                     decaf::lang::exceptions::IllegalMonitorStateException ) {
-
+        virtual void notify() {
             mutex.notify();
         }
 
-        virtual void notifyAll() throw( decaf::lang::exceptions::RuntimeException,
-                                        decaf::lang::exceptions::IllegalMonitorStateException ) {
-
+        virtual void notifyAll() {
             mutex.notifyAll();
         }
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/CountDownLatch.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/CountDownLatch.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/CountDownLatch.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/CountDownLatch.cpp Fri Jul  2 19:04:44 2010
@@ -42,9 +42,7 @@ CountDownLatch::~CountDownLatch() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void CountDownLatch::await()
-    throw ( decaf::lang::exceptions::InterruptedException,
-            decaf::lang::Exception ) {
+void CountDownLatch::await() {
 
     try {
 
@@ -62,9 +60,7 @@ void CountDownLatch::await()
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool CountDownLatch::await( long long timeOut )
-    throw ( decaf::lang::exceptions::InterruptedException,
-            decaf::lang::Exception ) {
+bool CountDownLatch::await( long long timeOut ) {
 
     try {
 
@@ -91,9 +87,7 @@ bool CountDownLatch::await( long long ti
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool CountDownLatch::await( long long timeout, const TimeUnit& unit )
-    throw ( decaf::lang::exceptions::InterruptedException,
-            decaf::lang::Exception ) {
+bool CountDownLatch::await( long long timeout, const TimeUnit& unit ) {
 
     try{
         return this->await( unit.toMillis( timeout ) );

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/CountDownLatch.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/CountDownLatch.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/CountDownLatch.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/CountDownLatch.h Fri Jul  2 19:04:44 2010
@@ -74,8 +74,7 @@ namespace concurrent{
          * @throws InterruptedException - if the current thread is interrupted while waiting.
          * @throws Exception - if any other error occurs.
          */
-        virtual void await() throw ( decaf::lang::exceptions::InterruptedException,
-                                     decaf::lang::Exception );
+        virtual void await();
 
         /**
          * Causes the current thread to wait until the latch has counted down to zero, unless the
@@ -107,9 +106,7 @@ namespace concurrent{
          * @throws InterruptedException - if the current thread is interrupted while waiting.
          * @throws Exception - if any other error occurs.
          */
-        virtual bool await( long long timeOut )
-            throw ( decaf::lang::exceptions::InterruptedException,
-                    decaf::lang::Exception );
+        virtual bool await( long long timeOut );
 
         /**
          * Causes the current thread to wait until the latch has counted down to zero, unless the
@@ -142,9 +139,7 @@ namespace concurrent{
          * @throws InterruptedException - if the current thread is interrupted while waiting.
          * @throws Exception - if any other error occurs.
          */
-        virtual bool await( long long timeout, const TimeUnit& unit )
-            throw ( decaf::lang::exceptions::InterruptedException,
-                    decaf::lang::Exception );
+        virtual bool await( long long timeout, const TimeUnit& unit );
 
         /**
          * Counts down the latch, releasing all waiting threads when

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Executor.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Executor.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Executor.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Executor.h Fri Jul  2 19:04:44 2010
@@ -101,9 +101,7 @@ namespace concurrent {
          *
          * @throws NullPointerException if command is null
          */
-        virtual void execute( Runnable* command )
-            throw ( decaf::util::concurrent::RejectedExecutionException,
-                    decaf::lang::exceptions::NullPointerException ) = 0;
+        virtual void execute( Runnable* command ) = 0;
 
     };
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ExecutorService.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ExecutorService.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ExecutorService.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ExecutorService.h Fri Jul  2 19:04:44 2010
@@ -67,8 +67,7 @@ namespace concurrent {
          *
          * @throws InterruptedException - if interrupted while waiting.
          */
-        bool awaitTermination( long long timeout, const TimeUnit& unit )
-            throw( decaf::lang::exceptions::InterruptedException ) = 0;
+        bool awaitTermination( long long timeout, const TimeUnit& unit ) = 0;
 
     };
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Future.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Future.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Future.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Future.h Fri Jul  2 19:04:44 2010
@@ -82,7 +82,7 @@ namespace concurrent {
          * @throws ExecutionException - if the computation threw an exception
          * @throws InterruptedException - if the current thread was interrupted while waiting
          */
-        V get() throw( CancellationException, InterruptedException, ExecutionException ) = 0;
+        V get() = 0;
 
         /**
          * Waits if necessary for at most the given time for the computation to complete, and
@@ -95,8 +95,7 @@ namespace concurrent {
          * @throws InterruptedException - if the current thread was interrupted while waiting
          * @throws TimeoutException - if the wait timed out
          */
-        V get( long long timeout, TimeUnit unit)
-            throw( InterruptedException, ExecutionException, TimeoutException ) = 0;
+        V get( long long timeout, TimeUnit unit ) = 0;
 
     };
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Mutex.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Mutex.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Mutex.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Mutex.cpp Fri Jul  2 19:04:44 2010
@@ -70,46 +70,37 @@ Mutex::~Mutex() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Mutex::lock() throw( decaf::lang::exceptions::RuntimeException ) {
+void Mutex::lock() {
 
     MutexImpl::lock( this->properties->mutex );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool Mutex::tryLock() throw( decaf::lang::exceptions::RuntimeException ) {
+bool Mutex::tryLock() {
 
     return MutexImpl::trylock( this->properties->mutex );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Mutex::unlock() throw( decaf::lang::exceptions::RuntimeException ) {
+void Mutex::unlock() {
 
     MutexImpl::unlock( this->properties->mutex );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Mutex::wait() throw( decaf::lang::exceptions::RuntimeException,
-                          decaf::lang::exceptions::IllegalMonitorStateException,
-                          decaf::lang::exceptions::InterruptedException ) {
+void Mutex::wait() {
 
     ConditionImpl::wait( this->properties->condition );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Mutex::wait( long long millisecs )
-    throw( decaf::lang::exceptions::RuntimeException,
-           decaf::lang::exceptions::IllegalMonitorStateException,
-           decaf::lang::exceptions::InterruptedException ) {
+void Mutex::wait( long long millisecs ) {
 
     wait( millisecs, 0 );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Mutex::wait( long long millisecs, int nanos )
-    throw( decaf::lang::exceptions::RuntimeException,
-           decaf::lang::exceptions::IllegalArgumentException,
-           decaf::lang::exceptions::IllegalMonitorStateException,
-           decaf::lang::exceptions::InterruptedException ) {
+void Mutex::wait( long long millisecs, int nanos ) {
 
     if( millisecs < 0 ) {
         throw IllegalArgumentException(
@@ -125,15 +116,13 @@ void Mutex::wait( long long millisecs, i
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Mutex::notify() throw( decaf::lang::exceptions::RuntimeException,
-                            decaf::lang::exceptions::IllegalMonitorStateException ) {
+void Mutex::notify() {
 
     ConditionImpl::notify( this->properties->condition );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Mutex::notifyAll() throw( decaf::lang::exceptions::RuntimeException,
-                               decaf::lang::exceptions::IllegalMonitorStateException ) {
+void Mutex::notifyAll() {
 
     ConditionImpl::notifyAll( this->properties->condition );
 }

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Mutex.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Mutex.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Mutex.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Mutex.h Fri Jul  2 19:04:44 2010
@@ -52,32 +52,21 @@ namespace concurrent{
 
         virtual ~Mutex();
 
-        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/util/concurrent/PooledThread.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/PooledThread.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/PooledThread.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/PooledThread.cpp Fri Jul  2 19:04:44 2010
@@ -31,10 +31,9 @@ using namespace decaf::util::concurrent;
 LOGDECAF_INITIALIZE(logger, PooledThread, "com.activemq.concurrent.PooledThread")
 
 ////////////////////////////////////////////////////////////////////////////////
-PooledThread::PooledThread(ThreadPool* pool)
-{
-    if(pool == NULL)
-    {
+PooledThread::PooledThread(ThreadPool* pool) {
+
+    if( pool == NULL ) {
         throw IllegalArgumentException( __FILE__, __LINE__,
             "PooledThread::PooledThread");
     }
@@ -49,13 +48,12 @@ PooledThread::PooledThread(ThreadPool* p
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-PooledThread::~PooledThread()
-{
+PooledThread::~PooledThread(){
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void PooledThread::run()
-{
+void PooledThread::run() {
+
     ThreadPool::Task task;
 
     try
@@ -158,7 +156,6 @@ void PooledThread::run()
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void PooledThread::stop() throw ( Exception )
-{
+void PooledThread::stop() {
     done = true;
 }

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/PooledThread.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/PooledThread.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/PooledThread.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/PooledThread.h Fri Jul  2 19:04:44 2010
@@ -71,7 +71,7 @@ namespace concurrent{
          * running one, and then die.  Does not block.
          * @throws Exception
          */
-        virtual void stop() throw ( lang::Exception );
+        virtual void stop();
 
         /**
          * Checks to see if the thread is busy, if busy it means
@@ -86,8 +86,7 @@ namespace concurrent{
          * notified when this thread starts and completes a task.
          * @param listener the listener to send notifications to.
          */
-        virtual void setPooledThreadListener( PooledThreadListener* listener )
-        {
+        virtual void setPooledThreadListener( PooledThreadListener* listener ) {
             this->listener = listener;
         }
 
@@ -96,8 +95,7 @@ namespace concurrent{
          * notified when this thread starts and completes a task.
          * @return a pointer to this thread's listener or NULL
          */
-        virtual PooledThreadListener* getPooledThreadListener()
-        {
+        virtual PooledThreadListener* getPooledThreadListener() {
             return this->listener;
         }
     };

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/PooledThreadListener.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/PooledThreadListener.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/PooledThreadListener.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/PooledThreadListener.h Fri Jul  2 19:04:44 2010
@@ -61,8 +61,7 @@ namespace concurrent{
          * @param thread - Pointer to the Pooled Thread that is making this call
          * @param ex - The Exception that occurred.
          */
-        virtual void onTaskException( PooledThread* thread,
-                                      lang::Exception& ex) = 0;
+        virtual void onTaskException( PooledThread* thread, lang::Exception& ex) = 0;
 
     };
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Semaphore.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Semaphore.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Semaphore.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Semaphore.cpp Fri Jul  2 19:04:44 2010
@@ -51,13 +51,11 @@ namespace concurrent {
 
 ////////////////////////////////////////////////////////////////////////////////
 Semaphore::Semaphore( int permits ) {
-
     this->handle.reset( new SemaphoreHandle( permits ) );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 Semaphore::Semaphore( int permits, bool fair ) {
-
     this->handle.reset( new SemaphoreHandle( permits, fair ) );
 }
 
@@ -66,68 +64,52 @@ Semaphore::~Semaphore() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Semaphore::acquire() throw( decaf::lang::exceptions::InterruptedException,
-                                 decaf::lang::exceptions::RuntimeException ) {
-
+void Semaphore::acquire() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Semaphore::acquireUninterruptibly() throw ( decaf::lang::exceptions::RuntimeException ) {
-
+void Semaphore::acquireUninterruptibly() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool Semaphore::tryAcquire() throw ( decaf::lang::exceptions::RuntimeException ) {
+bool Semaphore::tryAcquire() {
     return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool Semaphore::tryAcquire( long long timeout DECAF_UNUSED, const TimeUnit& unit DECAF_UNUSED )
-    throw( decaf::lang::exceptions::InterruptedException,
-           decaf::lang::exceptions::RuntimeException ) {
-
+bool Semaphore::tryAcquire( long long timeout DECAF_UNUSED, const TimeUnit& unit DECAF_UNUSED ) {
     return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Semaphore::release() throw ( decaf::lang::exceptions::RuntimeException ) {
+void Semaphore::release() {
 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Semaphore::acquire( int permits DECAF_UNUSED ) throw( decaf::lang::exceptions::InterruptedException,
-                                                           decaf::lang::exceptions::IllegalArgumentException,
-                                                           decaf::lang::exceptions::RuntimeException ) {
+void Semaphore::acquire( int permits DECAF_UNUSED ) {
 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Semaphore::acquireUninterruptibly( int permits DECAF_UNUSED )
-    throw( decaf::lang::exceptions::IllegalArgumentException,
-           decaf::lang::exceptions::RuntimeException ) {
+void Semaphore::acquireUninterruptibly( int permits DECAF_UNUSED ) {
 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool Semaphore::tryAcquire( int permits DECAF_UNUSED )
-    throw( decaf::lang::exceptions::IllegalArgumentException,
-           decaf::lang::exceptions::RuntimeException ) {
+bool Semaphore::tryAcquire( int permits DECAF_UNUSED ) {
 
     return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool Semaphore::tryAcquire( int permits DECAF_UNUSED, long long timeout DECAF_UNUSED, const TimeUnit& unit DECAF_UNUSED )
-    throw( decaf::lang::exceptions::IllegalArgumentException,
-           decaf::lang::exceptions::RuntimeException ) {
+bool Semaphore::tryAcquire( int permits DECAF_UNUSED, long long timeout DECAF_UNUSED, const TimeUnit& unit DECAF_UNUSED ) {
 
     return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Semaphore::release( int permits DECAF_UNUSED )
-    throw( decaf::lang::exceptions::IllegalArgumentException,
-           decaf::lang::exceptions::RuntimeException ) {
+void Semaphore::release( int permits DECAF_UNUSED ) {
 
 }
 
@@ -137,7 +119,7 @@ int Semaphore::availablePermits() const 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-int Semaphore::drainPermits() throw( decaf::lang::exceptions::RuntimeException ) {
+int Semaphore::drainPermits() {
     return 0;
 }
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Semaphore.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Semaphore.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Semaphore.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Semaphore.h Fri Jul  2 19:04:44 2010
@@ -195,8 +195,7 @@ namespace concurrent {
          * @throw InterruptedException - if the current thread is interrupted.
          * @throw RuntimeException if an unexpected error occurs while acquiring the Semaphore.
          */
-        void acquire() throw( decaf::lang::exceptions::InterruptedException,
-                              decaf::lang::exceptions::RuntimeException );
+        void acquire();
 
         /**
          * Acquires a permit from this semaphore, blocking until one is available.
@@ -215,7 +214,7 @@ namespace concurrent {
          *
          * @throw RuntimeException if an unexpected error occurs while acquiring the Semaphore.
          */
-        void acquireUninterruptibly() throw ( decaf::lang::exceptions::RuntimeException );
+        void acquireUninterruptibly();
 
         /**
          * Acquires a permit from this semaphore, only if one is available at the time of invocation.
@@ -235,7 +234,7 @@ namespace concurrent {
          *
          * @throw RuntimeException if an unexpected error occurs while acquiring the Semaphore.
          */
-        bool tryAcquire() throw ( decaf::lang::exceptions::RuntimeException );
+        bool tryAcquire();
 
         /**
          * Acquires a permit from this semaphore, if one becomes available within the given waiting
@@ -273,9 +272,7 @@ namespace concurrent {
          * @throw InterruptedException if the current thread is interrupted.
          * @throw RuntimeException if an unexpected error occurs while acquiring the Semaphore.
          */
-        bool tryAcquire( long long timeout, const TimeUnit& unit )
-            throw( decaf::lang::exceptions::InterruptedException,
-                   decaf::lang::exceptions::RuntimeException );
+        bool tryAcquire( long long timeout, const TimeUnit& unit );
 
         /**
          * Releases a permit, returning it to the semaphore.
@@ -290,7 +287,7 @@ namespace concurrent {
          *
          * @throw RuntimeException if an unexpected error occurs while releasing the Semaphore.
          */
-        void release() throw ( decaf::lang::exceptions::RuntimeException );
+        void release();
 
         /**
          * Acquires the given number of permits from this semaphore, blocking until all are available,
@@ -322,9 +319,7 @@ namespace concurrent {
          * @throw IllegalArgumentException if the permits argument is negative.
          * @throw RuntimeException if an unexpected error occurs while acquiring the Semaphore.
          */
-        void acquire( int permits ) throw( decaf::lang::exceptions::InterruptedException,
-                                           decaf::lang::exceptions::IllegalArgumentException,
-                                           decaf::lang::exceptions::RuntimeException );
+        void acquire( int permits );
 
         /**
          * Acquires the given number of permits from this semaphore, blocking until all are available.
@@ -346,9 +341,7 @@ namespace concurrent {
          * @throw IllegalArgumentException if the permits argument is negative.
          * @throw RuntimeException if an unexpected error occurs while acquiring the Semaphore.
          */
-        void acquireUninterruptibly( int permits )
-            throw( decaf::lang::exceptions::IllegalArgumentException,
-                   decaf::lang::exceptions::RuntimeException );
+        void acquireUninterruptibly( int permits );
 
         /**
          * Acquires the given number of permits from this semaphore, only if all are available at the
@@ -374,9 +367,7 @@ namespace concurrent {
          * @throw IllegalArgumentException if the permits argument is negative.
          * @throw RuntimeException if an unexpected error occurs while acquiring the Semaphore.
          */
-        bool tryAcquire( int permits )
-            throw( decaf::lang::exceptions::IllegalArgumentException,
-                   decaf::lang::exceptions::RuntimeException );
+        bool tryAcquire( int permits );
 
         /**
          * Acquires the given number of permits from this semaphore, if all become available within
@@ -420,9 +411,7 @@ namespace concurrent {
          * @throw IllegalArgumentException if the permits argument is negative.
          * @throw RuntimeException if an unexpected error occurs while acquiring the Semaphore.
          */
-        bool tryAcquire( int permits, long long timeout, const TimeUnit& unit )
-            throw( decaf::lang::exceptions::IllegalArgumentException,
-                   decaf::lang::exceptions::RuntimeException );
+        bool tryAcquire( int permits, long long timeout, const TimeUnit& unit );
 
         /**
          * Releases the given number of permits, returning them to the semaphore.
@@ -440,9 +429,7 @@ namespace concurrent {
          * @throw IllegalArgumentException if the permits argument is negative.
          * @throw RuntimeException if an unexpected error occurs while releasing the Semaphore.
          */
-        void release( int permits )
-            throw( decaf::lang::exceptions::IllegalArgumentException,
-                   decaf::lang::exceptions::RuntimeException );
+        void release( int permits );
 
         /**
          * Returns the current number of permits available in this semaphore.
@@ -460,7 +447,7 @@ namespace concurrent {
          *
          * @throw RuntimeException if an unexpected error occurs while draining the Semaphore.
          */
-        int drainPermits() throw( decaf::lang::exceptions::RuntimeException );
+        int drainPermits();
 
         /**
          * @returns true if this semaphore has fairness set true

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Synchronizable.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Synchronizable.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Synchronizable.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/Synchronizable.h Fri Jul  2 19:04:44 2010
@@ -44,7 +44,7 @@ namespace concurrent{
          *
          * @throws RuntimeException if an error occurs while locking the object.
          */
-        virtual void lock() throw( decaf::lang::exceptions::RuntimeException ) = 0;
+        virtual void lock() = 0;
 
         /**
          * Attempts to Lock the object, if the lock is already held by another
@@ -55,13 +55,14 @@ namespace concurrent{
          *
          * @throws RuntimeException if an error occurs while locking the object.
          */
-        virtual bool tryLock() throw( decaf::lang::exceptions::RuntimeException ) = 0;
+        virtual bool tryLock() = 0;
 
         /**
          * Unlocks the object.
+         *
          * @throws RuntimeException if an error occurs while unlocking the object.
          */
-        virtual void unlock() throw( decaf::lang::exceptions::RuntimeException ) = 0;
+        virtual void unlock() = 0;
 
         /**
          * Waits on a signal from this object, which is generated
@@ -73,9 +74,7 @@ namespace concurrent{
          * @throws IllegalMonitorStateException - if the current thread is not the owner of the
          *         the Synchronizable Object.
          */
-        virtual void wait() throw( decaf::lang::exceptions::RuntimeException,
-                                   decaf::lang::exceptions::IllegalMonitorStateException,
-                                   decaf::lang::exceptions::InterruptedException ) = 0;
+        virtual void wait() = 0;
 
         /**
          * Waits on a signal from this object, which is generated
@@ -91,10 +90,7 @@ namespace concurrent{
          * @throws IllegalMonitorStateException - if the current thread is not the owner of the
          *         the Synchronizable Object.
          */
-        virtual void wait( long long millisecs )
-            throw( decaf::lang::exceptions::RuntimeException,
-                   decaf::lang::exceptions::IllegalMonitorStateException,
-                   decaf::lang::exceptions::InterruptedException ) = 0;
+        virtual void wait( long long millisecs ) = 0;
 
         /**
          * Waits on a signal from this object, which is generated by a call to Notify.
@@ -119,11 +115,7 @@ namespace concurrent{
          * @throws IllegalMonitorStateException - if the current thread is not the owner of the
          *         the Synchronizable Object.
          */
-        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 ) = 0;
+        virtual void wait( long long millisecs, int nanos ) = 0;
 
         /**
          * Signals a waiter on this object that it can now wake
@@ -134,8 +126,7 @@ namespace concurrent{
          *         the Synchronizable Object.
          * @throws RuntimeException if an error occurs while notifying one of the waiting threads.
          */
-        virtual void notify() throw( decaf::lang::exceptions::RuntimeException,
-                                     decaf::lang::exceptions::IllegalMonitorStateException ) = 0;
+        virtual void notify() = 0;
 
         /**
          * Signals the waiters on this object that it can now wake
@@ -146,8 +137,7 @@ namespace concurrent{
          *         the Synchronizable Object.
          * @throws RuntimeException if an error occurs while notifying the waiting threads.
          */
-        virtual void notifyAll() throw( decaf::lang::exceptions::RuntimeException,
-                                        decaf::lang::exceptions::IllegalMonitorStateException ) = 0;
+        virtual void notifyAll() = 0;
 
     };
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/SynchronousQueue.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/SynchronousQueue.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/SynchronousQueue.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/SynchronousQueue.h Fri Jul  2 19:04:44 2010
@@ -67,7 +67,7 @@ namespace concurrent {
         class EmptyIterator : public Iterator<E> {
         public:
 
-            virtual E next() throw( lang::exceptions::NoSuchElementException ) {
+            virtual E next() {
 
                 throw lang::exceptions::NoSuchElementException(
                     __FILE__, __LINE__,
@@ -78,8 +78,7 @@ namespace concurrent {
                 return false;
             }
 
-            virtual void remove() throw ( lang::exceptions::IllegalStateException,
-                                          lang::exceptions::UnsupportedOperationException ) {
+            virtual void remove() {
 
                 throw lang::exceptions::IllegalStateException(
                     __FILE__, __LINE__,
@@ -108,10 +107,7 @@ namespace concurrent {
          * @throws NullPointerException {@inheritDoc}
          * @throws IllegalArgumentException {@inheritDoc}
          */
-        virtual void put( const E& value )
-            throw( decaf::lang::exceptions::InterruptedException,
-                   decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IllegalArgumentException ) {
+        virtual void put( const E& value ) {
 
             //if (o == null) throw new NullPointerException();
             //if (transferer.transfer(o, false, 0) == null) {
@@ -131,10 +127,7 @@ namespace concurrent {
          * @throws NullPointerException {@inheritDoc}
          * @throws IllegalArgumentException {@inheritDoc}
          */
-        virtual bool offer( const E& e, long timeout, const TimeUnit& unit )
-            throw( decaf::lang::exceptions::InterruptedException,
-                   decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IllegalArgumentException ) {
+        virtual bool offer( const E& e, long timeout, const TimeUnit& unit ) {
 
             //if (o == null) throw new NullPointerException();
             //if (transferer.transfer(o, true, unit.toNanos(timeout)) != null)
@@ -160,9 +153,7 @@ namespace concurrent {
          * @throws IllegalArgumentException if some property of the specified
          *         element prevents it from being added to this queue
          */
-        virtual bool offer( const E& value )
-            throw( decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IllegalArgumentException ) {
+        virtual bool offer( const E& value ) {
 
             //if (e == null) throw new NullPointerException();
             //return transferer.transfer(e, true, 0) != null;
@@ -177,7 +168,7 @@ namespace concurrent {
          * @return the head of this queue
          * @throws InterruptedException {@inheritDoc}
          */
-        virtual E take() throw( decaf::lang::exceptions::InterruptedException ) {
+        virtual E take() {
             //Object e = transferer.transfer(null, false, 0);
             //if (e != null)
             //    return (E)e;
@@ -201,8 +192,7 @@ namespace concurrent {
          * @return true if the head of the Queue was copied to the result param
          *         or false if no value could be returned.
          */
-        virtual bool poll( E& result, long long timeout, const TimeUnit& unit )
-            throw( decaf::lang::exceptions::InterruptedException ) {
+        virtual bool poll( E& result, long long timeout, const TimeUnit& unit ) {
 
             //Object e = transferer.transfer(null, true, unit.toNanos(timeout));
             //if (e != null || !Thread.interrupted())
@@ -254,37 +244,25 @@ namespace concurrent {
             return 0;
         }
 
-        virtual void clear()
-            throw ( lang::exceptions::UnsupportedOperationException ) {}
+        virtual void clear() {}
 
-        virtual bool contains( const E& value DECAF_UNUSED ) const throw ( lang::Exception ) {
+        virtual bool contains( const E& value DECAF_UNUSED ) const {
             return false;
         }
 
-        virtual bool containsAll( const Collection<E>& collection ) const
-            throw ( lang::Exception ) {
-
+        virtual bool containsAll( const Collection<E>& collection ) const {
             return collection.isEmpty();
         }
 
-        virtual bool remove( const E& value DECAF_UNUSED )
-            throw ( lang::exceptions::UnsupportedOperationException,
-                    lang::exceptions::IllegalArgumentException ) {
-
+        virtual bool remove( const E& value DECAF_UNUSED ) {
             return false;
         }
 
-        virtual bool removeAll( const Collection<E>& collection DECAF_UNUSED )
-            throw ( lang::exceptions::UnsupportedOperationException,
-                    lang::exceptions::IllegalArgumentException ) {
-
+        virtual bool removeAll( const Collection<E>& collection DECAF_UNUSED ) {
             return false;
         }
 
-        virtual bool retainAll( const Collection<E>& collection DECAF_UNUSED )
-            throw ( lang::exceptions::UnsupportedOperationException,
-                    lang::exceptions::IllegalArgumentException ) {
-
+        virtual bool retainAll( const Collection<E>& collection DECAF_UNUSED ) {
             return false;
         }
 
@@ -294,9 +272,7 @@ namespace concurrent {
 
         virtual std::vector<E> toArray() const { return std::vector<E>(); }
 
-        virtual std::size_t drainTo( Collection<E>& c )
-            throw( decaf::lang::exceptions::UnsupportedOperationException,
-                   decaf::lang::exceptions::IllegalArgumentException ) {
+        virtual std::size_t drainTo( Collection<E>& c ) {
 
             if( (void*)&c == this ) {
                 throw decaf::lang::exceptions::IllegalArgumentException(
@@ -315,9 +291,7 @@ namespace concurrent {
             return count;
         }
 
-        virtual std::size_t drainTo( Collection<E>& c, std::size_t maxElements )
-            throw( decaf::lang::exceptions::UnsupportedOperationException,
-                   decaf::lang::exceptions::IllegalArgumentException ) {
+        virtual std::size_t drainTo( Collection<E>& c, std::size_t maxElements ) {
 
             if( (void*)&c == this ) {
                 throw decaf::lang::exceptions::IllegalArgumentException(

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ThreadPool.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ThreadPool.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ThreadPool.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ThreadPool.cpp Fri Jul  2 19:04:44 2010
@@ -90,8 +90,7 @@ ThreadPool* ThreadPool::getInstance() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void ThreadPool::queueTask( ThreadPool::Task task )
-   throw ( lang::Exception ) {
+void ThreadPool::queueTask( ThreadPool::Task task ) {
 
     try{
 
@@ -128,8 +127,7 @@ void ThreadPool::queueTask( ThreadPool::
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-ThreadPool::Task ThreadPool::deQueueTask()
-    throw ( lang::Exception ) {
+ThreadPool::Task ThreadPool::deQueueTask() {
 
     try{
         //LOGCMS_DEBUG(logger, "ThreadPool::DeQueueTask - syncing on queue");

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ThreadPool.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ThreadPool.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ThreadPool.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/ThreadPool.h Fri Jul  2 19:04:44 2010
@@ -97,8 +97,7 @@ namespace concurrent{
          * @param task object that derives from Runnable
          * @throws ActiveMQException
          */
-        virtual void queueTask( Task task )
-            throw ( lang::Exception );
+        virtual void queueTask( Task task );
 
         /**
          * DeQueue a task to be completed by one of the Pooled Threads.
@@ -110,8 +109,7 @@ namespace concurrent{
          * @return object that derives from Runnable
          * @throws ActiveMQException
          */
-        virtual Task deQueueTask()
-            throw ( lang::Exception );
+        virtual Task deQueueTask();
 
         /**
          * Returns the current number of Threads in the Pool, this is

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/TimeUnit.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/TimeUnit.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/TimeUnit.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/TimeUnit.cpp Fri Jul  2 19:04:44 2010
@@ -98,8 +98,7 @@ int TimeUnit::excessNanos( long long tim
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void TimeUnit::sleep( long long timeout ) const
-    throw( decaf::lang::exceptions::InterruptedException ) {
+void TimeUnit::sleep( long long timeout ) const {
 
     if( timeout > 0 ) {
         long long ms = toMillis( timeout );
@@ -109,9 +108,7 @@ void TimeUnit::sleep( long long timeout 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void TimeUnit::timedWait( Synchronizable* obj, long long timeout ) const
-    throw( decaf::lang::exceptions::InterruptedException,
-           decaf::lang::exceptions::NullPointerException ) {
+void TimeUnit::timedWait( Synchronizable* obj, long long timeout ) const {
 
     if( obj == NULL ) {
         throw NullPointerException(
@@ -126,9 +123,7 @@ void TimeUnit::timedWait( Synchronizable
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void TimeUnit::timedJoin( Thread* thread, long long timeout )
-    throw( decaf::lang::exceptions::InterruptedException,
-           decaf::lang::exceptions::NullPointerException ) {
+void TimeUnit::timedJoin( Thread* thread, long long timeout ) {
 
     if( thread == NULL ) {
         throw NullPointerException(
@@ -179,8 +174,7 @@ long long TimeUnit::scale( long long dur
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-const TimeUnit& TimeUnit::valueOf( const std::string& name )
-    throw ( decaf::lang::exceptions::IllegalArgumentException ) {
+const TimeUnit& TimeUnit::valueOf( const std::string& name ) {
 
     for( int i = 0; i < 7; ++i ) {
         if( values[i]->name == name ) {

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/TimeUnit.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/TimeUnit.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/TimeUnit.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/TimeUnit.h Fri Jul  2 19:04:44 2010
@@ -218,9 +218,7 @@ namespace concurrent {
          *
          * @see Synchronizable#wait( long long, long long )
          */
-        void timedWait( Synchronizable* obj, long long timeout ) const
-            throw( decaf::lang::exceptions::InterruptedException,
-                   decaf::lang::exceptions::NullPointerException );
+        void timedWait( Synchronizable* obj, long long timeout ) const;
 
         /**
          * Perform a timed <tt>Thread.join</tt> using this time unit.
@@ -235,9 +233,7 @@ namespace concurrent {
          *
          * @see Thread#join( long long, long long )
          */
-        void timedJoin( decaf::lang::Thread* thread, long long timeout )
-            throw( decaf::lang::exceptions::InterruptedException,
-                   decaf::lang::exceptions::NullPointerException );
+        void timedJoin( decaf::lang::Thread* thread, long long timeout );
 
         /**
          * Perform a <tt>Thread.sleep</tt> using this unit.
@@ -246,8 +242,7 @@ namespace concurrent {
          * @param timeout the minimum time to sleep
          * @see Thread#sleep
          */
-        void sleep( long long timeout ) const
-            throw( decaf::lang::exceptions::InterruptedException );
+        void sleep( long long timeout ) const;
 
         /**
          * Converts the TimeUnit type to the Name of the TimeUnit.
@@ -269,59 +264,16 @@ namespace concurrent {
          * @throws IllegalArgumentException
          *          if this enum type has no constant with the specified name
          */
-        static const TimeUnit& valueOf( const std::string& name )
-            throw ( decaf::lang::exceptions::IllegalArgumentException );
+        static const TimeUnit& valueOf( const std::string& name );
 
     public:
 
-        /**
-         * Compares this object with the specified object for order. Returns a
-         * negative integer, zero, or a positive integer as this object is less
-         * than, equal to, or greater than the specified object.
-         *
-         * In the foregoing description, the notation sgn(expression) designates
-         * the mathematical signum function, which is defined to return one of
-         * -1, 0, or 1 according to whether the value of expression  is negative,
-         * zero or positive. The implementor must ensure sgn(x.compareTo(y)) ==
-         * -sgn(y.compareTo(x)) for all x and y. (This implies that x.compareTo(y)
-         * must throw an exception iff y.compareTo(x) throws an exception.)
-         *
-         * The implementor must also ensure that the relation is transitive:
-         * (x.compareTo(y)>0 && y.compareTo(z)>0) implies x.compareTo(z)>0.
-         *
-         * Finally, the implementer must ensure that x.compareTo(y)==0 implies
-         * that sgn(x.compareTo(z)) == sgn(y.compareTo(z)), for all z.
-         *
-         * It is strongly recommended, but not strictly required that
-         * (x.compareTo(y)==0) == (x.equals(y)). Generally speaking, any class
-         * that implements the Comparable interface and violates this condition
-         * should clearly indicate this fact. The recommended language is
-         * "Note: this class has a natural ordering that is inconsistent with
-         * equals."
-         * @param value - the Object to be compared.
-         * @returns a negative integer, zero, or a positive integer as this
-         * object is less than, equal to, or greater than the specified object.
-         */
         virtual int compareTo( const TimeUnit& value ) const;
 
-        /**
-         * @return true if this value is considered equal to the passed value.
-         */
         virtual bool equals( const TimeUnit& value ) const;
 
-        /**
-         * Compares equality between this object and the one passed.
-         * @param value - the value to be compared to this one.
-         * @return true if this object is equal to the one passed.
-         */
         virtual bool operator==( const TimeUnit& value ) const;
 
-        /**
-         * Compares this object to another and returns true if this object
-         * is considered to be less than the one passed.  This
-         * @param value - the value to be compared to this one.
-         * @return true if this object is equal to the one passed.
-         */
         virtual bool operator<( const TimeUnit& value ) const;
 
     private:

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/locks/Condition.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/locks/Condition.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/locks/Condition.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/locks/Condition.h Fri Jul  2 19:04:44 2010
@@ -182,10 +182,7 @@ namespace locks {
          * @throws IllegalMonitorStateException
          *         if the caller is not the lock owner.
          */
-        virtual void await()
-            throw( decaf::lang::exceptions::RuntimeException,
-                   decaf::lang::exceptions::InterruptedException,
-                   decaf::lang::exceptions::IllegalMonitorStateException ) = 0;
+        virtual void await() = 0;
 
         /**
          * Causes the current thread to wait until it is signalled.
@@ -221,9 +218,7 @@ namespace locks {
          * @throws IllegalMonitorStateException
          *         if the caller is not the lock owner.
          */
-        virtual void awaitUninterruptibly()
-            throw( decaf::lang::exceptions::RuntimeException,
-                   decaf::lang::exceptions::IllegalMonitorStateException ) = 0;
+        virtual void awaitUninterruptibly() = 0;
 
         /**
          * Causes the current thread to wait until it is signaled or interrupted, or
@@ -305,10 +300,7 @@ namespace locks {
          * @throws IllegalMonitorStateException
          *         if the caller is not the lock owner.
          */
-        virtual long long awaitNanos( long long nanosTimeout )
-            throw( decaf::lang::exceptions::RuntimeException,
-                   decaf::lang::exceptions::InterruptedException,
-                   decaf::lang::exceptions::IllegalMonitorStateException ) = 0;
+        virtual long long awaitNanos( long long nanosTimeout ) = 0;
 
         /**
          * Causes the current thread to wait until it is signaled or interrupted, or the
@@ -332,10 +324,7 @@ namespace locks {
          * @throws IllegalMonitorStateException
          *         if the caller is not the lock owner.
          */
-        virtual bool await( long long time, const TimeUnit& unit )
-            throw( decaf::lang::exceptions::RuntimeException,
-                   decaf::lang::exceptions::InterruptedException,
-                   decaf::lang::exceptions::IllegalMonitorStateException ) = 0;
+        virtual bool await( long long time, const TimeUnit& unit ) = 0;
 
         /*
          * Causes the current thread to wait until it is signaled or interrupted, or the
@@ -406,10 +395,7 @@ namespace locks {
          * @throws IllegalMonitorStateException
          *         if the caller is not the lock owner.
          */
-        virtual bool awaitUntil( const Date& deadline )
-            throw( decaf::lang::exceptions::RuntimeException,
-                   decaf::lang::exceptions::InterruptedException,
-                   decaf::lang::exceptions::IllegalMonitorStateException ) = 0;
+        virtual bool awaitUntil( const Date& deadline ) = 0;
 
         /**
          * Wakes up one waiting thread.
@@ -420,7 +406,7 @@ namespace locks {
          * @throws RuntimeException
          *         if an unexpected error occurs while trying to wait on the Condition.
          */
-        virtual void signal() throw ( decaf::lang::exceptions::RuntimeException ) = 0;
+        virtual void signal() = 0;
 
         /**
          * Wakes up all waiting threads.
@@ -431,7 +417,7 @@ namespace locks {
          * @throws RuntimeException
          *         if an unexpected error occurs while trying to wait on the Condition.
          */
-        virtual void signalAll() throw ( decaf::lang::exceptions::RuntimeException ) = 0;
+        virtual void signalAll() = 0;
 
     };
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/locks/Lock.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/locks/Lock.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/locks/Lock.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/locks/Lock.h Fri Jul  2 19:04:44 2010
@@ -115,7 +115,7 @@ namespace locks {
          *
          * @throws RuntimeException if an error occurs while acquiring the lock.
          */
-        virtual void lock() throw( decaf::lang::exceptions::RuntimeException ) = 0;
+        virtual void lock() = 0;
 
         /**
          * Acquires the lock unless the current thread is interrupted.
@@ -157,8 +157,7 @@ namespace locks {
          *         if the current thread is interrupted while acquiring the lock (and
          *         interruption of lock acquisition is supported).
          */
-        virtual void lockInterruptibly() throw ( decaf::lang::exceptions::RuntimeException,
-                                                 decaf::lang::exceptions::InterruptedException ) = 0;
+        virtual void lockInterruptibly() = 0;
 
         /**
          * Acquires the lock only if it is free at the time of invocation.
@@ -187,7 +186,7 @@ namespace locks {
          *
          * @throws RuntimeException if an error occurs while acquiring the lock.
          */
-        virtual bool tryLock() throw( decaf::lang::exceptions::RuntimeException ) = 0;
+        virtual bool tryLock() = 0;
 
         /**
          * Acquires the lock if it is free within the given waiting time and the current
@@ -244,9 +243,7 @@ namespace locks {
          *         if the current thread is interrupted while acquiring the lock (and
          *         interruption of lock acquisition is supported)
          */
-        virtual bool tryLock( long long time, const TimeUnit& unit )
-            throw ( decaf::lang::exceptions::RuntimeException,
-                    decaf::lang::exceptions::InterruptedException ) = 0;
+        virtual bool tryLock( long long time, const TimeUnit& unit ) = 0;
 
         /**
          * Releases the lock.
@@ -261,8 +258,7 @@ namespace locks {
          * @throws RuntimeException if an error occurs while acquiring the lock.
          * @throws IllegalMonitorStateException if the current thread is not the owner of the lock.
          */
-        virtual void unlock() throw( decaf::lang::exceptions::RuntimeException,
-                                     decaf::lang::exceptions::IllegalMonitorStateException ) = 0;
+        virtual void unlock() = 0;
 
         /**
          * Returns a new Condition instance that is bound to this Lock instance.
@@ -283,9 +279,7 @@ namespace locks {
          * @throws UnsupportedOperationException
          *         if this Lock implementation does not support conditions
          */
-        virtual Condition* newCondition()
-            throw ( decaf::lang::exceptions::RuntimeException,
-                    decaf::lang::exceptions::UnsupportedOperationException ) = 0;
+        virtual Condition* newCondition() = 0;
 
     };
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/locks/ReentrantLock.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/locks/ReentrantLock.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/locks/ReentrantLock.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/locks/ReentrantLock.cpp Fri Jul  2 19:04:44 2010
@@ -179,33 +179,19 @@ namespace locks{
 #endif
         }
 
-        virtual void await()
-            throw( decaf::lang::exceptions::RuntimeException,
-                   decaf::lang::exceptions::InterruptedException,
-                   decaf::lang::exceptions::IllegalMonitorStateException );
-
-        virtual void awaitUninterruptibly()
-            throw( decaf::lang::exceptions::RuntimeException,
-                   decaf::lang::exceptions::IllegalMonitorStateException );
-
-        virtual long long awaitNanos( long long nanosTimeout )
-            throw( decaf::lang::exceptions::RuntimeException,
-                   decaf::lang::exceptions::InterruptedException,
-                   decaf::lang::exceptions::IllegalMonitorStateException );
-
-        virtual bool await( long long time, const TimeUnit& unit )
-            throw( decaf::lang::exceptions::RuntimeException,
-                   decaf::lang::exceptions::InterruptedException,
-                   decaf::lang::exceptions::IllegalMonitorStateException );
-
-        virtual bool awaitUntil( const Date& deadline )
-            throw( decaf::lang::exceptions::RuntimeException,
-                   decaf::lang::exceptions::InterruptedException,
-                   decaf::lang::exceptions::IllegalMonitorStateException );
+        virtual void await();
 
-        virtual void signal() throw ( decaf::lang::exceptions::RuntimeException );
+        virtual void awaitUninterruptibly();
 
-        virtual void signalAll() throw ( decaf::lang::exceptions::RuntimeException );
+        virtual long long awaitNanos( long long nanosTimeout );
+
+        virtual bool await( long long time, const TimeUnit& unit );
+
+        virtual bool awaitUntil( const Date& deadline );
+
+        virtual void signal();
+
+        virtual void signalAll();
 
     };
 
@@ -225,7 +211,7 @@ ReentrantLock::~ReentrantLock() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void ReentrantLock::lock() throw( decaf::lang::exceptions::RuntimeException ) {
+void ReentrantLock::lock() {
 
     long long threadId = Thread::getId();
 
@@ -258,14 +244,13 @@ void ReentrantLock::lock() throw( decaf:
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void ReentrantLock::lockInterruptibly() throw ( decaf::lang::exceptions::RuntimeException,
-                                                decaf::lang::exceptions::InterruptedException ) {
+void ReentrantLock::lockInterruptibly() {
 
     this->lock();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool ReentrantLock::tryLock() throw( decaf::lang::exceptions::RuntimeException ) {
+bool ReentrantLock::tryLock() {
 
     long long threadId = Thread::getId();
 
@@ -299,9 +284,7 @@ bool ReentrantLock::tryLock() throw( dec
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool ReentrantLock::tryLock( long long time DECAF_UNUSED, const TimeUnit& unit DECAF_UNUSED )
-    throw ( decaf::lang::exceptions::RuntimeException,
-            decaf::lang::exceptions::InterruptedException ) {
+bool ReentrantLock::tryLock( long long time DECAF_UNUSED, const TimeUnit& unit DECAF_UNUSED ) {
 
 //    long long threadId = Thread::getId();
 //
@@ -324,8 +307,7 @@ bool ReentrantLock::tryLock( long long t
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void ReentrantLock::unlock() throw( decaf::lang::exceptions::RuntimeException,
-                                    decaf::lang::exceptions::IllegalMonitorStateException ) {
+void ReentrantLock::unlock() {
 
     if( handle->lock_owner_tid == 0 ) {
         return;
@@ -357,9 +339,7 @@ void ReentrantLock::unlock() throw( deca
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-Condition* ReentrantLock::newCondition()
-    throw ( decaf::lang::exceptions::RuntimeException,
-            decaf::lang::exceptions::UnsupportedOperationException ) {
+Condition* ReentrantLock::newCondition() {
 
     return new ConditionObject( this->handle.get() );
 }
@@ -415,10 +395,7 @@ std::string ReentrantLock::toString() co
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void ConditionObject::await()
-    throw( decaf::lang::exceptions::RuntimeException,
-           decaf::lang::exceptions::InterruptedException,
-           decaf::lang::exceptions::IllegalMonitorStateException ) {
+void ConditionObject::await() {
 
     // Save the current owner as we are going to unlock and release for
     // someone else to lock on potentially.  When we come back and
@@ -448,18 +425,12 @@ void ConditionObject::await()
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void ConditionObject::awaitUninterruptibly()
-    throw( decaf::lang::exceptions::RuntimeException,
-           decaf::lang::exceptions::IllegalMonitorStateException ) {
-
+void ConditionObject::awaitUninterruptibly() {
     this->await();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-long long ConditionObject::awaitNanos( long long nanosTimeout )
-    throw( decaf::lang::exceptions::RuntimeException,
-           decaf::lang::exceptions::InterruptedException,
-           decaf::lang::exceptions::IllegalMonitorStateException ) {
+long long ConditionObject::awaitNanos( long long nanosTimeout ) {
 
     // Save the current owner as we are going to unlock and release for
     // someone else to lock on potentially.  When we come back and
@@ -508,25 +479,19 @@ long long ConditionObject::awaitNanos( l
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool ConditionObject::await( long long time DECAF_UNUSED, const TimeUnit& unit DECAF_UNUSED )
-    throw( decaf::lang::exceptions::RuntimeException,
-           decaf::lang::exceptions::InterruptedException,
-           decaf::lang::exceptions::IllegalMonitorStateException ) {
+bool ConditionObject::await( long long time DECAF_UNUSED, const TimeUnit& unit DECAF_UNUSED ) {
 
     return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool ConditionObject::awaitUntil( const Date& deadline DECAF_UNUSED )
-    throw( decaf::lang::exceptions::RuntimeException,
-           decaf::lang::exceptions::InterruptedException,
-           decaf::lang::exceptions::IllegalMonitorStateException ) {
+bool ConditionObject::awaitUntil( const Date& deadline DECAF_UNUSED ) {
 
     return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void ConditionObject::signal() throw ( decaf::lang::exceptions::RuntimeException ) {
+void ConditionObject::signal() {
 
 #ifdef HAVE_PTHREAD_H
     if( pthread_cond_signal( &condition ) ) {
@@ -562,7 +527,7 @@ void ConditionObject::signal() throw ( d
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void ConditionObject::signalAll() throw ( decaf::lang::exceptions::RuntimeException ) {
+void ConditionObject::signalAll() {
 
 #ifdef HAVE_PTHREAD_H
     if( pthread_cond_broadcast( &condition ) ) {

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/locks/ReentrantLock.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/locks/ReentrantLock.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/locks/ReentrantLock.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/concurrent/locks/ReentrantLock.h Fri Jul  2 19:04:44 2010
@@ -103,7 +103,7 @@ namespace locks {
          *
          * @throws RuntimeException if an error occurs while acquiring the lock.
          */
-        virtual void lock() throw( decaf::lang::exceptions::RuntimeException );
+        virtual void lock();
 
         /**
          * Acquires the lock unless the current thread is interrupted.
@@ -137,8 +137,7 @@ namespace locks {
          *         if the current thread is interrupted while acquiring the lock (and
          *         interruption of lock acquisition is supported).
          */
-        virtual void lockInterruptibly() throw ( decaf::lang::exceptions::RuntimeException,
-                                                 decaf::lang::exceptions::InterruptedException );
+        virtual void lockInterruptibly();
 
         /**
          * Acquires the lock only if it is not held by another thread at the time of invocation.
@@ -161,7 +160,7 @@ namespace locks {
          *
          * @throws RuntimeException if an error occurs while acquiring the lock.
          */
-        virtual bool tryLock() throw( decaf::lang::exceptions::RuntimeException );
+        virtual bool tryLock();
 
         /**
          * Acquires the lock if it is not held by another thread within the given waiting time and the
@@ -214,9 +213,7 @@ namespace locks {
          *         if the current thread is interrupted while acquiring the lock (and
          *         interruption of lock acquisition is supported)
          */
-        virtual bool tryLock( long long time, const TimeUnit& unit )
-            throw ( decaf::lang::exceptions::RuntimeException,
-                    decaf::lang::exceptions::InterruptedException );
+        virtual bool tryLock( long long time, const TimeUnit& unit );
 
         /**
          * Attempts to release this lock.
@@ -227,8 +224,7 @@ namespace locks {
          *
          * @throws RuntimeException if an error occurs while acquiring the lock.
          */
-        virtual void unlock() throw( decaf::lang::exceptions::RuntimeException,
-                                     decaf::lang::exceptions::IllegalMonitorStateException );
+        virtual void unlock();
 
         /**
          * Returns a Condition instance for use with this Lock instance.
@@ -252,9 +248,7 @@ namespace locks {
          * @throws UnsupportedOperationException
          *         if this Lock implementation does not support conditions
          */
-        virtual Condition* newCondition()
-            throw ( decaf::lang::exceptions::RuntimeException,
-                    decaf::lang::exceptions::UnsupportedOperationException );
+        virtual Condition* newCondition();
 
         /**
          * Queries the number of holds on this lock by the current thread.

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/ConsoleHandler.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/ConsoleHandler.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/ConsoleHandler.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/ConsoleHandler.cpp Fri Jul  2 19:04:44 2010
@@ -32,7 +32,7 @@ ConsoleHandler::ConsoleHandler() : Strea
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void ConsoleHandler::close() throw ( decaf::io::IOException ) {
+void ConsoleHandler::close() {
     StreamHandler::close( true );
 }
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/ConsoleHandler.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/ConsoleHandler.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/ConsoleHandler.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/ConsoleHandler.h Fri Jul  2 19:04:44 2010
@@ -67,7 +67,7 @@ namespace logging{
          * but doesn't close.
          * @throw IOException
          */
-        virtual void close() throw ( decaf::io::IOException );
+        virtual void close();
 
         /**
          * Publish the Log Record to this Handler

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.cpp Fri Jul  2 19:04:44 2010
@@ -80,8 +80,7 @@ bool Level::operator<( const Level& valu
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-Level Level::parse( const std::string& name )
-    throw( decaf::lang::exceptions::IllegalArgumentException ) {
+Level Level::parse( const std::string& name ) {
 
     bool isNameAnInt;
     int nameAsInt;

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.h Fri Jul  2 19:04:44 2010
@@ -223,8 +223,7 @@ namespace logging {
          *         string is either a valid int (between Integer::MIN_VALUE and Integer::MAX_VALUE
          *         or is one of the known level names.
          */
-        static Level parse( const std::string& name )
-            throw( decaf::lang::exceptions::IllegalArgumentException );
+        static Level parse( const std::string& name );
 
     };
 

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.cpp Fri Jul  2 19:04:44 2010
@@ -90,9 +90,7 @@ void LogManager::removePropertyChangeLis
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool LogManager::addLogger( Logger* logger DECAF_UNUSED )
-    throw( decaf::lang::exceptions::NullPointerException,
-           decaf::lang::exceptions::IllegalArgumentException ) {
+bool LogManager::addLogger( Logger* logger DECAF_UNUSED ) {
 
     return false;
 }
@@ -138,14 +136,11 @@ void LogManager::shutdown() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void LogManager::readConfiguration()
-    throw( decaf::io::IOException ) {
+void LogManager::readConfiguration() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void LogManager::readConfiguration( decaf::io::InputStream* stream DECAF_UNUSED )
-    throw( decaf::io::IOException,
-           decaf::lang::exceptions::NullPointerException ) {
+void LogManager::readConfiguration( decaf::io::InputStream* stream DECAF_UNUSED ) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.h Fri Jul  2 19:04:44 2010
@@ -172,9 +172,7 @@ namespace logging{
          * @throws NullPointerException if logger is NULL.
          * @throws IllegalArgumentException if the logger has no name.
          */
-        bool addLogger( Logger* logger )
-            throw( decaf::lang::exceptions::NullPointerException,
-                   decaf::lang::exceptions::IllegalArgumentException );
+        bool addLogger( Logger* logger );
 
         /**
          * Retrieves or creates a new Logger using the name specified
@@ -254,7 +252,7 @@ namespace logging{
          *
          * @throws IOException if an I/O error occurs.
          */
-        void readConfiguration() throw( decaf::io::IOException );
+        void readConfiguration();
 
         /**
          * Reinitialize the logging properties and reread the logging configuration from the
@@ -270,9 +268,7 @@ namespace logging{
          * @throws NullPointerException if stream is NULL.
          * @throws IOException if an I/O error occurs.
          */
-        void readConfiguration( decaf::io::InputStream* stream )
-            throw( decaf::io::IOException,
-                   decaf::lang::exceptions::NullPointerException );
+        void readConfiguration( decaf::io::InputStream* stream );
 
         /**
          * Reset the logging configuration.

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.cpp Fri Jul  2 19:04:44 2010
@@ -43,7 +43,7 @@ Logger::~Logger() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Logger::addHandler( Handler* handler ) throw ( NullPointerException ) {
+void Logger::addHandler( Handler* handler ) {
 
     if( handler == NULL ) {
         NullPointerException(

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.h Fri Jul  2 19:04:44 2010
@@ -170,8 +170,7 @@ namespace logging{
          *
          * @throws NullPointerException if the Handler given is NULL.
          */
-        void addHandler( Handler* handler )
-            throw ( lang::exceptions::NullPointerException );
+        void addHandler( Handler* handler );
 
         /**
          * Removes the specified Handler from this logger, ownership of the

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/StreamHandler.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/StreamHandler.cpp?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/StreamHandler.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/StreamHandler.cpp Fri Jul  2 19:04:44 2010
@@ -68,7 +68,7 @@ StreamHandler::~StreamHandler() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void StreamHandler::close() throw ( decaf::io::IOException ) {
+void StreamHandler::close() {
     this->close( true );
 }
 
@@ -127,8 +127,7 @@ bool StreamHandler::isLoggable( const Lo
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void StreamHandler::setOuputStream( decaf::io::OutputStream* stream )
-    throw( decaf::lang::exceptions::NullPointerException ) {
+void StreamHandler::setOuputStream( decaf::io::OutputStream* stream ) {
 
     if( stream == NULL ) {
         throw NullPointerException(

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/StreamHandler.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/StreamHandler.h?rev=960088&r1=960087&r2=960088&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/StreamHandler.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/StreamHandler.h Fri Jul  2 19:04:44 2010
@@ -89,7 +89,7 @@ namespace logging{
          *
          * @throw IOException if an I/O error occurs.
          */
-        virtual void close() throw ( decaf::io::IOException );
+        virtual void close();
 
         /**
          * Flush the Handler's output, clears any buffers.
@@ -128,8 +128,7 @@ namespace logging{
          *
          * @throws NullPointerException if the passed stream is NULL.
          */
-        virtual void setOuputStream( decaf::io::OutputStream* stream )
-            throw( decaf::lang::exceptions::NullPointerException );
+        virtual void setOuputStream( decaf::io::OutputStream* stream );
 
         /**
          * Closes this handler, but the underlying output stream is only closed if



Mime
View raw message