oox/source/helper/storagebase.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: storagebase.cxx,v $
  10  * $Revision: 1.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "oox/helper/storagebase.hxx"
  32 #include <com/sun/star/io/XStream.hpp>
  33 #include <com/sun/star/embed/XTransactedObject.hpp>
  34 #include <rtl/ustrbuf.hxx>
  35
  36 using ::rtl::OUString;
  37 using ::rtl::OUStringBuffer;
  38 using ::com::sun::star::uno::Reference;
  39 using ::com::sun::star::uno::UNO_QUERY;
  40 using ::com::sun::star::embed::XStorage;
  41 using ::com::sun::star::embed::XTransactedObject;
  42 using ::com::sun::star::io::XInputStream;
  43 using ::com::sun::star::io::XOutputStream;
  44 using ::com::sun::star::io::XStream;
  45
  46 namespace oox {
  47
  48 // ============================================================================
  49
  50 namespace {
  51
  52 void lclSplitFirstElement( OUString& orElement, OUString& orRemainder, const OUString& rFullName )
  53 {
  54     sal_Int32 nSlashPos = rFullName.indexOf( '/' );
  55     if( (0 <= nSlashPos) && (nSlashPos < rFullName.getLength()) )
  56     {
  57         orElement = rFullName.copy( 0, nSlashPos );
  58         orRemainder = rFullName.copy( nSlashPos + 1 );
  59     }
  60     else
  61     {
  62         orElement = rFullName;
  63     }
  64 }
  65
  66 } // namespace
  67
  68 // ----------------------------------------------------------------------------
  69
  70 StorageBase::StorageBase( const Reference< XInputStream >& rxInStream, bool bBaseStreamAccess ) :
  71     mxInStream( rxInStream ),
  72     mpParentStorage( 0 ),
  73     mbBaseStreamAccess( bBaseStreamAccess )
  74 {
  75     OSL_ENSURE( mxInStream.is(), "StorageBase::StorageBase - missing base input stream" );
  76 }
  77
  78 StorageBase::StorageBase( const Reference< XStream >& rxOutStream, bool bBaseStreamAccess ) :
  79     mxOutStream( rxOutStream ),
  80     mpParentStorage( 0 ),
  81     mbBaseStreamAccess( bBaseStreamAccess )
  82 {
  83     OSL_ENSURE( mxOutStream.is(), "StorageBase::StorageBase - missing base output stream" );
  84 }
  85
  86 StorageBase::StorageBase( const StorageBase& rParentStorage, const OUString& rStorageName ) :
  87     maStorageName( rStorageName ),
  88     mpParentStorage( &rParentStorage ),
  89     mbBaseStreamAccess( false )
  90 {
  91 }
  92
  93 StorageBase::~StorageBase()
  94 {
  95 }
  96
  97 bool StorageBase::isStorage() const
  98 {
  99     return implIsStorage();
 100 }
 101
 102 Reference< XStorage > StorageBase::getXStorage() const
 103 {
 104     return implGetXStorage();
 105 }
 106
 107 const OUString& StorageBase::getName() const
 108 {
 109     return maStorageName;
 110 }
 111
 112 OUString StorageBase::getPath() const
 113 {
 114     OUStringBuffer aBuffer;
 115     if( mpParentStorage )
 116         aBuffer.append( mpParentStorage->getPath() );
 117     if( aBuffer.getLength() > 0 )
 118         aBuffer.append( sal_Unicode( '/' ) );
 119     aBuffer.append( maStorageName );
 120     return aBuffer.makeStringAndClear();
 121 }
 122
 123 void StorageBase::getElementNames( ::std::vector< OUString >& orElementNames ) const
 124 {
 125     orElementNames.clear();
 126     implGetElementNames( orElementNames );
 127 }
 128
 129 StorageRef StorageBase::openSubStorage( const OUString& rStorageName, bool bCreate )
 130 {
 131     StorageRef xSubStorage;
 132     OUString aElement, aRemainder;
 133     lclSplitFirstElement( aElement, aRemainder, rStorageName );
 134     if( aElement.getLength() > 0 )
 135         xSubStorage = getSubStorage( aElement, bCreate );
 136     if( xSubStorage.get() && (aRemainder.getLength() > 0) )
 137         xSubStorage = xSubStorage->openSubStorage( aRemainder, bCreate );
 138     return xSubStorage;
 139 }
 140
 141 Reference< XInputStream > StorageBase::openInputStream( const OUString& rStreamName )
 142 {
 143     Reference< XInputStream > xInStream;
 144     OUString aElement, aRemainder;
 145     lclSplitFirstElement( aElement, aRemainder, rStreamName );
 146     if( aElement.getLength() > 0 )
 147     {
 148         if( aRemainder.getLength() > 0 )
 149         {
 150             StorageRef xSubStorage = getSubStorage( aElement, false );
 151             if( xSubStorage.get() )
 152                 xInStream = xSubStorage->openInputStream( aRemainder );
 153         }
 154         else
 155         {
 156             xInStream = implOpenInputStream( aElement );
 157         }
 158     }
 159     else if( mbBaseStreamAccess )
 160     {
 161         xInStream = mxInStream;
 162     }
 163     return xInStream;
 164 }
 165
 166 Reference< XOutputStream > StorageBase::openOutputStream( const OUString& rStreamName )
 167 {
 168     Reference< XOutputStream > xOutStream;
 169     OUString aElement, aRemainder;
 170     lclSplitFirstElement( aElement, aRemainder, rStreamName );
 171     if( aElement.getLength() > 0 )
 172     {
 173         if( aRemainder.getLength() > 0 )
 174         {
 175             StorageRef xSubStorage = getSubStorage( aElement, true );
 176             if( xSubStorage.get() )
 177                 xOutStream = xSubStorage->openOutputStream( aRemainder );
 178         }
 179         else
 180         {
 181             xOutStream = implOpenOutputStream( aElement );
 182         }
 183     }
 184     else if( mbBaseStreamAccess )
 185     {
 186         xOutStream = mxOutStream->getOutputStream();
 187     }
 188     return xOutStream;
 189 }
 190
 191 StorageRef StorageBase::getSubStorage( const OUString& rElementName, bool bCreate )
 192 {
 193     SubStorageMap::iterator aIt = maSubStorages.find( rElementName );
 194     return (aIt == maSubStorages.end()) ?
 195         (maSubStorages[ rElementName ] = implOpenSubStorage( rElementName, bCreate )) : aIt->second;
 196 }
 197
 198 void StorageBase::commit()
 199 {
 200     for( SubStorageMap::iterator aIt = maSubStorages.begin(); aIt != maSubStorages.end(); aIt ++ )
 201         aIt->second->commit();
 202
 203     Reference< XTransactedObject > xTransactedObj( getXStorage(), UNO_QUERY );
 204
 205     if( xTransactedObj.is() )
 206         xTransactedObj->commit();
 207 }
 208
 209 // ============================================================================
 210
 211 } // namespace oox
 212