openoffice-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From msei...@apache.org
Subject svn commit: r1859382 - /openoffice/trunk/main/filter/source/config/cache/filtercache.cxx
Date Thu, 16 May 2019 15:08:22 GMT
Author: mseidel
Date: Thu May 16 15:08:22 2019
New Revision: 1859382

URL: http://svn.apache.org/viewvc?rev=1859382&view=rev
Log:
Fixed a lot of typos

Modified:
    openoffice/trunk/main/filter/source/config/cache/filtercache.cxx

Modified: openoffice/trunk/main/filter/source/config/cache/filtercache.cxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/filter/source/config/cache/filtercache.cxx?rev=1859382&r1=1859381&r2=1859382&view=diff
==============================================================================
--- openoffice/trunk/main/filter/source/config/cache/filtercache.cxx (original)
+++ openoffice/trunk/main/filter/source/config/cache/filtercache.cxx Thu May 16 15:08:22 2019
@@ -1,5 +1,5 @@
 /**************************************************************
- * 
+ *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
@@ -7,16 +7,16 @@
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
- * 
+ *
  *   http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
- * 
+ *
  *************************************************************/
 
 
@@ -64,7 +64,7 @@
 // namespace
 
 namespace filter{
-    namespace config{
+	namespace config{
 
 namespace css = ::com::sun::star;
 
@@ -72,12 +72,12 @@ namespace css = ::com::sun::star;
 // definitions
 
 // Error message in case filter config seems to be corrupted.
-// Note: Dont tell user something about "setup -repair"!
-// Its no longer supported by using native installers ...
+// Note: Don't tell user something about "setup -repair"!
+// It's no longer supported by using native installers ...
 static ::rtl::OUString MESSAGE_CORRUPTED_FILTERCONFIG = ::rtl::OUString::createFromAscii("The
filter configuration appears to be defective. Please install the office suite again.");
 
 /*-----------------------------------------------
-    15.03.2004 08:59
+	15.03.2004 08:59
 -----------------------------------------------*/
 FilterCache::FilterCache()
     : BaseLock    (                                        )
@@ -88,7 +88,7 @@ FilterCache::FilterCache()
 }
 
 /*-----------------------------------------------
-    15.03.2004 08:59
+	15.03.2004 08:59
 -----------------------------------------------*/
 FilterCache::~FilterCache()
 {
@@ -96,7 +96,7 @@ FilterCache::~FilterCache()
 }
 
 /*-----------------------------------------------
-    03.03.2004 11:27
+	03.03.2004 11:27
 -----------------------------------------------*/
 FilterCache* FilterCache::clone() const
 {
@@ -105,7 +105,7 @@ FilterCache* FilterCache::clone() const
 
     FilterCache* pClone = new FilterCache();
 
-    // Dont copy the configuration access points here.
+    // Don't copy the configuration access points here.
     // They will be created on demand inside the cloned instance,
     // if they are needed.
 
@@ -137,7 +137,7 @@ FilterCache* FilterCache::clone() const
 }
 
 /*-----------------------------------------------
-    03.03.2004 14:39
+	03.03.2004 14:39
 -----------------------------------------------*/
 void FilterCache::takeOver(const FilterCache& rClone)
 {
@@ -145,7 +145,7 @@ void FilterCache::takeOver(const FilterC
     ::osl::ResettableMutexGuard aLock(m_aLock);
 
     // a)
-	// Dont copy the configuration access points here!
+	// Don't copy the configuration access points here!
     // We must use our own ones ...
 
     // b)
@@ -154,7 +154,7 @@ void FilterCache::takeOver(const FilterC
 
 	// c)
 	// Take over only changed items!
-	// Otherwhise we risk the following scenario:
+	// Otherwise we risk the following scenario:
 	// c1) clone_1 contains changed filters
 	// c2) clone_2 container changed types
 	// c3) clone_1 take over changed filters and unchanged types
@@ -178,23 +178,23 @@ void FilterCache::takeOver(const FilterC
 	m_lChangedFrameLoaders.clear();
 	m_lChangedContentHandlers.clear();
 
-    m_sActLocale     = rClone.m_sActLocale;
-    m_sProductName = rClone.m_sProductName;
-    m_sOOoXMLFormatName = rClone.m_sOOoXMLFormatName;
-    m_sOOoXMLFormatVersion = rClone.m_sOOoXMLFormatVersion;
+	m_sActLocale = rClone.m_sActLocale;
+	m_sProductName = rClone.m_sProductName;
+	m_sOOoXMLFormatName = rClone.m_sOOoXMLFormatName;
+	m_sOOoXMLFormatVersion = rClone.m_sOOoXMLFormatVersion;
 
-    m_eFillState     = rClone.m_eFillState;
+	m_eFillState = rClone.m_eFillState;
 
 	// renew all dependencies and optimizations
 	// Because we can't be sure, that changed filters on one clone
 	// and changed types of another clone work together.
 	// But here we can check against the lates changes ...
-    impl_validateAndOptimize();
-    // <- SAFE ----------------------------------
+	impl_validateAndOptimize();
+	// <- SAFE ----------------------------------
 }
 
 /*-----------------------------------------------
-    28.10.2003 09:01
+	28.10.2003 09:01
 -----------------------------------------------*/
 void FilterCache::load(EFillState eRequired,
 #if OSL_DEBUG_LEVEL > 1
@@ -226,10 +226,10 @@ void FilterCache::load(EFillState eRequi
     }
 #endif
 
-    // Otherwhise load the missing items.
+    // Otherwise load the missing items.
 
     // ------------------------------------------
-    // a) load some const values from configration.
+    // a) load some const values from configuration.
     //    These values are needed there for loading
     //    config items ...
     //    Further we load some std items from the
@@ -260,13 +260,13 @@ void FilterCache::load(EFillState eRequi
             m_sOOoXMLFormatVersion = DEFAULT_FORMATVERSION;
         }
 
-        // Support the old configuration support. Read it only one times during office runtime!
+        // Support the old configuration support. Read it only one time during office runtime!
         impl_readOldFormat();
 
         // enable "loadOnDemand" feature ...
         // Create uno listener, which waits for finishing the office startup
         // and starts a thread, which calls loadAll() at this filter cache.
-        // Note: Its not a leak to create this listener with new here.
+        // Note: It's not a leak to create this listener with new here.
         // It kills itself after working!
         /* LateInitListener* pLateInit = */ new LateInitListener(m_xSMGR);
     }
@@ -280,7 +280,7 @@ void FilterCache::load(EFillState eRequi
 }
 
 /*-----------------------------------------------
-    28.10.2003 09:50
+	28.10.2003 09:50
 -----------------------------------------------*/
 sal_Bool FilterCache::isFillState(FilterCache::EFillState eState) const
     throw(css::uno::Exception)
@@ -292,7 +292,7 @@ sal_Bool FilterCache::isFillState(Filter
 }
 
 /*-----------------------------------------------
-    14.07.2003 10:45
+	14.07.2003 10:45
 -----------------------------------------------*/
 OUStringList FilterCache::getMatchingItemsByProps(      EItemType  eType  ,
                                                   const CacheItem& lIProps,
@@ -303,8 +303,8 @@ OUStringList FilterCache::getMatchingIte
     ::osl::ResettableMutexGuard aLock(m_aLock);
 
     // search for right list
-    // An exception is thrown �f "eType" is unknown.
-    // => rList will be valid everytimes next line is reached.
+    // An exception is thrown if "eType" is unknown.
+    // => rList will be valid every time the next line is reached.
     CacheItemList& rList = impl_getItemList(eType);
 
     OUStringList lKeys;
@@ -331,7 +331,7 @@ OUStringList FilterCache::getMatchingIte
 }
 
 /*-----------------------------------------------
-    02.07.2003 09:32
+	02.07.2003 09:32
 -----------------------------------------------*/
 sal_Bool FilterCache::hasItems(EItemType eType) const
     throw(css::uno::Exception)
@@ -340,8 +340,8 @@ sal_Bool FilterCache::hasItems(EItemType
     ::osl::ResettableMutexGuard aLock(m_aLock);
 
     // search for right list
-    // An exception is thrown �f "eType" is unknown.
-    // => rList will be valid everytimes next line is reached.
+    // An exception is thrown if "eType" is unknown.
+    // => rList will be valid every time the next line is reached.
     CacheItemList& rList = impl_getItemList(eType);
 
     return (rList.size()>0);
@@ -349,7 +349,7 @@ sal_Bool FilterCache::hasItems(EItemType
 }
 
 /*-----------------------------------------------
-    02.07.2003 11:48
+	02.07.2003 11:48
 -----------------------------------------------*/
 OUStringList FilterCache::getItemNames(EItemType eType) const
     throw(css::uno::Exception)
@@ -358,8 +358,8 @@ OUStringList FilterCache::getItemNames(E
     ::osl::ResettableMutexGuard aLock(m_aLock);
 
     // search for right list
-    // An exception is thrown �f "eType" is unknown.
-    // => rList will be valid everytimes next line is reached.
+    // An exception is thrown if "eType" is unknown.
+    // => rList will be valid every time the next line is reached.
     CacheItemList& rList = impl_getItemList(eType);
 
     OUStringList lKeys;
@@ -374,7 +374,7 @@ OUStringList FilterCache::getItemNames(E
 }
 
 /*-----------------------------------------------
-    27.10.2003 08:37
+	27.10.2003 08:37
 -----------------------------------------------*/
 sal_Bool FilterCache::hasItem(      EItemType        eType,
                               const ::rtl::OUString& sItem)
@@ -384,8 +384,8 @@ sal_Bool FilterCache::hasItem(      EIte
     ::osl::ResettableMutexGuard aLock(m_aLock);
 
     // search for right list
-    // An exception is thrown �f "eType" is unknown.
-    // => rList will be valid everytimes next line is reached.
+    // An exception is thrown if "eType" is unknown.
+    // => rList will be valid every time the next line is reached.
     CacheItemList& rList = impl_getItemList(eType);
 
     // if item could not be found - check if it can be loaded
@@ -409,7 +409,7 @@ sal_Bool FilterCache::hasItem(      EIte
 }
 
 /*-----------------------------------------------
-    17.07.2006 09:15
+	17.07.2006 09:15
 -----------------------------------------------*/
 CacheItem FilterCache::getItem(      EItemType        eType,
                                const ::rtl::OUString& sItem)
@@ -420,7 +420,7 @@ CacheItem FilterCache::getItem(      EIt
 
     // search for right list
     // An exception is thrown if "eType" is unknown.
-    // => rList will be valid everytimes next line is reached.
+    // => rList will be valid every time the next line is reached.
     CacheItemList& rList = impl_getItemList(eType);
 
     // check if item exists ...
@@ -456,7 +456,7 @@ CacheItem FilterCache::getItem(      EIt
             ::rtl::OUStringBuffer sMsg(256);
             sMsg.appendAscii("The requested filter '"                                   
                           );
             sMsg.append     (sItem                                                      
                           );
-            sMsg.appendAscii("' exists ... but it shouldn't; because the corresponding OOo
module was not installed.");
+            sMsg.appendAscii("' exists ... but it shouldn't; because the corresponding AOO
module was not installed.");
             throw css::container::NoSuchElementException(sMsg.makeStringAndClear(), css::uno::Reference<
css::uno::XInterface >());
         }
     }
@@ -466,7 +466,7 @@ CacheItem FilterCache::getItem(      EIt
 }
 
 /*-----------------------------------------------
-    03.03.2004 11:28
+	03.03.2004 11:28
 -----------------------------------------------*/
 void FilterCache::removeItem(      EItemType        eType,
                              const ::rtl::OUString& sItem)
@@ -476,8 +476,8 @@ void FilterCache::removeItem(      EItem
     ::osl::ResettableMutexGuard aLock(m_aLock);
 
     // search for right list
-    // An exception is thrown �f "eType" is unknown.
-    // => rList will be valid everytimes next line is reached.
+    // An exception is thrown if "eType" is unknown.
+    // => rList will be valid every time the next line is reached.
     CacheItemList& rList = impl_getItemList(eType);
 
     CacheItemList::iterator pItem = rList.find(sItem);
@@ -489,7 +489,7 @@ void FilterCache::removeItem(      EItem
 }
 
 /*-----------------------------------------------
-    26.11.2003 13:28
+	26.11.2003 13:28
 -----------------------------------------------*/
 void FilterCache::setItem(      EItemType        eType ,
                           const ::rtl::OUString& sItem ,
@@ -500,18 +500,18 @@ void FilterCache::setItem(      EItemTyp
     ::osl::ResettableMutexGuard aLock(m_aLock);
 
     // search for right list
-    // An exception is thrown �f "eType" is unknown.
-    // => rList will be valid everytimes next line is reached.
+    // An exception is thrown if "eType" is unknown.
+    // => rList will be valid every time the next line is reached.
     CacheItemList& rList = impl_getItemList(eType);
 
-    // name must be part of the property set too ... otherwhise our
+    // name must be part of the property set too ... otherwise our
     // container query can't work correctly
     CacheItem aItem = aValue;
     aItem[PROPNAME_NAME] <<= sItem;
     aItem.validateUINames(m_sActLocale);
 
 	// remove implicit properties as e.g. FINALIZED or MANDATORY
-	// They can't be saved here and must be readed on demand later, if they are needed.
+	// They can't be saved here and must be read on demand later, if they are needed.
 	removeStatePropsFromItem(aItem);
 
     rList[sItem] = aItem;
@@ -530,7 +530,7 @@ void FilterCache::refreshItem(      EIte
 }
 
 /*-----------------------------------------------
-    27.10.2003 08:14
+	27.10.2003 08:14
 -----------------------------------------------*/
 void FilterCache::addStatePropsToItem(      EItemType        eType,
                                       const ::rtl::OUString& sItem,
@@ -541,7 +541,7 @@ void FilterCache::addStatePropsToItem(
     ::osl::ResettableMutexGuard aLock(m_aLock);
 
 	// Note: Opening of the configuration layer throws some exceptions
-	// if it failed. So we dont must check any reference here ...
+	// if it failed. So we don't have to check any reference here ...
     css::uno::Reference< css::container::XNameAccess > xPackage;
     css::uno::Reference< css::container::XNameAccess > xSet;
     switch(eType)
@@ -564,10 +564,10 @@ void FilterCache::addStatePropsToItem(
 			{
 				/* TODO
 					Hack -->
-						The default frame loader can't be located inside te normal set of frame loaders.
-						Its an atomic property inside the misc cfg package. So we can't retrieve the information
+						The default frame loader can't be located inside the normal set of frame loaders.
+						It's an atomic property inside the misc cfg package. So we can't retrieve the information
 						about FINALIZED and MANDATORY very easy ... :-(
-						=> set it to readonly/required everytimes :-)
+						=> set it to readonly/required every time :-)
 				*/
 				css::uno::Any   aDirectValue       = impl_getDirectCFGValue(CFGDIRECTKEY_DEFAULTFRAMELOADER);
 				::rtl::OUString sDefaultFrameLoader;
@@ -612,13 +612,13 @@ void FilterCache::addStatePropsToItem(
 	catch(const css::container::NoSuchElementException&)
 	{
 		/*	Ignore exceptions for missing elements inside configuration.
-			May by the following reason exists:
+			Maybe the following reason exists:
 				-	The item does not exists inside the new configuration package org.openoffice.TypeDetection
- but
-					we got it from the old package org.openoffice.Office/TypeDetection. We dont migrate
such items
+					we got it from the old package org.openoffice.Office/TypeDetection. We don't migrate
such items
 					automatically to the new format. Because it will disturb e.g. the deinstallation of
an external filter
 					package. Because such external filter can remove the old file - but not the automatically
created new one ...
 
-			=> mark item as FINALIZED / MANDATORY, we dont support writing to the old format
+			=> mark item as FINALIZED / MANDATORY, we don't support writing to the old format
 		*/
 		rItem[PROPNAME_FINALIZED] <<= sal_True;
 		rItem[PROPNAME_MANDATORY] <<= sal_True;
@@ -628,7 +628,7 @@ void FilterCache::addStatePropsToItem(
 }
 
 /*-----------------------------------------------
-    05.03.2004 10:36
+	05.03.2004 10:36
 -----------------------------------------------*/
 void FilterCache::removeStatePropsFromItem(CacheItem& rItem)
     throw(css::uno::Exception)
@@ -643,7 +643,7 @@ void FilterCache::removeStatePropsFromIt
 }
 
 /*-----------------------------------------------
-    02.07.2003 09:17
+	02.07.2003 09:17
 -----------------------------------------------*/
 void FilterCache::flush()
     throw(css::uno::Exception)
@@ -682,7 +682,7 @@ void FilterCache::flush()
 }
 
 /*-----------------------------------------------
-    20.10.2003 09:22
+	20.10.2003 09:22
 -----------------------------------------------*/
 void FilterCache::impl_flushByList(const css::uno::Reference< css::container::XNameAccess
>& xSet  ,
                                          EItemType                                      
    eType ,
@@ -713,7 +713,7 @@ void FilterCache::impl_flushByList(const
                 css::uno::Reference< css::container::XNameReplace > xItem (xFactory->createInstance(),
css::uno::UNO_QUERY);
 
 				// special case. no exception - but not a valid item => set must be finalized or mandatory!
-				// Reject flush operation by throwing an exception. At least one item couldnt be flushed.
+				// Reject flush operation by throwing an exception. At least one item couldn't be flushed.
 				if (!xItem.is())
 					throw css::uno::Exception(::rtl::OUString::createFromAscii("Can't add item. Set is finalized
or mandatory!"),
 											  css::uno::Reference< css::uno::XInterface >()									  );
@@ -730,9 +730,9 @@ void FilterCache::impl_flushByList(const
                 xSet->getByName(sItem) >>= xItem;
 
 				// special case. no exception - but not a valid item => it must be finalized or mandatory!
-				// Reject flush operation by throwing an exception. At least one item couldnt be flushed.
+				// Reject flush operation by throwing an exception. At least one item couldn't be flushed.
 				if (!xItem.is())
-					throw css::uno::Exception(::rtl::OUString::createFromAscii("Can't change item. Its finalized
or mandatory!"),
+					throw css::uno::Exception(::rtl::OUString::createFromAscii("Can't change item. It's
finalized or mandatory!"),
 											  css::uno::Reference< css::uno::XInterface >()									   );
 
                 CacheItemList::const_iterator pItem = rCache.find(sItem);
@@ -745,7 +745,7 @@ void FilterCache::impl_flushByList(const
 }
 
 /*-----------------------------------------------
-    03.11.2003 08:38
+	03.11.2003 08:38
 -----------------------------------------------*/
 void FilterCache::detectFlatForURL(const css::util::URL& aURL      ,
                                          FlatDetection&  rFlatTypes) const
@@ -789,8 +789,8 @@ void FilterCache::detectFlatForURL(const
 
     //*******************************************
     // ii) search types matching to the given extension.
-    //     Copy every macthing type without changing its order!
-    //     Because preferred types was added as first one during
+    //     Copy every matching type without changing its order!
+    //     Because preferred type was added as first one during
     //     loading configuration.
     CacheItemRegistration::const_iterator pExtReg = m_lExtensions2Types.find(sExtension);
     if (pExtReg != m_lExtensions2Types.end())
@@ -813,7 +813,7 @@ void FilterCache::detectFlatForURL(const
 }
 
 /*-----------------------------------------------
-    03.11.2003 08:38
+	03.11.2003 08:38
 -----------------------------------------------*/
 CacheItemList& FilterCache::impl_getItemList(EItemType eType) const
     throw(css::uno::Exception)
@@ -837,7 +837,7 @@ CacheItemList& FilterCache::impl_getItem
 }
 
 /*-----------------------------------------------
-    21.10.2003 13:20
+	21.10.2003 13:20
 -----------------------------------------------*/
 css::uno::Reference< css::uno::XInterface > FilterCache::impl_openConfig(EConfigProvider
eProvider)
     throw(css::uno::Exception)
@@ -892,7 +892,7 @@ css::uno::Reference< css::uno::XInterfac
         case E_PROVIDER_OLD :
         {
             // This special provider is used to work with
-            // the old configuration format only. Its not cached!
+            // the old configuration format only. It's not cached!
             sPath   = CFGPACKAGE_TD_OLD;
             pConfig = &xOld;
             sRtlLog = ::rtl::OString("framework (as96863) ::FilterCache::impl_openconfig(E_PROVIDER_OLD)");
@@ -911,7 +911,7 @@ css::uno::Reference< css::uno::XInterfac
 
     // Start listening for changes on that configuration access.
     // We must not control the lifetime of this listener. Itself
-    // checks, when ist time to die :-)
+    // checks, when it's time to die :-)
     if (bStartListening)
     {
         CacheUpdateListener* pListener = new CacheUpdateListener(m_xSMGR, *pConfig, eItemType);
@@ -923,7 +923,7 @@ css::uno::Reference< css::uno::XInterfac
 }
 
 /*-----------------------------------------------
-    17.07.2003 10:10
+	17.07.2003 10:10
 -----------------------------------------------*/
 css::uno::Any FilterCache::impl_getDirectCFGValue(const ::rtl::OUString& sDirectKey)
 {
@@ -970,7 +970,7 @@ css::uno::Any FilterCache::impl_getDirec
 }
 
 /*-----------------------------------------------
-    17.07.2003 09:49
+	17.07.2003 09:49
 -----------------------------------------------*/
 css::uno::Reference< css::uno::XInterface > FilterCache::impl_createConfigAccess(const
::rtl::OUString& sRoot       ,
                                                                                        sal_Bool
        bReadOnly   ,
@@ -1011,7 +1011,7 @@ css::uno::Reference< css::uno::XInterfac
         else
             xCfg = xConfigProvider->createInstanceWithArguments(SERVICE_CONFIGURATIONUPDATEACCESS,
lParams.getAsConstList());
 
-        // If configuration could not be opened ... but factory method does not throwed an
exception
+        // If configuration could not be opened ... but factory method does not throw an
exception
         // trigger throwing of our own CorruptedFilterConfigurationException.
         // Let message empty. The normal exception text show enough informations to the user.
         if (! xCfg.is())
@@ -1032,7 +1032,7 @@ css::uno::Reference< css::uno::XInterfac
 }
 
 /*-----------------------------------------------
-    24.10.2003 10:03
+	24.10.2003 10:03
 -----------------------------------------------*/
 void FilterCache::impl_validateAndOptimize()
     throw(css::uno::Exception)
@@ -1042,7 +1042,7 @@ void FilterCache::impl_validateAndOptimi
 
     RTL_LOGFILE_CONTEXT( aLog, "framework (as96863) ::FilterCache::impl_validateAndOptimize");
 
-    // First check if any filter or type could be readed
+    // First check if any filter or type could be read
     // from the underlying configuration!
     sal_Bool bSomeTypesShouldExist   = ((m_eFillState & E_CONTAINS_STANDARD       ) ==
E_CONTAINS_STANDARD       );
     sal_Bool bAllFiltersShouldExist  = ((m_eFillState & E_CONTAINS_FILTERS        ) ==
E_CONTAINS_FILTERS        );
@@ -1074,7 +1074,7 @@ void FilterCache::impl_validateAndOptimi
     }
 
     // Create a log for all detected problems, which
-    // occur in the next feew lines.
+    // occur in the next few lines.
     // If there are some real errors throw a RuntimException!
     // If there are some warnings only, show an assertion.
     sal_Int32             nErrors   = 0;
@@ -1131,12 +1131,12 @@ void FilterCache::impl_validateAndOptimi
 #endif
 
         // create an optimized registration for this type to
-        // its set list of extensions/url pattern. If its a "normal" type
-        // set it at the end of this optimized list. But if its
+        // its set list of extensions/url pattern. If it's a "normal" type
+        // set it at the end of this optimized list. But if it's
         // a "Preferred" one - set it to the front of this list.
         // Of course multiple "Preferred" registrations can occur
         // (they shouldn't - but they can!) ... Ignore it. The last
-        // preferred type is useable in the same manner then every
+        // preferred type is usable in the same manner then every
         // other type!
         sal_Bool bPreferred = sal_False;
         aType[PROPNAME_PREFERRED] >>= bPreferred;
@@ -1173,7 +1173,7 @@ void FilterCache::impl_validateAndOptimi
 
 #if OSL_DEBUG_LEVEL > 0
 
-        // Dont check cross references between types and filters, if
+        // Don't check cross references between types and filters, if
         // not all filters read from disk!
         // OK - this cache can read single filters on demand too ...
         // but then the fill state of this cache shouldn't be set to E_CONTAINS_FILTERS!
@@ -1185,8 +1185,8 @@ void FilterCache::impl_validateAndOptimi
         if (!sPrefFilter.getLength())
         {
             // OK - there is no filter for this type. But thats not an error.
-            // May be it can be handled by a ContentHandler ...
-            // But at this time its not guaranteed that there is any ContentHandler
+            // Maybe it can be handled by a ContentHandler ...
+            // But at this time it's not guaranteed that there is any ContentHandler
             // or FrameLoader inside this cache ... but on disk ...
             sal_Bool bReferencedByLoader  = sal_True;
             sal_Bool bReferencedByHandler = sal_True;
@@ -1303,9 +1303,9 @@ void FilterCache::impl_validateAndOptimi
          ++pIt                           )
     {
         // Note: of course the default loader must be ignored here.
-        // Because we replace its registration later completly with all
+        // Because we replace its registration later completely with all
         // types, which are not referenced by any other loader.
-        // So we can avaoid our code against the complexity of a diff!
+        // So we can avoid our code against the complexity of a diff!
         ::rtl::OUString sLoader = pIt->first;
         if (sLoader.equals(sDefaultFrameLoader))
             continue;
@@ -1341,7 +1341,7 @@ void FilterCache::impl_validateAndOptimi
 }
 
 /*-----------------------------------------------
-    20.10.2003 08:15
+	20.10.2003 08:15
 -----------------------------------------------*/
 void FilterCache::impl_addItem2FlushList(      EItemType        eType,
                                          const ::rtl::OUString& sItem)
@@ -1379,7 +1379,7 @@ void FilterCache::impl_addItem2FlushList
 }
 
 /*-----------------------------------------------
-    20.10.2003 08:49
+	20.10.2003 08:49
 -----------------------------------------------*/
 FilterCache::EItemFlushState FilterCache::impl_specifyFlushOperation(const css::uno::Reference<
css::container::XNameAccess >& xSet ,
                                                                      const CacheItemList&
                                     rList,
@@ -1391,7 +1391,7 @@ FilterCache::EItemFlushState FilterCache
 
     EItemFlushState eState( E_ITEM_UNCHANGED );
 
-    // !? ... such situation can occur, if an item was added and(!) removed before it was
flushed :-)
+    // !? ... such a situation can occur, if an item was added and(!) removed before it was
flushed :-)
     if (!bExistsInConfigLayer && !bExistsInMemory)
         eState = E_ITEM_UNCHANGED;
     else
@@ -1408,7 +1408,7 @@ FilterCache::EItemFlushState FilterCache
 }
 
 /*-----------------------------------------------
-    14.10.2003 09:26
+	14.10.2003 09:26
 -----------------------------------------------*/
 void FilterCache::impl_resolveItem4TypeRegistration(      CacheItemList*   pList,
                                                     const ::rtl::OUString& sItem,
@@ -1416,9 +1416,9 @@ void FilterCache::impl_resolveItem4TypeR
     throw(css::uno::Exception)
 {
     CacheItem& rItem = (*pList)[sItem];
-    // In case its a new created entry (automatically done by the hash_map index operator!)
-    // we must be shure, that this entry has its own name as property available.
-    // Its needed later at our container interface!
+    // In case it's a new created entry (automatically done by the hash_map index operator!)
+    // we must be sure, that this entry has its own name as property available.
+    // It's needed later at our container interface!
     rItem[PROPNAME_NAME] <<= sItem;
 
     OUStringList lTypeRegs(rItem[PROPNAME_TYPES]);
@@ -1430,7 +1430,7 @@ void FilterCache::impl_resolveItem4TypeR
 }
 
 /*-----------------------------------------------
-    28.10.2003 09:18
+	28.10.2003 09:18
 -----------------------------------------------*/
 void FilterCache::impl_load(EFillState eRequiredState)
     throw(css::uno::Exception)
@@ -1439,7 +1439,7 @@ void FilterCache::impl_load(EFillState e
     ::osl::ResettableMutexGuard aLock(m_aLock);
 
     // Attention: Detect services are part of the standard set!
-    // So there is no need to handle it seperatly.
+    // So there is no need to handle it separately.
 
     // ------------------------------------------
     // a) The standard set of config value is needed.
@@ -1448,7 +1448,7 @@ void FilterCache::impl_load(EFillState e
         ((m_eFillState   & E_CONTAINS_STANDARD) != E_CONTAINS_STANDARD)
        )
     {
-        // Attention! If config couldnt be opened successfully
+        // Attention! If config couldn't be opened successfully
         // and exception os thrown automatically and must be forwarded
         // to our calli ...
         css::uno::Reference< css::container::XNameAccess > xTypes(impl_openConfig(E_PROVIDER_TYPES),
css::uno::UNO_QUERY);
@@ -1465,7 +1465,7 @@ void FilterCache::impl_load(EFillState e
         ((m_eFillState   & E_CONTAINS_TYPES) != E_CONTAINS_TYPES)
        )
     {
-        // Attention! If config couldnt be opened successfully
+        // Attention! If config couldn't be opened successfully
         // and exception os thrown automatically and must be forwarded
         // to our calli ...
         css::uno::Reference< css::container::XNameAccess > xTypes(impl_openConfig(E_PROVIDER_TYPES),
css::uno::UNO_QUERY);
@@ -1482,7 +1482,7 @@ void FilterCache::impl_load(EFillState e
         ((m_eFillState   & E_CONTAINS_FILTERS) != E_CONTAINS_FILTERS)
        )
     {
-        // Attention! If config couldnt be opened successfully
+        // Attention! If config couldn't be opened successfully
         // and exception os thrown automatically and must be forwarded
         // to our calli ...
         css::uno::Reference< css::container::XNameAccess > xFilters(impl_openConfig(E_PROVIDER_FILTERS),
css::uno::UNO_QUERY);
@@ -1499,7 +1499,7 @@ void FilterCache::impl_load(EFillState e
         ((m_eFillState   & E_CONTAINS_FRAMELOADERS) != E_CONTAINS_FRAMELOADERS)
        )
     {
-        // Attention! If config couldnt be opened successfully
+        // Attention! If config couldn't be opened successfully
         // and exception os thrown automatically and must be forwarded
         // to our calli ...
         css::uno::Reference< css::container::XNameAccess > xLoaders(impl_openConfig(E_PROVIDER_OTHERS),
css::uno::UNO_QUERY);
@@ -1516,7 +1516,7 @@ void FilterCache::impl_load(EFillState e
         ((m_eFillState   & E_CONTAINS_CONTENTHANDLERS) != E_CONTAINS_CONTENTHANDLERS)
        )
     {
-        // Attention! If config couldnt be opened successfully
+        // Attention! If config couldn't be opened successfully
         // and exception os thrown automatically and must be forwarded
         // to our calli ...
         css::uno::Reference< css::container::XNameAccess > xHandlers(impl_openConfig(E_PROVIDER_OTHERS),
css::uno::UNO_QUERY);
@@ -1526,10 +1526,10 @@ void FilterCache::impl_load(EFillState e
         }
     }
 
-    // update fill state. Note: its a bit field, which combines different parts.
+    // update fill state. Note: it's a bit field, which combines different parts.
     m_eFillState = (EFillState) ((sal_Int32)m_eFillState | (sal_Int32)eRequiredState);
 
-    // any data readed?
+    // any data read?
     // yes! => validate it and update optimized structures.
     impl_validateAndOptimize();
 
@@ -1537,7 +1537,7 @@ void FilterCache::impl_load(EFillState e
 }
 
 /*-----------------------------------------------
-    22.09.2003 14:27
+	22.09.2003 14:27
 -----------------------------------------------*/
 void FilterCache::impl_loadSet(const css::uno::Reference< css::container::XNameAccess
>& xConfig,
                                      EItemType                                          
eType  ,
@@ -1596,7 +1596,7 @@ void FilterCache::impl_loadSet(const css
     // get names of all existing sub items of this set
     // step over it and fill internal cache structures.
 
-    // But dont update optimized structures like e.g. hash
+    // But don't update optimized structures like e.g. hash
     // for mapping extensions to its types!
 
     const ::rtl::OUString* pItems = lItems.getConstArray();
@@ -1658,7 +1658,7 @@ void FilterCache::impl_loadSet(const css
 }
 
 /*-----------------------------------------------
-    26.11.2003 12:49
+	26.11.2003 12:49
 -----------------------------------------------*/
 void FilterCache::impl_readPatchUINames(const css::uno::Reference< css::container::XNameAccess
>& xNode,
                                               CacheItem&                            
             rItem)
@@ -1751,7 +1751,7 @@ void FilterCache::impl_readPatchUINames(
 }
 
 /*-----------------------------------------------
-    26.11.2003 12:56
+	26.11.2003 12:56
 -----------------------------------------------*/
 void FilterCache::impl_savePatchUINames(const css::uno::Reference< css::container::XNameReplace
>& xNode,
                                         const CacheItem&                            
              rItem)
@@ -1774,12 +1774,12 @@ void FilterCache::impl_savePatchUINames(
 }
 
 /*-----------------------------------------------
-    29.10.2003 13:17
-    TODO
-        clarify, how the real problem behind the
-        wrong constructed CacheItem instance (which
-        will force a crash during destruction)
-        can be solved ...
+	29.10.2003 13:17
+	TODO
+		clarify, how the real problem behind the
+		wrong constructed CacheItem instance (which
+		will force a crash during destruction)
+		can be solved ...
 -----------------------------------------------*/
 CacheItem FilterCache::impl_loadItem(const css::uno::Reference< css::container::XNameAccess
>& xSet   ,
                                            EItemType                                    
      eType  ,
@@ -1815,10 +1815,10 @@ CacheItem FilterCache::impl_loadItem(con
     #endif
 
     // The internal name of an item must(!) be part of the property
-    // set too. Of course its already used as key into the e.g. outside
+    // set too. Of course it's already used as key into the e.g. outside
     // used hash map ... but some of our API methods provide
     // this property set as result only. But the user of this CacheItem
-    // should know, which value the key names has :-) ITS IMPORTANT!
+    // should know, which value the key names has :-) IT'S IMPORTANT!
     CacheItem aItem;
     aItem[PROPNAME_NAME] = css::uno::makeAny(sItem);
     switch(eType)
@@ -1874,7 +1874,7 @@ CacheItem FilterCache::impl_loadItem(con
                     aItem[PROPNAME_FLAGS] <<= FilterCache::impl_convertFlagNames2FlagField(lFlagNames);
             }
             // read optional properties of a filter
-            // no else here! Is an additional switch ...
+            // no else here! It's an additional switch ...
             if (
                 (eOption == E_READ_UPDATE) ||
                 (eOption == E_READ_ALL   )
@@ -1905,7 +1905,7 @@ CacheItem FilterCache::impl_loadItem(con
 }
 
 /*-----------------------------------------------
-    27.10.2003 08:47
+	27.10.2003 08:47
 -----------------------------------------------*/
 CacheItemList::iterator FilterCache::impl_loadItemOnDemand(      EItemType        eType,
                                                            const ::rtl::OUString& sItem)
@@ -1951,7 +1951,7 @@ CacheItemList::iterator FilterCache::imp
 
         case E_DETECTSERVICE :
         {
-            OSL_ENSURE(sal_False, "Can't load detect services on demand. Who use this unsupported
feature?");
+            OSL_ENSURE(sal_False, "Can't load detect services on demand. Who uses this unsupported
feature?");
         }
         break;
     }
@@ -1975,10 +1975,10 @@ CacheItemList::iterator FilterCache::imp
     {
         if (pItemInCache != pList->end())
             pList->erase(pItemInCache);
-        // OK - this item does not exists inside configuration.
+        // OK - this item does not exist inside configuration.
         // And we already updated our internal cache.
         // But the outside code needs this NoSuchElementException
-        // to know, that this item does notexists.
+        // to know, that this item does not exist.
         // Nobody checks the iterator!
         throw css::container::NoSuchElementException();
     }
@@ -1987,7 +1987,7 @@ CacheItemList::iterator FilterCache::imp
 }
 
 /*-----------------------------------------------
-    20.10.2003 09:38
+	20.10.2003 09:38
 -----------------------------------------------*/
 void FilterCache::impl_saveItem(const css::uno::Reference< css::container::XNameReplace
>& xItem,
                                       EItemType                                         
  eType,
@@ -2056,7 +2056,7 @@ void FilterCache::impl_saveItem(const cs
             // special handling for flags! Convert it from an integer flag field back
             // to a list of names ...
             // But note: because we work directly on a reference to the cache item,
-            // its not allowd to change the value here. We must work on a copy!
+            // it's not allowed to change the value here. We must work on a copy!
             sal_Int32 nFlags = 0;
             pIt = aItem.find(PROPNAME_FLAGS);
             if (pIt != aItem.end())
@@ -2091,8 +2091,8 @@ void FilterCache::impl_saveItem(const cs
 }
 
 /*-----------------------------------------------
-    20.10.2003 09:45
-    static! => no locks necessary
+	20.10.2003 09:45
+	static! => no locks necessary
 -----------------------------------------------*/
 css::uno::Sequence< ::rtl::OUString > FilterCache::impl_convertFlagField2FlagNames(sal_Int32
nFlags)
 {
@@ -2126,8 +2126,8 @@ css::uno::Sequence< ::rtl::OUString > Fi
 }
 
 /*-----------------------------------------------
-    27.06.2003 09:26
-    static! => no locks necessary
+	27.06.2003 09:26
+	static! => no locks necessary
 -----------------------------------------------*/
 sal_Int32 FilterCache::impl_convertFlagNames2FlagField(const css::uno::Sequence< ::rtl::OUString
>& lNames)
 {
@@ -2258,7 +2258,7 @@ sal_Int32 FilterCache::impl_convertFlagN
 }
 
 /*-----------------------------------------------
-    12.02.2004 08:40
+	12.02.2004 08:40
 -----------------------------------------------*/
 void FilterCache::impl_interpretDataVal4Type(const ::rtl::OUString& sValue,
                                                    sal_Int32        nProp ,
@@ -2290,7 +2290,7 @@ void FilterCache::impl_interpretDataVal4
 }
 
 /*-----------------------------------------------
-    12.02.2004 08:50
+	12.02.2004 08:50
 -----------------------------------------------*/
 void FilterCache::impl_interpretDataVal4Filter(const ::rtl::OUString& sValue,
                                                      sal_Int32        nProp ,
@@ -2336,7 +2336,7 @@ void FilterCache::impl_interpretDataVal4
 }
 
 /*-----------------------------------------------
-    12.02.2004 08:30
+	12.02.2004 08:30
     TODO work on a cache copy first, which can be flushed afterwards
          That would be usefully to guarantee a consistent cache.
 -----------------------------------------------*/
@@ -2347,7 +2347,7 @@ void FilterCache::impl_readOldFormat()
     static ::rtl::OUString FILTER_SET = ::rtl::OUString::createFromAscii("Filters");
 
     // Attention: Opening/Reading of this old configuration format has to be handled gracefully.
-    // Its optional and shouldn't disturb our normal work!
+    // It's optional and shouldn't disturb our normal work!
     // E.g. we must check, if the package exists ...
 
     css::uno::Reference< css::container::XNameAccess > xCfg;
@@ -2357,13 +2357,13 @@ void FilterCache::impl_readOldFormat()
         xCfg = css::uno::Reference< css::container::XNameAccess >(xInt, css::uno::UNO_QUERY_THROW);
     }
     /* corrupt filter addon ? because it's external (optional) code .. we can ignore it.
Addon wont work then ...
-       but that seams to be acceptable.
+       but that seems to be acceptable.
        see #139088# for further informations
     */
     catch(const css::uno::Exception&)
         { return; }
 
-    // May be there is no type set ...
+    // Maybe there is no type set ...
     if (xCfg->hasByName(TYPES_SET))
     {
         css::uno::Reference< css::container::XNameAccess > xSet;
@@ -2374,7 +2374,7 @@ void FilterCache::impl_readOldFormat()
             m_lTypes[pItems[i]] = impl_readOldItem(xSet, E_TYPE, pItems[i]);
     }
 
-    // May be there is no filter set ...
+    // Maybe there is no filter set ...
     if (xCfg->hasByName(FILTER_SET))
     {
         css::uno::Reference< css::container::XNameAccess > xSet;
@@ -2387,7 +2387,7 @@ void FilterCache::impl_readOldFormat()
 }
 
 /*-----------------------------------------------
-    12.02.2004 08:30
+	12.02.2004 08:30
 -----------------------------------------------*/
 CacheItem FilterCache::impl_readOldItem(const css::uno::Reference< css::container::XNameAccess
>& xSet ,
                                               EItemType                                 
         eType,
@@ -2449,7 +2449,7 @@ CacheItem FilterCache::impl_readOldItem(
 }
 
 /*-----------------------------------------------
-    12.02.2004 08:15
+	12.02.2004 08:15
 -----------------------------------------------*/
 OUStringList FilterCache::impl_tokenizeString(const ::rtl::OUString& sData     ,
                                                     sal_Unicode      cSeperator)



Mime
View raw message