Code cleanup: ( () ) replaced by (())

5 files changed, 34 insertions, 34 deletions

diff --git a/sal/inc/rtl/bootstrap.hxx b/sal/inc/rtl/bootstrap.hxx
index 1fc594683dcb..60ad350435bf 100644
--- a/sal/inc/rtl/bootstrap.hxx
+++ b/sal/inc/rtl/bootstrap.hxx
@@ -80,7 +80,7 @@ namespace rtl
             @see rtl_bootstrap_set()
         */
         static inline void set( ::rtl::OUString const & name, ::rtl::OUString const & value )
-            SAL_THROW( () );
+            SAL_THROW(());
 
         /** default ctor.
          */
@@ -125,21 +125,21 @@ namespace rtl
 
             @param macro    [inout]  The macro to be expanded
         */
-        inline void expandMacrosFrom( ::rtl::OUString & macro ) const SAL_THROW( () )
+        inline void expandMacrosFrom( ::rtl::OUString & macro ) const SAL_THROW(())
             { rtl_bootstrap_expandMacros_from_handle( _handle, &macro.pData ); }
 
         /** Expands a macro using default bootstrap variables.
 
             @param macro    [inout]  The macro to be expanded
         */
-        static inline void expandMacros( ::rtl::OUString & macro ) SAL_THROW( () )
+        static inline void expandMacros( ::rtl::OUString & macro ) SAL_THROW(())
             { rtl_bootstrap_expandMacros( &macro.pData ); }
 
         /** Provides the bootstrap internal handle.
 
             @return bootstrap handle
         */
-        inline rtlBootstrapHandle getHandle() const SAL_THROW( () )
+        inline rtlBootstrapHandle getHandle() const SAL_THROW(())
             { return _handle; }
 
         /** Escapes special characters ("$" and "\").
@@ -154,7 +154,7 @@ namespace rtl
             @since UDK 3.2.9
         */
         static inline ::rtl::OUString encode( ::rtl::OUString const & value )
-            SAL_THROW( () );
+            SAL_THROW(());
     };
 
     //----------------------------------------------------------------------------
@@ -179,7 +179,7 @@ namespace rtl
     }
 
     inline void Bootstrap::set( ::rtl::OUString const & name, ::rtl::OUString const & value )
-        SAL_THROW( () )
+        SAL_THROW(())
     {
         rtl_bootstrap_set( name.pData, value.pData );
     }
@@ -223,7 +223,7 @@ namespace rtl
     }
 
     inline ::rtl::OUString Bootstrap::encode( ::rtl::OUString const & value )
-        SAL_THROW( () )
+        SAL_THROW(())
     {
         ::rtl::OUString encoded;
         rtl_bootstrap_encode(value.pData, &encoded.pData);
diff --git a/sal/inc/rtl/byteseq.h b/sal/inc/rtl/byteseq.h
index 93e85ddcd500..8d52c7e49adc 100644
--- a/sal/inc/rtl/byteseq.h
+++ b/sal/inc/rtl/byteseq.h
@@ -172,29 +172,29 @@ class ByteSequence
 public:
     /// @cond INTERNAL
     // these are here to force memory de/allocation to sal lib.
-    inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW( () )
+    inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW(())
         { return ::rtl_allocateMemory( nSize ); }
-    inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW( () )
+    inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW(())
         { ::rtl_freeMemory( pMem ); }
-    inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW( () )
+    inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW(())
         { return pMem; }
-    inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW( () )
+    inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW(())
         {}
     /// @endcond
 
     /** Default constructor: Creates an empty sequence.
     */
-    inline ByteSequence() SAL_THROW( () );
+    inline ByteSequence() SAL_THROW(());
     /** Copy constructor: Creates a copy of given sequence.
 
         @param rSeq another byte sequence
     */
-    inline ByteSequence( const ByteSequence & rSeq ) SAL_THROW( () );
+    inline ByteSequence( const ByteSequence & rSeq ) SAL_THROW(());
     /** Copy constructor Creates a copy from the C-Handle.
 
         @param pSequence another byte sequence handle
     */
-    inline ByteSequence( sal_Sequence *pSequence ) SAL_THROW( () );
+    inline ByteSequence( sal_Sequence *pSequence ) SAL_THROW(());
     /** Constructor: Creates a copy of given data bytes.
 
         @param pElements an array of bytes
@@ -222,23 +222,23 @@ public:
         @param pSequence sequence handle to be taken over
         @param noacquire dummy parameter forcing explicit BYTESEQ_NOACQUIRE
     */
-    inline ByteSequence( sal_Sequence *pSequence , enum __ByteSequence_NoAcquire noacquire ) SAL_THROW( () );
+    inline ByteSequence( sal_Sequence *pSequence , enum __ByteSequence_NoAcquire noacquire ) SAL_THROW(());
     /** Destructor: Releases sequence handle. Last handle will free memory.
     */
-    inline ~ByteSequence() SAL_THROW( () );
+    inline ~ByteSequence() SAL_THROW(());
 
     /** Assignment operator: Acquires given sequence handle and releases a previously set handle.
 
         @param rSeq another byte sequence
         @return this sequence
     */
-    inline ByteSequence & SAL_CALL operator = ( const ByteSequence & rSeq ) SAL_THROW( () );
+    inline ByteSequence & SAL_CALL operator = ( const ByteSequence & rSeq ) SAL_THROW(());
 
     /** Gets the length of sequence.
 
         @return length of sequence
     */
-    inline sal_Int32 SAL_CALL getLength() const SAL_THROW( () )
+    inline sal_Int32 SAL_CALL getLength() const SAL_THROW(())
         { return _pSequence->nElements; }
 
     /** Gets a pointer to byte array for READING. If the sequence has a length of 0, then the
@@ -246,7 +246,7 @@ public:
 
         @return pointer to byte array
     */
-    inline const sal_Int8 * SAL_CALL getConstArray() const SAL_THROW( () )
+    inline const sal_Int8 * SAL_CALL getConstArray() const SAL_THROW(())
         { return (const sal_Int8 *)_pSequence->elements; }
     /** Gets a pointer to elements array for READING AND WRITING. In general if the sequence
         has a handle acquired by other sequences (reference count > 1), then a new sequence is
@@ -277,7 +277,7 @@ public:
         @param nIndex index
         @return const C++ reference to byte at element of indenx nIndex
     */
-    inline const sal_Int8 & SAL_CALL operator [] ( sal_Int32 nIndex ) const SAL_THROW( () )
+    inline const sal_Int8 & SAL_CALL operator [] ( sal_Int32 nIndex ) const SAL_THROW(())
         { return getConstArray()[ nIndex ]; }
 
     /** Equality operator: Compares two sequences.
@@ -285,13 +285,13 @@ public:
         @param rSeq another byte sequence (right side)
         @return true if both sequences are equal, false otherwise
     */
-    inline sal_Bool SAL_CALL operator == ( const ByteSequence & rSeq ) const SAL_THROW( () );
+    inline sal_Bool SAL_CALL operator == ( const ByteSequence & rSeq ) const SAL_THROW(());
     /** Unequality operator: Compares two sequences.
 
         @param rSeq another byte sequence (right side)
         @return false if both sequences are equal, true otherwise
     */
-    inline sal_Bool SAL_CALL operator != ( const ByteSequence & rSeq ) const SAL_THROW( () );
+    inline sal_Bool SAL_CALL operator != ( const ByteSequence & rSeq ) const SAL_THROW(());
 
     /** Reallocates sequence to new length. If the sequence has a handle acquired by other sequences
         (reference count > 1), then the remaining elements are copied to a new sequence handle to
@@ -305,13 +305,13 @@ public:
 
         @return UNacquired handle of the sequence
     */
-    inline sal_Sequence * SAL_CALL getHandle() const SAL_THROW( () )
+    inline sal_Sequence * SAL_CALL getHandle() const SAL_THROW(())
         { return _pSequence; }
     /** Returns the UNnacquired C handle of the sequence (for compatibility reasons)
 
         @return UNacquired handle of the sequence
     */
-    inline sal_Sequence * SAL_CALL get() const SAL_THROW( () )
+    inline sal_Sequence * SAL_CALL get() const SAL_THROW(())
         { return _pSequence; }
 };
 
diff --git a/sal/inc/rtl/byteseq.hxx b/sal/inc/rtl/byteseq.hxx
index c0ccc13f7b94..852670e2a017 100644
--- a/sal/inc/rtl/byteseq.hxx
+++ b/sal/inc/rtl/byteseq.hxx
@@ -42,19 +42,19 @@ namespace rtl
 {
 
 //__________________________________________________________________________________________________
-inline ByteSequence::ByteSequence() SAL_THROW( () )
+inline ByteSequence::ByteSequence() SAL_THROW(())
     : _pSequence( 0 )
 {
     ::rtl_byte_sequence_construct( &_pSequence, 0 );
 }
 //__________________________________________________________________________________________________
-inline ByteSequence::ByteSequence( const ByteSequence & rSeq ) SAL_THROW( () )
+inline ByteSequence::ByteSequence( const ByteSequence & rSeq ) SAL_THROW(())
     : _pSequence( 0 )
 {
     ::rtl_byte_sequence_assign( &_pSequence, rSeq._pSequence );
 }
 //__________________________________________________________________________________________________
-inline ByteSequence::ByteSequence( sal_Sequence *pSequence) SAL_THROW( () )
+inline ByteSequence::ByteSequence( sal_Sequence *pSequence) SAL_THROW(())
     : _pSequence( pSequence )
 {
     ::rtl_byte_sequence_acquire( pSequence );
@@ -80,7 +80,7 @@ inline ByteSequence::ByteSequence( sal_Int32 len, enum __ByteSequence_NoDefault
 #endif
 }
 //__________________________________________________________________________________________________
-inline ByteSequence::ByteSequence( sal_Sequence *pSequence, enum __ByteSequence_NoAcquire ) SAL_THROW( () )
+inline ByteSequence::ByteSequence( sal_Sequence *pSequence, enum __ByteSequence_NoAcquire ) SAL_THROW(())
     : _pSequence( pSequence )
 {
 }
@@ -95,18 +95,18 @@ inline ByteSequence::ByteSequence( sal_Int32 len )
 #endif
 }
 //__________________________________________________________________________________________________
-inline ByteSequence::~ByteSequence() SAL_THROW( () )
+inline ByteSequence::~ByteSequence() SAL_THROW(())
 {
     ::rtl_byte_sequence_release( _pSequence );
 }
 //__________________________________________________________________________________________________
-inline ByteSequence & ByteSequence::operator = ( const ByteSequence & rSeq ) SAL_THROW( () )
+inline ByteSequence & ByteSequence::operator = ( const ByteSequence & rSeq ) SAL_THROW(())
 {
     ::rtl_byte_sequence_assign( &_pSequence, rSeq._pSequence );
     return *this;
 }
 //__________________________________________________________________________________________________
-inline sal_Bool ByteSequence::operator == ( const ByteSequence & rSeq ) const SAL_THROW( () )
+inline sal_Bool ByteSequence::operator == ( const ByteSequence & rSeq ) const SAL_THROW(())
 {
     return ::rtl_byte_sequence_equals( _pSequence, rSeq._pSequence );
 }
@@ -135,7 +135,7 @@ inline sal_Int8 & ByteSequence::operator [] ( sal_Int32 nIndex )
     return getArray()[ nIndex ];
 }
 //__________________________________________________________________________________________________
-inline sal_Bool ByteSequence::operator != ( const ByteSequence & rSeq ) const SAL_THROW( () )
+inline sal_Bool ByteSequence::operator != ( const ByteSequence & rSeq ) const SAL_THROW(())
 {
     return (! operator == ( rSeq ));
 }
diff --git a/sal/inc/rtl/ustring.hxx b/sal/inc/rtl/ustring.hxx
index f13f57cd6c20..ace4b1ae7179 100644
--- a/sal/inc/rtl/ustring.hxx
+++ b/sal/inc/rtl/ustring.hxx
@@ -128,7 +128,7 @@ public:
         @param str
                OUString data
     */
-    inline OUString( rtl_uString * str, __sal_NoAcquire ) SAL_THROW( () )
+    inline OUString( rtl_uString * str, __sal_NoAcquire ) SAL_THROW(())
         { pData = str; }
 
     /**
diff --git a/sal/inc/sal/types.h b/sal/inc/sal/types.h
index 6c613c060a50..f04c14cd0ff1 100644
--- a/sal/inc/sal/types.h
+++ b/sal/inc/sal/types.h
@@ -376,7 +376,7 @@ typedef struct _sal_Sequence
     use common C++ throw statement for throwing exceptions, e.g.
     throw RuntimeException();
 
-    SAL_THROW()          should be used for all C++ functions, e.g. SAL_THROW( () )
+    SAL_THROW()          should be used for all C++ functions, e.g. SAL_THROW(())
     SAL_THROW_EXTERN_C() should be used for all C functions
 */
 #ifdef __cplusplus