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