connectivity/source/sdbcx/VCollection.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29
  30 #include <algorithm>
  31 #include <stdio.h>
  32 #include "connectivity/sdbcx/VCollection.hxx"
  33 #include "connectivity/sdbcx/VDescriptor.hxx"
  34 #include "connectivity/dbexception.hxx"
  35 #include <comphelper/enumhelper.hxx>
  36 #include <comphelper/container.hxx>
  37 #include <comphelper/types.hxx>
  38 #include <comphelper/property.hxx>
  39 #include "TConnection.hxx"
  40 #include <rtl/ustrbuf.hxx>
  41 #include "resource/common_res.hrc"
  42 #include "resource/sharedresources.hxx"
  43
  44 using namespace connectivity::sdbcx;
  45 using namespace connectivity;
  46 using namespace comphelper;
  47 using namespace ::cppu;
  48 using namespace ::com::sun::star::beans;
  49 using namespace ::com::sun::star::uno;
  50 using namespace ::com::sun::star::lang;
  51 using namespace ::com::sun::star::sdbc;
  52 using namespace ::com::sun::star::container;
  53 using namespace ::com::sun::star::util;
  54
  55 namespace
  56 {
  57     template < typename T> class OHardRefMap : public connectivity::sdbcx::IObjectCollection
  58     {
  59         typedef ::std::multimap< ::rtl::OUString, T , ::comphelper::UStringMixLess> ObjectMap;
  60         typedef typename ObjectMap::iterator   ObjectIter;
  61         typedef typename ObjectMap::value_type ObjectEntry;
  62
  63     //  private:
  64         // this combination of map and vector is used to have a fast name and index access
  65         ::std::vector< ObjectIter >             m_aElements;        // hold the iterators which point to map
  66         ObjectMap                               m_aNameMap;         // hold the elements and a name
  67     public:
  68         OHardRefMap(sal_Bool _bCase)
  69             : m_aNameMap(_bCase ? true : false)
  70         {
  71         }
  72         virtual ~OHardRefMap()
  73         {
  74         }
  75
  76         virtual void reserve(size_t nLength)
  77         {
  78             m_aElements.reserve(nLength);
  79         }
  80         // -----------------------------------------------------------------------------
  81         virtual bool exists(const ::rtl::OUString& _sName )
  82         {
  83             return m_aNameMap.find(_sName) != m_aNameMap.end();
  84         }
  85         // -----------------------------------------------------------------------------
  86         virtual bool empty()
  87         {
  88             return m_aNameMap.empty();
  89         }
  90         // -----------------------------------------------------------------------------
  91         virtual void swapAll()
  92         {
  93             ::std::vector< ObjectIter >(m_aElements).swap(m_aElements);
  94             ObjectMap(m_aNameMap).swap(m_aNameMap);
  95         }
  96         // -----------------------------------------------------------------------------
  97         virtual void swap()
  98         {
  99             ::std::vector< ObjectIter >().swap(m_aElements);
 100
 101             OSL_ENSURE( m_aNameMap.empty(), "swap: what did disposeElements do?" );
 102             ObjectMap( m_aNameMap ).swap( m_aNameMap );
 103                 // Note that it's /important/ to construct the new ObjectMap from m_aNameMap before
 104                 // swapping. This way, it's ensured that the compare object held by these maps is preserved
 105                 // during the swap. If we would not do this, the UStringMixLess instance which is used would be
 106                 // default constructed (instead of being constructed from the same instance in m_aNameMap), and
 107                 // it's case-sensitive flag would have an unpredictable value.
 108         }
 109         // -----------------------------------------------------------------------------
 110         virtual void clear()
 111         {
 112             m_aElements.clear();
 113             m_aNameMap.clear();
 114         }
 115         // -----------------------------------------------------------------------------
 116         virtual void insert(const ::rtl::OUString& _sName,const ObjectType& _xObject)
 117         {
 118             m_aElements.push_back(m_aNameMap.insert(m_aNameMap.begin(), ObjectEntry(_sName,_xObject)));
 119         }
 120         // -----------------------------------------------------------------------------
 121         virtual void reFill(const TStringVector &_rVector)
 122         {
 123             OSL_ENSURE(!m_aNameMap.size(),"OCollection::reFill: collection isn't empty");
 124             m_aElements.reserve(_rVector.size());
 125
 126             for(TStringVector::const_iterator i=_rVector.begin(); i != _rVector.end();++i)
 127                 m_aElements.push_back(m_aNameMap.insert(m_aNameMap.begin(), ObjectEntry(*i,ObjectType())));
 128         }
 129         // -----------------------------------------------------------------------------
 130         virtual bool rename(const ::rtl::OUString _sOldName,const ::rtl::OUString _sNewName)
 131         {
 132             bool bRet = false;
 133             ObjectIter aIter = m_aNameMap.find(_sOldName);
 134             if ( aIter != m_aNameMap.end() )
 135             {
 136                 typename ::std::vector< ObjectIter >::iterator aFind = ::std::find(m_aElements.begin(),m_aElements.end(),aIter);
 137                 if(m_aElements.end() != aFind)
 138                 {
 139                     (*aFind) = m_aNameMap.insert(m_aNameMap.begin(), ObjectEntry(_sNewName,(*aFind)->second));
 140                     m_aNameMap.erase(aIter);
 141
 142                     bRet = true;
 143                 }
 144             }
 145             return bRet;
 146         }
 147         // -----------------------------------------------------------------------------
 148         virtual sal_Int32 size()
 149         {
 150             return static_cast<sal_Int32>(m_aNameMap.size());
 151         }
 152         // -----------------------------------------------------------------------------
 153         virtual Sequence< ::rtl::OUString > getElementNames()
 154         {
 155             Sequence< ::rtl::OUString > aNameList(m_aElements.size());
 156
 157             ::rtl::OUString* pStringArray = aNameList.getArray();
 158             typename ::std::vector< ObjectIter >::const_iterator aEnd = m_aElements.end();
 159             for(typename ::std::vector< ObjectIter >::const_iterator aIter = m_aElements.begin(); aIter != aEnd;++aIter,++pStringArray)
 160                 *pStringArray = (*aIter)->first;
 161
 162             return aNameList;
 163         }
 164         // -----------------------------------------------------------------------------
 165         virtual ::rtl::OUString getName(sal_Int32 _nIndex)
 166         {
 167             return m_aElements[_nIndex]->first;
 168         }
 169         // -----------------------------------------------------------------------------
 170         virtual void disposeAndErase(sal_Int32 _nIndex)
 171         {
 172             OSL_ENSURE(_nIndex >= 0 && _nIndex < static_cast<sal_Int32>(m_aElements.size()),"Illegal argument!");
 173             Reference<XComponent> xComp(m_aElements[_nIndex]->second.get(),UNO_QUERY);
 174             ::comphelper::disposeComponent(xComp);
 175             m_aElements[_nIndex]->second = T();
 176
 177             ::rtl::OUString sName = m_aElements[_nIndex]->first;
 178             m_aElements.erase(m_aElements.begin()+_nIndex);
 179             m_aNameMap.erase(sName);
 180         }
 181         // -----------------------------------------------------------------------------
 182         virtual void disposeElements()
 183         {
 184             for( ObjectIter aIter = m_aNameMap.begin(); aIter != m_aNameMap.end(); ++aIter)
 185             {
 186                 Reference<XComponent> xComp(aIter->second.get(),UNO_QUERY);
 187                 if ( xComp.is() )
 188                 {
 189                     ::comphelper::disposeComponent(xComp);
 190                     (*aIter).second = T();
 191                 }
 192             }
 193             m_aElements.clear();
 194             m_aNameMap.clear();
 195         }
 196         // -----------------------------------------------------------------------------
 197         virtual sal_Int32 findColumn( const ::rtl::OUString& columnName )
 198         {
 199             ObjectIter aIter = m_aNameMap.find(columnName);
 200             OSL_ENSURE(aIter != m_aNameMap.end(),"findColumn:: Illegal name!");
 201             return m_aElements.size() - (m_aElements.end() - ::std::find(m_aElements.begin(),m_aElements.end(),aIter));
 202         }
 203         // -----------------------------------------------------------------------------
 204         virtual ::rtl::OUString findColumnAtIndex(  sal_Int32 _nIndex)
 205         {
 206             OSL_ENSURE(_nIndex >= 0 && _nIndex < static_cast<sal_Int32>(m_aElements.size()),"Illegal argument!");
 207             return m_aElements[_nIndex]->first;
 208         }
 209         // -----------------------------------------------------------------------------
 210         virtual ObjectType getObject(sal_Int32 _nIndex)
 211         {
 212             OSL_ENSURE(_nIndex >= 0 && _nIndex < static_cast<sal_Int32>(m_aElements.size()),"Illegal argument!");
 213             return m_aElements[_nIndex]->second;
 214         }
 215         // -----------------------------------------------------------------------------
 216         virtual ObjectType getObject(const ::rtl::OUString& columnName)
 217         {
 218             return m_aNameMap.find(columnName)->second;
 219         }
 220         // -----------------------------------------------------------------------------
 221         virtual void setObject(sal_Int32 _nIndex,const ObjectType& _xObject)
 222         {
 223             OSL_ENSURE(_nIndex >= 0 && _nIndex < static_cast<sal_Int32>(m_aElements.size()),"Illegal argument!");
 224             m_aElements[_nIndex]->second = _xObject;
 225         }
 226         // -----------------------------------------------------------------------------
 227         sal_Bool isCaseSensitive() const
 228         {
 229             return m_aNameMap.key_comp().isCaseSensitive();
 230         }
 231         // -----------------------------------------------------------------------------
 232     };
 233 }
 234
 235 IObjectCollection::~IObjectCollection() {}
 236
 237 IMPLEMENT_SERVICE_INFO(OCollection,"com.sun.star.sdbcx.VContainer" , "com.sun.star.sdbcx.Container")
 238
 239 OCollection::OCollection(::cppu::OWeakObject& _rParent
 240                          , sal_Bool _bCase
 241                          , ::osl::Mutex& _rMutex
 242                          , const TStringVector &_rVector
 243                          , sal_Bool _bUseIndexOnly
 244                          , sal_Bool _bUseHardRef)
 245                      :m_aContainerListeners(_rMutex)
 246                      ,m_aRefreshListeners(_rMutex)
 247                      ,m_rParent(_rParent)
 248                      ,m_rMutex(_rMutex)
 249                      ,m_bUseIndexOnly(_bUseIndexOnly)
 250 {
 251     if ( _bUseHardRef )
 252     {
 253         m_pElements.reset(new OHardRefMap< ObjectType >(_bCase));
 254     }
 255     else
 256     {
 257         m_pElements.reset(new OHardRefMap< WeakReference< XPropertySet> >(_bCase));
 258     }
 259     m_pElements->reFill(_rVector);
 260 }
 261 // -------------------------------------------------------------------------
 262 OCollection::~OCollection()
 263 {
 264 }
 265 // -----------------------------------------------------------------------------
 266 Any SAL_CALL OCollection::queryInterface( const Type & rType ) throw (RuntimeException)
 267 {
 268     if ( m_bUseIndexOnly && rType == ::getCppuType(static_cast< Reference< XNameAccess > *> (NULL)) )
 269     {
 270         return Any();
 271     }
 272     return OCollectionBase::queryInterface( rType );
 273 }
 274 // -----------------------------------------------------------------------------
 275 Sequence< Type > SAL_CALL OCollection::getTypes() throw (RuntimeException)
 276 {
 277     if ( m_bUseIndexOnly )
 278     {
 279         Sequence< Type > aTypes(OCollectionBase::getTypes());
 280         Type* pBegin    = aTypes.getArray();
 281         Type* pEnd      = pBegin + aTypes.getLength();
 282
 283         ::std::vector<Type> aOwnTypes;
 284         aOwnTypes.reserve(aTypes.getLength());
 285         Type aType = ::getCppuType(static_cast< Reference<XNameAccess> *>(NULL));
 286         for(;pBegin != pEnd; ++pBegin)
 287         {
 288             if ( *pBegin != aType )
 289                 aOwnTypes.push_back(*pBegin);
 290         }
 291         Type* pTypes = aOwnTypes.empty() ? 0 : &aOwnTypes[0];
 292         return Sequence< Type >(pTypes,aOwnTypes.size());
 293     }
 294     return OCollectionBase::getTypes( );
 295 }
 296 // -------------------------------------------------------------------------
 297 void OCollection::clear_NoDispose()
 298 {
 299     ::osl::MutexGuard aGuard(m_rMutex);
 300
 301     m_pElements->clear();
 302     m_pElements->swapAll();
 303 }
 304
 305 // -------------------------------------------------------------------------
 306 void OCollection::disposing(void)
 307 {
 308     m_aContainerListeners.disposeAndClear(EventObject(static_cast<XTypeProvider*>(this)));
 309     m_aRefreshListeners.disposeAndClear(EventObject(static_cast<XTypeProvider*>(this)));
 310
 311     ::osl::MutexGuard aGuard(m_rMutex);
 312
 313     disposeElements();
 314
 315     m_pElements->swap();
 316 }
 317 // -------------------------------------------------------------------------
 318 Any SAL_CALL OCollection::getByIndex( sal_Int32 Index ) throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException)
 319 {
 320     ::osl::MutexGuard aGuard(m_rMutex);
 321     if (Index < 0 || Index >= m_pElements->size() )
 322         throw IndexOutOfBoundsException(::rtl::OUString::valueOf(Index),static_cast<XTypeProvider*>(this));
 323
 324     return makeAny(getObject(Index));
 325 }
 326 // -------------------------------------------------------------------------
 327 Any SAL_CALL OCollection::getByName( const ::rtl::OUString& aName ) throw(NoSuchElementException, WrappedTargetException, RuntimeException)
 328 {
 329     ::osl::MutexGuard aGuard(m_rMutex);
 330
 331     if ( !m_pElements->exists(aName) )
 332     {
 333         ::connectivity::SharedResources aResources;
 334         const ::rtl::OUString sError( aResources.getResourceStringWithSubstitution(
 335                 STR_NO_ELEMENT_NAME,
 336                 "$name$", aName
 337              ) );
 338         throw NoSuchElementException( sError, static_cast< XTypeProvider* >( this ) );
 339     }
 340
 341     return makeAny(getObject(m_pElements->findColumn(aName)));
 342 }
 343 // -------------------------------------------------------------------------
 344 Sequence< ::rtl::OUString > SAL_CALL OCollection::getElementNames(  ) throw(RuntimeException)
 345 {
 346     ::osl::MutexGuard aGuard(m_rMutex);
 347     return m_pElements->getElementNames();
 348 }
 349 // -------------------------------------------------------------------------
 350 void SAL_CALL OCollection::refresh(  ) throw(RuntimeException)
 351 {
 352     ::osl::MutexGuard aGuard(m_rMutex);
 353
 354     disposeElements();
 355
 356     impl_refresh();
 357     EventObject aEvt(static_cast<XTypeProvider*>(this));
 358     m_aRefreshListeners.notifyEach( &XRefreshListener::refreshed, aEvt );
 359 }
 360 // -----------------------------------------------------------------------------
 361 void OCollection::reFill(const TStringVector &_rVector)
 362 {
 363     m_pElements->reFill(_rVector);
 364 }
 365 // -------------------------------------------------------------------------
 366 // XDataDescriptorFactory
 367 Reference< XPropertySet > SAL_CALL OCollection::createDataDescriptor(  ) throw(RuntimeException)
 368 {
 369     ::osl::MutexGuard aGuard(m_rMutex);
 370
 371     return createDescriptor();
 372 }
 373 // -----------------------------------------------------------------------------
 374 ::rtl::OUString OCollection::getNameForObject(const ObjectType& _xObject)
 375 {
 376     OSL_ENSURE(_xObject.is(),"OCollection::getNameForObject: Object is NULL!");
 377     ::rtl::OUString sName;
 378     _xObject->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= sName;
 379     return sName;
 380 }
 381 // -------------------------------------------------------------------------
 382 // XAppend
 383 void SAL_CALL OCollection::appendByDescriptor( const Reference< XPropertySet >& descriptor ) throw(SQLException, ElementExistException, RuntimeException)
 384 {
 385     ::osl::ClearableMutexGuard aGuard(m_rMutex);
 386
 387     ::rtl::OUString sName = getNameForObject( descriptor );
 388
 389     if ( m_pElements->exists(sName) )
 390         throw ElementExistException(sName,static_cast<XTypeProvider*>(this));
 391
 392     ObjectType xNewlyCreated = appendObject( sName, descriptor );
 393     if ( !xNewlyCreated.is() )
 394         throw RuntimeException();
 395
 396     ODescriptor* pDescriptor = ODescriptor::getImplementation( xNewlyCreated );
 397     if ( pDescriptor )
 398         pDescriptor->setNew( sal_False );
 399
 400     sName = getNameForObject( xNewlyCreated );
 401     if ( !m_pElements->exists( sName ) ) // this may happen when the drived class included it itself
 402         m_pElements->insert( sName, xNewlyCreated );
 403
 404     // notify our container listeners
 405     ContainerEvent aEvent(static_cast<XContainer*>(this), makeAny(sName), makeAny(xNewlyCreated), Any());
 406     aGuard.clear();
 407     m_aContainerListeners.notifyEach( &XContainerListener::elementInserted, aEvent );
 408 }
 409 // -------------------------------------------------------------------------
 410 // XDrop
 411 void SAL_CALL OCollection::dropByName( const ::rtl::OUString& elementName ) throw(SQLException, NoSuchElementException, RuntimeException)
 412 {
 413     ::osl::MutexGuard aGuard(m_rMutex);
 414
 415     if ( !m_pElements->exists(elementName) )
 416         throw NoSuchElementException(elementName,static_cast<XTypeProvider*>(this));
 417
 418     dropImpl(m_pElements->findColumn(elementName));
 419 }
 420 // -------------------------------------------------------------------------
 421 void SAL_CALL OCollection::dropByIndex( sal_Int32 index ) throw(SQLException, IndexOutOfBoundsException, RuntimeException)
 422 {
 423     ::osl::MutexGuard aGuard(m_rMutex);
 424     if(index <0 || index >= getCount())
 425         throw IndexOutOfBoundsException(::rtl::OUString::valueOf(index),static_cast<XTypeProvider*>(this));
 426
 427     dropImpl(index);
 428 }
 429 // -----------------------------------------------------------------------------
 430 void OCollection::dropImpl(sal_Int32 _nIndex,sal_Bool _bReallyDrop)
 431 {
 432     ::rtl::OUString elementName = m_pElements->getName(_nIndex);
 433
 434     if ( _bReallyDrop )
 435         dropObject(_nIndex,elementName);
 436
 437     m_pElements->disposeAndErase(_nIndex);
 438
 439     // notify our container listeners
 440     notifyElementRemoved(elementName);
 441 }
 442 // -----------------------------------------------------------------------------
 443 void OCollection::notifyElementRemoved(const ::rtl::OUString& _sName)
 444 {
 445     ContainerEvent aEvent(static_cast<XContainer*>(this), makeAny(_sName), Any(), Any());
 446     // note that xExistent may be empty, in case somebody removed the data source while it is not alive at this moment
 447     OInterfaceIteratorHelper aListenerLoop(m_aContainerListeners);
 448     while (aListenerLoop.hasMoreElements())
 449         static_cast<XContainerListener*>(aListenerLoop.next())->elementRemoved(aEvent);
 450 }
 451 // -------------------------------------------------------------------------
 452 sal_Int32 SAL_CALL OCollection::findColumn( const ::rtl::OUString& columnName ) throw(SQLException, RuntimeException)
 453 {
 454     if ( !m_pElements->exists(columnName) )
 455     {
 456         ::connectivity::SharedResources aResources;
 457         const ::rtl::OUString sError( aResources.getResourceStringWithSubstitution(
 458                             STR_UNKNOWN_COLUMN_NAME,
 459                             "$columnname$", columnName
 460                          ) );
 461         ::dbtools::throwGenericSQLException(sError,static_cast< XIndexAccess*>(this));
 462     }
 463
 464     return m_pElements->findColumn(columnName) + 1; // because columns start at one
 465 }
 466 // -------------------------------------------------------------------------
 467 Reference< XEnumeration > SAL_CALL OCollection::createEnumeration(  ) throw(RuntimeException)
 468 {
 469     ::osl::MutexGuard aGuard(m_rMutex);
 470     return new OEnumerationByIndex( static_cast< XIndexAccess*>(this));
 471 }
 472 // -----------------------------------------------------------------------------
 473 void SAL_CALL OCollection::addContainerListener( const Reference< XContainerListener >& _rxListener ) throw(RuntimeException)
 474 {
 475     m_aContainerListeners.addInterface(_rxListener);
 476 }
 477
 478 //------------------------------------------------------------------------------
 479 void SAL_CALL OCollection::removeContainerListener( const Reference< XContainerListener >& _rxListener ) throw(RuntimeException)
 480 {
 481     m_aContainerListeners.removeInterface(_rxListener);
 482 }
 483 // -----------------------------------------------------------------------------
 484 void SAL_CALL OCollection::acquire() throw()
 485 {
 486     m_rParent.acquire();
 487 }
 488 // -----------------------------------------------------------------------------
 489 void SAL_CALL OCollection::release() throw()
 490 {
 491     m_rParent.release();
 492 }
 493 // -----------------------------------------------------------------------------
 494 Type SAL_CALL OCollection::getElementType(  ) throw(RuntimeException)
 495 {
 496     return::getCppuType(static_cast< Reference< XPropertySet>*>(NULL));
 497 }
 498 // -----------------------------------------------------------------------------
 499 sal_Bool SAL_CALL OCollection::hasElements(  ) throw(RuntimeException)
 500 {
 501     ::osl::MutexGuard aGuard(m_rMutex);
 502     return !m_pElements->empty();
 503 }
 504 // -----------------------------------------------------------------------------
 505 sal_Int32 SAL_CALL OCollection::getCount(  ) throw(RuntimeException)
 506 {
 507     ::osl::MutexGuard aGuard(m_rMutex);
 508     return m_pElements->size();
 509 }
 510 // -----------------------------------------------------------------------------
 511 sal_Bool SAL_CALL OCollection::hasByName( const ::rtl::OUString& aName ) throw(RuntimeException)
 512 {
 513     ::osl::MutexGuard aGuard(m_rMutex);
 514     return m_pElements->exists(aName);
 515 }
 516 // -----------------------------------------------------------------------------
 517 void SAL_CALL OCollection::addRefreshListener( const Reference< XRefreshListener >& l ) throw(RuntimeException)
 518 {
 519     m_aRefreshListeners.addInterface(l);
 520 }
 521 // -----------------------------------------------------------------------------
 522 void SAL_CALL OCollection::removeRefreshListener( const Reference< XRefreshListener >& l ) throw(RuntimeException)
 523 {
 524     m_aRefreshListeners.removeInterface(l);
 525 }
 526 // -----------------------------------------------------------------------------
 527 void OCollection::insertElement(const ::rtl::OUString& _sElementName,const ObjectType& _xElement)
 528 {
 529     OSL_ENSURE(!m_pElements->exists(_sElementName),"Element already exists");
 530     if ( !m_pElements->exists(_sElementName) )
 531         m_pElements->insert(_sElementName,_xElement);
 532 }
 533 // -----------------------------------------------------------------------------
 534 void OCollection::renameObject(const ::rtl::OUString _sOldName,const ::rtl::OUString _sNewName)
 535 {
 536     OSL_ENSURE(m_pElements->exists(_sOldName),"Element doesn't exist");
 537     OSL_ENSURE(!m_pElements->exists(_sNewName),"Element already exists");
 538     OSL_ENSURE(!_sNewName.isEmpty(),"New name must not be empty!");
 539     OSL_ENSURE(!_sOldName.isEmpty(),"Old name must not be empty!");
 540
 541     if ( m_pElements->rename(_sOldName,_sNewName) )
 542     {
 543         ContainerEvent aEvent(static_cast<XContainer*>(this), makeAny(_sNewName), makeAny(m_pElements->getObject(_sNewName)),makeAny(_sOldName));
 544         // note that xExistent may be empty, in case somebody removed the data source while it is not alive at this moment
 545         OInterfaceIteratorHelper aListenerLoop(m_aContainerListeners);
 546         while (aListenerLoop.hasMoreElements())
 547             static_cast<XContainerListener*>(aListenerLoop.next())->elementReplaced(aEvent);
 548     }
 549 }
 550 // -----------------------------------------------------------------------------
 551 ObjectType OCollection::getObject(sal_Int32 _nIndex)
 552 {
 553     ObjectType xName = m_pElements->getObject(_nIndex);
 554     if ( !xName.is() )
 555     {
 556         try
 557         {
 558             xName = createObject(m_pElements->getName(_nIndex));
 559         }
 560         catch(const SQLException& e)
 561         {
 562             try
 563             {
 564                 dropImpl(_nIndex,sal_False);
 565             }
 566             catch(const Exception& )
 567             {
 568             }
 569             throw WrappedTargetException(e.Message,static_cast<XTypeProvider*>(this),makeAny(e));
 570         }
 571         m_pElements->setObject(_nIndex,xName);
 572     }
 573     return xName;
 574 }
 575 // -----------------------------------------------------------------------------
 576 void OCollection::disposeElements()
 577 {
 578     m_pElements->disposeElements();
 579 }
 580 // -----------------------------------------------------------------------------
 581 Reference< XPropertySet > OCollection::createDescriptor()
 582 {
 583     OSL_ASSERT(!"Need to be overloaded when used!");
 584     throw SQLException();
 585 }
 586 // -----------------------------------------------------------------------------
 587 ObjectType OCollection::cloneDescriptor( const ObjectType& _descriptor )
 588 {
 589     ObjectType xNewDescriptor( createDescriptor() );
 590     ::comphelper::copyProperties( _descriptor, xNewDescriptor );
 591     return xNewDescriptor;
 592 }
 593 // -----------------------------------------------------------------------------
 594 ObjectType OCollection::appendObject( const ::rtl::OUString& /*_rForName*/, const Reference< XPropertySet >& descriptor )
 595 {
 596     return cloneDescriptor( descriptor );
 597 }
 598 // -----------------------------------------------------------------------------
 599 void OCollection::dropObject(sal_Int32 /*_nPos*/,const ::rtl::OUString /*_sElementName*/)
 600 {
 601 }
 602 // -----------------------------------------------------------------------------
 603
 604 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */