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