dbaccess/source/core/dataaccess/documentcontainer.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 #include "documentcontainer.hxx"
  21 #include <stringconstants.hxx>
  22 #include "documentdefinition.hxx"
  23 #include <ModelImpl.hxx>
  24 #include <com/sun/star/ucb/OpenCommandArgument2.hpp>
  25 #include <com/sun/star/ucb/OpenMode.hpp>
  26 #include <connectivity/dbtools.hxx>
  27 #include "myucp_resultset.hxx"
  28 #include <ucbhelper/cancelcommandexecution.hxx>
  29 #include <com/sun/star/ucb/UnsupportedOpenModeException.hpp>
  30 #include <com/sun/star/ucb/InsertCommandArgument.hpp>
  31 #include <com/sun/star/beans/PropertyAttribute.hpp>
  32 #include <com/sun/star/sdb/ErrorCondition.hpp>
  33 #include <comphelper/mimeconfighelper.hxx>
  34 #include <connectivity/sqlerror.hxx>
  35 #include <core_resource.hxx>
  36 #include <strings.hrc>
  37 #include <strings.hxx>
  38 #include <comphelper/namedvaluecollection.hxx>
  39 #include <comphelper/propertysequence.hxx>
  40 #include <comphelper/servicehelper.hxx>
  41 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  42
  43 #include <vcl/svapp.hxx>
  44 #include <osl/mutex.hxx>
  45 #include <o3tl/string_view.hxx>
  46
  47 using namespace ::com::sun::star::uno;
  48 using namespace ::com::sun::star::lang;
  49 using namespace ::com::sun::star::embed;
  50 using namespace ::com::sun::star::beans;
  51 using namespace ::com::sun::star::container;
  52 using namespace ::com::sun::star::ucb;
  53 using namespace ::com::sun::star::sdbc;
  54 using namespace ::com::sun::star::sdb;
  55 using namespace ::osl;
  56 using namespace ::comphelper;
  57 using namespace ::cppu;
  58
  59 namespace dbaccess
  60 {
  61
  62 namespace {
  63
  64 // LocalNameApproval
  65 class LocalNameApproval : public IContainerApprove
  66 {
  67     ::connectivity::SQLError    m_aErrors;
  68
  69 public:
  70     void approveElement( const OUString& _rName ) override;
  71 };
  72
  73 }
  74
  75 void LocalNameApproval::approveElement( const OUString& _rName )
  76 {
  77     if ( _rName.indexOf( '/' ) != -1 )
  78         throw IllegalArgumentException(
  79             m_aErrors.getErrorMessage( ErrorCondition::DB_OBJECT_NAME_WITH_SLASHES ),
  80             nullptr,
  81             0
  82         );
  83 }
  84
  85 // ODocumentContainer
  86
  87 ODocumentContainer::ODocumentContainer(const Reference< XComponentContext >& _xORB
  88                                     ,const Reference< XInterface >& _xParentContainer
  89                                     ,const TContentPtr& _pImpl
  90                                     , bool _bFormsContainer
  91                                     )
  92     :ODefinitionContainer(_xORB,_xParentContainer,_pImpl)
  93     ,OPropertyStateContainer(OContentHelper::rBHelper)
  94     ,m_bFormsContainer(_bFormsContainer)
  95 {
  96     registerProperty(PROPERTY_NAME, PROPERTY_ID_NAME, PropertyAttribute::BOUND | PropertyAttribute::READONLY | PropertyAttribute::CONSTRAINED,
  97                     &m_pImpl->m_aProps.aTitle, cppu::UnoType<decltype(m_pImpl->m_aProps.aTitle)>::get());
  98
  99     setElementApproval( std::make_shared<LocalNameApproval>() );
 100 }
 101
 102 ODocumentContainer::~ODocumentContainer()
 103 {
 104
 105     if ( !OContentHelper::rBHelper.bInDispose && !OContentHelper::rBHelper.bDisposed )
 106     {
 107         acquire();
 108         dispose();
 109     }
 110 }
 111
 112 IMPLEMENT_FORWARD_XINTERFACE3( ODocumentContainer,ODefinitionContainer,ODocumentContainer_Base,OPropertyStateContainer)
 113
 114 css::uno::Sequence<sal_Int8> ODocumentContainer::getImplementationId()
 115 {
 116     return css::uno::Sequence<sal_Int8>();
 117 }
 118
 119 css::uno::Sequence< css::uno::Type > ODocumentContainer::getTypes()
 120 {
 121     return  ::comphelper::concatSequences(
 122         ODefinitionContainer::getTypes( ),
 123         OPropertyStateContainer::getTypes( ),
 124         ODocumentContainer_Base::getTypes( )
 125     );
 126 }
 127 OUString SAL_CALL ODocumentContainer::getImplementationName()
 128     {
 129         return u"com.sun.star.comp.dba.ODocumentContainer"_ustr;
 130     };
 131 sal_Bool SAL_CALL ODocumentContainer::supportsService(const OUString& _rServiceName)
 132     {
 133         const css::uno::Sequence< OUString > aSupported(getSupportedServiceNames());
 134         for (const OUString& s : aSupported)
 135             if (s == _rServiceName)
 136                 return true;
 137
 138         return false;
 139     };
 140 css::uno::Reference< css::beans::XPropertySetInfo >  SAL_CALL ODocumentContainer::getPropertySetInfo()
 141 {
 142     Reference< XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
 143     return xInfo;
 144 }
 145 ::cppu::IPropertyArrayHelper& ODocumentContainer::getInfoHelper()
 146 {
 147     return *ODocumentContainer::getArrayHelper();
 148 }
 149 ::cppu::IPropertyArrayHelper* ODocumentContainer::createArrayHelper( ) const
 150 {
 151     css::uno::Sequence< css::beans::Property > aProps;
 152     describeProperties(aProps);
 153     return new ::cppu::OPropertyArrayHelper(aProps);
 154 }
 155
 156
 157 Sequence< OUString > SAL_CALL ODocumentContainer::getSupportedServiceNames(  )
 158 {
 159     return { m_bFormsContainer ? SERVICE_NAME_FORM_COLLECTION : SERVICE_NAME_REPORT_COLLECTION };
 160 }
 161
 162 OUString ODocumentContainer::determineContentType() const
 163 {
 164     return OUString();
 165 }
 166
 167 Reference< XContent > ODocumentContainer::createObject( const OUString& _rName)
 168 {
 169     const ODefinitionContainer_Impl& rDefinitions( getDefinitions() );
 170     ODefinitionContainer_Impl::const_iterator aFind = rDefinitions.find( _rName );
 171     OSL_ENSURE( aFind != rDefinitions.end(), "ODocumentContainer::createObject:Invalid entry in map!" );
 172     if ( aFind->second->m_aProps.bIsFolder )
 173         return new ODocumentContainer( m_aContext, *this, aFind->second, m_bFormsContainer );
 174     return new ODocumentDefinition( *this, m_aContext, aFind->second, m_bFormsContainer );
 175 }
 176
 177 Reference< XInterface > SAL_CALL ODocumentContainer::createInstance( const OUString& aServiceSpecifier )
 178 {
 179     return createInstanceWithArguments( aServiceSpecifier, Sequence< Any >() );
 180 }
 181
 182 namespace
 183 {
 184     template< class TYPE >
 185     void lcl_extractAndRemove( ::comphelper::NamedValueCollection& io_rArguments, const OUString& i_rName, TYPE& o_rValue )
 186     {
 187         if ( io_rArguments.has( i_rName ) )
 188         {
 189             io_rArguments.get_ensureType( i_rName, o_rValue );
 190             io_rArguments.remove( i_rName );
 191         }
 192     }
 193 }
 194
 195 Reference< XInterface > SAL_CALL ODocumentContainer::createInstanceWithArguments( const OUString& ServiceSpecifier, const Sequence< Any >& _aArguments )
 196 {
 197     Reference< XInterface > xRet;
 198     Reference< XContent > xContent;
 199     if ( ServiceSpecifier == SERVICE_SDB_DOCUMENTDEFINITION )
 200     {
 201         MutexGuard aGuard(m_aMutex);
 202
 203         // extract known arguments
 204         OUString sName, sPersistentName, sURL, sMediaType, sDocServiceName;
 205         Reference< XCommandProcessor > xCopyFrom;
 206         Reference< XConnection > xConnection;
 207         bool bAsTemplate( false );
 208         Sequence< sal_Int8 > aClassID;
 209
 210         ::comphelper::NamedValueCollection aArgs( _aArguments );
 211         lcl_extractAndRemove( aArgs, PROPERTY_NAME, sName );
 212         lcl_extractAndRemove( aArgs, PROPERTY_PERSISTENT_NAME, sPersistentName );
 213         lcl_extractAndRemove( aArgs, PROPERTY_URL, sURL );
 214         lcl_extractAndRemove( aArgs, PROPERTY_EMBEDDEDOBJECT, xCopyFrom );
 215         lcl_extractAndRemove( aArgs, PROPERTY_ACTIVE_CONNECTION, xConnection );
 216         lcl_extractAndRemove( aArgs, PROPERTY_AS_TEMPLATE, bAsTemplate );
 217         lcl_extractAndRemove( aArgs, INFO_MEDIATYPE, sMediaType );
 218         lcl_extractAndRemove( aArgs, u"DocumentServiceName"_ustr , sDocServiceName );
 219
 220         // ClassID has two allowed types, so a special treatment here
 221         Any aClassIDArg = aArgs.get( u"ClassID"_ustr );
 222         if ( aClassIDArg.hasValue() )
 223         {
 224             if ( !( aClassIDArg >>= aClassID ) )
 225             {
 226                 // Extended for usage also with a string
 227                 OUString sClassIDString;
 228                 if ( !( aClassIDArg >>= sClassIDString ) )
 229                     throw IllegalArgumentException( OUString(), *this, 2 );
 230
 231                 aClassID = ::comphelper::MimeConfigurationHelper::GetSequenceClassIDRepresentation( sClassIDString );
 232             }
 233
 234 #if OSL_DEBUG_LEVEL > 0
 235             OUString sClassIDString = ::comphelper::MimeConfigurationHelper::GetStringClassIDRepresentation( aClassID );
 236             (void)sClassIDString;
 237 #endif
 238             aArgs.remove( u"ClassID"_ustr );
 239         }
 240         // Everything which now is still present in the arguments is passed to the embedded object
 241         const Sequence< PropertyValue > aCreationArgs( aArgs.getPropertyValues() );
 242
 243         const ODefinitionContainer_Impl& rDefinitions( getDefinitions() );
 244         bool bNew = sPersistentName.isEmpty();
 245         if ( bNew )
 246         {
 247             sPersistentName = "Obj" + OUString::number(rDefinitions.size() + 1);
 248             Reference<XNameAccess> xElements = getContainerStorage();
 249             if ( xElements.is() )
 250                 sPersistentName = ::dbtools::createUniqueName(xElements,sPersistentName);
 251
 252             const bool bNeedClassID = !aClassID.hasElements() && sURL.isEmpty() ;
 253             if ( xCopyFrom.is() )
 254             {
 255                 Sequence<Any> aIni{ Any(getContainerStorage()), Any(sPersistentName) };
 256                 Command aCommand;
 257                 aCommand.Name = "copyTo";
 258                 aCommand.Argument <<= aIni;
 259
 260                 xCopyFrom->execute(aCommand,-1,Reference< XCommandEnvironment >());
 261                 Reference<XPropertySet> xProp(xCopyFrom,UNO_QUERY);
 262                 if ( xProp.is() && xProp->getPropertySetInfo().is() && xProp->getPropertySetInfo()->hasPropertyByName(PROPERTY_AS_TEMPLATE) )
 263                     xProp->getPropertyValue(PROPERTY_AS_TEMPLATE) >>= bAsTemplate;
 264
 265                 // if we do not have an own class ID, see if we can determine one from the copy we just created
 266                 if ( bNeedClassID )
 267                     ODocumentDefinition::GetDocumentServiceFromMediaType( getContainerStorage(), sPersistentName, m_aContext, aClassID );
 268             }
 269             else
 270             {
 271                 if ( bNeedClassID )
 272                 {
 273                     if ( !sMediaType.isEmpty() )
 274                         ODocumentDefinition::GetDocumentServiceFromMediaType( sMediaType, m_aContext, aClassID );
 275                     else if ( !sDocServiceName.isEmpty() )
 276                     {
 277                         ::comphelper::MimeConfigurationHelper aConfigHelper( m_aContext );
 278                         const Sequence< NamedValue > aProps( aConfigHelper.GetObjectPropsByDocumentName( sDocServiceName ) );
 279                         const ::comphelper::NamedValueCollection aMediaTypeProps( aProps );
 280                         aClassID = aMediaTypeProps.getOrDefault( u"ClassID"_ustr, Sequence< sal_Int8 >() );
 281                     }
 282                 }
 283             }
 284         }
 285
 286         ODefinitionContainer_Impl::const_iterator aFind = rDefinitions.find( sName );
 287         TContentPtr pElementImpl;
 288         if ( bNew || ( aFind == rDefinitions.end() ) )
 289         {
 290             pElementImpl = std::make_shared<OContentHelper_Impl>();
 291             if ( !bNew )
 292                 pElementImpl->m_aProps.aTitle = sName;
 293
 294             pElementImpl->m_aProps.sPersistentName = sPersistentName;
 295             pElementImpl->m_aProps.bAsTemplate = bAsTemplate;
 296             pElementImpl->m_pDataSource = m_pImpl->m_pDataSource;
 297         }
 298         else
 299             pElementImpl = aFind->second;
 300
 301         ::rtl::Reference< ODocumentDefinition > pDocDef = new ODocumentDefinition( *this, m_aContext, pElementImpl, m_bFormsContainer );
 302         if ( aClassID.hasElements() )
 303         {
 304             pDocDef->initialLoad( aClassID, aCreationArgs, xConnection );
 305         }
 306         else
 307         {
 308             OSL_ENSURE( !aCreationArgs.hasElements(), "ODocumentContainer::createInstance: additional creation args are lost, if you do not provide a class ID." );
 309         }
 310         xContent = pDocDef.get();
 311
 312         if ( !sURL.isEmpty() )
 313         {
 314             Sequence<Any> aIni{ Any(sURL) };
 315             Command aCommand;
 316             aCommand.Name = "insert";
 317             aCommand.Argument <<= aIni;
 318             Reference< XCommandProcessor > xCommandProcessor(xContent,UNO_QUERY);
 319             if ( xContent.is() )
 320             {
 321                 xCommandProcessor->execute(aCommand,-1,Reference< XCommandEnvironment >());
 322             }
 323         }
 324     }
 325     else if ( ServiceSpecifier == SERVICE_NAME_FORM_COLLECTION || SERVICE_NAME_REPORT_COLLECTION == ServiceSpecifier )
 326     {
 327         OUString sName;
 328         Reference<XNameAccess> xCopyFrom;
 329         for (auto& arg : _aArguments)
 330         {
 331             PropertyValue aValue;
 332             arg >>= aValue;
 333             if ( aValue.Name == PROPERTY_NAME)
 334             {
 335                 aValue.Value >>= sName;
 336             }
 337             else if ( aValue.Name == PROPERTY_EMBEDDEDOBJECT)
 338             {
 339                 xCopyFrom.set(aValue.Value,UNO_QUERY);
 340             }
 341         }
 342         OSL_ENSURE(!sName.isEmpty(),"Invalid name for a document container!");
 343         const ODefinitionContainer_Impl& rDefinitions( getDefinitions() );
 344         ODefinitionContainer_Impl::const_iterator aFind = rDefinitions.find( sName );
 345         TContentPtr pElementImpl;
 346         if ( aFind == rDefinitions.end() )
 347         {
 348             pElementImpl = std::make_shared<ODefinitionContainer_Impl>();
 349             pElementImpl->m_aProps.aTitle = sName;
 350             pElementImpl->m_pDataSource = m_pImpl->m_pDataSource;
 351         }
 352         else
 353             pElementImpl = aFind->second;
 354         OSL_ENSURE( pElementImpl ," Invalid entry in map!");
 355         xContent = new ODocumentContainer( m_aContext, *this, pElementImpl, ServiceSpecifier == SERVICE_NAME_FORM_COLLECTION );
 356
 357         // copy children
 358         if ( xCopyFrom.is() )
 359         {
 360             Reference<XContent> xObjectToCopy;
 361
 362             Reference<XMultiServiceFactory> xORB(xContent,UNO_QUERY);
 363             OSL_ENSURE(xORB.is(),"No service factory given");
 364             if ( xORB.is() )
 365             {
 366                 for (auto& element : xCopyFrom->getElementNames())
 367                 {
 368                     xCopyFrom->getByName(element) >>= xObjectToCopy;
 369                     Sequence<Any> aArguments(comphelper::InitAnyPropertySequence(
 370                     {
 371                         {"Name", Any(element)}, // set as folder
 372                         {"Parent", Any(xContent)},
 373                         {PROPERTY_EMBEDDEDOBJECT, Any(xObjectToCopy)},
 374                     }));
 375
 376                     OUString sServiceName;
 377                     if ( Reference< XNameAccess >( xObjectToCopy, UNO_QUERY ).is() )
 378                     {
 379                         if ( m_bFormsContainer )
 380                             sServiceName = SERVICE_NAME_FORM_COLLECTION;
 381                         else
 382                             sServiceName = SERVICE_NAME_REPORT_COLLECTION;
 383                     }
 384                     else
 385                         sServiceName = SERVICE_SDB_DOCUMENTDEFINITION;
 386
 387                     Reference<XContent > xNew(xORB->createInstanceWithArguments(sServiceName,aArguments),UNO_QUERY);
 388                     Reference<XNameContainer> xNameContainer(xContent,UNO_QUERY);
 389                     if ( xNameContainer.is() )
 390                         xNameContainer->insertByName(element, Any(xNew));
 391                 }
 392             }
 393         }
 394     }
 395     xRet = xContent;
 396     return xRet;
 397 }
 398
 399 Sequence< OUString > SAL_CALL ODocumentContainer::getAvailableServiceNames(  )
 400 {
 401     return
 402     {
 403         SERVICE_SDB_DOCUMENTDEFINITION,
 404         SERVICE_NAME_FORM_COLLECTION,
 405         SERVICE_NAME_REPORT_COLLECTION
 406     };
 407 }
 408
 409 Any SAL_CALL ODocumentContainer::execute( const Command& aCommand, sal_Int32 CommandId, const Reference< XCommandEnvironment >& Environment )
 410 {
 411     Any aRet;
 412     if ( aCommand.Name == "open" )
 413     {
 414         // open command for a folder content
 415         OpenCommandArgument2 aOpenCommand;
 416         if ( !( aCommand.Argument >>= aOpenCommand ) )
 417         {
 418             OSL_FAIL( "Wrong argument type!" );
 419             ucbhelper::cancelCommandExecution(
 420                 Any( IllegalArgumentException(
 421                                     OUString(),
 422                                     static_cast< cppu::OWeakObject * >( this ),
 423                                     -1 ) ),
 424                 Environment );
 425             // Unreachable
 426         }
 427         bool bOpenFolder =
 428             ( ( aOpenCommand.Mode == OpenMode::ALL ) ||
 429               ( aOpenCommand.Mode == OpenMode::FOLDERS ) ||
 430               ( aOpenCommand.Mode == OpenMode::DOCUMENTS ) );
 431
 432         if ( bOpenFolder )
 433         {
 434             // open as folder - return result set
 435
 436             Reference< XDynamicResultSet > xSet
 437                             = new DynamicResultSet( m_aContext,
 438                                                     this,
 439                                                     aOpenCommand,
 440                                                     Environment );
 441             aRet <<= xSet;
 442         }
 443         else
 444         {
 445             // Unsupported.
 446             ucbhelper::cancelCommandExecution(
 447                 Any( UnsupportedOpenModeException(
 448                                 OUString(),
 449                                 static_cast< cppu::OWeakObject * >( this ),
 450                                 sal_Int16( aOpenCommand.Mode ) ) ),
 451                 Environment );
 452                 // Unreachable
 453         }
 454     }
 455     else if ( aCommand.Name == "insert" )
 456     {
 457         // insert
 458
 459         InsertCommandArgument arg;
 460         if ( !( aCommand.Argument >>= arg ) )
 461         {
 462             OSL_FAIL( "Wrong argument type!" );
 463             ucbhelper::cancelCommandExecution(
 464                 Any( IllegalArgumentException(
 465                                     OUString(),
 466                                     static_cast< cppu::OWeakObject * >( this ),
 467                                     -1 ) ),
 468                 Environment );
 469             // Unreachable
 470         }
 471     }
 472     else if ( aCommand.Name == "delete" )
 473     {
 474         // delete
 475         for (auto& name : getElementNames())
 476             removeByName(name);
 477
 478         dispose();
 479     }
 480     else
 481         aRet = OContentHelper::execute(aCommand,CommandId,Environment);
 482     return aRet;
 483 }
 484
 485 namespace
 486 {
 487     bool lcl_queryContent(std::u16string_view _sName,Reference< XNameContainer >& _xNameContainer,Any& _rRet,OUString& _sSimpleName)
 488     {
 489         sal_Int32 nIndex = 0;
 490         OUString sName( o3tl::getToken(_sName,0,'/',nIndex) );
 491         bool bRet = _xNameContainer->hasByName(sName);
 492         if ( bRet )
 493         {
 494             _sSimpleName = sName;
 495             _rRet = _xNameContainer->getByName(_sSimpleName);
 496             while ( nIndex != -1 && bRet )
 497             {
 498                 sName = o3tl::getToken(_sName,0,'/',nIndex);
 499                 _xNameContainer.set(_rRet,UNO_QUERY);
 500                 bRet = _xNameContainer.is();
 501                 if ( bRet )
 502                 {
 503                     bRet = _xNameContainer->hasByName(sName);
 504                     _sSimpleName = sName;
 505                     if ( bRet )
 506                         _rRet = _xNameContainer->getByName(sName);
 507                 }
 508             }
 509         }
 510         if ( nIndex == -1 )
 511             _sSimpleName = sName; // a content
 512         else
 513             _xNameContainer.clear(); // a sub folder doesn't exist
 514         return bRet;
 515     }
 516 }
 517
 518 Reference< XComponent > SAL_CALL ODocumentContainer::loadComponentFromURL( const OUString& _sURL
 519                                                                        , const OUString& /*TargetFrameName*/
 520                                                                        , sal_Int32 /*SearchFlags*/
 521                                                                        , const Sequence< PropertyValue >& Arguments )
 522 {
 523     ::SolarMutexGuard aSolarGuard;
 524
 525     MutexGuard aGuard(m_aMutex);
 526     Reference< XComponent > xComp;
 527     try
 528     {
 529         Any aContent;
 530         Reference< XNameContainer > xNameContainer(this);
 531         OUString sName;
 532         if ( !lcl_queryContent(_sURL,xNameContainer,aContent,sName) )
 533         {
 534             OUString sMessage(
 535                 DBA_RES(RID_STR_NAME_NOT_FOUND).replaceFirst("$name$", _sURL));
 536             throw IllegalArgumentException( sMessage, *this, 1 );
 537         }
 538
 539         Reference< XCommandProcessor > xContent(aContent,UNO_QUERY);
 540         if ( xContent.is() )
 541         {
 542             Command aCommand;
 543
 544             ::comphelper::NamedValueCollection aArgs( Arguments );
 545             aCommand.Name = aArgs.getOrDefault( u"OpenMode"_ustr, u"open"_ustr );
 546             aArgs.remove( u"OpenMode"_ustr );
 547
 548             OpenCommandArgument2 aOpenCommand;
 549             aOpenCommand.Mode = OpenMode::DOCUMENT;
 550             aArgs.put( u"OpenCommandArgument"_ustr, aOpenCommand );
 551
 552             aCommand.Argument <<= aArgs.getPropertyValues();
 553             xComp.set(xContent->execute(aCommand,xContent->createCommandIdentifier(),Reference< XCommandEnvironment >()),UNO_QUERY);
 554         }
 555     }
 556     catch(const NoSuchElementException&)
 557     {
 558         throw IllegalArgumentException();
 559     }
 560     catch(const WrappedTargetException &e)
 561     {
 562         throw WrappedTargetRuntimeException(e.Message, e.Context, e.TargetException);
 563     }
 564     return xComp;
 565 }
 566
 567 Any SAL_CALL ODocumentContainer::getByHierarchicalName( const OUString& _sName )
 568 {
 569     MutexGuard aGuard(m_aMutex);
 570     Any aContent;
 571     Reference< XNameContainer > xNameContainer(this);
 572     OUString sName;
 573     if ( lcl_queryContent(_sName,xNameContainer,aContent,sName) )
 574         return aContent;
 575     throw NoSuchElementException(_sName,*this);
 576 }
 577
 578 sal_Bool SAL_CALL ODocumentContainer::hasByHierarchicalName( const OUString& _sName )
 579 {
 580     MutexGuard aGuard(m_aMutex);
 581     Any aContent;
 582     Reference< XNameContainer > xNameContainer(this);
 583     OUString sName;
 584     return lcl_queryContent(_sName,xNameContainer,aContent,sName);
 585 }
 586
 587 // XHierarchicalNameContainer
 588 void SAL_CALL ODocumentContainer::insertByHierarchicalName( const OUString& _sName, const Any& _aElement )
 589 {
 590     Reference< XContent > xContent(_aElement,UNO_QUERY);
 591     if ( !xContent.is() )
 592         throw IllegalArgumentException();
 593
 594     MutexGuard aGuard(m_aMutex);
 595     Any aContent;
 596     Reference< XNameContainer > xNameContainer(this);
 597     OUString sName;
 598     if ( lcl_queryContent(_sName,xNameContainer,aContent,sName) )
 599         throw ElementExistException(_sName,*this);
 600
 601     if ( !xNameContainer.is() )
 602     {
 603         sal_Int32 index = sName.getLength();
 604         OUString sMessage(
 605             DBA_RES(RID_STR_NO_SUB_FOLDER).replaceFirst("$folder$",
 606                 o3tl::getToken(_sName, 0,'/',index)));
 607         throw IllegalArgumentException( sMessage, *this, 1 );
 608     }
 609
 610     xNameContainer->insertByName(sName,_aElement);
 611 }
 612
 613 void SAL_CALL ODocumentContainer::removeByHierarchicalName( const OUString& _sName )
 614 {
 615     if ( _sName.isEmpty() )
 616         throw NoSuchElementException(_sName,*this);
 617
 618     MutexGuard aGuard(m_aMutex);
 619     Any aContent;
 620     OUString sName;
 621     Reference< XNameContainer > xNameContainer(this);
 622     if ( !lcl_queryContent(_sName,xNameContainer,aContent,sName) )
 623         throw NoSuchElementException(_sName,*this);
 624
 625     xNameContainer->removeByName(sName);
 626 }
 627
 628 // XHierarchicalNameReplace
 629 void SAL_CALL ODocumentContainer::replaceByHierarchicalName( const OUString& _sName, const Any& _aElement )
 630 {
 631     Reference< XContent > xContent(_aElement,UNO_QUERY);
 632     if ( !xContent.is() )
 633         throw IllegalArgumentException();
 634
 635     MutexGuard aGuard(m_aMutex);
 636     Any aContent;
 637     OUString sName;
 638     Reference< XNameContainer > xNameContainer(this);
 639     if ( !lcl_queryContent(_sName,xNameContainer,aContent,sName) )
 640         throw NoSuchElementException(_sName,*this);
 641
 642     xNameContainer->replaceByName(sName,_aElement);
 643 }
 644
 645 OUString SAL_CALL ODocumentContainer::getHierarchicalName()
 646 {
 647     ::osl::MutexGuard aGuard( m_aMutex );
 648     return impl_getHierarchicalName( false );
 649 }
 650
 651 OUString SAL_CALL ODocumentContainer::composeHierarchicalName( const OUString& i_rRelativeName )
 652 {
 653     OUString aBuffer = getHierarchicalName() + "/" + i_rRelativeName;
 654     return aBuffer;
 655 }
 656
 657 ::rtl::Reference<OContentHelper> ODocumentContainer::getContent(const OUString& _sName) const
 658 {
 659     ::rtl::Reference<OContentHelper> pContent;
 660     try
 661     {
 662         pContent = dynamic_cast<OContentHelper*>(const_cast<ODocumentContainer*>(this)->implGetByName( _sName, true ).get());
 663     }
 664     catch(const Exception&)
 665     {
 666     }
 667     return pContent;
 668 }
 669
 670 void ODocumentContainer::getPropertyDefaultByHandle( sal_Int32 /*_nHandle*/, Any& _rDefault ) const
 671 {
 672     _rDefault.clear();
 673 }
 674
 675 void SAL_CALL ODocumentContainer::commit(  )
 676 {
 677     MutexGuard aGuard(m_aMutex);
 678     for (auto const& elem : m_aDocumentMap)
 679     {
 680         Reference<XTransactedObject> xTrans(elem.second.get(),UNO_QUERY);
 681         if ( xTrans.is() )
 682             xTrans->commit();
 683     }
 684     Reference<XTransactedObject> xTrans(getContainerStorage(),UNO_QUERY);
 685     if ( xTrans.is() )
 686         xTrans->commit();
 687 }
 688
 689 void SAL_CALL ODocumentContainer::revert(  )
 690 {
 691     MutexGuard aGuard(m_aMutex);
 692     for (auto const& elem : m_aDocumentMap)
 693     {
 694         Reference<XTransactedObject> xTrans(elem.second.get(),UNO_QUERY);
 695         if ( xTrans.is() )
 696             xTrans->revert();
 697     }
 698     Reference<XTransactedObject> xTrans(getContainerStorage(),UNO_QUERY);
 699     if ( xTrans.is() )
 700         xTrans->revert();
 701 }
 702
 703 Reference< XStorage> ODocumentContainer::getContainerStorage() const
 704 {
 705     return  m_pImpl->m_pDataSource
 706         ?   m_pImpl->m_pDataSource->getStorage( m_bFormsContainer ? ODatabaseModelImpl::ObjectType::Form : ODatabaseModelImpl::ObjectType::Report )
 707         :   Reference< XStorage>();
 708 }
 709
 710 void SAL_CALL ODocumentContainer::removeByName( const OUString& _rName )
 711 {
 712     ResettableMutexGuard aGuard(m_aMutex);
 713
 714     // check the arguments
 715     if (_rName.isEmpty())
 716         throw IllegalArgumentException();
 717
 718     if (!checkExistence(_rName))
 719         throw NoSuchElementException(_rName,*this);
 720
 721     Reference< XCommandProcessor > xContent( implGetByName( _rName, true ), UNO_QUERY );
 722     if ( xContent.is() )
 723     {
 724         Command aCommand;
 725
 726         aCommand.Name = "delete";
 727         xContent->execute(aCommand,xContent->createCommandIdentifier(),Reference< XCommandEnvironment >());
 728     }
 729
 730     // do the removal
 731     implRemove(_rName);
 732
 733     notifyByName( aGuard, _rName, nullptr, nullptr, E_REMOVED, ContainerListemers );
 734 }
 735
 736 void SAL_CALL ODocumentContainer::rename( const OUString& newName )
 737 {
 738     try
 739     {
 740         osl::ClearableGuard< osl::Mutex > aGuard(m_aMutex);
 741         if ( newName == m_pImpl->m_aProps.aTitle )
 742             return;
 743
 744         sal_Int32 nHandle = PROPERTY_ID_NAME;
 745         Any aOld(m_pImpl->m_aProps.aTitle);
 746         Any aNew(newName);
 747
 748         aGuard.clear();
 749         fire(&nHandle, &aNew, &aOld, 1, true );
 750         m_pImpl->m_aProps.aTitle = newName;
 751         fire(&nHandle, &aNew, &aOld, 1, false );
 752     }
 753     catch(const PropertyVetoException&)
 754     {
 755         throw ElementExistException(newName,*this);
 756     }
 757 }
 758
 759 }   // namespace dbaccess
 760
 761 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */