/**************************************************************
 * 
 * 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_svl.hxx"
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/embed/ElementModes.hpp>
#include <com/sun/star/embed/XTransactedObject.hpp>
#include <com/sun/star/ucb/XProgressHandler.hpp>
#include <com/sun/star/ucb/XContentAccess.hpp>
#include <com/sun/star/ucb/XSimpleFileAccess.hpp>

#ifndef _COM_SUN_STAR_UCB_INTERACTIVEIODEXCEPTION_HPP_
#include <com/sun/star/ucb/InteractiveIOException.hpp>
#endif
#include <com/sun/star/ucb/IOErrorCode.hpp>
#include <com/sun/star/container/XHierarchicalNameAccess.hpp>
#include <com/sun/star/container/XEnumerationAccess.hpp>
#include <com/sun/star/container/XNamed.hpp>
#include <com/sun/star/util/XChangesBatch.hpp>
#include <com/sun/star/util/XCloneable.hpp>
#include <com/sun/star/lang/XUnoTunnel.hpp>
#include <com/sun/star/lang/XComponent.hpp>
#include <com/sun/star/lang/DisposedException.hpp>
#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
#include <com/sun/star/io/IOException.hpp>
#include <com/sun/star/io/XTruncate.hpp>
#include <com/sun/star/sdbc/XResultSet.hpp>
#include <com/sun/star/sdbc/XRow.hpp>


#ifndef _COMPHELPER_PROCESSFACTORY_HXX
#include <comphelper/processfactory.hxx>
#endif
#include <comphelper/storagehelper.hxx>
#include <cppuhelper/typeprovider.hxx>
#include <cppuhelper/exc_hlp.hxx>

#include <tools/urlobj.hxx>
#include <unotools/ucbhelper.hxx>
#include <unotools/ucbstreamhelper.hxx>
#include <unotools/streamwrap.hxx>
#include <ucbhelper/fileidentifierconverter.hxx>
#include <ucbhelper/contentbroker.hxx>
#include <ucbhelper/content.hxx>

#include "fsstorage.hxx"
#include "oinputstreamcontainer.hxx"
#include "ostreamcontainer.hxx"

using namespace ::com::sun::star;

//=========================================================

// TODO: move to a standard helper
sal_Bool isLocalFile_Impl( ::rtl::OUString aURL )
{
	::rtl::OUString aSystemPath;
    ::ucbhelper::ContentBroker* pBroker = ::ucbhelper::ContentBroker::get();
    if ( !pBroker )
		throw uno::RuntimeException();

	uno::Reference< ucb::XContentProviderManager > xManager =
				pBroker->getContentProviderManagerInterface();
	try
	{
		aSystemPath = ::ucbhelper::getSystemPathFromFileURL( xManager, aURL );
	}
	catch ( uno::Exception& )
	{
	}

	return ( aSystemPath.getLength() != 0 );
}


//=========================================================

struct FSStorage_Impl
{
	::rtl::OUString m_aURL;
	
	::ucbhelper::Content* m_pContent;
	sal_Int32 m_nMode;
	
	::cppu::OInterfaceContainerHelper* m_pListenersContainer; // list of listeners
	::cppu::OTypeCollection* m_pTypeCollection;

	uno::Reference< lang::XMultiServiceFactory > m_xFactory;

	
	FSStorage_Impl( const ::rtl::OUString& aURL, sal_Int32 nMode, uno::Reference< lang::XMultiServiceFactory > xFactory )
	: m_aURL( aURL )
	, m_pContent( NULL )
	, m_nMode( nMode )
	, m_pListenersContainer( NULL )
	, m_pTypeCollection( NULL )
	, m_xFactory( xFactory )
	{
		OSL_ENSURE( m_aURL.getLength(), "The URL must not be empty" );
	}

	FSStorage_Impl( const ::ucbhelper::Content& aContent, sal_Int32 nMode, uno::Reference< lang::XMultiServiceFactory > xFactory )
	: m_aURL( aContent.getURL() )
	, m_pContent( new ::ucbhelper::Content( aContent ) )
	, m_nMode( nMode )
	, m_pListenersContainer( NULL )
	, m_pTypeCollection( NULL )
	, m_xFactory( xFactory )
	{
		OSL_ENSURE( m_aURL.getLength(), "The URL must not be empty" );
	}

	~FSStorage_Impl();
};

//=========================================================

FSStorage_Impl::~FSStorage_Impl()
{
	if ( m_pListenersContainer )
		delete m_pListenersContainer;
	if ( m_pTypeCollection )
		delete m_pTypeCollection;
	if ( m_pContent )
		delete m_pContent;
}

//=====================================================
// FSStorage implementation
//=====================================================

//-----------------------------------------------
FSStorage::FSStorage( const ::ucbhelper::Content& aContent,
					sal_Int32 nMode,
					uno::Sequence< beans::PropertyValue >,
					uno::Reference< lang::XMultiServiceFactory > xFactory )
: m_pImpl( new FSStorage_Impl( aContent, nMode, xFactory ) )
{
	// TODO: use properties
	if ( !xFactory.is() )
		throw uno::RuntimeException();

	GetContent();
}

//-----------------------------------------------
FSStorage::~FSStorage()
{
	{
		::osl::MutexGuard aGuard( m_aMutex );
		m_refCount++; // to call dispose
		try {
			dispose();
		}
		catch( uno::RuntimeException& )
		{}
	}
}

//-----------------------------------------------
sal_Bool FSStorage::MakeFolderNoUI( const String& rFolder, sal_Bool )
{
   	INetURLObject aURL( rFolder );
	::rtl::OUString aTitle = aURL.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DECODE_WITH_CHARSET );
	aURL.removeSegment();
	::ucbhelper::Content aParent;
	::ucbhelper::Content aResultContent;

   	if ( ::ucbhelper::Content::create( aURL.GetMainURL( INetURLObject::NO_DECODE ),
								 uno::Reference< ucb::XCommandEnvironment >(),
								 aParent ) )
		return ::utl::UCBContentHelper::MakeFolder( aParent, aTitle, aResultContent, sal_False );
		
	return sal_False;
}

//-----------------------------------------------
::ucbhelper::Content* FSStorage::GetContent()
{
	::osl::MutexGuard aGuard( m_aMutex );
	if ( !m_pImpl->m_pContent )
	{
		uno::Reference< ucb::XCommandEnvironment > xDummyEnv;

		try
		{
			m_pImpl->m_pContent = new ::ucbhelper::Content( m_pImpl->m_aURL, xDummyEnv );
		}
		catch( uno::Exception& )
		{
		}
	}

	return m_pImpl->m_pContent;
}

//-----------------------------------------------
void FSStorage::CopyStreamToSubStream( const ::rtl::OUString& aSourceURL,
										const uno::Reference< embed::XStorage >& xDest,
										const ::rtl::OUString& aNewEntryName )
{
	if ( !xDest.is() )
		throw uno::RuntimeException();

	uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
	::ucbhelper::Content aSourceContent( aSourceURL, xDummyEnv );
	uno::Reference< io::XInputStream > xSourceInput = aSourceContent.openStream();

	if ( !xSourceInput.is() )
		throw io::IOException(); // TODO: error handling

	uno::Reference< io::XStream > xSubStream = xDest->openStreamElement(
												aNewEntryName,
												embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE );
	if ( !xSubStream.is() )
		throw uno::RuntimeException();
				
	uno::Reference< io::XOutputStream > xDestOutput = xSubStream->getOutputStream();
	if ( !xDestOutput.is() )
		throw uno::RuntimeException();

	::comphelper::OStorageHelper::CopyInputToOutput( xSourceInput, xDestOutput );
	xDestOutput->closeOutput();
}

//-----------------------------------------------
void FSStorage::CopyContentToStorage_Impl( ::ucbhelper::Content* pContent, const uno::Reference< embed::XStorage >& xDest )
{
	if ( !pContent )
		throw uno::RuntimeException();

	// get list of contents of the Content
	// create cursor for access to children
	uno::Sequence< ::rtl::OUString > aProps( 2 );
	::rtl::OUString* pProps = aProps.getArray();
	pProps[0] = ::rtl::OUString::createFromAscii( "TargetURL" );
	pProps[1] = ::rtl::OUString::createFromAscii( "IsFolder" );
	::ucbhelper::ResultSetInclude eInclude = ::ucbhelper::INCLUDE_FOLDERS_AND_DOCUMENTS;

	try
	{
		uno::Reference< sdbc::XResultSet > xResultSet = pContent->createCursor( aProps, eInclude );
		uno::Reference< ucb::XContentAccess > xContentAccess( xResultSet, uno::UNO_QUERY );
		uno::Reference< sdbc::XRow > xRow( xResultSet, uno::UNO_QUERY );
		if ( xResultSet.is() )
		{
			// go through the list: insert files as streams, insert folders as substorages using recursion
			while ( xResultSet->next() )
			{
				::rtl::OUString aSourceURL( xRow->getString( 1 ) );
				sal_Bool bIsFolder( xRow->getBoolean(2) );
	
				// TODO/LATER: not sure whether the entry name must be encoded
				::rtl::OUString aNewEntryName( INetURLObject( aSourceURL ).getName( INetURLObject::LAST_SEGMENT,
																					true,
																					INetURLObject::NO_DECODE ) );
				if ( bIsFolder )
				{
					uno::Reference< embed::XStorage > xSubStorage = xDest->openStorageElement( aNewEntryName,
																								embed::ElementModes::READWRITE );
					if ( !xSubStorage.is() )
						throw uno::RuntimeException();
	
					uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
					::ucbhelper::Content aSourceContent( aSourceURL, xDummyEnv );
					CopyContentToStorage_Impl( &aSourceContent, xSubStorage );
				}
				else
				{
					CopyStreamToSubStream( aSourceURL, xDest, aNewEntryName );
				}
			}
		}

		uno::Reference< embed::XTransactedObject > xTransact( xDest, uno::UNO_QUERY );
		if ( xTransact.is() )
			xTransact->commit();
	}
	catch( ucb::InteractiveIOException& r )
    {
        if ( r.Code == ucb::IOErrorCode_NOT_EXISTING )
			OSL_ENSURE( sal_False, "The folder does not exist!\n" );
		else
			throw;
    }
}

//____________________________________________________________________________________________________
//	XInterface
//____________________________________________________________________________________________________

//-----------------------------------------------
uno::Any SAL_CALL FSStorage::queryInterface( const uno::Type& rType )
		throw( uno::RuntimeException )
{
	uno::Any aReturn;
	aReturn <<= ::cppu::queryInterface
				(	rType
				,	static_cast<lang::XTypeProvider*> ( this )
				,	static_cast<embed::XStorage*> ( this )
				,	static_cast<embed::XHierarchicalStorageAccess*> ( this )
				,	static_cast<container::XNameAccess*> ( this )
				,	static_cast<container::XElementAccess*> ( this )
				,	static_cast<lang::XComponent*> ( this )
				,	static_cast<beans::XPropertySet*> ( this ) );

	if ( aReturn.hasValue() == sal_True )
		return aReturn ;

	return OWeakObject::queryInterface( rType );
}

//-----------------------------------------------
void SAL_CALL FSStorage::acquire() throw()
{
	OWeakObject::acquire();
}

//-----------------------------------------------
void SAL_CALL FSStorage::release() throw()
{
	OWeakObject::release();
}

//____________________________________________________________________________________________________
//	XTypeProvider
//____________________________________________________________________________________________________

//-----------------------------------------------
uno::Sequence< uno::Type > SAL_CALL FSStorage::getTypes()
		throw( uno::RuntimeException )
{
	if ( m_pImpl->m_pTypeCollection == NULL )
	{
		::osl::MutexGuard aGuard( m_aMutex );

		if ( m_pImpl->m_pTypeCollection == NULL )
		{
			m_pImpl->m_pTypeCollection = new ::cppu::OTypeCollection
								(	::getCppuType( ( const uno::Reference< lang::XTypeProvider >* )NULL )
								,	::getCppuType( ( const uno::Reference< embed::XStorage >* )NULL )
								,	::getCppuType( ( const uno::Reference< embed::XHierarchicalStorageAccess >* )NULL )
								,	::getCppuType( ( const uno::Reference< beans::XPropertySet >* )NULL ) );
		}
	}

	return m_pImpl->m_pTypeCollection->getTypes() ;
}

//-----------------------------------------------
uno::Sequence< sal_Int8 > SAL_CALL FSStorage::getImplementationId()
		throw( uno::RuntimeException )
{
	static ::cppu::OImplementationId* pID = NULL ;

	if ( pID == NULL )
	{
		::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() ) ;

		if ( pID == NULL )
		{
			static ::cppu::OImplementationId aID( sal_False ) ;
			pID = &aID ;
		}
	}

	return pID->getImplementationId() ;

}

//____________________________________________________________________________________________________
//	XStorage
//____________________________________________________________________________________________________

//-----------------------------------------------
void SAL_CALL FSStorage::copyToStorage( const uno::Reference< embed::XStorage >& xDest )
		throw ( embed::InvalidStorageException,
				io::IOException,
				lang::IllegalArgumentException,
				embed::StorageWrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( !xDest.is() || xDest == uno::Reference< uno::XInterface >( static_cast< OWeakObject*> ( this ), uno::UNO_QUERY ) )
		throw lang::IllegalArgumentException(); // TODO:

	if ( !GetContent() )
		throw io::IOException(); // TODO: error handling

	try
	{
		CopyContentToStorage_Impl( GetContent(), xDest );
	}
	catch( embed::InvalidStorageException& )
	{
		throw;
	}
	catch( lang::IllegalArgumentException& )
	{
		throw;
	}
	catch( embed::StorageWrappedTargetException& )
	{
		throw;
	}
	catch( io::IOException& )
	{
		throw;
	}
	catch( uno::RuntimeException& )
	{
		throw;
	}
	catch( uno::Exception& )
	{
      	uno::Any aCaught( ::cppu::getCaughtException() );
		throw embed::StorageWrappedTargetException( ::rtl::OUString::createFromAscii( "Can't copy raw stream" ),
												 uno::Reference< io::XInputStream >(),
												 aCaught );
	}
}

//-----------------------------------------------
uno::Reference< io::XStream > SAL_CALL FSStorage::openStreamElement(
	const ::rtl::OUString& aStreamName, sal_Int32 nOpenMode )
		throw ( embed::InvalidStorageException,
				lang::IllegalArgumentException,
				packages::WrongPasswordException,
				io::IOException,
				embed::StorageWrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( !GetContent() )
		throw io::IOException(); // TODO: error handling

	// TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
	INetURLObject aFileURL( m_pImpl->m_aURL );
	aFileURL.Append( aStreamName );

	if ( ::utl::UCBContentHelper::IsFolder( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
		throw io::IOException();

	if ( ( nOpenMode & embed::ElementModes::NOCREATE )
	  && !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
		throw io::IOException(); // TODO:

	uno::Reference< ucb::XCommandEnvironment > xDummyEnv; // TODO: provide InteractionHandler if any
	uno::Reference< io::XStream > xResult;
	try
	{
		if ( nOpenMode & embed::ElementModes::WRITE )
		{
			if ( isLocalFile_Impl( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
			{
				uno::Reference< ucb::XSimpleFileAccess > xSimpleFileAccess(
					m_pImpl->m_xFactory->createInstance( 
						::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.ucb.SimpleFileAccess" ) ) ),
					uno::UNO_QUERY_THROW );
				xResult = xSimpleFileAccess->openFileReadWrite( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) );
			}
			else
			{
				// TODO: test whether it really works for http and fwp
				SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( aFileURL.GetMainURL( INetURLObject::NO_DECODE ),
																	  	STREAM_STD_WRITE );
				if ( pStream )
				{
					if ( !pStream->GetError() )
						xResult = uno::Reference < io::XStream >( new ::utl::OStreamWrapper( *pStream ) );
					else
						delete pStream;
				}
			}
	
			if ( !xResult.is() )
				throw io::IOException();
	
			if ( ( nOpenMode & embed::ElementModes::TRUNCATE ) )
			{
				uno::Reference< io::XTruncate > xTrunc( xResult->getOutputStream(), uno::UNO_QUERY_THROW );
				xTrunc->truncate();
			}
		}
		else
		{
			if ( ( nOpenMode & embed::ElementModes::TRUNCATE )
		  	|| !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
				throw io::IOException(); // TODO: access denied
	
			::ucbhelper::Content aResultContent( aFileURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv );
			uno::Reference< io::XInputStream > xInStream = aResultContent.openStream();
			xResult = static_cast< io::XStream* >( new OFSInputStreamContainer( xInStream ) );
		}
	}
	catch( embed::InvalidStorageException& )
	{
		throw;
	}
	catch( lang::IllegalArgumentException& )
	{
		throw;
	}
	catch( packages::WrongPasswordException& )
	{
		throw;
	}
	catch( embed::StorageWrappedTargetException& )
	{
		throw;
	}
	catch( io::IOException& )
	{
		throw;
	}
	catch( uno::RuntimeException& )
	{
		throw;
	}
	catch( uno::Exception& )
	{
      	uno::Any aCaught( ::cppu::getCaughtException() );
		throw embed::StorageWrappedTargetException( ::rtl::OUString::createFromAscii( "Can't copy raw stream" ),
												 uno::Reference< io::XInputStream >(),
												 aCaught );
	}

	return xResult;
}

//-----------------------------------------------
uno::Reference< io::XStream > SAL_CALL FSStorage::openEncryptedStreamElement( 
	const ::rtl::OUString&, sal_Int32, const ::rtl::OUString& )
		throw ( embed::InvalidStorageException,
				lang::IllegalArgumentException,
				packages::NoEncryptionException,
				packages::WrongPasswordException,
				io::IOException,
				embed::StorageWrappedTargetException,
				uno::RuntimeException )
{
	throw packages::NoEncryptionException();
}

//-----------------------------------------------
uno::Reference< embed::XStorage > SAL_CALL FSStorage::openStorageElement(
			const ::rtl::OUString& aStorName, sal_Int32 nStorageMode )
		throw ( embed::InvalidStorageException,
				lang::IllegalArgumentException,
				io::IOException,
				embed::StorageWrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( !GetContent() )
		throw io::IOException(); // TODO: error handling

	if ( ( nStorageMode & embed::ElementModes::WRITE )
	  && !( m_pImpl->m_nMode & embed::ElementModes::WRITE ) )
	  	throw io::IOException(); // TODO: error handling

	// TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
	INetURLObject aFolderURL( m_pImpl->m_aURL );
	aFolderURL.Append( aStorName );

	sal_Bool bFolderExists = ::utl::UCBContentHelper::IsFolder( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) );
	if ( !bFolderExists && ::utl::UCBContentHelper::IsDocument( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
		throw io::IOException(); // TODO:

	if ( ( nStorageMode & embed::ElementModes::NOCREATE ) && !bFolderExists )
		throw io::IOException(); // TODO:

	uno::Reference< ucb::XCommandEnvironment > xDummyEnv; // TODO: provide InteractionHandler if any
	uno::Reference< embed::XStorage > xResult;
	try
	{
		if ( nStorageMode & embed::ElementModes::WRITE )
		{
			if ( ( nStorageMode & embed::ElementModes::TRUNCATE ) && bFolderExists )
			{
				::utl::UCBContentHelper::Kill( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ) );
				bFolderExists =
					MakeFolderNoUI( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ), sal_True ); // TODO: not atomar :(
			}
			else if ( !bFolderExists )
			{
				bFolderExists =
					MakeFolderNoUI( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ), sal_True ); // TODO: not atomar :(
			}
		}
		else if ( ( nStorageMode & embed::ElementModes::TRUNCATE ) )
			throw io::IOException(); // TODO: access denied

		if ( !bFolderExists )
			throw io::IOException(); // there is no such folder

		::ucbhelper::Content aResultContent( aFolderURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv );
		xResult = uno::Reference< embed::XStorage >( 
							static_cast< OWeakObject* >( new FSStorage(	aResultContent,
																		nStorageMode,
																		uno::Sequence< beans::PropertyValue >(),
																		m_pImpl->m_xFactory ) ),
							uno::UNO_QUERY );
	}
	catch( embed::InvalidStorageException& )
	{
		throw;
	}
	catch( lang::IllegalArgumentException& )
	{
		throw;
	}
	catch( embed::StorageWrappedTargetException& )
	{
		throw;
	}
	catch( io::IOException& )
	{
		throw;
	}
	catch( uno::RuntimeException& )
	{
		throw;
	}
	catch( uno::Exception& )
	{
      	uno::Any aCaught( ::cppu::getCaughtException() );
		throw embed::StorageWrappedTargetException( ::rtl::OUString::createFromAscii( "Can't copy raw stream" ),
												 uno::Reference< io::XInputStream >(),
												 aCaught );
	}

	return xResult;
}

//-----------------------------------------------
uno::Reference< io::XStream > SAL_CALL FSStorage::cloneStreamElement( const ::rtl::OUString& aStreamName )
		throw ( embed::InvalidStorageException,
				lang::IllegalArgumentException,
				packages::WrongPasswordException,
				io::IOException,
				embed::StorageWrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( !GetContent() )
		throw io::IOException(); // TODO: error handling

	// TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
	INetURLObject aFileURL( m_pImpl->m_aURL );
	aFileURL.Append( aStreamName );

	uno::Reference < io::XStream > xTempResult;
	try
	{
		uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
		::ucbhelper::Content aResultContent( aFileURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv );
		uno::Reference< io::XInputStream > xInStream = aResultContent.openStream();

		xTempResult = uno::Reference < io::XStream >(
					m_pImpl->m_xFactory->createInstance ( ::rtl::OUString::createFromAscii( "com.sun.star.io.TempFile" ) ),
					uno::UNO_QUERY_THROW );
		uno::Reference < io::XOutputStream > xTempOut = xTempResult->getOutputStream();
		uno::Reference < io::XInputStream > xTempIn = xTempResult->getInputStream();

		if ( !xTempOut.is() || !xTempIn.is() )
			throw io::IOException();

		::comphelper::OStorageHelper::CopyInputToOutput( xInStream, xTempOut );
		xTempOut->closeOutput();
	}
	catch( embed::InvalidStorageException& )
	{
		throw;
	}
	catch( lang::IllegalArgumentException& )
	{
		throw;
	}
	catch( packages::WrongPasswordException& )
	{
		throw;
	}
	catch( io::IOException& )
	{
		throw;
	}
	catch( embed::StorageWrappedTargetException& )
	{
		throw;
	}
	catch( uno::RuntimeException& )
	{
		throw;
	}
	catch( uno::Exception& )
	{
      	uno::Any aCaught( ::cppu::getCaughtException() );
		throw embed::StorageWrappedTargetException( ::rtl::OUString::createFromAscii( "Can't copy raw stream" ),
												 uno::Reference< io::XInputStream >(),
												 aCaught );
	}

	return xTempResult;
}

//-----------------------------------------------
uno::Reference< io::XStream > SAL_CALL FSStorage::cloneEncryptedStreamElement(
	const ::rtl::OUString&,
	const ::rtl::OUString& )
		throw ( embed::InvalidStorageException,
				lang::IllegalArgumentException,
				packages::NoEncryptionException,
				packages::WrongPasswordException,
				io::IOException,
				embed::StorageWrappedTargetException,
				uno::RuntimeException )
{
	throw packages::NoEncryptionException();
}

//-----------------------------------------------
void SAL_CALL FSStorage::copyLastCommitTo(
			const uno::Reference< embed::XStorage >& xTargetStorage )
		throw ( embed::InvalidStorageException,
				lang::IllegalArgumentException,
				io::IOException,
				embed::StorageWrappedTargetException,
				uno::RuntimeException )
{
	copyToStorage( xTargetStorage );
}

//-----------------------------------------------
void SAL_CALL FSStorage::copyStorageElementLastCommitTo(
			const ::rtl::OUString& aStorName,
			const uno::Reference< embed::XStorage >& xTargetStorage )
		throw ( embed::InvalidStorageException,
				lang::IllegalArgumentException,
				io::IOException,
				embed::StorageWrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	uno::Reference< embed::XStorage > xSourceStor( openStorageElement( aStorName, embed::ElementModes::READ ),
													uno::UNO_QUERY_THROW );
	xSourceStor->copyToStorage( xTargetStorage );
}

//-----------------------------------------------
sal_Bool SAL_CALL FSStorage::isStreamElement( const ::rtl::OUString& aElementName )
		throw ( embed::InvalidStorageException,
				lang::IllegalArgumentException,
				container::NoSuchElementException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( !GetContent() )
		throw embed::InvalidStorageException(); // TODO: error handling

	INetURLObject aURL( m_pImpl->m_aURL );
	aURL.Append( aElementName );

	return !::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
}

//-----------------------------------------------
sal_Bool SAL_CALL FSStorage::isStorageElement( const ::rtl::OUString& aElementName )
		throw ( embed::InvalidStorageException,
				lang::IllegalArgumentException,
				container::NoSuchElementException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( !GetContent() )
		throw embed::InvalidStorageException(); // TODO: error handling

	INetURLObject aURL( m_pImpl->m_aURL );
	aURL.Append( aElementName );

	return ::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
}

//-----------------------------------------------
void SAL_CALL FSStorage::removeElement( const ::rtl::OUString& aElementName )
		throw ( embed::InvalidStorageException,
				lang::IllegalArgumentException,
				container::NoSuchElementException,
				io::IOException,
				embed::StorageWrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( !GetContent() )
		throw io::IOException(); // TODO: error handling

	INetURLObject aURL( m_pImpl->m_aURL );
	aURL.Append( aElementName );

	if ( !::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) )
	  && !::utl::UCBContentHelper::IsDocument( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
		throw container::NoSuchElementException(); // TODO:

	::utl::UCBContentHelper::Kill( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
}

//-----------------------------------------------
void SAL_CALL FSStorage::renameElement( const ::rtl::OUString& aElementName, const ::rtl::OUString& aNewName )
		throw ( embed::InvalidStorageException,
				lang::IllegalArgumentException,
				container::NoSuchElementException,
				container::ElementExistException,
				io::IOException,
				embed::StorageWrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( !GetContent() )
		throw io::IOException(); // TODO: error handling

	INetURLObject aOldURL( m_pImpl->m_aURL );
	aOldURL.Append( aElementName );

	INetURLObject aNewURL( m_pImpl->m_aURL );
	aNewURL.Append( aNewName );

	if ( !::utl::UCBContentHelper::IsFolder( aOldURL.GetMainURL( INetURLObject::NO_DECODE ) )
	  && !::utl::UCBContentHelper::IsDocument( aOldURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
		throw container::NoSuchElementException(); // TODO:

	if ( ::utl::UCBContentHelper::IsFolder( aNewURL.GetMainURL( INetURLObject::NO_DECODE ) )
	  || ::utl::UCBContentHelper::IsDocument( aNewURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
	  	throw container::ElementExistException(); // TODO:

	try
	{
		uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
		::ucbhelper::Content aSourceContent( aOldURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv );

		if ( !GetContent()->transferContent( aSourceContent,
											::ucbhelper::InsertOperation_MOVE,
											aNewName,
											ucb::NameClash::ERROR ) )
			throw io::IOException(); // TODO: error handling
	}
	catch( embed::InvalidStorageException& )
	{
		throw;
	}
	catch( lang::IllegalArgumentException& )
	{
		throw;
	}
	catch( container::NoSuchElementException& )
	{
		throw;
	}
	catch( container::ElementExistException& )
	{
		throw;
	}
	catch( io::IOException& )
	{
		throw;
	}
	catch( embed::StorageWrappedTargetException& )
	{
		throw;
	}
	catch( uno::RuntimeException& )
	{
		throw;
	}
	catch( uno::Exception& )
	{
      	uno::Any aCaught( ::cppu::getCaughtException() );
		throw embed::StorageWrappedTargetException( ::rtl::OUString::createFromAscii( "Can't copy raw stream" ),
												 uno::Reference< io::XInputStream >(),
												 aCaught );
	}
}

//-----------------------------------------------
void SAL_CALL FSStorage::copyElementTo(	const ::rtl::OUString& aElementName,
										const uno::Reference< embed::XStorage >& xDest,
										const ::rtl::OUString& aNewName )
		throw ( embed::InvalidStorageException,
				lang::IllegalArgumentException,
				container::NoSuchElementException,
				container::ElementExistException,
				io::IOException,
				embed::StorageWrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( !xDest.is() )
		throw uno::RuntimeException();

	if ( !GetContent() )
		throw io::IOException(); // TODO: error handling

	INetURLObject aOwnURL( m_pImpl->m_aURL );
	aOwnURL.Append( aElementName );

	if ( xDest->hasByName( aNewName ) )
	  	throw container::ElementExistException(); // TODO:

	try
	{
		uno::Reference< ucb::XCommandEnvironment > xDummyEnv;
		if ( ::utl::UCBContentHelper::IsFolder( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
		{
			::ucbhelper::Content aSourceContent( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv );
			uno::Reference< embed::XStorage > xDestSubStor(
									xDest->openStorageElement( aNewName, embed::ElementModes::READWRITE ),
									uno::UNO_QUERY_THROW );
	
			CopyContentToStorage_Impl( &aSourceContent, xDestSubStor );
		}
		else if ( ::utl::UCBContentHelper::IsDocument( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
		{
			CopyStreamToSubStream( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ), xDest, aNewName );
		}
		else
			throw container::NoSuchElementException(); // TODO:
	}
	catch( embed::InvalidStorageException& )
	{
		throw;
	}
	catch( lang::IllegalArgumentException& )
	{
		throw;
	}
	catch( container::NoSuchElementException& )
	{
		throw;
	}
	catch( container::ElementExistException& )
	{
		throw;
	}
	catch( embed::StorageWrappedTargetException& )
	{
		throw;
	}
	catch( io::IOException& )
	{
		throw;
	}
	catch( uno::RuntimeException& )
	{
		throw;
	}
	catch( uno::Exception& )
	{
      	uno::Any aCaught( ::cppu::getCaughtException() );
		throw embed::StorageWrappedTargetException( ::rtl::OUString::createFromAscii( "Can't copy raw stream" ),
												 uno::Reference< io::XInputStream >(),
												 aCaught );
	}
}

//-----------------------------------------------
void SAL_CALL FSStorage::moveElementTo(	const ::rtl::OUString& aElementName,
										const uno::Reference< embed::XStorage >& xDest,
										const ::rtl::OUString& aNewName )
		throw ( embed::InvalidStorageException,
				lang::IllegalArgumentException,
				container::NoSuchElementException,
				container::ElementExistException,
				io::IOException,
				embed::StorageWrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );
	copyElementTo( aElementName, xDest, aNewName );

	INetURLObject aOwnURL( m_pImpl->m_aURL );
	aOwnURL.Append( aElementName );
	if ( !::utl::UCBContentHelper::Kill( aOwnURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
		throw io::IOException(); // TODO: error handling
}

//____________________________________________________________________________________________________
//	XNameAccess
//____________________________________________________________________________________________________

//-----------------------------------------------
uno::Any SAL_CALL FSStorage::getByName( const ::rtl::OUString& aName )
		throw ( container::NoSuchElementException,
				lang::WrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( !GetContent() )
		throw io::IOException(); // TODO: error handling

	if ( !aName.getLength() )
		throw lang::IllegalArgumentException();

	INetURLObject aURL( m_pImpl->m_aURL );
	aURL.Append( aName );

	uno::Any aResult;
	try
	{
		if ( ::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
		{
			aResult <<= openStorageElement( aName, embed::ElementModes::READ );
		}
		else if ( ::utl::UCBContentHelper::IsDocument( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
		{
			aResult <<= openStreamElement( aName, embed::ElementModes::READ );
		}
		else
			throw container::NoSuchElementException(); // TODO:
	}
	catch( container::NoSuchElementException& )
	{
		throw;
	}
	catch( lang::WrappedTargetException& )
	{
		throw;
	}
	catch( uno::RuntimeException& )
	{
		throw;
	}
	catch ( uno::Exception& )
	{
   		uno::Any aCaught( ::cppu::getCaughtException() );
		throw lang::WrappedTargetException( ::rtl::OUString::createFromAscii( "Can not open element!\n" ),
											uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
																				uno::UNO_QUERY ),
											aCaught );
	}

	return aResult;
}


//-----------------------------------------------
uno::Sequence< ::rtl::OUString > SAL_CALL FSStorage::getElementNames()
		throw ( uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( !GetContent() )
		throw io::IOException(); // TODO: error handling

	uno::Sequence< ::rtl::OUString > aProps( 1 );
	::rtl::OUString* pProps = aProps.getArray();
	pProps[0] = ::rtl::OUString::createFromAscii( "Title" );
	::ucbhelper::ResultSetInclude eInclude = ::ucbhelper::INCLUDE_FOLDERS_AND_DOCUMENTS;

	uno::Sequence< ::rtl::OUString > aResult;
	sal_Int32 nSize = 0;

	try
	{
		uno::Reference< sdbc::XResultSet > xResultSet = GetContent()->createCursor( aProps, eInclude );
		uno::Reference< ucb::XContentAccess > xContentAccess( xResultSet, uno::UNO_QUERY );
		uno::Reference< sdbc::XRow > xRow( xResultSet, uno::UNO_QUERY );
		if ( xResultSet.is() )
		{
			// go through the list
			while ( xResultSet->next() )
			{
				::rtl::OUString aName( xRow->getString( 1 ) );
				aResult.realloc( ++nSize );
				aResult[nSize-1] = aName;
			}
		}
	}
	catch( ucb::InteractiveIOException& r )
    {
        if ( r.Code == ucb::IOErrorCode_NOT_EXISTING )
			OSL_ENSURE( sal_False, "The folder does not exist!\n" );
		else
		{
	   		uno::Any aCaught( ::cppu::getCaughtException() );
			throw lang::WrappedTargetRuntimeException( ::rtl::OUString::createFromAscii( "Can not open storage!\n" ),
											uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
																				uno::UNO_QUERY ),
											aCaught );
		}
    }
	catch( uno::RuntimeException& )
	{
		throw;
	}
	catch ( uno::Exception& )
	{
   		uno::Any aCaught( ::cppu::getCaughtException() );
		throw lang::WrappedTargetRuntimeException( ::rtl::OUString::createFromAscii( "Can not open storage!\n" ),
											uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
																				uno::UNO_QUERY ),
											aCaught );
	}

	return aResult;
}


//-----------------------------------------------
sal_Bool SAL_CALL FSStorage::hasByName( const ::rtl::OUString& aName )
		throw ( uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	try
	{
		if ( !GetContent() )
			throw io::IOException(); // TODO: error handling

		if ( !aName.getLength() )
			throw lang::IllegalArgumentException();
	}
	catch( uno::RuntimeException& )
	{
		throw;
	}
	catch ( uno::Exception& )
	{
   		uno::Any aCaught( ::cppu::getCaughtException() );
		throw lang::WrappedTargetRuntimeException( ::rtl::OUString::createFromAscii( "Can not open storage!\n" ),
											uno::Reference< uno::XInterface >(  static_cast< OWeakObject* >( this ),
																				uno::UNO_QUERY ),
											aCaught );
	}

	INetURLObject aURL( m_pImpl->m_aURL );
	aURL.Append( aName );

	return ( ::utl::UCBContentHelper::IsFolder( aURL.GetMainURL( INetURLObject::NO_DECODE ) )
	  || ::utl::UCBContentHelper::IsDocument( aURL.GetMainURL( INetURLObject::NO_DECODE ) ) );
}

//-----------------------------------------------
uno::Type SAL_CALL FSStorage::getElementType()
		throw ( uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	// it is a multitype container
	return uno::Type();
}

//-----------------------------------------------
sal_Bool SAL_CALL FSStorage::hasElements()
		throw ( uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( !GetContent() )
		throw io::IOException(); // TODO: error handling
	
	uno::Sequence< ::rtl::OUString > aProps( 1 );
	aProps[0] = ::rtl::OUString::createFromAscii( "TargetURL" );
	::ucbhelper::ResultSetInclude eInclude = ::ucbhelper::INCLUDE_FOLDERS_AND_DOCUMENTS;

	try
	{
		uno::Reference< sdbc::XResultSet > xResultSet = GetContent()->createCursor( aProps, eInclude );
		return ( xResultSet.is() && xResultSet->next() );
	}
	catch( uno::Exception& )
	{
		throw uno::RuntimeException();
	}
}


//____________________________________________________________________________________________________
//	XDisposable
//____________________________________________________________________________________________________

//-----------------------------------------------
void SAL_CALL FSStorage::dispose()
		throw ( uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( m_pImpl->m_pListenersContainer )
	{
   		lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >(this) );
		m_pImpl->m_pListenersContainer->disposeAndClear( aSource );
	}

	delete m_pImpl;
	m_pImpl = NULL;
}

//-----------------------------------------------
void SAL_CALL FSStorage::addEventListener(
			const uno::Reference< lang::XEventListener >& xListener )
		throw ( uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( !m_pImpl->m_pListenersContainer )
		m_pImpl->m_pListenersContainer = new ::cppu::OInterfaceContainerHelper( m_aMutex );

	m_pImpl->m_pListenersContainer->addInterface( xListener );
}

//-----------------------------------------------
void SAL_CALL FSStorage::removeEventListener(
			const uno::Reference< lang::XEventListener >& xListener )
		throw ( uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( m_pImpl->m_pListenersContainer )
		m_pImpl->m_pListenersContainer->removeInterface( xListener );
}

//____________________________________________________________________________________________________
//	XPropertySet
//____________________________________________________________________________________________________

//-----------------------------------------------
uno::Reference< beans::XPropertySetInfo > SAL_CALL FSStorage::getPropertySetInfo()
		throw ( uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	//TODO:
	return uno::Reference< beans::XPropertySetInfo >();
}


//-----------------------------------------------
void SAL_CALL FSStorage::setPropertyValue( const ::rtl::OUString& aPropertyName, const uno::Any& )
		throw ( beans::UnknownPropertyException,
				beans::PropertyVetoException,
				lang::IllegalArgumentException,
				lang::WrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( aPropertyName.equalsAscii( "URL" ) || aPropertyName.equalsAscii( "OpenMode" ) )
		throw beans::PropertyVetoException(); // TODO
	else
		throw beans::UnknownPropertyException(); // TODO
}


//-----------------------------------------------
uno::Any SAL_CALL FSStorage::getPropertyValue( const ::rtl::OUString& aPropertyName )
		throw ( beans::UnknownPropertyException,
				lang::WrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( aPropertyName.equalsAscii( "URL" ) )
		return uno::makeAny( m_pImpl->m_aURL );
	else if ( aPropertyName.equalsAscii( "OpenMode" ) )
		return uno::makeAny( m_pImpl->m_nMode );

	throw beans::UnknownPropertyException(); // TODO
}


//-----------------------------------------------
void SAL_CALL FSStorage::addPropertyChangeListener(
			const ::rtl::OUString& /*aPropertyName*/,
			const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/ )
		throw ( beans::UnknownPropertyException,
				lang::WrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	//TODO:
}


//-----------------------------------------------
void SAL_CALL FSStorage::removePropertyChangeListener(
			const ::rtl::OUString& /*aPropertyName*/,
			const uno::Reference< beans::XPropertyChangeListener >& /*aListener*/ )
		throw ( beans::UnknownPropertyException,
				lang::WrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	//TODO:
}


//-----------------------------------------------
void SAL_CALL FSStorage::addVetoableChangeListener(
			const ::rtl::OUString& /*PropertyName*/,
			const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
		throw ( beans::UnknownPropertyException,
				lang::WrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	//TODO:
}


//-----------------------------------------------
void SAL_CALL FSStorage::removeVetoableChangeListener(
			const ::rtl::OUString& /*PropertyName*/,
			const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
		throw ( beans::UnknownPropertyException,
				lang::WrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	//TODO:
}

//____________________________________________________________________________________________________
//	XHierarchicalStorageAccess
//____________________________________________________________________________________________________
//-----------------------------------------------
uno::Reference< embed::XExtendedStorageStream > SAL_CALL FSStorage::openStreamElementByHierarchicalName( const ::rtl::OUString& sStreamPath, ::sal_Int32 nOpenMode )
		throw ( embed::InvalidStorageException,
				lang::IllegalArgumentException,
				packages::WrongPasswordException,
				io::IOException,
				embed::StorageWrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( sStreamPath.toChar() == '/' )
		throw lang::IllegalArgumentException();

	if ( !GetContent() )
		throw io::IOException(); // TODO: error handling

	INetURLObject aBaseURL( m_pImpl->m_aURL );
	if ( !aBaseURL.setFinalSlash() )
		throw uno::RuntimeException();

	INetURLObject aFileURL = INetURLObject::GetAbsURL(
				aBaseURL.GetMainURL( INetURLObject::NO_DECODE ),
				sStreamPath );

	if ( ::utl::UCBContentHelper::IsFolder( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
		throw io::IOException();

	if ( ( nOpenMode & embed::ElementModes::NOCREATE )
	  && !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
		throw io::IOException(); // TODO:

	uno::Reference< ucb::XCommandEnvironment > xDummyEnv; // TODO: provide InteractionHandler if any
	uno::Reference< io::XStream > xResult;
	try
	{
		if ( nOpenMode & embed::ElementModes::WRITE )
		{
			if ( isLocalFile_Impl( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
			{
				uno::Reference< ucb::XSimpleFileAccess > xSimpleFileAccess(
					m_pImpl->m_xFactory->createInstance( 
						::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.ucb.SimpleFileAccess" ) ) ),
					uno::UNO_QUERY_THROW );
				uno::Reference< io::XStream > xStream =
					xSimpleFileAccess->openFileReadWrite( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) );

				xResult = static_cast< io::XStream* >( new OFSStreamContainer( xStream ) );
			}
			else
			{
				// TODO: test whether it really works for http and fwp
				SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( aFileURL.GetMainURL( INetURLObject::NO_DECODE ),
																	  	STREAM_STD_WRITE );
				if ( pStream )
				{
					if ( !pStream->GetError() )
					{
						uno::Reference< io::XStream > xStream =
							uno::Reference < io::XStream >( new ::utl::OStreamWrapper( *pStream ) );
						xResult = static_cast< io::XStream* >( new OFSStreamContainer( xStream ) );
					}
					else
						delete pStream;
				}
			}
	
			if ( !xResult.is() )
				throw io::IOException();
	
			if ( ( nOpenMode & embed::ElementModes::TRUNCATE ) )
			{
				uno::Reference< io::XTruncate > xTrunc( xResult->getOutputStream(), uno::UNO_QUERY_THROW );
				xTrunc->truncate();
			}
		}
		else
		{
			if ( ( nOpenMode & embed::ElementModes::TRUNCATE )
		  	|| !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
				throw io::IOException(); // TODO: access denied
	
			::ucbhelper::Content aResultContent( aFileURL.GetMainURL( INetURLObject::NO_DECODE ), xDummyEnv );
			uno::Reference< io::XInputStream > xInStream = aResultContent.openStream();
			xResult = static_cast< io::XStream* >( new OFSInputStreamContainer( xInStream ) );
		}
	}
	catch( embed::InvalidStorageException& )
	{
		throw;
	}
	catch( lang::IllegalArgumentException& )
	{
		throw;
	}
	catch( packages::WrongPasswordException& )
	{
		throw;
	}
	catch( embed::StorageWrappedTargetException& )
	{
		throw;
	}
	catch( io::IOException& )
	{
		throw;
	}
	catch( uno::RuntimeException& )
	{
		throw;
	}
	catch( uno::Exception& )
	{
      	uno::Any aCaught( ::cppu::getCaughtException() );
		throw embed::StorageWrappedTargetException( ::rtl::OUString::createFromAscii( "Can't copy raw stream" ),
												 uno::Reference< io::XInputStream >(),
												 aCaught );
	}

	return uno::Reference< embed::XExtendedStorageStream >( xResult, uno::UNO_QUERY_THROW );
}

//-----------------------------------------------
uno::Reference< embed::XExtendedStorageStream > SAL_CALL FSStorage::openEncryptedStreamElementByHierarchicalName( const ::rtl::OUString& /*sStreamName*/, ::sal_Int32 /*nOpenMode*/, const ::rtl::OUString& /*sPassword*/ )
		throw ( embed::InvalidStorageException,
				lang::IllegalArgumentException,
				packages::NoEncryptionException,
				packages::WrongPasswordException,
				io::IOException,
				embed::StorageWrappedTargetException,
				uno::RuntimeException )
{
	throw packages::NoEncryptionException();
}

//-----------------------------------------------
void SAL_CALL FSStorage::removeStreamElementByHierarchicalName( const ::rtl::OUString& sStreamPath )
		throw ( embed::InvalidStorageException,
				lang::IllegalArgumentException,
				container::NoSuchElementException,
				io::IOException,
				embed::StorageWrappedTargetException,
				uno::RuntimeException )
{
	::osl::MutexGuard aGuard( m_aMutex );

	if ( !m_pImpl )
		throw lang::DisposedException();

	if ( !GetContent() )
		throw io::IOException(); // TODO: error handling

	// TODO/LATER: may need possibility to create folder if it was removed, since the folder can not be locked
	INetURLObject aBaseURL( m_pImpl->m_aURL );
	if ( !aBaseURL.setFinalSlash() )
		throw uno::RuntimeException();

	INetURLObject aFileURL = INetURLObject::GetAbsURL(
				aBaseURL.GetMainURL( INetURLObject::NO_DECODE ),
				sStreamPath );

	if ( !::utl::UCBContentHelper::IsDocument( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
	{
		if ( ::utl::UCBContentHelper::IsFolder( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
			throw lang::IllegalArgumentException();
		else
			throw container::NoSuchElementException(); // TODO:
	}

	if ( !::utl::UCBContentHelper::Kill( aFileURL.GetMainURL( INetURLObject::NO_DECODE ) ) )
		throw io::IOException(); // TODO: error handling
}