framework/qa/complex/loadAllDocuments/StreamSimulator.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18 package complex.loadAllDocuments;
  19
  20 import com.sun.star.uno.UnoRuntime;
  21 import com.sun.star.ucb.XSimpleFileAccess;
  22 import com.sun.star.lang.XMultiServiceFactory;
  23
  24 /**
  25  * Simulates an input and output stream and
  26  * implements the interfaces XInputStream, XOutputStream.
  27  * So it can be used for testing loading/saving of documents
  28  * using streams instead of URLs.
  29  */
  30 public class StreamSimulator implements com.sun.star.io.XInputStream    ,
  31                                         com.sun.star.io.XOutputStream   ,
  32                                         com.sun.star.io.XSeekable
  33 {
  34     //_________________________________
  35     /**
  36      * @member  m_sFileName     name of the corrsponding file on disk
  37      * @member  m_xInStream     the internal input stream for reading
  38      * @member  m_xOutStream    the internal input stream for writing
  39      * @member  m_xSeek         points at runtime to m_xInStream or m_xOutStream and make it seekable
  40      *
  41      * @member  m_bInWasUsed    indicates, that the input stream interface was used
  42      * @member  m_bOutWasUsed   indicates, that the output stream interface was used
  43      */
  44
  45     private String                          m_sFileName     ;
  46     private com.sun.star.io.XInputStream    m_xInStream     ;
  47     private com.sun.star.io.XOutputStream   m_xOutStream    ;
  48     private com.sun.star.io.XSeekable       m_xSeek         ;
  49
  50     public  boolean                         m_bInWasUsed    ;
  51     public  boolean                         m_bOutWasUsed   ;
  52
  53     /**
  54      * construct a new instance of this class
  55      * It set the name of the correspojnding file on disk, which
  56      * should be source or target for the following operations on
  57      * this object. And it regulate if it should function as
  58      * input or output stream.
  59      *
  60      * @param   sFileName
  61      *              name of the file on disk
  62      *              Will be used as source (if param bInput==true)
  63      *              or as target (if param bInput==false).
  64      *
  65      * @param   bInput
  66      *              it specify, which interface should work at this object.
  67      *              <TRUE/>  => we simulate an input stream
  68      *              <FALSE/> => we simulate an output stream
  69      *
  70      * @throw   com.sun.star.io.NotConnectedException
  71      *              in case the internal streams to the file on disk couldn't
  72      *              be established.
  73      *              They are neccessary. Otherwhise this simulator can't
  74      *              really work.
  75      */
  76     public StreamSimulator(XMultiServiceFactory xMSF,
  77                             String  sFileName, boolean bInput)
  78                             throws com.sun.star.io.NotConnectedException
  79     {
  80         m_sFileName     = sFileName ;
  81         m_bInWasUsed    = false     ;
  82         m_bOutWasUsed   = false     ;
  83
  84         try
  85         {
  86             XSimpleFileAccess xHelper = UnoRuntime.queryInterface(XSimpleFileAccess.class,
  87             xMSF.createInstance("com.sun.star.ucb.SimpleFileAccess"));
  88
  89             if (xHelper == null)
  90                 throw new com.sun.star.io.NotConnectedException(
  91                         "ucb helper not available. Can't create streams.");
  92
  93             if (bInput)
  94             {
  95                 m_xInStream = xHelper.openFileRead(m_sFileName);
  96                 m_xSeek = UnoRuntime.queryInterface(
  97                             com.sun.star.io.XSeekable.class,
  98                             m_xInStream);
  99             }
 100             else
 101             {
 102                 m_xOutStream = xHelper.openFileWrite(m_sFileName);
 103                 m_xSeek = UnoRuntime.queryInterface(
 104                             com.sun.star.io.XSeekable.class,
 105                             m_xOutStream);
 106             }
 107         }
 108         catch(com.sun.star.uno.Exception exUno)
 109         {
 110             throw new com.sun.star.io.NotConnectedException(
 111                                             "Could not open the file.");
 112         }
 113     }
 114
 115     /**
 116      * following methods simulates the XInputStream.
 117      * The notice all actions inside the internal protocol
 118      * and try to map all neccessary functions to the internal
 119      * open in-stream.
 120      */
 121     public int readBytes(byte[][] lData, int nBytesToRead )
 122                                 throws com.sun.star.io.NotConnectedException,
 123                                 com.sun.star.io.BufferSizeExceededException,
 124                                 com.sun.star.io.IOException
 125     {
 126         m_bInWasUsed = true;
 127
 128         if (m_xInStream == null)
 129         {
 130             throw new com.sun.star.io.NotConnectedException("stream not open");
 131         }
 132
 133         int nRead = 0;
 134         try
 135         {
 136             nRead = m_xInStream.readBytes(lData,nBytesToRead);
 137         }
 138         catch (com.sun.star.io.NotConnectedException       exConnect) {
 139         }
 140         catch (com.sun.star.io.BufferSizeExceededException exBuffer ) {
 141         }
 142         catch (com.sun.star.io.IOException                 exIO     ) {
 143         }
 144         catch (com.sun.star.uno.RuntimeException           exRuntime) {
 145         }
 146
 147
 148         return nRead;
 149     }
 150
 151     public int readSomeBytes(byte[][] lData, int nMaxBytesToRead)
 152                             throws com.sun.star.io.NotConnectedException,
 153                             com.sun.star.io.BufferSizeExceededException ,
 154                             com.sun.star.io.IOException
 155     {
 156         m_bInWasUsed = true;
 157
 158         if (m_xInStream == null)
 159         {
 160             throw new com.sun.star.io.NotConnectedException("stream not open");
 161         }
 162
 163         int nRead = 0;
 164         try
 165         {
 166             nRead = m_xInStream.readSomeBytes(lData,nMaxBytesToRead);
 167         }
 168         catch (com.sun.star.io.NotConnectedException       exConnect) {
 169         }
 170         catch (com.sun.star.io.BufferSizeExceededException exBuffer ) {
 171         }
 172         catch (com.sun.star.io.IOException                 exIO     ) {
 173         }
 174         catch (com.sun.star.uno.RuntimeException           exRuntime) {
 175         }
 176
 177         return nRead;
 178     }
 179
 180     //_________________________________
 181
 182     public void skipBytes(int nBytesToSkip)
 183                                 throws com.sun.star.io.NotConnectedException,
 184                                 com.sun.star.io.BufferSizeExceededException ,
 185                                 com.sun.star.io.IOException
 186     {
 187         m_bInWasUsed = true;
 188
 189         if (m_xInStream == null)
 190         {
 191             throw new com.sun.star.io.NotConnectedException("stream not open");
 192         }
 193
 194         try
 195         {
 196             m_xInStream.skipBytes(nBytesToSkip);
 197         }
 198         catch (com.sun.star.io.NotConnectedException       exConnect) {
 199         }
 200         catch (com.sun.star.io.BufferSizeExceededException exBuffer ) {
 201         }
 202         catch (com.sun.star.io.IOException                 exIO     ) {
 203         }
 204         catch (com.sun.star.uno.RuntimeException           exRuntime) {
 205         }
 206     }
 207
 208     public int available() throws com.sun.star.io.NotConnectedException,
 209                                   com.sun.star.io.IOException
 210     {
 211         m_bInWasUsed = true;
 212
 213         if (m_xInStream == null)
 214         {
 215             throw new com.sun.star.io.NotConnectedException("stream not open");
 216         }
 217
 218         int nAvailable = 0;
 219         try
 220         {
 221             nAvailable = m_xInStream.available();
 222         }
 223         catch (com.sun.star.io.NotConnectedException exConnect) {
 224         }
 225         catch (com.sun.star.io.IOException           exIO     ) {
 226         }
 227         catch (com.sun.star.uno.RuntimeException     exRuntime) {
 228         }
 229
 230         return nAvailable;
 231     }
 232
 233     //_________________________________
 234
 235     public void closeInput() throws com.sun.star.io.NotConnectedException,
 236                                     com.sun.star.io.IOException
 237     {
 238         m_bInWasUsed = true;
 239
 240         if (m_xInStream == null)
 241         {
 242             throw new com.sun.star.io.NotConnectedException("stream not open");
 243         }
 244
 245         try
 246         {
 247             m_xInStream.closeInput();
 248         }
 249         catch (com.sun.star.io.NotConnectedException exConnect) {
 250         }
 251         catch (com.sun.star.io.IOException           exIO     ) {
 252         }
 253         catch (com.sun.star.uno.RuntimeException     exRuntime) {
 254         }
 255     }
 256
 257     /**
 258      * following methods simulates the XOutputStream.
 259      * The notice all actions inside the internal protocol
 260      * and try to map all neccessary functions to the internal
 261      * open out-stream.
 262      */
 263     public void writeBytes(byte[] lData)
 264                                 throws com.sun.star.io.NotConnectedException,
 265                                 com.sun.star.io.BufferSizeExceededException ,
 266                                 com.sun.star.io.IOException
 267     {
 268         m_bOutWasUsed = true;
 269
 270         if (m_xOutStream == null)
 271         {
 272             throw new com.sun.star.io.NotConnectedException("stream not open");
 273         }
 274
 275         try
 276         {
 277             m_xOutStream.writeBytes(lData);
 278         }
 279         catch (com.sun.star.io.NotConnectedException       exConnect) {
 280         }
 281         catch (com.sun.star.io.BufferSizeExceededException exBuffer ) {
 282         }
 283         catch (com.sun.star.io.IOException                 exIO     ) {
 284         }
 285         catch (com.sun.star.uno.RuntimeException           exRuntime) {
 286         }
 287
 288     }
 289
 290     //_________________________________
 291
 292     public void flush() throws com.sun.star.io.NotConnectedException        ,
 293                                com.sun.star.io.BufferSizeExceededException  ,
 294                                com.sun.star.io.IOException
 295     {
 296         m_bOutWasUsed = true;
 297
 298         if (m_xOutStream == null)
 299         {
 300             throw new com.sun.star.io.NotConnectedException("stream not open");
 301         }
 302
 303         try
 304         {
 305             m_xOutStream.flush();
 306         }
 307         catch (com.sun.star.io.NotConnectedException       exConnect) {
 308         }
 309         catch (com.sun.star.io.BufferSizeExceededException exBuffer ) {
 310         }
 311         catch (com.sun.star.io.IOException                 exIO     ) {
 312         }
 313         catch (com.sun.star.uno.RuntimeException           exRuntime) {
 314         }
 315     }
 316
 317     //_________________________________
 318
 319     public void closeOutput() throws com.sun.star.io.NotConnectedException      ,
 320                                      com.sun.star.io.BufferSizeExceededException,
 321                                      com.sun.star.io.IOException
 322     {
 323         m_bOutWasUsed = true;
 324
 325         if (m_xOutStream == null)
 326         {
 327             throw new com.sun.star.io.NotConnectedException("stream not open");
 328         }
 329
 330         try
 331         {
 332             m_xOutStream.closeOutput();
 333         }
 334         catch (com.sun.star.io.NotConnectedException       exConnect) {
 335         }
 336         catch (com.sun.star.io.BufferSizeExceededException exBuffer ) {
 337         }
 338         catch (com.sun.star.io.IOException                 exIO     ) {
 339         }
 340         catch (com.sun.star.uno.RuntimeException           exRuntime) {
 341         }
 342     }
 343
 344     /**
 345      * following methods simulates the XSeekable.
 346      * The notice all actions inside the internal protocol
 347      * and try to map all neccessary functions to the internal
 348      * open stream.
 349      */
 350     public void seek(long nLocation )
 351                     throws com.sun.star.lang.IllegalArgumentException,
 352                     com.sun.star.io.IOException
 353     {
 354         if (m_xInStream != null)
 355             m_bInWasUsed = true;
 356         else
 357         if (m_xOutStream != null)
 358             m_bOutWasUsed = true;
 359
 360         if (m_xSeek == null)
 361         {
 362             throw new com.sun.star.io.IOException("stream not seekable");
 363         }
 364
 365         try
 366         {
 367             m_xSeek.seek(nLocation);
 368         }
 369         catch (com.sun.star.lang.IllegalArgumentException exArg    ) {
 370         }
 371         catch (com.sun.star.io.IOException                exIO     ) {
 372         }
 373         catch (com.sun.star.uno.RuntimeException          exRuntime) {
 374         }
 375     }
 376
 377     public long getPosition() throws com.sun.star.io.IOException
 378     {
 379
 380         if (m_xInStream != null)
 381             m_bInWasUsed = true;
 382         else
 383         if (m_xOutStream != null)
 384             m_bOutWasUsed = true;
 385
 386         if (m_xSeek == null)
 387         {
 388             throw new com.sun.star.io.IOException("stream not seekable");
 389         }
 390
 391         long nPos = 0;
 392         try
 393         {
 394             nPos = m_xSeek.getPosition();
 395         }
 396         catch (com.sun.star.io.IOException       exIO     ) {
 397         }
 398         catch (com.sun.star.uno.RuntimeException exRuntime) {
 399         }
 400
 401         return nPos;
 402     }
 403
 404     //_________________________________
 405
 406     public long getLength() throws com.sun.star.io.IOException
 407     {
 408
 409         if (m_xInStream != null)
 410             m_bInWasUsed = true;
 411         else
 412         if (m_xOutStream != null)
 413             m_bOutWasUsed = true;
 414
 415         if (m_xSeek == null)
 416         {
 417             throw new com.sun.star.io.IOException("stream not seekable");
 418         }
 419
 420         long nLen = 0;
 421         try
 422         {
 423             nLen = m_xSeek.getLength();
 424         }
 425         catch (com.sun.star.io.IOException       exIO     ) {
 426         }
 427         catch (com.sun.star.uno.RuntimeException exRuntime) {
 428         }
 429
 430         return nLen;
 431     }
 432 }