io/source/TextInputStream/TextInputStream.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: TextInputStream.cxx,v $
  10  * $Revision: 1.15 $
  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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_io.hxx"
  33
  34
  35 #include <string.h>
  36 #include <osl/mutex.hxx>
  37 #include <osl/diagnose.h>
  38
  39 #include <rtl/unload.h>
  40
  41 #include <uno/mapping.hxx>
  42
  43 #include <cppuhelper/factory.hxx>
  44 #include <cppuhelper/implbase3.hxx>
  45 #include <cppuhelper/implementationentry.hxx>
  46
  47 #include <rtl/textenc.h>
  48 #include <rtl/tencinfo.h>
  49
  50 #include <com/sun/star/io/XTextInputStream.hpp>
  51 #include <com/sun/star/io/XActiveDataSink.hpp>
  52 #include <com/sun/star/lang/XServiceInfo.hpp>
  53
  54
  55 #define IMPLEMENTATION_NAME "com.sun.star.comp.io.TextInputStream"
  56 #define SERVICE_NAME "com.sun.star.io.TextInputStream"
  57
  58 using namespace ::osl;
  59 using namespace ::rtl;
  60 using namespace ::cppu;
  61 using namespace ::com::sun::star::uno;
  62 using namespace ::com::sun::star::lang;
  63 using namespace ::com::sun::star::io;
  64 using namespace ::com::sun::star::registry;
  65
  66 namespace io_TextInputStream
  67 {
  68     rtl_StandardModuleCount g_moduleCount = MODULE_COUNT_INIT;
  69
  70 //===========================================================================
  71 // Implementation XTextInputStream
  72
  73 typedef WeakImplHelper3< XTextInputStream, XActiveDataSink, XServiceInfo > TextInputStreamHelper;
  74 class OCommandEnvironment;
  75
  76 #define INITIAL_UNICODE_BUFFER_CAPACITY         0x100
  77 #define READ_BYTE_COUNT                                         0x100
  78
  79 class OTextInputStream : public TextInputStreamHelper
  80 {
  81     Reference< XInputStream > mxStream;
  82
  83     // Encoding
  84     OUString mEncoding;
  85     sal_Bool mbEncodingInitialized;
  86     rtl_TextToUnicodeConverter  mConvText2Unicode;
  87     rtl_TextToUnicodeContext    mContextText2Unicode;
  88     Sequence<sal_Int8>                  mSeqSource;
  89
  90     // Internal buffer for characters that are already converted successfully
  91     sal_Unicode* mpBuffer;
  92     sal_Int32 mnBufferSize;
  93     sal_Int32 mnCharsInBuffer;
  94     sal_Bool mbReachedEOF;
  95
  96     void implResizeBuffer( void );
  97     OUString implReadString( const Sequence< sal_Unicode >& Delimiters,
  98         sal_Bool bRemoveDelimiter, sal_Bool bFindLineEnd )
  99             throw(IOException, RuntimeException);
 100     sal_Int32 implReadNext() throw(IOException, RuntimeException);
 101
 102 public:
 103     OTextInputStream();
 104     virtual ~OTextInputStream();
 105
 106     // Methods XTextInputStream
 107     virtual OUString SAL_CALL readLine(  )
 108         throw(IOException, RuntimeException);
 109     virtual OUString SAL_CALL readString( const Sequence< sal_Unicode >& Delimiters, sal_Bool bRemoveDelimiter )
 110         throw(IOException, RuntimeException);
 111     virtual sal_Bool SAL_CALL isEOF(  )
 112         throw(IOException, RuntimeException);
 113     virtual void SAL_CALL setEncoding( const OUString& Encoding ) throw(RuntimeException);
 114
 115     // Methods XInputStream
 116     virtual sal_Int32 SAL_CALL readBytes( Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead )
 117         throw(NotConnectedException, BufferSizeExceededException, IOException, RuntimeException);
 118     virtual sal_Int32 SAL_CALL readSomeBytes( Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead )
 119         throw(NotConnectedException, BufferSizeExceededException, IOException, RuntimeException);
 120     virtual void SAL_CALL skipBytes( sal_Int32 nBytesToSkip )
 121         throw(NotConnectedException, BufferSizeExceededException, IOException, RuntimeException);
 122     virtual sal_Int32 SAL_CALL available(  )
 123         throw(NotConnectedException, IOException, RuntimeException);
 124     virtual void SAL_CALL closeInput(  )
 125         throw(NotConnectedException, IOException, RuntimeException);
 126
 127     // Methods XActiveDataSink
 128     virtual void SAL_CALL setInputStream( const Reference< XInputStream >& aStream )
 129         throw(RuntimeException);
 130     virtual Reference< XInputStream > SAL_CALL getInputStream()
 131         throw(RuntimeException);
 132
 133     // Methods XServiceInfo
 134         virtual OUString              SAL_CALL getImplementationName() throw();
 135         virtual Sequence< OUString >  SAL_CALL getSupportedServiceNames(void) throw();
 136         virtual sal_Bool              SAL_CALL supportsService(const OUString& ServiceName) throw();
 137 };
 138
 139 OTextInputStream::OTextInputStream()
 140     : mSeqSource( READ_BYTE_COUNT ), mpBuffer( NULL ), mnBufferSize( 0 )
 141     , mnCharsInBuffer( 0 ), mbReachedEOF( sal_False )
 142 {
 143     g_moduleCount.modCnt.acquire( &g_moduleCount.modCnt );
 144     mbEncodingInitialized = false;
 145 }
 146
 147 OTextInputStream::~OTextInputStream()
 148 {
 149     if( mbEncodingInitialized )
 150     {
 151         rtl_destroyUnicodeToTextContext( mConvText2Unicode, mContextText2Unicode );
 152         rtl_destroyUnicodeToTextConverter( mConvText2Unicode );
 153     }
 154     g_moduleCount.modCnt.release( &g_moduleCount.modCnt );
 155 }
 156
 157 void OTextInputStream::implResizeBuffer( void )
 158 {
 159     sal_Int32 mnNewBufferSize = mnBufferSize * 2;
 160     sal_Unicode* pNewBuffer = new sal_Unicode[ mnNewBufferSize ];
 161     memcpy( pNewBuffer, mpBuffer, mnCharsInBuffer * sizeof( sal_Unicode ) );
 162     mpBuffer = pNewBuffer;
 163     mnBufferSize = mnNewBufferSize;
 164 }
 165
 166
 167 //===========================================================================
 168 // XTextInputStream
 169
 170 OUString OTextInputStream::readLine(  )
 171     throw(IOException, RuntimeException)
 172 {
 173     static Sequence< sal_Unicode > aDummySeq;
 174     return implReadString( aDummySeq, sal_True, sal_True );
 175 }
 176
 177 OUString OTextInputStream::readString( const Sequence< sal_Unicode >& Delimiters, sal_Bool )
 178         throw(IOException, RuntimeException)
 179 {
 180     return implReadString( Delimiters, sal_True, sal_False );
 181 }
 182
 183 sal_Bool OTextInputStream::isEOF()
 184     throw(IOException, RuntimeException)
 185 {
 186     sal_Bool bRet = sal_False;
 187     if( mnCharsInBuffer == 0 && mbReachedEOF )
 188         bRet = sal_True;
 189     return bRet;
 190 }
 191
 192
 193 OUString OTextInputStream::implReadString( const Sequence< sal_Unicode >& Delimiters,
 194                                            sal_Bool bRemoveDelimiter, sal_Bool bFindLineEnd )
 195         throw(IOException, RuntimeException)
 196 {
 197     OUString aRetStr;
 198     if( !mbEncodingInitialized )
 199     {
 200         OUString aUtf8Str( RTL_CONSTASCII_USTRINGPARAM("utf8") );
 201         setEncoding( aUtf8Str );
 202     }
 203     if( !mbEncodingInitialized )
 204         return aRetStr;
 205
 206     if( !mpBuffer )
 207     {
 208         mnBufferSize = INITIAL_UNICODE_BUFFER_CAPACITY;
 209         mpBuffer = new sal_Unicode[ mnBufferSize ];
 210     }
 211
 212     // Only for bFindLineEnd
 213     sal_Unicode cLineEndChar1 = 0x0D;
 214     sal_Unicode cLineEndChar2 = 0x0A;
 215
 216     sal_Int32 nBufferReadPos = 0;
 217     sal_Int32 nCopyLen = 0;
 218     sal_Bool bFound = sal_False;
 219     sal_Bool bFoundFirstLineEndChar = sal_False;
 220     sal_Unicode cFirstLineEndChar = 0;
 221     const sal_Unicode* pDelims = Delimiters.getConstArray();
 222     const sal_Int32 nDelimCount = Delimiters.getLength();
 223     while( !bFound )
 224     {
 225         // Still characters available?
 226         if( nBufferReadPos == mnCharsInBuffer )
 227         {
 228             // Already reached EOF? Then we can't read any more
 229             if( mbReachedEOF )
 230                 break;
 231
 232             // No, so read new characters
 233             if( !implReadNext() )
 234                 break;
 235         }
 236
 237         // Now there should be characters available
 238         // (otherwise the loop should have been breaked before)
 239         sal_Unicode     c = mpBuffer[ nBufferReadPos++ ];
 240
 241         if( bFindLineEnd )
 242         {
 243             if( bFoundFirstLineEndChar )
 244             {
 245                 bFound = sal_True;
 246                 nCopyLen = nBufferReadPos - 2;
 247                 if( c == cLineEndChar1 || c == cLineEndChar2 )
 248                 {
 249                     // Same line end char -> new line break
 250                     if( c == cFirstLineEndChar )
 251                     {
 252                         nBufferReadPos--;
 253                     }
 254                 }
 255                 else
 256                 {
 257                     // No second line end char
 258                     nBufferReadPos--;
 259                 }
 260             }
 261             else if( c == cLineEndChar1 || c == cLineEndChar2 )
 262             {
 263                 bFoundFirstLineEndChar = sal_True;
 264                 cFirstLineEndChar = c;
 265             }
 266         }
 267         else
 268         {
 269             for( sal_Int32 i = 0 ; i < nDelimCount ; i++ )
 270             {
 271                 if( c == pDelims[ i ] )
 272                 {
 273                     bFound = sal_True;
 274                     nCopyLen = nBufferReadPos;
 275                     if( bRemoveDelimiter )
 276                         nCopyLen--;
 277                 }
 278             }
 279         }
 280     }
 281
 282     // Nothing found? Return all
 283     if( !nCopyLen && !bFound && mbReachedEOF )
 284         nCopyLen = nBufferReadPos;
 285
 286     // Create string
 287     if( nCopyLen )
 288         aRetStr = OUString( mpBuffer, nCopyLen );
 289
 290     // Copy rest of buffer
 291     memmove( mpBuffer, mpBuffer + nBufferReadPos,
 292         (mnCharsInBuffer - nBufferReadPos) * sizeof( sal_Unicode ) );
 293     mnCharsInBuffer -= nBufferReadPos;
 294
 295     return aRetStr;
 296 }
 297
 298
 299 sal_Int32 OTextInputStream::implReadNext()
 300         throw(IOException, RuntimeException)
 301 {
 302     sal_Int32 nFreeBufferSize = mnBufferSize - mnCharsInBuffer;
 303     if( nFreeBufferSize < READ_BYTE_COUNT )
 304         implResizeBuffer();
 305     nFreeBufferSize = mnBufferSize - mnCharsInBuffer;
 306
 307     try
 308     {
 309         sal_Int32 nBytesToRead = READ_BYTE_COUNT;
 310         sal_Int32 nRead = mxStream->readSomeBytes( mSeqSource, nBytesToRead );
 311         sal_Int32 nTotalRead = nRead;
 312         if( nRead < nBytesToRead )
 313             mbReachedEOF = sal_True;
 314
 315         // Try to convert
 316         sal_uInt32 uiInfo;
 317         sal_Size nSrcCvtBytes = 0;
 318         sal_Size nTargetCount = 0;
 319         sal_Size nSourceCount = 0;
 320         while( sal_True )
 321         {
 322             const sal_Int8 *pbSource = mSeqSource.getConstArray();
 323
 324             // All invalid characters are transformed to the unicode undefined char
 325             nTargetCount += rtl_convertTextToUnicode(
 326                                 mConvText2Unicode,
 327                                 mContextText2Unicode,
 328                                 (const sal_Char*) &( pbSource[nSourceCount] ),
 329                                 nTotalRead - nSourceCount,
 330                                 mpBuffer + mnCharsInBuffer + nTargetCount,
 331                                 nFreeBufferSize - nTargetCount,
 332                                 RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_DEFAULT   |
 333                                 RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT |
 334                                 RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT,
 335                                 &uiInfo,
 336                                 &nSrcCvtBytes );
 337             nSourceCount += nSrcCvtBytes;
 338
 339             sal_Bool bCont = sal_False;
 340             if( uiInfo & RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL )
 341             {
 342                 implResizeBuffer();
 343                 bCont = sal_True;
 344             }
 345
 346             if( uiInfo & RTL_TEXTTOUNICODE_INFO_SRCBUFFERTOSMALL )
 347             {
 348                 // read next byte
 349                 static Sequence< sal_Int8 > aOneByteSeq( 1 );
 350                 nRead = mxStream->readSomeBytes( aOneByteSeq, 1 );
 351                 if( nRead == 0 )
 352                 {
 353                     mbReachedEOF = sal_True;
 354                     break;
 355                 }
 356
 357                 sal_Int32 nOldLen = mSeqSource.getLength();
 358                 nTotalRead++;
 359                 if( nTotalRead > nOldLen )
 360                 {
 361                     mSeqSource.realloc( nTotalRead );
 362                 }
 363                 mSeqSource.getArray()[ nOldLen ] = aOneByteSeq.getConstArray()[ 0 ];
 364                 pbSource = mSeqSource.getConstArray();
 365                 bCont = sal_True;
 366             }
 367
 368             if( bCont )
 369                 continue;
 370             break;
 371         }
 372
 373         mnCharsInBuffer += nTargetCount;
 374         return nTargetCount;
 375     }
 376     catch( NotConnectedException& )
 377     {
 378         throw IOException();
 379         //throw IOException( L"OTextInputStream::implReadString failed" );
 380     }
 381     catch( BufferSizeExceededException& )
 382     {
 383         throw IOException();
 384     }
 385 }
 386
 387 void OTextInputStream::setEncoding( const OUString& Encoding )
 388     throw(RuntimeException)
 389 {
 390     OString aOEncodingStr = OUStringToOString( Encoding, RTL_TEXTENCODING_ASCII_US );
 391     rtl_TextEncoding encoding = rtl_getTextEncodingFromMimeCharset( aOEncodingStr.getStr() );
 392     if( RTL_TEXTENCODING_DONTKNOW == encoding )
 393         return;
 394
 395     mbEncodingInitialized = true;
 396     mConvText2Unicode = rtl_createTextToUnicodeConverter( encoding );
 397     mContextText2Unicode = rtl_createTextToUnicodeContext( mConvText2Unicode );
 398     mEncoding = Encoding;
 399 }
 400
 401 //===========================================================================
 402 // XInputStream
 403
 404 sal_Int32 OTextInputStream::readBytes( Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead )
 405     throw(NotConnectedException, BufferSizeExceededException, IOException, RuntimeException)
 406 {
 407     return mxStream->readBytes( aData, nBytesToRead );
 408 }
 409
 410 sal_Int32 OTextInputStream::readSomeBytes( Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead )
 411     throw(NotConnectedException, BufferSizeExceededException, IOException, RuntimeException)
 412 {
 413     return mxStream->readSomeBytes( aData, nMaxBytesToRead );
 414 }
 415
 416 void OTextInputStream::skipBytes( sal_Int32 nBytesToSkip )
 417     throw(NotConnectedException, BufferSizeExceededException, IOException, RuntimeException)
 418 {
 419     mxStream->skipBytes( nBytesToSkip );
 420 }
 421
 422 sal_Int32 OTextInputStream::available(  )
 423     throw(NotConnectedException, IOException, RuntimeException)
 424 {
 425     return mxStream->available();
 426 }
 427
 428 void OTextInputStream::closeInput(  )
 429     throw(NotConnectedException, IOException, RuntimeException)
 430 {
 431     mxStream->closeInput();
 432 }
 433
 434
 435 //===========================================================================
 436 // XActiveDataSink
 437
 438 void OTextInputStream::setInputStream( const Reference< XInputStream >& aStream )
 439     throw(RuntimeException)
 440 {
 441     mxStream = aStream;
 442 }
 443
 444 Reference< XInputStream > OTextInputStream::getInputStream()
 445     throw(RuntimeException)
 446 {
 447     return mxStream;
 448 }
 449
 450
 451 Reference< XInterface > SAL_CALL TextInputStream_CreateInstance( const Reference< XComponentContext > &)
 452 {
 453     return Reference < XInterface >( ( OWeakObject * ) new OTextInputStream() );
 454 }
 455
 456 OUString TextInputStream_getImplementationName()
 457 {
 458     return OUString( RTL_CONSTASCII_USTRINGPARAM( IMPLEMENTATION_NAME ) );
 459 }
 460
 461 Sequence< OUString > TextInputStream_getSupportedServiceNames()
 462 {
 463     static Sequence < OUString > *pNames = 0;
 464     if( ! pNames )
 465     {
 466         MutexGuard guard( Mutex::getGlobalMutex() );
 467         if( !pNames )
 468         {
 469             static Sequence< OUString > seqNames(1);
 470             seqNames.getArray()[0] = OUString( RTL_CONSTASCII_USTRINGPARAM( SERVICE_NAME ) );
 471             pNames = &seqNames;
 472         }
 473     }
 474     return *pNames;
 475 }
 476
 477 OUString OTextInputStream::getImplementationName() throw()
 478 {
 479     return TextInputStream_getImplementationName();
 480 }
 481
 482 sal_Bool OTextInputStream::supportsService(const OUString& ServiceName) throw()
 483 {
 484     Sequence< OUString > aSNL = getSupportedServiceNames();
 485     const OUString * pArray = aSNL.getConstArray();
 486
 487     for( sal_Int32 i = 0; i < aSNL.getLength(); i++ )
 488         if( pArray[i] == ServiceName )
 489             return sal_True;
 490
 491     return sal_False;
 492 }
 493
 494 Sequence< OUString > OTextInputStream::getSupportedServiceNames(void) throw()
 495 {
 496     return TextInputStream_getSupportedServiceNames();
 497 }
 498
 499 }
 500
 501 using namespace io_TextInputStream;
 502
 503 static struct ImplementationEntry g_entries[] =
 504 {
 505     {
 506         TextInputStream_CreateInstance, TextInputStream_getImplementationName ,
 507         TextInputStream_getSupportedServiceNames, createSingleComponentFactory ,
 508         &g_moduleCount.modCnt , 0
 509     },
 510     { 0, 0, 0, 0, 0, 0 }
 511 };
 512
 513 extern "C"
 514 {
 515 sal_Bool SAL_CALL component_canUnload( TimeValue *pTime )
 516 {
 517     return g_moduleCount.canUnload( &g_moduleCount , pTime );
 518 }
 519
 520 //==================================================================================================
 521 void SAL_CALL component_getImplementationEnvironment(
 522     const sal_Char ** ppEnvTypeName, uno_Environment ** )
 523 {
 524     *ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME;
 525 }
 526 //==================================================================================================
 527 sal_Bool SAL_CALL component_writeInfo(
 528     void * pServiceManager, void * pRegistryKey )
 529 {
 530     return component_writeInfoHelper( pServiceManager, pRegistryKey, g_entries );
 531 }
 532 //==================================================================================================
 533 void * SAL_CALL component_getFactory(
 534     const sal_Char * pImplName, void * pServiceManager, void * pRegistryKey )
 535 {
 536     return component_getFactoryHelper( pImplName, pServiceManager, pRegistryKey , g_entries );
 537 }
 538 }
 539
 540