| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_cppuhelper.hxx" |
| |
| #include <cppuhelper/interfacecontainer.hxx> |
| #include <cppuhelper/queryinterface.hxx> |
| #include <cppuhelper/propshlp.hxx> |
| |
| #include <osl/diagnose.h> |
| #include <osl/mutex.hxx> |
| |
| #include <hash_map> |
| |
| #include <com/sun/star/lang/XEventListener.hpp> |
| |
| |
| using namespace osl; |
| using namespace com::sun::star::uno; |
| using namespace com::sun::star::lang; |
| |
| namespace cppu |
| { |
| |
| //=================================================================== |
| //=================================================================== |
| //=================================================================== |
| /** |
| * Reallocate the sequence. |
| */ |
| static void realloc( Sequence< Reference< XInterface > > & rSeq, sal_Int32 nNewLen ) |
| SAL_THROW( () ) |
| { |
| rSeq.realloc( nNewLen ); |
| } |
| |
| /** |
| * Remove an element from an interface sequence. |
| */ |
| static void sequenceRemoveElementAt( Sequence< Reference< XInterface > > & rSeq, sal_Int32 index ) |
| SAL_THROW( () ) |
| { |
| sal_Int32 nNewLen = rSeq.getLength() - 1; |
| |
| Sequence< Reference< XInterface > > aDestSeq( rSeq.getLength() - 1 ); |
| // getArray on a const sequence is faster |
| const Reference< XInterface > * pSource = ((const Sequence< Reference< XInterface > > &)rSeq).getConstArray(); |
| Reference< XInterface > * pDest = aDestSeq.getArray(); |
| sal_Int32 i = 0; |
| for( ; i < index; i++ ) |
| pDest[i] = pSource[i]; |
| for( sal_Int32 j = i ; j < nNewLen; j++ ) |
| pDest[j] = pSource[j+1]; |
| rSeq = aDestSeq; |
| } |
| |
| |
| //----------------------------------------------------------------------------- |
| //----------------------------------------------------------------------------- |
| |
| #ifdef _MSC_VER |
| #pragma warning( disable: 4786 ) |
| #endif |
| |
| //=================================================================== |
| //=================================================================== |
| //=================================================================== |
| OInterfaceIteratorHelper::OInterfaceIteratorHelper( OInterfaceContainerHelper & rCont_ ) |
| SAL_THROW( () ) |
| : rCont( rCont_ ) |
| { |
| MutexGuard aGuard( rCont.rMutex ); |
| if( rCont.bInUse ) |
| // worst case, two iterators at the same time |
| rCont.copyAndResetInUse(); |
| bIsList = rCont_.bIsList; |
| aData = rCont_.aData; |
| if( bIsList ) |
| { |
| rCont.bInUse = sal_True; |
| nRemain = aData.pAsSequence->getLength(); |
| } |
| else if( aData.pAsInterface ) |
| { |
| aData.pAsInterface->acquire(); |
| nRemain = 1; |
| } |
| else |
| nRemain = 0; |
| } |
| |
| OInterfaceIteratorHelper::~OInterfaceIteratorHelper() SAL_THROW( () ) |
| { |
| sal_Bool bShared; |
| { |
| MutexGuard aGuard( rCont.rMutex ); |
| // bResetInUse protect the iterator against recursion |
| bShared = aData.pAsSequence == rCont.aData.pAsSequence && rCont.bIsList; |
| if( bShared ) |
| { |
| OSL_ENSURE( rCont.bInUse, "OInterfaceContainerHelper must be in use" ); |
| rCont.bInUse = sal_False; |
| } |
| } |
| |
| if( !bShared ) |
| { |
| if( bIsList ) |
| // Sequence owned by the iterator |
| delete aData.pAsSequence; |
| else if( aData.pAsInterface ) |
| // Interface is acquired by the iterator |
| aData.pAsInterface->release(); |
| } |
| } |
| |
| XInterface * OInterfaceIteratorHelper::next() SAL_THROW( () ) |
| { |
| if( nRemain ) |
| { |
| nRemain--; |
| if( bIsList ) |
| // typecase to const,so the getArray method is faster |
| return aData.pAsSequence->getConstArray()[nRemain].get(); |
| else if( aData.pAsInterface ) |
| return aData.pAsInterface; |
| } |
| // exception |
| return 0; |
| } |
| |
| void OInterfaceIteratorHelper::remove() SAL_THROW( () ) |
| { |
| if( bIsList ) |
| { |
| OSL_ASSERT( nRemain >= 0 && |
| nRemain < aData.pAsSequence->getLength() ); |
| XInterface * p = aData.pAsSequence->getConstArray()[nRemain].get(); |
| rCont.removeInterface( * reinterpret_cast< const Reference< XInterface > * >( &p ) ); |
| } |
| else |
| { |
| OSL_ASSERT( 0 == nRemain ); |
| rCont.removeInterface( * reinterpret_cast< const Reference< XInterface > * >(&aData.pAsInterface)); |
| } |
| } |
| |
| //=================================================================== |
| //=================================================================== |
| //=================================================================== |
| |
| |
| OInterfaceContainerHelper::OInterfaceContainerHelper( Mutex & rMutex_ ) SAL_THROW( () ) |
| : rMutex( rMutex_ ) |
| , bInUse( sal_False ) |
| , bIsList( sal_False ) |
| { |
| } |
| |
| OInterfaceContainerHelper::~OInterfaceContainerHelper() SAL_THROW( () ) |
| { |
| OSL_ENSURE( !bInUse, "~OInterfaceContainerHelper but is in use" ); |
| if( bIsList ) |
| delete aData.pAsSequence; |
| else if( aData.pAsInterface ) |
| aData.pAsInterface->release(); |
| } |
| |
| sal_Int32 OInterfaceContainerHelper::getLength() const SAL_THROW( () ) |
| { |
| MutexGuard aGuard( rMutex ); |
| if( bIsList ) |
| return aData.pAsSequence->getLength(); |
| else if( aData.pAsInterface ) |
| return 1; |
| return 0; |
| } |
| |
| Sequence< Reference<XInterface> > OInterfaceContainerHelper::getElements() const SAL_THROW( () ) |
| { |
| MutexGuard aGuard( rMutex ); |
| if( bIsList ) |
| return *aData.pAsSequence; |
| else if( aData.pAsInterface ) |
| { |
| Reference<XInterface> x( aData.pAsInterface ); |
| return Sequence< Reference< XInterface > >( &x, 1 ); |
| } |
| return Sequence< Reference< XInterface > >(); |
| } |
| |
| void OInterfaceContainerHelper::copyAndResetInUse() SAL_THROW( () ) |
| { |
| OSL_ENSURE( bInUse, "OInterfaceContainerHelper not in use" ); |
| if( bInUse ) |
| { |
| // this should be the worst case. If a iterator is active |
| // and a new Listener is added. |
| if( bIsList ) |
| aData.pAsSequence = new Sequence< Reference< XInterface > >( *aData.pAsSequence ); |
| else if( aData.pAsInterface ) |
| aData.pAsInterface->acquire(); |
| |
| bInUse = sal_False; |
| } |
| } |
| |
| sal_Int32 OInterfaceContainerHelper::addInterface( const Reference<XInterface> & rListener ) SAL_THROW( () ) |
| { |
| OSL_ASSERT( rListener.is() ); |
| MutexGuard aGuard( rMutex ); |
| if( bInUse ) |
| copyAndResetInUse(); |
| |
| if( bIsList ) |
| { |
| sal_Int32 nLen = aData.pAsSequence->getLength(); |
| realloc( *aData.pAsSequence, nLen +1 ); |
| aData.pAsSequence->getArray()[ nLen ] = rListener; |
| return nLen +1; |
| } |
| else if( aData.pAsInterface ) |
| { |
| Sequence< Reference< XInterface > > * pSeq = new Sequence< Reference< XInterface > >( 2 ); |
| Reference<XInterface> * pArray = pSeq->getArray(); |
| pArray[0] = aData.pAsInterface; |
| pArray[1] = rListener; |
| aData.pAsInterface->release(); |
| aData.pAsSequence = pSeq; |
| bIsList = sal_True; |
| return 2; |
| } |
| else |
| { |
| aData.pAsInterface = rListener.get(); |
| if( rListener.is() ) |
| rListener->acquire(); |
| return 1; |
| } |
| } |
| |
| sal_Int32 OInterfaceContainerHelper::removeInterface( const Reference<XInterface> & rListener ) SAL_THROW( () ) |
| { |
| OSL_ASSERT( rListener.is() ); |
| MutexGuard aGuard( rMutex ); |
| if( bInUse ) |
| copyAndResetInUse(); |
| |
| if( bIsList ) |
| { |
| const Reference<XInterface> * pL = aData.pAsSequence->getConstArray(); |
| sal_Int32 nLen = aData.pAsSequence->getLength(); |
| sal_Int32 i; |
| for( i = 0; i < nLen; i++ ) |
| { |
| // It is not valid to compare the Pointer direkt, but is is is much |
| // more faster. |
| if( pL[i].get() == rListener.get() ) |
| { |
| sequenceRemoveElementAt( *aData.pAsSequence, i ); |
| break; |
| } |
| } |
| |
| if( i == nLen ) |
| { |
| // interface not found, use the correct compare method |
| for( i = 0; i < nLen; i++ ) |
| { |
| if( pL[i] == rListener ) |
| { |
| sequenceRemoveElementAt(*aData.pAsSequence, i ); |
| break; |
| } |
| } |
| } |
| |
| if( aData.pAsSequence->getLength() == 1 ) |
| { |
| XInterface * p = aData.pAsSequence->getConstArray()[0].get(); |
| p->acquire(); |
| delete aData.pAsSequence; |
| aData.pAsInterface = p; |
| bIsList = sal_False; |
| return 1; |
| } |
| else |
| return aData.pAsSequence->getLength(); |
| } |
| else if( aData.pAsInterface && Reference<XInterface>( aData.pAsInterface ) == rListener ) |
| { |
| aData.pAsInterface->release(); |
| aData.pAsInterface = 0; |
| } |
| return aData.pAsInterface ? 1 : 0; |
| } |
| |
| void OInterfaceContainerHelper::disposeAndClear( const EventObject & rEvt ) SAL_THROW( () ) |
| { |
| ClearableMutexGuard aGuard( rMutex ); |
| OInterfaceIteratorHelper aIt( *this ); |
| // Container freigeben, falls im disposing neue Einträge kommen |
| OSL_ENSURE( !bIsList || bInUse, "OInterfaceContainerHelper not in use" ); |
| if( !bIsList && aData.pAsInterface ) |
| aData.pAsInterface->release(); |
| // set the member to null, the iterator delete the values |
| aData.pAsInterface = NULL; |
| bIsList = sal_False; |
| bInUse = sal_False; |
| aGuard.clear(); |
| while( aIt.hasMoreElements() ) |
| { |
| try |
| { |
| Reference<XEventListener > xLst( aIt.next(), UNO_QUERY ); |
| if( xLst.is() ) |
| xLst->disposing( rEvt ); |
| } |
| catch ( RuntimeException & ) |
| { |
| // be robust, if e.g. a remote bridge has disposed already. |
| // there is no way, to delegate the error to the caller :o(. |
| } |
| } |
| } |
| |
| |
| void OInterfaceContainerHelper::clear() SAL_THROW( () ) |
| { |
| ClearableMutexGuard aGuard( rMutex ); |
| OInterfaceIteratorHelper aIt( *this ); |
| // Container freigeben, falls im disposing neue Einträge kommen |
| OSL_ENSURE( !bIsList || bInUse, "OInterfaceContainerHelper not in use" ); |
| if( !bIsList && aData.pAsInterface ) |
| aData.pAsInterface->release(); |
| // set the member to null, the iterator delete the values |
| aData.pAsInterface = 0; |
| bIsList = sal_False; |
| bInUse = sal_False; |
| // release mutex before aIt destructor call |
| aGuard.clear(); |
| } |
| |
| //################################################################################################## |
| //################################################################################################## |
| //################################################################################################## |
| |
| // specialized class for type |
| |
| typedef ::std::vector< std::pair < Type , void* > > t_type2ptr; |
| |
| OMultiTypeInterfaceContainerHelper::OMultiTypeInterfaceContainerHelper( Mutex & rMutex_ ) |
| SAL_THROW( () ) |
| : rMutex( rMutex_ ) |
| { |
| m_pMap = new t_type2ptr(); |
| } |
| OMultiTypeInterfaceContainerHelper::~OMultiTypeInterfaceContainerHelper() |
| SAL_THROW( () ) |
| { |
| t_type2ptr * pMap = (t_type2ptr *)m_pMap; |
| t_type2ptr::iterator iter = pMap->begin(); |
| t_type2ptr::iterator end = pMap->end(); |
| |
| while( iter != end ) |
| { |
| delete (OInterfaceContainerHelper*)(*iter).second; |
| (*iter).second = 0; |
| ++iter; |
| } |
| delete pMap; |
| } |
| Sequence< Type > OMultiTypeInterfaceContainerHelper::getContainedTypes() const |
| SAL_THROW( () ) |
| { |
| t_type2ptr * pMap = (t_type2ptr *)m_pMap; |
| t_type2ptr::size_type nSize; |
| |
| ::osl::MutexGuard aGuard( rMutex ); |
| nSize = pMap->size(); |
| if( nSize ) |
| { |
| ::com::sun::star::uno::Sequence< Type > aInterfaceTypes( nSize ); |
| Type * pArray = aInterfaceTypes.getArray(); |
| |
| t_type2ptr::iterator iter = pMap->begin(); |
| t_type2ptr::iterator end = pMap->end(); |
| |
| sal_Int32 i = 0; |
| while( iter != end ) |
| { |
| // are interfaces added to this container? |
| if( ((OInterfaceContainerHelper*)(*iter).second)->getLength() ) |
| // yes, put the type in the array |
| pArray[i++] = (*iter).first; |
| ++iter; |
| } |
| if( (t_type2ptr::size_type)i != nSize ) { |
| // may be empty container, reduce the sequence to the right size |
| aInterfaceTypes = ::com::sun::star::uno::Sequence< Type >( pArray, i ); |
| } |
| return aInterfaceTypes; |
| } |
| return ::com::sun::star::uno::Sequence< Type >(); |
| } |
| |
| static t_type2ptr::iterator findType(t_type2ptr *pMap, const Type & rKey ) |
| { |
| t_type2ptr::iterator iter = pMap->begin(); |
| t_type2ptr::iterator end = pMap->end(); |
| |
| while( iter != end ) |
| { |
| if (iter->first == rKey) |
| break; |
| iter++; |
| } |
| return iter; |
| } |
| |
| OInterfaceContainerHelper * OMultiTypeInterfaceContainerHelper::getContainer( const Type & rKey ) const |
| SAL_THROW( () ) |
| { |
| ::osl::MutexGuard aGuard( rMutex ); |
| |
| t_type2ptr * pMap = (t_type2ptr *)m_pMap; |
| t_type2ptr::iterator iter = findType( pMap, rKey ); |
| if( iter != pMap->end() ) |
| return (OInterfaceContainerHelper*) (*iter).second; |
| return 0; |
| } |
| sal_Int32 OMultiTypeInterfaceContainerHelper::addInterface( |
| const Type & rKey, const Reference< XInterface > & rListener ) |
| SAL_THROW( () ) |
| { |
| ::osl::MutexGuard aGuard( rMutex ); |
| t_type2ptr * pMap = (t_type2ptr *)m_pMap; |
| t_type2ptr::iterator iter = findType( pMap, rKey ); |
| if( iter == pMap->end() ) |
| { |
| OInterfaceContainerHelper * pLC = new OInterfaceContainerHelper( rMutex ); |
| pMap->push_back(std::pair<Type, void*>(rKey, pLC)); |
| return pLC->addInterface( rListener ); |
| } |
| else |
| return ((OInterfaceContainerHelper*)(*iter).second)->addInterface( rListener ); |
| } |
| sal_Int32 OMultiTypeInterfaceContainerHelper::removeInterface( |
| const Type & rKey, const Reference< XInterface > & rListener ) |
| SAL_THROW( () ) |
| { |
| ::osl::MutexGuard aGuard( rMutex ); |
| |
| // search container with id nUik |
| t_type2ptr * pMap = (t_type2ptr *)m_pMap; |
| t_type2ptr::iterator iter = findType( pMap, rKey ); |
| // container found? |
| if( iter != pMap->end() ) |
| return ((OInterfaceContainerHelper*)(*iter).second)->removeInterface( rListener ); |
| |
| // no container with this id. Always return 0 |
| return 0; |
| } |
| void OMultiTypeInterfaceContainerHelper::disposeAndClear( const EventObject & rEvt ) |
| SAL_THROW( () ) |
| { |
| t_type2ptr::size_type nSize = 0; |
| OInterfaceContainerHelper ** ppListenerContainers = NULL; |
| { |
| ::osl::MutexGuard aGuard( rMutex ); |
| t_type2ptr * pMap = (t_type2ptr *)m_pMap; |
| nSize = pMap->size(); |
| if( nSize ) |
| { |
| typedef OInterfaceContainerHelper* ppp; |
| ppListenerContainers = new ppp[nSize]; |
| //ppListenerContainers = new (ListenerContainer*)[nSize]; |
| |
| t_type2ptr::iterator iter = pMap->begin(); |
| t_type2ptr::iterator end = pMap->end(); |
| |
| t_type2ptr::size_type i = 0; |
| while( iter != end ) |
| { |
| ppListenerContainers[i++] = (OInterfaceContainerHelper*)(*iter).second; |
| ++iter; |
| } |
| } |
| } |
| |
| // create a copy, because do not fire event in a guarded section |
| for( t_type2ptr::size_type i = 0; |
| i < nSize; i++ ) |
| { |
| if( ppListenerContainers[i] ) |
| ppListenerContainers[i]->disposeAndClear( rEvt ); |
| } |
| |
| delete [] ppListenerContainers; |
| } |
| void OMultiTypeInterfaceContainerHelper::clear() |
| SAL_THROW( () ) |
| { |
| ::osl::MutexGuard aGuard( rMutex ); |
| t_type2ptr * pMap = (t_type2ptr *)m_pMap; |
| t_type2ptr::iterator iter = pMap->begin(); |
| t_type2ptr::iterator end = pMap->end(); |
| |
| while( iter != end ) |
| { |
| ((OInterfaceContainerHelper*)(*iter).second)->clear(); |
| ++iter; |
| } |
| } |
| |
| |
| //################################################################################################## |
| //################################################################################################## |
| //################################################################################################## |
| |
| // specialized class for long |
| |
| typedef ::std::vector< std::pair < sal_Int32 , void* > > t_long2ptr; |
| |
| static t_long2ptr::iterator findLong(t_long2ptr *pMap, sal_Int32 nKey ) |
| { |
| t_long2ptr::iterator iter = pMap->begin(); |
| t_long2ptr::iterator end = pMap->end(); |
| |
| while( iter != end ) |
| { |
| if (iter->first == nKey) |
| break; |
| iter++; |
| } |
| return iter; |
| } |
| |
| OMultiTypeInterfaceContainerHelperInt32::OMultiTypeInterfaceContainerHelperInt32( Mutex & rMutex_ ) |
| SAL_THROW( () ) |
| : m_pMap( NULL ) |
| , rMutex( rMutex_ ) |
| { |
| // delay pMap allocation until necessary. |
| } |
| OMultiTypeInterfaceContainerHelperInt32::~OMultiTypeInterfaceContainerHelperInt32() |
| SAL_THROW( () ) |
| { |
| if (!m_pMap) |
| return; |
| |
| t_long2ptr * pMap = (t_long2ptr *)m_pMap; |
| t_long2ptr::iterator iter = pMap->begin(); |
| t_long2ptr::iterator end = pMap->end(); |
| |
| while( iter != end ) |
| { |
| delete (OInterfaceContainerHelper*)(*iter).second; |
| (*iter).second = 0; |
| ++iter; |
| } |
| delete pMap; |
| } |
| Sequence< sal_Int32 > OMultiTypeInterfaceContainerHelperInt32::getContainedTypes() const |
| SAL_THROW( () ) |
| { |
| t_long2ptr * pMap = (t_long2ptr *)m_pMap; |
| t_long2ptr::size_type nSize; |
| |
| ::osl::MutexGuard aGuard( rMutex ); |
| nSize = pMap ? pMap->size() : 0; |
| if( nSize ) |
| { |
| ::com::sun::star::uno::Sequence< sal_Int32 > aInterfaceTypes( nSize ); |
| sal_Int32 * pArray = aInterfaceTypes.getArray(); |
| |
| t_long2ptr::iterator iter = pMap->begin(); |
| t_long2ptr::iterator end = pMap->end(); |
| |
| sal_Int32 i = 0; |
| while( iter != end ) |
| { |
| // are interfaces added to this container? |
| if( ((OInterfaceContainerHelper*)(*iter).second)->getLength() ) |
| // yes, put the type in the array |
| pArray[i++] = (*iter).first; |
| ++iter; |
| } |
| if( (t_long2ptr::size_type)i != nSize ) { |
| // may be empty container, reduce the sequence to the right size |
| aInterfaceTypes = ::com::sun::star::uno::Sequence< sal_Int32 >( pArray, i ); |
| } |
| return aInterfaceTypes; |
| } |
| return ::com::sun::star::uno::Sequence< sal_Int32 >(); |
| } |
| OInterfaceContainerHelper * OMultiTypeInterfaceContainerHelperInt32::getContainer( const sal_Int32 & rKey ) const |
| SAL_THROW( () ) |
| { |
| ::osl::MutexGuard aGuard( rMutex ); |
| |
| if (!m_pMap) |
| return 0; |
| t_long2ptr * pMap = (t_long2ptr *)m_pMap; |
| t_long2ptr::iterator iter = findLong( pMap, rKey ); |
| if( iter != pMap->end() ) |
| return (OInterfaceContainerHelper*) (*iter).second; |
| return 0; |
| } |
| sal_Int32 OMultiTypeInterfaceContainerHelperInt32::addInterface( |
| const sal_Int32 & rKey, const Reference< XInterface > & rListener ) |
| SAL_THROW( () ) |
| { |
| ::osl::MutexGuard aGuard( rMutex ); |
| if (!m_pMap) |
| m_pMap = new t_long2ptr(); |
| t_long2ptr * pMap = (t_long2ptr *)m_pMap; |
| t_long2ptr::iterator iter = findLong( pMap, rKey ); |
| if( iter == pMap->end() ) |
| { |
| OInterfaceContainerHelper * pLC = new OInterfaceContainerHelper( rMutex ); |
| pMap->push_back(std::pair< sal_Int32, void* >(rKey, pLC)); |
| return pLC->addInterface( rListener ); |
| } |
| else |
| return ((OInterfaceContainerHelper*)(*iter).second)->addInterface( rListener ); |
| } |
| sal_Int32 OMultiTypeInterfaceContainerHelperInt32::removeInterface( |
| const sal_Int32 & rKey, const Reference< XInterface > & rListener ) |
| SAL_THROW( () ) |
| { |
| ::osl::MutexGuard aGuard( rMutex ); |
| |
| if (!m_pMap) |
| return 0; |
| // search container with id nUik |
| t_long2ptr * pMap = (t_long2ptr *)m_pMap; |
| t_long2ptr::iterator iter = findLong( pMap, rKey ); |
| // container found? |
| if( iter != pMap->end() ) |
| return ((OInterfaceContainerHelper*)(*iter).second)->removeInterface( rListener ); |
| |
| // no container with this id. Always return 0 |
| return 0; |
| } |
| void OMultiTypeInterfaceContainerHelperInt32::disposeAndClear( const EventObject & rEvt ) |
| SAL_THROW( () ) |
| { |
| t_long2ptr::size_type nSize = 0; |
| OInterfaceContainerHelper ** ppListenerContainers = NULL; |
| { |
| ::osl::MutexGuard aGuard( rMutex ); |
| if (!m_pMap) |
| return; |
| |
| t_long2ptr * pMap = (t_long2ptr *)m_pMap; |
| nSize = pMap->size(); |
| if( nSize ) |
| { |
| typedef OInterfaceContainerHelper* ppp; |
| ppListenerContainers = new ppp[nSize]; |
| //ppListenerContainers = new (ListenerContainer*)[nSize]; |
| |
| t_long2ptr::iterator iter = pMap->begin(); |
| t_long2ptr::iterator end = pMap->end(); |
| |
| t_long2ptr::size_type i = 0; |
| while( iter != end ) |
| { |
| ppListenerContainers[i++] = (OInterfaceContainerHelper*)(*iter).second; |
| ++iter; |
| } |
| } |
| } |
| |
| // create a copy, because do not fire event in a guarded section |
| for( t_long2ptr::size_type i = 0; |
| i < nSize; i++ ) |
| { |
| if( ppListenerContainers[i] ) |
| ppListenerContainers[i]->disposeAndClear( rEvt ); |
| } |
| |
| delete [] ppListenerContainers; |
| } |
| void OMultiTypeInterfaceContainerHelperInt32::clear() |
| SAL_THROW( () ) |
| { |
| ::osl::MutexGuard aGuard( rMutex ); |
| if (!m_pMap) |
| return; |
| t_long2ptr * pMap = (t_long2ptr *)m_pMap; |
| t_long2ptr::iterator iter = pMap->begin(); |
| t_long2ptr::iterator end = pMap->end(); |
| |
| while( iter != end ) |
| { |
| ((OInterfaceContainerHelper*)(*iter).second)->clear(); |
| ++iter; |
| } |
| } |
| |
| } |
| |