LCOV - code coverage report
Current view: top level - ucbhelper/source/provider - contentinfo.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 35 139 25.2 %
Date: 2015-06-13 12:38:46 Functions: 8 29 27.6 %
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             :                                 TODO
      22             :  **************************************************************************
      23             : 
      24             :  *************************************************************************/
      25             : #include <com/sun/star/beans/PropertyValue.hpp>
      26             : #include <com/sun/star/ucb/XPropertySetRegistry.hpp>
      27             : 
      28             : #include "osl/diagnose.h"
      29             : #include "osl/mutex.hxx"
      30             : #include <ucbhelper/contenthelper.hxx>
      31             : #include <ucbhelper/contentinfo.hxx>
      32             : 
      33             : using namespace com::sun::star;
      34             : 
      35             : 
      36             : 
      37             : 
      38             : // PropertySetInfo Implementation.
      39             : 
      40             : 
      41             : 
      42             : 
      43             : namespace ucbhelper {
      44             : 
      45        3339 : PropertySetInfo::PropertySetInfo(
      46             :     const uno::Reference< com::sun::star::ucb::XCommandEnvironment >& rxEnv,
      47             :     ContentImplHelper* pContent )
      48             : : m_xEnv( rxEnv ),
      49             :   m_pProps( 0 ),
      50        3339 :   m_pContent( pContent )
      51             : {
      52        3339 : }
      53             : 
      54             : 
      55             : // virtual
      56       10017 : PropertySetInfo::~PropertySetInfo()
      57             : {
      58        3339 :     delete m_pProps;
      59        6678 : }
      60             : 
      61             : 
      62             : 
      63             : // XInterface methods.
      64             : 
      65       13356 : void SAL_CALL PropertySetInfo::acquire()
      66             :     throw()
      67             : {
      68       13356 :     OWeakObject::acquire();
      69       13356 : }
      70             : 
      71       13356 : void SAL_CALL PropertySetInfo::release()
      72             :     throw()
      73             : {
      74       13356 :     OWeakObject::release();
      75       13356 : }
      76             : 
      77           0 : css::uno::Any SAL_CALL PropertySetInfo::queryInterface( const css::uno::Type & rType )
      78             :     throw( css::uno::RuntimeException, std::exception )
      79             : {
      80             :     css::uno::Any aRet = cppu::queryInterface( rType,
      81             :                                                (static_cast< lang::XTypeProvider* >(this)),
      82             :                                                (static_cast< beans::XPropertySetInfo* >(this))
      83           0 :                                                );
      84           0 :     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
      85             : }
      86             : 
      87             : // XTypeProvider methods.
      88           0 : XTYPEPROVIDER_IMPL_2( PropertySetInfo,
      89             :                       lang::XTypeProvider,
      90             :                       beans::XPropertySetInfo );
      91             : 
      92             : 
      93             : // XPropertySetInfo methods.
      94             : 
      95             : 
      96             : 
      97             : // virtual
      98        3339 : uno::Sequence< beans::Property > SAL_CALL PropertySetInfo::getProperties()
      99             :     throw( uno::RuntimeException, std::exception )
     100             : {
     101        3339 :     if ( !m_pProps )
     102             :     {
     103        3339 :         osl::MutexGuard aGuard( m_aMutex );
     104        3339 :         if ( !m_pProps )
     105             :         {
     106             : 
     107             :             // Get info for core ( native) properties.
     108             : 
     109             : 
     110             :             try
     111             :             {
     112             :                 uno::Sequence< beans::Property > aProps
     113        3339 :                     = m_pContent->getProperties( m_xEnv );
     114        3339 :                 m_pProps = new uno::Sequence< beans::Property >( aProps );
     115             :             }
     116           0 :             catch ( uno::RuntimeException const & )
     117             :             {
     118           0 :                 throw;
     119             :             }
     120           0 :             catch ( uno::Exception const & )
     121             :             {
     122           0 :                 m_pProps = new uno::Sequence< beans::Property >( 0 );
     123             :             }
     124             : 
     125             : 
     126             :             // Get info for additional properties.
     127             : 
     128             : 
     129             :             uno::Reference< com::sun::star::ucb::XPersistentPropertySet >
     130        3339 :                 xSet ( m_pContent->getAdditionalPropertySet( false ) );
     131             : 
     132        3339 :             if ( xSet.is() )
     133             :             {
     134             :                 // Get property set info.
     135             :                 uno::Reference< beans::XPropertySetInfo > xInfo(
     136           0 :                     xSet->getPropertySetInfo() );
     137           0 :                 if ( xInfo.is() )
     138             :                 {
     139             :                     const uno::Sequence< beans::Property >& rAddProps
     140           0 :                         = xInfo->getProperties();
     141           0 :                     sal_Int32 nAddProps = rAddProps.getLength();
     142           0 :                     if ( nAddProps > 0 )
     143             :                     {
     144           0 :                         sal_Int32 nPos = m_pProps->getLength();
     145           0 :                         m_pProps->realloc( nPos + nAddProps );
     146             : 
     147           0 :                         beans::Property* pProps = m_pProps->getArray();
     148             :                         const beans::Property* pAddProps
     149           0 :                             = rAddProps.getConstArray();
     150             : 
     151           0 :                         for ( sal_Int32 n = 0; n < nAddProps; ++n, ++nPos )
     152           0 :                             pProps[ nPos ] = pAddProps[ n ];
     153           0 :                     }
     154           0 :                 }
     155        3339 :             }
     156        3339 :         }
     157             :     }
     158        3339 :     return *m_pProps;
     159             : }
     160             : 
     161             : 
     162             : // virtual
     163           0 : beans::Property SAL_CALL PropertySetInfo::getPropertyByName(
     164             :         const OUString& aName )
     165             :     throw( beans::UnknownPropertyException, uno::RuntimeException, std::exception )
     166             : {
     167           0 :     beans::Property aProp;
     168           0 :     if ( queryProperty( aName, aProp ) )
     169           0 :         return aProp;
     170             : 
     171           0 :     throw beans::UnknownPropertyException();
     172             : }
     173             : 
     174             : 
     175             : // virtual
     176        3329 : sal_Bool SAL_CALL PropertySetInfo::hasPropertyByName(
     177             :         const OUString& Name )
     178             :     throw( uno::RuntimeException, std::exception )
     179             : {
     180        3329 :     beans::Property aProp;
     181        3329 :     return queryProperty( Name, aProp );
     182             : }
     183             : 
     184             : 
     185             : 
     186             : // Non-Interface methods.
     187             : 
     188             : 
     189             : 
     190           0 : void PropertySetInfo::reset()
     191             : {
     192           0 :     osl::MutexGuard aGuard( m_aMutex );
     193           0 :     delete m_pProps;
     194           0 :     m_pProps = 0;
     195           0 : }
     196             : 
     197             : 
     198        3329 : bool PropertySetInfo::queryProperty(
     199             :     const OUString& rName, beans::Property& rProp )
     200             : {
     201        3329 :     osl::MutexGuard aGuard( m_aMutex );
     202             : 
     203        3329 :     getProperties();
     204             : 
     205        3329 :     const beans::Property* pProps = m_pProps->getConstArray();
     206        3329 :     sal_Int32 nCount = m_pProps->getLength();
     207       43277 :     for ( sal_Int32 n = 0; n < nCount; ++n )
     208             :     {
     209       39948 :         const beans::Property& rCurrProp = pProps[ n ];
     210       39948 :         if ( rCurrProp.Name == rName )
     211             :         {
     212           0 :             rProp = rCurrProp;
     213           0 :             return true;
     214             :         }
     215             :     }
     216             : 
     217        3329 :     return false;
     218             : }
     219             : 
     220             : 
     221             : 
     222             : 
     223             : // CommandProcessorInfo Implementation.
     224             : 
     225             : 
     226             : 
     227             : 
     228           0 : CommandProcessorInfo::CommandProcessorInfo(
     229             :     const uno::Reference< com::sun::star::ucb::XCommandEnvironment >& rxEnv,
     230             :     ContentImplHelper* pContent )
     231             : : m_xEnv( rxEnv ),
     232             :   m_pCommands( 0 ),
     233           0 :   m_pContent( pContent )
     234             : {
     235           0 : }
     236             : 
     237             : 
     238             : // virtual
     239           0 : CommandProcessorInfo::~CommandProcessorInfo()
     240             : {
     241           0 :     delete m_pCommands;
     242           0 : }
     243             : 
     244             : 
     245             : 
     246             : // XInterface methods.
     247             : 
     248             : 
     249           0 : void SAL_CALL CommandProcessorInfo::acquire()
     250             :     throw()
     251             : {
     252           0 :     OWeakObject::acquire();
     253           0 : }
     254             : 
     255           0 : void SAL_CALL CommandProcessorInfo::release()
     256             :     throw()
     257             : {
     258           0 :     OWeakObject::release();
     259           0 : }
     260             : 
     261           0 : css::uno::Any SAL_CALL CommandProcessorInfo::queryInterface( const css::uno::Type & rType )
     262             :     throw( css::uno::RuntimeException, std::exception )
     263             : {
     264             :     css::uno::Any aRet = cppu::queryInterface( rType,
     265             :                                                (static_cast< lang::XTypeProvider* >(this)),
     266             :                                                (static_cast< css::ucb::XCommandInfo* >(this))
     267           0 :                     );
     268           0 :     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
     269             : }
     270             : 
     271             : // XTypeProvider methods.
     272             : 
     273             : 
     274             : 
     275           0 : XTYPEPROVIDER_IMPL_2( CommandProcessorInfo,
     276             :                          lang::XTypeProvider,
     277             :                          com::sun::star::ucb::XCommandInfo );
     278             : 
     279             : 
     280             : 
     281             : // XCommandInfo methods.
     282             : 
     283             : 
     284             : 
     285             : // virtual
     286             : uno::Sequence< com::sun::star::ucb::CommandInfo > SAL_CALL
     287           0 : CommandProcessorInfo::getCommands()
     288             :     throw( uno::RuntimeException, std::exception )
     289             : {
     290           0 :     if ( !m_pCommands )
     291             :     {
     292           0 :         osl::MutexGuard aGuard( m_aMutex );
     293           0 :         if ( !m_pCommands )
     294             :         {
     295             : 
     296             :             // Get info for commands.
     297             : 
     298             : 
     299             :             try
     300             :             {
     301             :                 uno::Sequence< com::sun::star::ucb::CommandInfo > aCmds
     302           0 :                     = m_pContent->getCommands( m_xEnv );
     303             :                 m_pCommands
     304             :                     = new uno::Sequence< com::sun::star::ucb::CommandInfo >(
     305           0 :                         aCmds );
     306             :             }
     307           0 :             catch ( uno::RuntimeException const & )
     308             :             {
     309           0 :                 throw;
     310             :             }
     311           0 :             catch ( uno::Exception const & )
     312             :             {
     313             :                 m_pCommands
     314             :                     = new uno::Sequence< com::sun::star::ucb::CommandInfo >(
     315           0 :                         0 );
     316             :             }
     317           0 :         }
     318             :     }
     319           0 :     return *m_pCommands;
     320             : }
     321             : 
     322             : 
     323             : // virtual
     324             : com::sun::star::ucb::CommandInfo SAL_CALL
     325           0 : CommandProcessorInfo::getCommandInfoByName(
     326             :         const OUString& Name )
     327             :     throw( com::sun::star::ucb::UnsupportedCommandException,
     328             :            uno::RuntimeException, std::exception )
     329             : {
     330           0 :     com::sun::star::ucb::CommandInfo aInfo;
     331           0 :     if ( queryCommand( Name, aInfo ) )
     332           0 :         return aInfo;
     333             : 
     334           0 :     throw com::sun::star::ucb::UnsupportedCommandException();
     335             : }
     336             : 
     337             : 
     338             : // virtual
     339             : com::sun::star::ucb::CommandInfo SAL_CALL
     340           0 : CommandProcessorInfo::getCommandInfoByHandle( sal_Int32 Handle )
     341             :     throw( com::sun::star::ucb::UnsupportedCommandException,
     342             :            uno::RuntimeException, std::exception )
     343             : {
     344           0 :     com::sun::star::ucb::CommandInfo aInfo;
     345           0 :     if ( queryCommand( Handle, aInfo ) )
     346           0 :         return aInfo;
     347             : 
     348           0 :     throw com::sun::star::ucb::UnsupportedCommandException();
     349             : }
     350             : 
     351             : 
     352             : // virtual
     353           0 : sal_Bool SAL_CALL CommandProcessorInfo::hasCommandByName(
     354             :        const OUString& Name )
     355             :     throw( uno::RuntimeException, std::exception )
     356             : {
     357           0 :     com::sun::star::ucb::CommandInfo aInfo;
     358           0 :     return queryCommand( Name, aInfo );
     359             : }
     360             : 
     361             : 
     362             : // virtual
     363           0 : sal_Bool SAL_CALL CommandProcessorInfo::hasCommandByHandle( sal_Int32 Handle )
     364             :     throw( uno::RuntimeException, std::exception )
     365             : {
     366           0 :     com::sun::star::ucb::CommandInfo aInfo;
     367           0 :     return queryCommand( Handle, aInfo );
     368             : }
     369             : 
     370             : 
     371             : 
     372             : // Non-Interface methods.
     373             : 
     374             : 
     375             : 
     376           0 : void CommandProcessorInfo::reset()
     377             : {
     378           0 :     osl::MutexGuard aGuard( m_aMutex );
     379           0 :     delete m_pCommands;
     380           0 :     m_pCommands = 0;
     381           0 : }
     382             : 
     383             : 
     384             : 
     385           0 : bool CommandProcessorInfo::queryCommand(
     386             :     const OUString& rName,
     387             :     com::sun::star::ucb::CommandInfo& rCommand )
     388             : {
     389           0 :     osl::MutexGuard aGuard( m_aMutex );
     390             : 
     391           0 :     getCommands();
     392             : 
     393             :     const com::sun::star::ucb::CommandInfo* pCommands
     394           0 :         = m_pCommands->getConstArray();
     395           0 :     sal_Int32 nCount = m_pCommands->getLength();
     396           0 :     for ( sal_Int32 n = 0; n < nCount; ++n )
     397             :     {
     398           0 :         const com::sun::star::ucb::CommandInfo& rCurrCommand = pCommands[ n ];
     399           0 :         if ( rCurrCommand.Name == rName )
     400             :         {
     401           0 :             rCommand = rCurrCommand;
     402           0 :             return true;
     403             :         }
     404             :     }
     405             : 
     406           0 :     return false;
     407             : }
     408             : 
     409             : 
     410           0 : bool CommandProcessorInfo::queryCommand(
     411             :     sal_Int32 nHandle,
     412             :     com::sun::star::ucb::CommandInfo& rCommand )
     413             : {
     414           0 :     osl::MutexGuard aGuard( m_aMutex );
     415             : 
     416           0 :     getCommands();
     417             : 
     418             :     const com::sun::star::ucb::CommandInfo* pCommands
     419           0 :         = m_pCommands->getConstArray();
     420           0 :     sal_Int32 nCount = m_pCommands->getLength();
     421           0 :     for ( sal_Int32 n = 0; n < nCount; ++n )
     422             :     {
     423           0 :         const com::sun::star::ucb::CommandInfo& rCurrCommand = pCommands[ n ];
     424           0 :         if ( rCurrCommand.Handle == nHandle )
     425             :         {
     426           0 :             rCommand = rCurrCommand;
     427           0 :             return true;
     428             :         }
     429             :     }
     430             : 
     431           0 :     return false;
     432             : }
     433             : 
     434             : } // namespace ucbhelper
     435             : 
     436             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11