[Libreoffice-commits] .: 2 commits - package/source

Caolán McNamara caolan at kemper.freedesktop.org
Wed Apr 13 12:38:49 PDT 2011


 package/source/xstor/owriteablestream.cxx |  146 ++---
 package/source/xstor/xstorage.cxx         |  814 +++++++++++++++---------------
 2 files changed, 480 insertions(+), 480 deletions(-)

New commits:
commit 2a7bacf66abbdee13ea6cdf887fa6099f9decaaa
Author: Caolán McNamara <caolanm at redhat.com>
Date:   Wed Apr 13 10:56:30 2011 +0100

    catch by const reference

diff --git a/package/source/xstor/owriteablestream.cxx b/package/source/xstor/owriteablestream.cxx
index c1c5e8f..927a796 100644
--- a/package/source/xstor/owriteablestream.cxx
+++ b/package/source/xstor/owriteablestream.cxx
@@ -99,7 +99,7 @@ void StaticAddLog( const ::rtl::OUString& aMessage )
             xLogRing->logString( aMessage );
         }
     }
-    catch( uno::Exception& )
+    catch( const uno::Exception& )
     {
         // No log
     }
@@ -121,9 +121,9 @@ void SetEncryptionKeyProperty_Impl( const uno::Reference< beans::XPropertySet >&
     try {
         xPropertySet->setPropertyValue( aString_EncryptionKey, uno::makeAny( aKey ) );
     }
-    catch ( uno::Exception& aException )
+    catch ( const uno::Exception& rException )
     {
-        ::package::StaticAddLog( aException.Message );
+        ::package::StaticAddLog( rException.Message );
         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't set encryption") ) );
         OSL_FAIL( "Can't write encryption related properties!\n" );
         throw io::IOException(); // TODO
@@ -141,9 +141,9 @@ uno::Any GetEncryptionKeyProperty_Impl( const uno::Reference< beans::XPropertySe
     try {
         return xPropertySet->getPropertyValue( aString_EncryptionKey );
     }
-    catch ( uno::Exception& aException )
+    catch ( const uno::Exception& rException )
     {
-        ::package::StaticAddLog( aException.Message );
+        ::package::StaticAddLog( rException.Message );
         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Can't get encryption property" ) ) );
 
         OSL_FAIL( "Can't get encryption related properties!\n" );
@@ -185,9 +185,9 @@ sal_Bool KillFile( const ::rtl::OUString& aURL, const uno::Reference< lang::XMul
             bRet = sal_True;
         }
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-        ::package::StaticAddLog( aException.Message );
+        ::package::StaticAddLog( rException.Message );
         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception") ) );
     }
 
@@ -213,9 +213,9 @@ const sal_Int32 n_ConstBufferSize = 32000;
         uno::Any aUrl = xTempFile->getPropertyValue( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Uri") ) );
         aUrl >>= aTempURL;
     }
-    catch ( uno::Exception& aException )
+    catch ( const uno::Exception& rException )
     {
-        ::package::StaticAddLog( aException.Message );
+        ::package::StaticAddLog( rException.Message );
         ::package::StaticAddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception") ) );
     }
     
@@ -296,7 +296,7 @@ void OWriteStream_Impl::CleanCacheStream()
             if ( xInputCache.is() )
                 xInputCache->closeInput();
         }
-        catch( uno::Exception& )
+        catch( const uno::Exception& )
         {}
 
         try
@@ -305,7 +305,7 @@ void OWriteStream_Impl::CleanCacheStream()
             if ( xOutputCache.is() )
                 xOutputCache->closeOutput();
         }
-        catch( uno::Exception& )
+        catch( const uno::Exception& )
         {}
 
         m_xCacheStream = uno::Reference< io::XStream >();
@@ -324,7 +324,7 @@ void OWriteStream_Impl::AddLog( const ::rtl::OUString& aMessage )
             if ( aContext.is() )
                 m_xLogRing.set( aContext.getSingleton( "com.sun.star.logging.DocumentIOLogRing" ), uno::UNO_QUERY_THROW );
         }
-        catch( uno::Exception& )
+        catch( const uno::Exception& )
         {
             // No log
         }
@@ -478,9 +478,9 @@ void OWriteStream_Impl::DisposeWrappers()
         try {
             m_pAntiImpl->dispose();
         }	 
-        catch ( uno::RuntimeException& aRuntimeException )
+        catch ( const uno::RuntimeException& rRuntimeException )
         {
-            AddLog( aRuntimeException.Message );
+            AddLog( rRuntimeException.Message );
             AddLog( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(OSL_LOG_PREFIX "Quiet exception") ) );
         }
         
@@ -543,17 +543,17 @@ uno::Reference< lang::XMultiServiceFactory > OWriteStream_Impl::GetServiceFactor
                     throw io::IOException(); // TODO:
             }
         }
-        catch( packages::WrongPasswordException& aWrongPasswordException )
+        catch( const packages::WrongPasswordException& rWrongPasswordException )
         {
-            AddLog( aWrongPasswordException.Message );
+            AddLog( rWrongPasswordException.Message );
             AddLog( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow") ) );
 
             KillFile( aTempURL, GetServiceFactory() );
             throw;
         }
-        catch( uno::Exception& aException )
+        catch( const uno::Exception& rException )
         {
-            AddLog( aException.Message );
+            AddLog( rException.Message );
             AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow") ) );
 
             KillFile( aTempURL, GetServiceFactory() );
@@ -637,14 +637,14 @@ uno::Reference< lang::XMultiServiceFactory > OWriteStream_Impl::GetServiceFactor
                             throw io::IOException(); // TODO:
                     }
                 }
-                catch( packages::WrongPasswordException& )
+                catch( const packages::WrongPasswordException& )
                 {
                     KillFile( m_aTempURL, GetServiceFactory() );
                     m_aTempURL = ::rtl::OUString();
 
                     throw;
                 }
-                catch( uno::Exception& )
+                catch( const uno::Exception& )
                 {
                     KillFile( m_aTempURL, GetServiceFactory() );
                     m_aTempURL = ::rtl::OUString();
@@ -681,10 +681,10 @@ uno::Reference< io::XStream > OWriteStream_Impl::GetTempFileAsStream()
             {
                 xTempStream = xTempAccess->openFileReadWrite( m_aTempURL );
             }
-            catch( uno::Exception& aException )
+            catch( const uno::Exception& rException )
             {
-        AddLog( aException.Message );
-        AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
+                AddLog( rException.Message );
+                AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
             }
         }
     }
@@ -726,9 +726,9 @@ uno::Reference< io::XInputStream > OWriteStream_Impl::GetTempFileAsInputStream()
             {
                 xInputStream = xTempAccess->openFileRead( m_aTempURL );
             }
-            catch( uno::Exception& aException )
+            catch( const uno::Exception& rException )
             {
-                AddLog( aException.Message );
+                AddLog( rException.Message );
                 AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
             }
         }
@@ -875,7 +875,7 @@ void OWriteStream_Impl::Commit()
         {
             xInStream.set( static_cast< io::XInputStream* >( new OSelfTerminateFileStream( GetServiceFactory(), m_aTempURL ) ), uno::UNO_QUERY );
         }
-        catch( uno::Exception& )
+        catch( const uno::Exception& )
         {
         }
 
@@ -1083,9 +1083,9 @@ void OWriteStream_Impl::ReadRelInfoIfNecessary()
             m_xOrigRelInfoStream = uno::Reference< io::XInputStream >();
             m_nRelInfoStatus = RELINFO_READ;
         }
-        catch( uno::Exception& aException )
+        catch( const uno::Exception& rException )
         {
-            AddLog( aException.Message );
+            AddLog( rException.Message );
             AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
 
             m_nRelInfoStatus = RELINFO_BROKEN;
@@ -1105,7 +1105,7 @@ void OWriteStream_Impl::ReadRelInfoIfNecessary()
 
             m_nRelInfoStatus = RELINFO_CHANGED_STREAM_READ;
         }
-        catch( uno::Exception )
+        catch( const uno::Exception& )
         {
             m_nRelInfoStatus = RELINFO_CHANGED_BROKEN;
         }
@@ -1153,9 +1153,9 @@ uno::Sequence< beans::PropertyValue > OWriteStream_Impl::ReadPackageStreamProper
             try {
                 aResult[nInd].Value = xPropSet->getPropertyValue( aResult[nInd].Name );
             }
-            catch( uno::Exception& aException )
+            catch( const uno::Exception& rException )
             {
-                AddLog( aException.Message );
+                AddLog( rException.Message );
                 AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
 
                 OSL_FAIL( "A property can't be retrieved!\n" );
@@ -1274,7 +1274,7 @@ uno::Reference< io::XStream > OWriteStream_Impl::GetStream( sal_Int32 nStreamMod
             m_bHasCachedEncryptionData = sal_True;
             m_aEncryptionData = aEncryptionData;
         }
-        catch( packages::WrongPasswordException& )
+        catch( const packages::WrongPasswordException& )
         {
             // retry with different encoding
             SetEncryptionKeyProperty_Impl( xPropertySet, aEncryptionData.getUnpackedValueOrDefault( PACKAGE_ENCRYPTIONDATA_SHA1MS1252, uno::Sequence< sal_Int8 >() ) );
@@ -1297,16 +1297,16 @@ uno::Reference< io::XStream > OWriteStream_Impl::GetStream( sal_Int32 nStreamMod
                         m_pParent->m_bIsModified = sal_True;
                 }
             }
-            catch( packages::WrongPasswordException& aWrongPasswordException )
+            catch( const packages::WrongPasswordException& rWrongPasswordException )
             {
                 SetEncryptionKeyProperty_Impl( xPropertySet, uno::Sequence< sal_Int8 >() );
-                AddLog( aWrongPasswordException.Message );
+                AddLog( rWrongPasswordException.Message );
                 AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
                 throw;
             }
-            catch ( uno::Exception& aException )
+            catch ( const uno::Exception& rException )
             {
-                AddLog( aException.Message );
+                AddLog( rException.Message );
                 AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
 
                 OSL_FAIL( "Can't write encryption related properties!\n" );
@@ -1314,11 +1314,11 @@ uno::Reference< io::XStream > OWriteStream_Impl::GetStream( sal_Int32 nStreamMod
                 throw io::IOException(); // TODO:
             }
         }
-        catch( uno::Exception& aException )
+        catch( const uno::Exception& rException )
         {
             SetEncryptionKeyProperty_Impl( xPropertySet, uno::Sequence< sal_Int8 >() );
 
-            AddLog( aException.Message );
+            AddLog( rException.Message );
             AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
             throw;
         }
@@ -1349,9 +1349,9 @@ uno::Reference< io::XStream > OWriteStream_Impl::GetStream( sal_Int32 nStreamMod
         {
             aGlobalEncryptionData = GetCommonRootEncryptionData();
         }
-        catch( packages::NoEncryptionException& aNoEncryptionException )
+        catch( const packages::NoEncryptionException& rNoEncryptionException )
         {
-            AddLog( aNoEncryptionException.Message );
+            AddLog( rNoEncryptionException.Message );
             AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
             throw packages::WrongPasswordException();
@@ -1586,9 +1586,9 @@ void OWriteStream_Impl::GetCopyOfLastCommit( uno::Reference< io::XStream >& xTar
         {
             aGlobalEncryptionData = GetCommonRootEncryptionData();
         }
-        catch( packages::NoEncryptionException& aNoEncryptionException )
+        catch( const packages::NoEncryptionException& rNoEncryptionException )
         {
-            AddLog( aNoEncryptionException.Message );
+            AddLog( rNoEncryptionException.Message );
             AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "No Element" ) ) );
 
             throw packages::WrongPasswordException();
@@ -1659,7 +1659,7 @@ void OWriteStream_Impl::GetCopyOfLastCommit( uno::Reference< io::XStream >& xTar
                 SetEncryptionKeyProperty_Impl( xPropertySet, uno::Sequence< sal_Int8 >() );
             }
         }
-        catch( packages::WrongPasswordException& aWrongPasswordException )
+        catch( const packages::WrongPasswordException& rWrongPasswordException )
         {
             SetEncryptionKeyProperty_Impl( xPropertySet, aEncryptionData.getUnpackedValueOrDefault( PACKAGE_ENCRYPTIONDATA_SHA1MS1252, uno::Sequence< sal_Int8 >() ) );
             try {
@@ -1669,24 +1669,24 @@ void OWriteStream_Impl::GetCopyOfLastCommit( uno::Reference< io::XStream >& xTar
                 {
                     OSL_FAIL( "Encrypted ZipStream must already have input stream inside!\n" );
                     SetEncryptionKeyProperty_Impl( xPropertySet, uno::Sequence< sal_Int8 >() );
-                    AddLog( aWrongPasswordException.Message );
+                    AddLog( rWrongPasswordException.Message );
                     AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
                     throw;
                 }
             }
-            catch( uno::Exception& aException )
+            catch( const uno::Exception& rException )
             {
                 SetEncryptionKeyProperty_Impl( xPropertySet, uno::Sequence< sal_Int8 >() );
-                AddLog( aException.Message );
+                AddLog( rException.Message );
                 AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
                 throw;
             }
         }
-        catch( uno::Exception& aException )
+        catch( const uno::Exception& rException )
         {
             OSL_FAIL( "Can't open encrypted stream!\n" );
             SetEncryptionKeyProperty_Impl( xPropertySet, uno::Sequence< sal_Int8 >() );
-            AddLog( aException.Message );
+            AddLog( rException.Message );
             AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
             throw;
         }
@@ -1861,9 +1861,9 @@ OWriteStream::~OWriteStream()
             try {
                 dispose();
             }
-            catch( uno::RuntimeException& aRuntimeException )
+            catch( const uno::RuntimeException& rRuntimeException )
             {
-                m_pImpl->AddLog( aRuntimeException.Message );
+                m_pImpl->AddLog( rRuntimeException.Message );
                 m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
             }
         }
@@ -1946,7 +1946,7 @@ void OWriteStream::CopyToStreamInternally_Impl( const uno::Reference< io::XStrea
     try {
         ::comphelper::OStorageHelper::CopyInputToOutput( m_xInStream, xDestOutStream );
     }
-    catch ( uno::Exception& e )
+    catch ( const uno::Exception& e )
     {
         eThrown = e;
         bThrown = sal_True;
@@ -1957,9 +1957,9 @@ void OWriteStream::CopyToStreamInternally_Impl( const uno::Reference< io::XStrea
     try {
         m_xSeekable->seek( nCurPos );
     } 
-    catch ( uno::Exception& aException )
+    catch ( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( aException.Message );
+        m_pImpl->AddLog( rException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
 
         // TODO: set the stoream in invalid state or dispose
@@ -2633,9 +2633,9 @@ void SAL_CALL OWriteStream::dispose()
                     m_pImpl->Revert();
                 }
             }
-            catch( uno::Exception& aException )
+            catch( const uno::Exception& rException )
             {
-                m_pImpl->AddLog( aException.Message );
+                m_pImpl->AddLog( rException.Message );
                 m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
                 uno::Any aCaught( ::cppu::getCaughtException() );
@@ -2778,9 +2778,9 @@ sal_Bool SAL_CALL OWriteStream::hasByID(  const ::rtl::OUString& sID )
         getRelationshipByID( sID );
         return sal_True;
     }
-    catch( container::NoSuchElementException& aNoSuchElementException )
+    catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( aNoSuchElementException.Message );
+        m_pImpl->AddLog( rNoSuchElementException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "No Element" ) ) );
     }
 
@@ -3487,27 +3487,27 @@ void SAL_CALL OWriteStream::commit()
         // when the storage is commited the parent is modified
         ModifyParentUnlockMutex_Impl( aGuard );
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( aException.Message );
+        m_pImpl->AddLog( rException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
         uno::Any aCaught( ::cppu::getCaughtException() );
@@ -3551,27 +3551,27 @@ void SAL_CALL OWriteStream::revert()
     try {
         m_pImpl->Revert();
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( aException.Message );
+        m_pImpl->AddLog( rException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
         uno::Any aCaught( ::cppu::getCaughtException() );
commit 23125b4732a0ed29d1c71b3546190b059efe7e52
Author: Caolán McNamara <caolanm at redhat.com>
Date:   Wed Apr 13 10:37:02 2011 +0100

    catch by const reference

diff --git a/package/source/xstor/xstorage.cxx b/package/source/xstor/xstorage.cxx
index ab3c5f3..51ef167 100644
--- a/package/source/xstor/xstorage.cxx
+++ b/package/source/xstor/xstorage.cxx
@@ -318,9 +318,9 @@ OStorage_Impl::~OStorage_Impl()
             try {
                 m_pAntiImpl->InternalDispose( sal_False );
             }
-            catch ( uno::Exception& aException )
+            catch ( const uno::Exception& rException )
             {
-                AddLog( aException.Message );
+                AddLog( rException.Message );
                 AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
             }
             m_pAntiImpl = NULL;
@@ -334,9 +334,9 @@ OStorage_Impl::~OStorage_Impl()
                 if ( xTmp.is() )
                     try {
                         pStorageIter->m_pPointer->InternalDispose( sal_False );
-                    } catch( uno::Exception& aException )
+                    } catch( const uno::Exception& rException )
                     {
-                        AddLog( aException.Message );
+                        AddLog( rException.Message );
                         AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
                     }
             }
@@ -395,10 +395,10 @@ OStorage_Impl::~OStorage_Impl()
                     m_xStream = uno::Reference< io::XStream >();
                 }
             }
-            catch( uno::Exception& aException )
+            catch( const uno::Exception& rException )
             {
                 AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
-                AddLog( aException.Message );
+                AddLog( rException.Message );
             }
         }
     }
@@ -415,7 +415,7 @@ void OStorage_Impl::AddLog( const ::rtl::OUString& aMessage )
             if ( aContext.is() )
                 m_xLogRing.set( aContext.getSingleton( "com.sun.star.logging.DocumentIOLogRing" ), uno::UNO_QUERY_THROW );
         }
-        catch( uno::Exception& )
+        catch( const uno::Exception& )
         {
             // No log
         }
@@ -444,10 +444,10 @@ void OStorage_Impl::RemoveReadOnlyWrap( OStorage& aStorage )
         {
             try {
                 pStorageIter->m_pPointer->InternalDispose( sal_False );
-            } catch( uno::Exception& aException )
+            } catch( const uno::Exception& rException )
             {
                 AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
-                AddLog( aException.Message );
+                AddLog( rException.Message );
             }
 
             OStorageList_Impl::iterator pIterToDelete( pStorageIter );
@@ -619,7 +619,7 @@ void OStorage_Impl::ReadRelInfoIfNecessary()
 
             m_nRelInfoStatus = RELINFO_CHANGED_STREAM_READ;
         }
-        catch( uno::Exception )
+        catch( const uno::Exception& )
         {
             m_nRelInfoStatus = RELINFO_CHANGED_BROKEN;
         }
@@ -684,9 +684,9 @@ void OStorage_Impl::ReadContents()
                 m_aChildrenList.push_back( pNewElement );
             }
         }
-        catch( container::NoSuchElementException& aNoSuchElementException )
+        catch( const container::NoSuchElementException& rNoSuchElementException )
         {
-            AddLog( aNoSuchElementException.Message );
+            AddLog( rNoSuchElementException.Message );
             AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "NoSuchElement" ) ) );
 
             OSL_FAIL( "hasMoreElements() implementation has problems!\n" );
@@ -754,9 +754,9 @@ void OStorage_Impl::CopyToStorage( const uno::Reference< embed::XStorage >& xDes
                 if ( xEncr.is() )
                     xEncr->setEncryptionData( GetCommonRootEncryptionData().getAsConstNamedValueList() );
             }
-            catch( packages::NoEncryptionException& aNoEncryptionException )
+            catch( const packages::NoEncryptionException& rNoEncryptionException )
             {
-                AddLog( aNoEncryptionException.Message );
+                AddLog( rNoEncryptionException.Message );
                 AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "No Encryption" ) ) );
             }
         }
@@ -924,9 +924,9 @@ void OStorage_Impl::CopyStorageElement( SotElement_Impl* pElement,
                 aCommonEncryptionData = GetCommonRootEncryptionData();
                 bHasCommonEncryptionData = sal_True;
             }
-            catch( packages::NoEncryptionException& aNoEncryptionException )
+            catch( const packages::NoEncryptionException& rNoEncryptionException )
             {
-                AddLog( aNoEncryptionException.Message );
+                AddLog( rNoEncryptionException.Message );
                 AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "No Encryption" ) ) );
             }
 
@@ -979,9 +979,9 @@ void OStorage_Impl::CopyStorageElement( SotElement_Impl* pElement,
                     ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UseCommonStoragePasswordEncryption" ) ),
                     uno::Any( (sal_Bool) sal_True ) );
             }
-            catch( packages::WrongPasswordException& aWrongPasswordException )
+            catch( const packages::WrongPasswordException& rWrongPasswordException )
             {
-                AddLog( aWrongPasswordException.Message );
+                AddLog( rWrongPasswordException.Message );
                 AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Handled exception" ) ) );
 
                 // If the common storage password does not allow to open the stream
@@ -1273,7 +1273,7 @@ void OStorage_Impl::Commit()
         {
             xChangesBatch->commitChanges();
         }
-        catch( lang::WrappedTargetException& r )
+        catch( const lang::WrappedTargetException& r )
         {
             // the wrapped UseBackupException means that the target medium can be corrupted
             embed::UseBackupException aException;
@@ -1973,9 +1973,9 @@ OStorage::~OStorage()
             try {
                 dispose();
             }
-            catch( uno::RuntimeException& aRuntimeException )
+            catch( const uno::RuntimeException& rRuntimeException )
             {
-                m_pImpl->AddLog( aRuntimeException.Message );
+                m_pImpl->AddLog( rRuntimeException.Message );
                 m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Handled exception" ) ) );
             }
         }
@@ -2039,9 +2039,9 @@ void SAL_CALL OStorage::InternalDispose( sal_Bool bNotifyImpl )
 
                         try {
                             xTmp->dispose();
-                        } catch( uno::Exception& aException )
+                        } catch( const uno::Exception& rException )
                         {
-                            m_pImpl->AddLog( aException.Message );
+                            m_pImpl->AddLog( rException.Message );
                             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
                         }
                     }
@@ -2421,39 +2421,39 @@ void SAL_CALL OStorage::copyToStorage( const uno::Reference< embed::XStorage >&
     try {
         m_pImpl->CopyToStorage( xDest, sal_False );
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -2512,45 +2512,45 @@ uno::Reference< io::XStream > SAL_CALL OStorage::openStreamElement(
             MakeLinkToSubComponent_Impl( xStreamComponent );
         }
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( packages::WrongPasswordException& aWrongPasswordException )
+    catch( const packages::WrongPasswordException& rWrongPasswordException )
     {
-        m_pImpl->AddLog( aWrongPasswordException.Message );
+        m_pImpl->AddLog( rWrongPasswordException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -2693,39 +2693,39 @@ uno::Reference< embed::XStorage > SAL_CALL OStorage::openStorageElement(
             MakeLinkToSubComponent_Impl( xStorageComponent );
         }
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -2771,45 +2771,45 @@ uno::Reference< io::XStream > SAL_CALL OStorage::cloneStreamElement( const ::rtl
             throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
         return xResult;
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( packages::WrongPasswordException& aWrongPasswordException )
+    catch( const packages::WrongPasswordException& rWrongPasswordException )
     {
-        m_pImpl->AddLog( aWrongPasswordException.Message );
+        m_pImpl->AddLog( rWrongPasswordException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -2859,39 +2859,39 @@ void SAL_CALL OStorage::copyLastCommitTo(
     {
         m_pImpl->CopyLastCommitTo( xTargetStorage );
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -2959,39 +2959,39 @@ void SAL_CALL OStorage::copyStorageElementLastCommitTo(
         else
             throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); // TODO: general_error
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -3029,33 +3029,33 @@ sal_Bool SAL_CALL OStorage::isStreamElement( const ::rtl::OUString& aElementName
     {
         pElement = m_pImpl->FindElement( aElementName );
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( container::NoSuchElementException& aNoSuchElementException )
+    catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( aNoSuchElementException.Message );
+        m_pImpl->AddLog( rNoSuchElementException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -3098,33 +3098,33 @@ sal_Bool SAL_CALL OStorage::isStorageElement( const ::rtl::OUString& aElementNam
     {
         pElement = m_pImpl->FindElement( aElementName );
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( container::NoSuchElementException& aNoSuchElementException )
+    catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( aNoSuchElementException.Message );
+        m_pImpl->AddLog( rNoSuchElementException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -3180,45 +3180,45 @@ void SAL_CALL OStorage::removeElement( const ::rtl::OUString& aElementName )
         m_pImpl->m_bIsModified = sal_True;
         m_pImpl->m_bBroadcastModified = sal_True;
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( container::NoSuchElementException& aNoSuchElementException )
+    catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( aNoSuchElementException.Message );
+        m_pImpl->AddLog( rNoSuchElementException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -3279,51 +3279,51 @@ void SAL_CALL OStorage::renameElement( const ::rtl::OUString& aElementName, cons
         m_pImpl->m_bIsModified = sal_True;
         m_pImpl->m_bBroadcastModified = sal_True;
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( container::NoSuchElementException& aNoSuchElementException )
+    catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( aNoSuchElementException.Message );
+        m_pImpl->AddLog( rNoSuchElementException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( container::ElementExistException& aElementExistException )
+    catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( aElementExistException.Message );
+        m_pImpl->AddLog( rElementExistException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -3387,51 +3387,51 @@ void SAL_CALL OStorage::copyElementTo(	const ::rtl::OUString& aElementName,
 
         m_pImpl->CopyStorageElement( pElement, xDest, aNewName, sal_False );
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( container::NoSuchElementException& aNoSuchElementException )
+    catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( aNoSuchElementException.Message );
+        m_pImpl->AddLog( rNoSuchElementException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( container::ElementExistException& aElementExistException )
+    catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( aElementExistException.Message );
+        m_pImpl->AddLog( rElementExistException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -3499,51 +3499,51 @@ void SAL_CALL OStorage::moveElementTo(	const ::rtl::OUString& aElementName,
         m_pImpl->m_bIsModified = sal_True;
         m_pImpl->m_bBroadcastModified = sal_True;
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( container::NoSuchElementException& aNoSuchElementException )
+    catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( aNoSuchElementException.Message );
+        m_pImpl->AddLog( rNoSuchElementException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( container::ElementExistException& aElementExistException )
+    catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( aElementExistException.Message );
+        m_pImpl->AddLog( rElementExistException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -3610,51 +3610,51 @@ uno::Reference< io::XStream > SAL_CALL OStorage::openEncryptedStream(
             MakeLinkToSubComponent_Impl( xStreamComponent );
         }
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( packages::NoEncryptionException& aNoEncryptionException )
+    catch( const packages::NoEncryptionException& rNoEncryptionException )
     {
-        m_pImpl->AddLog( aNoEncryptionException.Message );
+        m_pImpl->AddLog( rNoEncryptionException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( packages::WrongPasswordException& aWrongPasswordException )
+    catch( const packages::WrongPasswordException& rWrongPasswordException )
     {
-        m_pImpl->AddLog( aWrongPasswordException.Message );
+        m_pImpl->AddLog( rWrongPasswordException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -3706,51 +3706,51 @@ uno::Reference< io::XStream > SAL_CALL OStorage::cloneEncryptedStream(
             throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
         return xResult;
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( packages::NoEncryptionException& aNoEncryptionException )
+    catch( const packages::NoEncryptionException& rNoEncryptionException )
     {
-        m_pImpl->AddLog( aNoEncryptionException.Message );
+        m_pImpl->AddLog( rNoEncryptionException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( packages::WrongPasswordException& aWrongPasswordException )
+    catch( const packages::WrongPasswordException& rWrongPasswordException )
     {
-        m_pImpl->AddLog( aWrongPasswordException.Message );
+        m_pImpl->AddLog( rWrongPasswordException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -3824,45 +3824,45 @@ uno::Reference< io::XInputStream > SAL_CALL OStorage::getPlainRawStreamElement(
         xTempOut->closeOutput();
         xSeek->seek( 0 );
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( container::NoSuchElementException& aNoSuchElementException )
+    catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( aNoSuchElementException.Message );
+        m_pImpl->AddLog( rNoSuchElementException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -3938,51 +3938,51 @@ uno::Reference< io::XInputStream > SAL_CALL OStorage::getRawEncrStreamElement(
         xSeek->seek( 0 );
 
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( packages::NoEncryptionException& aNoEncryptionException )
+    catch( const packages::NoEncryptionException& rNoEncryptionException )
     {
-        m_pImpl->AddLog( aNoEncryptionException.Message );
+        m_pImpl->AddLog( rNoEncryptionException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( container::NoSuchElementException& aNoSuchElementException )
+    catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( aNoSuchElementException.Message );
+        m_pImpl->AddLog( rNoSuchElementException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -4035,51 +4035,51 @@ void SAL_CALL OStorage::insertRawEncrStreamElement( const ::rtl::OUString& aStre
 
         m_pImpl->InsertRawStream( aStreamName, xInStream );
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( packages::NoRawFormatException& aNoRawFormatException )
+    catch( const packages::NoRawFormatException& rNoRawFormatException )
     {
-        m_pImpl->AddLog( aNoRawFormatException.Message );
+        m_pImpl->AddLog( rNoRawFormatException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( container::ElementExistException& aElementExistException )
+    catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( aElementExistException.Message );
+        m_pImpl->AddLog( rElementExistException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -4123,27 +4123,27 @@ void SAL_CALL OStorage::commit()
         if ( m_pImpl->m_pParent && m_pImpl->m_pParent->m_pAntiImpl )
             xParentModif = (util::XModifiable*)m_pImpl->m_pParent->m_pAntiImpl;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( aException.Message );
+        m_pImpl->AddLog( rException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
         uno::Any aCaught( ::cppu::getCaughtException() );
@@ -4197,27 +4197,27 @@ void SAL_CALL OStorage::revert()
         m_pImpl->m_bIsModified = sal_False;
         m_pImpl->m_bBroadcastModified = sal_True;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( aException.Message );
+        m_pImpl->AddLog( rException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
         uno::Any aCaught( ::cppu::getCaughtException() );
@@ -4392,27 +4392,27 @@ uno::Any SAL_CALL OStorage::getByName( const ::rtl::OUString& aName )
         else
             aResult <<= openStreamElement( aName, embed::ElementModes::READ );
     }
-    catch( container::NoSuchElementException& aNoSuchElementException )
+    catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( aNoSuchElementException.Message );
+        m_pImpl->AddLog( rNoSuchElementException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::WrappedTargetException& aWrappedTargetException )
+    catch( const lang::WrappedTargetException& rWrappedTargetException )
     {
-        m_pImpl->AddLog( aWrappedTargetException.Message );
+        m_pImpl->AddLog( rWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch ( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-           m_pImpl->AddLog( aException.Message );
+           m_pImpl->AddLog( rException.Message );
            m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
            uno::Any aCaught( ::cppu::getCaughtException() );
@@ -4444,15 +4444,15 @@ uno::Sequence< ::rtl::OUString > SAL_CALL OStorage::getElementNames()
     {
         return m_pImpl->GetElementNames();
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch ( uno::Exception& aException )
+    catch ( const uno::Exception& rException )
     {
-           m_pImpl->AddLog( aException.Message );
+           m_pImpl->AddLog( rException.Message );
            m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
            uno::Any aCaught( ::cppu::getCaughtException() );
@@ -4490,15 +4490,15 @@ sal_Bool SAL_CALL OStorage::hasByName( const ::rtl::OUString& aName )
     {
         pElement = m_pImpl->FindElement( aName );
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch ( uno::Exception& aException )
+    catch ( const uno::Exception& rException )
     {
-           m_pImpl->AddLog( aException.Message );
+           m_pImpl->AddLog( rException.Message );
            m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
            uno::Any aCaught( ::cppu::getCaughtException() );
@@ -4547,15 +4547,15 @@ sal_Bool SAL_CALL OStorage::hasElements()
     {
         return ( m_pImpl->GetChildrenList().size() != 0 );
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch ( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-           m_pImpl->AddLog( aException.Message );
+           m_pImpl->AddLog( rException.Message );
            m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
            uno::Any aCaught( ::cppu::getCaughtException() );
@@ -4587,15 +4587,15 @@ void SAL_CALL OStorage::dispose()
     {
         InternalDispose( sal_True );
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch ( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-           m_pImpl->AddLog( aException.Message );
+           m_pImpl->AddLog( rException.Message );
            m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
            uno::Any aCaught( ::cppu::getCaughtException() );
@@ -4676,15 +4676,15 @@ void SAL_CALL OStorage::removeEncryption()
         try {
             m_pImpl->ReadContents();
         }
-        catch ( uno::RuntimeException& aRuntimeException )
+        catch ( const uno::RuntimeException& rRuntimeException )
         {
-            m_pImpl->AddLog( aRuntimeException.Message );
+            m_pImpl->AddLog( rRuntimeException.Message );
             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
             throw;
         }
-        catch ( uno::Exception& aException )
+        catch ( const uno::Exception& rException )
         {
-            m_pImpl->AddLog( aException.Message );
+            m_pImpl->AddLog( rException.Message );
             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
             uno::Any aCaught( ::cppu::getCaughtException() );
@@ -4709,9 +4709,9 @@ void SAL_CALL OStorage::removeEncryption()
             m_pImpl->m_bHasCommonEncryptionData = sal_False;
             m_pImpl->m_aCommonEncryptionData.clear();
         }
-        catch( uno::Exception& aException )
+        catch( const uno::Exception& rException )
         {
-            m_pImpl->AddLog( aException.Message );
+            m_pImpl->AddLog( rException.Message );
             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
             OSL_FAIL( "The call must not fail, it is pretty simple!" );
@@ -4750,15 +4750,15 @@ void SAL_CALL OStorage::setEncryptionData( const uno::Sequence< beans::NamedValu
         try {
             m_pImpl->ReadContents(); 
         }
-        catch ( uno::RuntimeException& aRuntimeException )
+        catch ( const uno::RuntimeException& rRuntimeException )
         {
-            m_pImpl->AddLog( aRuntimeException.Message );
+            m_pImpl->AddLog( rRuntimeException.Message );
             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
             throw;
         }
-        catch ( uno::Exception& aException )
+        catch ( const uno::Exception& rException )
         {
-            m_pImpl->AddLog( aException.Message );
+            m_pImpl->AddLog( rException.Message );
             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
             uno::Any aCaught( ::cppu::getCaughtException() );
@@ -4781,9 +4781,9 @@ void SAL_CALL OStorage::setEncryptionData( const uno::Sequence< beans::NamedValu
             m_pImpl->m_bHasCommonEncryptionData = sal_True;
             m_pImpl->m_aCommonEncryptionData = aEncryptionMap;
         }
-        catch( uno::Exception& aException )
+        catch( const uno::Exception& rException )
         {
-            m_pImpl->AddLog( aException.Message );
+            m_pImpl->AddLog( rException.Message );
             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
             throw io::IOException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() );
@@ -4951,15 +4951,15 @@ uno::Any SAL_CALL OStorage::getPropertyValue( const ::rtl::OUString& aPropertyNa
         {
             m_pImpl->ReadContents();
         }
-        catch ( uno::RuntimeException& aRuntimeException )
+        catch ( const uno::RuntimeException& rRuntimeException )
         {
-            m_pImpl->AddLog( aRuntimeException.Message );
+            m_pImpl->AddLog( rRuntimeException.Message );
             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
             throw;
         }
-        catch ( uno::Exception& aException )
+        catch ( const uno::Exception& rException )
         {
-            m_pImpl->AddLog( aException.Message );
+            m_pImpl->AddLog( rException.Message );
             m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
             uno::Any aCaught( ::cppu::getCaughtException() );
@@ -5013,15 +5013,15 @@ uno::Any SAL_CALL OStorage::getPropertyValue( const ::rtl::OUString& aPropertyNa
 
                 return xPackPropSet->getPropertyValue( aPropertyName );
             }
-            catch ( uno::RuntimeException& aRuntimeException )
+            catch ( const uno::RuntimeException& rRuntimeException )
             {
-                m_pImpl->AddLog( aRuntimeException.Message );
+                m_pImpl->AddLog( rRuntimeException.Message );
                 m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
                 throw;
             }
-            catch ( uno::Exception& aException )
+            catch ( const uno::Exception& rException )
             {
-                m_pImpl->AddLog( aException.Message );
+                m_pImpl->AddLog( rException.Message );
                 m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
                 uno::Any aCaught( ::cppu::getCaughtException() );
@@ -5143,9 +5143,9 @@ sal_Bool SAL_CALL OStorage::hasByID(  const ::rtl::OUString& sID )
         getRelationshipByID( sID );
         return sal_True;
     }
-    catch( container::NoSuchElementException& aNoSuchElementException )
+    catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( aNoSuchElementException.Message );
+        m_pImpl->AddLog( rNoSuchElementException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Quiet exception" ) ) );
     }
 
@@ -5563,45 +5563,45 @@ void SAL_CALL OStorage::insertStreamElementDirect(
 
         pElement->m_pStream->InsertStreamDirectly( xInStream, aProps );
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( container::ElementExistException& aElementExistException )
+    catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( aElementExistException.Message );
+        m_pImpl->AddLog( rElementExistException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -5663,51 +5663,51 @@ void SAL_CALL OStorage::copyElementDirectlyTo(
         uno::Reference< embed::XStorage > xStorDest( xDest, uno::UNO_QUERY_THROW );
         m_pImpl->CopyStorageElement( pElement, xStorDest, aNewName, sal_True );
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( container::NoSuchElementException& aNoSuchElementException )
+    catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( aNoSuchElementException.Message );
+        m_pImpl->AddLog( rNoSuchElementException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( container::ElementExistException& aElementExistException )
+    catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( aElementExistException.Message );
+        m_pImpl->AddLog( rElementExistException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );
           m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
 
           uno::Any aCaught( ::cppu::getCaughtException() );
@@ -5745,39 +5745,39 @@ void SAL_CALL OStorage::writeAndAttachToStream( const uno::Reference< io::XStrea
     {
         m_pImpl->m_pSwitchStream->CopyAndSwitchPersistenceTo( xStream );
     }
-    catch( embed::InvalidStorageException& aInvalidStorageException )
+    catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( aInvalidStorageException.Message );
+        m_pImpl->AddLog( rInvalidStorageException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( lang::IllegalArgumentException& aIllegalArgumentException )
+    catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( aIllegalArgumentException.Message );
+        m_pImpl->AddLog( rIllegalArgumentException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( embed::StorageWrappedTargetException& aStorageWrappedTargetException )
+    catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( aStorageWrappedTargetException.Message );
+        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( io::IOException& aIOException )
+    catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( aIOException.Message );
+        m_pImpl->AddLog( rIOException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::RuntimeException& aRuntimeException )
+    catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( aRuntimeException.Message );
+        m_pImpl->AddLog( rRuntimeException.Message );
         m_pImpl->AddLog( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Rethrow" ) ) );
         throw;
     }
-    catch( uno::Exception& aException )
+    catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( aException.Message );
+          m_pImpl->AddLog( rException.Message );

... etc. - the rest is truncated


More information about the Libreoffice-commits mailing list