/**************************************************************
 * 
 * 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_ucb.hxx"

#include <contentresultsetwrapper.hxx>
#include <com/sun/star/sdbc/FetchDirection.hpp>
#include <com/sun/star/ucb/FetchError.hpp>
#include <com/sun/star/beans/PropertyAttribute.hpp>
#include <com/sun/star/sdbc/ResultSetType.hpp>
#include <com/sun/star/lang/DisposedException.hpp>
#include <rtl/ustring.hxx>
#include <osl/diagnose.h>

using namespace com::sun::star::beans;
using namespace com::sun::star::lang;
using namespace com::sun::star::sdbc;
using namespace com::sun::star::ucb;
using namespace com::sun::star::uno;
using namespace com::sun::star::util;
using namespace cppu;
using namespace rtl;

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
// class ContentResultSetWrapper
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------

ContentResultSetWrapper::ContentResultSetWrapper(
								Reference< XResultSet > xOrigin )
				: m_xResultSetOrigin( xOrigin )
				, m_xRowOrigin( NULL )
				, m_xContentAccessOrigin( NULL )
				, m_xPropertySetOrigin( NULL )
				, m_xPropertySetInfo( NULL )
				, m_nForwardOnly( 2 )
				, m_xMetaDataFromOrigin( NULL )
				, m_bDisposed( sal_False )
				, m_bInDispose( sal_False )
				, m_pDisposeEventListeners( NULL )
				, m_pPropertyChangeListeners( NULL )
				, m_pVetoableChangeListeners( NULL )
{
	m_pMyListenerImpl = new ContentResultSetWrapperListener( this );
	m_xMyListenerImpl = Reference< XPropertyChangeListener >( m_pMyListenerImpl );

	OSL_ENSURE( m_xResultSetOrigin.is(), "XResultSet is required" );

	//!! call impl_init() at the end of constructor of derived class
};


void SAL_CALL ContentResultSetWrapper::impl_init_xRowOrigin()
{
	{
		osl::Guard< osl::Mutex > aGuard( m_aMutex );
		if(m_xRowOrigin.is())
			return;
	}

	Reference< XRow > xOrgig =
		Reference< XRow >( m_xResultSetOrigin, UNO_QUERY );

	{
		osl::Guard< osl::Mutex > aGuard( m_aMutex );
		m_xRowOrigin = xOrgig; 
		OSL_ENSURE( m_xRowOrigin.is(), "interface XRow is required" );
	}
}

void SAL_CALL ContentResultSetWrapper::impl_init_xContentAccessOrigin()
{
	{
		osl::Guard< osl::Mutex > aGuard( m_aMutex );
		if(m_xContentAccessOrigin.is())
			return;
	}

	Reference< XContentAccess > xOrgig =
		Reference< XContentAccess >( m_xResultSetOrigin, UNO_QUERY );

	{
		osl::Guard< osl::Mutex > aGuard( m_aMutex );
		m_xContentAccessOrigin = xOrgig; 
		OSL_ENSURE( m_xContentAccessOrigin.is(), "interface XContentAccess is required" );
	}
}


void SAL_CALL ContentResultSetWrapper::impl_init_xPropertySetOrigin()
{
	{
		osl::Guard< osl::Mutex > aGuard( m_aMutex );
		if( m_xPropertySetOrigin.is() )
			return;
	}

	Reference< XPropertySet > xOrig =
		Reference< XPropertySet >( m_xResultSetOrigin, UNO_QUERY );

	{
		osl::Guard< osl::Mutex > aGuard( m_aMutex );
		m_xPropertySetOrigin = xOrig; 
		OSL_ENSURE( m_xPropertySetOrigin.is(), "interface XPropertySet is required" );
	}
}

void SAL_CALL ContentResultSetWrapper::impl_init()
{
	//call this at the end of constructor of derived class
	//

	//listen to disposing from Origin:
	Reference< XComponent > xComponentOrigin( m_xResultSetOrigin, UNO_QUERY );
	OSL_ENSURE( xComponentOrigin.is(), "interface XComponent is required" );
	xComponentOrigin->addEventListener( static_cast< XPropertyChangeListener * >( m_pMyListenerImpl ) );
}

ContentResultSetWrapper::~ContentResultSetWrapper()
{
	//call impl_deinit() at start of destructor of derived class

	delete m_pDisposeEventListeners;
	delete m_pPropertyChangeListeners;
	delete m_pVetoableChangeListeners;
};

void SAL_CALL ContentResultSetWrapper::impl_deinit()
{
	//call this at start of destructor of derived class
	//
	m_pMyListenerImpl->impl_OwnerDies();
}

//virtual
void SAL_CALL ContentResultSetWrapper
	::impl_initPropertySetInfo()
{
	{
		osl::Guard< osl::Mutex > aGuard( m_aMutex );
		if( m_xPropertySetInfo.is() )
			return;

		impl_init_xPropertySetOrigin();
		if( !m_xPropertySetOrigin.is() )
			return;
	}

	Reference< XPropertySetInfo > xOrig =
			m_xPropertySetOrigin->getPropertySetInfo();

	{
		osl::Guard< osl::Mutex > aGuard( m_aMutex );
		m_xPropertySetInfo = xOrig;
	}
}

void SAL_CALL ContentResultSetWrapper
::impl_EnsureNotDisposed()
	throw( DisposedException, RuntimeException )
{
	osl::Guard< osl::Mutex > aGuard( m_aMutex );
	if( m_bDisposed )
		throw DisposedException();
}

ContentResultSetWrapper::PropertyChangeListenerContainer_Impl* SAL_CALL
	ContentResultSetWrapper
	::impl_getPropertyChangeListenerContainer()
{
	osl::Guard< osl::Mutex > aGuard( m_aMutex );
	if ( !m_pPropertyChangeListeners )
		m_pPropertyChangeListeners =
			new PropertyChangeListenerContainer_Impl( m_aContainerMutex );
	return m_pPropertyChangeListeners;
}

ContentResultSetWrapper::PropertyChangeListenerContainer_Impl* SAL_CALL
	ContentResultSetWrapper
	::impl_getVetoableChangeListenerContainer()
{
	osl::Guard< osl::Mutex > aGuard( m_aMutex );
	if ( !m_pVetoableChangeListeners )
		m_pVetoableChangeListeners =
			new PropertyChangeListenerContainer_Impl( m_aContainerMutex );
	return m_pVetoableChangeListeners;
}

void SAL_CALL ContentResultSetWrapper
	::impl_notifyPropertyChangeListeners(
					const PropertyChangeEvent& rEvt )
{
	{
		osl::Guard< osl::Mutex > aGuard( m_aMutex );
		if( !m_pPropertyChangeListeners )
			return;
	}

	// Notify listeners interested especially in the changed property.
	OInterfaceContainerHelper* pContainer =
			m_pPropertyChangeListeners->getContainer( rEvt.PropertyName );
	if( pContainer )
	{
		OInterfaceIteratorHelper aIter( *pContainer );
		while( aIter.hasMoreElements() )
		{
			Reference< XPropertyChangeListener > xListener(
													aIter.next(), UNO_QUERY );
			if( xListener.is() )
				xListener->propertyChange( rEvt );
		}
	}

	// Notify listeners interested in all properties.
	pContainer = m_pPropertyChangeListeners->getContainer( OUString() );
	if( pContainer )
	{
		OInterfaceIteratorHelper aIter( *pContainer );
		while( aIter.hasMoreElements() )
		{
			Reference< XPropertyChangeListener > xListener(
													aIter.next(), UNO_QUERY );
			if( xListener.is() )
				xListener->propertyChange( rEvt );
		}
	}
}

void SAL_CALL ContentResultSetWrapper
	::impl_notifyVetoableChangeListeners( const PropertyChangeEvent& rEvt )
	throw( PropertyVetoException,
		   RuntimeException )
{
	{
		osl::Guard< osl::Mutex > aGuard( m_aMutex );
		if( !m_pVetoableChangeListeners )
			return;
	}

	// Notify listeners interested especially in the changed property.
	OInterfaceContainerHelper* pContainer =
			m_pVetoableChangeListeners->getContainer( rEvt.PropertyName );
	if( pContainer )
	{
		OInterfaceIteratorHelper aIter( *pContainer );
		while( aIter.hasMoreElements() )
		{
			Reference< XVetoableChangeListener > xListener(
													aIter.next(), UNO_QUERY );
			if( xListener.is() )
				xListener->vetoableChange( rEvt );
		}
	}

	// Notify listeners interested in all properties.
	pContainer = m_pVetoableChangeListeners->getContainer( OUString() );
	if( pContainer )
	{
		OInterfaceIteratorHelper aIter( *pContainer );
		while( aIter.hasMoreElements() )
		{
			Reference< XVetoableChangeListener > xListener(
													aIter.next(), UNO_QUERY );
			if( xListener.is() )
				xListener->vetoableChange( rEvt );
		}
	}
}

sal_Bool SAL_CALL ContentResultSetWrapper
	::impl_isForwardOnly()
{
	//m_nForwardOnly == 2 -> don't know
	//m_nForwardOnly == 1 -> YES
	//m_nForwardOnly == 0 -> NO

	//@todo replace this with lines in comment
	osl::Guard< osl::Mutex > aGuard( m_aMutex );
	m_nForwardOnly = 0;
	return false;


	/*
	ReacquireableGuard aGuard( m_aMutex );
	if( m_nForwardOnly == 2 )
	{
		aGuard.clear();
		if( !getPropertySetInfo().is() )
		{
			aGuard.reacquire();
			m_nForwardOnly = 0;
			return m_nForwardOnly;
		}
		aGuard.reacquire();

		rtl::OUString aName = OUString::createFromAscii( "ResultSetType" );
		//find out, if we are ForwardOnly and cache the value:

		impl_init_xPropertySetOrigin();
		if( !m_xPropertySetOrigin.is() )
		{
			OSL_ENSURE( sal_False, "broadcaster was disposed already" );
			m_nForwardOnly = 0;
			return m_nForwardOnly;
		}

		aGuard.clear();
		Any aAny = m_xPropertySetOrigin->getPropertyValue( aName );

		aGuard.reacquire();
		long nResultSetType;
		if( ( aAny >>= nResultSetType ) &&
			( nResultSetType == ResultSetType::FORWARD_ONLY ) )
			m_nForwardOnly = 1;
		else
			m_nForwardOnly = 0;
	}
	return m_nForwardOnly;
	*/
}

//--------------------------------------------------------------------------
// XInterface methods.
//--------------------------------------------------------------------------
//list all interfaces inclusive baseclasses of interfaces
QUERYINTERFACE_IMPL_START( ContentResultSetWrapper )

	SAL_STATIC_CAST( XComponent*, this ),
	SAL_STATIC_CAST( XCloseable*, this ),
	SAL_STATIC_CAST( XResultSetMetaDataSupplier*, this ),
	SAL_STATIC_CAST( XPropertySet*, this ),

	SAL_STATIC_CAST( XContentAccess*, this ),
	SAL_STATIC_CAST( XResultSet*, this ),
	SAL_STATIC_CAST( XRow*, this )

QUERYINTERFACE_IMPL_END

//--------------------------------------------------------------------------
// XComponent methods.
//--------------------------------------------------------------------------
// virtual
void SAL_CALL ContentResultSetWrapper
	::dispose() throw( RuntimeException )
{
	impl_EnsureNotDisposed();

	ReacquireableGuard aGuard( m_aMutex );
	if( m_bInDispose || m_bDisposed )
		return;
	m_bInDispose = sal_True;

	if( m_xPropertySetOrigin.is() )
	{
		aGuard.clear();
		try
		{
			m_xPropertySetOrigin->removePropertyChangeListener(
				OUString(), static_cast< XPropertyChangeListener * >( m_pMyListenerImpl ) );
		}
		catch( Exception& )
		{
			OSL_ENSURE( sal_False, "could not remove PropertyChangeListener" );
		}
		try
		{
			m_xPropertySetOrigin->removeVetoableChangeListener(
				OUString(), static_cast< XVetoableChangeListener * >( m_pMyListenerImpl ) );
		}
		catch( Exception& )
		{
			OSL_ENSURE( sal_False, "could not remove VetoableChangeListener" );
		}

		Reference< XComponent > xComponentOrigin( m_xResultSetOrigin, UNO_QUERY );
		OSL_ENSURE( xComponentOrigin.is(), "interface XComponent is required" );
		xComponentOrigin->removeEventListener( static_cast< XPropertyChangeListener * >( m_pMyListenerImpl ) );
	}

	aGuard.reacquire();
	if( m_pDisposeEventListeners && m_pDisposeEventListeners->getLength() )
	{
		EventObject aEvt;
		aEvt.Source = static_cast< XComponent * >( this );

		aGuard.clear();
		m_pDisposeEventListeners->disposeAndClear( aEvt );
	}

	aGuard.reacquire();
	if( m_pPropertyChangeListeners )
	{
		EventObject aEvt;
		aEvt.Source = static_cast< XPropertySet * >( this );

		aGuard.clear();
		m_pPropertyChangeListeners->disposeAndClear( aEvt );
	}

	aGuard.reacquire();
	if( m_pVetoableChangeListeners )
	{
		EventObject aEvt;
		aEvt.Source = static_cast< XPropertySet * >( this );

		aGuard.clear();
		m_pVetoableChangeListeners->disposeAndClear( aEvt );
	}

	aGuard.reacquire();
	m_bDisposed = sal_True;
	m_bInDispose = sal_False;
}

//--------------------------------------------------------------------------
// virtual
void SAL_CALL ContentResultSetWrapper
	::addEventListener(	const Reference< XEventListener >& Listener )
	throw( RuntimeException )
{
	impl_EnsureNotDisposed();
	osl::Guard< osl::Mutex > aGuard( m_aMutex );

	if ( !m_pDisposeEventListeners )
		m_pDisposeEventListeners =
					new OInterfaceContainerHelper( m_aContainerMutex );

	m_pDisposeEventListeners->addInterface( Listener );
}

//--------------------------------------------------------------------------
// virtual
void SAL_CALL ContentResultSetWrapper
	::removeEventListener( const Reference< XEventListener >& Listener )
	throw( RuntimeException )
{
	impl_EnsureNotDisposed();
	osl::Guard< osl::Mutex > aGuard( m_aMutex );

	if ( m_pDisposeEventListeners )
		m_pDisposeEventListeners->removeInterface( Listener );
}

//--------------------------------------------------------------------------
//XCloseable methods.
//--------------------------------------------------------------------------
//virtual
void SAL_CALL ContentResultSetWrapper
	::close()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();
	dispose();
}

//--------------------------------------------------------------------------
//XResultSetMetaDataSupplier methods.
//--------------------------------------------------------------------------
//virtual
Reference< XResultSetMetaData > SAL_CALL ContentResultSetWrapper
	::getMetaData()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	ReacquireableGuard aGuard( m_aMutex );
	if( !m_xMetaDataFromOrigin.is() && m_xResultSetOrigin.is() )
	{
		Reference< XResultSetMetaDataSupplier > xMetaDataSupplier
			= Reference< XResultSetMetaDataSupplier >(
				m_xResultSetOrigin, UNO_QUERY );

		if( xMetaDataSupplier.is() )
		{
			aGuard.clear();

			Reference< XResultSetMetaData > xMetaData
				= xMetaDataSupplier->getMetaData();

			aGuard.reacquire();
			m_xMetaDataFromOrigin = xMetaData;
		}
	}
	return m_xMetaDataFromOrigin;
}


//--------------------------------------------------------------------------
// XPropertySet methods.
//--------------------------------------------------------------------------
// virtual
Reference< XPropertySetInfo > SAL_CALL ContentResultSetWrapper
	::getPropertySetInfo() throw( RuntimeException )
{
	impl_EnsureNotDisposed();
	{
		osl::Guard< osl::Mutex > aGuard( m_aMutex );
		if( m_xPropertySetInfo.is() )
			return m_xPropertySetInfo;
	}
	impl_initPropertySetInfo();
	return m_xPropertySetInfo;
}
//--------------------------------------------------------------------------
// virtual
void SAL_CALL ContentResultSetWrapper
	::setPropertyValue( const OUString& rPropertyName, const Any& rValue )
	throw( UnknownPropertyException,
		   PropertyVetoException,
		   IllegalArgumentException,
		   WrappedTargetException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();
	impl_init_xPropertySetOrigin();
	if( !m_xPropertySetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw UnknownPropertyException();
	}
	m_xPropertySetOrigin->setPropertyValue( rPropertyName, rValue );
}

//--------------------------------------------------------------------------
// virtual
Any SAL_CALL ContentResultSetWrapper
	::getPropertyValue( const OUString& rPropertyName )
	throw( UnknownPropertyException,
		   WrappedTargetException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();
	impl_init_xPropertySetOrigin();
	if( !m_xPropertySetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw UnknownPropertyException();
	}
	return m_xPropertySetOrigin->getPropertyValue( rPropertyName );
}

//--------------------------------------------------------------------------
// virtual
void SAL_CALL ContentResultSetWrapper
	::addPropertyChangeListener(
			const OUString& aPropertyName,
			const Reference< XPropertyChangeListener >& xListener )
	throw( UnknownPropertyException,
		   WrappedTargetException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !getPropertySetInfo().is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw UnknownPropertyException();
	}

	if( aPropertyName.getLength() )
	{
		m_xPropertySetInfo->getPropertyByName( aPropertyName );
		//throws UnknownPropertyException, if so
	}

	impl_getPropertyChangeListenerContainer();
	sal_Bool bNeedRegister = !m_pPropertyChangeListeners->
						getContainedTypes().getLength();
	m_pPropertyChangeListeners->addInterface( aPropertyName, xListener );
	if( bNeedRegister )
	{
		impl_init_xPropertySetOrigin();
		{
			osl::Guard< osl::Mutex > aGuard( m_aMutex );
			if( !m_xPropertySetOrigin.is() )
			{
				OSL_ENSURE( sal_False, "broadcaster was disposed already" );
				return;
			}
		}
		try
		{
			m_xPropertySetOrigin->addPropertyChangeListener(
				OUString(), static_cast< XPropertyChangeListener * >( m_pMyListenerImpl ) );
		}
		catch( Exception& rEx )
		{
			m_pPropertyChangeListeners->removeInterface( aPropertyName, xListener );
			throw rEx;
		}
	}
}

//--------------------------------------------------------------------------
// virtual
void SAL_CALL ContentResultSetWrapper
	::addVetoableChangeListener(
			const OUString& rPropertyName,
			const Reference< XVetoableChangeListener >& xListener )
	throw( UnknownPropertyException,
		   WrappedTargetException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !getPropertySetInfo().is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw UnknownPropertyException();
	}
	if( rPropertyName.getLength() )
	{
		m_xPropertySetInfo->getPropertyByName( rPropertyName );
		//throws UnknownPropertyException, if so
	}

	impl_getVetoableChangeListenerContainer();
	sal_Bool bNeedRegister = !m_pVetoableChangeListeners->
						getContainedTypes().getLength();
	m_pVetoableChangeListeners->addInterface( rPropertyName, xListener );
	if( bNeedRegister )
	{
		impl_init_xPropertySetOrigin();
		{
			osl::Guard< osl::Mutex > aGuard( m_aMutex );
			if( !m_xPropertySetOrigin.is() )
			{
				OSL_ENSURE( sal_False, "broadcaster was disposed already" );
				return;
			}
		}
		try
		{
			m_xPropertySetOrigin->addVetoableChangeListener(
				OUString(), static_cast< XVetoableChangeListener * >( m_pMyListenerImpl ) );
		}
		catch( Exception& rEx )
		{
			m_pVetoableChangeListeners->removeInterface( rPropertyName, xListener );
			throw rEx;
		}
	}
}

//--------------------------------------------------------------------------
// virtual
void SAL_CALL ContentResultSetWrapper
	::removePropertyChangeListener(
			const OUString& rPropertyName,
			const Reference< XPropertyChangeListener >& xListener )
	throw( UnknownPropertyException,
		   WrappedTargetException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	{
		//noop, if no listener registered
		osl::Guard< osl::Mutex > aGuard( m_aMutex );
		if( !m_pPropertyChangeListeners )
			return;
	}
	OInterfaceContainerHelper* pContainer =
		m_pPropertyChangeListeners->getContainer( rPropertyName );

	if( !pContainer )
	{
		if( rPropertyName.getLength() )
		{
			if( !getPropertySetInfo().is() )
				throw UnknownPropertyException();

			m_xPropertySetInfo->getPropertyByName( rPropertyName );
			//throws UnknownPropertyException, if so
		}
		return; //the listener was not registered
	}

	m_pPropertyChangeListeners->removeInterface( rPropertyName, xListener );

	if( !m_pPropertyChangeListeners->getContainedTypes().getLength() )
	{
		impl_init_xPropertySetOrigin();
		{
			osl::Guard< osl::Mutex > aGuard( m_aMutex );
			if( !m_xPropertySetOrigin.is() )
			{
				OSL_ENSURE( sal_False, "broadcaster was disposed already" );
				return;
			}
		}
		try
		{
			m_xPropertySetOrigin->removePropertyChangeListener(
				OUString(), static_cast< XPropertyChangeListener * >( m_pMyListenerImpl ) );
		}
		catch( Exception& )
		{
			OSL_ENSURE( sal_False, "could not remove PropertyChangeListener" );
		}
	}
}

//--------------------------------------------------------------------------
// virtual
void SAL_CALL ContentResultSetWrapper
	::removeVetoableChangeListener(
			const OUString& rPropertyName,
			const Reference< XVetoableChangeListener >& xListener )
	throw( UnknownPropertyException,
		   WrappedTargetException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	{
		//noop, if no listener registered
		osl::Guard< osl::Mutex > aGuard( m_aMutex );
		if( !m_pVetoableChangeListeners )
			return;
	}
	OInterfaceContainerHelper* pContainer =
		m_pVetoableChangeListeners->getContainer( rPropertyName );

	if( !pContainer )
	{
		if( rPropertyName.getLength() )
		{
			if( !getPropertySetInfo().is() )
				throw UnknownPropertyException();

			m_xPropertySetInfo->getPropertyByName( rPropertyName );
			//throws UnknownPropertyException, if so
		}
		return; //the listener was not registered
	}

	m_pVetoableChangeListeners->removeInterface( rPropertyName, xListener );

	if( !m_pVetoableChangeListeners->getContainedTypes().getLength() )
	{
		impl_init_xPropertySetOrigin();
		{
			osl::Guard< osl::Mutex > aGuard( m_aMutex );
			if( !m_xPropertySetOrigin.is() )
			{
				OSL_ENSURE( sal_False, "broadcaster was disposed already" );
				return;
			}
		}
		try
		{
			m_xPropertySetOrigin->removeVetoableChangeListener(
				OUString(), static_cast< XVetoableChangeListener * >( m_pMyListenerImpl ) );
		}
		catch( Exception& )
		{
			OSL_ENSURE( sal_False, "could not remove VetoableChangeListener" );
		}
	}
}

//--------------------------------------------------------------------------
// own methods.
//--------------------------------------------------------------------------

//virtual
void SAL_CALL ContentResultSetWrapper
	::impl_disposing( const EventObject& )
	throw( RuntimeException )
{
	impl_EnsureNotDisposed();

	osl::Guard< osl::Mutex > aGuard( m_aMutex );

	if( !m_xResultSetOrigin.is() )
		return;

	//release all references to the broadcaster:
	m_xResultSetOrigin.clear();
	if(m_xRowOrigin.is())
		m_xRowOrigin.clear();
	if(m_xContentAccessOrigin.is())
		m_xContentAccessOrigin.clear();
	if(m_xPropertySetOrigin.is())
		m_xPropertySetOrigin.clear();
	m_xMetaDataFromOrigin.clear();
	if(m_xPropertySetInfo.is())
		m_xPropertySetInfo.clear();
}

//virtual
void SAL_CALL ContentResultSetWrapper
	::impl_propertyChange( const PropertyChangeEvent& rEvt )
	throw( RuntimeException )
{
	impl_EnsureNotDisposed();

	PropertyChangeEvent aEvt( rEvt );
	aEvt.Source = static_cast< XPropertySet * >( this );
	aEvt.Further = sal_False;
	impl_notifyPropertyChangeListeners(	aEvt );
}

//virtual
void SAL_CALL ContentResultSetWrapper
	::impl_vetoableChange( const PropertyChangeEvent& rEvt )
	throw( PropertyVetoException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	PropertyChangeEvent aEvt( rEvt );
	aEvt.Source = static_cast< XPropertySet * >( this );
	aEvt.Further = sal_False;

	impl_notifyVetoableChangeListeners( aEvt );
}

//--------------------------------------------------------------------------
// XContentAccess methods.	( -- position dependent )
//--------------------------------------------------------------------------

// virtual
OUString SAL_CALL ContentResultSetWrapper
	::queryContentIdentifierString()
	throw( RuntimeException )
{
	impl_EnsureNotDisposed();
	impl_init_xContentAccessOrigin();
	if( !m_xContentAccessOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xContentAccessOrigin->queryContentIdentifierString();
}

//--------------------------------------------------------------------------
// virtual
Reference< XContentIdentifier > SAL_CALL ContentResultSetWrapper
	::queryContentIdentifier()
	throw( RuntimeException )
{
	impl_EnsureNotDisposed();
	impl_init_xContentAccessOrigin();
	if( !m_xContentAccessOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xContentAccessOrigin->queryContentIdentifier();
}

//--------------------------------------------------------------------------
// virtual
Reference< XContent > SAL_CALL ContentResultSetWrapper
	::queryContent()
	throw( RuntimeException )
{
	impl_EnsureNotDisposed();
	impl_init_xContentAccessOrigin();
	if( !m_xContentAccessOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xContentAccessOrigin->queryContent();
}

//-----------------------------------------------------------------
// XResultSet methods.
//-----------------------------------------------------------------
//virtual

sal_Bool SAL_CALL ContentResultSetWrapper
	::next()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !m_xResultSetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xResultSetOrigin->next();
}

//virtual
sal_Bool SAL_CALL ContentResultSetWrapper
	::previous()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !m_xResultSetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xResultSetOrigin->previous();
}

//virtual
sal_Bool SAL_CALL ContentResultSetWrapper
	::absolute( sal_Int32 row )
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !m_xResultSetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xResultSetOrigin->absolute( row );
}

//virtual
sal_Bool SAL_CALL ContentResultSetWrapper
	::relative( sal_Int32 rows )
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !m_xResultSetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xResultSetOrigin->relative( rows );
}


//virtual
sal_Bool SAL_CALL ContentResultSetWrapper
	::first()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !m_xResultSetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xResultSetOrigin->first();
}

//virtual
sal_Bool SAL_CALL ContentResultSetWrapper
	::last()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !m_xResultSetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xResultSetOrigin->last();
}

//virtual
void SAL_CALL ContentResultSetWrapper
	::beforeFirst()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !m_xResultSetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	m_xResultSetOrigin->beforeFirst();
}

//virtual
void SAL_CALL ContentResultSetWrapper
	::afterLast()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !m_xResultSetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	m_xResultSetOrigin->afterLast();
}

//virtual
sal_Bool SAL_CALL ContentResultSetWrapper
	::isAfterLast()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !m_xResultSetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xResultSetOrigin->isAfterLast();
}

//virtual
sal_Bool SAL_CALL ContentResultSetWrapper
	::isBeforeFirst()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !m_xResultSetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xResultSetOrigin->isBeforeFirst();
}

//virtual
sal_Bool SAL_CALL ContentResultSetWrapper
	::isFirst()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !m_xResultSetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xResultSetOrigin->isFirst();
}

//virtual
sal_Bool SAL_CALL ContentResultSetWrapper
	::isLast()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !m_xResultSetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xResultSetOrigin->isLast();
}


//virtual
sal_Int32 SAL_CALL ContentResultSetWrapper
	::getRow()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !m_xResultSetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xResultSetOrigin->getRow();
}

//virtual
void SAL_CALL ContentResultSetWrapper
	::refreshRow()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !m_xResultSetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	m_xResultSetOrigin->refreshRow();
}

//virtual
sal_Bool SAL_CALL ContentResultSetWrapper
	::rowUpdated()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !m_xResultSetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xResultSetOrigin->rowUpdated();
}
//virtual
sal_Bool SAL_CALL ContentResultSetWrapper
	::rowInserted()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !m_xResultSetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xResultSetOrigin->rowInserted();
}

//virtual
sal_Bool SAL_CALL ContentResultSetWrapper
	::rowDeleted()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();

	if( !m_xResultSetOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xResultSetOrigin->rowDeleted();
}

//virtual
Reference< XInterface > SAL_CALL ContentResultSetWrapper
	::getStatement()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();
	//@todo ?return anything
	return Reference< XInterface >();
}

//-----------------------------------------------------------------
// XRow methods.
//-----------------------------------------------------------------

#define XROW_GETXXX( getXXX )									\
impl_EnsureNotDisposed();										\
impl_init_xRowOrigin();											\
if( !m_xRowOrigin.is() )										\
{																\
	OSL_ENSURE( sal_False, "broadcaster was disposed already" );\
	throw RuntimeException();									\
}																\
return m_xRowOrigin->getXXX( columnIndex );

//virtual
sal_Bool SAL_CALL ContentResultSetWrapper
	::wasNull()
	throw( SQLException,
		   RuntimeException )
{
	impl_EnsureNotDisposed();
	impl_init_xRowOrigin();
	if( !m_xRowOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xRowOrigin->wasNull();
}

//virtual
rtl::OUString SAL_CALL ContentResultSetWrapper
	::getString( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getString );
}

//virtual
sal_Bool SAL_CALL ContentResultSetWrapper
	::getBoolean( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getBoolean );
}

//virtual
sal_Int8 SAL_CALL ContentResultSetWrapper
	::getByte( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getByte );
}

//virtual
sal_Int16 SAL_CALL ContentResultSetWrapper
	::getShort( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getShort );
}

//virtual
sal_Int32 SAL_CALL ContentResultSetWrapper
	::getInt( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getInt );
}

//virtual
sal_Int64 SAL_CALL ContentResultSetWrapper
	::getLong( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getLong );
}

//virtual
float SAL_CALL ContentResultSetWrapper
	::getFloat( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getFloat );
}

//virtual
double SAL_CALL ContentResultSetWrapper
	::getDouble( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getDouble );
}

//virtual
Sequence< sal_Int8 > SAL_CALL ContentResultSetWrapper
	::getBytes( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getBytes );
}

//virtual
Date SAL_CALL ContentResultSetWrapper
	::getDate( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getDate );
}

//virtual
Time SAL_CALL ContentResultSetWrapper
	::getTime( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getTime );
}

//virtual
DateTime SAL_CALL ContentResultSetWrapper
	::getTimestamp( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getTimestamp );
}

//virtual
Reference< com::sun::star::io::XInputStream >
	SAL_CALL ContentResultSetWrapper
	::getBinaryStream( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getBinaryStream );
}

//virtual
Reference< com::sun::star::io::XInputStream >
	SAL_CALL ContentResultSetWrapper
	::getCharacterStream( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getCharacterStream );
}

//virtual
Any SAL_CALL ContentResultSetWrapper
	::getObject( sal_Int32 columnIndex,
		   const Reference<
			com::sun::star::container::XNameAccess >& typeMap )
	throw( SQLException,
		   RuntimeException )
{
	//if you change this macro please pay attention to
	//define XROW_GETXXX, where this is similar implemented

	impl_EnsureNotDisposed();
	impl_init_xRowOrigin();
	if( !m_xRowOrigin.is() )
	{
		OSL_ENSURE( sal_False, "broadcaster was disposed already" );
		throw RuntimeException();
	}
	return m_xRowOrigin->getObject( columnIndex, typeMap );
}

//virtual
Reference< XRef > SAL_CALL ContentResultSetWrapper
	::getRef( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getRef );
}

//virtual
Reference< XBlob > SAL_CALL ContentResultSetWrapper
	::getBlob( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getBlob );
}

//virtual
Reference< XClob > SAL_CALL ContentResultSetWrapper
	::getClob( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getClob );
}

//virtual
Reference< XArray > SAL_CALL ContentResultSetWrapper
	::getArray( sal_Int32 columnIndex )
	throw( SQLException,
		   RuntimeException )
{
	XROW_GETXXX( getArray );
}

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
// class ContentResultSetWrapperListener
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------

ContentResultSetWrapperListener::ContentResultSetWrapperListener(
	ContentResultSetWrapper* pOwner )
	: m_pOwner( pOwner )
{
}

ContentResultSetWrapperListener::~ContentResultSetWrapperListener()
{
}

//--------------------------------------------------------------------------
// XInterface methods.
//--------------------------------------------------------------------------
//list all interfaces inclusive baseclasses of interfaces
XINTERFACE_COMMON_IMPL( ContentResultSetWrapperListener )
QUERYINTERFACE_IMPL_START( ContentResultSetWrapperListener )

	static_cast< XEventListener * >(
					 static_cast< XPropertyChangeListener * >(this))
	, SAL_STATIC_CAST( XPropertyChangeListener*, this )
	, SAL_STATIC_CAST( XVetoableChangeListener*, this )

QUERYINTERFACE_IMPL_END


//--------------------------------------------------------------------------
//XEventListener methods.
//--------------------------------------------------------------------------

//virtual
void SAL_CALL ContentResultSetWrapperListener
	::disposing( const EventObject& rEventObject )
	throw( RuntimeException )
{
	if( m_pOwner )
		m_pOwner->impl_disposing( rEventObject );
}

//--------------------------------------------------------------------------
//XPropertyChangeListener methods.
//--------------------------------------------------------------------------

//virtual
void SAL_CALL ContentResultSetWrapperListener
	::propertyChange( const PropertyChangeEvent& rEvt )
	throw( RuntimeException )
{
	if( m_pOwner )
		m_pOwner->impl_propertyChange( rEvt );
}

//--------------------------------------------------------------------------
//XVetoableChangeListener methods.
//--------------------------------------------------------------------------
//virtual
void SAL_CALL ContentResultSetWrapperListener
	::vetoableChange( const PropertyChangeEvent& rEvt )
	throw( PropertyVetoException,
		   RuntimeException )
{
	if( m_pOwner )
		m_pOwner->impl_vetoableChange( rEvt );
}

void SAL_CALL ContentResultSetWrapperListener
	::impl_OwnerDies()
{
	m_pOwner = NULL;
}