| /************************************************************** |
| * |
| * 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 "osl/diagnose.h" |
| #include "cppuhelper/implbase1.hxx" |
| #include "cppuhelper/weak.hxx" |
| #include "cppuhelper/propshlp.hxx" |
| #include "cppuhelper/exc_hlp.hxx" |
| #include "com/sun/star/beans/PropertyAttribute.hpp" |
| #include "com/sun/star/lang/DisposedException.hpp" |
| |
| |
| using namespace osl; |
| using namespace com::sun::star::uno; |
| using namespace com::sun::star::beans; |
| using namespace com::sun::star::lang; |
| using namespace rtl; |
| using namespace cppu; |
| |
| namespace cppu { |
| |
| IPropertyArrayHelper::~IPropertyArrayHelper() |
| { |
| } |
| |
| inline const ::com::sun::star::uno::Type & getPropertyTypeIdentifier( ) SAL_THROW( () ) |
| { |
| return ::getCppuType( (Reference< XPropertyChangeListener > *)0 ); |
| } |
| inline const ::com::sun::star::uno::Type & getPropertiesTypeIdentifier() SAL_THROW( () ) |
| { |
| return ::getCppuType( (Reference< XPropertiesChangeListener > *)0 ); |
| } |
| inline const ::com::sun::star::uno::Type & getVetoableTypeIdentifier() SAL_THROW( () ) |
| { |
| return ::getCppuType( (Reference< XVetoableChangeListener > *)0 ); |
| } |
| |
| extern "C" { |
| |
| static int compare_OUString_Property_Impl( const void *arg1, const void *arg2 ) |
| SAL_THROW_EXTERN_C() |
| { |
| return ((OUString *)arg1)->compareTo( ((Property *)arg2)->Name ); |
| } |
| |
| } |
| |
| /** |
| * The class which implements the PropertySetInfo interface. |
| */ |
| |
| class OPropertySetHelperInfo_Impl |
| : public WeakImplHelper1< ::com::sun::star::beans::XPropertySetInfo > |
| { |
| Sequence < Property > aInfos; |
| |
| public: |
| OPropertySetHelperInfo_Impl( IPropertyArrayHelper & rHelper_ ) SAL_THROW( () ); |
| |
| // XPropertySetInfo-Methoden |
| virtual Sequence< Property > SAL_CALL getProperties(void) throw(::com::sun::star::uno::RuntimeException); |
| virtual Property SAL_CALL getPropertyByName(const OUString& PropertyName) throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::uno::RuntimeException); |
| virtual sal_Bool SAL_CALL hasPropertyByName(const OUString& PropertyName) throw(::com::sun::star::uno::RuntimeException); |
| }; |
| |
| |
| /** |
| * Create an object that implements XPropertySetInfo IPropertyArrayHelper. |
| */ |
| OPropertySetHelperInfo_Impl::OPropertySetHelperInfo_Impl( |
| IPropertyArrayHelper & rHelper_ ) |
| SAL_THROW( () ) |
| :aInfos( rHelper_.getProperties() ) |
| { |
| } |
| |
| /** |
| * Return the sequence of properties, which are provided throug the constructor. |
| */ |
| Sequence< Property > OPropertySetHelperInfo_Impl::getProperties(void) throw(::com::sun::star::uno::RuntimeException) |
| |
| { |
| return aInfos; |
| } |
| |
| /** |
| * Return the sequence of properties, which are provided throug the constructor. |
| */ |
| Property OPropertySetHelperInfo_Impl::getPropertyByName( const OUString & PropertyName ) throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::uno::RuntimeException) |
| { |
| Property * pR; |
| pR = (Property *)bsearch( &PropertyName, aInfos.getConstArray(), aInfos.getLength(), |
| sizeof( Property ), |
| compare_OUString_Property_Impl ); |
| if( !pR ) { |
| throw UnknownPropertyException(); |
| } |
| |
| return *pR; |
| } |
| |
| /** |
| * Return the sequence of properties, which are provided throug the constructor. |
| */ |
| sal_Bool OPropertySetHelperInfo_Impl::hasPropertyByName( const OUString & PropertyName ) throw(::com::sun::star::uno::RuntimeException) |
| { |
| Property * pR; |
| pR = (Property *)bsearch( &PropertyName, aInfos.getConstArray(), aInfos.getLength(), |
| sizeof( Property ), |
| compare_OUString_Property_Impl ); |
| return pR != NULL; |
| } |
| |
| // ---------------------------------------------------- |
| // class PropertySetHelper_Impl |
| // ---------------------------------------------------- |
| class OPropertySetHelper::Impl { |
| |
| public: |
| Impl( bool i_bIgnoreRuntimeExceptionsWhileFiring, |
| IEventNotificationHook *i_pFireEvents |
| ) |
| :m_bIgnoreRuntimeExceptionsWhileFiring( i_bIgnoreRuntimeExceptionsWhileFiring ) |
| ,m_pFireEvents( i_pFireEvents ) |
| { |
| } |
| |
| bool m_bIgnoreRuntimeExceptionsWhileFiring; |
| class IEventNotificationHook * const m_pFireEvents; |
| |
| ::std::vector< sal_Int32 > m_handles; |
| ::std::vector< Any > m_newValues; |
| ::std::vector< Any > m_oldValues; |
| }; |
| |
| |
| // ---------------------------------------------------- |
| // class PropertySetHelper |
| // ---------------------------------------------------- |
| OPropertySetHelper::OPropertySetHelper( |
| OBroadcastHelper & rBHelper_ ) SAL_THROW( () ) |
| : rBHelper( rBHelper_ ), |
| aBoundLC( rBHelper_.rMutex ), |
| aVetoableLC( rBHelper_.rMutex ), |
| m_pReserved( new Impl(false, 0) ) |
| { |
| } |
| |
| OPropertySetHelper::OPropertySetHelper( |
| OBroadcastHelper & rBHelper_, bool bIgnoreRuntimeExceptionsWhileFiring ) |
| : rBHelper( rBHelper_ ), |
| aBoundLC( rBHelper_.rMutex ), |
| aVetoableLC( rBHelper_.rMutex ), |
| m_pReserved( new Impl( bIgnoreRuntimeExceptionsWhileFiring, 0 ) ) |
| { |
| } |
| |
| OPropertySetHelper::OPropertySetHelper( |
| OBroadcastHelper & rBHelper_, IEventNotificationHook * i_pFireEvents, |
| bool bIgnoreRuntimeExceptionsWhileFiring) |
| : rBHelper( rBHelper_ ), |
| aBoundLC( rBHelper_.rMutex ), |
| aVetoableLC( rBHelper_.rMutex ), |
| m_pReserved( |
| new Impl( bIgnoreRuntimeExceptionsWhileFiring, i_pFireEvents) ) |
| { |
| } |
| |
| /** |
| * You must call disposing before. |
| */ |
| OPropertySetHelper::~OPropertySetHelper() SAL_THROW( () ) |
| { |
| } |
| |
| /** |
| * These method is called from queryInterface, if no delegator is set. |
| * Otherwise this method is called from the delegator. |
| */ |
| // XAggregation |
| Any OPropertySetHelper::queryInterface( const ::com::sun::star::uno::Type & rType ) |
| throw (RuntimeException) |
| { |
| return ::cppu::queryInterface( |
| rType, |
| static_cast< XPropertySet * >( this ), |
| static_cast< XMultiPropertySet * >( this ), |
| static_cast< XFastPropertySet * >( this ) ); |
| } |
| |
| /** |
| * called from the derivee's XTypeProvider::getTypes implementation |
| */ |
| ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > OPropertySetHelper::getTypes() |
| throw (RuntimeException) |
| { |
| Sequence< ::com::sun::star::uno::Type > aTypes( 3 ); |
| aTypes[ 0 ] = XPropertySet::static_type(); |
| aTypes[ 1 ] = XMultiPropertySet::static_type(); |
| aTypes[ 2 ] = XFastPropertySet::static_type(); |
| return aTypes; |
| } |
| |
| // ComponentHelper |
| void OPropertySetHelper::disposing() SAL_THROW( () ) |
| { |
| // Create an event with this as sender |
| Reference < XPropertySet > rSource( SAL_STATIC_CAST( XPropertySet * , this ) , UNO_QUERY ); |
| EventObject aEvt; |
| aEvt.Source = rSource; |
| |
| // inform all listeners to reelease this object |
| // The listener container are automaticly cleared |
| aBoundLC.disposeAndClear( aEvt ); |
| aVetoableLC.disposeAndClear( aEvt ); |
| } |
| |
| Reference < XPropertySetInfo > OPropertySetHelper::createPropertySetInfo( |
| IPropertyArrayHelper & rProperties ) SAL_THROW( () ) |
| { |
| return static_cast< XPropertySetInfo * >( new OPropertySetHelperInfo_Impl( rProperties ) ); |
| } |
| |
| // XPropertySet |
| void OPropertySetHelper::setPropertyValue( |
| const OUString& rPropertyName, const Any& rValue ) |
| throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::beans::PropertyVetoException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException) |
| { |
| // get the map table |
| IPropertyArrayHelper & rPH = getInfoHelper(); |
| // map the name to the handle |
| sal_Int32 nHandle = rPH.getHandleByName( rPropertyName ); |
| // call the method of the XFastPropertySet interface |
| setFastPropertyValue( nHandle, rValue ); |
| } |
| |
| // XPropertySet |
| Any OPropertySetHelper::getPropertyValue( |
| const OUString& rPropertyName ) |
| throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException) |
| { |
| // get the map table |
| IPropertyArrayHelper & rPH = getInfoHelper(); |
| // map the name to the handle |
| sal_Int32 nHandle = rPH.getHandleByName( rPropertyName ); |
| // call the method of the XFastPropertySet interface |
| return getFastPropertyValue( nHandle ); |
| } |
| |
| // XPropertySet |
| void OPropertySetHelper::addPropertyChangeListener( |
| const OUString& rPropertyName, |
| const Reference < XPropertyChangeListener > & rxListener ) |
| throw(::com::sun::star::beans::UnknownPropertyException, |
| ::com::sun::star::lang::WrappedTargetException, |
| ::com::sun::star::uno::RuntimeException) |
| { |
| MutexGuard aGuard( rBHelper.rMutex ); |
| OSL_ENSURE( !rBHelper.bInDispose, "do not addPropertyChangeListener in the dispose call" ); |
| OSL_ENSURE( !rBHelper.bDisposed, "object is disposed" ); |
| if( !rBHelper.bInDispose && !rBHelper.bDisposed ) |
| { |
| // only add listeners if you are not disposed |
| // a listener with no name means all properties |
| if( rPropertyName.getLength() ) |
| { |
| // get the map table |
| IPropertyArrayHelper & rPH = getInfoHelper(); |
| // map the name to the handle |
| sal_Int32 nHandle = rPH.getHandleByName( rPropertyName ); |
| if( nHandle == -1 ) { |
| // property not known throw exception |
| throw UnknownPropertyException() ; |
| } |
| |
| sal_Int16 nAttributes; |
| rPH.fillPropertyMembersByHandle( NULL, &nAttributes, nHandle ); |
| if( !(nAttributes & ::com::sun::star::beans::PropertyAttribute::BOUND) ) |
| { |
| OSL_ENSURE( sal_False, "add listener to an unbound property" ); |
| // silent ignore this |
| return; |
| } |
| // add the change listener to the helper container |
| |
| aBoundLC.addInterface( (sal_Int32)nHandle, rxListener ); |
| } |
| else |
| // add the change listener to the helper container |
| rBHelper.aLC.addInterface( |
| getPropertyTypeIdentifier( ), |
| rxListener |
| ); |
| } |
| } |
| |
| |
| // XPropertySet |
| void OPropertySetHelper::removePropertyChangeListener( |
| const OUString& rPropertyName, |
| const Reference < XPropertyChangeListener >& rxListener ) |
| throw(::com::sun::star::beans::UnknownPropertyException, |
| ::com::sun::star::lang::WrappedTargetException, |
| ::com::sun::star::uno::RuntimeException) |
| { |
| MutexGuard aGuard( rBHelper.rMutex ); |
| OSL_ENSURE( !rBHelper.bDisposed, "object is disposed" ); |
| // all listeners are automaticly released in a dispose call |
| if( !rBHelper.bInDispose && !rBHelper.bDisposed ) |
| { |
| if( rPropertyName.getLength() ) |
| { |
| // get the map table |
| IPropertyArrayHelper & rPH = getInfoHelper(); |
| // map the name to the handle |
| sal_Int32 nHandle = rPH.getHandleByName( rPropertyName ); |
| if( nHandle == -1 ) |
| // property not known throw exception |
| throw UnknownPropertyException(); |
| aBoundLC.removeInterface( (sal_Int32)nHandle, rxListener ); |
| } |
| else { |
| // remove the change listener to the helper container |
| rBHelper.aLC.removeInterface( |
| getPropertyTypeIdentifier( ), |
| rxListener |
| ); |
| } |
| } |
| } |
| |
| // XPropertySet |
| void OPropertySetHelper::addVetoableChangeListener( |
| const OUString& rPropertyName, |
| const Reference< XVetoableChangeListener > & rxListener ) |
| throw(::com::sun::star::beans::UnknownPropertyException, |
| ::com::sun::star::lang::WrappedTargetException, |
| ::com::sun::star::uno::RuntimeException) |
| { |
| MutexGuard aGuard( rBHelper.rMutex ); |
| OSL_ENSURE( !rBHelper.bInDispose, "do not addVetoableChangeListener in the dispose call" ); |
| OSL_ENSURE( !rBHelper.bDisposed, "object is disposed" ); |
| if( !rBHelper.bInDispose && !rBHelper.bDisposed ) |
| { |
| // only add listeners if you are not disposed |
| // a listener with no name means all properties |
| if( rPropertyName.getLength() ) |
| { |
| // get the map table |
| IPropertyArrayHelper & rPH = getInfoHelper(); |
| // map the name to the handle |
| sal_Int32 nHandle = rPH.getHandleByName( rPropertyName ); |
| if( nHandle == -1 ) { |
| // property not known throw exception |
| throw UnknownPropertyException(); |
| } |
| |
| sal_Int16 nAttributes; |
| rPH.fillPropertyMembersByHandle( NULL, &nAttributes, nHandle ); |
| if( !(nAttributes & PropertyAttribute::CONSTRAINED) ) |
| { |
| OSL_ENSURE( sal_False, "addVetoableChangeListener, and property is not constrained" ); |
| // silent ignore this |
| return; |
| } |
| // add the vetoable listener to the helper container |
| aVetoableLC.addInterface( (sal_Int32)nHandle, rxListener ); |
| } |
| else |
| // add the vetoable listener to the helper container |
| rBHelper.aLC.addInterface( |
| getVetoableTypeIdentifier( ), |
| rxListener |
| ); |
| } |
| } |
| |
| // XPropertySet |
| void OPropertySetHelper::removeVetoableChangeListener( |
| const OUString& rPropertyName, |
| const Reference < XVetoableChangeListener > & rxListener ) |
| throw(::com::sun::star::beans::UnknownPropertyException, |
| ::com::sun::star::lang::WrappedTargetException, |
| ::com::sun::star::uno::RuntimeException) |
| { |
| MutexGuard aGuard( rBHelper.rMutex ); |
| OSL_ENSURE( !rBHelper.bDisposed, "object is disposed" ); |
| // all listeners are automaticly released in a dispose call |
| if( !rBHelper.bInDispose && !rBHelper.bDisposed ) |
| { |
| if( rPropertyName.getLength() ) |
| { |
| // get the map table |
| IPropertyArrayHelper & rPH = getInfoHelper(); |
| // map the name to the handle |
| sal_Int32 nHandle = rPH.getHandleByName( rPropertyName ); |
| if( nHandle == -1 ) { |
| // property not known throw exception |
| throw UnknownPropertyException(); |
| } |
| // remove the vetoable listener to the helper container |
| aVetoableLC.removeInterface( (sal_Int32)nHandle, rxListener ); |
| } |
| else |
| // add the vetoable listener to the helper container |
| rBHelper.aLC.removeInterface( |
| getVetoableTypeIdentifier( ), |
| rxListener |
| ); |
| } |
| } |
| |
| void OPropertySetHelper::setDependentFastPropertyValue( sal_Int32 i_handle, const ::com::sun::star::uno::Any& i_value ) |
| { |
| //OSL_PRECOND( rBHelper.rMutex.isAcquired(), "OPropertySetHelper::setDependentFastPropertyValue: to be called with a locked mutex only!" ); |
| // there is no such thing as Mutex.isAcquired, sadly ... |
| |
| sal_Int16 nAttributes(0); |
| IPropertyArrayHelper& rInfo = getInfoHelper(); |
| if ( !rInfo.fillPropertyMembersByHandle( NULL, &nAttributes, i_handle ) ) |
| // unknown property |
| throw UnknownPropertyException(); |
| |
| // no need to check for READONLY-ness of the property. The method is intended to be called internally, which |
| // implies it might be invoked for properties which are read-only to the instance's clients, but well allowed |
| // to change their value. |
| |
| Any aConverted, aOld; |
| sal_Bool bChanged = convertFastPropertyValue( aConverted, aOld, i_handle, i_value ); |
| if ( !bChanged ) |
| return; |
| |
| // don't fire vetoable events. This method is called with our mutex locked, so calling into listeners would not be |
| // a good idea. The caler is responsible for not invoking this for constrained properties. |
| OSL_ENSURE( ( nAttributes & PropertyAttribute::CONSTRAINED ) == 0, |
| "OPropertySetHelper::setDependentFastPropertyValue: not to be used for constrained properties!" ); |
| (void)nAttributes; |
| |
| // actually set the new value |
| try |
| { |
| setFastPropertyValue_NoBroadcast( i_handle, aConverted ); |
| } |
| catch (const UnknownPropertyException& ) { throw; /* allowed to leave */ } |
| catch (const PropertyVetoException& ) { throw; /* allowed to leave */ } |
| catch (const IllegalArgumentException& ) { throw; /* allowed to leave */ } |
| catch (const WrappedTargetException& ) { throw; /* allowed to leave */ } |
| catch (const RuntimeException& ) { throw; /* allowed to leave */ } |
| catch (const Exception& ) |
| { |
| // not allowed to leave this meathod |
| WrappedTargetException aWrapped; |
| aWrapped.TargetException <<= ::cppu::getCaughtException(); |
| aWrapped.Context = static_cast< XPropertySet* >( this ); |
| throw aWrapped; |
| } |
| |
| // remember the handle/values, for the events to be fired later |
| m_pReserved->m_handles.push_back( i_handle ); |
| m_pReserved->m_newValues.push_back( aConverted ); // TODO: setFastPropertyValue notifies the unconverted value here ...? |
| m_pReserved->m_oldValues.push_back( aOld ); |
| } |
| |
| // XFastPropertySet |
| void OPropertySetHelper::setFastPropertyValue( sal_Int32 nHandle, const Any& rValue ) |
| throw(::com::sun::star::beans::UnknownPropertyException, |
| ::com::sun::star::beans::PropertyVetoException, |
| ::com::sun::star::lang::IllegalArgumentException, |
| ::com::sun::star::lang::WrappedTargetException, |
| ::com::sun::star::uno::RuntimeException) |
| { |
| OSL_ENSURE( !rBHelper.bInDispose, "do not setFastPropertyValue in the dispose call" ); |
| OSL_ENSURE( !rBHelper.bDisposed, "object is disposed" ); |
| |
| IPropertyArrayHelper & rInfo = getInfoHelper(); |
| sal_Int16 nAttributes; |
| if( !rInfo.fillPropertyMembersByHandle( NULL, &nAttributes, nHandle ) ) { |
| // unknown property |
| throw UnknownPropertyException(); |
| } |
| if( nAttributes & PropertyAttribute::READONLY ) |
| throw PropertyVetoException(); |
| |
| Any aConvertedVal; |
| Any aOldVal; |
| |
| // Will the property change? |
| sal_Bool bChanged; |
| { |
| MutexGuard aGuard( rBHelper.rMutex ); |
| bChanged = convertFastPropertyValue( aConvertedVal, aOldVal, nHandle, rValue ); |
| // release guard to fire events |
| } |
| if( bChanged ) |
| { |
| // Is it a constrained property? |
| if( nAttributes & PropertyAttribute::CONSTRAINED ) |
| { |
| // In aValue is the converted rValue |
| // fire a constarined event |
| // second parameter NULL means constrained |
| fire( &nHandle, &rValue, &aOldVal, 1, sal_True ); |
| } |
| |
| { |
| MutexGuard aGuard( rBHelper.rMutex ); |
| try |
| { |
| // set the property to the new value |
| setFastPropertyValue_NoBroadcast( nHandle, aConvertedVal ); |
| } |
| catch (const ::com::sun::star::beans::UnknownPropertyException& ) { throw; /* allowed to leave */ } |
| catch (const ::com::sun::star::beans::PropertyVetoException& ) { throw; /* allowed to leave */ } |
| catch (const ::com::sun::star::lang::IllegalArgumentException& ) { throw; /* allowed to leave */ } |
| catch (const ::com::sun::star::lang::WrappedTargetException& ) { throw; /* allowed to leave */ } |
| catch (const ::com::sun::star::uno::RuntimeException& ) { throw; /* allowed to leave */ } |
| catch (const ::com::sun::star::uno::Exception& e ) |
| { |
| // not allowed to leave this meathod |
| ::com::sun::star::lang::WrappedTargetException aWrap; |
| aWrap.Context = static_cast< ::com::sun::star::beans::XPropertySet* >( this ); |
| aWrap.TargetException <<= e; |
| |
| throw ::com::sun::star::lang::WrappedTargetException( aWrap ); |
| } |
| |
| // release guard to fire events |
| } |
| // file a change event, if the value changed |
| impl_fireAll( &nHandle, &rValue, &aOldVal, 1 ); |
| } |
| } |
| |
| // XFastPropertySet |
| Any OPropertySetHelper::getFastPropertyValue( sal_Int32 nHandle ) |
| throw(::com::sun::star::beans::UnknownPropertyException, |
| ::com::sun::star::lang::WrappedTargetException, |
| ::com::sun::star::uno::RuntimeException) |
| |
| { |
| IPropertyArrayHelper & rInfo = getInfoHelper(); |
| if( !rInfo.fillPropertyMembersByHandle( NULL, NULL, nHandle ) ) |
| // unknown property |
| throw UnknownPropertyException(); |
| |
| Any aRet; |
| MutexGuard aGuard( rBHelper.rMutex ); |
| getFastPropertyValue( aRet, nHandle ); |
| return aRet; |
| } |
| |
| //-------------------------------------------------------------------------- |
| void OPropertySetHelper::impl_fireAll( sal_Int32* i_handles, const Any* i_newValues, const Any* i_oldValues, sal_Int32 i_count ) |
| { |
| ClearableMutexGuard aGuard( rBHelper.rMutex ); |
| if ( m_pReserved->m_handles.empty() ) |
| { |
| aGuard.clear(); |
| fire( i_handles, i_newValues, i_oldValues, i_count, sal_False ); |
| return; |
| } |
| |
| const size_t additionalEvents = m_pReserved->m_handles.size(); |
| OSL_ENSURE( additionalEvents == m_pReserved->m_newValues.size() |
| && additionalEvents == m_pReserved->m_oldValues.size(), |
| "OPropertySetHelper::impl_fireAll: inconsistency!" ); |
| |
| ::std::vector< sal_Int32 > allHandles( additionalEvents + i_count ); |
| ::std::copy( m_pReserved->m_handles.begin(), m_pReserved->m_handles.end(), allHandles.begin() ); |
| ::std::copy( i_handles, i_handles + i_count, allHandles.begin() + additionalEvents ); |
| |
| ::std::vector< Any > allNewValues( additionalEvents + i_count ); |
| ::std::copy( m_pReserved->m_newValues.begin(), m_pReserved->m_newValues.end(), allNewValues.begin() ); |
| ::std::copy( i_newValues, i_newValues + i_count, allNewValues.begin() + additionalEvents ); |
| |
| ::std::vector< Any > allOldValues( additionalEvents + i_count ); |
| ::std::copy( m_pReserved->m_oldValues.begin(), m_pReserved->m_oldValues.end(), allOldValues.begin() ); |
| ::std::copy( i_oldValues, i_oldValues + i_count, allOldValues.begin() + additionalEvents ); |
| |
| m_pReserved->m_handles.clear(); |
| m_pReserved->m_newValues.clear(); |
| m_pReserved->m_oldValues.clear(); |
| |
| aGuard.clear(); |
| fire( &allHandles[0], &allNewValues[0], &allOldValues[0], additionalEvents + i_count, sal_False ); |
| } |
| |
| //-------------------------------------------------------------------------- |
| void OPropertySetHelper::fire |
| ( |
| sal_Int32 * pnHandles, |
| const Any * pNewValues, |
| const Any * pOldValues, |
| sal_Int32 nHandles, // These is the Count of the array |
| sal_Bool bVetoable |
| ) |
| { |
| OSL_ENSURE( m_pReserved.get(), "No OPropertySetHelper::Impl" ); |
| if (m_pReserved->m_pFireEvents) { |
| m_pReserved->m_pFireEvents->fireEvents( |
| pnHandles, nHandles, bVetoable, |
| m_pReserved->m_bIgnoreRuntimeExceptionsWhileFiring); |
| } |
| |
| // Only fire, if one or more properties changed |
| if( nHandles ) |
| { |
| // create the event sequence of all changed properties |
| Sequence< PropertyChangeEvent > aEvts( nHandles ); |
| PropertyChangeEvent * pEvts = aEvts.getArray(); |
| Reference < XInterface > xSource( (XPropertySet *)this, UNO_QUERY ); |
| sal_Int32 i; |
| sal_Int32 nChangesLen = 0; |
| // Loop over all changed properties to fill the event struct |
| for( i = 0; i < nHandles; i++ ) |
| { |
| // Vetoable fire and constrained attribute set or |
| // Change fire and Changed and bound attribute set |
| IPropertyArrayHelper & rInfo = getInfoHelper(); |
| sal_Int16 nAttributes; |
| OUString aPropName; |
| rInfo.fillPropertyMembersByHandle( &aPropName, &nAttributes, pnHandles[i] ); |
| |
| if( |
| (bVetoable && (nAttributes & PropertyAttribute::CONSTRAINED)) || |
| (!bVetoable && (nAttributes & PropertyAttribute::BOUND)) |
| ) |
| { |
| pEvts[nChangesLen].Source = xSource; |
| pEvts[nChangesLen].PropertyName = aPropName; |
| pEvts[nChangesLen].PropertyHandle = pnHandles[i]; |
| pEvts[nChangesLen].OldValue = pOldValues[i]; |
| pEvts[nChangesLen].NewValue = pNewValues[i]; |
| nChangesLen++; |
| } |
| } |
| |
| bool bIgnoreRuntimeExceptionsWhileFiring = |
| m_pReserved->m_bIgnoreRuntimeExceptionsWhileFiring; |
| |
| // fire the events for all changed properties |
| for( i = 0; i < nChangesLen; i++ ) |
| { |
| // get the listener container for the property name |
| OInterfaceContainerHelper * pLC; |
| if( bVetoable ) // fire change Events? |
| pLC = aVetoableLC.getContainer( pEvts[i].PropertyHandle ); |
| else |
| pLC = aBoundLC.getContainer( pEvts[i].PropertyHandle ); |
| if( pLC ) |
| { |
| // Ueber alle Listener iterieren und Events senden |
| OInterfaceIteratorHelper aIt( *pLC); |
| while( aIt.hasMoreElements() ) |
| { |
| XInterface * pL = aIt.next(); |
| try |
| { |
| try |
| { |
| if( bVetoable ) // fire change Events? |
| { |
| ((XVetoableChangeListener *)pL)->vetoableChange( |
| pEvts[i] ); |
| } |
| else |
| { |
| ((XPropertyChangeListener *)pL)->propertyChange( |
| pEvts[i] ); |
| } |
| } |
| catch (DisposedException & exc) |
| { |
| OSL_ENSURE( exc.Context.is(), |
| "DisposedException without Context!" ); |
| if (exc.Context == pL) |
| aIt.remove(); |
| else |
| throw; |
| } |
| } |
| catch (RuntimeException & exc) |
| { |
| OSL_TRACE( |
| OUStringToOString( |
| OUString( RTL_CONSTASCII_USTRINGPARAM( |
| "caught RuntimeException while " |
| "firing listeners: ") ) + |
| exc.Message, RTL_TEXTENCODING_UTF8 ).getStr() ); |
| if (! bIgnoreRuntimeExceptionsWhileFiring) |
| throw; |
| } |
| } |
| } |
| // broadcast to all listeners with "" property name |
| if( bVetoable ){ |
| // fire change Events? |
| pLC = rBHelper.aLC.getContainer( |
| getVetoableTypeIdentifier() |
| ); |
| } |
| else { |
| pLC = rBHelper.aLC.getContainer( |
| getPropertyTypeIdentifier( ) |
| ); |
| } |
| if( pLC ) |
| { |
| // Ueber alle Listener iterieren und Events senden |
| OInterfaceIteratorHelper aIt( *pLC); |
| while( aIt.hasMoreElements() ) |
| { |
| XInterface * pL = aIt.next(); |
| try |
| { |
| try |
| { |
| if( bVetoable ) // fire change Events? |
| { |
| ((XVetoableChangeListener *)pL)->vetoableChange( |
| pEvts[i] ); |
| } |
| else |
| { |
| ((XPropertyChangeListener *)pL)->propertyChange( |
| pEvts[i] ); |
| } |
| } |
| catch (DisposedException & exc) |
| { |
| OSL_ENSURE( exc.Context.is(), |
| "DisposedException without Context!" ); |
| if (exc.Context == pL) |
| aIt.remove(); |
| else |
| throw; |
| } |
| } |
| catch (RuntimeException & exc) |
| { |
| OSL_TRACE( |
| OUStringToOString( |
| OUString( RTL_CONSTASCII_USTRINGPARAM( |
| "caught RuntimeException while " |
| "firing listeners: ") ) + |
| exc.Message, RTL_TEXTENCODING_UTF8 ).getStr() ); |
| if (! bIgnoreRuntimeExceptionsWhileFiring) |
| throw; |
| } |
| } |
| } |
| } |
| |
| // reduce array to changed properties |
| aEvts.realloc( nChangesLen ); |
| |
| if( !bVetoable ) |
| { |
| OInterfaceContainerHelper * pCont = 0; |
| pCont = rBHelper.aLC.getContainer( |
| getPropertiesTypeIdentifier( ) |
| ); |
| if( pCont ) |
| { |
| // Here is a Bug, unbound properties are also fired |
| OInterfaceIteratorHelper aIt( *pCont ); |
| while( aIt.hasMoreElements() ) |
| { |
| XPropertiesChangeListener * pL = |
| (XPropertiesChangeListener *)aIt.next(); |
| try |
| { |
| try |
| { |
| // fire the hole event sequence to the |
| // XPropertiesChangeListener's |
| pL->propertiesChange( aEvts ); |
| } |
| catch (DisposedException & exc) |
| { |
| OSL_ENSURE( exc.Context.is(), |
| "DisposedException without Context!" ); |
| if (exc.Context == pL) |
| aIt.remove(); |
| else |
| throw; |
| } |
| } |
| catch (RuntimeException & exc) |
| { |
| OSL_TRACE( |
| OUStringToOString( |
| OUString( RTL_CONSTASCII_USTRINGPARAM( |
| "caught RuntimeException while " |
| "firing listeners: ") ) + |
| exc.Message, RTL_TEXTENCODING_UTF8 ).getStr() ); |
| if (! bIgnoreRuntimeExceptionsWhileFiring) |
| throw; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| // OPropertySetHelper |
| void OPropertySetHelper::setFastPropertyValues( |
| sal_Int32 nSeqLen, |
| sal_Int32 * pHandles, |
| const Any * pValues, |
| sal_Int32 nHitCount ) |
| SAL_THROW( (::com::sun::star::uno::Exception) ) |
| { |
| OSL_ENSURE( !rBHelper.bInDispose, "do not getFastPropertyValue in the dispose call" ); |
| OSL_ENSURE( !rBHelper.bDisposed, "object is disposed" ); |
| |
| Any * pConvertedValues = NULL; |
| Any * pOldValues = NULL; |
| |
| try |
| { |
| // get the map table |
| IPropertyArrayHelper & rPH = getInfoHelper(); |
| |
| pConvertedValues = new Any[ nHitCount ]; |
| pOldValues = new Any[ nHitCount ]; |
| sal_Int32 n = 0; |
| sal_Int32 i; |
| |
| { |
| // must lock the mutex outside the loop. So all values are consistent. |
| MutexGuard aGuard( rBHelper.rMutex ); |
| for( i = 0; i < nSeqLen; i++ ) |
| { |
| if( pHandles[i] != -1 ) |
| { |
| sal_Int16 nAttributes; |
| rPH.fillPropertyMembersByHandle( NULL, &nAttributes, pHandles[i] ); |
| if( nAttributes & PropertyAttribute::READONLY ) { |
| throw PropertyVetoException(); |
| } |
| // Will the property change? |
| if( convertFastPropertyValue( pConvertedValues[ n ], pOldValues[n], |
| pHandles[i], pValues[i] ) ) |
| { |
| // only increment if the property really change |
| pHandles[n] = pHandles[i]; |
| n++; |
| } |
| } |
| } |
| // release guard to fire events |
| } |
| |
| // fire vetoable events |
| fire( pHandles, pConvertedValues, pOldValues, n, sal_True ); |
| |
| { |
| // must lock the mutex outside the loop. |
| MutexGuard aGuard( rBHelper.rMutex ); |
| // Loop over all changed properties |
| for( i = 0; i < n; i++ ) |
| { |
| // Will the property change? |
| setFastPropertyValue_NoBroadcast( pHandles[i], pConvertedValues[i] ); |
| } |
| // release guard to fire events |
| } |
| |
| // fire change events |
| impl_fireAll( pHandles, pConvertedValues, pOldValues, n ); |
| } |
| catch( ... ) |
| { |
| delete [] pOldValues; |
| delete [] pConvertedValues; |
| throw; |
| } |
| delete [] pOldValues; |
| delete [] pConvertedValues; |
| } |
| |
| // XMultiPropertySet |
| /** |
| * The sequence may be conatain not known properties. The implementation |
| * must ignore these properties. |
| */ |
| void OPropertySetHelper::setPropertyValues( |
| const Sequence<OUString>& rPropertyNames, |
| const Sequence<Any>& rValues ) |
| throw(::com::sun::star::beans::PropertyVetoException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException) |
| { |
| sal_Int32 * pHandles = NULL; |
| try |
| { |
| sal_Int32 nSeqLen = rPropertyNames.getLength(); |
| pHandles = new sal_Int32[ nSeqLen ]; |
| // get the map table |
| IPropertyArrayHelper & rPH = getInfoHelper(); |
| // fill the handle array |
| sal_Int32 nHitCount = rPH.fillHandles( pHandles, rPropertyNames ); |
| if( nHitCount != 0 ) |
| setFastPropertyValues( nSeqLen, pHandles, rValues.getConstArray(), nHitCount ); |
| } |
| catch( ... ) |
| { |
| delete [] pHandles; |
| throw; |
| } |
| delete [] pHandles; |
| } |
| |
| // XMultiPropertySet |
| Sequence<Any> OPropertySetHelper::getPropertyValues( const Sequence<OUString>& rPropertyNames ) |
| throw(::com::sun::star::uno::RuntimeException) |
| { |
| sal_Int32 nSeqLen = rPropertyNames.getLength(); |
| sal_Int32 * pHandles = new sal_Int32[ nSeqLen ]; |
| Sequence< Any > aValues( nSeqLen ); |
| |
| // get the map table |
| IPropertyArrayHelper & rPH = getInfoHelper(); |
| // fill the handle array |
| rPH.fillHandles( pHandles, rPropertyNames ); |
| |
| Any * pValues = aValues.getArray(); |
| |
| MutexGuard aGuard( rBHelper.rMutex ); |
| // fill the sequence with the values |
| for( sal_Int32 i = 0; i < nSeqLen; i++ ) |
| getFastPropertyValue( pValues[i], pHandles[i] ); |
| |
| delete [] pHandles; |
| return aValues; |
| } |
| |
| // XMultiPropertySet |
| void OPropertySetHelper::addPropertiesChangeListener( |
| const Sequence<OUString> & , |
| const Reference < XPropertiesChangeListener > & rListener ) |
| throw(::com::sun::star::uno::RuntimeException) |
| { |
| rBHelper.addListener( getCppuType(&rListener) , rListener ); |
| } |
| |
| // XMultiPropertySet |
| void OPropertySetHelper::removePropertiesChangeListener( |
| const Reference < XPropertiesChangeListener > & rListener ) |
| throw(::com::sun::star::uno::RuntimeException) |
| { |
| rBHelper.removeListener( getCppuType(&rListener) , rListener ); |
| } |
| |
| // XMultiPropertySet |
| void OPropertySetHelper::firePropertiesChangeEvent( |
| const Sequence<OUString>& rPropertyNames, |
| const Reference < XPropertiesChangeListener >& rListener ) |
| throw(::com::sun::star::uno::RuntimeException) |
| { |
| sal_Int32 nLen = rPropertyNames.getLength(); |
| sal_Int32 * pHandles = new sal_Int32[nLen]; |
| IPropertyArrayHelper & rPH = getInfoHelper(); |
| rPH.fillHandles( pHandles, rPropertyNames ); |
| const OUString* pNames = rPropertyNames.getConstArray(); |
| |
| // get the count of matching properties |
| sal_Int32 nFireLen = 0; |
| sal_Int32 i; |
| for( i = 0; i < nLen; i++ ) |
| if( pHandles[i] != -1 ) |
| nFireLen++; |
| |
| Sequence<PropertyChangeEvent> aChanges( nFireLen ); |
| PropertyChangeEvent* pChanges = aChanges.getArray(); |
| |
| sal_Int32 nFirePos = 0; |
| { |
| // must lock the mutex outside the loop. So all values are consistent. |
| MutexGuard aGuard( rBHelper.rMutex ); |
| Reference < XInterface > xSource( (XPropertySet *)this, UNO_QUERY ); |
| for( i = 0; i < nLen; i++ ) |
| { |
| if( pHandles[i] != -1 ) |
| { |
| pChanges[nFirePos].Source = xSource; |
| pChanges[nFirePos].PropertyName = pNames[i]; |
| pChanges[nFirePos].PropertyHandle = pHandles[i]; |
| getFastPropertyValue( pChanges[nFirePos].OldValue, pHandles[i] ); |
| pChanges[nFirePos].NewValue = pChanges[nFirePos].OldValue; |
| nFirePos++; |
| } |
| } |
| // release guard to fire events |
| } |
| if( nFireLen ) |
| rListener->propertiesChange( aChanges ); |
| |
| delete [] pHandles; |
| } |
| |
| #ifdef xdvnsdfln |
| // XPropertyState |
| PropertyState OPropertySetHelper::getPropertyState( const OUString& PropertyName ) |
| { |
| PropertyState aState; |
| return aState; |
| } |
| |
| // XPropertyState |
| Sequence< PropertyState > OPropertySetHelper::getPropertyStates( const Sequence< OUString >& PropertyNames ) |
| { |
| ULONG nNames = PropertyNames.getLength(); |
| const OUString* pNames = PropertyNames.getConstArray(); |
| |
| Sequence< PropertyState > aStates( nNames ); |
| return aStates; |
| |
| } |
| |
| void OPropertySetHelper::setPropertyToDefault( const OUString& aPropertyName ) |
| { |
| setPropertyValue( aPropertyName, Any() ); |
| } |
| |
| Any OPropertySetHelper::getPropertyDefault( const OUString& aPropertyName ) const |
| { |
| return Any(); |
| } |
| |
| void OPropertySetHelper::addPropertyStateChangeListener( const OUString& aPropertyName, const XPropertyStateChangeListenerRef& Listener ) |
| { |
| } |
| |
| void OPropertySetHelper::removePropertyStateChangeListener( const OUString& aPropertyName, const XPropertyStateChangeListenerRef& Listener ) |
| { |
| } |
| #endif |
| |
| //======================================================================== |
| //== OPropertyArrayHelper ================================================ |
| //======================================================================== |
| |
| //======================================================================== |
| |
| // static OUString makeOUString( sal_Char *p ) |
| // { |
| // sal_Int32 nLen = strlen(p); |
| // sal_Unicode *pw = new sal_Unicode[nLen]; |
| |
| // for( int i = 0 ; i < nLen ; i ++ ) { |
| |
| // // Only ascii strings allowed with this helper ! |
| // OSL_ASSERT( p[i] < 127 ); |
| // pw[i] = p[i]; |
| // } |
| // OUString ow( pw , nLen ); |
| // delete pw; |
| // return ow; |
| // } |
| |
| extern "C" { |
| |
| static int compare_Property_Impl( const void *arg1, const void *arg2 ) |
| SAL_THROW_EXTERN_C() |
| { |
| return ((Property *)arg1)->Name.compareTo( ((Property *)arg2)->Name ); |
| } |
| |
| } |
| |
| void OPropertyArrayHelper::init( sal_Bool bSorted ) SAL_THROW( () ) |
| { |
| sal_Int32 i, nElements = aInfos.getLength(); |
| const Property* pProperties = aInfos.getConstArray(); |
| |
| for( i = 1; i < nElements; i++ ) |
| { |
| if( pProperties[i-1].Name >= pProperties[i].Name ) |
| { |
| #ifndef OS2 // YD disabled, too many troubles with debug builds! |
| if (bSorted) { |
| OSL_ENSURE( false, "Property array is not sorted" ); |
| } |
| #endif |
| // not sorted |
| qsort( aInfos.getArray(), nElements, sizeof( Property ), |
| compare_Property_Impl ); |
| break; |
| } |
| } |
| // may be that the array is resorted |
| pProperties = aInfos.getConstArray(); |
| for( i = 0; i < nElements; i++ ) |
| if( pProperties[i].Handle != i ) |
| return; |
| // The handle is the index |
| bRightOrdered = sal_True; |
| } |
| |
| OPropertyArrayHelper::OPropertyArrayHelper( |
| Property * pProps, |
| sal_Int32 nEle, |
| sal_Bool bSorted ) |
| SAL_THROW( () ) |
| : aInfos(pProps, nEle) |
| , bRightOrdered( sal_False ) |
| { |
| init( bSorted ); |
| } |
| |
| OPropertyArrayHelper::OPropertyArrayHelper( |
| const Sequence< Property > & aProps, |
| sal_Bool bSorted ) |
| SAL_THROW( () ) |
| : aInfos(aProps) |
| , bRightOrdered( sal_False ) |
| { |
| init( bSorted ); |
| } |
| |
| //======================================================================== |
| sal_Int32 OPropertyArrayHelper::getCount() const |
| { |
| return aInfos.getLength(); |
| } |
| |
| //======================================================================== |
| sal_Bool OPropertyArrayHelper::fillPropertyMembersByHandle |
| ( |
| OUString * pPropName, |
| sal_Int16 * pAttributes, |
| sal_Int32 nHandle |
| ) |
| { |
| const Property* pProperties = aInfos.getConstArray(); |
| sal_Int32 nElements = aInfos.getLength(); |
| |
| if( bRightOrdered ) |
| { |
| if( nHandle < 0 || nHandle >= nElements ) |
| return sal_False; |
| if( pPropName ) |
| *pPropName = pProperties[ nHandle ].Name; |
| if( pAttributes ) |
| *pAttributes = pProperties[ nHandle ].Attributes; |
| return sal_True; |
| } |
| else |
| { |
| // normally the array is sorted |
| for( sal_Int32 i = 0; i < nElements; i++ ) |
| { |
| if( pProperties[i].Handle == nHandle ) |
| { |
| if( pPropName ) |
| *pPropName = pProperties[ i ].Name; |
| if( pAttributes ) |
| *pAttributes = pProperties[ i ].Attributes; |
| return sal_True; |
| } |
| } |
| } |
| return sal_False; |
| } |
| |
| //======================================================================== |
| Sequence< Property > OPropertyArrayHelper::getProperties(void) |
| { |
| /*if( aInfos.getLength() != nElements ) |
| { |
| ((OPropertyArrayHelper *)this)->aInfos.realloc( nElements ); |
| Property * pProps = ((OPropertyArrayHelper *)this)->aInfos.getArray(); |
| for( sal_Int32 i = 0; i < nElements; i++ ) |
| { |
| pProps[i].Name = pProperties[i].Name; |
| pProps[i].Handle = pProperties[i].Handle; |
| pProps[i].Type = pProperties[i].Type; |
| pProps[i].Attributes = pProperties[i].Attributes; |
| } |
| }*/ |
| return aInfos; |
| } |
| |
| //======================================================================== |
| Property OPropertyArrayHelper::getPropertyByName(const OUString& aPropertyName) |
| throw (UnknownPropertyException) |
| { |
| Property * pR; |
| pR = (Property *)bsearch( &aPropertyName, aInfos.getConstArray(), aInfos.getLength(), |
| sizeof( Property ), |
| compare_OUString_Property_Impl ); |
| if( !pR ) { |
| throw UnknownPropertyException(); |
| } |
| |
| /*Property aProp; |
| aProp.Name = pR->Name; |
| aProp.Handle = pR->Handle; |
| aProp.Type = pR->Type; |
| aProp.Attributes = pR->Attributes; |
| return aProp;*/ |
| return *pR; |
| } |
| |
| //======================================================================== |
| sal_Bool OPropertyArrayHelper::hasPropertyByName(const OUString& aPropertyName) |
| { |
| Property * pR; |
| pR = (Property *)bsearch( &aPropertyName, aInfos.getConstArray(), aInfos.getLength(), |
| sizeof( Property ), |
| compare_OUString_Property_Impl ); |
| return pR != NULL; |
| } |
| |
| //======================================================================== |
| sal_Int32 OPropertyArrayHelper::getHandleByName( const OUString & rPropName ) |
| { |
| Property * pR; |
| pR = (Property *)bsearch( &rPropName, aInfos.getConstArray(), aInfos.getLength(), |
| sizeof( Property ), |
| compare_OUString_Property_Impl ); |
| return pR ? pR->Handle : -1; |
| } |
| |
| //======================================================================== |
| sal_Int32 OPropertyArrayHelper::fillHandles( sal_Int32 * pHandles, const Sequence< OUString > & rPropNames ) |
| { |
| sal_Int32 nHitCount = 0; |
| const OUString * pReqProps = rPropNames.getConstArray(); |
| sal_Int32 nReqLen = rPropNames.getLength(); |
| const Property * pCur = aInfos.getConstArray(); |
| const Property * pEnd = pCur + aInfos.getLength(); |
| |
| for( sal_Int32 i = 0; i < nReqLen; i++ ) |
| { |
| // Logarithmus ermitteln |
| sal_Int32 n = (sal_Int32)(pEnd - pCur); |
| sal_Int32 nLog = 0; |
| while( n ) |
| { |
| nLog += 1; |
| n = n >> 1; |
| } |
| |
| // Anzahl der noch zu suchenden Properties * dem Log2 der verbleibenden |
| // zu dursuchenden Properties. |
| if( (nReqLen - i) * nLog >= pEnd - pCur ) |
| { |
| // linear search is better |
| while( pCur < pEnd && pReqProps[i] > pCur->Name ) |
| { |
| pCur++; |
| } |
| if( pCur < pEnd && pReqProps[i] == pCur->Name ) |
| { |
| pHandles[i] = pCur->Handle; |
| nHitCount++; |
| } |
| else |
| pHandles[i] = -1; |
| } |
| else |
| { |
| // binary search is better |
| sal_Int32 nCompVal = 1; |
| const Property * pOldEnd = pEnd--; |
| const Property * pMid = pCur; |
| |
| while( nCompVal != 0 && pCur <= pEnd ) |
| { |
| pMid = (pEnd - pCur) / 2 + pCur; |
| |
| nCompVal = pReqProps[i].compareTo( pMid->Name ); |
| |
| if( nCompVal > 0 ) |
| pCur = pMid + 1; |
| else |
| pEnd = pMid - 1; |
| } |
| |
| if( nCompVal == 0 ) |
| { |
| pHandles[i] = pMid->Handle; |
| nHitCount++; |
| pCur = pMid +1; |
| } |
| else if( nCompVal > 0 ) |
| { |
| pHandles[i] = -1; |
| pCur = pMid +1; |
| } |
| else |
| { |
| pHandles[i] = -1; |
| pCur = pMid; |
| } |
| pEnd = pOldEnd; |
| } |
| } |
| return nHitCount; |
| } |
| |
| } // end namespace cppu |
| |
| |
| |
