oox/source/helper/textinputstream.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/textinputstream.hxx>
  21
  22 #include <com/sun/star/io/NotConnectedException.hpp>
  23 #include <com/sun/star/io/XActiveDataSink.hpp>
  24 #include <com/sun/star/io/TextInputStream.hpp>
  25 #include <cppuhelper/implbase.hxx>
  26 #include <osl/diagnose.h>
  27 #include <rtl/tencinfo.h>
  28 #include <oox/helper/binaryinputstream.hxx>
  29
  30 namespace oox {
  31
  32 using namespace ::com::sun::star::io;
  33 using namespace ::com::sun::star::lang;
  34 using namespace ::com::sun::star::uno;
  35
  36 namespace {
  37
  38 /** Implementation of a UNO input stream wrapping a binary input stream.
  39  */
  40 class UnoBinaryInputStream : public ::cppu::WeakImplHelper< XInputStream >
  41 {
  42 public:
  43     explicit            UnoBinaryInputStream( BinaryInputStream& rInStrm );
  44
  45     virtual sal_Int32 SAL_CALL readBytes( Sequence< sal_Int8 >& rData, sal_Int32 nBytesToRead ) override;
  46     virtual sal_Int32 SAL_CALL readSomeBytes( Sequence< sal_Int8 >& rData, sal_Int32 nMaxBytesToRead ) override;
  47     virtual void SAL_CALL skipBytes( sal_Int32 nBytesToSkip ) override;
  48     virtual sal_Int32 SAL_CALL available() override;
  49     virtual void SAL_CALL closeInput() override;
  50
  51 private:
  52     /// @throws NotConnectedException
  53     void                ensureConnected() const;
  54
  55 private:
  56     BinaryInputStream*  mpInStrm;
  57 };
  58
  59 UnoBinaryInputStream::UnoBinaryInputStream( BinaryInputStream& rInStrm ) :
  60     mpInStrm( &rInStrm )
  61 {
  62 }
  63
  64 sal_Int32 SAL_CALL UnoBinaryInputStream::readBytes( Sequence< sal_Int8 >& rData, sal_Int32 nBytesToRead )
  65 {
  66     ensureConnected();
  67     return mpInStrm->readData( rData, nBytesToRead );
  68 }
  69
  70 sal_Int32 SAL_CALL UnoBinaryInputStream::readSomeBytes( Sequence< sal_Int8 >& rData, sal_Int32 nMaxBytesToRead )
  71 {
  72     ensureConnected();
  73     return mpInStrm->readData( rData, nMaxBytesToRead );
  74 }
  75
  76 void SAL_CALL UnoBinaryInputStream::skipBytes( sal_Int32 nBytesToSkip )
  77 {
  78     ensureConnected();
  79     mpInStrm->skip( nBytesToSkip );
  80 }
  81
  82 sal_Int32 SAL_CALL UnoBinaryInputStream::available()
  83 {
  84     ensureConnected();
  85     throw RuntimeException( "Functionality not supported", Reference< XInputStream >() );
  86 }
  87
  88 void SAL_CALL UnoBinaryInputStream::closeInput()
  89 {
  90     ensureConnected();
  91     mpInStrm->close();
  92     mpInStrm = nullptr;
  93 }
  94
  95 void UnoBinaryInputStream::ensureConnected() const
  96 {
  97     if( !mpInStrm )
  98         throw NotConnectedException( "Stream closed" );
  99 }
 100
 101 } // namespace
 102
 103 TextInputStream::TextInputStream( const Reference< XComponentContext >& rxContext, const Reference< XInputStream >& rxInStrm, rtl_TextEncoding eTextEnc )
 104 {
 105     init( rxContext, rxInStrm, eTextEnc );
 106 }
 107
 108 TextInputStream::TextInputStream( const Reference< XComponentContext >& rxContext, BinaryInputStream& rInStrm, rtl_TextEncoding eTextEnc )
 109 {
 110     init( rxContext, new UnoBinaryInputStream( rInStrm ), eTextEnc );
 111 }
 112
 113 TextInputStream::~TextInputStream()
 114 {
 115 }
 116
 117 bool TextInputStream::isEof() const
 118 {
 119     if( mxTextStrm.is() ) try
 120     {
 121         return mxTextStrm->isEOF();
 122     }
 123     catch (const Exception&)
 124     {
 125     }
 126     return true;
 127 }
 128
 129 OUString TextInputStream::readLine()
 130 {
 131     if( mxTextStrm.is() ) try
 132     {
 133         /*  The function createFinalString() adds a character that may have
 134             been buffered in the previous call of readToChar() (see below). */
 135         return createFinalString( mxTextStrm->readLine() );
 136     }
 137     catch (const Exception&)
 138     {
 139         mxTextStrm.clear();
 140     }
 141     return OUString();
 142 }
 143
 144 OUString TextInputStream::readToChar( sal_Unicode cChar, bool bIncludeChar )
 145 {
 146     if( mxTextStrm.is() ) try
 147     {
 148         Sequence< sal_Unicode > aDelimiters( 1 );
 149         aDelimiters[ 0 ] = cChar;
 150         /*  Always get the delimiter character from the UNO text input stream.
 151             In difference to this implementation, it will not return it in the
 152             next call but silently skip it. If caller specifies to exclude the
 153             character in this call, it will be returned in the next call of one
 154             of the own member functions. The function createFinalString() adds
 155             a character that has been buffered in the previous call. */
 156         OUString aString = createFinalString( mxTextStrm->readString( aDelimiters, false ) );
 157         // remove last character from string and remember it for next call
 158         if( !bIncludeChar && !aString.isEmpty() && (aString[ aString.getLength() - 1 ] == cChar) )
 159         {
 160             mcPendingChar = cChar;
 161             aString = aString.copy( 0, aString.getLength() - 1 );
 162         }
 163         return aString;
 164     }
 165     catch (const Exception&)
 166     {
 167         mxTextStrm.clear();
 168     }
 169     return OUString();
 170 }
 171
 172 Reference< XTextInputStream2 > TextInputStream::createXTextInputStream(
 173         const Reference< XComponentContext >& rxContext, const Reference< XInputStream >& rxInStrm, rtl_TextEncoding eTextEnc )
 174 {
 175     Reference< XTextInputStream2 > xTextStrm;
 176     const char* pcCharset = rtl_getBestMimeCharsetFromTextEncoding( eTextEnc );
 177     OSL_ENSURE( pcCharset, "TextInputStream::createXTextInputStream - unsupported text encoding" );
 178     if( rxContext.is() && rxInStrm.is() && pcCharset ) try
 179     {
 180         xTextStrm = css::io::TextInputStream::create( rxContext );
 181         xTextStrm->setInputStream( rxInStrm );
 182         xTextStrm->setEncoding( OUString::createFromAscii( pcCharset ) );
 183     }
 184     catch (const Exception&)
 185     {
 186     }
 187     return xTextStrm;
 188 }
 189
 190 // private --------------------------------------------------------------------
 191
 192 OUString TextInputStream::createFinalString( const OUString& rString )
 193 {
 194     if( mcPendingChar == 0 )
 195         return rString;
 196
 197     OUString aString = OUStringLiteral1( mcPendingChar ) + rString;
 198     mcPendingChar = 0;
 199     return aString;
 200 }
 201
 202 void TextInputStream::init( const Reference< XComponentContext >& rxContext, const Reference< XInputStream >& rxInStrm, rtl_TextEncoding eTextEnc )
 203 {
 204     mcPendingChar = 0;
 205     mxTextStrm = createXTextInputStream( rxContext, rxInStrm, eTextEnc );
 206 }
 207
 208 } // namespace oox
 209
 210 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */