various: remove SAL_THROW macro

Change-Id: I9464179a736b91f5bc32eb5e5e89b3b4e3da3494

3 files changed, 24 insertions, 26 deletions

diff --git a/include/salhelper/dynload.hxx b/include/salhelper/dynload.hxx
index 35eb81159558..d4942b8b6a53 100644
--- a/include/salhelper/dynload.hxx
+++ b/include/salhelper/dynload.hxx
@@ -106,7 +106,7 @@ class ODynamicLoader
 {
 public:
     /// Default constructor
-    ODynamicLoader() SAL_THROW(())
+    ODynamicLoader()
     {
         m_pLoader = 0;
     }
@@ -118,7 +118,7 @@ public:
         @param strInitFunction specifies the name of the initialization function.
      */
     ODynamicLoader( const ::rtl::OUString& strModuleName,
-                       const ::rtl::OUString& strInitFunction ) SAL_THROW(())
+                       const ::rtl::OUString& strInitFunction )
     {
         if (!m_pStaticLoader)
         {
@@ -136,7 +136,7 @@ public:
     }
 
     /// Copy constructor
-    ODynamicLoader(const ODynamicLoader<API>& toCopy) SAL_THROW(())
+    ODynamicLoader(const ODynamicLoader<API>& toCopy)
     {
         m_pLoader = toCopy.m_pLoader;
         if( m_pLoader )
@@ -144,14 +144,14 @@ public:
     }
 
     /// Destructor, decrease the reference count and unload the library if it is tha last instance.
-    ~ODynamicLoader() SAL_THROW(())
+    ~ODynamicLoader()
     {
         if( m_pLoader )
             m_pLoader->release();
     }
 
     /// Assign operator
-    ODynamicLoader<API>& SAL_CALL operator = (const ODynamicLoader<API>& toAssign) SAL_THROW(())
+    ODynamicLoader<API>& SAL_CALL operator = (const ODynamicLoader<API>& toAssign)
     {
         if( m_pLoader != toAssign.m_pLoader )
         {
@@ -170,19 +170,19 @@ public:
     }
 
     /// returns a poiner to the initialized API function structure.
-    API* SAL_CALL getApi() const SAL_THROW(())
+    API* SAL_CALL getApi() const
     {
         return (API*)m_pLoader->getApi();
     }
 
     /// cast operator, which cast to a poiner with the initialized API function structure.
-    API* SAL_CALL operator->() const SAL_THROW(())
+    API* SAL_CALL operator->() const
     {
         return (API*)m_pLoader->getApi();
     }
 
     /// checks if the loader works on a loaded and initialized library.
-    bool SAL_CALL isLoaded() const SAL_THROW(())
+    bool SAL_CALL isLoaded() const
     {
         return (m_pLoader != NULL);
     }
diff --git a/include/salhelper/refobj.hxx b/include/salhelper/refobj.hxx
index 5c5aa8fc9969..6278e2f0fc64 100644
--- a/include/salhelper/refobj.hxx
+++ b/include/salhelper/refobj.hxx
@@ -45,36 +45,36 @@ class ReferenceObject : public rtl::IReference
 public:
     /** Allocation.
      */
-    static void* operator new (size_t n) SAL_THROW(())
+    static void* operator new (size_t n)
     {
         return ::rtl_allocateMemory (n);
     }
-    static void operator delete (void* p) SAL_THROW(())
+    static void operator delete (void* p)
     {
         ::rtl_freeMemory (p);
     }
-    static void* operator new (size_t, void* p) SAL_THROW(())
+    static void* operator new (size_t, void* p)
     {
         return (p);
     }
-    static void operator delete (void*, void*) SAL_THROW(())
+    static void operator delete (void*, void*)
     {}
 
 public:
     /** Construction.
      */
-    inline ReferenceObject() SAL_THROW(()) : m_nReferenceCount (0)
+    inline ReferenceObject() : m_nReferenceCount (0)
     {}
 
 
     /** IReference.
      */
-    virtual oslInterlockedCount SAL_CALL acquire() SAL_THROW(()) SAL_OVERRIDE
+    virtual oslInterlockedCount SAL_CALL acquire() SAL_OVERRIDE
     {
         return osl_atomic_increment (&m_nReferenceCount);
     }
 
-    virtual oslInterlockedCount SAL_CALL release() SAL_THROW(()) SAL_OVERRIDE
+    virtual oslInterlockedCount SAL_CALL release() SAL_OVERRIDE
     {
         oslInterlockedCount result;
         result = ::osl_atomic_decrement (&m_nReferenceCount);
@@ -89,7 +89,7 @@ public:
 protected:
     /** Destruction.
      */
-    virtual ~ReferenceObject() SAL_THROW(())
+    virtual ~ReferenceObject()
     {
         OSL_ASSERT(m_nReferenceCount == 0);
     }
diff --git a/include/salhelper/simplereferenceobject.hxx b/include/salhelper/simplereferenceobject.hxx
index 5f901c3f1015..b150fb238c14 100644
--- a/include/salhelper/simplereferenceobject.hxx
+++ b/include/salhelper/simplereferenceobject.hxx
@@ -58,7 +58,7 @@ namespace salhelper {
 class SALHELPER_DLLPUBLIC SimpleReferenceObject
 {
 public:
-    inline SimpleReferenceObject() SAL_THROW(()): m_nCount(0) {}
+    inline SimpleReferenceObject(): m_nCount(0) {}
 
     /** @attention
         The results are undefined if, for any individual instance of
@@ -66,33 +66,31 @@ public:
         the total number of calls to release() by a platform dependent amount
         (which, hopefully, is quite large).
      */
-    inline void acquire() SAL_THROW(())
+    inline void acquire()
     { osl_atomic_increment(&m_nCount); }
 
-    inline void release() SAL_THROW(())
+    inline void release()
     { if (osl_atomic_decrement(&m_nCount) == 0) delete this; }
 
     /** see general class documentation
      */
-    static void * operator new(std::size_t nSize) SAL_THROW((std::bad_alloc));
+    static void * operator new(std::size_t nSize);
 
     /** see general class documentation
      */
     static void * operator new(std::size_t nSize,
-                               std::nothrow_t const & rNothrow)
-        SAL_THROW(());
+                               std::nothrow_t const & rNothrow);
 
     /** see general class documentation
      */
-    static void operator delete(void * pPtr) SAL_THROW(());
+    static void operator delete(void * pPtr);
 
     /** see general class documentation
      */
-    static void operator delete(void * pPtr, std::nothrow_t const & rNothrow)
-        SAL_THROW(());
+    static void operator delete(void * pPtr, std::nothrow_t const & rNothrow);
 
 protected:
-    virtual ~SimpleReferenceObject() SAL_THROW(());
+    virtual ~SimpleReferenceObject();
 
 private:
     oslInterlockedCount m_nCount;