dbaccess/source/core/dataaccess/definitioncontainer.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: definitioncontainer.cxx,v $
  10  * $Revision: 1.26 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_dbaccess.hxx"
  33
  34 #ifndef _DBA_CORE_DEFINITIONCONTAINER_HXX_
  35 #include "definitioncontainer.hxx"
  36 #endif
  37 #ifndef DBACCESS_SHARED_DBASTRINGS_HRC
  38 #include "dbastrings.hrc"
  39 #endif
  40 #ifndef _DBASHARED_APITOOLS_HXX_
  41 #include "apitools.hxx"
  42 #endif
  43 #ifndef _DBA_CORE_RESOURCE_HXX_
  44 #include "core_resource.hxx"
  45 #endif
  46 #ifndef _DBA_CORE_RESOURCE_HRC_
  47 #include "core_resource.hrc"
  48 #endif
  49
  50 #ifndef _TOOLS_DEBUG_HXX
  51 #include <tools/debug.hxx>
  52 #endif
  53 #ifndef TOOLS_DIAGNOSE_EX_H
  54 #include <tools/diagnose_ex.h>
  55 #endif
  56 #ifndef _COMPHELPER_SEQUENCE_HXX_
  57 #include <comphelper/sequence.hxx>
  58 #endif
  59 #ifndef _COMPHELPER_ENUMHELPER_HXX_
  60 #include <comphelper/enumhelper.hxx>
  61 #endif
  62 #ifndef _COMPHELPER_EXTRACT_HXX_
  63 #include <comphelper/extract.hxx>
  64 #endif
  65 #ifndef _COM_SUN_STAR_LANG_XCOMPONENT_HPP_
  66 #include <com/sun/star/lang/XComponent.hpp>
  67 #endif
  68 #ifndef _COM_SUN_STAR_UCB_COMMANDINFO_HPP_
  69 #include <com/sun/star/ucb/CommandInfo.hpp>
  70 #endif
  71 #ifndef _COM_SUN_STAR_BEANS_XPROPERTYSET_HPP_
  72 #include <com/sun/star/beans/XPropertySet.hpp>
  73 #endif
  74 #ifndef _COM_SUN_STAR_SDB_ERRORCONDITION_HPP_
  75 #include <com/sun/star/sdb/ErrorCondition.hpp>
  76 #endif
  77 #ifndef _COMPHELPER_TYPES_HXX_
  78 #include <comphelper/types.hxx>
  79 #endif
  80 #ifndef _UCBHELPER_CONTENTIDENTIFIER_HXX
  81 #include <ucbhelper/contentidentifier.hxx>
  82 #endif
  83
  84
  85 using namespace ::com::sun::star::uno;
  86 using namespace ::com::sun::star::lang;
  87 using namespace ::com::sun::star::util;
  88 using namespace ::com::sun::star::beans;
  89 using namespace ::com::sun::star::container;
  90 using namespace ::com::sun::star::sdbcx;
  91 using namespace ::com::sun::star::sdb;
  92 using namespace ::osl;
  93 using namespace ::comphelper;
  94 using namespace ::cppu;
  95 using namespace ::com::sun::star::ucb;
  96
  97 //........................................................................
  98 namespace dbaccess
  99 {
 100 //........................................................................
 101
 102 //==========================================================================
 103 //= ODefinitionContainer_Impl
 104 //==========================================================================
 105 //--------------------------------------------------------------------------
 106 void ODefinitionContainer_Impl::erase( TContentPtr _pDefinition )
 107 {
 108     NamedDefinitions::iterator aPos = find( _pDefinition );
 109     if ( aPos != end() )
 110         m_aDefinitions.erase( aPos );
 111 }
 112
 113 //--------------------------------------------------------------------------
 114 ODefinitionContainer_Impl::const_iterator ODefinitionContainer_Impl::find( TContentPtr _pDefinition ) const
 115 {
 116     return ::std::find_if(
 117         m_aDefinitions.begin(),
 118         m_aDefinitions.end(),
 119         ::std::compose1(
 120             ::std::bind2nd( ::std::equal_to< TContentPtr >(), _pDefinition ),
 121             ::std::select2nd< NamedDefinitions::value_type >()
 122         )
 123     );
 124 }
 125
 126 //--------------------------------------------------------------------------
 127 ODefinitionContainer_Impl::iterator ODefinitionContainer_Impl::find( TContentPtr _pDefinition )
 128 {
 129     return ::std::find_if(
 130         m_aDefinitions.begin(),
 131         m_aDefinitions.end(),
 132         ::std::compose1(
 133             ::std::bind2nd( ::std::equal_to< TContentPtr >(), _pDefinition ),
 134             ::std::select2nd< NamedDefinitions::value_type >()
 135         )
 136     );
 137 }
 138
 139 //==========================================================================
 140 //= ODefinitionContainer
 141 //==========================================================================
 142 DBG_NAME(ODefinitionContainer)
 143 //--------------------------------------------------------------------------
 144 ODefinitionContainer::ODefinitionContainer(   const Reference< XMultiServiceFactory >& _xORB
 145                                             , const Reference< XInterface >&    _xParentContainer
 146                                             , const TContentPtr& _pImpl
 147                                             , bool _bCheckSlash
 148                                             )
 149     :OContentHelper(_xORB,_xParentContainer,_pImpl)
 150     ,m_aApproveListeners(m_aMutex)
 151     ,m_aContainerListeners(m_aMutex)
 152     ,m_bInPropertyChange(sal_False)
 153     ,m_bCheckSlash(_bCheckSlash)
 154 {
 155     m_pImpl->m_aProps.bIsDocument = sal_False;
 156     m_pImpl->m_aProps.bIsFolder = sal_True;
 157
 158     const ODefinitionContainer_Impl& rDefinitions( getDefinitions() );
 159     ODefinitionContainer_Impl::const_iterator aEnd = rDefinitions.end();
 160     for (       ODefinitionContainer_Impl::const_iterator aDefinition = rDefinitions.begin();
 161             aDefinition != aEnd;
 162             ++aDefinition
 163         )
 164         m_aDocuments.push_back(
 165             m_aDocumentMap.insert(
 166                 Documents::value_type( aDefinition->first, Documents::mapped_type() ) ).first );
 167
 168     DBG_CTOR(ODefinitionContainer, NULL);
 169 }
 170
 171 //--------------------------------------------------------------------------
 172 void SAL_CALL ODefinitionContainer::disposing()
 173 {
 174     OContentHelper::disposing();
 175
 176     MutexGuard aGuard(m_aMutex);
 177
 178     // say our listeners goobye
 179     EventObject aEvt(*this);
 180     m_aApproveListeners.disposeAndClear(aEvt);
 181     m_aContainerListeners.disposeAndClear(aEvt);
 182
 183     // dispose our elements
 184     Documents::iterator aIter = m_aDocumentMap.begin();
 185     Documents::iterator aEnd = m_aDocumentMap.end();
 186
 187     for (; aIter != aEnd; ++aIter)
 188     {
 189         Reference<XContent> xProp = aIter->second;
 190         if ( xProp.is() )
 191         {
 192             removeObjectListener(xProp);
 193             ::comphelper::disposeComponent(xProp);
 194         }
 195     }
 196
 197     // remove our elements
 198     m_aDocuments.clear();
 199     //  !!! do this before clearing the map which the vector elements refer to !!!
 200     m_aDocumentMap.clear();
 201 }
 202
 203 //--------------------------------------------------------------------------
 204 ODefinitionContainer::~ODefinitionContainer()
 205 {
 206     DBG_DTOR(ODefinitionContainer, NULL);
 207 }
 208
 209 IMPLEMENT_FORWARD_XINTERFACE2( ODefinitionContainer,OContentHelper,ODefinitionContainer_Base)
 210 IMPLEMENT_TYPEPROVIDER2(ODefinitionContainer,OContentHelper,ODefinitionContainer_Base);
 211 // XServiceInfo
 212 //--------------------------------------------------------------------------
 213 ::rtl::OUString SAL_CALL ODefinitionContainer::getImplementationName(  ) throw(RuntimeException)
 214 {
 215     return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sdb.ODefinitionContainer"));
 216 }
 217 //--------------------------------------------------------------------------
 218 Sequence< ::rtl::OUString > SAL_CALL ODefinitionContainer::getSupportedServiceNames(  ) throw(RuntimeException)
 219 {
 220     Sequence< ::rtl::OUString > aReturn(2);
 221     aReturn.getArray()[0] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sdb.DefinitionContainer"));
 222     aReturn.getArray()[1] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.ucb.Content"));
 223     return aReturn;
 224 }
 225
 226 // XNameContainer
 227 //--------------------------------------------------------------------------
 228 void SAL_CALL ODefinitionContainer::insertByName( const ::rtl::OUString& _rName, const Any& aElement ) throw(IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException)
 229 {
 230     ResettableMutexGuard aGuard(m_aMutex);
 231
 232     // approve the new object
 233     Reference< XContent > xNewElement(aElement,UNO_QUERY);
 234     approveNewObject( _rName, xNewElement );  // will throw if necessary
 235
 236     notifyByName( aGuard, _rName, xNewElement, NULL, E_INSERTED, ApproveListeners );
 237     implAppend( _rName, xNewElement );
 238     notifyByName( aGuard, _rName, xNewElement, NULL, E_INSERTED, ContainerListemers );
 239 }
 240
 241 //--------------------------------------------------------------------------
 242 void SAL_CALL ODefinitionContainer::removeByName( const ::rtl::OUString& _rName ) throw(NoSuchElementException, WrappedTargetException, RuntimeException)
 243 {
 244     ResettableMutexGuard aGuard(m_aMutex);
 245
 246     // check the arguments
 247     if (!_rName.getLength())
 248         throw IllegalArgumentException();
 249
 250     if (!checkExistence(_rName))
 251         throw NoSuchElementException(_rName,*this);
 252
 253     // the old element (for the notifications)
 254     Reference< XContent > xOldElement = implGetByName( _rName, impl_haveAnyListeners_nothrow() );
 255
 256     // do the removal
 257     notifyByName( aGuard, _rName, NULL, xOldElement, E_REMOVED, ApproveListeners );
 258     implRemove( _rName );
 259     notifyByName( aGuard, _rName, NULL, xOldElement, E_REMOVED, ContainerListemers );
 260
 261     removeObjectListener( xOldElement );
 262     disposeComponent(xOldElement);
 263 }
 264
 265 // XNameReplace
 266 //--------------------------------------------------------------------------
 267 void SAL_CALL ODefinitionContainer::replaceByName( const ::rtl::OUString& _rName, const Any& aElement ) throw(IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException)
 268 {
 269     ResettableMutexGuard aGuard(m_aMutex);
 270
 271     // let derived classes approve the new object
 272     Reference< XContent > xNewElement(aElement,UNO_QUERY);
 273     approveNewObject( _rName, xNewElement );    // will throw if necessary
 274
 275     // the old element (for the notifications)
 276     Reference< XContent > xOldElement = implGetByName( _rName, impl_haveAnyListeners_nothrow() );
 277
 278     notifyByName( aGuard, _rName, xNewElement, xOldElement, E_REPLACED, ApproveListeners );
 279     implReplace( _rName, xNewElement );
 280     notifyByName( aGuard, _rName, xNewElement, xOldElement, E_REPLACED, ContainerListemers );
 281
 282     // and dispose it
 283     disposeComponent(xOldElement);
 284 }
 285
 286 // -----------------------------------------------------------------------------
 287 namespace
 288 {
 289     typedef Reference< XVeto > ( SAL_CALL XContainerApproveListener::*ContainerApprovalMethod )( const ContainerEvent& );
 290
 291     struct RaiseExceptionFromVeto
 292     {
 293     private:
 294         ContainerApprovalMethod m_pMethod;
 295         const ContainerEvent&   m_rEvent;
 296
 297     public:
 298         RaiseExceptionFromVeto( ContainerApprovalMethod _pMethod, const ContainerEvent& _rEvent )
 299             :m_pMethod( _pMethod )
 300             ,m_rEvent( _rEvent )
 301         {
 302         }
 303
 304         void operator()( const Reference< XContainerApproveListener >& _Listener ) const
 305         {
 306             Reference< XVeto > xVeto = (_Listener.get()->*m_pMethod)( m_rEvent );
 307             if ( !xVeto.is() )
 308                 return;
 309
 310             Any eVetoDetails = xVeto->getDetails();
 311
 312             IllegalArgumentException aIllegalArgumentError;
 313             if ( eVetoDetails >>= aIllegalArgumentError )
 314                 throw aIllegalArgumentError;
 315
 316             WrappedTargetException aWrappedError;
 317             if ( eVetoDetails >>= aWrappedError )
 318                 throw aWrappedError;
 319
 320             throw WrappedTargetException( xVeto->getReason(), _Listener.get(), eVetoDetails );
 321         }
 322     };
 323 }
 324
 325 // -----------------------------------------------------------------------------
 326 void ODefinitionContainer::notifyByName( ResettableMutexGuard& _rGuard, const ::rtl::OUString& _rName,
 327         const Reference< XContent >& _xNewElement, const Reference< XContent >& _xOldElement,
 328         ContainerOperation _eOperation, ListenerType _eType )
 329 {
 330     bool bApprove = ( _eType == ApproveListeners );
 331
 332     ::cppu::OInterfaceContainerHelper& rContainer( bApprove ? m_aApproveListeners : m_aContainerListeners );
 333     if ( !rContainer.getLength() )
 334         return;
 335
 336     ContainerEvent aEvent( *this, makeAny( _rName ), makeAny( _xNewElement ), makeAny( _xOldElement ) );
 337
 338     _rGuard.clear();
 339     switch ( _eOperation )
 340     {
 341         case E_INSERTED:
 342             if ( bApprove )
 343                 rContainer.forEach< XContainerApproveListener, RaiseExceptionFromVeto >(
 344                     RaiseExceptionFromVeto( &XContainerApproveListener::approveInsertElement, aEvent ) );
 345             else
 346                 rContainer.notifyEach( &XContainerListener::elementInserted, aEvent );
 347             break;
 348         case E_REPLACED:
 349             if ( bApprove )
 350                 rContainer.forEach< XContainerApproveListener, RaiseExceptionFromVeto >(
 351                     RaiseExceptionFromVeto( &XContainerApproveListener::approveReplaceElement, aEvent ) );
 352             else
 353                 rContainer.notifyEach( &XContainerListener::elementReplaced, aEvent );
 354             break;
 355         case E_REMOVED:
 356             if ( bApprove )
 357                 rContainer.forEach< XContainerApproveListener, RaiseExceptionFromVeto >(
 358                     RaiseExceptionFromVeto( &XContainerApproveListener::approveRemoveElement, aEvent ) );
 359             else
 360                 rContainer.notifyEach( &XContainerListener::elementRemoved, aEvent );
 361             break;
 362     }
 363
 364     if ( bApprove )
 365         _rGuard.reset();
 366 }
 367
 368 //--------------------------------------------------------------------------
 369 void SAL_CALL ODefinitionContainer::addContainerListener( const Reference< XContainerListener >& _rxListener ) throw(RuntimeException)
 370 {
 371     if (_rxListener.is())
 372         m_aContainerListeners.addInterface(_rxListener);
 373 }
 374
 375 //--------------------------------------------------------------------------
 376 void SAL_CALL ODefinitionContainer::removeContainerListener( const Reference< XContainerListener >& _rxListener ) throw(RuntimeException)
 377 {
 378     if (_rxListener.is())
 379         m_aContainerListeners.removeInterface(_rxListener);
 380 }
 381
 382 //--------------------------------------------------------------------------
 383 void SAL_CALL ODefinitionContainer::addContainerApproveListener( const Reference< XContainerApproveListener >& _Listener ) throw (RuntimeException)
 384 {
 385     if ( _Listener.is() )
 386         m_aApproveListeners.addInterface( _Listener );
 387 }
 388
 389 //--------------------------------------------------------------------------
 390 void SAL_CALL ODefinitionContainer::removeContainerApproveListener( const Reference< XContainerApproveListener >& _Listener ) throw (RuntimeException)
 391 {
 392     if ( _Listener.is() )
 393         m_aApproveListeners.removeInterface( _Listener );
 394 }
 395
 396
 397 // XElementAccess
 398 //--------------------------------------------------------------------------
 399 Type SAL_CALL ODefinitionContainer::getElementType( ) throw (RuntimeException)
 400 {
 401     return ::getCppuType( static_cast< Reference< XContent >* >(NULL) );
 402 }
 403
 404 //--------------------------------------------------------------------------
 405 sal_Bool SAL_CALL ODefinitionContainer::hasElements( ) throw (RuntimeException)
 406 {
 407     MutexGuard aGuard(m_aMutex);
 408     return !m_aDocuments.empty();
 409 }
 410
 411 // XEnumerationAccess
 412 //--------------------------------------------------------------------------
 413 Reference< XEnumeration > SAL_CALL ODefinitionContainer::createEnumeration(  ) throw(RuntimeException)
 414 {
 415     MutexGuard aGuard(m_aMutex);
 416     return new ::comphelper::OEnumerationByIndex(static_cast<XIndexAccess*>(this));
 417 }
 418
 419 //--------------------------------------------------------------------------
 420 // XIndexAccess
 421 sal_Int32 SAL_CALL ODefinitionContainer::getCount(  ) throw(RuntimeException)
 422 {
 423     MutexGuard aGuard(m_aMutex);
 424     return m_aDocuments.size();
 425 }
 426
 427 //--------------------------------------------------------------------------
 428 Any SAL_CALL ODefinitionContainer::getByIndex( sal_Int32 _nIndex ) throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException)
 429 {
 430     MutexGuard aGuard(m_aMutex);
 431
 432     if ((_nIndex < 0) || (_nIndex >= (sal_Int32)m_aDocuments.size()))
 433         throw IndexOutOfBoundsException();
 434
 435     Documents::iterator aPos = m_aDocuments[_nIndex];
 436     Reference<XContent> xProp = aPos->second;
 437     if (!xProp.is())
 438     {   // that's the first access to the object
 439         // -> create it
 440         xProp = createObject(aPos->first);
 441         aPos->second = Documents::mapped_type();
 442         // and update the name-access map
 443     }
 444
 445     return makeAny(xProp);
 446 }
 447
 448 //--------------------------------------------------------------------------
 449 Any SAL_CALL ODefinitionContainer::getByName( const ::rtl::OUString& _rName ) throw(NoSuchElementException, WrappedTargetException, RuntimeException)
 450 {
 451     MutexGuard aGuard(m_aMutex);
 452
 453     return makeAny( implGetByName( _rName, sal_True ) );
 454 }
 455
 456 //--------------------------------------------------------------------------
 457 Reference< XContent > ODefinitionContainer::implGetByName(const ::rtl::OUString& _rName, sal_Bool _bReadIfNeccessary) throw (NoSuchElementException)
 458 {
 459     Documents::iterator aMapPos = m_aDocumentMap.find(_rName);
 460     if (aMapPos == m_aDocumentMap.end())
 461         throw NoSuchElementException(_rName,*this);
 462
 463     Reference< XContent > xProp = aMapPos->second;
 464
 465     if (_bReadIfNeccessary && !xProp.is())
 466     {   // the object has never been accessed before, so we have to read it now
 467         // (that's the expensive part)
 468
 469         // create the object and insert it into the map
 470         xProp = createObject(_rName);
 471         aMapPos->second = xProp;
 472         addObjectListener(xProp);
 473     }
 474
 475     return xProp;
 476 }
 477
 478 //--------------------------------------------------------------------------
 479 Sequence< ::rtl::OUString > SAL_CALL ODefinitionContainer::getElementNames(  ) throw(RuntimeException)
 480 {
 481     MutexGuard aGuard(m_aMutex);
 482
 483     Sequence< ::rtl::OUString > aNames(m_aDocumentMap.size());
 484     ::rtl::OUString* pNames = aNames.getArray();
 485     Documents::iterator aEnd = m_aDocumentMap.end();
 486     for (       Documents::iterator aNameIter = m_aDocumentMap.begin();
 487             aNameIter != aEnd;
 488             ++pNames, ++aNameIter
 489         )
 490     {
 491         *pNames = aNameIter->first;
 492     }
 493
 494     return aNames;
 495 }
 496
 497 //--------------------------------------------------------------------------
 498 sal_Bool SAL_CALL ODefinitionContainer::hasByName( const ::rtl::OUString& _rName ) throw(RuntimeException)
 499 {
 500     MutexGuard aGuard(m_aMutex);
 501
 502     return checkExistence(_rName);
 503 }
 504
 505 //--------------------------------------------------------------------------
 506 void SAL_CALL ODefinitionContainer::disposing( const EventObject& _rSource ) throw(RuntimeException)
 507 {
 508     MutexGuard aGuard(m_aMutex);
 509     Reference< XContent > xSource(_rSource.Source, UNO_QUERY);
 510     // it's one of our documents ....
 511     Documents::iterator aIter = m_aDocumentMap.begin();
 512     Documents::iterator aEnd = m_aDocumentMap.end();
 513     for (;aIter != aEnd;++aIter )
 514     {
 515         if ( xSource == aIter->second.get() )
 516         {
 517             removeObjectListener(xSource);
 518             // and clear our document map/vector, so the object will be recreated on next access
 519             aIter->second = Documents::mapped_type();
 520         }
 521     }
 522 }
 523
 524 //--------------------------------------------------------------------------
 525 void ODefinitionContainer::implRemove(const ::rtl::OUString& _rName)
 526 {
 527     // from the object maps
 528     Documents::iterator aFind = m_aDocumentMap.find(_rName);
 529     if ( aFind != m_aDocumentMap.end() )
 530     {
 531         m_aDocuments.erase( ::std::find(m_aDocuments.begin(),m_aDocuments.end(),aFind));
 532         m_aDocumentMap.erase(aFind);
 533
 534         getDefinitions().erase( _rName );
 535
 536         notifyDataSourceModified();
 537     }
 538 }
 539
 540 //--------------------------------------------------------------------------
 541 namespace
 542 {
 543     bool    lcl_ensureName( const Reference< XContent >& _rxContent, const ::rtl::OUString& _rName )
 544     {
 545         if ( !_rxContent.is() )
 546             return true;
 547
 548         // ..........................................................
 549         // obtain the current name. If it's the same as the new one,
 550         // don't do anything
 551         try
 552         {
 553             Reference< XPropertySet > xProps( _rxContent, UNO_QUERY );
 554             if ( xProps.is() )
 555             {
 556                 ::rtl::OUString sCurrentName;
 557                 OSL_VERIFY( xProps->getPropertyValue( PROPERTY_NAME ) >>= sCurrentName );
 558                 if ( sCurrentName.equals( _rName ) )
 559                     return true;
 560             }
 561         }
 562         catch( const Exception& )
 563         {
 564             OSL_ENSURE( sal_False, "lcl_ensureName: caught an exception while obtaining the current name!" );
 565         }
 566
 567         // ..........................................................
 568         // set the new name
 569         Reference< XRename > xRename( _rxContent, UNO_QUERY );
 570         OSL_ENSURE( xRename.is(), "lcl_ensureName: invalid content (not renameable)!" );
 571         if ( !xRename.is() )
 572             return false;
 573         try
 574         {
 575             xRename->rename( _rName );
 576             return true;
 577         }
 578         catch( const Exception& )
 579         {
 580             OSL_ENSURE( sal_False, "lcl_ensureName: caught an exception!" );
 581         }
 582         return false;
 583     }
 584 }
 585 //--------------------------------------------------------------------------
 586 void ODefinitionContainer::implAppend(const ::rtl::OUString& _rName, const Reference< XContent >& _rxNewObject)
 587 {
 588     MutexGuard aGuard(m_aMutex);
 589     try
 590     {
 591         Reference<XChild> xChild(_rxNewObject,UNO_QUERY);
 592         if ( xChild.is() )
 593             xChild->setParent(static_cast<OWeakObject*>(this));
 594
 595         ODefinitionContainer_Impl& rDefinitions( getDefinitions() );
 596         ODefinitionContainer_Impl::const_iterator aFind = rDefinitions.find( _rName );
 597         if ( aFind == rDefinitions.end() )
 598         {
 599             // ensure that the new object thas the proper name.
 600             // Somebody could create an object with name "foo", and insert it as "bar"
 601             // into a container. In this case, we need to ensure that the object name
 602             // is also "bar"
 603             // #i44786# / 2005-03-11 / frank.schoenheit@sun.com
 604             lcl_ensureName( _rxNewObject, _rName );
 605
 606             ::rtl::Reference< OContentHelper > pContent = OContentHelper::getImplementation( _rxNewObject );
 607             if ( pContent.is() )
 608             {
 609                 TContentPtr pImpl = pContent->getImpl();
 610                 rDefinitions.erase( pImpl );
 611                 pImpl->m_aProps.aTitle = _rName;
 612                 rDefinitions.insert( _rName, pImpl );
 613             }
 614         }
 615
 616
 617         m_aDocuments.push_back(m_aDocumentMap.insert(Documents::value_type(_rName,_rxNewObject)).first);
 618         notifyDataSourceModified();
 619         // now update our structures
 620         if ( _rxNewObject.is() )
 621             addObjectListener(_rxNewObject);
 622     }
 623     catch(Exception&)
 624     {
 625         DBG_ERROR("ODefinitionContainer::implAppend: caught something !");
 626     }
 627 }
 628
 629 //--------------------------------------------------------------------------
 630 void ODefinitionContainer::implReplace(const ::rtl::OUString& _rName, const Reference< XContent >& _rxNewObject)
 631 {
 632     DBG_ASSERT(checkExistence(_rName), "ODefinitionContainer::implReplace : invalid name !");
 633
 634     Documents::iterator aFind = m_aDocumentMap.find(_rName);
 635     removeObjectListener(aFind->second);
 636     aFind->second = _rxNewObject;
 637     addObjectListener(aFind->second);
 638 }
 639
 640 // -----------------------------------------------------------------------------
 641 void ODefinitionContainer::approveNewObject(const ::rtl::OUString& _sName,const Reference< XContent >& _rxObject) const
 642 {
 643     // check the arguments
 644     if ( !_sName.getLength() )
 645         throw IllegalArgumentException(
 646             DBA_RES( RID_STR_NAME_MUST_NOT_BE_EMPTY ),
 647             *this,
 648             0 );
 649
 650     if ( m_bCheckSlash && _sName.indexOf( '/' ) != -1 )
 651         throw IllegalArgumentException(
 652             m_aErrorHelper.getErrorMessage( ErrorCondition::DB_OBJECT_NAME_WITH_SLASHES ),
 653             *this,
 654             0 );
 655
 656     if ( !_rxObject.is() )
 657         throw IllegalArgumentException(
 658             DBA_RES( RID_STR_NO_NULL_OBJECTS_IN_CONTAINER ),
 659             *this,
 660             0 );
 661
 662     const ODefinitionContainer_Impl& rDefinitions( getDefinitions() );
 663     if ( rDefinitions.find( _sName ) != rDefinitions.end() )
 664         throw ElementExistException(
 665             DBA_RES( RID_STR_NAME_ALREADY_USED ),
 666             *this );
 667
 668     ::rtl::Reference< OContentHelper > pContent( OContentHelper::getImplementation( _rxObject ) );
 669     if ( !pContent.is() )
 670         throw IllegalArgumentException(
 671             DBA_RES( RID_STR_OBJECT_CONTAINER_MISMATCH ),
 672             *this,
 673             1 );
 674
 675     if ( rDefinitions.find( pContent->getImpl() ) != rDefinitions.end() )
 676         throw ElementExistException(
 677             DBA_RES( RID_STR_OBJECT_ALREADY_CONTAINED ),
 678             *this );
 679 }
 680
 681 // -----------------------------------------------------------------------------
 682 // XPropertyChangeListener
 683 void SAL_CALL ODefinitionContainer::propertyChange( const PropertyChangeEvent& evt ) throw (RuntimeException)
 684 {
 685     ClearableMutexGuard aGuard(m_aMutex);
 686     if(evt.PropertyName == (rtl::OUString) PROPERTY_NAME || evt.PropertyName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Title" ) ))
 687     {
 688         m_bInPropertyChange = sal_True;
 689         try
 690         {
 691             ::rtl::OUString sNewName,sOldName;
 692             evt.OldValue >>= sOldName;
 693             evt.NewValue >>= sNewName;
 694             Reference<XContent> xContent( evt.Source, UNO_QUERY );
 695             removeObjectListener( xContent );
 696             implRemove( sOldName );
 697             implAppend( sNewName, xContent );
 698         }
 699         catch(const Exception&)
 700         {
 701             DBG_UNHANDLED_EXCEPTION();
 702             throw RuntimeException();
 703         }
 704         m_bInPropertyChange = sal_False;
 705     }
 706 }
 707 // -----------------------------------------------------------------------------
 708 // XVetoableChangeListener
 709 void SAL_CALL ODefinitionContainer::vetoableChange( const PropertyChangeEvent& aEvent ) throw (PropertyVetoException, RuntimeException)
 710 {
 711     MutexGuard aGuard(m_aMutex);
 712
 713     if(aEvent.PropertyName == (rtl::OUString) PROPERTY_NAME || aEvent.PropertyName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Title" ) ) )
 714     {
 715         ::rtl::OUString sNewName;
 716         aEvent.NewValue >>= sNewName;
 717         if(hasByName(sNewName))
 718             throw PropertyVetoException();
 719     }
 720 }
 721 // -----------------------------------------------------------------------------
 722 void ODefinitionContainer::addObjectListener(const Reference< XContent >& _xNewObject)
 723 {
 724     OSL_ENSURE(_xNewObject.is(),"ODefinitionContainer::addObjectListener: Object is null!");
 725     Reference<XPropertySet> xProp(_xNewObject,UNO_QUERY);
 726     if ( xProp.is() )
 727     {
 728         xProp->addPropertyChangeListener(PROPERTY_NAME, this);
 729         xProp->addVetoableChangeListener(PROPERTY_NAME, this);
 730         //::rtl::OUString sTitle(RTL_CONSTASCII_USTRINGPARAM( "Title" ));
 731         //xProp->addPropertyChangeListener(sTitle, this);
 732         //xProp->addVetoableChangeListener(sTitle, this);
 733     } // if ( xProp.is() )
 734 }
 735 // -----------------------------------------------------------------------------
 736 void ODefinitionContainer::removeObjectListener(const Reference< XContent >& _xNewObject)
 737 {
 738     OSL_ENSURE(_xNewObject.is(),"ODefinitionContainer::addObjectListener: Object is null!");
 739     Reference<XPropertySet> xProp(_xNewObject,UNO_QUERY);
 740     if ( xProp.is() )
 741     {
 742         xProp->removePropertyChangeListener(PROPERTY_NAME, this);
 743         xProp->removeVetoableChangeListener(PROPERTY_NAME, this);
 744         //::rtl::OUString sTitle(RTL_CONSTASCII_USTRINGPARAM( "Title" ));
 745         //xProp->removePropertyChangeListener(sTitle, this);
 746         //xProp->removeVetoableChangeListener(sTitle, this);
 747     }
 748 }
 749 // -----------------------------------------------------------------------------
 750 sal_Bool ODefinitionContainer::checkExistence(const ::rtl::OUString& _rName)
 751 {
 752     return m_aDocumentMap.find(_rName) != m_aDocumentMap.end();
 753 }
 754
 755 //........................................................................
 756 }
 757 // namespace dbaccess
 758 //........................................................................