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