connectivity/source/commontools/paramwrapper.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 #include <connectivity/paramwrapper.hxx>
  20
  21 #include <com/sun/star/beans/PropertyAttribute.hpp>
  22 #include <com/sun/star/sdbc/DataType.hpp>
  23 #include <com/sun/star/lang/WrappedTargetException.hpp>
  24 #include <com/sun/star/sdb/XParametersSupplier.hpp>
  25 #include <com/sun/star/lang/DisposedException.hpp>
  26
  27 #include <tools/diagnose_ex.h>
  28 #include <comphelper/enumhelper.hxx>
  29
  30 #define PROPERTY_ID_VALUE   1000
  31
  32
  33 namespace dbtools
  34 {
  35 namespace param
  36 {
  37
  38
  39     using ::com::sun::star::uno::Reference;
  40     using ::com::sun::star::sdbc::XParameters;
  41     using ::com::sun::star::uno::Sequence;
  42     using ::com::sun::star::uno::Type;
  43     using ::com::sun::star::uno::RuntimeException;
  44     using ::com::sun::star::uno::XWeak;
  45     using ::com::sun::star::beans::XPropertySet;
  46     using ::com::sun::star::beans::XFastPropertySet;
  47     using ::com::sun::star::beans::XMultiPropertySet;
  48     using ::com::sun::star::beans::XPropertySetInfo;
  49     using ::com::sun::star::beans::Property;
  50     using ::com::sun::star::uno::Exception;
  51     using ::com::sun::star::uno::UNO_QUERY_THROW;
  52     using ::com::sun::star::uno::Any;
  53     using ::com::sun::star::lang::IllegalArgumentException;
  54     using ::com::sun::star::sdbc::SQLException;
  55     using ::com::sun::star::lang::WrappedTargetException;
  56     using ::com::sun::star::lang::IndexOutOfBoundsException;
  57     using ::com::sun::star::container::XEnumeration;
  58     using ::com::sun::star::sdb::XSingleSelectQueryAnalyzer;
  59     using ::com::sun::star::sdb::XParametersSupplier;
  60     using ::com::sun::star::lang::DisposedException;
  61
  62     namespace PropertyAttribute = ::com::sun::star::beans::PropertyAttribute;
  63     namespace DataType = ::com::sun::star::sdbc::DataType;
  64
  65
  66     //= ParameterWrapper
  67
  68
  69     ParameterWrapper::ParameterWrapper( const Reference< XPropertySet >& _rxColumn )
  70         :PropertyBase( m_aBHelper )
  71         ,m_xDelegator( _rxColumn )
  72     {
  73         if ( m_xDelegator.is() )
  74             m_xDelegatorPSI = m_xDelegator->getPropertySetInfo();
  75         if ( !m_xDelegatorPSI.is() )
  76             throw RuntimeException();
  77     }
  78
  79
  80     ParameterWrapper::ParameterWrapper( const Reference< XPropertySet >& _rxColumn,
  81             const Reference< XParameters >& _rxAllParameters, const ::std::vector< sal_Int32 >& _rIndexes )
  82         :PropertyBase( m_aBHelper )
  83         ,m_aIndexes( _rIndexes )
  84         ,m_xDelegator( _rxColumn )
  85         ,m_xValueDestination( _rxAllParameters )
  86     {
  87         if ( m_xDelegator.is() )
  88             m_xDelegatorPSI = m_xDelegator->getPropertySetInfo();
  89         if ( !m_xDelegatorPSI.is() )
  90             throw RuntimeException();
  91
  92         OSL_ENSURE( !m_aIndexes.empty(), "ParameterWrapper::ParameterWrapper: sure about the indexes?" );
  93     }
  94
  95
  96     ParameterWrapper::~ParameterWrapper()
  97     {
  98     }
  99
 100
 101     IMPLEMENT_FORWARD_REFCOUNT( ParameterWrapper, UnoBase )
 102
 103     css::uno::Any ParameterWrapper::queryInterface(css::uno::Type const & aType)
 104         throw (css::uno::RuntimeException, std::exception)
 105     {
 106         css::uno::Any a(UnoBase::queryInterface(aType));
 107         if (!a.hasValue()) {
 108             a = PropertyBase::queryInterface(aType);
 109             if (!a.hasValue()
 110                 && aType == cppu::UnoType<css::lang::XTypeProvider>::get())
 111             {
 112                 a <<= css::uno::Reference<css::lang::XTypeProvider>(this);
 113             }
 114         }
 115         return a;
 116     }
 117
 118
 119     Sequence< Type > SAL_CALL ParameterWrapper::getTypes(   ) throw(RuntimeException, std::exception)
 120     {
 121         Sequence< Type > aTypes( 5 );
 122         aTypes[ 0 ] = ::getCppuType( static_cast< Reference< XWeak >*             >( NULL ) );
 123         aTypes[ 1 ] = ::getCppuType( static_cast< Reference< XTypeProvider >* >( NULL ) );
 124         aTypes[ 2 ] = ::getCppuType( static_cast< Reference< XPropertySet >*      >( NULL ) );
 125         aTypes[ 3 ] = ::getCppuType( static_cast< Reference< XFastPropertySet >*  >( NULL ) );
 126         aTypes[ 4 ] = ::getCppuType( static_cast< Reference< XMultiPropertySet >* >( NULL ) );
 127         return aTypes;
 128     }
 129
 130
 131     IMPLEMENT_GET_IMPLEMENTATION_ID( ParameterWrapper )
 132
 133
 134     OUString ParameterWrapper::impl_getPseudoAggregatePropertyName( sal_Int32 _nHandle ) const
 135     {
 136         Reference< XPropertySetInfo >  xInfo = const_cast<ParameterWrapper*>( this )->getPropertySetInfo();
 137         Sequence< Property > aProperties = xInfo->getProperties();
 138         const Property* pProperties = aProperties.getConstArray();
 139         for ( sal_Int32 i = 0; i < aProperties.getLength(); ++i, ++pProperties )
 140         {
 141             if ( pProperties->Handle == _nHandle )
 142                 return pProperties->Name;
 143         }
 144
 145         OSL_FAIL( "ParameterWrapper::impl_getPseudoAggregatePropertyName: invalid argument!" );
 146         return OUString();
 147     }
 148
 149
 150     Reference< XPropertySetInfo > ParameterWrapper::getPropertySetInfo() throw( RuntimeException, std::exception )
 151     {
 152         return createPropertySetInfo( getInfoHelper() );
 153     }
 154
 155
 156     ::cppu::IPropertyArrayHelper& ParameterWrapper::getInfoHelper()
 157     {
 158         if ( !m_pInfoHelper.get() )
 159         {
 160             Sequence< Property > aProperties;
 161             try
 162             {
 163                 aProperties = m_xDelegatorPSI->getProperties();
 164                 sal_Int32 nProperties( aProperties.getLength() );
 165                 aProperties.realloc( nProperties + 1 );
 166                 aProperties[ nProperties ] = Property(
 167                     OUString( "Value" ),
 168                     PROPERTY_ID_VALUE,
 169                     ::cppu::UnoType< Any >::get(),
 170                     PropertyAttribute::TRANSIENT | PropertyAttribute::MAYBEVOID
 171                 );
 172             }
 173             catch( const Exception& )
 174             {
 175                 DBG_UNHANDLED_EXCEPTION();
 176             }
 177
 178             m_pInfoHelper.reset( new ::cppu::OPropertyArrayHelper( aProperties, false ) );
 179         }
 180         return *m_pInfoHelper;
 181     }
 182
 183
 184     sal_Bool ParameterWrapper::convertFastPropertyValue(Any& rConvertedValue, Any& rOldValue, sal_Int32 nHandle, const Any& rValue) throw( IllegalArgumentException )
 185     {
 186         OSL_ENSURE( PROPERTY_ID_VALUE == nHandle, "ParameterWrapper::convertFastPropertyValue: the only non-readonly prop should be our PROPERTY_VALUE!" );
 187         (void)nHandle;
 188
 189         // we're lazy here ...
 190         rOldValue = m_aValue.makeAny();
 191         rConvertedValue = rValue;
 192         return sal_True;    // assume "modified" ...
 193     }
 194
 195
 196     void ParameterWrapper::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const Any& rValue ) throw( Exception, std::exception )
 197     {
 198         if ( nHandle == PROPERTY_ID_VALUE )
 199         {
 200             try
 201             {
 202                 // TODO : aParamType & nScale can be obtained within the constructor ....
 203                 sal_Int32 nParamType = DataType::VARCHAR;
 204                 OSL_VERIFY( m_xDelegator->getPropertyValue("Type") >>= nParamType );
 205
 206                 sal_Int32 nScale = 0;
 207                 if ( m_xDelegatorPSI->hasPropertyByName("Scale") )
 208                     OSL_VERIFY( m_xDelegator->getPropertyValue("Scale") >>= nScale );
 209
 210                 if ( m_xValueDestination.is() )
 211                 {
 212                     for ( ::std::vector< sal_Int32 >::iterator aIter = m_aIndexes.begin(); aIter != m_aIndexes.end(); ++aIter )
 213                     {
 214                         m_xValueDestination->setObjectWithInfo( *aIter + 1, rValue, nParamType, nScale );
 215                             // (the index of the parameters is one-based)
 216                     }
 217                 }
 218
 219                 m_aValue = rValue;
 220             }
 221             catch( SQLException& e )
 222             {
 223                 WrappedTargetException aExceptionWrapper;
 224                 aExceptionWrapper.Context = e.Context;
 225                 aExceptionWrapper.Message = e.Message;
 226                 aExceptionWrapper.TargetException <<= e;
 227                 throw WrappedTargetException( aExceptionWrapper );
 228             }
 229         }
 230         else
 231         {
 232             OUString aName = impl_getPseudoAggregatePropertyName( nHandle );
 233             m_xDelegator->setPropertyValue( aName, rValue );
 234         }
 235     }
 236
 237
 238     void ParameterWrapper::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
 239     {
 240         if ( nHandle == PROPERTY_ID_VALUE )
 241         {
 242             rValue = m_aValue.makeAny();
 243         }
 244         else
 245         {
 246             OUString aName = impl_getPseudoAggregatePropertyName( nHandle );
 247             rValue = m_xDelegator->getPropertyValue( aName );
 248         }
 249     }
 250
 251
 252     void SAL_CALL ParameterWrapper::dispose()
 253     {
 254         ::osl::MutexGuard aGuard( m_aMutex );
 255
 256         m_aValue.setNull();
 257         m_aIndexes.resize(0);
 258         m_xDelegator.clear();
 259         m_xDelegatorPSI.clear();
 260         m_xValueDestination.clear();
 261
 262         m_aBHelper.bDisposed = sal_True;
 263     }
 264
 265
 266     //= ParameterWrapperContainer
 267
 268
 269     ParameterWrapperContainer::ParameterWrapperContainer()
 270         :ParameterWrapperContainer_Base( m_aMutex )
 271     {
 272     }
 273
 274
 275     ParameterWrapperContainer::ParameterWrapperContainer( const Reference< XSingleSelectQueryAnalyzer >& _rxComposer )
 276         :ParameterWrapperContainer_Base( m_aMutex )
 277     {
 278         Reference< XParametersSupplier > xSuppParams( _rxComposer, UNO_QUERY_THROW );
 279         Reference< XIndexAccess > xParameters( xSuppParams->getParameters(), UNO_QUERY_THROW );
 280         sal_Int32 nParamCount( xParameters->getCount() );
 281         m_aParameters.reserve( nParamCount );
 282         for ( sal_Int32 i=0; i<nParamCount; ++i )
 283         {
 284             m_aParameters.push_back( new ParameterWrapper( Reference< XPropertySet >( xParameters->getByIndex( i ), UNO_QUERY_THROW ) ) );
 285         }
 286     }
 287
 288
 289     ParameterWrapperContainer::~ParameterWrapperContainer()
 290     {
 291     }
 292
 293
 294     Type SAL_CALL ParameterWrapperContainer::getElementType() throw( RuntimeException, std::exception )
 295     {
 296         ::osl::MutexGuard aGuard( m_aMutex );
 297         impl_checkDisposed_throw();
 298         return ::getCppuType( static_cast< Reference< XPropertySet >* >( NULL ) );
 299     }
 300
 301
 302     sal_Bool SAL_CALL ParameterWrapperContainer::hasElements() throw( RuntimeException, std::exception )
 303     {
 304         ::osl::MutexGuard aGuard( m_aMutex );
 305         impl_checkDisposed_throw();
 306         return !m_aParameters.empty();
 307     }
 308
 309
 310     sal_Int32 SAL_CALL ParameterWrapperContainer::getCount() throw( RuntimeException, std::exception )
 311     {
 312         ::osl::MutexGuard aGuard( m_aMutex );
 313         impl_checkDisposed_throw();
 314         return m_aParameters.size();
 315     }
 316
 317
 318     Any SAL_CALL ParameterWrapperContainer::getByIndex( sal_Int32 _nIndex ) throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException, std::exception )
 319     {
 320         ::osl::MutexGuard aGuard( m_aMutex );
 321         impl_checkDisposed_throw();
 322
 323         if ( ( _nIndex < 0 ) || ( _nIndex >= (sal_Int32)m_aParameters.size() ) )
 324             throw IndexOutOfBoundsException();
 325
 326         return makeAny( Reference< XPropertySet >( m_aParameters[ _nIndex ].get() ) );
 327     }
 328
 329
 330     Reference< XEnumeration > ParameterWrapperContainer::createEnumeration() throw( RuntimeException, std::exception )
 331     {
 332         ::osl::MutexGuard aGuard( m_aMutex );
 333         impl_checkDisposed_throw();
 334
 335         return new ::comphelper::OEnumerationByIndex( static_cast< XIndexAccess* >( this ) );
 336     }
 337
 338
 339     void ParameterWrapperContainer::impl_checkDisposed_throw()
 340     {
 341         if ( rBHelper.bDisposed )
 342             throw DisposedException( OUString(), *this );
 343     }
 344
 345
 346     void SAL_CALL ParameterWrapperContainer::disposing()
 347     {
 348         ::osl::MutexGuard aGuard( m_aMutex );
 349         impl_checkDisposed_throw();
 350
 351         for (   Parameters::const_iterator param = m_aParameters.begin();
 352                 param != m_aParameters.end();
 353                 ++param
 354             )
 355         {
 356             (*param)->dispose();
 357         }
 358
 359         Parameters aEmpty;
 360         m_aParameters.swap( aEmpty );
 361     }
 362
 363
 364 } } // namespace dbtools::param
 365
 366
 367 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */