LCOV - code coverage report
Current view: top level - ucb/source/ucp/ftp - ftpresultsetbase.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 0 205 0.0 %
Date: 2014-11-03 Functions: 0 48 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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             : #include <comphelper/processfactory.hxx>
      21             : #include <ucbhelper/contentidentifier.hxx>
      22             : #include <com/sun/star/ucb/OpenMode.hpp>
      23             : #include <com/sun/star/uno/Reference.h>
      24             : #include <com/sun/star/beans/PropertyAttribute.hpp>
      25             : #include <com/sun/star/ucb/ListActionType.hpp>
      26             : #include <com/sun/star/ucb/XSourceInitialization.hpp>
      27             : #include <ucbhelper/resultsetmetadata.hxx>
      28             : #include "ftpresultsetbase.hxx"
      29             : 
      30             : using namespace ftp;
      31             : using namespace com::sun::star;
      32             : 
      33           0 : ResultSetBase::ResultSetBase(
      34             :     const uno::Reference< uno::XComponentContext >&  rxContext,
      35             :     const uno::Reference< ucb::XContentProvider >&  xProvider,
      36             :     sal_Int32 nOpenMode,
      37             :     const uno::Sequence< beans::Property >& seq,
      38             :     const uno::Sequence< ucb::NumberedSortingInfo >& seqSort )
      39             :     : m_xContext( rxContext ),
      40             :       m_xProvider( xProvider ),
      41             :       m_nRow( -1 ),
      42             :       m_nWasNull( true ),
      43             :       m_nOpenMode( nOpenMode ),
      44             :       m_bRowCountFinal( true ),
      45             :       m_sProperty( seq ),
      46             :       m_sSortingInfo( seqSort ),
      47             :       m_pDisposeEventListeners( 0 ),
      48             :       m_pRowCountListeners( 0 ),
      49           0 :       m_pIsFinalListeners( 0 )
      50             : {
      51           0 : }
      52             : 
      53           0 : ResultSetBase::~ResultSetBase()
      54             : {
      55           0 :     delete m_pIsFinalListeners;
      56           0 :     delete m_pRowCountListeners;
      57           0 :     delete m_pDisposeEventListeners;
      58           0 : }
      59             : 
      60             : 
      61             : // XInterface
      62             : 
      63             : void SAL_CALL
      64           0 : ResultSetBase::acquire(
      65             :     void )
      66             :     throw()
      67             : {
      68           0 :     OWeakObject::acquire();
      69           0 : }
      70             : 
      71             : 
      72             : void SAL_CALL
      73           0 : ResultSetBase::release(
      74             :     void )
      75             :     throw()
      76             : {
      77           0 :     OWeakObject::release();
      78           0 : }
      79             : 
      80             : 
      81             : 
      82             : uno::Any SAL_CALL
      83           0 : ResultSetBase::queryInterface(
      84             :     const uno::Type& rType )
      85             :     throw( uno::RuntimeException, std::exception )
      86             : {
      87             :     uno::Any aRet = cppu::queryInterface(
      88             :         rType,
      89             :         (static_cast< lang::XComponent* >(this)),
      90             :         (static_cast< sdbc::XRow* >(this)),
      91             :         (static_cast< sdbc::XResultSet* >(this)),
      92             :         (static_cast< sdbc::XResultSetMetaDataSupplier* >(this)),
      93             :         (static_cast< beans::XPropertySet* >(this)),
      94           0 :         (static_cast< ucb::XContentAccess* >(this)) );
      95           0 :     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
      96             : }
      97             : 
      98             : 
      99             : 
     100             : // XComponent
     101             : 
     102             : 
     103             : void SAL_CALL
     104           0 : ResultSetBase::addEventListener(
     105             :     const uno::Reference< lang::XEventListener >& Listener )
     106             :     throw( uno::RuntimeException, std::exception )
     107             : {
     108           0 :     osl::MutexGuard aGuard( m_aMutex );
     109             : 
     110           0 :     if ( ! m_pDisposeEventListeners )
     111             :         m_pDisposeEventListeners =
     112           0 :             new cppu::OInterfaceContainerHelper( m_aMutex );
     113             : 
     114           0 :     m_pDisposeEventListeners->addInterface( Listener );
     115           0 : }
     116             : 
     117             : 
     118             : void SAL_CALL
     119           0 : ResultSetBase::removeEventListener(
     120             :     const uno::Reference< lang::XEventListener >& Listener )
     121             :     throw( uno::RuntimeException, std::exception )
     122             : {
     123           0 :     osl::MutexGuard aGuard( m_aMutex );
     124             : 
     125           0 :     if ( m_pDisposeEventListeners )
     126           0 :         m_pDisposeEventListeners->removeInterface( Listener );
     127           0 : }
     128             : 
     129             : 
     130             : 
     131             : void SAL_CALL
     132           0 : ResultSetBase::dispose()
     133             :     throw( uno::RuntimeException, std::exception )
     134             : {
     135           0 :     osl::MutexGuard aGuard( m_aMutex );
     136             : 
     137           0 :     lang::EventObject aEvt;
     138           0 :     aEvt.Source = static_cast< lang::XComponent * >( this );
     139             : 
     140           0 :     if ( m_pDisposeEventListeners && m_pDisposeEventListeners->getLength() )
     141             :     {
     142           0 :         m_pDisposeEventListeners->disposeAndClear( aEvt );
     143             :     }
     144           0 :     if( m_pRowCountListeners && m_pRowCountListeners->getLength() )
     145             :     {
     146           0 :         m_pRowCountListeners->disposeAndClear( aEvt );
     147             :     }
     148           0 :     if( m_pIsFinalListeners && m_pIsFinalListeners->getLength() )
     149             :     {
     150           0 :         m_pIsFinalListeners->disposeAndClear( aEvt );
     151           0 :     }
     152           0 : }
     153             : 
     154             : 
     155             : 
     156             : //  XResultSet
     157             : 
     158             : sal_Bool SAL_CALL
     159           0 : ResultSetBase::next(
     160             :     void )
     161             :     throw( sdbc::SQLException,
     162             :            uno::RuntimeException, std::exception )
     163             : {
     164             :     bool test;
     165           0 :     if( ++m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()) )
     166           0 :         test = true;
     167             :     else
     168           0 :         test = false;
     169           0 :     return test;
     170             : }
     171             : 
     172             : 
     173             : sal_Bool SAL_CALL
     174           0 : ResultSetBase::isBeforeFirst(
     175             :     void )
     176             :     throw( sdbc::SQLException,
     177             :            uno::RuntimeException, std::exception )
     178             : {
     179           0 :     return m_nRow == -1;
     180             : }
     181             : 
     182             : 
     183             : sal_Bool SAL_CALL
     184           0 : ResultSetBase::isAfterLast(
     185             :     void )
     186             :     throw( sdbc::SQLException,
     187             :            uno::RuntimeException, std::exception )
     188             : {
     189           0 :     return m_nRow >= sal::static_int_cast<sal_Int32>(m_aItems.size());   // Cannot happen, if m_aFolder.isOpen()
     190             : }
     191             : 
     192             : 
     193             : sal_Bool SAL_CALL
     194           0 : ResultSetBase::isFirst(
     195             :     void )
     196             :     throw( sdbc::SQLException,
     197             :            uno::RuntimeException, std::exception )
     198             : {
     199           0 :     return m_nRow == 0;
     200             : }
     201             : 
     202             : 
     203             : sal_Bool SAL_CALL
     204           0 : ResultSetBase::isLast(
     205             :     void  )
     206             :     throw( sdbc::SQLException,
     207             :            uno::RuntimeException, std::exception)
     208             : {
     209           0 :     if( m_nRow ==  sal::static_int_cast<sal_Int32>(m_aItems.size()) - 1 )
     210           0 :         return true;
     211             :     else
     212           0 :         return false;
     213             : }
     214             : 
     215             : 
     216             : void SAL_CALL
     217           0 : ResultSetBase::beforeFirst(
     218             :     void  )
     219             :     throw( sdbc::SQLException,
     220             :            uno::RuntimeException, std::exception)
     221             : {
     222           0 :     m_nRow = -1;
     223           0 : }
     224             : 
     225             : 
     226             : void SAL_CALL
     227           0 : ResultSetBase::afterLast(
     228             :     void  )
     229             :     throw( sdbc::SQLException,
     230             :            uno::RuntimeException, std::exception )
     231             : {
     232           0 :     m_nRow = m_aItems.size();
     233           0 : }
     234             : 
     235             : 
     236             : sal_Bool SAL_CALL
     237           0 : ResultSetBase::first(
     238             :     void  )
     239             :     throw( sdbc::SQLException,
     240             :            uno::RuntimeException, std::exception)
     241             : {
     242           0 :     m_nRow = -1;
     243           0 :     return next();
     244             : }
     245             : 
     246             : 
     247             : sal_Bool SAL_CALL
     248           0 : ResultSetBase::last(
     249             :     void  )
     250             :     throw( sdbc::SQLException,
     251             :            uno::RuntimeException, std::exception )
     252             : {
     253           0 :     m_nRow = m_aItems.size() - 1;
     254           0 :     return true;
     255             : }
     256             : 
     257             : 
     258             : sal_Int32 SAL_CALL
     259           0 : ResultSetBase::getRow(
     260             :     void )
     261             :     throw( sdbc::SQLException,
     262             :            uno::RuntimeException, std::exception)
     263             : {
     264             :     // Test, whether behind last row
     265           0 :     if( -1 == m_nRow || m_nRow >= sal::static_int_cast<sal_Int32>(m_aItems.size()) )
     266           0 :         return 0;
     267             :     else
     268           0 :         return m_nRow+1;
     269             : }
     270             : 
     271             : 
     272           0 : sal_Bool SAL_CALL ResultSetBase::absolute( sal_Int32 row )
     273             :     throw( sdbc::SQLException, uno::RuntimeException, std::exception)
     274             : {
     275           0 :     if( row >= 0 )
     276           0 :         m_nRow = row - 1;
     277             :     else
     278             :     {
     279           0 :         last();
     280           0 :         m_nRow += ( row + 1 );
     281           0 :         if( m_nRow < -1 )
     282           0 :             m_nRow = -1;
     283             :     }
     284             : 
     285           0 :     return 0<= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size());
     286             : }
     287             : 
     288             : 
     289             : 
     290             : 
     291             : sal_Bool SAL_CALL
     292           0 : ResultSetBase::relative(
     293             :     sal_Int32 row )
     294             :     throw( sdbc::SQLException,
     295             :            uno::RuntimeException, std::exception)
     296             : {
     297           0 :     if( isAfterLast() || isBeforeFirst() )
     298           0 :         throw sdbc::SQLException();
     299             : 
     300           0 :     if( row > 0 )
     301           0 :         while( row-- )
     302           0 :             next();
     303           0 :     else if( row < 0 )
     304           0 :         while( row++ && m_nRow > - 1 )
     305           0 :             previous();
     306             : 
     307           0 :     return 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size());
     308             : }
     309             : 
     310             : 
     311             : 
     312             : sal_Bool SAL_CALL
     313           0 : ResultSetBase::previous(
     314             :     void )
     315             :     throw( sdbc::SQLException,
     316             :            uno::RuntimeException, std::exception)
     317             : {
     318           0 :     if( m_nRow > sal::static_int_cast<sal_Int32>(m_aItems.size()) )
     319           0 :         m_nRow = m_aItems.size();  // Correct Handling of afterLast
     320           0 :     if( 0 <= m_nRow ) -- m_nRow;
     321             : 
     322           0 :     return 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size());
     323             : }
     324             : 
     325             : 
     326             : void SAL_CALL
     327           0 : ResultSetBase::refreshRow(
     328             :     void )
     329             :     throw( sdbc::SQLException,
     330             :            uno::RuntimeException, std::exception)
     331             : {
     332           0 : }
     333             : 
     334             : 
     335             : sal_Bool SAL_CALL
     336           0 : ResultSetBase::rowUpdated(
     337             :     void )
     338             :     throw( sdbc::SQLException,
     339             :            uno::RuntimeException, std::exception )
     340             : {
     341           0 :     return false;
     342             : }
     343             : 
     344             : sal_Bool SAL_CALL
     345           0 : ResultSetBase::rowInserted(
     346             :     void  )
     347             :     throw( sdbc::SQLException,
     348             :            uno::RuntimeException, std::exception )
     349             : {
     350           0 :     return false;
     351             : }
     352             : 
     353             : sal_Bool SAL_CALL
     354           0 : ResultSetBase::rowDeleted(
     355             :     void  )
     356             :     throw( sdbc::SQLException,
     357             :            uno::RuntimeException, std::exception )
     358             : {
     359           0 :     return false;
     360             : }
     361             : 
     362             : 
     363             : uno::Reference< uno::XInterface > SAL_CALL
     364           0 : ResultSetBase::getStatement(
     365             :     void  )
     366             :     throw( sdbc::SQLException,
     367             :            uno::RuntimeException, std::exception )
     368             : {
     369           0 :     uno::Reference< uno::XInterface > test( 0 );
     370           0 :     return test;
     371             : }
     372             : 
     373             : 
     374             : // XCloseable
     375             : 
     376             : void SAL_CALL
     377           0 : ResultSetBase::close(
     378             :     void )
     379             :     throw( sdbc::SQLException,
     380             :            uno::RuntimeException, std::exception)
     381             : {
     382           0 : }
     383             : 
     384             : 
     385             : OUString SAL_CALL
     386           0 : ResultSetBase::queryContentIdentifierString(
     387             :     void )
     388             :     throw( uno::RuntimeException, std::exception )
     389             : {
     390           0 :     if( 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()) )
     391           0 :         return m_aPath[m_nRow];
     392             :     else
     393           0 :         return OUString();
     394             : }
     395             : 
     396             : 
     397             : uno::Reference< ucb::XContentIdentifier > SAL_CALL
     398           0 : ResultSetBase::queryContentIdentifier(
     399             :     void
     400             : )
     401             :     throw(
     402             :         uno::RuntimeException, std::exception
     403             :     )
     404             : {
     405           0 :     if( 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()) )
     406             :     {
     407           0 :         if(!m_aIdents[m_nRow].is()) {
     408           0 :             OUString url = queryContentIdentifierString();
     409           0 :             if(!url.isEmpty() )
     410           0 :                 m_aIdents[m_nRow] =
     411             :                     uno::Reference< ucb::XContentIdentifier >(
     412           0 :                         new ::ucbhelper::ContentIdentifier(url) );
     413             :         }
     414           0 :         return m_aIdents[m_nRow];
     415             :     }
     416             : 
     417           0 :     return uno::Reference<ucb::XContentIdentifier>();
     418             : }
     419             : 
     420             : 
     421             : uno::Reference< ucb::XContent > SAL_CALL
     422           0 : ResultSetBase::queryContent(
     423             :     void )
     424             :     throw( uno::RuntimeException, std::exception )
     425             : {
     426           0 :     if( 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()) )
     427           0 :         return m_xProvider->queryContent(queryContentIdentifier());
     428             :     else
     429           0 :         return uno::Reference< ucb::XContent >();
     430             : }
     431             : 
     432             : 
     433             : 
     434           0 : class XPropertySetInfoImpl
     435             :     : public cppu::OWeakObject,
     436             :       public beans::XPropertySetInfo
     437             : {
     438             : public:
     439             : 
     440           0 :     XPropertySetInfoImpl( const uno::Sequence< beans::Property >& aSeq )
     441           0 :         : m_aSeq( aSeq )
     442             :     {
     443           0 :     }
     444             : 
     445           0 :     void SAL_CALL acquire( void )
     446             :         throw() SAL_OVERRIDE
     447             :     {
     448           0 :         OWeakObject::acquire();
     449           0 :     }
     450             : 
     451             : 
     452           0 :     void SAL_CALL release( void )
     453             :         throw() SAL_OVERRIDE
     454             :     {
     455           0 :         OWeakObject::release();
     456           0 :     }
     457             : 
     458           0 :     uno::Any SAL_CALL queryInterface( const uno::Type& rType )
     459             :         throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE
     460             :     {
     461             :         uno::Any aRet = cppu::queryInterface(
     462             :             rType,
     463           0 :             (static_cast< beans::XPropertySetInfo* >(this)) );
     464           0 :         return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
     465             :     }
     466             : 
     467           0 :     uno::Sequence< beans::Property > SAL_CALL getProperties()
     468             :         throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE
     469             :     {
     470           0 :         return m_aSeq;
     471             :     }
     472             : 
     473           0 :     beans::Property SAL_CALL getPropertyByName( const OUString& aName )
     474             :         throw( beans::UnknownPropertyException,
     475             :                uno::RuntimeException, std::exception) SAL_OVERRIDE
     476             :     {
     477           0 :         for( int i = 0; i < m_aSeq.getLength(); ++i )
     478           0 :             if( aName == m_aSeq[i].Name )
     479           0 :                 return m_aSeq[i];
     480           0 :         throw beans::UnknownPropertyException();
     481             :     }
     482             : 
     483           0 :     sal_Bool SAL_CALL hasPropertyByName( const OUString& Name )
     484             :         throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE
     485             :     {
     486           0 :         for( int i = 0; i < m_aSeq.getLength(); ++i )
     487           0 :             if( Name == m_aSeq[i].Name )
     488           0 :                 return true;
     489           0 :         return false;
     490             :     }
     491             : 
     492             : private:
     493             : 
     494             :     uno::Sequence< beans::Property > m_aSeq;
     495             : };
     496             : 
     497             : 
     498             : 
     499             : // XPropertySet
     500             : uno::Reference< beans::XPropertySetInfo > SAL_CALL
     501           0 : ResultSetBase::getPropertySetInfo()
     502             :     throw( uno::RuntimeException, std::exception)
     503             : {
     504           0 :     uno::Sequence< beans::Property > seq(2);
     505           0 :     seq[0].Name = "RowCount";
     506           0 :     seq[0].Handle = -1;
     507           0 :     seq[0].Type = cppu::UnoType<sal_Int32>::get();
     508           0 :     seq[0].Attributes = beans::PropertyAttribute::READONLY;
     509             : 
     510           0 :     seq[1].Name = "IsRowCountFinal";
     511           0 :     seq[1].Handle = -1;
     512           0 :     seq[1].Type = cppu::UnoType<sal_Bool>::get();
     513           0 :     seq[1].Attributes = beans::PropertyAttribute::READONLY;
     514             : 
     515             :     //t
     516             :     return uno::Reference< beans::XPropertySetInfo > (
     517           0 :         new XPropertySetInfoImpl( seq ) );
     518             : }
     519             : 
     520             : 
     521             : 
     522           0 : void SAL_CALL ResultSetBase::setPropertyValue(
     523             :     const OUString& aPropertyName, const uno::Any& /*aValue*/ )
     524             :     throw( beans::UnknownPropertyException,
     525             :            beans::PropertyVetoException,
     526             :            lang::IllegalArgumentException,
     527             :            lang::WrappedTargetException,
     528             :            uno::RuntimeException, std::exception)
     529             : {
     530           0 :     if( aPropertyName == "IsRowCountFinal" ||
     531           0 :         aPropertyName == "RowCount" )
     532           0 :         return;
     533             : 
     534           0 :     throw beans::UnknownPropertyException();
     535             : }
     536             : 
     537             : 
     538           0 : uno::Any SAL_CALL ResultSetBase::getPropertyValue(
     539             :     const OUString& PropertyName )
     540             :     throw( beans::UnknownPropertyException,
     541             :            lang::WrappedTargetException,
     542             :            uno::RuntimeException, std::exception)
     543             : {
     544           0 :     if( PropertyName == "IsRowCountFinal" )
     545             :     {
     546           0 :         uno::Any aAny;
     547           0 :         aAny <<= m_bRowCountFinal;
     548           0 :         return aAny;
     549             :     }
     550           0 :     else if ( PropertyName == "RowCount" )
     551             :     {
     552           0 :         uno::Any aAny;
     553           0 :         sal_Int32 count = m_aItems.size();
     554           0 :         aAny <<= count;
     555           0 :         return aAny;
     556             :     }
     557             :     else
     558           0 :         throw beans::UnknownPropertyException();
     559             : }
     560             : 
     561             : 
     562           0 : void SAL_CALL ResultSetBase::addPropertyChangeListener(
     563             :     const OUString& aPropertyName,
     564             :     const uno::Reference< beans::XPropertyChangeListener >& xListener )
     565             :     throw( beans::UnknownPropertyException,
     566             :            lang::WrappedTargetException,
     567             :            uno::RuntimeException, std::exception)
     568             : {
     569           0 :     if( aPropertyName == "IsRowCountFinal" )
     570             :     {
     571           0 :         osl::MutexGuard aGuard( m_aMutex );
     572           0 :         if ( ! m_pIsFinalListeners )
     573             :             m_pIsFinalListeners =
     574           0 :                 new cppu::OInterfaceContainerHelper( m_aMutex );
     575             : 
     576           0 :         m_pIsFinalListeners->addInterface( xListener );
     577             :     }
     578           0 :     else if ( aPropertyName == "RowCount" )
     579             :     {
     580           0 :         osl::MutexGuard aGuard( m_aMutex );
     581           0 :         if ( ! m_pRowCountListeners )
     582             :             m_pRowCountListeners =
     583           0 :                 new cppu::OInterfaceContainerHelper( m_aMutex );
     584           0 :         m_pRowCountListeners->addInterface( xListener );
     585             :     }
     586             :     else
     587           0 :         throw beans::UnknownPropertyException();
     588           0 : }
     589             : 
     590             : 
     591           0 : void SAL_CALL ResultSetBase::removePropertyChangeListener(
     592             :     const OUString& aPropertyName,
     593             :     const uno::Reference< beans::XPropertyChangeListener >& aListener )
     594             :     throw( beans::UnknownPropertyException,
     595             :            lang::WrappedTargetException,
     596             :            uno::RuntimeException, std::exception)
     597             : {
     598           0 :     if( aPropertyName == "IsRowCountFinal" &&
     599             :         m_pIsFinalListeners )
     600             :     {
     601           0 :         osl::MutexGuard aGuard( m_aMutex );
     602           0 :         m_pIsFinalListeners->removeInterface( aListener );
     603             :     }
     604           0 :     else if ( aPropertyName == "RowCount" &&
     605             :               m_pRowCountListeners )
     606             :     {
     607           0 :         osl::MutexGuard aGuard( m_aMutex );
     608           0 :         m_pRowCountListeners->removeInterface( aListener );
     609             :     }
     610             :     else
     611           0 :         throw beans::UnknownPropertyException();
     612           0 : }
     613             : 
     614             : 
     615           0 : void SAL_CALL ResultSetBase::addVetoableChangeListener(
     616             :     const OUString& /*PropertyName*/,
     617             :     const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
     618             :     throw( beans::UnknownPropertyException,
     619             :            lang::WrappedTargetException,
     620             :            uno::RuntimeException, std::exception)
     621             : {
     622           0 : }
     623             : 
     624             : 
     625           0 : void SAL_CALL ResultSetBase::removeVetoableChangeListener(
     626             :     const OUString& /*PropertyName*/,
     627             :     const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
     628             :     throw( beans::UnknownPropertyException,
     629             :            lang::WrappedTargetException,
     630             :            uno::RuntimeException, std::exception)
     631             : {
     632           0 : }
     633             : 
     634             : 
     635             : 
     636             : // XResultSetMetaDataSupplier
     637             : uno::Reference< sdbc::XResultSetMetaData > SAL_CALL
     638           0 : ResultSetBase::getMetaData(
     639             :     void )
     640             :     throw( sdbc::SQLException,
     641             :            uno::RuntimeException, std::exception )
     642             : {
     643             :     ::ucbhelper::ResultSetMetaData* p =
     644           0 :           new ::ucbhelper::ResultSetMetaData( m_xContext, m_sProperty );
     645           0 :     return uno::Reference< sdbc::XResultSetMetaData >( p );
     646             : }
     647             : 
     648             : 
     649             : 
     650             : 
     651             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10