Quelle  switchpersistencestream.cxx   Sprache: C

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   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 .
 */

#include <osl/diagnose.h>
#include <com/sun/star/io/IOException.hpp>
#include <com/sun/star/io/NotConnectedException.hpp>
#include <com/sun/star/io/TempFile.hpp>
#include <comphelper/storagehelper.hxx>
#include <unotools/tempfile.hxx>
#include <utility>
#include "switchpersistencestream.hxx"

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

struct SPStreamData_Impl
{
    bool m_bInStreamBased;

    // the streams below are not visible from outside so there is no need to remember position

    // original stream related members
    uno::Reference< io::XTruncate > m_xOrigTruncate;
    uno::Reference< io::XSeekable > m_xOrigSeekable;
    uno::Reference< io::XInputStream > m_xOrigInStream;
    uno::Reference< io::XOutputStream > m_xOrigOutStream;
    comphelper::ByteReader* m_pByteReader;

    bool m_bInOpen;
    bool m_bOutOpen;

    SPStreamData_Impl(
            bool bInStreamBased,
            uno::Reference< io::XTruncate > xOrigTruncate,
            uno::Reference< io::XSeekable > xOrigSeekable,
            uno::Reference< io::XInputStream > xOrigInStream,
            uno::Reference< io::XOutputStream > xOrigOutStream,
            bool bInOpen,
            bool bOutOpen )
    : m_bInStreamBased( bInStreamBased )
    , m_xOrigTruncate(std::move( xOrigTruncate ))
    , m_xOrigSeekable(std::move( xOrigSeekable ))
    , m_xOrigInStream(std::move( xOrigInStream ))
    , m_xOrigOutStream(std::move( xOrigOutStream ))
    , m_pByteReader(dynamic_cast<comphelper::ByteReader*>(m_xOrigInStream.get()))
    , m_bInOpen( bInOpen )
    , m_bOutOpen( bOutOpen )
    {
    }
};

SwitchablePersistenceStream::SwitchablePersistenceStream(
        const uno::Reference< io::XStream >& xStream )
{
    SwitchPersistenceTo( xStream );
}

SwitchablePersistenceStream::SwitchablePersistenceStream(
        const uno::Reference< io::XInputStream >& xInputStream )
{
    SwitchPersistenceTo( xInputStream );
}

SwitchablePersistenceStream::~SwitchablePersistenceStream()
{
    CloseAll_Impl();
}

void SwitchablePersistenceStream::SwitchPersistenceTo( const uno::Reference< io::XStream >& xStream )
{
    uno::Reference< io::XTruncate > xNewTruncate( xStream, uno::UNO_QUERY_THROW );
    uno::Reference< io::XSeekable > xNewSeekable( xStream, uno::UNO_QUERY_THROW );
    uno::Reference< io::XInputStream > xNewInStream = xStream->getInputStream();
    uno::Reference< io::XOutputStream > xNewOutStream = xStream->getOutputStream();
    if ( !xNewInStream.is() || !xNewOutStream.is() )
        throw uno::RuntimeException();

    sal_Int64 nPos = 0;
    bool bInOpen = false;
    bool bOutOpen = false;

    if ( m_pStreamData && m_pStreamData->m_xOrigSeekable.is() )
    {
        // check that the length is the same
        if ( m_pStreamData->m_xOrigSeekable->getLength() != xNewSeekable->getLength() )
            throw uno::RuntimeException();

        // get the current position
        nPos = m_pStreamData->m_xOrigSeekable->getPosition();
        bInOpen = m_pStreamData->m_bInOpen;
        bOutOpen = m_pStreamData->m_bOutOpen;
    }

    xNewSeekable->seek( nPos );

    CloseAll_Impl();

    m_pStreamData.reset( new SPStreamData_Impl( false,
                                            xNewTruncate, xNewSeekable, xNewInStream, xNewOutStream,
                                            bInOpen, bOutOpen ) );
}

void SwitchablePersistenceStream::SwitchPersistenceTo( const uno::Reference< io::XInputStream >& xInputStream )
{
    uno::Reference< io::XTruncate > xNewTruncate;
    uno::Reference< io::XSeekable > xNewSeekable( xInputStream, uno::UNO_QUERY_THROW );
    uno::Reference< io::XOutputStream > xNewOutStream;
    if ( !xInputStream.is() )
        throw uno::RuntimeException();

    sal_Int64 nPos = 0;
    bool bInOpen = false;
    bool bOutOpen = false;

    if ( m_pStreamData && m_pStreamData->m_xOrigSeekable.is() )
    {
        // check that the length is the same
        if ( m_pStreamData->m_xOrigSeekable->getLength() != xNewSeekable->getLength() )
            throw uno::RuntimeException();

        // get the current position
        nPos = m_pStreamData->m_xOrigSeekable->getPosition();
        bInOpen = m_pStreamData->m_bInOpen;
        bOutOpen = m_pStreamData->m_bOutOpen;
    }

    xNewSeekable->seek( nPos );

    CloseAll_Impl();

    m_pStreamData.reset( new SPStreamData_Impl( true,
                                            xNewTruncate, xNewSeekable, xInputStream, xNewOutStream,
                                            bInOpen, bOutOpen ) );

}

void SwitchablePersistenceStream::CopyAndSwitchPersistenceTo( const uno::Reference< io::XStream >& xStream )
{
    uno::Reference< io::XStream > xTargetStream = xStream;
    uno::Reference< io::XSeekable > xTargetSeek;

    if ( !xTargetStream.is() )
    {
        xTargetStream.set( new utl::TempFileFastService );
        xTargetSeek.set( xTargetStream, uno::UNO_QUERY_THROW );
    }
    else
    {
        // the provided stream must be empty
        xTargetSeek.set( xTargetStream, uno::UNO_QUERY_THROW );
        if ( xTargetSeek->getLength() )
            throw io::IOException(u"provided stream not empty"_ustr);
    }

    uno::Reference< io::XTruncate > xTargetTruncate( xTargetStream, uno::UNO_QUERY_THROW );
    uno::Reference< io::XInputStream > xTargetInStream = xTargetStream->getInputStream();
    uno::Reference< io::XOutputStream > xTargetOutStream = xTargetStream->getOutputStream();
    if ( !xTargetInStream.is() || !xTargetOutStream.is() )
        throw uno::RuntimeException();

    if ( !m_pStreamData->m_xOrigInStream.is() || !m_pStreamData->m_xOrigSeekable.is() )
        throw uno::RuntimeException();

    sal_Int64 nPos = m_pStreamData->m_xOrigSeekable->getPosition();
    m_pStreamData->m_xOrigSeekable->seek( 0 );
    ::comphelper::OStorageHelper::CopyInputToOutput( m_pStreamData->m_xOrigInStream, xTargetOutStream );
    xTargetOutStream->flush();
    xTargetSeek->seek( nPos );

    bool bInOpen = m_pStreamData->m_bInOpen;
    bool bOutOpen = m_pStreamData->m_bOutOpen;

    CloseAll_Impl();

    m_pStreamData.reset( new SPStreamData_Impl( false,
                                        xTargetTruncate, xTargetSeek, xTargetInStream, xTargetOutStream,
                                        bInOpen, bOutOpen ) );
}

void SwitchablePersistenceStream::CloseAll_Impl()
{
    m_pStreamData.reset();
}

// css::io::XStream
uno::Reference< io::XInputStream > SAL_CALL SwitchablePersistenceStream::getInputStream(  )
{
    std::scoped_lock aGuard( m_aMutex );

    if ( m_pStreamData )
        m_pStreamData->m_bInOpen = true;
    return static_cast< io::XInputStream* >( this );
}

uno::Reference< io::XOutputStream > SAL_CALL SwitchablePersistenceStream::getOutputStream(  )
{
    std::scoped_lock aGuard( m_aMutex );

    if ( m_pStreamData )
        m_pStreamData->m_bOutOpen = true;
    return static_cast< io::XOutputStream* >( this );
}

// css::io::XInputStream
::sal_Int32 SAL_CALL SwitchablePersistenceStream::readBytes( uno::Sequence< ::sal_Int8 >& aData, ::sal_Int32 nBytesToRead )
{
    std::scoped_lock aGuard( m_aMutex );

    if ( !m_pStreamData )
        throw io::NotConnectedException();

    // the original stream data should be provided
    if ( !m_pStreamData->m_xOrigInStream.is() )
        throw uno::RuntimeException();

    return m_pStreamData->m_xOrigInStream->readBytes( aData, nBytesToRead );
}

::sal_Int32 SAL_CALL SwitchablePersistenceStream::readSomeBytes( uno::Sequence< ::sal_Int8 >& aData, ::sal_Int32 nMaxBytesToRead )
{
    std::scoped_lock aGuard( m_aMutex );

    if ( !m_pStreamData )
        throw io::NotConnectedException();

    // the original stream data should be provided
    if ( !m_pStreamData->m_xOrigInStream.is() )
        throw uno::RuntimeException();

    return m_pStreamData->m_xOrigInStream->readBytes( aData, nMaxBytesToRead );
}

::sal_Int32 SwitchablePersistenceStream::readSomeBytes( sal_Int8* aData, sal_Int32 nBytesToRead)
{
    std::scoped_lock aGuard( m_aMutex );

    if ( !m_pStreamData )
        throw io::NotConnectedException();

    // the original stream data should be provided
    if ( !m_pStreamData->m_xOrigInStream.is() )
        throw uno::RuntimeException();

    if (m_pStreamData->m_pByteReader)
        return m_pStreamData->m_pByteReader->readSomeBytes( aData, nBytesToRead );
    else
    {
        css::uno::Sequence < sal_Int8 > aSequence;
        sal_Int32 nBytesActuallyRead = m_pStreamData->m_xOrigInStream->readSomeBytes( aSequence, nBytesToRead );
        memcpy(aData, aSequence.getConstArray(), nBytesActuallyRead);
        return nBytesActuallyRead;
    }
}

void SAL_CALL SwitchablePersistenceStream::skipBytes( ::sal_Int32 nBytesToSkip )
{
    std::scoped_lock aGuard( m_aMutex );

    if ( !m_pStreamData )
        throw io::NotConnectedException();

    // the original stream data should be provided
    if ( !m_pStreamData->m_xOrigInStream.is() )
        throw uno::RuntimeException();

    m_pStreamData->m_xOrigInStream->skipBytes( nBytesToSkip );
}

::sal_Int32 SAL_CALL SwitchablePersistenceStream::available(  )
{
    std::scoped_lock aGuard( m_aMutex );

    if ( !m_pStreamData )
        throw io::NotConnectedException();

    // the original stream data should be provided
    if ( !m_pStreamData->m_xOrigInStream.is() )
        throw uno::RuntimeException();

    return m_pStreamData->m_xOrigInStream->available();
}

void SAL_CALL SwitchablePersistenceStream::closeInput()
{
    std::scoped_lock aGuard( m_aMutex );

    if ( !m_pStreamData )
        throw io::NotConnectedException();

    m_pStreamData->m_bInOpen = false;
    if ( !m_pStreamData->m_bOutOpen )
        CloseAll_Impl();
}

// css::io::XOutputStream
void SAL_CALL SwitchablePersistenceStream::writeBytes( const uno::Sequence< ::sal_Int8 >&&nbsp;aData )
{
    std::scoped_lock aGuard( m_aMutex );

    if ( !m_pStreamData )
        throw io::NotConnectedException();

    if ( m_pStreamData->m_bInStreamBased )
        throw io::IOException();

    // the original stream data should be provided
    if ( !m_pStreamData->m_xOrigOutStream.is() )
        throw uno::RuntimeException();

    m_pStreamData->m_xOrigOutStream->writeBytes( aData );
}

void SAL_CALL SwitchablePersistenceStream::flush(  )
{
    std::scoped_lock aGuard( m_aMutex );

    if ( !m_pStreamData || m_pStreamData->m_bInStreamBased )
    {
        OSL_FAIL( "flush() is not acceptable!" );
        return;
        // in future throw exception, for now some code might call flush() on closed stream
        // since file ucp implementation allows it
        // throw io::NotConnectedException();
    }

    // the original stream data should be provided
    if ( !m_pStreamData->m_xOrigOutStream.is() )
        throw uno::RuntimeException();

    m_pStreamData->m_xOrigOutStream->flush();
}

void SAL_CALL SwitchablePersistenceStream::closeOutput(  )
{
    std::scoped_lock aGuard( m_aMutex );

    if ( !m_pStreamData )
        throw io::NotConnectedException();

    m_pStreamData->m_bOutOpen = false;
    if ( !m_pStreamData->m_bInOpen )
        CloseAll_Impl();
}

// css::io::XTruncate
void SAL_CALL SwitchablePersistenceStream::truncate(  )
{
    std::scoped_lock aGuard( m_aMutex );

    if ( !m_pStreamData )
        throw io::NotConnectedException();

    if ( m_pStreamData->m_bInStreamBased )
        throw io::IOException();

    // the original stream data should be provided
    if ( !m_pStreamData->m_xOrigTruncate.is() )
        throw uno::RuntimeException();

    m_pStreamData->m_xOrigTruncate->truncate();
}

// css::io::XSeekable
void SAL_CALL SwitchablePersistenceStream::seek( ::sal_Int64 location )
{
    std::scoped_lock aGuard( m_aMutex );

    if ( !m_pStreamData )
        throw io::NotConnectedException();

    // the original stream data should be provided
    if ( !m_pStreamData->m_xOrigSeekable.is() )
        throw uno::RuntimeException();

    m_pStreamData->m_xOrigSeekable->seek( location );
}

::sal_Int64 SAL_CALL SwitchablePersistenceStream::getPosition(  )
{
    std::scoped_lock aGuard( m_aMutex );

    if ( !m_pStreamData )
        throw io::NotConnectedException();

    // the original stream data should be provided
    if ( !m_pStreamData->m_xOrigSeekable.is() )
        throw uno::RuntimeException();

    return m_pStreamData->m_xOrigSeekable->getPosition();
}

::sal_Int64 SAL_CALL SwitchablePersistenceStream::getLength(  )
{
    std::scoped_lock aGuard( m_aMutex );

    if ( !m_pStreamData )
        throw io::NotConnectedException();

    // the original stream data should be provided
    if ( !m_pStreamData->m_xOrigSeekable.is() )
        throw uno::RuntimeException();

    return m_pStreamData->m_xOrigSeekable->getLength();
}

void SAL_CALL SwitchablePersistenceStream::waitForCompletion()
{
    if ( !m_pStreamData )
        throw io::NotConnectedException();

    uno::Reference< io::XAsyncOutputMonitor > asyncOutputMonitor( m_pStreamData->m_xOrigOutStream, uno::UNO_QUERY );
    if ( asyncOutputMonitor.is() )
        asyncOutputMonitor->waitForCompletion();
}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */