oox/source/helper/storagebase.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 "oox/helper/storagebase.hxx"
  21
  22 #include <com/sun/star/embed/XTransactedObject.hpp>
  23 #include <com/sun/star/io/XStream.hpp>
  24 #include <rtl/ustrbuf.hxx>
  25 #include "oox/helper/binaryinputstream.hxx"
  26 #include "oox/helper/binaryoutputstream.hxx"
  27
  28 namespace oox {
  29
  30 // ============================================================================
  31
  32 using namespace ::com::sun::star::embed;
  33 using namespace ::com::sun::star::io;
  34 using namespace ::com::sun::star::uno;
  35
  36 // ============================================================================
  37
  38 namespace {
  39
  40 void lclSplitFirstElement( OUString& orElement, OUString& orRemainder, OUString aFullName )
  41 {
  42     sal_Int32  nSlashPos = aFullName.indexOf( '/' );
  43
  44     // strip leading slashes
  45     while( nSlashPos == 0 )
  46     {
  47         aFullName = aFullName.copy(1);
  48         nSlashPos = aFullName.indexOf( '/' );
  49     }
  50
  51     if( (0 <= nSlashPos) && (nSlashPos < aFullName.getLength()) )
  52     {
  53         orElement = aFullName.copy( 0, nSlashPos );
  54         orRemainder = aFullName.copy( nSlashPos + 1 );
  55     }
  56     else
  57     {
  58         orElement = aFullName;
  59     }
  60 }
  61
  62 } // namespace
  63
  64 // ----------------------------------------------------------------------------
  65
  66 StorageBase::StorageBase( const Reference< XInputStream >& rxInStream, bool bBaseStreamAccess ) :
  67     mxInStream( rxInStream ),
  68     mbBaseStreamAccess( bBaseStreamAccess ),
  69     mbReadOnly( true )
  70 {
  71     OSL_ENSURE( mxInStream.is(), "StorageBase::StorageBase - missing base input stream" );
  72 }
  73
  74 StorageBase::StorageBase( const Reference< XStream >& rxOutStream, bool bBaseStreamAccess ) :
  75     mxOutStream( rxOutStream ),
  76     mbBaseStreamAccess( bBaseStreamAccess ),
  77     mbReadOnly( false )
  78 {
  79     OSL_ENSURE( mxOutStream.is(), "StorageBase::StorageBase - missing base output stream" );
  80 }
  81
  82 StorageBase::StorageBase( const StorageBase& rParentStorage, const OUString& rStorageName, bool bReadOnly ) :
  83     maParentPath( rParentStorage.getPath() ),
  84     maStorageName( rStorageName ),
  85     mbBaseStreamAccess( false ),
  86     mbReadOnly( bReadOnly )
  87 {
  88 }
  89
  90 StorageBase::~StorageBase()
  91 {
  92 }
  93
  94 bool StorageBase::isStorage() const
  95 {
  96     return implIsStorage();
  97 }
  98
  99 bool StorageBase::isRootStorage() const
 100 {
 101     return implIsStorage() && maStorageName.isEmpty();
 102 }
 103
 104 bool StorageBase::isReadOnly() const
 105 {
 106     return mbReadOnly;
 107 }
 108
 109 Reference< XStorage > StorageBase::getXStorage() const
 110 {
 111     return implGetXStorage();
 112 }
 113
 114 const OUString& StorageBase::getName() const
 115 {
 116     return maStorageName;
 117 }
 118
 119 OUString StorageBase::getPath() const
 120 {
 121     OUStringBuffer aBuffer( maParentPath );
 122     if( !aBuffer.isEmpty() )
 123         aBuffer.append( '/' );
 124     aBuffer.append( maStorageName );
 125     return aBuffer.makeStringAndClear();
 126 }
 127
 128 void StorageBase::getElementNames( ::std::vector< OUString >& orElementNames ) const
 129 {
 130     orElementNames.clear();
 131     implGetElementNames( orElementNames );
 132 }
 133
 134 StorageRef StorageBase::openSubStorage( const OUString& rStorageName, bool bCreateMissing )
 135 {
 136     StorageRef xSubStorage;
 137     OSL_ENSURE( !bCreateMissing || !mbReadOnly, "StorageBase::openSubStorage - cannot create substorage in read-only mode" );
 138     if( !bCreateMissing || !mbReadOnly )
 139     {
 140         OUString aElement, aRemainder;
 141         lclSplitFirstElement( aElement, aRemainder, rStorageName );
 142         if( !aElement.isEmpty() )
 143             xSubStorage = getSubStorage( aElement, bCreateMissing );
 144         if( xSubStorage.get() && !aRemainder.isEmpty() )
 145             xSubStorage = xSubStorage->openSubStorage( aRemainder, bCreateMissing );
 146     }
 147     return xSubStorage;
 148 }
 149
 150 Reference< XInputStream > StorageBase::openInputStream( const OUString& rStreamName )
 151 {
 152     Reference< XInputStream > xInStream;
 153     OUString aElement, aRemainder;
 154     lclSplitFirstElement( aElement, aRemainder, rStreamName );
 155     if( !aElement.isEmpty() )
 156     {
 157         if( !aRemainder.isEmpty() )
 158         {
 159             StorageRef xSubStorage = getSubStorage( aElement, false );
 160             if( xSubStorage.get() )
 161                 xInStream = xSubStorage->openInputStream( aRemainder );
 162         }
 163         else
 164         {
 165             xInStream = implOpenInputStream( aElement );
 166         }
 167     }
 168     else if( mbBaseStreamAccess )
 169     {
 170         xInStream = mxInStream;
 171     }
 172     return xInStream;
 173 }
 174
 175 Reference< XOutputStream > StorageBase::openOutputStream( const OUString& rStreamName )
 176 {
 177     Reference< XOutputStream > xOutStream;
 178     OSL_ENSURE( !mbReadOnly, "StorageBase::openOutputStream - cannot create output stream in read-only mode" );
 179     if( !mbReadOnly )
 180     {
 181         OUString aElement, aRemainder;
 182         lclSplitFirstElement( aElement, aRemainder, rStreamName );
 183         if( !aElement.isEmpty() )
 184         {
 185             if( !aRemainder.isEmpty() )
 186             {
 187                 StorageRef xSubStorage = getSubStorage( aElement, true );
 188                 if( xSubStorage.get() )
 189                     xOutStream = xSubStorage->openOutputStream( aRemainder );
 190             }
 191             else
 192             {
 193                 xOutStream = implOpenOutputStream( aElement );
 194             }
 195         }
 196         else if( mbBaseStreamAccess )
 197         {
 198             xOutStream = mxOutStream->getOutputStream();
 199         }
 200     }
 201     return xOutStream;
 202 }
 203
 204 void StorageBase::copyToStorage( StorageBase& rDestStrg, const OUString& rElementName )
 205 {
 206     OSL_ENSURE( rDestStrg.isStorage() && !rDestStrg.isReadOnly(), "StorageBase::copyToStorage - invalid destination" );
 207     OSL_ENSURE( !rElementName.isEmpty(), "StorageBase::copyToStorage - invalid element name" );
 208     if( rDestStrg.isStorage() && !rDestStrg.isReadOnly() && !rElementName.isEmpty() )
 209     {
 210         StorageRef xSubStrg = openSubStorage( rElementName, false );
 211         if( xSubStrg.get() )
 212         {
 213             StorageRef xDestSubStrg = rDestStrg.openSubStorage( rElementName, true );
 214             if( xDestSubStrg.get() )
 215                 xSubStrg->copyStorageToStorage( *xDestSubStrg );
 216         }
 217         else
 218         {
 219             Reference< XInputStream > xInStrm = openInputStream( rElementName );
 220             if( xInStrm.is() )
 221             {
 222                 Reference< XOutputStream > xOutStrm = rDestStrg.openOutputStream( rElementName );
 223                 if( xOutStrm.is() )
 224                 {
 225                     BinaryXInputStream aInStrm( xInStrm, true );
 226                     BinaryXOutputStream aOutStrm( xOutStrm, true );
 227                     aInStrm.copyToStream( aOutStrm );
 228                 }
 229             }
 230         }
 231     }
 232 }
 233
 234 void StorageBase::copyStorageToStorage( StorageBase& rDestStrg )
 235 {
 236     OSL_ENSURE( rDestStrg.isStorage() && !rDestStrg.isReadOnly(), "StorageBase::copyToStorage - invalid destination" );
 237     if( rDestStrg.isStorage() && !rDestStrg.isReadOnly() )
 238     {
 239         ::std::vector< OUString > aElements;
 240         getElementNames( aElements );
 241         for( ::std::vector< OUString >::iterator aIt = aElements.begin(), aEnd = aElements.end(); aIt != aEnd; ++aIt )
 242             copyToStorage( rDestStrg, *aIt );
 243     }
 244 }
 245
 246 void StorageBase::commit()
 247 {
 248     OSL_ENSURE( !mbReadOnly, "StorageBase::commit - cannot commit in read-only mode" );
 249     if( !mbReadOnly )
 250     {
 251         // commit all open substorages
 252         maSubStorages.forEachMem( &StorageBase::commit );
 253         // commit this storage
 254         implCommit();
 255     }
 256 }
 257
 258 // private --------------------------------------------------------------------
 259
 260 StorageRef StorageBase::getSubStorage( const OUString& rElementName, bool bCreateMissing )
 261 {
 262     StorageRef& rxSubStrg = maSubStorages[ rElementName ];
 263     if( !rxSubStrg )
 264         rxSubStrg = implOpenSubStorage( rElementName, bCreateMissing );
 265     return rxSubStrg;
 266 }
 267
 268 // ============================================================================
 269
 270 } // namespace oox
 271
 272 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */