From ed5640d8b587fbcfed7dd7967f3de04b37a76f26 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 11:06:44 +0200 Subject: Adding upstream version 4:7.4.7. Signed-off-by: Daniel Baumann --- connectivity/source/manager/mdrivermanager.cxx | 665 +++++++++++++++++++++++++ connectivity/source/manager/mdrivermanager.hxx | 121 +++++ connectivity/source/manager/sdbc2.component | 26 + 3 files changed, 812 insertions(+) create mode 100644 connectivity/source/manager/mdrivermanager.cxx create mode 100644 connectivity/source/manager/mdrivermanager.hxx create mode 100644 connectivity/source/manager/sdbc2.component (limited to 'connectivity/source/manager') diff --git a/connectivity/source/manager/mdrivermanager.cxx b/connectivity/source/manager/mdrivermanager.cxx new file mode 100644 index 000000000..e7e0adf5e --- /dev/null +++ b/connectivity/source/manager/mdrivermanager.cxx @@ -0,0 +1,665 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 regarding copyright + * ownership. The ASF licenses this file 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 . + */ + +#include + +#include "mdrivermanager.hxx" +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include + +namespace drivermanager +{ + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::logging; +using namespace ::osl; + +constexpr OUStringLiteral SERVICE_SDBC_DRIVER = u"com.sun.star.sdbc.Driver"; + +/// @throws NoSuchElementException +static void throwNoSuchElementException() +{ + throw NoSuchElementException(); +} + +class ODriverEnumeration : public ::cppu::WeakImplHelper< XEnumeration > +{ + friend class OSDBCDriverManager; + + typedef std::vector< Reference< XDriver > > DriverArray; + DriverArray m_aDrivers; + DriverArray::const_iterator m_aPos; + // order matters! + +protected: + virtual ~ODriverEnumeration() override; +public: + explicit ODriverEnumeration(DriverArray&& _rDriverSequence); + +// XEnumeration + virtual sal_Bool SAL_CALL hasMoreElements( ) override; + virtual Any SAL_CALL nextElement( ) override; +}; + + +ODriverEnumeration::ODriverEnumeration(DriverArray&& _rDriverSequence) + :m_aDrivers( std::move(_rDriverSequence) ) + ,m_aPos( m_aDrivers.begin() ) +{ +} + + +ODriverEnumeration::~ODriverEnumeration() +{ +} + + +sal_Bool SAL_CALL ODriverEnumeration::hasMoreElements( ) +{ + return m_aPos != m_aDrivers.end(); +} + + +Any SAL_CALL ODriverEnumeration::nextElement( ) +{ + if ( !hasMoreElements() ) + throwNoSuchElementException(); + + return Any( *m_aPos++ ); +} + +namespace +{ + /// an STL functor which ensures that a SdbcDriver described by a DriverAccess is loaded + struct EnsureDriver + { + explicit EnsureDriver( const Reference< XComponentContext > &rxContext ) + : mxContext( rxContext ) {} + + const DriverAccess& operator()( const DriverAccess& _rDescriptor ) const + { + // we did not load this driver, yet + if (_rDescriptor.xDriver.is()) + return _rDescriptor; + + // we have a factory for it + if (_rDescriptor.xComponentFactory.is()) + { + DriverAccess& rDesc = const_cast(_rDescriptor); + try + { + //load driver + rDesc.xDriver.set( + rDesc.xComponentFactory->createInstanceWithContext(mxContext), css::uno::UNO_QUERY); + } + catch (const Exception&) + { + //failure, abandon driver + rDesc.xComponentFactory.clear(); + } + } + return _rDescriptor; + } + + private: + Reference< XComponentContext > mxContext; + }; + + /// an STL functor which extracts a SdbcDriver from a DriverAccess + struct ExtractDriverFromAccess + { + const Reference& operator()( const DriverAccess& _rAccess ) const + { + return _rAccess.xDriver; + } + }; + + struct ExtractDriverFromCollectionElement + { + const Reference& operator()( const DriverCollection::value_type& _rElement ) const + { + return _rElement.second; + } + }; + + // predicate for checking whether or not a driver accepts a given URL + class AcceptsURL + { + protected: + const OUString& m_rURL; + + public: + // ctor + explicit AcceptsURL( const OUString& _rURL ) : m_rURL( _rURL ) { } + + + bool operator()( const Reference& _rDriver ) const + { + // ask the driver + return _rDriver.is() && _rDriver->acceptsURL( m_rURL ); + } + }; + +#if !ENABLE_FUZZERS + sal_Int32 lcl_getDriverPrecedence( const Reference& _rContext, Sequence< OUString >& _rPrecedence ) + { + _rPrecedence.realloc( 0 ); + try + { + // create a configuration provider + Reference< XMultiServiceFactory > xConfigurationProvider( + css::configuration::theDefaultProvider::get( _rContext ) ); + + // one argument for creating the node access: the path to the configuration node + Sequence< Any > aCreationArgs{ Any(NamedValue( + "nodepath", Any( OUString("org.openoffice.Office.DataAccess/DriverManager") ) )) }; + + // create the node access + Reference< XNameAccess > xDriverManagerNode( + xConfigurationProvider->createInstanceWithArguments("com.sun.star.configuration.ConfigurationAccess", aCreationArgs), + UNO_QUERY); + + OSL_ENSURE(xDriverManagerNode.is(), "lcl_getDriverPrecedence: could not open my configuration node!"); + if (xDriverManagerNode.is()) + { + // obtain the preference list + Any aPreferences = xDriverManagerNode->getByName("DriverPrecedence"); + bool bSuccess = aPreferences >>= _rPrecedence; + OSL_ENSURE(bSuccess || !aPreferences.hasValue(), "lcl_getDriverPrecedence: invalid value for the preferences node (no string sequence but not NULL)!"); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("connectivity.manager"); + } + + return _rPrecedence.getLength(); + } +#endif + + /// an STL algorithm compatible predicate comparing two DriverAccess instances by their implementation names + struct CompareDriverAccessByName + { + + bool operator()( const DriverAccess& lhs, const DriverAccess& rhs ) + { + return lhs.sImplementationName < rhs.sImplementationName; + } + }; + + /// and an STL algorithm compatible predicate comparing the impl name of a DriverAccess to a string + struct EqualDriverAccessToName + { + OUString m_sImplName; + explicit EqualDriverAccessToName(const OUString& _sImplName) : m_sImplName(_sImplName){} + + bool operator()( const DriverAccess& lhs) + { + return lhs.sImplementationName == m_sImplName; + } + }; +} + +OSDBCDriverManager::OSDBCDriverManager( const Reference< XComponentContext >& _rxContext ) + :OSDBCDriverManager_Base(m_aMutex) + ,m_xContext( _rxContext ) + ,m_aEventLogger( _rxContext, "org.openoffice.logging.sdbc.DriverManager" ) + ,m_aDriverConfig(m_xContext) + ,m_nLoginTimeout(0) +{ + // bootstrap all objects supporting the .sdb.Driver service + bootstrapDrivers(); + + // initialize the drivers order + initializeDriverPrecedence(); +} + + +OSDBCDriverManager::~OSDBCDriverManager() +{ +} + +void OSDBCDriverManager::bootstrapDrivers() +{ + Reference< XContentEnumerationAccess > xEnumAccess( m_xContext->getServiceManager(), UNO_QUERY ); + Reference< XEnumeration > xEnumDrivers; + if (xEnumAccess.is()) + xEnumDrivers = xEnumAccess->createContentEnumeration(SERVICE_SDBC_DRIVER); + + OSL_ENSURE( xEnumDrivers.is(), "OSDBCDriverManager::bootstrapDrivers: no enumeration for the drivers available!" ); + if (!xEnumDrivers.is()) + return; + + Reference< XSingleComponentFactory > xFactory; + Reference< XServiceInfo > xSI; + while (xEnumDrivers->hasMoreElements()) + { + xFactory.set(xEnumDrivers->nextElement(), css::uno::UNO_QUERY); + OSL_ENSURE( xFactory.is(), "OSDBCDriverManager::bootstrapDrivers: no factory extracted" ); + + if ( xFactory.is() ) + { + // we got a factory for the driver + DriverAccess aDriverDescriptor; + bool bValidDescriptor = false; + + // can it tell us something about the implementation name? + xSI.set(xFactory, css::uno::UNO_QUERY); + if ( xSI.is() ) + { // yes -> no need to load the driver immediately (load it later when needed) + aDriverDescriptor.sImplementationName = xSI->getImplementationName(); + aDriverDescriptor.xComponentFactory = xFactory; + bValidDescriptor = true; + + m_aEventLogger.log( LogLevel::CONFIG, + "found SDBC driver $1$, no need to load it", + aDriverDescriptor.sImplementationName + ); + } + else + { + // no -> create the driver + Reference< XDriver > xDriver( xFactory->createInstanceWithContext( m_xContext ), UNO_QUERY ); + OSL_ENSURE( xDriver.is(), "OSDBCDriverManager::bootstrapDrivers: a driver which is no driver?!" ); + + if ( xDriver.is() ) + { + aDriverDescriptor.xDriver = xDriver; + // and obtain its implementation name + xSI.set(xDriver, css::uno::UNO_QUERY); + OSL_ENSURE( xSI.is(), "OSDBCDriverManager::bootstrapDrivers: a driver without service info?" ); + if ( xSI.is() ) + { + aDriverDescriptor.sImplementationName = xSI->getImplementationName(); + bValidDescriptor = true; + + m_aEventLogger.log( LogLevel::CONFIG, + "found SDBC driver $1$, needed to load it", + aDriverDescriptor.sImplementationName + ); + } + } + } + + if ( bValidDescriptor ) + { + m_aDriversBS.push_back( aDriverDescriptor ); + } + } + } +} + + +void OSDBCDriverManager::initializeDriverPrecedence() +{ +#if !ENABLE_FUZZERS + if ( m_aDriversBS.empty() ) + // nothing to do + return; + + try + { + // get the precedence of the drivers from the configuration + Sequence< OUString > aDriverOrder; + if ( 0 == lcl_getDriverPrecedence( m_xContext, aDriverOrder ) ) + // nothing to do + return; + + // aDriverOrder now is the list of driver implementation names in the order they should be used + + if ( m_aEventLogger.isLoggable( LogLevel::CONFIG ) ) + { + sal_Int32 nOrderedCount = aDriverOrder.getLength(); + for ( sal_Int32 i=0; i(i + 1), nOrderedCount, aDriverOrder[i] + ); + } + + // sort our bootstrapped drivers + std::sort( m_aDriversBS.begin(), m_aDriversBS.end(), CompareDriverAccessByName() ); + + // the first driver for which there is no preference + DriverAccessArray::iterator aNoPrefDriversStart = m_aDriversBS.begin(); + // at the moment this is the first of all drivers we know + + // loop through the names in the precedence order + for ( const OUString& rDriverOrder : std::as_const(aDriverOrder) ) + { + if (aNoPrefDriversStart == m_aDriversBS.end()) + break; + + DriverAccess driver_order; + driver_order.sImplementationName = rDriverOrder; + + // look for the impl name in the DriverAccess array + std::pair< DriverAccessArray::iterator, DriverAccessArray::iterator > aPos = + std::equal_range( aNoPrefDriversStart, m_aDriversBS.end(), driver_order, CompareDriverAccessByName() ); + + if ( aPos.first != aPos.second ) + { // we have a DriverAccess with this impl name + + OSL_ENSURE( std::distance( aPos.first, aPos.second ) == 1, + "OSDBCDriverManager::initializeDriverPrecedence: more than one driver with this impl name? How this?" ); + // move the DriverAccess pointed to by aPos.first to the position pointed to by aNoPrefDriversStart + + if ( aPos.first != aNoPrefDriversStart ) + { // if this does not hold, the DriverAccess already has the correct position + + // rotate the range [aNoPrefDriversStart, aPos.second) right 1 element + std::rotate( aNoPrefDriversStart, aPos.second - 1, aPos.second ); + } + + // next round we start searching and pos right + ++aNoPrefDriversStart; + } + } + } + catch (Exception&) + { + TOOLS_WARN_EXCEPTION( "connectivity.hsqldb", "OSDBCDriverManager::initializeDriverPrecedence: caught an exception while sorting the drivers!"); + } +#endif +} + + +Reference< XConnection > SAL_CALL OSDBCDriverManager::getConnection( const OUString& _rURL ) +{ + MutexGuard aGuard(m_aMutex); + + m_aEventLogger.log( LogLevel::INFO, + "connection requested for URL $1$", + _rURL + ); + + Reference< XConnection > xConnection; + Reference< XDriver > xDriver = implGetDriverForURL(_rURL); + if (xDriver.is()) + { + // TODO : handle the login timeout + xConnection = xDriver->connect(_rURL, Sequence< PropertyValue >()); + // may throw an exception + m_aEventLogger.log( LogLevel::INFO, + "connection retrieved for URL $1$", + _rURL + ); + } + + return xConnection; +} + + +Reference< XConnection > SAL_CALL OSDBCDriverManager::getConnectionWithInfo( const OUString& _rURL, const Sequence< PropertyValue >& _rInfo ) +{ + MutexGuard aGuard(m_aMutex); + + m_aEventLogger.log( LogLevel::INFO, + "connection with info requested for URL $1$", + _rURL + ); + + Reference< XConnection > xConnection; + Reference< XDriver > xDriver = implGetDriverForURL(_rURL); + if (xDriver.is()) + { + // TODO : handle the login timeout + xConnection = xDriver->connect(_rURL, _rInfo); + // may throw an exception + m_aEventLogger.log( LogLevel::INFO, + "connection with info retrieved for URL $1$", + _rURL + ); + } + + return xConnection; +} + + +void SAL_CALL OSDBCDriverManager::setLoginTimeout( sal_Int32 seconds ) +{ + MutexGuard aGuard(m_aMutex); + m_nLoginTimeout = seconds; +} + + +sal_Int32 SAL_CALL OSDBCDriverManager::getLoginTimeout( ) +{ + MutexGuard aGuard(m_aMutex); + return m_nLoginTimeout; +} + + +Reference< XEnumeration > SAL_CALL OSDBCDriverManager::createEnumeration( ) +{ + MutexGuard aGuard(m_aMutex); + + ODriverEnumeration::DriverArray aDrivers; + + // ensure that all our bootstrapped drivers are instantiated + std::for_each( m_aDriversBS.begin(), m_aDriversBS.end(), EnsureDriver( m_xContext ) ); + + // copy the bootstrapped drivers + std::transform( + m_aDriversBS.begin(), // "copy from" start + m_aDriversBS.end(), // "copy from" end + std::back_inserter( aDrivers ), // insert into + ExtractDriverFromAccess() // transformation to apply (extract a driver from a driver access) + ); + + // append the runtime drivers + std::transform( + m_aDriversRT.begin(), // "copy from" start + m_aDriversRT.end(), // "copy from" end + std::back_inserter( aDrivers ), // insert into + ExtractDriverFromCollectionElement() // transformation to apply (extract a driver from a driver access) + ); + + return new ODriverEnumeration( std::move(aDrivers) ); +} + + +css::uno::Type SAL_CALL OSDBCDriverManager::getElementType( ) +{ + return cppu::UnoType::get(); +} + + +sal_Bool SAL_CALL OSDBCDriverManager::hasElements( ) +{ + MutexGuard aGuard(m_aMutex); + return !(m_aDriversBS.empty() && m_aDriversRT.empty()); +} + + +OUString SAL_CALL OSDBCDriverManager::getImplementationName( ) +{ + return "com.sun.star.comp.sdbc.OSDBCDriverManager"; +} + +sal_Bool SAL_CALL OSDBCDriverManager::supportsService( const OUString& _rServiceName ) +{ + return cppu::supportsService(this, _rServiceName); +} + + +Sequence< OUString > SAL_CALL OSDBCDriverManager::getSupportedServiceNames( ) +{ + return { "com.sun.star.sdbc.DriverManager" }; +} + + +Reference< XInterface > SAL_CALL OSDBCDriverManager::getRegisteredObject( const OUString& _rName ) +{ + MutexGuard aGuard(m_aMutex); + DriverCollection::const_iterator aSearch = m_aDriversRT.find(_rName); + if (aSearch == m_aDriversRT.end()) + throwNoSuchElementException(); + + return aSearch->second; +} + + +void SAL_CALL OSDBCDriverManager::registerObject( const OUString& _rName, const Reference< XInterface >& _rxObject ) +{ + MutexGuard aGuard(m_aMutex); + + m_aEventLogger.log( LogLevel::INFO, + "attempt to register new driver for name $1$", + _rName + ); + + DriverCollection::const_iterator aSearch = m_aDriversRT.find(_rName); + if (aSearch != m_aDriversRT.end()) + throw ElementExistException(); + Reference< XDriver > xNewDriver(_rxObject, UNO_QUERY); + if (!xNewDriver.is()) + throw IllegalArgumentException(); + + m_aDriversRT.emplace(_rName, xNewDriver); + + m_aEventLogger.log( LogLevel::INFO, + "new driver registered for name $1$", + _rName + ); +} + + +void SAL_CALL OSDBCDriverManager::revokeObject( const OUString& _rName ) +{ + MutexGuard aGuard(m_aMutex); + + m_aEventLogger.log( LogLevel::INFO, + "attempt to revoke driver for name $1$", + _rName + ); + + DriverCollection::iterator aSearch = m_aDriversRT.find(_rName); + if (aSearch == m_aDriversRT.end()) + throwNoSuchElementException(); + + m_aDriversRT.erase(aSearch); // we already have the iterator so we could use it + + m_aEventLogger.log( LogLevel::INFO, + "driver revoked for name $1$", + _rName + ); +} + + +Reference< XDriver > SAL_CALL OSDBCDriverManager::getDriverByURL( const OUString& _rURL ) +{ + m_aEventLogger.log( LogLevel::INFO, + "driver requested for URL $1$", + _rURL + ); + + Reference< XDriver > xDriver( implGetDriverForURL( _rURL ) ); + + if ( xDriver.is() ) + m_aEventLogger.log( LogLevel::INFO, + "driver obtained for URL $1$", + _rURL + ); + + return xDriver; +} + + +Reference< XDriver > OSDBCDriverManager::implGetDriverForURL(const OUString& _rURL) +{ + Reference< XDriver > xReturn; + + { + const OUString sDriverFactoryName = m_aDriverConfig.getDriverFactoryName(_rURL); + + EqualDriverAccessToName aEqual(sDriverFactoryName); + DriverAccessArray::const_iterator aFind = std::find_if(m_aDriversBS.begin(),m_aDriversBS.end(),aEqual); + if ( aFind == m_aDriversBS.end() ) + { + // search all bootstrapped drivers + aFind = std::find_if( + m_aDriversBS.begin(), // begin of search range + m_aDriversBS.end(), // end of search range + [&_rURL, this] (const DriverAccessArray::value_type& driverAccess) { + // extract the driver from the access, then ask the resulting driver for acceptance + const DriverAccess& ensuredAccess = EnsureDriver(m_xContext)(driverAccess); + const Reference driver = ExtractDriverFromAccess()(ensuredAccess); + return AcceptsURL(_rURL)(driver); + }); + } // if ( m_aDriversBS.find(sDriverFactoryName ) == m_aDriversBS.end() ) + else + { + EnsureDriver aEnsure( m_xContext ); + aEnsure(*aFind); + } + + // found something? + if ( m_aDriversBS.end() != aFind && aFind->xDriver.is() && aFind->xDriver->acceptsURL(_rURL) ) + xReturn = aFind->xDriver; + } + + if ( !xReturn.is() ) + { + // no -> search the runtime drivers + DriverCollection::const_iterator aPos = std::find_if( + m_aDriversRT.begin(), // begin of search range + m_aDriversRT.end(), // end of search range + [&_rURL] (const DriverCollection::value_type& element) { + // extract the driver from the collection element, then ask the resulting driver for acceptance + const Reference driver = ExtractDriverFromCollectionElement()(element); + return AcceptsURL(_rURL)(driver); + }); + + if ( m_aDriversRT.end() != aPos ) + xReturn = aPos->second; + } + + return xReturn; +} + +} // namespace drivermanager + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* +connectivity_OSDBCDriverManager_get_implementation( + css::uno::XComponentContext* context , css::uno::Sequence const&) +{ + return cppu::acquire(new drivermanager::OSDBCDriverManager(context)); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/manager/mdrivermanager.hxx b/connectivity/source/manager/mdrivermanager.hxx new file mode 100644 index 000000000..239116f1c --- /dev/null +++ b/connectivity/source/manager/mdrivermanager.hxx @@ -0,0 +1,121 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 regarding copyright + * ownership. The ASF licenses this file 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 . + */ + +#pragma once + +#include + +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace drivermanager +{ + + typedef std::map< OUString, css::uno::Reference< css::sdbc::XDriver > > DriverCollection; + + struct DriverAccess + { + OUString sImplementationName; /// the implementation name of the driver + css::uno::Reference< css::sdbc::XDriver > xDriver; /// the driver itself + css::uno::Reference< css::lang::XSingleComponentFactory > xComponentFactory; /// the factory to create the driver component (if not already done so) + }; + + + // OSDBCDriverManager - the one-instance service for managing SDBC drivers + + typedef ::cppu::WeakComponentImplHelper< css::sdbc::XDriverManager2 + , css::lang::XServiceInfo + , css::uno::XNamingService + > OSDBCDriverManager_Base; + + class OSDBCDriverManager final : public cppu::BaseMutex, public OSDBCDriverManager_Base + { + friend class ODriverEnumeration; + + css::uno::Reference m_xContext; + ::comphelper::EventLogger m_aEventLogger; + + typedef std::vector DriverAccessArray; + DriverAccessArray m_aDriversBS; + + // for drivers registered at runtime (not bootstrapped) we don't require an XServiceInfo interface, + // so we have to remember their impl-name in another way + typedef std::map< OUString, css::uno::Reference< css::sdbc::XDriver > > DriverCollection; + DriverCollection m_aDriversRT; + + ::connectivity::DriversConfig m_aDriverConfig; + sal_Int32 m_nLoginTimeout; + + public: + + explicit OSDBCDriverManager( + const css::uno::Reference< css::uno::XComponentContext >& _rxContext ); + virtual ~OSDBCDriverManager() override; + + // XDriverManager + virtual css::uno::Reference< css::sdbc::XConnection > SAL_CALL getConnection( const OUString& url ) override; + virtual css::uno::Reference< css::sdbc::XConnection > SAL_CALL getConnectionWithInfo( const OUString& url, const css::uno::Sequence< css::beans::PropertyValue >& info ) override; + virtual void SAL_CALL setLoginTimeout( sal_Int32 seconds ) override; + virtual sal_Int32 SAL_CALL getLoginTimeout( ) override; + + // XDriverAccess + virtual css::uno::Reference< css::sdbc::XDriver > SAL_CALL getDriverByURL( const OUString& url ) override; + + // XEnumerationAccess + virtual css::uno::Reference< css::container::XEnumeration > SAL_CALL createEnumeration( ) override; + + // XElementAccess + virtual css::uno::Type SAL_CALL getElementType( ) override; + virtual sal_Bool SAL_CALL hasElements( ) override; + + // XServiceInfo + virtual OUString SAL_CALL getImplementationName( ) override; + virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override; + virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames( ) override; + + // XNamingService + virtual css::uno::Reference< css::uno::XInterface > SAL_CALL getRegisteredObject( const OUString& Name ) override; + virtual void SAL_CALL registerObject( const OUString& Name, const css::uno::Reference< css::uno::XInterface >& Object ) override; + virtual void SAL_CALL revokeObject( const OUString& Name ) override; + + private: + css::uno::Reference< css::sdbc::XDriver > implGetDriverForURL(const OUString& _rURL); + + /** retrieve the driver order preferences from the configuration and + sort m_aDriversBS accordingly. + */ + void initializeDriverPrecedence(); + + void bootstrapDrivers(); + }; + +} // namespace drivermanager + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/connectivity/source/manager/sdbc2.component b/connectivity/source/manager/sdbc2.component new file mode 100644 index 000000000..b9433256a --- /dev/null +++ b/connectivity/source/manager/sdbc2.component @@ -0,0 +1,26 @@ + + + + + + + + -- cgit v1.2.3