1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_framework.hxx" 26 27 /*TODO 28 - change "singleton" behaviour by using new helper ::comhelper::SingletonRef 29 - rename method exist() to existHandlerForURL() or similar one 30 - may its a good idea to replace struct ProtocolHandler by css::beans::NamedValue type?! 31 */ 32 33 //_________________________________________________________________________________________________________________ 34 // my own includes 35 //_________________________________________________________________________________________________________________ 36 37 #include <classes/protocolhandlercache.hxx> 38 #include <classes/converter.hxx> 39 #include <threadhelp/readguard.hxx> 40 #include <threadhelp/writeguard.hxx> 41 #include <threadhelp/lockhelper.hxx> 42 43 //_________________________________________________________________________________________________________________ 44 // interface includes 45 //_________________________________________________________________________________________________________________ 46 47 //_________________________________________________________________________________________________________________ 48 // other includes 49 //_________________________________________________________________________________________________________________ 50 #include <tools/wldcrd.hxx> 51 #include <unotools/configpathes.hxx> 52 #include <rtl/ustrbuf.hxx> 53 54 //_________________________________________________________________________________________________________________ 55 // namespace 56 //_________________________________________________________________________________________________________________ 57 58 namespace framework{ 59 60 //_________________________________________________________________________________________________________________ 61 // non exported const 62 //_________________________________________________________________________________________________________________ 63 64 //_________________________________________________________________________________________________________________ 65 // non exported definitions 66 //_________________________________________________________________________________________________________________ 67 68 /** 69 @short overloaded index operator of hash map to support pattern key search 70 @descr All keys inside this hash map are URL pattern which points to an uno 71 implementation name of a protocol handler service which is registered 72 for this pattern. This operator makes it easy to find such registered 73 handler by using a full qualified URL and compare it with all pattern 74 keys. 75 76 @param sURL 77 the full qualified URL which should match to a registered pattern 78 79 @return An iterator which points to the found item inside the hash or PatternHash::end() 80 if no pattern match this given <var>sURL</var>. 81 82 @modified 30.04.2002 09:52, as96863 83 */ 84 PatternHash::iterator PatternHash::findPatternKey( const ::rtl::OUString& sURL ) 85 { 86 PatternHash::iterator pItem = this->begin(); 87 while( pItem!=this->end() ) 88 { 89 WildCard aPattern(pItem->first); 90 if (aPattern.Matches(sURL)) 91 break; 92 ++pItem; 93 } 94 return pItem; 95 } 96 97 //_________________________________________________________________________________________________________________ 98 99 /** 100 @short initialize static member of class HandlerCache 101 @descr We use a singleton pattern to implement this handler cache. 102 That means it use two static member list to hold all neccessary informations 103 and a ref count mechanism to create/destroy it on demand. 104 105 @modified 30.04.2002 11:13, as96863 106 */ 107 HandlerHash* HandlerCache::m_pHandler = NULL; 108 PatternHash* HandlerCache::m_pPattern = NULL; 109 sal_Int32 HandlerCache::m_nRefCount = 0 ; 110 HandlerCFGAccess* HandlerCache::m_pConfig = NULL; 111 112 //_________________________________________________________________________________________________________________ 113 114 /** 115 @short ctor of the cache of all registered protoco handler 116 @descr It tries to open the right configuration package automaticly 117 and fill the internal structures. After that the cache can be 118 used for read access on this data and perform some search 119 operations on it. 120 121 @modified 30.04.2002 10:02, as96863 122 */ 123 HandlerCache::HandlerCache() 124 { 125 /* SAFE */{ 126 WriteGuard aGlobalLock( LockHelper::getGlobalLock() ); 127 128 if (m_nRefCount==0) 129 { 130 m_pHandler = new HandlerHash(); 131 m_pPattern = new PatternHash(); 132 m_pConfig = new HandlerCFGAccess(PACKAGENAME_PROTOCOLHANDLER); 133 m_pConfig->read(&m_pHandler,&m_pPattern); 134 m_pConfig->setCache(this); 135 } 136 137 ++m_nRefCount; 138 /* SAFE */} 139 } 140 141 //_________________________________________________________________________________________________________________ 142 143 /** 144 @short dtor of the cache 145 @descr It frees all used memory. In further implementations (may if we support write access too) 146 it's a good place to flush changes back to the configuration - but not needed yet. 147 148 @modified 30.04.2002 09:54, as96863 149 */ 150 HandlerCache::~HandlerCache() 151 { 152 /* SAFE */{ 153 WriteGuard aGlobalLock( LockHelper::getGlobalLock() ); 154 155 if( m_nRefCount==1) 156 { 157 m_pConfig->setCache(NULL); 158 m_pHandler->free(); 159 m_pPattern->free(); 160 161 delete m_pConfig; 162 delete m_pHandler; 163 delete m_pPattern; 164 m_pConfig = NULL; 165 m_pHandler= NULL; 166 m_pPattern= NULL; 167 } 168 169 --m_nRefCount; 170 /* SAFE */} 171 } 172 173 //_________________________________________________________________________________________________________________ 174 175 /** 176 @short dtor of the cache 177 @descr It frees all used memory. In further implementations (may if we support write access too) 178 it's a good place to flush changes back to the configuration - but not needed yet. 179 180 @modified 30.04.2002 09:54, as96863 181 */ 182 sal_Bool HandlerCache::search( const ::rtl::OUString& sURL, ProtocolHandler* pReturn ) const 183 { 184 sal_Bool bFound = sal_False; 185 /* SAFE */{ 186 ReadGuard aReadLock( LockHelper::getGlobalLock() ); 187 PatternHash::const_iterator pItem = m_pPattern->findPatternKey(sURL); 188 if (pItem!=m_pPattern->end()) 189 { 190 *pReturn = (*m_pHandler)[pItem->second]; 191 bFound = sal_True; 192 } 193 /* SAFE */} 194 return bFound; 195 } 196 197 //_________________________________________________________________________________________________________________ 198 199 /** 200 @short search for a registered handler by using an URL struct 201 @descr We combine neccessary parts of this struct to a valid URL string 202 and call our other search method ... 203 It's a helper for outside code. 204 205 @modified 30.04.2002 09:54, as96863 206 */ 207 sal_Bool HandlerCache::search( const css::util::URL& aURL, ProtocolHandler* pReturn ) const 208 { 209 return search( aURL.Complete, pReturn ); 210 } 211 212 //_________________________________________________________________________________________________________________ 213 214 sal_Bool HandlerCache::exists( const ::rtl::OUString& sURL ) const 215 { 216 sal_Bool bFound = sal_False; 217 /* SAFE */{ 218 ReadGuard aReadLock( LockHelper::getGlobalLock() ); 219 PatternHash::const_iterator pItem = m_pPattern->findPatternKey(sURL); 220 bFound = pItem!=m_pPattern->end(); 221 /* SAFE */} 222 return bFound; 223 } 224 225 //_________________________________________________________________________________________________________________ 226 void HandlerCache::takeOver(HandlerHash* pHandler, PatternHash* pPattern) 227 { 228 // SAFE -> 229 WriteGuard aWriteLock( LockHelper::getGlobalLock() ); 230 231 HandlerHash* pOldHandler = m_pHandler; 232 PatternHash* pOldPattern = m_pPattern; 233 234 m_pHandler = pHandler; 235 m_pPattern = pPattern; 236 237 pOldHandler->free(); 238 pOldPattern->free(); 239 delete pOldHandler; 240 delete pOldPattern; 241 242 aWriteLock.unlock(); 243 // <- SAFE 244 } 245 246 //_________________________________________________________________________________________________________________ 247 248 /** 249 @short dtor of the config access class 250 @descr It opens the configuration package automaticly by using base class mechanism. 251 After that "read()" method of this class should be called to use it. 252 253 @param sPackage 254 specifies the package name of the configuration data which should be used 255 256 @modified 30.04.2002 10:06, as96863 257 */ 258 HandlerCFGAccess::HandlerCFGAccess( const ::rtl::OUString& sPackage ) 259 : ConfigItem( sPackage ) 260 { 261 css::uno::Sequence< ::rtl::OUString > lListenPathes(1); 262 lListenPathes[0] = SETNAME_HANDLER; 263 EnableNotification(lListenPathes); 264 } 265 266 //_________________________________________________________________________________________________________________ 267 268 /** 269 @short use base class mechanism to fill given structures 270 @descr User use us as a wrapper between configuration api and his internal structures. 271 He give us some pointer to his member and we fill it. 272 273 @param pHandler 274 pointer to a list of protocol handler infos 275 276 @param pPattern 277 reverse map of handler pattern to her uno names 278 279 @modified 30.04.2002 09:54, as96863 280 */ 281 void HandlerCFGAccess::read( HandlerHash** ppHandler , 282 PatternHash** ppPattern ) 283 { 284 // list of all uno implementation names without encoding 285 css::uno::Sequence< ::rtl::OUString > lNames = GetNodeNames( SETNAME_HANDLER, ::utl::CONFIG_NAME_LOCAL_PATH ); 286 sal_Int32 nSourceCount = lNames.getLength(); 287 sal_Int32 nTargetCount = nSourceCount; 288 // list of all full qualified path names of configuration entries 289 css::uno::Sequence< ::rtl::OUString > lFullNames ( nTargetCount ); 290 291 // expand names to full path names 292 sal_Int32 nSource=0; 293 sal_Int32 nTarget=0; 294 for( nSource=0; nSource<nSourceCount; ++nSource ) 295 { 296 ::rtl::OUStringBuffer sPath( SETNAME_HANDLER ); 297 sPath.append(CFG_PATH_SEPERATOR); 298 sPath.append(lNames[nSource]); 299 sPath.append(CFG_PATH_SEPERATOR); 300 sPath.append(PROPERTY_PROTOCOLS); 301 302 lFullNames[nTarget] = sPath.makeStringAndClear(); 303 ++nTarget; 304 } 305 306 // get values at all 307 css::uno::Sequence< css::uno::Any > lValues = GetProperties( lFullNames ); 308 LOG_ASSERT2( lFullNames.getLength()!=lValues.getLength(), "HandlerCFGAccess::read()", "Miss some configuration values of handler set!" ) 309 310 // fill structures 311 nSource = 0; 312 for( nTarget=0; nTarget<nTargetCount; ++nTarget ) 313 { 314 // create it new for every loop to guarantee a real empty object! 315 ProtocolHandler aHandler; 316 aHandler.m_sUNOName = ::utl::extractFirstFromConfigurationPath(lNames[nSource]); 317 318 // unpack all values of this handler 319 css::uno::Sequence< ::rtl::OUString > lTemp; 320 lValues[nTarget] >>= lTemp; 321 aHandler.m_lProtocols = Converter::convert_seqOUString2OUStringList(lTemp); 322 323 // register his pattern into the performance search hash 324 for (OUStringList::iterator pItem =aHandler.m_lProtocols.begin(); 325 pItem!=aHandler.m_lProtocols.end() ; 326 ++pItem ) 327 { 328 (**ppPattern)[*pItem] = lNames[nSource]; 329 } 330 331 // ï¿œnsert the handler info into the normal handler cache 332 (**ppHandler)[lNames[nSource]] = aHandler; 333 ++nSource; 334 } 335 } 336 337 //_________________________________________________________________________________________________________________ 338 void HandlerCFGAccess::Notify(const css::uno::Sequence< rtl::OUString >& /*lPropertyNames*/) 339 { 340 HandlerHash* pHandler = new HandlerHash; 341 PatternHash* pPattern = new PatternHash; 342 343 read(&pHandler, &pPattern); 344 if (m_pCache) 345 m_pCache->takeOver(pHandler, pPattern); 346 else 347 { 348 delete pHandler; 349 delete pPattern; 350 } 351 } 352 353 void HandlerCFGAccess::Commit() 354 { 355 } 356 357 } // namespace framework 358