xref: /aoo42x/main/comphelper/source/container/enumerablemap.cxx (revision e2530cf9)

/**************************************************************
 *
 * 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.
 *
 *************************************************************/



#include "precompiled_comphelper.hxx"

#include "comphelper_module.hxx"
#include "comphelper/anytostring.hxx"
#include "comphelper/anycompare.hxx"
#include "comphelper/componentbase.hxx"
#include "comphelper/componentcontext.hxx"
#include "comphelper/extract.hxx"

/** === begin UNO includes === **/
#include <com/sun/star/container/XEnumerableMap.hpp>
#include <com/sun/star/lang/XInitialization.hpp>
#include <com/sun/star/ucb/AlreadyInitializedException.hpp>
#include <com/sun/star/beans/Pair.hpp>
#include <com/sun/star/lang/XServiceInfo.hpp>
/** === end UNO includes === **/

#include <cppuhelper/compbase3.hxx>
#include <cppuhelper/implbase1.hxx>
#include <rtl/math.hxx>
#include <rtl/ustrbuf.hxx>
#include <typelib/typedescription.hxx>

#include <map>
#include <boost/shared_ptr.hpp>

//........................................................................
namespace comphelper
{
//........................................................................

	/** === begin UNO using === **/
	using ::com::sun::star::uno::Reference;
	using ::com::sun::star::uno::XInterface;
	using ::com::sun::star::uno::UNO_QUERY;
	using ::com::sun::star::uno::UNO_QUERY_THROW;
	using ::com::sun::star::uno::UNO_SET_THROW;
	using ::com::sun::star::uno::Exception;
	using ::com::sun::star::uno::RuntimeException;
	using ::com::sun::star::uno::Any;
	using ::com::sun::star::uno::makeAny;
	using ::com::sun::star::uno::Sequence;
	using ::com::sun::star::uno::Type;
	using ::com::sun::star::container::XEnumerableMap;
	using ::com::sun::star::lang::NoSupportException;
	using ::com::sun::star::beans::IllegalTypeException;
	using ::com::sun::star::container::NoSuchElementException;
	using ::com::sun::star::lang::IllegalArgumentException;
	using ::com::sun::star::lang::XInitialization;
	using ::com::sun::star::ucb::AlreadyInitializedException;
	using ::com::sun::star::beans::Pair;
	using ::com::sun::star::uno::TypeClass;
	using ::com::sun::star::uno::TypeClass_VOID;
	using ::com::sun::star::uno::TypeClass_UNKNOWN;
	using ::com::sun::star::uno::TypeClass_ANY;
	using ::com::sun::star::uno::TypeClass_EXCEPTION;
	using ::com::sun::star::uno::TypeClass_STRUCT;
	using ::com::sun::star::uno::TypeClass_UNION;
	using ::com::sun::star::uno::TypeClass_FLOAT;
	using ::com::sun::star::uno::TypeClass_DOUBLE;
	using ::com::sun::star::uno::TypeClass_INTERFACE;
	using ::com::sun::star::lang::XServiceInfo;
	using ::com::sun::star::uno::XComponentContext;
	using ::com::sun::star::container::XEnumeration;
	using ::com::sun::star::uno::TypeDescription;
	using ::com::sun::star::lang::WrappedTargetException;
	using ::com::sun::star::lang::DisposedException;
	/** === end UNO using === **/

	//====================================================================
	//= MapData
	//====================================================================
	class IMapModificationListener;
	typedef ::std::vector< IMapModificationListener* > MapListeners;

	typedef ::std::map< Any, Any, LessPredicateAdapter > KeyedValues;
	struct MapData
	{
		Type										m_aKeyType;
		Type										m_aValueType;
		::std::auto_ptr< KeyedValues >				m_pValues;
		::boost::shared_ptr< IKeyPredicateLess >	m_pKeyCompare;
		bool										m_bMutable;
		MapListeners								m_aModListeners;

		MapData()
			:m_bMutable( true )
		{
		}

		MapData( const MapData& _source )
			:m_aKeyType( _source.m_aKeyType )
			,m_aValueType( _source.m_aValueType )
			,m_pValues( new KeyedValues( *_source.m_pValues ) )
			,m_pKeyCompare( _source.m_pKeyCompare )
			,m_bMutable( false )
			,m_aModListeners()
		{
		}
	private:
		MapData& operator=( const MapData& _source ); // not implemented
	};

	//====================================================================
	//= IMapModificationListener
	//====================================================================
	/** implemented by components who want to be notified of modifications in the MapData they work with
	*/
	class SAL_NO_VTABLE IMapModificationListener
	{
	public:
		/// called when the map was modified
		virtual void mapModified() = 0;
		virtual ~IMapModificationListener()
		{
		}
	};

	//====================================================================
	//= MapData helpers
	//====================================================================
	//--------------------------------------------------------------------
	static void lcl_registerMapModificationListener( MapData& _mapData, IMapModificationListener& _listener )
	{
	#if OSL_DEBUG_LEVEL > 0
		for (   MapListeners::const_iterator lookup = _mapData.m_aModListeners.begin();
				lookup != _mapData.m_aModListeners.end();
				++lookup
			)
		{
			OSL_ENSURE( *lookup != &_listener, "lcl_registerMapModificationListener: this listener is already registered!" );
		}
	#endif
		_mapData.m_aModListeners.push_back( &_listener );
	}

	//--------------------------------------------------------------------
	static void lcl_revokeMapModificationListener( MapData& _mapData, IMapModificationListener& _listener )
	{
		for (   MapListeners::iterator lookup = _mapData.m_aModListeners.begin();
				lookup != _mapData.m_aModListeners.end();
				++lookup
			)
		{
			if ( *lookup == &_listener )
			{
				_mapData.m_aModListeners.erase( lookup );
				return;
			}
		}
		OSL_ENSURE( false, "lcl_revokeMapModificationListener: the listener is not registered!" );
	}

	//--------------------------------------------------------------------
	static void lcl_notifyMapDataListeners_nothrow( const MapData& _mapData )
	{
		for (   MapListeners::const_iterator loop = _mapData.m_aModListeners.begin();
				loop != _mapData.m_aModListeners.end();
				++loop
			)
		{
			(*loop)->mapModified();
		}
	}

	//====================================================================
	//= EnumerableMap
	//====================================================================
	typedef ::cppu::WeakAggComponentImplHelper3 <   XInitialization
												,   XEnumerableMap
												,   XServiceInfo
												> Map_IFace;

	class COMPHELPER_DLLPRIVATE EnumerableMap :public Map_IFace
									,public ComponentBase
	{
	protected:
		EnumerableMap( const ComponentContext& _rContext );
		virtual ~EnumerableMap();

		// XInitialization
		virtual void SAL_CALL initialize( const Sequence< Any >& aArguments ) throw (Exception, RuntimeException);

		// XEnumerableMap
		virtual ::com::sun::star::uno::Reference< ::com::sun::star::container::XEnumeration > SAL_CALL createKeyEnumeration( ::sal_Bool _Isolated ) throw (::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException);
		virtual ::com::sun::star::uno::Reference< ::com::sun::star::container::XEnumeration > SAL_CALL createValueEnumeration( ::sal_Bool _Isolated ) throw (::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException);
		virtual ::com::sun::star::uno::Reference< ::com::sun::star::container::XEnumeration > SAL_CALL createElementEnumeration( ::sal_Bool _Isolated ) throw (::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException);

		// XMap
		virtual Type SAL_CALL getKeyType() throw (RuntimeException);
		virtual Type SAL_CALL getValueType() throw (RuntimeException);
		virtual void SAL_CALL clear(  ) throw (NoSupportException, RuntimeException);
		virtual ::sal_Bool SAL_CALL containsKey( const Any& _key ) throw (IllegalTypeException, IllegalArgumentException, RuntimeException);
		virtual ::sal_Bool SAL_CALL containsValue( const Any& _value ) throw (IllegalTypeException, IllegalArgumentException, RuntimeException);
		virtual Any SAL_CALL get( const Any& _key ) throw (IllegalTypeException, IllegalArgumentException, NoSuchElementException, RuntimeException);
		virtual Any SAL_CALL put( const Any& _key, const Any& _value ) throw (NoSupportException, IllegalTypeException, IllegalArgumentException, RuntimeException);
		virtual Any SAL_CALL remove( const Any& _key ) throw (NoSupportException, IllegalTypeException, IllegalArgumentException, NoSuchElementException, RuntimeException);

		// XElementAccess (base of XMap)
		virtual Type SAL_CALL getElementType() throw (RuntimeException);
		virtual ::sal_Bool SAL_CALL hasElements() throw (RuntimeException);

		// XServiceInfo
		virtual ::rtl::OUString SAL_CALL getImplementationName(  ) throw (RuntimeException);
		virtual ::sal_Bool SAL_CALL supportsService( const ::rtl::OUString& ServiceName ) throw (RuntimeException);
		virtual Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames(  ) throw (RuntimeException);

	public:
		// XServiceInfo, static version (used for component registration)
		static ::rtl::OUString SAL_CALL getImplementationName_static(  );
		static Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames_static(  );
		static Reference< XInterface > SAL_CALL Create( const Reference< XComponentContext >& );

	private:
		void impl_initValues_throw( const Sequence< Pair< Any, Any > >& _initialValues );

		/// throws a IllegalTypeException if the given value is not compatible with our ValueType
		void impl_checkValue_throw( const Any& _value ) const;
		void impl_checkKey_throw( const Any& _key ) const;
		void impl_checkNaN_throw( const Any& _keyOrValue, const Type& _keyOrValueType ) const;
		void impl_checkMutable_throw() const;

	private:
		::osl::Mutex		m_aMutex;
		ComponentContext	m_aContext;
		MapData				m_aData;

		::std::vector< ::com::sun::star::uno::WeakReference< XInterface > >
							m_aDependentComponents;
	};

	//====================================================================
	//= EnumerationType
	//====================================================================
	enum EnumerationType
	{
		eKeys, eValues, eBoth
	};

	//====================================================================
	//= MapEnumerator
	//====================================================================
	class MapEnumerator : public IMapModificationListener
	{
	public:
		MapEnumerator( ::cppu::OWeakObject& _rParent, MapData& _mapData, const EnumerationType _type )
			:m_rParent( _rParent )
			,m_rMapData( _mapData )
			,m_eType( _type )
			,m_mapPos( _mapData.m_pValues->begin() )
			,m_disposed( false )
		{
			lcl_registerMapModificationListener( m_rMapData, *this );
		}

		virtual ~MapEnumerator()
		{
			dispose();
		}

		void dispose()
		{
			if ( !m_disposed )
			{
				lcl_revokeMapModificationListener( m_rMapData, *this );
				m_disposed = true;
			}
		}

		// XEnumeration equivalents
		::sal_Bool hasMoreElements();
		Any nextElement();

		// IMapModificationListener
		virtual void mapModified();

	private:
		::cppu::OWeakObject&		m_rParent;
		MapData&					m_rMapData;
		const EnumerationType		m_eType;
		KeyedValues::const_iterator	m_mapPos;
		bool						m_disposed;

	private:
		MapEnumerator(); // not implemented
		MapEnumerator( const MapEnumerator& ); // not implemented
		MapEnumerator& operator=( const MapEnumerator& ); // not implemented
	};

	//====================================================================
	//= MapEnumeration
	//====================================================================
	typedef ::cppu::WeakImplHelper1 <   XEnumeration
									>   MapEnumeration_Base;
	class MapEnumeration :public ComponentBase
						 ,public MapEnumeration_Base
	{
	public:
		MapEnumeration( ::cppu::OWeakObject& _parentMap, MapData& _mapData, ::cppu::OBroadcastHelper& _rBHelper,
						const EnumerationType _type, const bool _isolated )
			:ComponentBase( _rBHelper, ComponentBase::NoInitializationNeeded() )
			,m_xKeepMapAlive( _parentMap )
			,m_pMapDataCopy( _isolated ? new MapData( _mapData ) : NULL )
			,m_aEnumerator( *this, _isolated ? *m_pMapDataCopy : _mapData, _type )
		{
		}

		// XEnumeration
		virtual ::sal_Bool SAL_CALL hasMoreElements(  ) throw (RuntimeException);
		virtual Any SAL_CALL nextElement(  ) throw (NoSuchElementException, WrappedTargetException, RuntimeException);

	protected:
		virtual ~MapEnumeration()
		{
			acquire();
			{
				::osl::MutexGuard aGuard( getMutex() );
				m_aEnumerator.dispose();
				m_pMapDataCopy.reset();
			}
		}

	private:
		// since we share our mutex with the main map, we need to keep it alive as long as we live
		Reference< XInterface >		m_xKeepMapAlive;
		::std::auto_ptr< MapData >	m_pMapDataCopy;
		MapEnumerator				m_aEnumerator;
	};

	//====================================================================
	//= EnumerableMap
	//====================================================================
	//--------------------------------------------------------------------
	EnumerableMap::EnumerableMap( const ComponentContext& _rContext )
		:Map_IFace( m_aMutex )
		,ComponentBase( Map_IFace::rBHelper )
		,m_aContext( _rContext )
	{
	}

	//--------------------------------------------------------------------
	EnumerableMap::~EnumerableMap()
	{
		if ( !impl_isDisposed() )
		{
			acquire();
			dispose();
		}
	}

	//--------------------------------------------------------------------
	void SAL_CALL EnumerableMap::initialize( const Sequence< Any >& _arguments ) throw (Exception, RuntimeException)
	{
		ComponentMethodGuard aGuard( *this, ComponentMethodGuard::WithoutInit );
		if ( impl_isInitialized_nothrow() )
			throw AlreadyInitializedException();

		sal_Int32 nArgumentCount = _arguments.getLength();
		if ( ( nArgumentCount != 2 ) && ( nArgumentCount != 3 ) )
			throw IllegalArgumentException();

		Type aKeyType, aValueType;
		if ( !( _arguments[0] >>= aKeyType ) )
			throw IllegalArgumentException( ::rtl::OUString::createFromAscii( "com.sun.star.uno.Type expected." ), *this, 1 );
		if ( !( _arguments[1] >>= aValueType ) )
			throw IllegalArgumentException( ::rtl::OUString::createFromAscii( "com.sun.star.uno.Type expected." ), *this, 2 );

		Sequence< Pair< Any, Any > > aInitialValues;
		bool bMutable = true;
		if ( nArgumentCount == 3 )
		{
			if ( !( _arguments[2] >>= aInitialValues ) )
				throw IllegalArgumentException( ::rtl::OUString::createFromAscii( "[]com.sun.star.beans.Pair<any,any> expected." ), *this, 2 );
			bMutable = false;
		}

		// for the value, anything is allowed, except VOID
		if ( ( aValueType.getTypeClass() == TypeClass_VOID ) || ( aValueType.getTypeClass() == TypeClass_UNKNOWN ) )
			throw IllegalTypeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Unsupported value type." ) ), *this );

		// create the comparator for the KeyType, and throw if the type is not supported
		::std::auto_ptr< IKeyPredicateLess > pComparator( getStandardLessPredicate( aKeyType, NULL ) );
		if ( !pComparator.get() )
			throw IllegalTypeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Unsupported key type." ) ), *this );

		// init members
		m_aData.m_aKeyType = aKeyType;
		m_aData.m_aValueType = aValueType;
		m_aData.m_pKeyCompare = pComparator;
		m_aData.m_pValues.reset( new KeyedValues( *m_aData.m_pKeyCompare ) );
		m_aData.m_bMutable = bMutable;

		if ( aInitialValues.getLength() )
			impl_initValues_throw( aInitialValues );

		setInitialized();
	}

	//--------------------------------------------------------------------
	void EnumerableMap::impl_initValues_throw( const Sequence< Pair< Any, Any > >& _initialValues )
	{
		OSL_PRECOND( m_aData.m_pValues.get() && m_aData.m_pValues->empty(), "EnumerableMap::impl_initValues_throw: illegal call!" );
		if ( !m_aData.m_pValues.get() || !m_aData.m_pValues->empty() )
			throw RuntimeException();

		const Pair< Any, Any >* mapping = _initialValues.getConstArray();
		const Pair< Any, Any >* mappingEnd = mapping + _initialValues.getLength();
		Any normalizedValue;
		for ( ; mapping != mappingEnd; ++mapping )
		{
			impl_checkValue_throw( mapping->Second );
			(*m_aData.m_pValues)[ mapping->First ] = mapping->Second;
		}
	}

	//--------------------------------------------------------------------
	void EnumerableMap::impl_checkValue_throw( const Any& _value ) const
	{
		if ( !_value.hasValue() )
			// nothing to do, NULL values are always allowed, regardless of the ValueType
			return;

		TypeClass eAllowedTypeClass = m_aData.m_aValueType.getTypeClass();
		bool bValid = false;

		switch ( eAllowedTypeClass )
		{
		default:
			bValid = ( _value.getValueTypeClass() == eAllowedTypeClass );
			break;
		case TypeClass_ANY:
			bValid = true;
			break;
		case TypeClass_INTERFACE:
		{
			// special treatment: _value might contain the proper type, but the interface
			// might actually be NULL. Which is still valid...
			if ( m_aData.m_aValueType.isAssignableFrom( _value.getValueType() ) )
				// this also catches the special case where XFoo is our value type,
				// and _value contains a NULL-reference to XFoo, or a derived type
				bValid = true;
			else
			{
				Reference< XInterface > xValue( _value, UNO_QUERY );
				Any aTypedValue;
				if ( xValue.is() )
					// XInterface is not-NULL, but is X(ValueType) not-NULL, too?
					xValue.set( xValue->queryInterface( m_aData.m_aValueType ), UNO_QUERY );
				bValid = xValue.is();
			}
		}
		break;
		case TypeClass_EXCEPTION:
		case TypeClass_STRUCT:
		case TypeClass_UNION:
		{
			// values are accepted if and only if their type equals, or is derived from, our value type

			if ( _value.getValueTypeClass() != eAllowedTypeClass )
				bValid = false;
			else
			{
				const TypeDescription aValueTypeDesc( _value.getValueType() );
				const TypeDescription aRequiredTypeDesc( m_aData.m_aValueType );

				const _typelib_CompoundTypeDescription* pValueCompoundTypeDesc =
					reinterpret_cast< const _typelib_CompoundTypeDescription* >( aValueTypeDesc.get() );

				while ( pValueCompoundTypeDesc )
				{
					if ( typelib_typedescription_equals( &pValueCompoundTypeDesc->aBase, aRequiredTypeDesc.get() ) )
						break;
					pValueCompoundTypeDesc = pValueCompoundTypeDesc->pBaseTypeDescription;
				}
				bValid = ( pValueCompoundTypeDesc != NULL );
			}
		}
		break;
		}

		if ( !bValid )
		{
			::rtl::OUStringBuffer aMessage;
			aMessage.appendAscii( "Incompatible value type. Found '" );
			aMessage.append( _value.getValueTypeName() );
			aMessage.appendAscii( "', where '" );
			aMessage.append( m_aData.m_aValueType.getTypeName() );
			aMessage.appendAscii( "' (or compatible type) is expected." );
			throw IllegalTypeException( aMessage.makeStringAndClear(), *const_cast< EnumerableMap* >( this ) );
		}

		impl_checkNaN_throw( _value, m_aData.m_aValueType );
	}

	//--------------------------------------------------------------------
	void EnumerableMap::impl_checkNaN_throw( const Any& _keyOrValue, const Type& _keyOrValueType ) const
	{
		if  (   ( _keyOrValueType.getTypeClass() == TypeClass_DOUBLE )
			||  ( _keyOrValueType.getTypeClass() == TypeClass_FLOAT )
			)
		{
			double nValue(0);
			if ( _keyOrValue >>= nValue )
				if ( ::rtl::math::isNan( nValue ) )
					throw IllegalArgumentException(
						::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "NaN (not-a-number) not supported by this implementation." ) ),
						*const_cast< EnumerableMap* >( this ), 0 );
			// (note that the case of _key not containing a float/double value is handled in the
			// respective IKeyPredicateLess implementation, so there's no need to handle this here.)
		}
	}

	//--------------------------------------------------------------------
	void EnumerableMap::impl_checkKey_throw( const Any& _key ) const
	{
		if ( !_key.hasValue() )
			throw IllegalArgumentException(
				::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "NULL keys not supported by this implementation." ) ),
				*const_cast< EnumerableMap* >( this ), 0 );

		impl_checkNaN_throw( _key, m_aData.m_aKeyType );
	}

	//--------------------------------------------------------------------
	void EnumerableMap::impl_checkMutable_throw() const
	{
		if ( !m_aData.m_bMutable )
			throw NoSupportException(
					::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "The map is immutable." ) ),
					*const_cast< EnumerableMap* >( this ) );
	}

	//--------------------------------------------------------------------
	Reference< XEnumeration > SAL_CALL EnumerableMap::createKeyEnumeration( ::sal_Bool _Isolated ) throw (NoSupportException, RuntimeException)
	{
		ComponentMethodGuard aGuard( *this );
		return new MapEnumeration( *this, m_aData, getBroadcastHelper(), eKeys, _Isolated );
	}

	//--------------------------------------------------------------------
	Reference< XEnumeration > SAL_CALL EnumerableMap::createValueEnumeration( ::sal_Bool _Isolated ) throw (NoSupportException, RuntimeException)
	{
		ComponentMethodGuard aGuard( *this );
		return new MapEnumeration( *this, m_aData, getBroadcastHelper(), eValues, _Isolated );
	}

	//--------------------------------------------------------------------
	Reference< XEnumeration > SAL_CALL EnumerableMap::createElementEnumeration( ::sal_Bool _Isolated ) throw (NoSupportException, RuntimeException)
	{
		ComponentMethodGuard aGuard( *this );
		return new MapEnumeration( *this, m_aData, getBroadcastHelper(), eBoth, _Isolated );
	}

	//--------------------------------------------------------------------
	Type SAL_CALL EnumerableMap::getKeyType() throw (RuntimeException)
	{
		ComponentMethodGuard aGuard( *this );
		return m_aData.m_aKeyType;
	}

	//--------------------------------------------------------------------
	Type SAL_CALL EnumerableMap::getValueType() throw (RuntimeException)
	{
		ComponentMethodGuard aGuard( *this );
		return m_aData.m_aValueType;
	}

	//--------------------------------------------------------------------
	void SAL_CALL EnumerableMap::clear(  ) throw (NoSupportException, RuntimeException)
	{
		ComponentMethodGuard aGuard( *this );
		impl_checkMutable_throw();

		m_aData.m_pValues->clear();

		lcl_notifyMapDataListeners_nothrow( m_aData );
	}

	//--------------------------------------------------------------------
	::sal_Bool SAL_CALL EnumerableMap::containsKey( const Any& _key ) throw (IllegalTypeException, IllegalArgumentException, RuntimeException)
	{
		ComponentMethodGuard aGuard( *this );
		impl_checkKey_throw( _key );

		KeyedValues::const_iterator pos = m_aData.m_pValues->find( _key );
		return ( pos != m_aData.m_pValues->end() );
	}

	//--------------------------------------------------------------------
	::sal_Bool SAL_CALL EnumerableMap::containsValue( const Any& _value ) throw (IllegalTypeException, IllegalArgumentException, RuntimeException)
	{
		ComponentMethodGuard aGuard( *this );
		impl_checkValue_throw( _value );

		for (   KeyedValues::const_iterator mapping = m_aData.m_pValues->begin();
				mapping != m_aData.m_pValues->end();
				++mapping
			)
		{
			if ( mapping->second == _value )
				return sal_True;
		}
		return sal_False;
	}

	//--------------------------------------------------------------------
	Any SAL_CALL EnumerableMap::get( const Any& _key ) throw (IllegalTypeException, IllegalArgumentException, NoSuchElementException, RuntimeException)
	{
		ComponentMethodGuard aGuard( *this );
		impl_checkKey_throw( _key );

		KeyedValues::const_iterator pos = m_aData.m_pValues->find( _key );
		if ( pos == m_aData.m_pValues->end() )
			throw NoSuchElementException( anyToString( _key ), *this );

		return pos->second;
	}

	//--------------------------------------------------------------------
	Any SAL_CALL EnumerableMap::put( const Any& _key, const Any& _value ) throw (NoSupportException, IllegalTypeException, IllegalArgumentException, RuntimeException)
	{
		ComponentMethodGuard aGuard( *this );
		impl_checkMutable_throw();
		impl_checkKey_throw( _key );
		impl_checkValue_throw( _value );

		Any previousValue;

		KeyedValues::iterator pos = m_aData.m_pValues->find( _key );
		if ( pos != m_aData.m_pValues->end() )
		{
			previousValue = pos->second;
			pos->second = _value;
		}
		else
		{
			(*m_aData.m_pValues)[ _key ] = _value;
		}

		lcl_notifyMapDataListeners_nothrow( m_aData );

		return previousValue;
	}

	//--------------------------------------------------------------------
	Any SAL_CALL EnumerableMap::remove( const Any& _key ) throw (NoSupportException, IllegalTypeException, IllegalArgumentException, NoSuchElementException, RuntimeException)
	{
		ComponentMethodGuard aGuard( *this );
		impl_checkMutable_throw();
		impl_checkKey_throw( _key );

		Any previousValue;

		KeyedValues::iterator pos = m_aData.m_pValues->find( _key );
		if ( pos != m_aData.m_pValues->end() )
		{
			previousValue = pos->second;
			m_aData.m_pValues->erase( pos );
		}

		lcl_notifyMapDataListeners_nothrow( m_aData );

		return previousValue;
	}

	//--------------------------------------------------------------------
	Type SAL_CALL EnumerableMap::getElementType() throw (RuntimeException)
	{
		return ::cppu::UnoType< Pair< Any, Any > >::get();
	}

	//--------------------------------------------------------------------
	::sal_Bool SAL_CALL EnumerableMap::hasElements() throw (RuntimeException)
	{
		ComponentMethodGuard aGuard( *this );
		return m_aData.m_pValues->empty();
	}

	//--------------------------------------------------------------------
	::rtl::OUString SAL_CALL EnumerableMap::getImplementationName(  ) throw (RuntimeException)
	{
		return getImplementationName_static();
	}

	//--------------------------------------------------------------------
	::sal_Bool SAL_CALL EnumerableMap::supportsService( const ::rtl::OUString& _serviceName ) throw (RuntimeException)
	{
		Sequence< ::rtl::OUString > aServices( getSupportedServiceNames() );
		for ( sal_Int32 i=0; i<aServices.getLength(); ++i )
			if ( _serviceName == aServices[i] )
				return sal_True;
		return sal_False;
	}

	//--------------------------------------------------------------------
	Sequence< ::rtl::OUString > SAL_CALL EnumerableMap::getSupportedServiceNames(  ) throw (RuntimeException)
	{
		return getSupportedServiceNames_static();
	}

	//--------------------------------------------------------------------
	::rtl::OUString SAL_CALL EnumerableMap::getImplementationName_static(  )
	{
		return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "org.openoffice.comp.comphelper.EnumerableMap" ) );
	}

	//--------------------------------------------------------------------
	Sequence< ::rtl::OUString > SAL_CALL EnumerableMap::getSupportedServiceNames_static(  )
	{
		Sequence< ::rtl::OUString > aServiceNames(1);
		aServiceNames[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.container.EnumerableMap" ) );
		return aServiceNames;
	}

	//--------------------------------------------------------------------
	Reference< XInterface > SAL_CALL EnumerableMap::Create( const Reference< XComponentContext >& _context )
	{
		return *new EnumerableMap( ComponentContext( _context ) );
	}

	//====================================================================
	//= MapEnumerator
	//====================================================================
	//--------------------------------------------------------------------
	::sal_Bool MapEnumerator::hasMoreElements()
	{
		if ( m_disposed )
			throw DisposedException( ::rtl::OUString(), m_rParent );
		return m_mapPos != m_rMapData.m_pValues->end();
	}

	//--------------------------------------------------------------------
	Any MapEnumerator::nextElement()
	{
		if ( m_disposed )
			throw DisposedException( ::rtl::OUString(), m_rParent );
		if ( m_mapPos == m_rMapData.m_pValues->end() )
			throw NoSuchElementException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "No more elements." ) ), m_rParent );

		Any aNextElement;
		switch ( m_eType )
		{
		case eKeys:		aNextElement = m_mapPos->first; break;
		case eValues:	aNextElement = m_mapPos->second; break;
		case eBoth:		aNextElement <<= Pair< Any, Any >( m_mapPos->first, m_mapPos->second ); break;
		}
		++m_mapPos;
		return aNextElement;
	}

	//--------------------------------------------------------------------
	void MapEnumerator::mapModified()
	{
		m_disposed = true;
	}

	//====================================================================
	//= MapEnumeration - implementation
	//====================================================================
	//--------------------------------------------------------------------
	::sal_Bool SAL_CALL MapEnumeration::hasMoreElements(  ) throw (RuntimeException)
	{
		ComponentMethodGuard aGuard( *this );
		return m_aEnumerator.hasMoreElements();
	}

	//--------------------------------------------------------------------
	Any SAL_CALL MapEnumeration::nextElement(  ) throw (NoSuchElementException, WrappedTargetException, RuntimeException)
	{
		ComponentMethodGuard aGuard( *this );
		return m_aEnumerator.nextElement();
	}

//........................................................................
}	// namespace comphelper
//........................................................................

void createRegistryInfo_Map()
{
	::comphelper::module::OAutoRegistration< ::comphelper::EnumerableMap > aAutoRegistration;
}