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