io/source/stm/odata.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 <string.h>
  21 #include <unordered_map>
  22 #include <vector>
  23
  24 #include <cppuhelper/weak.hxx>
  25 #include <cppuhelper/implbase.hxx>
  26 #include <cppuhelper/supportsservice.hxx>
  27 #include <osl/endian.h>
  28
  29 #include <com/sun/star/io/NotConnectedException.hpp>
  30 #include <com/sun/star/io/XObjectInputStream.hpp>
  31 #include <com/sun/star/io/XObjectOutputStream.hpp>
  32 #include <com/sun/star/io/XActiveDataSource.hpp>
  33 #include <com/sun/star/io/XActiveDataSink.hpp>
  34 #include <com/sun/star/io/XMarkableStream.hpp>
  35 #include <com/sun/star/io/XConnectable.hpp>
  36 #include <com/sun/star/io/UnexpectedEOFException.hpp>
  37 #include <com/sun/star/io/WrongFormatException.hpp>
  38 #include <com/sun/star/lang/XServiceInfo.hpp>
  39 #include <com/sun/star/uno/XComponentContext.hpp>
  40
  41 using namespace ::cppu;
  42 using namespace ::osl;
  43 using namespace ::std;
  44 using namespace ::com::sun::star::io;
  45 using namespace ::com::sun::star::uno;
  46 using namespace ::com::sun::star::lang;
  47
  48 namespace io_stm {
  49
  50 namespace {
  51
  52 class ODataInputStream :
  53     public WeakImplHelper <
  54                               XDataInputStream,
  55                               XActiveDataSink,
  56                               XConnectable,
  57                               XServiceInfo
  58                            >
  59 {
  60 public:
  61     ODataInputStream( )
  62         : m_bValidStream( false )
  63         {
  64         }
  65
  66 public: // XInputStream
  67     virtual sal_Int32 SAL_CALL readBytes(Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead) override;
  68     virtual sal_Int32 SAL_CALL readSomeBytes(Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead) override;
  69     virtual void SAL_CALL skipBytes(sal_Int32 nBytesToSkip) override;
  70     virtual sal_Int32 SAL_CALL available() override;
  71     virtual void SAL_CALL closeInput() override;
  72
  73 public: // XDataInputStream
  74     virtual sal_Int8 SAL_CALL readBoolean() override;
  75     virtual sal_Int8 SAL_CALL readByte() override;
  76     virtual sal_Unicode SAL_CALL readChar() override;
  77     virtual sal_Int16 SAL_CALL readShort() override;
  78     virtual sal_Int32 SAL_CALL readLong() override;
  79     virtual sal_Int64 SAL_CALL readHyper() override;
  80     virtual float SAL_CALL readFloat() override;
  81     virtual double SAL_CALL readDouble() override;
  82     virtual OUString SAL_CALL readUTF() override;
  83
  84
  85 public: // XActiveDataSink
  86     virtual void SAL_CALL setInputStream(const Reference< XInputStream > & aStream) override;
  87     virtual Reference< XInputStream > SAL_CALL getInputStream() override;
  88
  89 public: // XConnectable
  90     virtual void SAL_CALL setPredecessor(const Reference < XConnectable >& aPredecessor) override;
  91     virtual Reference < XConnectable > SAL_CALL getPredecessor() override;
  92     virtual void SAL_CALL setSuccessor(const Reference < XConnectable >& aSuccessor) override;
  93     virtual Reference < XConnectable > SAL_CALL getSuccessor() override ;
  94
  95
  96 public: // XServiceInfo
  97     OUString                     SAL_CALL getImplementationName() override;
  98     Sequence< OUString >         SAL_CALL getSupportedServiceNames() override;
  99     sal_Bool                        SAL_CALL supportsService(const OUString& ServiceName) override;
 100
 101 protected:
 102
 103     Reference < XConnectable >  m_pred;
 104     Reference < XConnectable >  m_succ;
 105     Reference < XInputStream >  m_input;
 106     bool m_bValidStream;
 107 };
 108
 109 }
 110
 111 // XInputStream
 112 sal_Int32 ODataInputStream::readBytes(Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead)
 113 {
 114      if( !m_bValidStream )
 115      {
 116          throw NotConnectedException( );
 117      }
 118      sal_Int32 nRead = m_input->readBytes( aData , nBytesToRead );
 119      return nRead;
 120 }
 121
 122 sal_Int32 ODataInputStream::readSomeBytes(Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead)
 123 {
 124      if( !m_bValidStream )
 125          throw NotConnectedException( );
 126      sal_Int32 nRead = m_input->readSomeBytes( aData , nMaxBytesToRead );
 127      return nRead;
 128 }
 129 void ODataInputStream::skipBytes(sal_Int32 nBytesToSkip)
 130 {
 131      if( !m_bValidStream )
 132          throw NotConnectedException( );
 133      m_input->skipBytes( nBytesToSkip );
 134 }
 135
 136
 137 sal_Int32 ODataInputStream::available()
 138 {
 139      if( !m_bValidStream )
 140          throw NotConnectedException( );
 141      sal_Int32 nAvail = m_input->available( );
 142      return nAvail;
 143 }
 144
 145 void ODataInputStream::closeInput()
 146 {
 147      if( !m_bValidStream )
 148          throw NotConnectedException( );
 149      m_input->closeInput( );
 150      setInputStream( Reference< XInputStream > () );
 151      setPredecessor( Reference < XConnectable >() );
 152      setSuccessor( Reference < XConnectable >() );
 153      m_bValidStream = false;
 154 }
 155
 156
 157 //== XDataInputStream ===========================================
 158
 159 // XDataInputStream
 160 sal_Int8 ODataInputStream::readBoolean()
 161 {
 162     return readByte();
 163 }
 164
 165 sal_Int8 ODataInputStream::readByte()
 166 {
 167     Sequence<sal_Int8> aTmp(1);
 168     if( 1 != readBytes( aTmp, 1 ) )
 169     {
 170         throw UnexpectedEOFException();
 171     }
 172     return aTmp.getConstArray()[0];
 173 }
 174
 175 sal_Unicode ODataInputStream::readChar()
 176 {
 177     Sequence<sal_Int8> aTmp(2);
 178     if( 2 != readBytes( aTmp, 2 ) )
 179     {
 180         throw UnexpectedEOFException();
 181     }
 182
 183     const sal_uInt8 * pBytes = reinterpret_cast<const sal_uInt8 *>(aTmp.getConstArray());
 184     return (static_cast<sal_Unicode>(pBytes[0]) << 8) + pBytes[1];
 185 }
 186
 187 sal_Int16 ODataInputStream::readShort()
 188 {
 189     Sequence<sal_Int8> aTmp(2);
 190     if( 2 != readBytes( aTmp, 2 ) )
 191     {
 192         throw UnexpectedEOFException();
 193     }
 194
 195     const sal_uInt8 * pBytes = reinterpret_cast<const sal_uInt8 *>(aTmp.getConstArray());
 196     return (static_cast<sal_Int16>(pBytes[0]) << 8) + pBytes[1];
 197 }
 198
 199
 200 sal_Int32 ODataInputStream::readLong()
 201 {
 202     Sequence<sal_Int8> aTmp(4);
 203     if( 4 != readBytes( aTmp, 4 ) )
 204     {
 205         throw UnexpectedEOFException( );
 206     }
 207
 208     const sal_uInt8 * pBytes = reinterpret_cast<const sal_uInt8 *>(aTmp.getConstArray());
 209     return (static_cast<sal_Int32>(pBytes[0]) << 24) + (static_cast<sal_Int32>(pBytes[1]) << 16) + (static_cast<sal_Int32>(pBytes[2]) << 8) + pBytes[3];
 210 }
 211
 212
 213 sal_Int64 ODataInputStream::readHyper()
 214 {
 215     Sequence<sal_Int8> aTmp(8);
 216     if( 8 != readBytes( aTmp, 8 ) )
 217     {
 218         throw UnexpectedEOFException( );
 219     }
 220
 221     const sal_uInt8 * pBytes = reinterpret_cast<const sal_uInt8 *>(aTmp.getConstArray());
 222     return
 223         (static_cast<sal_Int64>(pBytes[0]) << 56) +
 224         (static_cast<sal_Int64>(pBytes[1]) << 48) +
 225         (static_cast<sal_Int64>(pBytes[2]) << 40) +
 226         (static_cast<sal_Int64>(pBytes[3]) << 32) +
 227         (static_cast<sal_Int64>(pBytes[4]) << 24) +
 228         (static_cast<sal_Int64>(pBytes[5]) << 16) +
 229         (static_cast<sal_Int64>(pBytes[6]) << 8) +
 230         pBytes[7];
 231 }
 232
 233 float ODataInputStream::readFloat()
 234 {
 235     union { float f; sal_uInt32 n; } a;
 236     a.n = readLong();
 237     return a.f;
 238 }
 239
 240 double ODataInputStream::readDouble()
 241 {
 242     union { double d; struct { sal_uInt32 n1; sal_uInt32 n2; } ad; } a;
 243 #if defined OSL_LITENDIAN
 244     a.ad.n2 = readLong();
 245     a.ad.n1 = readLong();
 246 #else
 247     a.ad.n1 = readLong();
 248     a.ad.n2 = readLong();
 249 #endif
 250     return a.d;
 251 }
 252
 253 OUString ODataInputStream::readUTF()
 254 {
 255     sal_uInt16              nShortLen = static_cast<sal_uInt16>(readShort());
 256     sal_Int32               nUTFLen;
 257
 258     if( (sal_uInt16(0xffff)) == nShortLen )
 259     {
 260         // is interpreted as a sign, that string is longer than 64k
 261         // incompatible to older XDataInputStream-routines, when strings are exactly 64k
 262         nUTFLen = readLong();
 263     }
 264     else
 265     {
 266         nUTFLen = static_cast<sal_Int32>(nShortLen);
 267     }
 268
 269     Sequence<sal_Unicode>   aBuffer( nUTFLen );
 270     sal_Unicode *           pStr = aBuffer.getArray();
 271
 272     sal_Int32 nCount = 0;
 273     sal_Int32 nStrLen = 0;
 274     while( nCount < nUTFLen )
 275     {
 276         sal_uInt8 c = static_cast<sal_uInt8>(readByte());
 277         sal_uInt8 char2, char3;
 278         switch( c >> 4 )
 279         {
 280             case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
 281                 // 0xxxxxxx
 282                 nCount++;
 283                 pStr[nStrLen++] = c;
 284                 break;
 285
 286             case 12: case 13:
 287                 // 110x xxxx   10xx xxxx
 288                 nCount += 2;
 289                 if( nCount > nUTFLen )
 290                 {
 291                     throw WrongFormatException( );
 292                 }
 293
 294                 char2 = static_cast<sal_uInt8>(readByte());
 295                 if( (char2 & 0xC0) != 0x80 )
 296                 {
 297                     throw WrongFormatException( );
 298                 }
 299
 300                 pStr[nStrLen++] = (sal_Unicode(c & 0x1F) << 6) | (char2 & 0x3F);
 301                 break;
 302
 303             case 14:
 304             // 1110 xxxx  10xx xxxx  10xx xxxx
 305                 nCount += 3;
 306                 if( nCount > nUTFLen )
 307                 {
 308                     throw WrongFormatException( );
 309                 }
 310
 311                 char2 = static_cast<sal_uInt8>(readByte());
 312                 char3 = static_cast<sal_uInt8>(readByte());
 313
 314                 if( ((char2 & 0xC0) != 0x80) || ((char3 & 0xC0) != 0x80) ) {
 315                     throw WrongFormatException( );
 316                 }
 317                 pStr[nStrLen++] = (sal_Unicode(c & 0x0F) << 12) |
 318                                 (sal_Unicode(char2 & 0x3F) << 6) |
 319                                 (char3 & 0x3F);
 320                 break;
 321
 322             default:
 323                 // 10xx xxxx,  1111 xxxx
 324                 throw WrongFormatException();
 325                 //throw new UTFDataFormatException();
 326         }
 327     }
 328     return OUString( pStr, nStrLen );
 329 }
 330
 331
 332 // XActiveDataSource
 333 void ODataInputStream::setInputStream(const Reference< XInputStream > & aStream)
 334 {
 335
 336     if( m_input != aStream ) {
 337         m_input = aStream;
 338
 339         Reference < XConnectable > pred( m_input , UNO_QUERY );
 340         setPredecessor( pred );
 341     }
 342
 343     m_bValidStream = m_input.is();
 344 }
 345
 346 Reference< XInputStream > ODataInputStream::getInputStream()
 347 {
 348     return m_input;
 349 }
 350
 351
 352 // XDataSink
 353 void ODataInputStream::setSuccessor( const Reference < XConnectable > &r )
 354 {
 355      /// if the references match, nothing needs to be done
 356      if( m_succ != r ) {
 357          /// store the reference for later use
 358          m_succ = r;
 359
 360          if( m_succ.is() ) {
 361               /// set this instance as the sink !
 362               m_succ->setPredecessor( Reference< XConnectable > (
 363                   static_cast< XConnectable * >(this) ) );
 364          }
 365      }
 366 }
 367
 368 Reference < XConnectable > ODataInputStream::getSuccessor()
 369 {
 370     return m_succ;
 371 }
 372
 373
 374 // XDataSource
 375 void ODataInputStream::setPredecessor( const Reference < XConnectable > &r )
 376 {
 377     if( r != m_pred ) {
 378         m_pred = r;
 379         if( m_pred.is() ) {
 380             m_pred->setSuccessor( Reference< XConnectable > (
 381                 static_cast< XConnectable * >(this) ) );
 382         }
 383     }
 384 }
 385 Reference < XConnectable > ODataInputStream::getPredecessor()
 386 {
 387     return m_pred;
 388 }
 389
 390 // XServiceInfo
 391 OUString ODataInputStream::getImplementationName()
 392 {
 393     return "com.sun.star.comp.io.stm.DataInputStream";
 394 }
 395
 396 // XServiceInfo
 397 sal_Bool ODataInputStream::supportsService(const OUString& ServiceName)
 398 {
 399     return cppu::supportsService(this, ServiceName);
 400 }
 401
 402 // XServiceInfo
 403 Sequence< OUString > ODataInputStream::getSupportedServiceNames()
 404 {
 405     return { "com.sun.star.io.DataInputStream" };
 406 }
 407
 408 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 409 io_ODataInputStream_get_implementation(
 410     css::uno::XComponentContext* , css::uno::Sequence<css::uno::Any> const&)
 411 {
 412     return cppu::acquire(new ODataInputStream());
 413 }
 414
 415 namespace {
 416
 417 class ODataOutputStream :
 418     public WeakImplHelper <
 419              XDataOutputStream,
 420              XActiveDataSource,
 421              XConnectable,
 422               XServiceInfo >
 423 {
 424 public:
 425     ODataOutputStream()
 426         : m_bValidStream( false )
 427         {
 428         }
 429
 430 public: // XOutputStream
 431     virtual void SAL_CALL writeBytes(const Sequence< sal_Int8 >& aData) override;
 432     virtual void SAL_CALL flush() override;
 433     virtual void SAL_CALL closeOutput() override;
 434
 435 public: // XDataOutputStream
 436     virtual void SAL_CALL writeBoolean(sal_Bool Value) override;
 437     virtual void SAL_CALL writeByte(sal_Int8 Value) override;
 438     virtual void SAL_CALL writeChar(sal_Unicode Value) override;
 439     virtual void SAL_CALL writeShort(sal_Int16 Value) override;
 440     virtual void SAL_CALL writeLong(sal_Int32 Value) override;
 441     virtual void SAL_CALL writeHyper(sal_Int64 Value) override;
 442     virtual void SAL_CALL writeFloat(float Value) override;
 443     virtual void SAL_CALL writeDouble(double Value) override;
 444     virtual void SAL_CALL writeUTF(const OUString& Value) override;
 445
 446 public: // XActiveDataSource
 447     virtual void SAL_CALL setOutputStream(const Reference< XOutputStream > & aStream) override;
 448     virtual Reference < XOutputStream > SAL_CALL getOutputStream() override;
 449
 450 public: // XConnectable
 451     virtual void SAL_CALL setPredecessor(const Reference < XConnectable >& aPredecessor) override;
 452     virtual Reference < XConnectable > SAL_CALL getPredecessor() override;
 453     virtual void SAL_CALL setSuccessor(const Reference < XConnectable >& aSuccessor) override;
 454     virtual Reference < XConnectable > SAL_CALL getSuccessor() override;
 455
 456 public: // XServiceInfo
 457     OUString                     SAL_CALL getImplementationName() override;
 458     Sequence< OUString >         SAL_CALL getSupportedServiceNames() override;
 459     sal_Bool                     SAL_CALL supportsService(const OUString& ServiceName) override;
 460
 461 protected:
 462     Reference < XConnectable >  m_succ;
 463     Reference < XConnectable >  m_pred;
 464     Reference<  XOutputStream > m_output;
 465     bool m_bValidStream;
 466 };
 467
 468 }
 469
 470 // XOutputStream
 471 void ODataOutputStream::writeBytes(const Sequence< sal_Int8 >& aData)
 472 {
 473     if( !m_bValidStream )
 474         throw NotConnectedException( );
 475     m_output->writeBytes( aData );
 476 }
 477
 478 void ODataOutputStream::flush()
 479 {
 480     if( !m_bValidStream )
 481         throw NotConnectedException();
 482     m_output->flush();
 483 }
 484
 485
 486 void ODataOutputStream::closeOutput()
 487 {
 488     if( !m_bValidStream )
 489         throw NotConnectedException();
 490     m_output->closeOutput();
 491     setOutputStream( Reference< XOutputStream > () );
 492     setPredecessor( Reference < XConnectable >() );
 493     setSuccessor( Reference < XConnectable >() );
 494 }
 495
 496 // XDataOutputStream
 497 void ODataOutputStream::writeBoolean(sal_Bool Value)
 498 {
 499     if( Value )
 500     {
 501         writeByte( 1 );
 502     }
 503     else
 504     {
 505         writeByte( 0 );
 506     }
 507 }
 508
 509
 510 void ODataOutputStream::writeByte(sal_Int8 Value)
 511 {
 512     writeBytes( { Value } );
 513 }
 514
 515 void ODataOutputStream::writeChar(sal_Unicode Value)
 516 {
 517     writeBytes( { sal_Int8(Value >> 8),
 518                   sal_Int8(Value) } );
 519 }
 520
 521
 522 void ODataOutputStream::writeShort(sal_Int16 Value)
 523 {
 524     writeBytes( { sal_Int8(Value >> 8),
 525                   sal_Int8(Value) } );
 526 }
 527
 528 void ODataOutputStream::writeLong(sal_Int32 Value)
 529 {
 530     writeBytes( { sal_Int8(Value >> 24),
 531                   sal_Int8(Value >> 16),
 532                   sal_Int8(Value >> 8),
 533                   sal_Int8(Value) } );
 534 }
 535
 536 void ODataOutputStream::writeHyper(sal_Int64 Value)
 537 {
 538     writeBytes( { sal_Int8(Value >> 56),
 539                   sal_Int8(Value >> 48),
 540                   sal_Int8(Value >> 40),
 541                   sal_Int8(Value >> 32),
 542                   sal_Int8(Value >> 24),
 543                   sal_Int8(Value >> 16),
 544                   sal_Int8(Value >> 8),
 545                   sal_Int8(Value) } );
 546 }
 547
 548
 549 void ODataOutputStream::writeFloat(float Value)
 550 {
 551     union { float f; sal_uInt32 n; } a;
 552     a.f = Value;
 553     writeLong( a.n );
 554 }
 555
 556 void ODataOutputStream::writeDouble(double Value)
 557 {
 558     union { double d; struct { sal_uInt32 n1; sal_uInt32 n2; } ad; } a;
 559     a.d = Value;
 560 #if defined OSL_LITENDIAN
 561     writeLong( a.ad.n2 );
 562     writeLong( a.ad.n1 );
 563 #else
 564     writeLong( a.ad.n1 );
 565     writeLong( a.ad.n2 );
 566 #endif
 567 }
 568
 569 void ODataOutputStream::writeUTF(const OUString& Value)
 570 {
 571     sal_Int32 nStrLen = Value.getLength();
 572     const sal_Unicode * pStr = Value.getStr();
 573     sal_Int32 nUTFLen = 0;
 574     sal_Int32 i;
 575
 576     for( i = 0 ; i < nStrLen ; i++ )
 577     {
 578         sal_uInt16 c = pStr[i];
 579         if( (c >= 0x0001) && (c <= 0x007F) )
 580         {
 581             nUTFLen++;
 582         }
 583         else if( c > 0x07FF )
 584         {
 585             nUTFLen += 3;
 586         }
 587         else
 588         {
 589             nUTFLen += 2;
 590         }
 591     }
 592
 593
 594     // compatibility mode for older implementations, where it was not possible
 595     // to write blocks bigger than 64 k. Note that there is a tradeoff. Blocks,
 596     // that are exactly 64k long can not be read by older routines when written
 597     // with these routines and the other way round !!!!!
 598     if( nUTFLen >= 0xFFFF ) {
 599         writeShort( sal_Int16(-1) );
 600         writeLong( nUTFLen );
 601     }
 602     else {
 603         writeShort( static_cast<sal_uInt16>(nUTFLen) );
 604     }
 605     for( i = 0 ; i < nStrLen ; i++ )
 606     {
 607         sal_uInt16 c = pStr[i];
 608         if( (c >= 0x0001) && (c <= 0x007F) )
 609         {
 610             writeByte(sal_Int8(c));
 611         }
 612         else if( c > 0x07FF )
 613         {
 614             writeByte(sal_Int8(0xE0 | ((c >> 12) & 0x0F)));
 615             writeByte(sal_Int8(0x80 | ((c >>  6) & 0x3F)));
 616             writeByte(sal_Int8(0x80 | ((c >>  0) & 0x3F)));
 617         }
 618         else
 619         {
 620             writeByte(sal_Int8(0xC0 | ((c >>  6) & 0x1F)));
 621             writeByte(sal_Int8(0x80 | ((c >>  0) & 0x3F)));
 622         }
 623     }
 624 }
 625
 626 // XActiveDataSource
 627 void ODataOutputStream::setOutputStream(const Reference< XOutputStream > & aStream)
 628 {
 629     if( m_output != aStream ) {
 630         m_output = aStream;
 631         m_bValidStream = m_output.is();
 632
 633         Reference < XConnectable > succ( m_output , UNO_QUERY );
 634         setSuccessor( succ );
 635     }
 636 }
 637
 638 Reference< XOutputStream > ODataOutputStream::getOutputStream()
 639 {
 640     return m_output;
 641 }
 642
 643
 644 // XDataSink
 645 void ODataOutputStream::setSuccessor( const Reference < XConnectable > &r )
 646 {
 647      /// if the references match, nothing needs to be done
 648      if( m_succ != r )
 649      {
 650          /// store the reference for later use
 651          m_succ = r;
 652
 653          if( m_succ.is() )
 654          {
 655               /// set this instance as the sink !
 656               m_succ->setPredecessor( Reference < XConnectable > (
 657                   static_cast< XConnectable * >(this) ));
 658          }
 659      }
 660 }
 661 Reference < XConnectable > ODataOutputStream::getSuccessor()
 662 {
 663     return m_succ;
 664 }
 665
 666
 667 // XDataSource
 668 void ODataOutputStream::setPredecessor( const Reference < XConnectable > &r )
 669 {
 670     if( r != m_pred ) {
 671         m_pred = r;
 672         if( m_pred.is() ) {
 673             m_pred->setSuccessor( Reference< XConnectable > (
 674                 static_cast< XConnectable * >(this) ));
 675         }
 676     }
 677 }
 678 Reference < XConnectable > ODataOutputStream::getPredecessor()
 679 {
 680     return m_pred;
 681 }
 682
 683
 684 // XServiceInfo
 685 OUString ODataOutputStream::getImplementationName()
 686 {
 687     return "com.sun.star.comp.io.stm.DataOutputStream";
 688 }
 689
 690 // XServiceInfo
 691 sal_Bool ODataOutputStream::supportsService(const OUString& ServiceName)
 692 {
 693     return cppu::supportsService(this, ServiceName);
 694 }
 695
 696 // XServiceInfo
 697 Sequence< OUString > ODataOutputStream::getSupportedServiceNames()
 698 {
 699     return { "com.sun.star.io.DataOutputStream" };
 700 }
 701
 702 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 703 io_ODataOutputStream_get_implementation(
 704     css::uno::XComponentContext* , css::uno::Sequence<css::uno::Any> const&)
 705 {
 706     return cppu::acquire(new ODataOutputStream());
 707 }
 708
 709 namespace {
 710
 711 struct equalObjectContainer_Impl
 712 {
 713     bool operator()(const Reference< XInterface > & s1,
 714                          const Reference< XInterface > & s2) const
 715       {
 716         return s1 == s2;
 717     }
 718 };
 719
 720
 721 struct hashObjectContainer_Impl
 722 {
 723     size_t operator()(const Reference< XInterface > & xRef) const
 724     {
 725         return reinterpret_cast<size_t>(xRef.get());
 726     }
 727 };
 728
 729 }
 730
 731 typedef std::unordered_map
 732 <
 733     Reference< XInterface >,
 734     sal_Int32,
 735     hashObjectContainer_Impl,
 736     equalObjectContainer_Impl
 737 > ObjectContainer_Impl;
 738
 739 namespace {
 740
 741 class OObjectOutputStream:
 742     public ImplInheritanceHelper<
 743             ODataOutputStream, /* parent */
 744             XObjectOutputStream, XMarkableStream >
 745 {
 746 public:
 747     OObjectOutputStream()
 748         : m_nMaxId(0) ,
 749           m_bValidMarkable(false)
 750         {
 751         }
 752
 753 public:
 754     // XOutputStream
 755     virtual void SAL_CALL writeBytes(const Sequence< sal_Int8 >& aData) override
 756         { ODataOutputStream::writeBytes( aData ); }
 757
 758     virtual void SAL_CALL flush() override
 759         { ODataOutputStream::flush(); }
 760
 761     virtual void SAL_CALL closeOutput() override
 762         { ODataOutputStream::closeOutput(); }
 763
 764 public:
 765     // XDataOutputStream
 766     virtual void SAL_CALL writeBoolean(sal_Bool Value) override
 767                 { ODataOutputStream::writeBoolean( Value ); }
 768     virtual void SAL_CALL writeByte(sal_Int8 Value) override
 769                 { ODataOutputStream::writeByte( Value ); }
 770     virtual void SAL_CALL writeChar(sal_Unicode Value) override
 771                 { ODataOutputStream::writeChar( Value ); }
 772     virtual void SAL_CALL writeShort(sal_Int16 Value) override
 773                 { ODataOutputStream::writeShort( Value ); }
 774     virtual void SAL_CALL writeLong(sal_Int32 Value) override
 775                 { ODataOutputStream::writeLong( Value ); }
 776     virtual void SAL_CALL writeHyper(sal_Int64 Value) override
 777                 { ODataOutputStream::writeHyper( Value ); }
 778     virtual void SAL_CALL writeFloat(float Value) override
 779                 { ODataOutputStream::writeFloat( Value ); }
 780     virtual void SAL_CALL writeDouble(double Value) override
 781                 { ODataOutputStream::writeDouble( Value ); }
 782     virtual void SAL_CALL writeUTF(const OUString& Value) override
 783                 { ODataOutputStream::writeUTF( Value );}
 784
 785     // XObjectOutputStream
 786         virtual void SAL_CALL writeObject( const Reference< XPersistObject > & r ) override;
 787
 788 public: // XMarkableStream
 789     virtual sal_Int32 SAL_CALL createMark() override;
 790     virtual void SAL_CALL deleteMark(sal_Int32 Mark) override;
 791     virtual void SAL_CALL jumpToMark(sal_Int32 nMark) override;
 792     virtual void SAL_CALL jumpToFurthest() override;
 793     virtual sal_Int32 SAL_CALL offsetToMark(sal_Int32 nMark) override;
 794
 795 public: // XServiceInfo
 796     OUString                   SAL_CALL   getImplementationName() override;
 797     Sequence< OUString >       SAL_CALL   getSupportedServiceNames() override;
 798     sal_Bool                   SAL_CALL   supportsService(const OUString& ServiceName) override;
 799
 800 private:
 801     void connectToMarkable();
 802 private:
 803     ObjectContainer_Impl                m_mapObject;
 804     sal_Int32                           m_nMaxId;
 805     Reference< XMarkableStream >        m_rMarkable;
 806     bool                            m_bValidMarkable;
 807 };
 808
 809 }
 810
 811 void OObjectOutputStream::writeObject( const Reference< XPersistObject > & xPObj )
 812 {
 813
 814     connectToMarkable();
 815     bool bWriteObj = false;
 816     // create Mark to write length of info
 817     sal_uInt32 nInfoLenMark = m_rMarkable->createMark();
 818
 819     // length of the info data (is later rewritten)
 820     OObjectOutputStream::writeShort( 0 );
 821
 822     // write the object identifier
 823     if( xPObj.is() )
 824     {
 825         Reference< XInterface > rX( xPObj , UNO_QUERY );
 826
 827         ObjectContainer_Impl::const_iterator aIt
 828             = m_mapObject.find( rX );
 829         if( aIt == m_mapObject.end() )
 830         {
 831             // insert new object in hash table
 832             m_mapObject[ rX ] = ++m_nMaxId;
 833             ODataOutputStream::writeLong( m_nMaxId );
 834             ODataOutputStream::writeUTF( xPObj->getServiceName() );
 835             bWriteObj = true;
 836         }
 837         else
 838         {
 839             ODataOutputStream::writeLong( (*aIt).second );
 840             ODataOutputStream::writeUTF( OUString() );
 841         }
 842     }
 843     else
 844     {
 845         ODataOutputStream::writeLong( 0 );
 846         ODataOutputStream::writeUTF( OUString() );
 847     }
 848
 849     sal_uInt32 nObjLenMark = m_rMarkable->createMark();
 850     ODataOutputStream::writeLong( 0 );
 851
 852     sal_Int32 nInfoLen = m_rMarkable->offsetToMark( nInfoLenMark );
 853     m_rMarkable->jumpToMark( nInfoLenMark );
 854     // write length of the info data
 855     ODataOutputStream::writeShort( static_cast<sal_Int16>(nInfoLen) );
 856     // jump to the end of the stream
 857     m_rMarkable->jumpToFurthest();
 858
 859     if( bWriteObj )
 860         xPObj->write( Reference< XObjectOutputStream > (
 861             static_cast< XObjectOutputStream *  >(this) ) );
 862
 863     sal_Int32 nObjLen = m_rMarkable->offsetToMark( nObjLenMark ) -4;
 864     m_rMarkable->jumpToMark( nObjLenMark );
 865     // write length of the info data
 866     ODataOutputStream::writeLong( nObjLen );
 867     // jump to the end of the stream
 868     m_rMarkable->jumpToFurthest();
 869
 870     m_rMarkable->deleteMark( nObjLenMark );
 871     m_rMarkable->deleteMark( nInfoLenMark );
 872 }
 873
 874
 875 void OObjectOutputStream::connectToMarkable()
 876 {
 877     if(  m_bValidMarkable )
 878         return;
 879
 880     if( ! m_bValidStream )
 881         throw NotConnectedException();
 882
 883     // find the markable stream !
 884     Reference< XInterface > rTry(m_output);
 885     while( true ) {
 886         if( ! rTry.is() )
 887         {
 888             throw NotConnectedException();
 889         }
 890         Reference < XMarkableStream > markable( rTry , UNO_QUERY );
 891         if( markable.is() )
 892         {
 893             m_rMarkable = markable;
 894             break;
 895         }
 896         Reference < XActiveDataSource > source( rTry , UNO_QUERY );
 897         rTry = source;
 898     }
 899     m_bValidMarkable = true;
 900 }
 901
 902
 903 sal_Int32 OObjectOutputStream::createMark()
 904 {
 905     connectToMarkable();    // throws an exception, if a markable is not connected !
 906
 907     return m_rMarkable->createMark();
 908 }
 909
 910 void OObjectOutputStream::deleteMark(sal_Int32 Mark)
 911 {
 912     if( ! m_bValidMarkable )
 913     {
 914         throw NotConnectedException();
 915     }
 916     m_rMarkable->deleteMark( Mark );
 917 }
 918
 919 void OObjectOutputStream::jumpToMark(sal_Int32 nMark)
 920 {
 921     if( ! m_bValidMarkable )
 922     {
 923         throw NotConnectedException();
 924     }
 925     m_rMarkable->jumpToMark( nMark );
 926 }
 927
 928
 929 void OObjectOutputStream::jumpToFurthest()
 930 {
 931     connectToMarkable();
 932     m_rMarkable->jumpToFurthest();
 933 }
 934
 935 sal_Int32 OObjectOutputStream::offsetToMark(sal_Int32 nMark)
 936 {
 937     if( ! m_bValidMarkable )
 938     {
 939         throw NotConnectedException();
 940     }
 941     return m_rMarkable->offsetToMark( nMark );
 942 }
 943
 944 // XServiceInfo
 945 OUString OObjectOutputStream::getImplementationName()
 946 {
 947     return "com.sun.star.comp.io.stm.ObjectOutputStream";
 948 }
 949
 950 // XServiceInfo
 951 sal_Bool OObjectOutputStream::supportsService(const OUString& ServiceName)
 952 {
 953     return cppu::supportsService(this, ServiceName);
 954 }
 955
 956 // XServiceInfo
 957 Sequence< OUString > OObjectOutputStream::getSupportedServiceNames()
 958 {
 959     return { "com.sun.star.io.ObjectOutputStream" };
 960 }
 961
 962 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 963 io_OObjectOutputStream_get_implementation(
 964     css::uno::XComponentContext* , css::uno::Sequence<css::uno::Any> const&)
 965 {
 966     return cppu::acquire(new OObjectOutputStream());
 967 }
 968
 969 namespace {
 970
 971 class OObjectInputStream:
 972     public ImplInheritanceHelper<
 973         ODataInputStream, /* parent */
 974         XObjectInputStream, XMarkableStream >
 975 {
 976 public:
 977     explicit OObjectInputStream( const Reference < XComponentContext > &r)
 978         : m_rSMgr( r->getServiceManager() )
 979         , m_rCxt( r )
 980         , m_bValidMarkable(false)
 981         {
 982         }
 983
 984 public: // XInputStream
 985     virtual sal_Int32 SAL_CALL readBytes(Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead) override
 986         { return ODataInputStream::readBytes( aData , nBytesToRead ); }
 987
 988     virtual sal_Int32 SAL_CALL readSomeBytes(Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead) override
 989         { return ODataInputStream::readSomeBytes( aData, nMaxBytesToRead ); }
 990
 991     virtual void SAL_CALL skipBytes(sal_Int32 nBytesToSkip) override
 992         { ODataInputStream::skipBytes( nBytesToSkip ); }
 993
 994     virtual sal_Int32 SAL_CALL available() override
 995         { return ODataInputStream::available(); }
 996
 997     virtual void SAL_CALL closeInput() override
 998         { ODataInputStream::closeInput(); }
 999
1000 public: // XDataInputStream
1001     virtual sal_Int8 SAL_CALL readBoolean() override
1002                 { return ODataInputStream::readBoolean(); }
1003     virtual sal_Int8 SAL_CALL readByte() override
1004                 { return ODataInputStream::readByte(); }
1005     virtual sal_Unicode SAL_CALL readChar() override
1006                 { return ODataInputStream::readChar(); }
1007     virtual sal_Int16 SAL_CALL readShort() override
1008                 { return ODataInputStream::readShort(); }
1009     virtual sal_Int32 SAL_CALL readLong() override
1010                 { return ODataInputStream::readLong(); }
1011     virtual sal_Int64 SAL_CALL readHyper() override
1012                 { return ODataInputStream::readHyper(); }
1013     virtual float SAL_CALL readFloat() override
1014                 { return ODataInputStream::readFloat(); }
1015     virtual double SAL_CALL readDouble() override
1016         { return ODataInputStream::readDouble(); }
1017     virtual OUString SAL_CALL readUTF() override
1018                 { return ODataInputStream::readUTF(); }
1019
1020 public: // XObjectInputStream
1021         virtual Reference< XPersistObject > SAL_CALL readObject( ) override;
1022
1023 public: // XMarkableStream
1024     virtual sal_Int32 SAL_CALL createMark() override;
1025     virtual void SAL_CALL deleteMark(sal_Int32 Mark) override;
1026     virtual void SAL_CALL jumpToMark(sal_Int32 nMark) override;
1027     virtual void SAL_CALL jumpToFurthest() override;
1028     virtual sal_Int32 SAL_CALL offsetToMark(sal_Int32 nMark) override;
1029
1030 public: // XServiceInfo
1031     OUString                     SAL_CALL getImplementationName() override;
1032     Sequence< OUString >         SAL_CALL getSupportedServiceNames() override;
1033     sal_Bool                     SAL_CALL supportsService(const OUString& ServiceName) override;
1034
1035 private:
1036     void connectToMarkable();
1037 private:
1038     Reference < XMultiComponentFactory > m_rSMgr;
1039     Reference < XComponentContext >     m_rCxt;
1040     bool                m_bValidMarkable;
1041     Reference < XMarkableStream > m_rMarkable;
1042     vector < Reference<  XPersistObject > > m_aPersistVector;
1043
1044 };
1045
1046 }
1047
1048 Reference< XPersistObject >  OObjectInputStream::readObject()
1049 {
1050     // check if chain contains a XMarkableStream
1051     connectToMarkable();
1052
1053     Reference< XPersistObject > xLoadedObj;
1054
1055     // create Mark to skip newer versions
1056     sal_uInt32 nMark = m_rMarkable->createMark();
1057     // length of the data
1058     sal_Int32 nLen = static_cast<sal_uInt16>(ODataInputStream::readShort());
1059     if( nLen < 0xc )
1060     {
1061         throw WrongFormatException();
1062     }
1063
1064     // read the object identifier
1065     sal_uInt32 nId = readLong();
1066
1067     // the name of the persist model
1068     // MM ???
1069     OUString aName = readUTF();
1070
1071     // Read the length of the object
1072     sal_Int32 nObjLen = readLong();
1073     if( 0 == nId && 0 != nObjLen )
1074     {
1075         throw WrongFormatException();
1076     }
1077
1078     // skip data of new version
1079     skipBytes( nLen - m_rMarkable->offsetToMark( nMark ) );
1080
1081     bool bLoadSuccessful = true;
1082     if( nId )
1083     {
1084         if( !aName.isEmpty() )
1085         {
1086             // load the object
1087             Reference< XInterface > x = m_rSMgr->createInstanceWithContext( aName, m_rCxt );
1088             xLoadedObj.set( x, UNO_QUERY );
1089             if( xLoadedObj.is() )
1090             {
1091                 sal_uInt32 nSize = m_aPersistVector.size();
1092                 if( nSize <= nId )
1093                 {
1094                     // grow to the right size
1095                     Reference< XPersistObject > xEmpty;
1096                     m_aPersistVector.insert( m_aPersistVector.end(), nId - nSize + 1, xEmpty );
1097                 }
1098
1099                 m_aPersistVector[nId] = xLoadedObj;
1100                 xLoadedObj->read( Reference< XObjectInputStream >(
1101                     static_cast< XObjectInputStream * >(this) ) );
1102             }
1103             else
1104             {
1105                 // no service with this name could be instantiated
1106                 bLoadSuccessful = false;
1107             }
1108         }
1109         else {
1110             if (nId >= m_aPersistVector.size())
1111             {
1112                 // id unknown, load failure !
1113                 bLoadSuccessful = false;
1114             }
1115             else
1116             {
1117                 // Object has already been read,
1118                 xLoadedObj = m_aPersistVector[nId];
1119             }
1120         }
1121     }
1122
1123     // skip to the position behind the object
1124     skipBytes( nObjLen + nLen - m_rMarkable->offsetToMark( nMark ) );
1125     m_rMarkable->deleteMark( nMark );
1126
1127     if( ! bLoadSuccessful )
1128     {
1129         throw WrongFormatException();
1130     }
1131     return xLoadedObj;
1132 }
1133
1134
1135 void OObjectInputStream::connectToMarkable()
1136 {
1137     if(  m_bValidMarkable )        return;
1138
1139     if( ! m_bValidStream )
1140     {
1141         throw NotConnectedException( );
1142     }
1143
1144     // find the markable stream !
1145     Reference< XInterface > rTry(m_input);
1146     while( true ) {
1147         if( ! rTry.is() )
1148         {
1149             throw NotConnectedException( );
1150         }
1151         Reference<  XMarkableStream > markable( rTry , UNO_QUERY );
1152         if( markable.is() )
1153         {
1154             m_rMarkable = markable;
1155             break;
1156         }
1157         Reference < XActiveDataSink > sink( rTry , UNO_QUERY );
1158         rTry = sink;
1159     }
1160     m_bValidMarkable = true;
1161 }
1162
1163 sal_Int32 OObjectInputStream::createMark()
1164 {
1165     connectToMarkable();    // throws an exception, if a markable is not connected !
1166
1167     return m_rMarkable->createMark();
1168 }
1169
1170 void OObjectInputStream::deleteMark(sal_Int32 Mark)
1171 {
1172     if( ! m_bValidMarkable )
1173     {
1174         throw NotConnectedException();
1175     }
1176     m_rMarkable->deleteMark( Mark );
1177 }
1178
1179 void OObjectInputStream::jumpToMark(sal_Int32 nMark)
1180 {
1181     if( ! m_bValidMarkable )
1182     {
1183         throw NotConnectedException();
1184     }
1185     m_rMarkable->jumpToMark( nMark );
1186 }
1187 void OObjectInputStream::jumpToFurthest()
1188 {
1189     connectToMarkable();
1190     m_rMarkable->jumpToFurthest();
1191 }
1192
1193 sal_Int32 OObjectInputStream::offsetToMark(sal_Int32 nMark)
1194 {
1195     if( ! m_bValidMarkable )
1196     {
1197         throw NotConnectedException();
1198     }
1199     return m_rMarkable->offsetToMark( nMark );
1200 }
1201
1202 // XServiceInfo
1203 OUString OObjectInputStream::getImplementationName()
1204 {
1205     return "com.sun.star.comp.io.stm.ObjectInputStream";
1206 }
1207
1208 // XServiceInfo
1209 sal_Bool OObjectInputStream::supportsService(const OUString& ServiceName)
1210 {
1211     return cppu::supportsService(this, ServiceName);
1212 }
1213
1214 // XServiceInfo
1215 Sequence< OUString > OObjectInputStream::getSupportedServiceNames()
1216 {
1217     return { "com.sun.star.io.ObjectInputStream" };
1218 }
1219
1220 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
1221 io_OObjectInputStream_get_implementation(
1222     css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
1223 {
1224     return cppu::acquire(new OObjectInputStream(context));
1225 }
1226
1227 }
1228
1229
1230 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */