1 files changed, 37 insertions, 71 deletions

diff --git a/cpp/src/IceUtil/ThreadException.cpp b/cpp/src/IceUtil/ThreadException.cpp
index 7429e8449f3..769cd264d3d 100644
--- a/cpp/src/IceUtil/ThreadException.cpp
+++ b/cpp/src/IceUtil/ThreadException.cpp
@@ -11,162 +11,128 @@
 
 using namespace std;
 
-IceUtil::ThreadSyscallException::ThreadSyscallException(const char* file, int line, int err ): 
-    SyscallException(file, line, err)
+IceUtil::ThreadSyscallException::ThreadSyscallException(const char* file, int line, int err ):
+    SyscallExceptionHelper<ThreadSyscallException>(file, line, err)
 {
 }
-    
-const char* IceUtil::ThreadSyscallException::_name = "IceUtil::ThreadSyscallException";
 
 string
-IceUtil::ThreadSyscallException::ice_name() const
+IceUtil::ThreadSyscallException::ice_id() const
 {
-    return _name;
+    return "::IceUtil::ThreadSyscallException";
 }
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::ThreadSyscallException*
 IceUtil::ThreadSyscallException::ice_clone() const
 {
     return new ThreadSyscallException(*this);
 }
-
-void
-IceUtil::ThreadSyscallException::ice_throw() const
-{
-    throw *this;
-}
+#endif
 
 IceUtil::ThreadLockedException::ThreadLockedException(const char* file, int line) :
-    Exception(file, line)
+    ExceptionHelper<ThreadLockedException>(file, line)
 {
 }
 
-const char* IceUtil::ThreadLockedException::_name = "IceUtil::ThreadLockedException";
-
 string
-IceUtil::ThreadLockedException::ice_name() const
+IceUtil::ThreadLockedException::ice_id() const
 {
-    return _name;
+    return "::IceUtil::ThreadLockedException";
 }
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::ThreadLockedException*
 IceUtil::ThreadLockedException::ice_clone() const
 {
     return new ThreadLockedException(*this);
 }
+#endif
 
-void
-IceUtil::ThreadLockedException::ice_throw() const
-{
-    throw *this;
-}
 
 IceUtil::ThreadStartedException::ThreadStartedException(const char* file, int line) :
-    Exception(file, line)
+    ExceptionHelper<ThreadStartedException>(file, line)
 {
 }
 
-const char* IceUtil::ThreadStartedException::_name = "IceUtil::ThreadStartedException";
-
 string
-IceUtil::ThreadStartedException::ice_name() const
+IceUtil::ThreadStartedException::ice_id() const
 {
-    return _name;
+    return "::IceUtil::ThreadStartedException";
 }
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::ThreadStartedException*
 IceUtil::ThreadStartedException::ice_clone() const
 {
     return new ThreadStartedException(*this);
 }
-
-void
-IceUtil::ThreadStartedException::ice_throw() const
-{
-    throw *this;
-}
+#endif
 
 IceUtil::ThreadNotStartedException::ThreadNotStartedException(const char* file, int line) :
-    Exception(file, line)
+    ExceptionHelper<ThreadNotStartedException>(file, line)
 {
 }
 
-const char* IceUtil::ThreadNotStartedException::_name = "IceUtil::ThreadNotStartedException";
-
 string
-IceUtil::ThreadNotStartedException::ice_name() const
+IceUtil::ThreadNotStartedException::ice_id() const
 {
-    return _name;
+    return "::IceUtil::ThreadNotStartedException";
 }
 
+
+#ifndef ICE_CPP11_MAPPING
 IceUtil::ThreadNotStartedException*
 IceUtil::ThreadNotStartedException::ice_clone() const
 {
     return new ThreadNotStartedException(*this);
 }
-
-void
-IceUtil::ThreadNotStartedException::ice_throw() const
-{
-    throw *this;
-}
+#endif
 
 
 IceUtil::BadThreadControlException::BadThreadControlException(const char* file, int line) :
-    Exception(file, line)
+    ExceptionHelper<BadThreadControlException>(file, line)
 {
 }
 
-const char* IceUtil::BadThreadControlException::_name = "IceUtil::BadThreadControlException";
-
 string
-IceUtil::BadThreadControlException::ice_name() const
+IceUtil::BadThreadControlException::ice_id() const
 {
-    return _name;
+    return "::IceUtil::BadThreadControlException";
 }
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::BadThreadControlException*
 IceUtil::BadThreadControlException::ice_clone() const
 {
     return new BadThreadControlException(*this);
 }
+#endif
 
-void
-IceUtil::BadThreadControlException::ice_throw() const
-{
-    throw *this;
-}
-
-IceUtil::InvalidTimeoutException::InvalidTimeoutException(const char* file, int line, 
-                                                          const IceUtil::Time& timeout) : 
-    Exception(file, line),
+IceUtil::InvalidTimeoutException::InvalidTimeoutException(const char* file, int line,
+                                                          const IceUtil::Time& timeout) :
+    ExceptionHelper<InvalidTimeoutException>(file, line),
     _timeout(timeout)
 {
 }
-    
-const char* IceUtil::InvalidTimeoutException::_name = "IceUtil::InvalidTimeoutException";
 
 string
-IceUtil::InvalidTimeoutException::ice_name() const
+IceUtil::InvalidTimeoutException::ice_id() const
 {
-    return _name;
-}
-
-void
-IceUtil::InvalidTimeoutException::ice_print(ostream& os) const
-{
-    Exception::ice_print(os);
-    os << ":\ninvalid timeout: " << _timeout << " seconds";
+    return "::IceUtil::InvalidTimeoutException";
 }
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::InvalidTimeoutException*
 IceUtil::InvalidTimeoutException::ice_clone() const
 {
     return new InvalidTimeoutException(*this);
 }
+#endif
 
 void
-IceUtil::InvalidTimeoutException::ice_throw() const
+IceUtil::InvalidTimeoutException::ice_print(ostream& os) const
 {
-    throw *this;
+    Exception::ice_print(os);
+    os << ":\ninvalid timeout: " << _timeout << " seconds";
 }