connectivity/source/manager/mdrivermanager.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "mdrivermanager.hxx"
  22 #include <com/sun/star/configuration/theDefaultProvider.hpp>
  23 #include <com/sun/star/sdbc/XDriver.hpp>
  24 #include <com/sun/star/container/XContentEnumerationAccess.hpp>
  25 #include <com/sun/star/container/ElementExistException.hpp>
  26 #include <com/sun/star/beans/NamedValue.hpp>
  27 #include <com/sun/star/logging/LogLevel.hpp>
  28
  29 #include <tools/diagnose_ex.h>
  30 #include <cppuhelper/implbase.hxx>
  31 #include <cppuhelper/supportsservice.hxx>
  32 #include <cppuhelper/weak.hxx>
  33 #include <osl/diagnose.h>
  34
  35 #include <algorithm>
  36 #include <iterator>
  37 #include <vector>
  38
  39 namespace drivermanager
  40 {
  41
  42 using namespace ::com::sun::star::uno;
  43 using namespace ::com::sun::star::lang;
  44 using namespace ::com::sun::star::sdbc;
  45 using namespace ::com::sun::star::beans;
  46 using namespace ::com::sun::star::container;
  47 using namespace ::com::sun::star::logging;
  48 using namespace ::osl;
  49
  50 #define SERVICE_SDBC_DRIVER     "com.sun.star.sdbc.Driver"
  51
  52 /// @throws NoSuchElementException
  53 static void throwNoSuchElementException()
  54 {
  55     throw NoSuchElementException();
  56 }
  57
  58 class ODriverEnumeration : public ::cppu::WeakImplHelper< XEnumeration >
  59 {
  60     friend class OSDBCDriverManager;
  61
  62     typedef std::vector< Reference< XDriver > > DriverArray;
  63     DriverArray                 m_aDrivers;
  64     DriverArray::const_iterator m_aPos;
  65     // order matters!
  66
  67 protected:
  68     virtual ~ODriverEnumeration() override;
  69 public:
  70     explicit ODriverEnumeration(const DriverArray& _rDriverSequence);
  71
  72 // XEnumeration
  73     virtual sal_Bool SAL_CALL hasMoreElements( ) override;
  74     virtual Any SAL_CALL nextElement( ) override;
  75 };
  76
  77
  78 ODriverEnumeration::ODriverEnumeration(const DriverArray& _rDriverSequence)
  79     :m_aDrivers( _rDriverSequence )
  80     ,m_aPos( m_aDrivers.begin() )
  81 {
  82 }
  83
  84
  85 ODriverEnumeration::~ODriverEnumeration()
  86 {
  87 }
  88
  89
  90 sal_Bool SAL_CALL ODriverEnumeration::hasMoreElements(  )
  91 {
  92     return m_aPos != m_aDrivers.end();
  93 }
  94
  95
  96 Any SAL_CALL ODriverEnumeration::nextElement(  )
  97 {
  98     if ( !hasMoreElements() )
  99         throwNoSuchElementException();
 100
 101     return makeAny( *m_aPos++ );
 102 }
 103
 104     namespace {
 105
 106     /// an STL functor which ensures that a SdbcDriver described by a DriverAccess is loaded
 107     struct EnsureDriver
 108     {
 109         explicit EnsureDriver( const Reference< XComponentContext > &rxContext )
 110             : mxContext( rxContext ) {}
 111
 112         const DriverAccess& operator()( const DriverAccess& _rDescriptor ) const
 113         {
 114             // we did not load this driver, yet
 115             if (!_rDescriptor.xDriver.is())
 116             {
 117                 // we have a factory for it
 118                 if (_rDescriptor.xComponentFactory.is())
 119                 {
 120                     DriverAccess& rDesc = const_cast<DriverAccess&>(_rDescriptor);
 121                     try
 122                     {
 123                         //load driver
 124                         rDesc.xDriver.set(
 125                             rDesc.xComponentFactory->createInstanceWithContext(mxContext), css::uno::UNO_QUERY);
 126                     }
 127                     catch (const Exception&)
 128                     {
 129                         //failure, abandon driver
 130                         rDesc.xComponentFactory.clear();
 131                     }
 132                 }
 133             }
 134             return _rDescriptor;
 135         }
 136
 137     private:
 138         Reference< XComponentContext > mxContext;
 139     };
 140
 141     /// an STL functor which extracts a SdbcDriver from a DriverAccess
 142     struct ExtractDriverFromAccess
 143     {
 144         const Reference<XDriver>& operator()( const DriverAccess& _rAccess ) const
 145         {
 146             return _rAccess.xDriver;
 147         }
 148     };
 149
 150     struct ExtractDriverFromCollectionElement
 151     {
 152         const Reference<XDriver>& operator()( const DriverCollection::value_type& _rElement ) const
 153         {
 154             return _rElement.second;
 155         }
 156     };
 157
 158     // predicate for checking whether or not a driver accepts a given URL
 159     class AcceptsURL
 160     {
 161     protected:
 162         const OUString& m_rURL;
 163
 164     public:
 165         // ctor
 166         explicit AcceptsURL( const OUString& _rURL ) : m_rURL( _rURL ) { }
 167
 168
 169         bool operator()( const Reference<XDriver>& _rDriver ) const
 170         {
 171             // ask the driver
 172             return _rDriver.is() && _rDriver->acceptsURL( m_rURL );
 173         }
 174     };
 175
 176     }
 177
 178     static sal_Int32 lcl_getDriverPrecedence( const Reference<XComponentContext>& _rContext, Sequence< OUString >& _rPrecedence )
 179     {
 180         _rPrecedence.realloc( 0 );
 181         try
 182         {
 183             // create a configuration provider
 184             Reference< XMultiServiceFactory > xConfigurationProvider(
 185                 css::configuration::theDefaultProvider::get( _rContext ) );
 186
 187             // one argument for creating the node access: the path to the configuration node
 188             Sequence< Any > aCreationArgs(1);
 189             aCreationArgs[0] <<= NamedValue( "nodepath", makeAny( OUString("org.openoffice.Office.DataAccess/DriverManager") ) );
 190
 191             // create the node access
 192             Reference< XNameAccess > xDriverManagerNode(
 193                 xConfigurationProvider->createInstanceWithArguments("com.sun.star.configuration.ConfigurationAccess", aCreationArgs),
 194                 UNO_QUERY);
 195
 196             OSL_ENSURE(xDriverManagerNode.is(), "lcl_getDriverPrecedence: could not open my configuration node!");
 197             if (xDriverManagerNode.is())
 198             {
 199                 // obtain the preference list
 200                 Any aPreferences = xDriverManagerNode->getByName("DriverPrecedence");
 201                 bool bSuccess = aPreferences >>= _rPrecedence;
 202                 OSL_ENSURE(bSuccess || !aPreferences.hasValue(), "lcl_getDriverPrecedence: invalid value for the preferences node (no string sequence but not NULL)!");
 203             }
 204         }
 205         catch( const Exception& )
 206         {
 207             DBG_UNHANDLED_EXCEPTION("connectivity.manager");
 208         }
 209
 210         return _rPrecedence.getLength();
 211     }
 212
 213     namespace {
 214
 215     /// an STL argorithm compatible predicate comparing two DriverAccess instances by their implementation names
 216     struct CompareDriverAccessByName
 217     {
 218
 219         bool operator()( const DriverAccess& lhs, const DriverAccess& rhs )
 220         {
 221             return lhs.sImplementationName < rhs.sImplementationName;
 222         }
 223     };
 224
 225     /// and STL argorithm compatible predicate comparing a DriverAccess' impl name to a string
 226     struct EqualDriverAccessToName
 227     {
 228         OUString m_sImplName;
 229         explicit EqualDriverAccessToName(const OUString& _sImplName) : m_sImplName(_sImplName){}
 230
 231         bool operator()( const DriverAccess& lhs)
 232         {
 233             return lhs.sImplementationName == m_sImplName;
 234         }
 235     };
 236
 237     }
 238
 239 OSDBCDriverManager::OSDBCDriverManager( const Reference< XComponentContext >& _rxContext )
 240     :OSDBCDriverManager_Base(m_aMutex)
 241     ,m_xContext( _rxContext )
 242     ,m_aEventLogger( _rxContext, "org.openoffice.logging.sdbc.DriverManager" )
 243     ,m_aDriverConfig(m_xContext)
 244     ,m_nLoginTimeout(0)
 245 {
 246     // bootstrap all objects supporting the .sdb.Driver service
 247     bootstrapDrivers();
 248
 249     // initialize the drivers order
 250     initializeDriverPrecedence();
 251 }
 252
 253
 254 OSDBCDriverManager::~OSDBCDriverManager()
 255 {
 256 }
 257
 258 void OSDBCDriverManager::bootstrapDrivers()
 259 {
 260     Reference< XContentEnumerationAccess > xEnumAccess( m_xContext->getServiceManager(), UNO_QUERY );
 261     Reference< XEnumeration > xEnumDrivers;
 262     if (xEnumAccess.is())
 263         xEnumDrivers = xEnumAccess->createContentEnumeration(SERVICE_SDBC_DRIVER);
 264
 265     OSL_ENSURE( xEnumDrivers.is(), "OSDBCDriverManager::bootstrapDrivers: no enumeration for the drivers available!" );
 266     if (!xEnumDrivers.is())
 267         return;
 268
 269     Reference< XSingleComponentFactory > xFactory;
 270     Reference< XServiceInfo > xSI;
 271     while (xEnumDrivers->hasMoreElements())
 272     {
 273         xFactory.set(xEnumDrivers->nextElement(), css::uno::UNO_QUERY);
 274         OSL_ENSURE( xFactory.is(), "OSDBCDriverManager::bootstrapDrivers: no factory extracted" );
 275
 276         if ( xFactory.is() )
 277         {
 278             // we got a factory for the driver
 279             DriverAccess aDriverDescriptor;
 280             bool bValidDescriptor = false;
 281
 282             // can it tell us something about the implementation name?
 283             xSI.set(xFactory, css::uno::UNO_QUERY);
 284             if ( xSI.is() )
 285             {   // yes -> no need to load the driver immediately (load it later when needed)
 286                 aDriverDescriptor.sImplementationName = xSI->getImplementationName();
 287                 aDriverDescriptor.xComponentFactory = xFactory;
 288                 bValidDescriptor = true;
 289
 290                 m_aEventLogger.log( LogLevel::CONFIG,
 291                     "found SDBC driver $1$, no need to load it",
 292                     aDriverDescriptor.sImplementationName
 293                 );
 294             }
 295             else
 296             {
 297                 // no -> create the driver
 298                 Reference< XDriver > xDriver( xFactory->createInstanceWithContext( m_xContext ), UNO_QUERY );
 299                 OSL_ENSURE( xDriver.is(), "OSDBCDriverManager::bootstrapDrivers: a driver which is no driver?!" );
 300
 301                 if ( xDriver.is() )
 302                 {
 303                     aDriverDescriptor.xDriver = xDriver;
 304                     // and obtain its implementation name
 305                     xSI.set(xDriver, css::uno::UNO_QUERY);
 306                     OSL_ENSURE( xSI.is(), "OSDBCDriverManager::bootstrapDrivers: a driver without service info?" );
 307                     if ( xSI.is() )
 308                     {
 309                         aDriverDescriptor.sImplementationName = xSI->getImplementationName();
 310                         bValidDescriptor = true;
 311
 312                         m_aEventLogger.log( LogLevel::CONFIG,
 313                             "found SDBC driver $1$, needed to load it",
 314                             aDriverDescriptor.sImplementationName
 315                         );
 316                     }
 317                 }
 318             }
 319
 320             if ( bValidDescriptor )
 321             {
 322                 m_aDriversBS.push_back( aDriverDescriptor );
 323             }
 324         }
 325     }
 326 }
 327
 328
 329 void OSDBCDriverManager::initializeDriverPrecedence()
 330 {
 331     if ( m_aDriversBS.empty() )
 332         // nothing to do
 333         return;
 334
 335     try
 336     {
 337         // get the precedence of the drivers from the configuration
 338         Sequence< OUString > aDriverOrder;
 339         if ( 0 == lcl_getDriverPrecedence( m_xContext, aDriverOrder ) )
 340             // nothing to do
 341             return;
 342
 343         // aDriverOrder now is the list of driver implementation names in the order they should be used
 344
 345         if ( m_aEventLogger.isLoggable( LogLevel::CONFIG ) )
 346         {
 347             sal_Int32 nOrderedCount = aDriverOrder.getLength();
 348             for ( sal_Int32 i=0; i<nOrderedCount; ++i )
 349             m_aEventLogger.log( LogLevel::CONFIG,
 350                 "configuration's driver order: driver $1$ of $2$: $3$",
 351                 static_cast<sal_Int32>(i + 1), nOrderedCount, aDriverOrder[i]
 352             );
 353         }
 354
 355         // sort our bootstrapped drivers
 356         std::sort( m_aDriversBS.begin(), m_aDriversBS.end(), CompareDriverAccessByName() );
 357
 358         // the first driver for which there is no preference
 359         DriverAccessArray::iterator aNoPrefDriversStart = m_aDriversBS.begin();
 360             // at the moment this is the first of all drivers we know
 361
 362         // loop through the names in the precedence order
 363         for ( const OUString& rDriverOrder : std::as_const(aDriverOrder) )
 364         {
 365             if (aNoPrefDriversStart == m_aDriversBS.end())
 366                 break;
 367
 368             DriverAccess driver_order;
 369             driver_order.sImplementationName = rDriverOrder;
 370
 371             // look for the impl name in the DriverAccess array
 372             std::pair< DriverAccessArray::iterator, DriverAccessArray::iterator > aPos =
 373                 std::equal_range( aNoPrefDriversStart, m_aDriversBS.end(), driver_order, CompareDriverAccessByName() );
 374
 375             if ( aPos.first != aPos.second )
 376             {   // we have a DriverAccess with this impl name
 377
 378                 OSL_ENSURE( std::distance( aPos.first, aPos.second ) == 1,
 379                     "OSDBCDriverManager::initializeDriverPrecedence: more than one driver with this impl name? How this?" );
 380                 // move the DriverAccess pointed to by aPos.first to the position pointed to by aNoPrefDriversStart
 381
 382                 if ( aPos.first != aNoPrefDriversStart )
 383                 {   // if this does not hold, the DriverAccess already has the correct position
 384
 385                     // rotate the range [aNoPrefDriversStart, aPos.second) right 1 element
 386                     std::rotate( aNoPrefDriversStart, aPos.second - 1, aPos.second );
 387                 }
 388
 389                 // next round we start searching and pos right
 390                 ++aNoPrefDriversStart;
 391             }
 392         }
 393     }
 394     catch (Exception&)
 395     {
 396         TOOLS_WARN_EXCEPTION( "connectivity.hsqldb", "OSDBCDriverManager::initializeDriverPrecedence: caught an exception while sorting the drivers!");
 397     }
 398 }
 399
 400
 401 Reference< XConnection > SAL_CALL OSDBCDriverManager::getConnection( const OUString& _rURL )
 402 {
 403     MutexGuard aGuard(m_aMutex);
 404
 405     m_aEventLogger.log( LogLevel::INFO,
 406         "connection requested for URL $1$",
 407         _rURL
 408     );
 409
 410     Reference< XConnection > xConnection;
 411     Reference< XDriver > xDriver = implGetDriverForURL(_rURL);
 412     if (xDriver.is())
 413     {
 414         // TODO : handle the login timeout
 415         xConnection = xDriver->connect(_rURL, Sequence< PropertyValue >());
 416         // may throw an exception
 417         m_aEventLogger.log( LogLevel::INFO,
 418             "connection retrieved for URL $1$",
 419             _rURL
 420         );
 421     }
 422
 423     return xConnection;
 424 }
 425
 426
 427 Reference< XConnection > SAL_CALL OSDBCDriverManager::getConnectionWithInfo( const OUString& _rURL, const Sequence< PropertyValue >& _rInfo )
 428 {
 429     MutexGuard aGuard(m_aMutex);
 430
 431     m_aEventLogger.log( LogLevel::INFO,
 432         "connection with info requested for URL $1$",
 433         _rURL
 434     );
 435
 436     Reference< XConnection > xConnection;
 437     Reference< XDriver > xDriver = implGetDriverForURL(_rURL);
 438     if (xDriver.is())
 439     {
 440         // TODO : handle the login timeout
 441         xConnection = xDriver->connect(_rURL, _rInfo);
 442         // may throw an exception
 443         m_aEventLogger.log( LogLevel::INFO,
 444             "connection with info retrieved for URL $1$",
 445             _rURL
 446         );
 447     }
 448
 449     return xConnection;
 450 }
 451
 452
 453 void SAL_CALL OSDBCDriverManager::setLoginTimeout( sal_Int32 seconds )
 454 {
 455     MutexGuard aGuard(m_aMutex);
 456     m_nLoginTimeout = seconds;
 457 }
 458
 459
 460 sal_Int32 SAL_CALL OSDBCDriverManager::getLoginTimeout(  )
 461 {
 462     MutexGuard aGuard(m_aMutex);
 463     return m_nLoginTimeout;
 464 }
 465
 466
 467 Reference< XEnumeration > SAL_CALL OSDBCDriverManager::createEnumeration(  )
 468 {
 469     MutexGuard aGuard(m_aMutex);
 470
 471     ODriverEnumeration::DriverArray aDrivers;
 472
 473     // ensure that all our bootstrapped drivers are instantiated
 474     std::for_each( m_aDriversBS.begin(), m_aDriversBS.end(), EnsureDriver( m_xContext ) );
 475
 476     // copy the bootstrapped drivers
 477     std::transform(
 478         m_aDriversBS.begin(),               // "copy from" start
 479         m_aDriversBS.end(),                 // "copy from" end
 480         std::back_inserter( aDrivers ),   // insert into
 481         ExtractDriverFromAccess()           // transformation to apply (extract a driver from a driver access)
 482     );
 483
 484     // append the runtime drivers
 485     std::transform(
 486         m_aDriversRT.begin(),                   // "copy from" start
 487         m_aDriversRT.end(),                     // "copy from" end
 488         std::back_inserter( aDrivers ),       // insert into
 489         ExtractDriverFromCollectionElement()    // transformation to apply (extract a driver from a driver access)
 490     );
 491
 492     return new ODriverEnumeration( aDrivers );
 493 }
 494
 495
 496 css::uno::Type SAL_CALL OSDBCDriverManager::getElementType(  )
 497 {
 498     return cppu::UnoType<XDriver>::get();
 499 }
 500
 501
 502 sal_Bool SAL_CALL OSDBCDriverManager::hasElements(  )
 503 {
 504     MutexGuard aGuard(m_aMutex);
 505     return !(m_aDriversBS.empty() && m_aDriversRT.empty());
 506 }
 507
 508
 509 OUString SAL_CALL OSDBCDriverManager::getImplementationName(  )
 510 {
 511     return "com.sun.star.comp.sdbc.OSDBCDriverManager";
 512 }
 513
 514 sal_Bool SAL_CALL OSDBCDriverManager::supportsService( const OUString& _rServiceName )
 515 {
 516     return cppu::supportsService(this, _rServiceName);
 517 }
 518
 519
 520 Sequence< OUString > SAL_CALL OSDBCDriverManager::getSupportedServiceNames(  )
 521 {
 522     return { "com.sun.star.sdbc.DriverManager" };
 523 }
 524
 525
 526 Reference< XInterface > SAL_CALL OSDBCDriverManager::getRegisteredObject( const OUString& _rName )
 527 {
 528     MutexGuard aGuard(m_aMutex);
 529     DriverCollection::const_iterator aSearch = m_aDriversRT.find(_rName);
 530     if (aSearch == m_aDriversRT.end())
 531         throwNoSuchElementException();
 532
 533     return aSearch->second;
 534 }
 535
 536
 537 void SAL_CALL OSDBCDriverManager::registerObject( const OUString& _rName, const Reference< XInterface >& _rxObject )
 538 {
 539     MutexGuard aGuard(m_aMutex);
 540
 541     m_aEventLogger.log( LogLevel::INFO,
 542         "attempt to register new driver for name $1$",
 543         _rName
 544     );
 545
 546     DriverCollection::const_iterator aSearch = m_aDriversRT.find(_rName);
 547     if (aSearch != m_aDriversRT.end())
 548         throw ElementExistException();
 549     Reference< XDriver > xNewDriver(_rxObject, UNO_QUERY);
 550     if (!xNewDriver.is())
 551         throw IllegalArgumentException();
 552
 553     m_aDriversRT.emplace(_rName, xNewDriver);
 554
 555     m_aEventLogger.log( LogLevel::INFO,
 556         "new driver registered for name $1$",
 557         _rName
 558     );
 559 }
 560
 561
 562 void SAL_CALL OSDBCDriverManager::revokeObject( const OUString& _rName )
 563 {
 564     MutexGuard aGuard(m_aMutex);
 565
 566     m_aEventLogger.log( LogLevel::INFO,
 567         "attempt to revoke driver for name $1$",
 568         _rName
 569     );
 570
 571     DriverCollection::iterator aSearch = m_aDriversRT.find(_rName);
 572     if (aSearch == m_aDriversRT.end())
 573         throwNoSuchElementException();
 574
 575     m_aDriversRT.erase(aSearch); // we already have the iterator so we could use it
 576
 577     m_aEventLogger.log( LogLevel::INFO,
 578         "driver revoked for name $1$",
 579         _rName
 580     );
 581 }
 582
 583
 584 Reference< XDriver > SAL_CALL OSDBCDriverManager::getDriverByURL( const OUString& _rURL )
 585 {
 586     m_aEventLogger.log( LogLevel::INFO,
 587         "driver requested for URL $1$",
 588         _rURL
 589     );
 590
 591     Reference< XDriver > xDriver( implGetDriverForURL( _rURL ) );
 592
 593     if ( xDriver.is() )
 594         m_aEventLogger.log( LogLevel::INFO,
 595             "driver obtained for URL $1$",
 596             _rURL
 597         );
 598
 599     return xDriver;
 600 }
 601
 602
 603 Reference< XDriver > OSDBCDriverManager::implGetDriverForURL(const OUString& _rURL)
 604 {
 605     Reference< XDriver > xReturn;
 606
 607     {
 608         const OUString sDriverFactoryName = m_aDriverConfig.getDriverFactoryName(_rURL);
 609
 610         EqualDriverAccessToName aEqual(sDriverFactoryName);
 611         DriverAccessArray::const_iterator aFind = std::find_if(m_aDriversBS.begin(),m_aDriversBS.end(),aEqual);
 612         if ( aFind == m_aDriversBS.end() )
 613         {
 614             // search all bootstrapped drivers
 615             aFind = std::find_if(
 616                 m_aDriversBS.begin(),       // begin of search range
 617                 m_aDriversBS.end(),         // end of search range
 618                 [&_rURL, this] (const DriverAccessArray::value_type& driverAccess) {
 619                     // extract the driver from the access, then ask the resulting driver for acceptance
 620                     const DriverAccess& ensuredAccess = EnsureDriver(m_xContext)(driverAccess);
 621                     const Reference<XDriver> driver = ExtractDriverFromAccess()(ensuredAccess);
 622                     return AcceptsURL(_rURL)(driver);
 623                 });
 624         } // if ( m_aDriversBS.find(sDriverFactoryName ) == m_aDriversBS.end() )
 625         else
 626         {
 627             EnsureDriver aEnsure( m_xContext );
 628             aEnsure(*aFind);
 629         }
 630
 631         // found something?
 632         if ( m_aDriversBS.end() != aFind && aFind->xDriver.is() && aFind->xDriver->acceptsURL(_rURL) )
 633             xReturn = aFind->xDriver;
 634     }
 635
 636     if ( !xReturn.is() )
 637     {
 638         // no -> search the runtime drivers
 639         DriverCollection::const_iterator aPos = std::find_if(
 640             m_aDriversRT.begin(),       // begin of search range
 641             m_aDriversRT.end(),         // end of search range
 642             [&_rURL] (const DriverCollection::value_type& element) {
 643                 // extract the driver from the collection element, then ask the resulting driver for acceptance
 644                 const Reference<XDriver> driver = ExtractDriverFromCollectionElement()(element);
 645                 return AcceptsURL(_rURL)(driver);
 646             });
 647
 648         if ( m_aDriversRT.end() != aPos )
 649             xReturn = aPos->second;
 650     }
 651
 652     return xReturn;
 653 }
 654
 655 }   // namespace drivermanager
 656
 657 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 658 connectivity_OSDBCDriverManager_get_implementation(
 659     css::uno::XComponentContext* context , css::uno::Sequence<css::uno::Any> const&)
 660 {
 661     return cppu::acquire(new drivermanager::OSDBCDriverManager(context));
 662 }
 663
 664
 665 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */