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