package/source/xstor/switchpersistencestream.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <osl/diagnose.h>
  21 #include <com/sun/star/io/IOException.hpp>
  22 #include <com/sun/star/io/NotConnectedException.hpp>
  23 #include <com/sun/star/io/TempFile.hpp>
  24 #include <comphelper/storagehelper.hxx>
  25 #include <unotools/tempfile.hxx>
  26 #include <utility>
  27 #include "switchpersistencestream.hxx"
  28
  29 using namespace ::com::sun::star;
  30
  31 struct SPStreamData_Impl
  32 {
  33     bool m_bInStreamBased;
  34
  35     // the streams below are not visible from outside so there is no need to remember position
  36
  37     // original stream related members
  38     uno::Reference< io::XTruncate > m_xOrigTruncate;
  39     uno::Reference< io::XSeekable > m_xOrigSeekable;
  40     uno::Reference< io::XInputStream > m_xOrigInStream;
  41     uno::Reference< io::XOutputStream > m_xOrigOutStream;
  42     comphelper::ByteReader* m_pByteReader;
  43
  44     bool m_bInOpen;
  45     bool m_bOutOpen;
  46
  47     SPStreamData_Impl(
  48             bool bInStreamBased,
  49             uno::Reference< io::XTruncate > xOrigTruncate,
  50             uno::Reference< io::XSeekable > xOrigSeekable,
  51             uno::Reference< io::XInputStream > xOrigInStream,
  52             uno::Reference< io::XOutputStream > xOrigOutStream,
  53             bool bInOpen,
  54             bool bOutOpen )
  55     : m_bInStreamBased( bInStreamBased )
  56     , m_xOrigTruncate(std::move( xOrigTruncate ))
  57     , m_xOrigSeekable(std::move( xOrigSeekable ))
  58     , m_xOrigInStream(std::move( xOrigInStream ))
  59     , m_xOrigOutStream(std::move( xOrigOutStream ))
  60     , m_pByteReader(dynamic_cast<comphelper::ByteReader*>(m_xOrigInStream.get()))
  61     , m_bInOpen( bInOpen )
  62     , m_bOutOpen( bOutOpen )
  63     {
  64     }
  65 };
  66
  67 SwitchablePersistenceStream::SwitchablePersistenceStream(
  68         const uno::Reference< io::XStream >& xStream )
  69 {
  70     SwitchPersistenceTo( xStream );
  71 }
  72
  73 SwitchablePersistenceStream::SwitchablePersistenceStream(
  74         const uno::Reference< io::XInputStream >& xInputStream )
  75 {
  76     SwitchPersistenceTo( xInputStream );
  77 }
  78
  79 SwitchablePersistenceStream::~SwitchablePersistenceStream()
  80 {
  81     CloseAll_Impl();
  82 }
  83
  84 void SwitchablePersistenceStream::SwitchPersistenceTo( const uno::Reference< io::XStream >& xStream )
  85 {
  86     uno::Reference< io::XTruncate > xNewTruncate( xStream, uno::UNO_QUERY_THROW );
  87     uno::Reference< io::XSeekable > xNewSeekable( xStream, uno::UNO_QUERY_THROW );
  88     uno::Reference< io::XInputStream > xNewInStream = xStream->getInputStream();
  89     uno::Reference< io::XOutputStream > xNewOutStream = xStream->getOutputStream();
  90     if ( !xNewInStream.is() || !xNewOutStream.is() )
  91         throw uno::RuntimeException();
  92
  93     sal_Int64 nPos = 0;
  94     bool bInOpen = false;
  95     bool bOutOpen = false;
  96
  97     if ( m_pStreamData && m_pStreamData->m_xOrigSeekable.is() )
  98     {
  99         // check that the length is the same
 100         if ( m_pStreamData->m_xOrigSeekable->getLength() != xNewSeekable->getLength() )
 101             throw uno::RuntimeException();
 102
 103         // get the current position
 104         nPos = m_pStreamData->m_xOrigSeekable->getPosition();
 105         bInOpen = m_pStreamData->m_bInOpen;
 106         bOutOpen = m_pStreamData->m_bOutOpen;
 107     }
 108
 109     xNewSeekable->seek( nPos );
 110
 111     CloseAll_Impl();
 112
 113     m_pStreamData.reset( new SPStreamData_Impl( false,
 114                                             xNewTruncate, xNewSeekable, xNewInStream, xNewOutStream,
 115                                             bInOpen, bOutOpen ) );
 116 }
 117
 118 void SwitchablePersistenceStream::SwitchPersistenceTo( const uno::Reference< io::XInputStream >& xInputStream )
 119 {
 120     uno::Reference< io::XTruncate > xNewTruncate;
 121     uno::Reference< io::XSeekable > xNewSeekable( xInputStream, uno::UNO_QUERY_THROW );
 122     uno::Reference< io::XOutputStream > xNewOutStream;
 123     if ( !xInputStream.is() )
 124         throw uno::RuntimeException();
 125
 126     sal_Int64 nPos = 0;
 127     bool bInOpen = false;
 128     bool bOutOpen = false;
 129
 130     if ( m_pStreamData && m_pStreamData->m_xOrigSeekable.is() )
 131     {
 132         // check that the length is the same
 133         if ( m_pStreamData->m_xOrigSeekable->getLength() != xNewSeekable->getLength() )
 134             throw uno::RuntimeException();
 135
 136         // get the current position
 137         nPos = m_pStreamData->m_xOrigSeekable->getPosition();
 138         bInOpen = m_pStreamData->m_bInOpen;
 139         bOutOpen = m_pStreamData->m_bOutOpen;
 140     }
 141
 142     xNewSeekable->seek( nPos );
 143
 144     CloseAll_Impl();
 145
 146     m_pStreamData.reset( new SPStreamData_Impl( true,
 147                                             xNewTruncate, xNewSeekable, xInputStream, xNewOutStream,
 148                                             bInOpen, bOutOpen ) );
 149
 150 }
 151
 152 void SwitchablePersistenceStream::CopyAndSwitchPersistenceTo( const uno::Reference< io::XStream >& xStream )
 153 {
 154     uno::Reference< io::XStream > xTargetStream = xStream;
 155     uno::Reference< io::XSeekable > xTargetSeek;
 156
 157     if ( !xTargetStream.is() )
 158     {
 159         xTargetStream.set( new utl::TempFileFastService );
 160         xTargetSeek.set( xTargetStream, uno::UNO_QUERY_THROW );
 161     }
 162     else
 163     {
 164         // the provided stream must be empty
 165         xTargetSeek.set( xTargetStream, uno::UNO_QUERY_THROW );
 166         if ( xTargetSeek->getLength() )
 167             throw io::IOException(u"provided stream not empty"_ustr);
 168     }
 169
 170     uno::Reference< io::XTruncate > xTargetTruncate( xTargetStream, uno::UNO_QUERY_THROW );
 171     uno::Reference< io::XInputStream > xTargetInStream = xTargetStream->getInputStream();
 172     uno::Reference< io::XOutputStream > xTargetOutStream = xTargetStream->getOutputStream();
 173     if ( !xTargetInStream.is() || !xTargetOutStream.is() )
 174         throw uno::RuntimeException();
 175
 176     if ( !m_pStreamData->m_xOrigInStream.is() || !m_pStreamData->m_xOrigSeekable.is() )
 177         throw uno::RuntimeException();
 178
 179     sal_Int64 nPos = m_pStreamData->m_xOrigSeekable->getPosition();
 180     m_pStreamData->m_xOrigSeekable->seek( 0 );
 181     ::comphelper::OStorageHelper::CopyInputToOutput( m_pStreamData->m_xOrigInStream, xTargetOutStream );
 182     xTargetOutStream->flush();
 183     xTargetSeek->seek( nPos );
 184
 185     bool bInOpen = m_pStreamData->m_bInOpen;
 186     bool bOutOpen = m_pStreamData->m_bOutOpen;
 187
 188     CloseAll_Impl();
 189
 190     m_pStreamData.reset( new SPStreamData_Impl( false,
 191                                         xTargetTruncate, xTargetSeek, xTargetInStream, xTargetOutStream,
 192                                         bInOpen, bOutOpen ) );
 193 }
 194
 195 void SwitchablePersistenceStream::CloseAll_Impl()
 196 {
 197     m_pStreamData.reset();
 198 }
 199
 200 // css::io::XStream
 201 uno::Reference< io::XInputStream > SAL_CALL SwitchablePersistenceStream::getInputStream(  )
 202 {
 203     std::scoped_lock aGuard( m_aMutex );
 204
 205     if ( m_pStreamData )
 206         m_pStreamData->m_bInOpen = true;
 207     return static_cast< io::XInputStream* >( this );
 208 }
 209
 210 uno::Reference< io::XOutputStream > SAL_CALL SwitchablePersistenceStream::getOutputStream(  )
 211 {
 212     std::scoped_lock aGuard( m_aMutex );
 213
 214     if ( m_pStreamData )
 215         m_pStreamData->m_bOutOpen = true;
 216     return static_cast< io::XOutputStream* >( this );
 217 }
 218
 219 // css::io::XInputStream
 220 ::sal_Int32 SAL_CALL SwitchablePersistenceStream::readBytes( uno::Sequence< ::sal_Int8 >& aData, ::sal_Int32 nBytesToRead )
 221 {
 222     std::scoped_lock aGuard( m_aMutex );
 223
 224     if ( !m_pStreamData )
 225         throw io::NotConnectedException();
 226
 227     // the original stream data should be provided
 228     if ( !m_pStreamData->m_xOrigInStream.is() )
 229         throw uno::RuntimeException();
 230
 231     return m_pStreamData->m_xOrigInStream->readBytes( aData, nBytesToRead );
 232 }
 233
 234 ::sal_Int32 SAL_CALL SwitchablePersistenceStream::readSomeBytes( uno::Sequence< ::sal_Int8 >& aData, ::sal_Int32 nMaxBytesToRead )
 235 {
 236     std::scoped_lock aGuard( m_aMutex );
 237
 238     if ( !m_pStreamData )
 239         throw io::NotConnectedException();
 240
 241     // the original stream data should be provided
 242     if ( !m_pStreamData->m_xOrigInStream.is() )
 243         throw uno::RuntimeException();
 244
 245     return m_pStreamData->m_xOrigInStream->readBytes( aData, nMaxBytesToRead );
 246 }
 247
 248 ::sal_Int32 SwitchablePersistenceStream::readSomeBytes( sal_Int8* aData, sal_Int32 nBytesToRead)
 249 {
 250     std::scoped_lock aGuard( m_aMutex );
 251
 252     if ( !m_pStreamData )
 253         throw io::NotConnectedException();
 254
 255     // the original stream data should be provided
 256     if ( !m_pStreamData->m_xOrigInStream.is() )
 257         throw uno::RuntimeException();
 258
 259     return m_pStreamData->m_pByteReader->readSomeBytes( aData, nBytesToRead );
 260 }
 261
 262 void SAL_CALL SwitchablePersistenceStream::skipBytes( ::sal_Int32 nBytesToSkip )
 263 {
 264     std::scoped_lock aGuard( m_aMutex );
 265
 266     if ( !m_pStreamData )
 267         throw io::NotConnectedException();
 268
 269     // the original stream data should be provided
 270     if ( !m_pStreamData->m_xOrigInStream.is() )
 271         throw uno::RuntimeException();
 272
 273     m_pStreamData->m_xOrigInStream->skipBytes( nBytesToSkip );
 274 }
 275
 276 ::sal_Int32 SAL_CALL SwitchablePersistenceStream::available(  )
 277 {
 278     std::scoped_lock aGuard( m_aMutex );
 279
 280     if ( !m_pStreamData )
 281         throw io::NotConnectedException();
 282
 283     // the original stream data should be provided
 284     if ( !m_pStreamData->m_xOrigInStream.is() )
 285         throw uno::RuntimeException();
 286
 287     return m_pStreamData->m_xOrigInStream->available();
 288 }
 289
 290 void SAL_CALL SwitchablePersistenceStream::closeInput()
 291 {
 292     std::scoped_lock aGuard( m_aMutex );
 293
 294     if ( !m_pStreamData )
 295         throw io::NotConnectedException();
 296
 297     m_pStreamData->m_bInOpen = false;
 298     if ( !m_pStreamData->m_bOutOpen )
 299         CloseAll_Impl();
 300 }
 301
 302 // css::io::XOutputStream
 303 void SAL_CALL SwitchablePersistenceStream::writeBytes( const uno::Sequence< ::sal_Int8 >& aData )
 304 {
 305     std::scoped_lock aGuard( m_aMutex );
 306
 307     if ( !m_pStreamData )
 308         throw io::NotConnectedException();
 309
 310     if ( m_pStreamData->m_bInStreamBased )
 311         throw io::IOException();
 312
 313     // the original stream data should be provided
 314     if ( !m_pStreamData->m_xOrigOutStream.is() )
 315         throw uno::RuntimeException();
 316
 317     m_pStreamData->m_xOrigOutStream->writeBytes( aData );
 318 }
 319
 320 void SAL_CALL SwitchablePersistenceStream::flush(  )
 321 {
 322     std::scoped_lock aGuard( m_aMutex );
 323
 324     if ( !m_pStreamData || m_pStreamData->m_bInStreamBased )
 325     {
 326         OSL_FAIL( "flush() is not acceptable!" );
 327         return;
 328         // in future throw exception, for now some code might call flush() on closed stream
 329         // since file ucp implementation allows it
 330         // throw io::NotConnectedException();
 331     }
 332
 333     // the original stream data should be provided
 334     if ( !m_pStreamData->m_xOrigOutStream.is() )
 335         throw uno::RuntimeException();
 336
 337     m_pStreamData->m_xOrigOutStream->flush();
 338 }
 339
 340 void SAL_CALL SwitchablePersistenceStream::closeOutput(  )
 341 {
 342     std::scoped_lock aGuard( m_aMutex );
 343
 344     if ( !m_pStreamData )
 345         throw io::NotConnectedException();
 346
 347     m_pStreamData->m_bOutOpen = false;
 348     if ( !m_pStreamData->m_bInOpen )
 349         CloseAll_Impl();
 350 }
 351
 352 // css::io::XTruncate
 353 void SAL_CALL SwitchablePersistenceStream::truncate(  )
 354 {
 355     std::scoped_lock aGuard( m_aMutex );
 356
 357     if ( !m_pStreamData )
 358         throw io::NotConnectedException();
 359
 360     if ( m_pStreamData->m_bInStreamBased )
 361         throw io::IOException();
 362
 363     // the original stream data should be provided
 364     if ( !m_pStreamData->m_xOrigTruncate.is() )
 365         throw uno::RuntimeException();
 366
 367     m_pStreamData->m_xOrigTruncate->truncate();
 368 }
 369
 370 // css::io::XSeekable
 371 void SAL_CALL SwitchablePersistenceStream::seek( ::sal_Int64 location )
 372 {
 373     std::scoped_lock aGuard( m_aMutex );
 374
 375     if ( !m_pStreamData )
 376         throw io::NotConnectedException();
 377
 378     // the original stream data should be provided
 379     if ( !m_pStreamData->m_xOrigSeekable.is() )
 380         throw uno::RuntimeException();
 381
 382     m_pStreamData->m_xOrigSeekable->seek( location );
 383 }
 384
 385 ::sal_Int64 SAL_CALL SwitchablePersistenceStream::getPosition(  )
 386 {
 387     std::scoped_lock aGuard( m_aMutex );
 388
 389     if ( !m_pStreamData )
 390         throw io::NotConnectedException();
 391
 392     // the original stream data should be provided
 393     if ( !m_pStreamData->m_xOrigSeekable.is() )
 394         throw uno::RuntimeException();
 395
 396     return m_pStreamData->m_xOrigSeekable->getPosition();
 397 }
 398
 399 ::sal_Int64 SAL_CALL SwitchablePersistenceStream::getLength(  )
 400 {
 401     std::scoped_lock aGuard( m_aMutex );
 402
 403     if ( !m_pStreamData )
 404         throw io::NotConnectedException();
 405
 406     // the original stream data should be provided
 407     if ( !m_pStreamData->m_xOrigSeekable.is() )
 408         throw uno::RuntimeException();
 409
 410     return m_pStreamData->m_xOrigSeekable->getLength();
 411 }
 412
 413 void SAL_CALL SwitchablePersistenceStream::waitForCompletion()
 414 {
 415     if ( !m_pStreamData )
 416         throw io::NotConnectedException();
 417
 418     uno::Reference< io::XAsyncOutputMonitor > asyncOutputMonitor( m_pStreamData->m_xOrigOutStream, uno::UNO_QUERY );
 419     if ( asyncOutputMonitor.is() )
 420         asyncOutputMonitor->waitForCompletion();
 421 }
 422
 423 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */