connectivity/source/drivers/postgresql/pq_xcontainer.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  *  Effective License of whole file:
   5  *
   6  *    This library is free software; you can redistribute it and/or
   7  *    modify it under the terms of the GNU Lesser General Public
   8  *    License version 2.1, as published by the Free Software Foundation.
   9  *
  10  *    This library is distributed in the hope that it will be useful,
  11  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  *    Lesser General Public License for more details.
  14  *
  15  *    You should have received a copy of the GNU Lesser General Public
  16  *    License along with this library; if not, write to the Free Software
  17  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  18  *    MA  02111-1307  USA
  19  *
  20  *  Parts "Copyright by Sun Microsystems, Inc" prior to August 2011:
  21  *
  22  *    The Contents of this file are made available subject to the terms of
  23  *    the GNU Lesser General Public License Version 2.1
  24  *
  25  *    Copyright: 2000 by Sun Microsystems, Inc.
  26  *
  27  *    Contributor(s): Joerg Budischewski
  28  *
  29  *  All parts contributed on or after August 2011:
  30  *
  31  *    This Source Code Form is subject to the terms of the Mozilla Public
  32  *    License, v. 2.0. If a copy of the MPL was not distributed with this
  33  *    file, You can obtain one at http://mozilla.org/MPL/2.0/.
  34  *
  35  ************************************************************************/
  36
  37 #include <com/sun/star/container/ElementExistException.hpp>
  38 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  39 #include <cppuhelper/implbase.hxx>
  40
  41 #include "pq_xcontainer.hxx"
  42 #include "pq_statics.hxx"
  43 #include "pq_tools.hxx"
  44
  45 using osl::MutexGuard;
  46
  47 using com::sun::star::beans::XPropertySet;
  48
  49 using com::sun::star::uno::Any;
  50 using com::sun::star::uno::makeAny;
  51 using com::sun::star::uno::Type;
  52 using com::sun::star::uno::XInterface;
  53 using com::sun::star::uno::Reference;
  54 using com::sun::star::uno::Sequence;
  55 using com::sun::star::uno::RuntimeException;
  56
  57 using com::sun::star::container::NoSuchElementException;
  58 using com::sun::star::container::XEnumeration;
  59 using com::sun::star::container::XContainerListener;
  60 using com::sun::star::container::ContainerEvent;
  61 using com::sun::star::lang::IndexOutOfBoundsException;
  62 using com::sun::star::lang::XEventListener;
  63
  64
  65 namespace pq_sdbc_driver
  66 {
  67
  68 namespace {
  69
  70 class ReplacedBroadcaster : public EventBroadcastHelper
  71 {
  72     ContainerEvent m_event;
  73 public:
  74     ReplacedBroadcaster(
  75         const Reference< XInterface > & source,
  76         const OUString & name,
  77         const Any & newElement,
  78         const OUString & oldElement ) :
  79         m_event( source, makeAny( name ), newElement, makeAny(oldElement) )
  80     {}
  81
  82     virtual void fire( XEventListener * listener ) const override
  83     {
  84         static_cast<XContainerListener*>(listener)->elementReplaced( m_event );
  85     }
  86     virtual Type getType() const override
  87     {
  88         return cppu::UnoType<XContainerListener>::get();
  89     }
  90 };
  91
  92 class InsertedBroadcaster : public EventBroadcastHelper
  93 {
  94 public:
  95     ContainerEvent m_event;
  96     InsertedBroadcaster(
  97         const Reference< XInterface > & source,
  98         const OUString & name,
  99         const Any & newElement ) :
 100         m_event( source, makeAny( name ), newElement, Any() )
 101     {}
 102
 103     virtual void fire( XEventListener * listener ) const override
 104     {
 105         static_cast<XContainerListener*>(listener)->elementInserted( m_event );
 106     }
 107
 108     virtual Type getType() const override
 109     {
 110         return cppu::UnoType<XContainerListener>::get();
 111     }
 112 };
 113
 114 class RemovedBroadcaster : public EventBroadcastHelper
 115 {
 116 public:
 117     ContainerEvent m_event;
 118     RemovedBroadcaster(
 119         const Reference< XInterface > & source,
 120         const OUString & name) :
 121         m_event( source, makeAny( name ), Any(), Any() )
 122     {}
 123
 124     virtual void fire( XEventListener * listener ) const override
 125     {
 126         static_cast<XContainerListener*>(listener)->elementRemoved( m_event );
 127     }
 128
 129     virtual Type getType() const override
 130     {
 131         return cppu::UnoType<XContainerListener>::get();
 132     }
 133 };
 134
 135 }
 136
 137 Container::Container(
 138     const ::rtl::Reference< comphelper::RefCountedMutex > & refMutex,
 139     const css::uno::Reference< css::sdbc::XConnection >  & origin,
 140     ConnectionSettings *pSettings,
 141     const OUString &type)
 142     : ContainerBase( refMutex->GetMutex() ),
 143       m_xMutex( refMutex ),
 144       m_pSettings( pSettings ),
 145       m_origin( origin ),
 146       m_type( type )
 147 {
 148 }
 149
 150 Any Container::getByName( const OUString& aName )
 151 {
 152     String2IntMap::const_iterator ii = m_name2index.find( aName );
 153     if( ii == m_name2index.end() )
 154     {
 155         throw NoSuchElementException(
 156             "Element " + aName + " unknown in " + m_type + "-Container",
 157             *this );
 158     }
 159     OSL_ASSERT( ii->second >= 0 && ii->second < static_cast<int>(m_values.size()) );
 160     return m_values[ ii->second ];
 161 }
 162
 163 Sequence< OUString > Container::getElementNames(  )
 164 {
 165     Sequence< OUString > ret( m_values.size() );
 166     for( const auto& [rName, rIndex] : m_name2index )
 167     {
 168         // give element names in index order !
 169         ret[rIndex] = rName;
 170     }
 171     return ret;
 172 }
 173
 174 sal_Bool Container::hasByName( const OUString& aName )
 175 {
 176     return m_name2index.find( aName ) != m_name2index.end();
 177 }
 178     // Methods
 179 Type Container::getElementType(  )
 180 {
 181     return Type();
 182 }
 183
 184 sal_Bool Container::hasElements(  )
 185 {
 186     return ! m_name2index.empty();
 187 }
 188
 189 Any Container::getByIndex( sal_Int32 Index )
 190 {
 191     if( Index < 0 || Index >= static_cast<sal_Int32>(m_values.size()) )
 192     {
 193         throw IndexOutOfBoundsException(
 194             "Index " + OUString::number( Index )
 195             + " out of range for " + m_type + "-Container, expected 0 <= x <= "
 196             + OUString::number(m_values.size() -1),
 197             *this );
 198     }
 199     return m_values[Index];
 200 }
 201
 202 sal_Int32 Container::getCount()
 203 {
 204     return m_values.size();
 205 }
 206
 207 namespace {
 208
 209 class ContainerEnumeration : public ::cppu::WeakImplHelper< XEnumeration >
 210 {
 211     std::vector< css::uno::Any > m_vec;
 212     sal_Int32 m_index;
 213 public:
 214     explicit ContainerEnumeration( const std::vector< css::uno::Any > &vec )
 215         : m_vec( vec ),
 216           m_index( -1 )
 217     {}
 218
 219 public:
 220     // XEnumeration
 221     virtual sal_Bool SAL_CALL hasMoreElements(  ) override;
 222     virtual css::uno::Any SAL_CALL nextElement(  ) override;
 223
 224 };
 225
 226 }
 227
 228 sal_Bool ContainerEnumeration::hasMoreElements()
 229 {
 230     return static_cast<int>(m_vec.size()) > m_index +1;
 231 }
 232
 233 css::uno::Any ContainerEnumeration::nextElement()
 234 {
 235     if( ! hasMoreElements() )
 236     {
 237         throw NoSuchElementException(
 238             "NoSuchElementException during enumeration", *this );
 239     }
 240     m_index ++;
 241     return m_vec[m_index];
 242 }
 243
 244 Reference< XEnumeration > Container::createEnumeration(  )
 245 {
 246     return new ContainerEnumeration( m_values );
 247 }
 248
 249 void Container::addRefreshListener(
 250     const css::uno::Reference< css::util::XRefreshListener >& l )
 251 {
 252     rBHelper.addListener( cppu::UnoType<decltype(l)>::get() , l );
 253 }
 254
 255 void Container::removeRefreshListener(
 256     const css::uno::Reference< css::util::XRefreshListener >& l )
 257 {
 258     rBHelper.removeListener( cppu::UnoType<decltype(l)>::get() , l );
 259 }
 260
 261 void Container::disposing()
 262 {
 263     m_origin.clear();
 264 }
 265
 266 void Container::rename( const OUString &oldName, const OUString &newName )
 267 {
 268     Any newValue;
 269     {
 270         osl::MutexGuard guard ( m_xMutex->GetMutex() );
 271         String2IntMap::iterator ii = m_name2index.find( oldName );
 272         if( ii != m_name2index.end() )
 273         {
 274             sal_Int32 nIndex = ii->second;
 275             newValue = m_values[nIndex];
 276             m_name2index.erase( ii );
 277             m_name2index[ newName ] = nIndex;
 278         }
 279     }
 280     fire( ReplacedBroadcaster( *this, newName, newValue, oldName ) );
 281     fire( RefreshedBroadcaster( *this ) );
 282 }
 283
 284 void Container::dropByName( const OUString& elementName )
 285 {
 286     osl::MutexGuard guard( m_xMutex->GetMutex() );
 287     String2IntMap::const_iterator ii = m_name2index.find( elementName );
 288     if( ii == m_name2index.end() )
 289     {
 290         throw css::container::NoSuchElementException(
 291             "Column " + elementName + " is unknown in "
 292             + m_type + " container, so it can't be dropped",
 293             *this );
 294     }
 295     dropByIndex( ii->second );
 296 }
 297
 298 void Container::dropByIndex( sal_Int32 index )
 299 {
 300     osl::MutexGuard guard( m_xMutex->GetMutex() );
 301     if( index < 0 ||  index >=static_cast<sal_Int32>(m_values.size()) )
 302     {
 303         throw css::lang::IndexOutOfBoundsException(
 304             "Index out of range (allowed 0 to "
 305             + OUString::number(m_values.size() -1)
 306             + ", got " + OUString::number( index )
 307             + ") in " + m_type,
 308             *this );
 309     }
 310
 311     OUString name;
 312     String2IntMap::iterator ii = std::find_if(m_name2index.begin(), m_name2index.end(),
 313         [&index](const String2IntMap::value_type& rEntry) { return rEntry.second == index; });
 314     if (ii != m_name2index.end())
 315     {
 316         name = ii->first;
 317         m_name2index.erase( ii );
 318     }
 319
 320     for( int i = index +1 ; i < static_cast<int>(m_values.size()) ; i ++ )
 321     {
 322         m_values[i-1] = m_values[i];
 323
 324         // I know, this is expensive, but don't want to maintain another map ...
 325         ii = std::find_if(m_name2index.begin(), m_name2index.end(),
 326             [&i](const String2IntMap::value_type& rEntry) { return rEntry.second == i; });
 327         if (ii != m_name2index.end())
 328         {
 329             ii->second = i-1;
 330         }
 331     }
 332     m_values.resize( m_values.size() - 1 );
 333
 334     fire( RemovedBroadcaster( *this, name ) );
 335 }
 336
 337 void Container::append(
 338     const OUString & name,
 339     const css::uno::Reference< css::beans::XPropertySet >& descriptor )
 340
 341 {
 342     osl::MutexGuard guard( m_xMutex->GetMutex() );
 343
 344     if( hasByName( name ) )
 345     {
 346         throw css::container::ElementExistException(
 347             "a " + m_type + " with name " + name + " already exists in this container",
 348             *this );
 349     }
 350
 351     int index = m_values.size();
 352     m_values.push_back( makeAny( descriptor ) );
 353     m_name2index[name] = index;
 354
 355     fire( InsertedBroadcaster( *this, name, makeAny( descriptor ) ) );
 356 }
 357
 358 void Container::appendByDescriptor(
 359     const css::uno::Reference< css::beans::XPropertySet >& descriptor)
 360 {
 361     append( extractStringProperty( descriptor, getStatics().NAME ), descriptor );
 362 }
 363
 364
 365 void Container::addContainerListener(
 366         const css::uno::Reference< css::container::XContainerListener >& l )
 367 {
 368     rBHelper.addListener( cppu::UnoType<decltype(l)>::get() , l );
 369 }
 370
 371 void Container::removeContainerListener(
 372         const css::uno::Reference< css::container::XContainerListener >& l )
 373 {
 374     rBHelper.removeListener( cppu::UnoType<decltype(l)>::get() , l );
 375 }
 376
 377
 378 void Container::fire( const EventBroadcastHelper &helper )
 379 {
 380     cppu::OInterfaceContainerHelper *container = rBHelper.getContainer( helper.getType() );
 381     if( !container )
 382         return;
 383
 384     cppu::OInterfaceIteratorHelper iterator( * container );
 385     while( iterator.hasMoreElements() )
 386     {
 387         try
 388         {
 389             helper.fire( static_cast<XEventListener *>(iterator.next()) );
 390         }
 391         catch ( css::uno::RuntimeException & )
 392         {
 393             OSL_ENSURE( false, "exception caught" );
 394             // loose coupling, a runtime exception shall not break anything
 395             // TODO: log away as warning !
 396         }
 397         catch( css::uno::Exception & )
 398         {
 399             OSL_ENSURE( false, "exception from listener flying through" );
 400             throw;
 401         }
 402     }
 403
 404 }
 405
 406 }
 407
 408 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */