LCOV - code coverage report
Current view: top level - ucbhelper/source/provider - propertyvalueset.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 63 189 33.3 %
Date: 2014-11-03 Functions: 19 43 44.2 %
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             : 
      21             : /**************************************************************************
      22             :                                 TODO
      23             :  **************************************************************************
      24             : 
      25             :  *************************************************************************/
      26             : 
      27             : #include <vector>
      28             : #include <com/sun/star/beans/Property.hpp>
      29             : #include <com/sun/star/beans/XPropertyAccess.hpp>
      30             : #include <com/sun/star/beans/XPropertySet.hpp>
      31             : #include <com/sun/star/beans/XPropertySetInfo.hpp>
      32             : #include <com/sun/star/script/Converter.hpp>
      33             : 
      34             : #include "osl/diagnose.h"
      35             : #include "osl/mutex.hxx"
      36             : #include <ucbhelper/propertyvalueset.hxx>
      37             : 
      38             : using namespace com::sun::star::beans;
      39             : using namespace com::sun::star::container;
      40             : using namespace com::sun::star::io;
      41             : using namespace com::sun::star::lang;
      42             : using namespace com::sun::star::script;
      43             : using namespace com::sun::star::sdbc;
      44             : using namespace com::sun::star::uno;
      45             : using namespace com::sun::star::util;
      46             : 
      47             : namespace ucbhelper_impl
      48             : {
      49             : 
      50             : 
      51             : 
      52             : // PropertyValue.
      53             : 
      54             : 
      55             : 
      56             : const sal_uInt32 NO_VALUE_SET               = 0x00000000;
      57             : const sal_uInt32 STRING_VALUE_SET           = 0x00000001;
      58             : const sal_uInt32 BOOLEAN_VALUE_SET          = 0x00000002;
      59             : const sal_uInt32 BYTE_VALUE_SET             = 0x00000004;
      60             : const sal_uInt32 SHORT_VALUE_SET            = 0x00000008;
      61             : const sal_uInt32 INT_VALUE_SET              = 0x00000010;
      62             : const sal_uInt32 LONG_VALUE_SET             = 0x00000020;
      63             : const sal_uInt32 FLOAT_VALUE_SET            = 0x00000040;
      64             : const sal_uInt32 DOUBLE_VALUE_SET           = 0x00000080;
      65             : const sal_uInt32 BYTES_VALUE_SET            = 0x00000100;
      66             : const sal_uInt32 DATE_VALUE_SET             = 0x00000200;
      67             : const sal_uInt32 TIME_VALUE_SET             = 0x00000400;
      68             : const sal_uInt32 TIMESTAMP_VALUE_SET        = 0x00000800;
      69             : const sal_uInt32 BINARYSTREAM_VALUE_SET     = 0x00001000;
      70             : const sal_uInt32 CHARACTERSTREAM_VALUE_SET  = 0x00002000;
      71             : const sal_uInt32 REF_VALUE_SET              = 0x00004000;
      72             : const sal_uInt32 BLOB_VALUE_SET             = 0x00008000;
      73             : const sal_uInt32 CLOB_VALUE_SET             = 0x00010000;
      74             : const sal_uInt32 ARRAY_VALUE_SET            = 0x00020000;
      75             : const sal_uInt32 OBJECT_VALUE_SET           = 0x00040000;
      76             : 
      77       17888 : struct PropertyValue
      78             : {
      79             :     OUString
      80             :                 sPropertyName;
      81             : 
      82             :     sal_uInt32  nPropsSet;
      83             :     sal_uInt32  nOrigValue;
      84             : 
      85             :     OUString    aString;    // getString
      86             :     bool    bBoolean;   // getBoolean
      87             :     sal_Int8    nByte;      // getByte
      88             :     sal_Int16   nShort;     // getShort
      89             :     sal_Int32   nInt;       // getInt
      90             :     sal_Int64   nLong;      // getLong
      91             :     float       nFloat;     // getFloat
      92             :     double      nDouble;    // getDouble
      93             : 
      94             :     Sequence< sal_Int8 >        aBytes;             // getBytes
      95             :     Date                        aDate;              // getDate
      96             :     Time                        aTime;              // getTime
      97             :     DateTime                    aTimestamp;         // getTimestamp
      98             :     Reference< XInputStream >   xBinaryStream;      // getBinaryStream
      99             :     Reference< XInputStream >   xCharacterStream;   // getCharacterStream
     100             :     Reference< XRef >           xRef;               // getRef
     101             :     Reference< XBlob >          xBlob;              // getBlob
     102             :     Reference< XClob >          xClob;              // getClob
     103             :     Reference< XArray >         xArray;             // getArray
     104             :     Any                         aObject;            // getObject
     105             : 
     106        5752 :     inline PropertyValue()
     107             :         : nPropsSet( NO_VALUE_SET ), nOrigValue( NO_VALUE_SET ),
     108             :           bBoolean(false),
     109             :           nByte(0),
     110             :           nShort(0),
     111             :           nInt(0),
     112             :           nLong(0),
     113             :           nFloat(0.0),
     114        5752 :           nDouble(0.0)
     115        5752 :         {}
     116             : };
     117             : } // namespace ucbhelper_impl
     118             : 
     119             : using namespace ucbhelper_impl;
     120             : 
     121             : namespace ucbhelper
     122             : {
     123             : 
     124             : 
     125             : 
     126             : // class PropertyValues.
     127             : 
     128             : 
     129             : 
     130             : typedef std::vector< ucbhelper_impl::PropertyValue > PropertyValuesVector;
     131             : 
     132       11096 : class PropertyValues : public PropertyValuesVector {};
     133             : 
     134             : } // namespace ucbhelper
     135             : 
     136             : 
     137             : 
     138             : // Welcome to the macro hell...
     139             : 
     140             : 
     141             : 
     142             : #define GETVALUE_IMPL_TYPE( _type_, _type_name_, _member_name_, _cppu_type_ ) \
     143             :                                                                               \
     144             :     osl::MutexGuard aGuard( m_aMutex );                                       \
     145             :                                                                               \
     146             :     _type_ aValue = _type_();   /* default ctor */                            \
     147             :                                                                               \
     148             :     m_bWasNull = true;                                                    \
     149             :                                                                               \
     150             :     if ( ( columnIndex < 1 )                                                  \
     151             :          || ( columnIndex > sal_Int32( m_pValues->size() ) ) )                \
     152             :     {                                                                         \
     153             :         OSL_FAIL( "PropertyValueSet - index out of range!" );    \
     154             :     }                                                                         \
     155             :     else                                                                      \
     156             :     {                                                                         \
     157             :         ucbhelper_impl::PropertyValue& rValue                                 \
     158             :             = (*m_pValues)[ columnIndex - 1 ];                                \
     159             :                                                                               \
     160             :         if ( rValue.nOrigValue != NO_VALUE_SET )                              \
     161             :         {                                                                     \
     162             :             if ( rValue.nPropsSet & _type_name_ )                             \
     163             :             {                                                                 \
     164             :                 /* Values is present natively... */                           \
     165             :                 aValue = rValue._member_name_;                                \
     166             :                 m_bWasNull = false;                                       \
     167             :             }                                                                 \
     168             :             else                                                              \
     169             :             {                                                                 \
     170             :                 if ( !(rValue.nPropsSet & OBJECT_VALUE_SET) )                 \
     171             :                 {                                                             \
     172             :                     /* Value is not (yet) available as Any. Create it. */     \
     173             :                     getObject( columnIndex, Reference< XNameAccess >() );     \
     174             :                 }                                                             \
     175             :                                                                               \
     176             :                 if ( rValue.nPropsSet & OBJECT_VALUE_SET )                    \
     177             :                 {                                                             \
     178             :                     /* Value is available as Any. */                          \
     179             :                                                                               \
     180             :                     if ( rValue.aObject.hasValue() )                          \
     181             :                     {                                                         \
     182             :                         /* Try to convert into native value. */               \
     183             :                         if ( rValue.aObject >>= aValue )                      \
     184             :                         {                                                     \
     185             :                             rValue._member_name_ = aValue;                    \
     186             :                             rValue.nPropsSet |= _type_name_;                  \
     187             :                             m_bWasNull = false;                           \
     188             :                         }                                                     \
     189             :                         else                                                  \
     190             :                         {                                                     \
     191             :                             /* Last chance. Try type converter service... */  \
     192             :                                                                               \
     193             :                             Reference< XTypeConverter > xConverter            \
     194             :                                                     = getTypeConverter();     \
     195             :                             if ( xConverter.is() )                            \
     196             :                             {                                                 \
     197             :                                 try                                           \
     198             :                                 {                                             \
     199             :                                     Any aConvAny = xConverter->convertTo(     \
     200             :                                                              rValue.aObject,      \
     201             :                                                             _cppu_type_ );    \
     202             :                                                                               \
     203             :                                     if ( aConvAny >>= aValue )                \
     204             :                                     {                                         \
     205             :                                         rValue._member_name_ = aValue;        \
     206             :                                         rValue.nPropsSet |= _type_name_;      \
     207             :                                         m_bWasNull = false;               \
     208             :                                     }                                         \
     209             :                                 }                                             \
     210             :                                 catch (const IllegalArgumentException&)       \
     211             :                                 {                                             \
     212             :                                 }                                             \
     213             :                                 catch (const CannotConvertException&)         \
     214             :                                 {                                             \
     215             :                                 }                                             \
     216             :                             }                                                 \
     217             :                         }                                                     \
     218             :                     }                                                         \
     219             :                 }                                                             \
     220             :             }                                                                 \
     221             :         }                                                                     \
     222             :     }                                                                         \
     223             :     return aValue;
     224             : 
     225             : #define GETVALUE_IMPL( _type_, _type_name_, _member_name_ )                   \
     226             :     GETVALUE_IMPL_TYPE( _type_,                                               \
     227             :                         _type_name_,                                          \
     228             :                         _member_name_,                                        \
     229             :                         getCppuType( static_cast< const _type_ * >( 0 ) ) )
     230             : 
     231             : #define SETVALUE_IMPL( _prop_name_, _type_name_, _member_name_, _value_ )     \
     232             :                                                                               \
     233             :     osl::MutexGuard aGuard( m_aMutex );                                       \
     234             :                                                                               \
     235             :     ucbhelper_impl::PropertyValue aNewValue;                                  \
     236             :     aNewValue.sPropertyName = _prop_name_;                                    \
     237             :     aNewValue.nPropsSet     = _type_name_;                                    \
     238             :     aNewValue.nOrigValue    = _type_name_;                                    \
     239             :     aNewValue._member_name_ = _value_;                                        \
     240             :                                                                               \
     241             :     m_pValues->push_back( aNewValue );
     242             : 
     243             : namespace ucbhelper {
     244             : 
     245             : 
     246             : 
     247             : 
     248             : // PropertyValueSet Implementation.
     249             : 
     250             : 
     251             : 
     252             : 
     253             : 
     254        5548 : PropertyValueSet::PropertyValueSet(
     255             :                     const Reference< XComponentContext >& rxContext )
     256             : :  m_xContext( rxContext ),
     257        5548 :   m_pValues( new PropertyValues ),
     258             :   m_bWasNull( false ),
     259       11096 :   m_bTriedToGetTypeConverter( false )
     260             : 
     261             : {
     262        5548 : }
     263             : 
     264             : 
     265             : // virtual
     266       16644 : PropertyValueSet::~PropertyValueSet()
     267             : {
     268        5548 :     delete m_pValues;
     269       11096 : }
     270             : 
     271             : 
     272             : 
     273             : // XInterface methods.
     274       22504 : void SAL_CALL PropertyValueSet::acquire()
     275             :     throw()
     276             : {
     277       22504 :     OWeakObject::acquire();
     278       22504 : }
     279             : 
     280       22504 : void SAL_CALL PropertyValueSet::release()
     281             :     throw()
     282             : {
     283       22504 :     OWeakObject::release();
     284       22504 : }
     285             : 
     286           0 : css::uno::Any SAL_CALL PropertyValueSet::queryInterface( const css::uno::Type & rType )
     287             :     throw( css::uno::RuntimeException, std::exception )
     288             : {
     289             :     css::uno::Any aRet = cppu::queryInterface( rType,
     290             :                                                (static_cast< XTypeProvider* >(this)),
     291             :                                                (static_cast< XRow* >(this)),
     292             :                                                (static_cast< XColumnLocate* >(this))
     293           0 :                                                );
     294           0 :     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
     295             : }
     296             : 
     297             : // XTypeProvider methods.
     298             : 
     299             : 
     300             : 
     301           0 : XTYPEPROVIDER_IMPL_3( PropertyValueSet,
     302             :                       XTypeProvider,
     303             :                          XRow,
     304             :                       XColumnLocate );
     305             : 
     306             : 
     307             : 
     308             : // XRow methods.
     309             : 
     310             : 
     311             : 
     312             : // virtual
     313          20 : sal_Bool SAL_CALL PropertyValueSet::wasNull()
     314             :     throw( SQLException, RuntimeException, std::exception )
     315             : {
     316             :     // This method can not be implemented correctly!!! Imagine different
     317             :     // threads doing a getXYZ - wasNull calling sequence on the same
     318             :     // implementation object...
     319          20 :     return m_bWasNull;
     320             : }
     321             : 
     322             : 
     323             : // virtual
     324          64 : OUString SAL_CALL PropertyValueSet::getString( sal_Int32 columnIndex )
     325             :     throw( SQLException, RuntimeException, std::exception )
     326             : {
     327          64 :     GETVALUE_IMPL( OUString, STRING_VALUE_SET, aString );
     328             : }
     329             : 
     330             : 
     331             : // virtual
     332          40 : sal_Bool SAL_CALL PropertyValueSet::getBoolean( sal_Int32 columnIndex )
     333             :     throw( SQLException, RuntimeException, std::exception )
     334             : {
     335          80 :     GETVALUE_IMPL_TYPE(
     336          40 :             bool, BOOLEAN_VALUE_SET, bBoolean, getCppuBooleanType() );
     337             : }
     338             : 
     339             : 
     340             : // virtual
     341           0 : sal_Int8 SAL_CALL PropertyValueSet::getByte( sal_Int32 columnIndex )
     342             :     throw( SQLException, RuntimeException, std::exception )
     343             : {
     344           0 :     GETVALUE_IMPL( sal_Int8, BYTE_VALUE_SET, nByte );
     345             : }
     346             : 
     347             : 
     348             : // virtual
     349           0 : sal_Int16 SAL_CALL PropertyValueSet::getShort( sal_Int32 columnIndex )
     350             :     throw( SQLException, RuntimeException, std::exception )
     351             : {
     352           0 :     GETVALUE_IMPL( sal_Int16, SHORT_VALUE_SET, nShort );
     353             : }
     354             : 
     355             : 
     356             : // virtual
     357           0 : sal_Int32 SAL_CALL PropertyValueSet::getInt( sal_Int32 columnIndex )
     358             :     throw( SQLException, RuntimeException, std::exception )
     359             : {
     360           0 :     GETVALUE_IMPL( sal_Int32, INT_VALUE_SET, nInt );
     361             : }
     362             : 
     363             : 
     364             : // virtual
     365           0 : sal_Int64 SAL_CALL PropertyValueSet::getLong( sal_Int32 columnIndex )
     366             :     throw( SQLException, RuntimeException, std::exception )
     367             : {
     368           0 :     GETVALUE_IMPL( sal_Int64, LONG_VALUE_SET, nLong );
     369             : }
     370             : 
     371             : 
     372             : // virtual
     373           0 : float SAL_CALL PropertyValueSet::getFloat( sal_Int32 columnIndex )
     374             :     throw( SQLException, RuntimeException, std::exception )
     375             : {
     376           0 :     GETVALUE_IMPL( float, FLOAT_VALUE_SET, nFloat );
     377             : }
     378             : 
     379             : 
     380             : // virtual
     381           0 : double SAL_CALL PropertyValueSet::getDouble( sal_Int32 columnIndex )
     382             :     throw( SQLException, RuntimeException, std::exception )
     383             : {
     384           0 :     GETVALUE_IMPL( double, DOUBLE_VALUE_SET, nDouble );
     385             : }
     386             : 
     387             : 
     388             : // virtual
     389             : Sequence< sal_Int8 > SAL_CALL
     390           0 : PropertyValueSet::getBytes( sal_Int32 columnIndex )
     391             :     throw( SQLException, RuntimeException, std::exception )
     392             : {
     393           0 :     GETVALUE_IMPL( Sequence< sal_Int8 >, BYTES_VALUE_SET, aBytes );
     394             : }
     395             : 
     396             : 
     397             : // virtual
     398           0 : Date SAL_CALL PropertyValueSet::getDate( sal_Int32 columnIndex )
     399             :     throw( SQLException, RuntimeException, std::exception )
     400             : {
     401           0 :     GETVALUE_IMPL( Date, DATE_VALUE_SET, aDate );
     402             : }
     403             : 
     404             : 
     405             : // virtual
     406           0 : Time SAL_CALL PropertyValueSet::getTime( sal_Int32 columnIndex )
     407             :     throw( SQLException, RuntimeException, std::exception )
     408             : {
     409           0 :     GETVALUE_IMPL( Time, TIME_VALUE_SET, aTime );
     410             : }
     411             : 
     412             : 
     413             : // virtual
     414           0 : DateTime SAL_CALL PropertyValueSet::getTimestamp( sal_Int32 columnIndex )
     415             :     throw( SQLException, RuntimeException, std::exception )
     416             : {
     417           0 :     GETVALUE_IMPL( DateTime, TIMESTAMP_VALUE_SET, aTimestamp );
     418             : }
     419             : 
     420             : 
     421             : // virtual
     422             : Reference< XInputStream > SAL_CALL
     423           0 : PropertyValueSet::getBinaryStream( sal_Int32 columnIndex )
     424             :     throw( SQLException, RuntimeException, std::exception )
     425             : {
     426           0 :     GETVALUE_IMPL(
     427           0 :         Reference< XInputStream >, BINARYSTREAM_VALUE_SET, xBinaryStream );
     428             : }
     429             : 
     430             : 
     431             : // virtual
     432             : Reference< XInputStream > SAL_CALL
     433           0 : PropertyValueSet::getCharacterStream( sal_Int32 columnIndex )
     434             :     throw( SQLException, RuntimeException, std::exception )
     435             : {
     436           0 :     GETVALUE_IMPL(
     437           0 :         Reference< XInputStream >, CHARACTERSTREAM_VALUE_SET, xCharacterStream );
     438             : }
     439             : 
     440             : 
     441             : // virtual
     442        5728 : Any SAL_CALL PropertyValueSet::getObject(
     443             :                                     sal_Int32 columnIndex,
     444             :                                          const Reference< XNameAccess >& )
     445             :     throw( SQLException, RuntimeException, std::exception )
     446             : {
     447        5728 :     osl::MutexGuard aGuard( m_aMutex );
     448             : 
     449        5728 :     Any aValue;
     450             : 
     451        5728 :     m_bWasNull = true;
     452             : 
     453        5728 :     if ( ( columnIndex < 1 )
     454        5728 :          || ( columnIndex > sal_Int32( m_pValues->size() ) ) )
     455             :     {
     456             :         OSL_FAIL( "PropertyValueSet - index out of range!" );
     457             :     }
     458             :     else
     459             :     {
     460             :         ucbhelper_impl::PropertyValue& rValue
     461        5728 :             = (*m_pValues)[ columnIndex - 1 ];
     462             : 
     463        5728 :         if ( rValue.nPropsSet & OBJECT_VALUE_SET )
     464             :         {
     465             :             // Values is present natively...
     466         412 :             aValue = rValue.aObject;
     467         412 :             m_bWasNull = false;
     468             :         }
     469             :         else
     470             :         {
     471             :             // Make Any from original value.
     472             : 
     473        5316 :             switch ( rValue.nOrigValue )
     474             :             {
     475             :                 case NO_VALUE_SET:
     476           4 :                     break;
     477             : 
     478             :                 case STRING_VALUE_SET:
     479        2320 :                     aValue <<= rValue.aString;
     480        2320 :                     break;
     481             : 
     482             :                 case BOOLEAN_VALUE_SET:
     483        2980 :                     aValue <<= rValue.bBoolean;
     484        2980 :                     break;
     485             : 
     486             :                 case BYTE_VALUE_SET:
     487           0 :                     aValue <<= rValue.nByte;
     488           0 :                     break;
     489             : 
     490             :                 case SHORT_VALUE_SET:
     491           0 :                     aValue <<= rValue.nShort;
     492           0 :                     break;
     493             : 
     494             :                 case INT_VALUE_SET:
     495           0 :                     aValue <<= rValue.nInt;
     496           0 :                     break;
     497             : 
     498             :                 case LONG_VALUE_SET:
     499          12 :                     aValue <<= rValue.nLong;
     500          12 :                     break;
     501             : 
     502             :                 case FLOAT_VALUE_SET:
     503           0 :                     aValue <<= rValue.nFloat;
     504           0 :                     break;
     505             : 
     506             :                 case DOUBLE_VALUE_SET:
     507           0 :                     aValue <<= rValue.nDouble;
     508           0 :                     break;
     509             : 
     510             :                 case BYTES_VALUE_SET:
     511           0 :                     aValue <<= rValue.aBytes;
     512           0 :                     break;
     513             : 
     514             :                 case DATE_VALUE_SET:
     515           0 :                     aValue <<= rValue.aDate;
     516           0 :                     break;
     517             : 
     518             :                 case TIME_VALUE_SET:
     519           0 :                     aValue <<= rValue.aTime;
     520           0 :                     break;
     521             : 
     522             :                 case TIMESTAMP_VALUE_SET:
     523           0 :                     aValue <<= rValue.aTimestamp;
     524           0 :                     break;
     525             : 
     526             :                 case BINARYSTREAM_VALUE_SET:
     527           0 :                     aValue <<= rValue.xBinaryStream;
     528           0 :                     break;
     529             : 
     530             :                 case CHARACTERSTREAM_VALUE_SET:
     531           0 :                     aValue <<= rValue.xCharacterStream;
     532           0 :                     break;
     533             : 
     534             :                 case REF_VALUE_SET:
     535           0 :                     aValue <<= rValue.xRef;
     536           0 :                     break;
     537             : 
     538             :                 case BLOB_VALUE_SET:
     539           0 :                     aValue <<= rValue.xBlob;
     540           0 :                     break;
     541             : 
     542             :                 case CLOB_VALUE_SET:
     543           0 :                     aValue <<= rValue.xClob;
     544           0 :                     break;
     545             : 
     546             :                 case ARRAY_VALUE_SET:
     547           0 :                     aValue <<= rValue.xArray;
     548           0 :                     break;
     549             : 
     550             :                 case OBJECT_VALUE_SET:
     551             :                     // Fall-through is intended!
     552             :                 default:
     553             :                     OSL_FAIL( "PropertyValueSet::getObject - "
     554             :                                 "Wrong original type" );
     555           0 :                     break;
     556             :             }
     557             : 
     558        5316 :             if ( aValue.hasValue() )
     559             :             {
     560        5312 :                 rValue.aObject = aValue;
     561        5312 :                 rValue.nPropsSet |= OBJECT_VALUE_SET;
     562        5312 :                 m_bWasNull = false;
     563             :             }
     564             :         }
     565             :      }
     566             : 
     567        5728 :     return aValue;
     568             : }
     569             : 
     570             : 
     571             : // virtual
     572           0 : Reference< XRef > SAL_CALL PropertyValueSet::getRef( sal_Int32 columnIndex )
     573             :     throw( SQLException, RuntimeException, std::exception )
     574             : {
     575           0 :     GETVALUE_IMPL( Reference< XRef >, REF_VALUE_SET, xRef );
     576             : }
     577             : 
     578             : 
     579             : // virtual
     580           0 : Reference< XBlob > SAL_CALL PropertyValueSet::getBlob( sal_Int32 columnIndex )
     581             :     throw( SQLException, RuntimeException, std::exception )
     582             : {
     583           0 :     GETVALUE_IMPL( Reference< XBlob >, BLOB_VALUE_SET, xBlob );
     584             : }
     585             : 
     586             : 
     587             : // virtual
     588           0 : Reference< XClob > SAL_CALL PropertyValueSet::getClob( sal_Int32 columnIndex )
     589             :     throw( SQLException, RuntimeException, std::exception )
     590             : {
     591           0 :     GETVALUE_IMPL( Reference< XClob >, CLOB_VALUE_SET, xClob );
     592             : }
     593             : 
     594             : 
     595             : // virtual
     596           0 : Reference< XArray > SAL_CALL PropertyValueSet::getArray( sal_Int32 columnIndex )
     597             :     throw( SQLException, RuntimeException, std::exception )
     598             : {
     599           0 :     GETVALUE_IMPL( Reference< XArray >, ARRAY_VALUE_SET, xArray );
     600             : }
     601             : 
     602             : 
     603             : 
     604             : // XColumnLocate methods.
     605             : 
     606             : 
     607             : 
     608             : // virtual
     609           0 : sal_Int32 SAL_CALL PropertyValueSet::findColumn( const OUString& columnName )
     610             :     throw( SQLException, RuntimeException, std::exception )
     611             : {
     612           0 :     osl::MutexGuard aGuard( m_aMutex );
     613             : 
     614           0 :     if ( !columnName.isEmpty() )
     615             :     {
     616           0 :         sal_Int32 nCount = m_pValues->size();
     617           0 :         for ( sal_Int32 n = 0; n < nCount; ++n )
     618             :         {
     619           0 :             if ( (*m_pValues)[ n ].sPropertyName.equals( columnName ) )
     620           0 :                 return sal_Int32( n + 1 ); // Index is 1-based.
     621             :         }
     622             :     }
     623           0 :     return 0;
     624             : }
     625             : 
     626             : 
     627             : 
     628             : // Non-interface methods.
     629             : 
     630             : 
     631             : 
     632           0 : const Reference< XTypeConverter >& PropertyValueSet::getTypeConverter()
     633             : {
     634           0 :     osl::MutexGuard aGuard( m_aMutex );
     635             : 
     636           0 :     if ( !m_bTriedToGetTypeConverter && !m_xTypeConverter.is() )
     637             :     {
     638           0 :         m_bTriedToGetTypeConverter = true;
     639           0 :         m_xTypeConverter = Converter::create(m_xContext);
     640             : 
     641             :         OSL_ENSURE( m_xTypeConverter.is(),
     642             :                     "PropertyValueSet::getTypeConverter() - "
     643             :                     "Service 'com.sun.star.script.Converter' n/a!" );
     644             :     }
     645           0 :     return m_xTypeConverter;
     646             : }
     647             : 
     648             : 
     649        2344 : void PropertyValueSet::appendString( const OUString& rPropName,
     650             :                                      const OUString& rValue )
     651             : {
     652        2344 :     SETVALUE_IMPL( rPropName, STRING_VALUE_SET, aString, rValue );
     653        2344 : }
     654             : 
     655             : 
     656        3020 : void PropertyValueSet::appendBoolean( const OUString& rPropName,
     657             :                                       bool bValue )
     658             : {
     659        3020 :     SETVALUE_IMPL( rPropName, BOOLEAN_VALUE_SET, bBoolean, bValue );
     660        3020 : }
     661             : 
     662             : 
     663          12 : void PropertyValueSet::appendLong( const OUString& rPropName,
     664             :                                    sal_Int64 nValue )
     665             : {
     666          12 :     SETVALUE_IMPL( rPropName, LONG_VALUE_SET, nLong, nValue );
     667          12 : }
     668             : 
     669             : 
     670           0 : void PropertyValueSet::appendTimestamp( const OUString& rPropName,
     671             :                                         const DateTime& rValue )
     672             : {
     673           0 :     SETVALUE_IMPL( rPropName, TIMESTAMP_VALUE_SET, aTimestamp, rValue );
     674           0 : }
     675             : 
     676             : 
     677         348 : void PropertyValueSet::appendObject( const OUString& rPropName,
     678             :                                      const Any& rValue )
     679             : {
     680         348 :     SETVALUE_IMPL( rPropName, OBJECT_VALUE_SET, aObject, rValue );
     681         348 : }
     682             : 
     683             : 
     684          28 : void PropertyValueSet::appendVoid( const OUString& rPropName )
     685             : {
     686          28 :     SETVALUE_IMPL( rPropName, NO_VALUE_SET, aObject, Any() );
     687          28 : }
     688             : 
     689             : 
     690           0 : void PropertyValueSet::appendPropertySet(
     691             :                                 const Reference< XPropertySet >& rxSet )
     692             : {
     693           0 :     if ( rxSet.is() )
     694             :     {
     695           0 :         Reference< XPropertySetInfo > xInfo = rxSet->getPropertySetInfo();
     696           0 :         if ( xInfo.is() )
     697             :         {
     698           0 :             Sequence< Property > aProps      = xInfo->getProperties();
     699           0 :             const Property*      pProps      = aProps.getConstArray();
     700           0 :             sal_Int32            nPropsCount = aProps.getLength();
     701             : 
     702           0 :             Reference< XPropertyAccess > xPropertyAccess( rxSet, UNO_QUERY );
     703           0 :             if ( xPropertyAccess.is() )
     704             :             {
     705             :                 // Efficient: Get all prop values with one ( remote) call.
     706             : 
     707             :                 Sequence< ::com::sun::star::beans::PropertyValue > aPropValues
     708           0 :                     = xPropertyAccess->getPropertyValues();
     709             : 
     710             :                 const ::com::sun::star::beans::PropertyValue* pPropValues
     711           0 :                       = aPropValues.getConstArray();
     712             : 
     713           0 :                 sal_Int32 nValuesCount = aPropValues.getLength();
     714           0 :                 for ( sal_Int32 n = 0; n < nValuesCount; ++n )
     715             :                 {
     716             :                     const ::com::sun::star::beans::PropertyValue& rPropValue
     717           0 :                         = pPropValues[ n ];
     718             : 
     719             :                     // Find info for current property value.
     720           0 :                     for ( sal_Int32 m = 0; m < nPropsCount; ++m )
     721             :                     {
     722           0 :                         const Property& rProp = pProps[ m ];
     723           0 :                         if ( rProp.Name == rPropValue.Name )
     724             :                         {
     725             :                             // Found!
     726           0 :                             appendObject( rProp, rPropValue.Value );
     727           0 :                             break;
     728             :                         }
     729             :                     }
     730           0 :                 }
     731             :             }
     732             :             else
     733             :             {
     734             :                 // Get every single prop value with one ( remote) call.
     735             : 
     736           0 :                 for ( sal_Int32 n = 0; n < nPropsCount; ++n )
     737             :                 {
     738           0 :                     const Property& rProp = pProps[ n ];
     739             : 
     740             :                     try
     741             :                     {
     742           0 :                         Any aValue = rxSet->getPropertyValue( rProp.Name );
     743             : 
     744           0 :                         if ( aValue.hasValue() )
     745           0 :                             appendObject( rProp, aValue );
     746             :                     }
     747           0 :                     catch (const UnknownPropertyException&)
     748             :                     {
     749             :                     }
     750           0 :                     catch (const WrappedTargetException&)
     751             :                     {
     752             :                     }
     753             :                 }
     754           0 :             }
     755           0 :         }
     756             :     }
     757           0 : }
     758             : 
     759             : 
     760           0 : bool PropertyValueSet::appendPropertySetValue(
     761             :                                 const Reference< XPropertySet >& rxSet,
     762             :                                 const Property& rProperty )
     763             : {
     764           0 :     if ( rxSet.is() )
     765             :     {
     766             :         try
     767             :         {
     768           0 :             Any aValue = rxSet->getPropertyValue( rProperty.Name );
     769           0 :             if ( aValue.hasValue() )
     770             :             {
     771           0 :                 appendObject( rProperty, aValue );
     772           0 :                 return true;
     773           0 :             }
     774             :         }
     775           0 :         catch (const UnknownPropertyException&)
     776             :         {
     777             :         }
     778           0 :         catch (const WrappedTargetException&)
     779             :         {
     780             :         }
     781             :     }
     782             : 
     783             :     // Error.
     784           0 :     return false;
     785             : }
     786             : 
     787             : } // namespace ucbhelper
     788             : 
     789             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10