1228 lines
34 KiB
C++
1228 lines
34 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
#include <cppuhelper/weak.hxx>
|
|
#include <cppuhelper/implbase.hxx>
|
|
#include <cppuhelper/supportsservice.hxx>
|
|
#include <osl/endian.h>
|
|
|
|
#include <com/sun/star/io/NotConnectedException.hpp>
|
|
#include <com/sun/star/io/XObjectInputStream.hpp>
|
|
#include <com/sun/star/io/XObjectOutputStream.hpp>
|
|
#include <com/sun/star/io/XActiveDataSource.hpp>
|
|
#include <com/sun/star/io/XActiveDataSink.hpp>
|
|
#include <com/sun/star/io/XMarkableStream.hpp>
|
|
#include <com/sun/star/io/XConnectable.hpp>
|
|
#include <com/sun/star/io/UnexpectedEOFException.hpp>
|
|
#include <com/sun/star/io/WrongFormatException.hpp>
|
|
#include <com/sun/star/lang/XServiceInfo.hpp>
|
|
#include <com/sun/star/uno/XComponentContext.hpp>
|
|
|
|
using namespace ::cppu;
|
|
using namespace ::com::sun::star::io;
|
|
using namespace ::com::sun::star::uno;
|
|
using namespace ::com::sun::star::lang;
|
|
|
|
namespace io_stm {
|
|
|
|
namespace {
|
|
|
|
class ODataInputStream :
|
|
public WeakImplHelper <
|
|
XDataInputStream,
|
|
XActiveDataSink,
|
|
XConnectable,
|
|
XServiceInfo
|
|
>
|
|
{
|
|
public:
|
|
ODataInputStream( )
|
|
: m_bValidStream( false )
|
|
{
|
|
}
|
|
|
|
public: // XInputStream
|
|
virtual sal_Int32 SAL_CALL readBytes(Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead) override;
|
|
virtual sal_Int32 SAL_CALL readSomeBytes(Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead) override;
|
|
virtual void SAL_CALL skipBytes(sal_Int32 nBytesToSkip) override;
|
|
virtual sal_Int32 SAL_CALL available() override;
|
|
virtual void SAL_CALL closeInput() override;
|
|
|
|
public: // XDataInputStream
|
|
virtual sal_Int8 SAL_CALL readBoolean() override;
|
|
virtual sal_Int8 SAL_CALL readByte() override;
|
|
virtual sal_Unicode SAL_CALL readChar() override;
|
|
virtual sal_Int16 SAL_CALL readShort() override;
|
|
virtual sal_Int32 SAL_CALL readLong() override;
|
|
virtual sal_Int64 SAL_CALL readHyper() override;
|
|
virtual float SAL_CALL readFloat() override;
|
|
virtual double SAL_CALL readDouble() override;
|
|
virtual OUString SAL_CALL readUTF() override;
|
|
|
|
|
|
public: // XActiveDataSink
|
|
virtual void SAL_CALL setInputStream(const Reference< XInputStream > & aStream) override;
|
|
virtual Reference< XInputStream > SAL_CALL getInputStream() override;
|
|
|
|
public: // XConnectable
|
|
virtual void SAL_CALL setPredecessor(const Reference < XConnectable >& aPredecessor) override;
|
|
virtual Reference < XConnectable > SAL_CALL getPredecessor() override;
|
|
virtual void SAL_CALL setSuccessor(const Reference < XConnectable >& aSuccessor) override;
|
|
virtual Reference < XConnectable > SAL_CALL getSuccessor() override ;
|
|
|
|
|
|
public: // XServiceInfo
|
|
OUString SAL_CALL getImplementationName() override;
|
|
Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
|
|
sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override;
|
|
|
|
protected:
|
|
|
|
Reference < XConnectable > m_pred;
|
|
Reference < XConnectable > m_succ;
|
|
Reference < XInputStream > m_input;
|
|
bool m_bValidStream;
|
|
};
|
|
|
|
}
|
|
|
|
// XInputStream
|
|
sal_Int32 ODataInputStream::readBytes(Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead)
|
|
{
|
|
if( !m_bValidStream )
|
|
{
|
|
throw NotConnectedException( );
|
|
}
|
|
sal_Int32 nRead = m_input->readBytes( aData , nBytesToRead );
|
|
return nRead;
|
|
}
|
|
|
|
sal_Int32 ODataInputStream::readSomeBytes(Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead)
|
|
{
|
|
if( !m_bValidStream )
|
|
throw NotConnectedException( );
|
|
sal_Int32 nRead = m_input->readSomeBytes( aData , nMaxBytesToRead );
|
|
return nRead;
|
|
}
|
|
void ODataInputStream::skipBytes(sal_Int32 nBytesToSkip)
|
|
{
|
|
if( !m_bValidStream )
|
|
throw NotConnectedException( );
|
|
m_input->skipBytes( nBytesToSkip );
|
|
}
|
|
|
|
|
|
sal_Int32 ODataInputStream::available()
|
|
{
|
|
if( !m_bValidStream )
|
|
throw NotConnectedException( );
|
|
sal_Int32 nAvail = m_input->available( );
|
|
return nAvail;
|
|
}
|
|
|
|
void ODataInputStream::closeInput()
|
|
{
|
|
if( !m_bValidStream )
|
|
throw NotConnectedException( );
|
|
m_input->closeInput( );
|
|
setInputStream( Reference< XInputStream > () );
|
|
setPredecessor( Reference < XConnectable >() );
|
|
setSuccessor( Reference < XConnectable >() );
|
|
m_bValidStream = false;
|
|
}
|
|
|
|
|
|
//== XDataInputStream ===========================================
|
|
|
|
// XDataInputStream
|
|
sal_Int8 ODataInputStream::readBoolean()
|
|
{
|
|
return readByte();
|
|
}
|
|
|
|
sal_Int8 ODataInputStream::readByte()
|
|
{
|
|
Sequence<sal_Int8> aTmp(1);
|
|
if( 1 != readBytes( aTmp, 1 ) )
|
|
{
|
|
throw UnexpectedEOFException();
|
|
}
|
|
return aTmp.getConstArray()[0];
|
|
}
|
|
|
|
sal_Unicode ODataInputStream::readChar()
|
|
{
|
|
Sequence<sal_Int8> aTmp(2);
|
|
if( 2 != readBytes( aTmp, 2 ) )
|
|
{
|
|
throw UnexpectedEOFException();
|
|
}
|
|
|
|
const sal_uInt8 * pBytes = reinterpret_cast<const sal_uInt8 *>(aTmp.getConstArray());
|
|
return (static_cast<sal_Unicode>(pBytes[0]) << 8) + pBytes[1];
|
|
}
|
|
|
|
sal_Int16 ODataInputStream::readShort()
|
|
{
|
|
Sequence<sal_Int8> aTmp(2);
|
|
if( 2 != readBytes( aTmp, 2 ) )
|
|
{
|
|
throw UnexpectedEOFException();
|
|
}
|
|
|
|
const sal_uInt8 * pBytes = reinterpret_cast<const sal_uInt8 *>(aTmp.getConstArray());
|
|
return (static_cast<sal_Int16>(pBytes[0]) << 8) + pBytes[1];
|
|
}
|
|
|
|
|
|
sal_Int32 ODataInputStream::readLong()
|
|
{
|
|
Sequence<sal_Int8> aTmp(4);
|
|
if( 4 != readBytes( aTmp, 4 ) )
|
|
{
|
|
throw UnexpectedEOFException( );
|
|
}
|
|
|
|
const sal_uInt8 * pBytes = reinterpret_cast<const sal_uInt8 *>(aTmp.getConstArray());
|
|
return (static_cast<sal_Int32>(pBytes[0]) << 24) + (static_cast<sal_Int32>(pBytes[1]) << 16) + (static_cast<sal_Int32>(pBytes[2]) << 8) + pBytes[3];
|
|
}
|
|
|
|
|
|
sal_Int64 ODataInputStream::readHyper()
|
|
{
|
|
Sequence<sal_Int8> aTmp(8);
|
|
if( 8 != readBytes( aTmp, 8 ) )
|
|
{
|
|
throw UnexpectedEOFException( );
|
|
}
|
|
|
|
const sal_uInt8 * pBytes = reinterpret_cast<const sal_uInt8 *>(aTmp.getConstArray());
|
|
return
|
|
(static_cast<sal_Int64>(pBytes[0]) << 56) +
|
|
(static_cast<sal_Int64>(pBytes[1]) << 48) +
|
|
(static_cast<sal_Int64>(pBytes[2]) << 40) +
|
|
(static_cast<sal_Int64>(pBytes[3]) << 32) +
|
|
(static_cast<sal_Int64>(pBytes[4]) << 24) +
|
|
(static_cast<sal_Int64>(pBytes[5]) << 16) +
|
|
(static_cast<sal_Int64>(pBytes[6]) << 8) +
|
|
pBytes[7];
|
|
}
|
|
|
|
float ODataInputStream::readFloat()
|
|
{
|
|
union { float f; sal_uInt32 n; } a;
|
|
a.n = readLong();
|
|
return a.f;
|
|
}
|
|
|
|
double ODataInputStream::readDouble()
|
|
{
|
|
union { double d; struct { sal_uInt32 n1; sal_uInt32 n2; } ad; } a;
|
|
#if defined OSL_LITENDIAN
|
|
a.ad.n2 = readLong();
|
|
a.ad.n1 = readLong();
|
|
#else
|
|
a.ad.n1 = readLong();
|
|
a.ad.n2 = readLong();
|
|
#endif
|
|
return a.d;
|
|
}
|
|
|
|
OUString ODataInputStream::readUTF()
|
|
{
|
|
sal_uInt16 nShortLen = static_cast<sal_uInt16>(readShort());
|
|
sal_Int32 nUTFLen;
|
|
|
|
if( (sal_uInt16(0xffff)) == nShortLen )
|
|
{
|
|
// is interpreted as a sign, that string is longer than 64k
|
|
// incompatible to older XDataInputStream-routines, when strings are exactly 64k
|
|
nUTFLen = readLong();
|
|
}
|
|
else
|
|
{
|
|
nUTFLen = static_cast<sal_Int32>(nShortLen);
|
|
}
|
|
|
|
Sequence<sal_Unicode> aBuffer( nUTFLen );
|
|
sal_Unicode * pStr = aBuffer.getArray();
|
|
|
|
sal_Int32 nCount = 0;
|
|
sal_Int32 nStrLen = 0;
|
|
while( nCount < nUTFLen )
|
|
{
|
|
sal_uInt8 c = static_cast<sal_uInt8>(readByte());
|
|
sal_uInt8 char2, char3;
|
|
switch( c >> 4 )
|
|
{
|
|
case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
|
|
// 0xxxxxxx
|
|
nCount++;
|
|
pStr[nStrLen++] = c;
|
|
break;
|
|
|
|
case 12: case 13:
|
|
// 110x xxxx 10xx xxxx
|
|
nCount += 2;
|
|
if( nCount > nUTFLen )
|
|
{
|
|
throw WrongFormatException( );
|
|
}
|
|
|
|
char2 = static_cast<sal_uInt8>(readByte());
|
|
if( (char2 & 0xC0) != 0x80 )
|
|
{
|
|
throw WrongFormatException( );
|
|
}
|
|
|
|
pStr[nStrLen++] = (sal_Unicode(c & 0x1F) << 6) | (char2 & 0x3F);
|
|
break;
|
|
|
|
case 14:
|
|
// 1110 xxxx 10xx xxxx 10xx xxxx
|
|
nCount += 3;
|
|
if( nCount > nUTFLen )
|
|
{
|
|
throw WrongFormatException( );
|
|
}
|
|
|
|
char2 = static_cast<sal_uInt8>(readByte());
|
|
char3 = static_cast<sal_uInt8>(readByte());
|
|
|
|
if( ((char2 & 0xC0) != 0x80) || ((char3 & 0xC0) != 0x80) ) {
|
|
throw WrongFormatException( );
|
|
}
|
|
pStr[nStrLen++] = (sal_Unicode(c & 0x0F) << 12) |
|
|
(sal_Unicode(char2 & 0x3F) << 6) |
|
|
(char3 & 0x3F);
|
|
break;
|
|
|
|
default:
|
|
// 10xx xxxx, 1111 xxxx
|
|
throw WrongFormatException();
|
|
//throw new UTFDataFormatException();
|
|
}
|
|
}
|
|
return OUString( pStr, nStrLen );
|
|
}
|
|
|
|
|
|
// XActiveDataSource
|
|
void ODataInputStream::setInputStream(const Reference< XInputStream > & aStream)
|
|
{
|
|
|
|
if( m_input != aStream ) {
|
|
m_input = aStream;
|
|
|
|
Reference < XConnectable > pred( m_input , UNO_QUERY );
|
|
setPredecessor( pred );
|
|
}
|
|
|
|
m_bValidStream = m_input.is();
|
|
}
|
|
|
|
Reference< XInputStream > ODataInputStream::getInputStream()
|
|
{
|
|
return m_input;
|
|
}
|
|
|
|
|
|
// XDataSink
|
|
void ODataInputStream::setSuccessor( const Reference < XConnectable > &r )
|
|
{
|
|
/// if the references match, nothing needs to be done
|
|
if( m_succ != r ) {
|
|
/// store the reference for later use
|
|
m_succ = r;
|
|
|
|
if( m_succ.is() ) {
|
|
/// set this instance as the sink !
|
|
m_succ->setPredecessor( Reference< XConnectable > (
|
|
static_cast< XConnectable * >(this) ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
Reference < XConnectable > ODataInputStream::getSuccessor()
|
|
{
|
|
return m_succ;
|
|
}
|
|
|
|
|
|
// XDataSource
|
|
void ODataInputStream::setPredecessor( const Reference < XConnectable > &r )
|
|
{
|
|
if( r != m_pred ) {
|
|
m_pred = r;
|
|
if( m_pred.is() ) {
|
|
m_pred->setSuccessor( Reference< XConnectable > (
|
|
static_cast< XConnectable * >(this) ) );
|
|
}
|
|
}
|
|
}
|
|
Reference < XConnectable > ODataInputStream::getPredecessor()
|
|
{
|
|
return m_pred;
|
|
}
|
|
|
|
// XServiceInfo
|
|
OUString ODataInputStream::getImplementationName()
|
|
{
|
|
return u"com.sun.star.comp.io.stm.DataInputStream"_ustr;
|
|
}
|
|
|
|
// XServiceInfo
|
|
sal_Bool ODataInputStream::supportsService(const OUString& ServiceName)
|
|
{
|
|
return cppu::supportsService(this, ServiceName);
|
|
}
|
|
|
|
// XServiceInfo
|
|
Sequence< OUString > ODataInputStream::getSupportedServiceNames()
|
|
{
|
|
return { u"com.sun.star.io.DataInputStream"_ustr };
|
|
}
|
|
|
|
extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
|
|
io_ODataInputStream_get_implementation(
|
|
css::uno::XComponentContext* , css::uno::Sequence<css::uno::Any> const&)
|
|
{
|
|
return cppu::acquire(new ODataInputStream());
|
|
}
|
|
|
|
namespace {
|
|
|
|
class ODataOutputStream :
|
|
public WeakImplHelper <
|
|
XDataOutputStream,
|
|
XActiveDataSource,
|
|
XConnectable,
|
|
XServiceInfo >
|
|
{
|
|
public:
|
|
ODataOutputStream()
|
|
: m_bValidStream( false )
|
|
{
|
|
}
|
|
|
|
public: // XOutputStream
|
|
virtual void SAL_CALL writeBytes(const Sequence< sal_Int8 >& aData) override;
|
|
virtual void SAL_CALL flush() override;
|
|
virtual void SAL_CALL closeOutput() override;
|
|
|
|
public: // XDataOutputStream
|
|
virtual void SAL_CALL writeBoolean(sal_Bool Value) override;
|
|
virtual void SAL_CALL writeByte(sal_Int8 Value) override;
|
|
virtual void SAL_CALL writeChar(sal_Unicode Value) override;
|
|
virtual void SAL_CALL writeShort(sal_Int16 Value) override;
|
|
virtual void SAL_CALL writeLong(sal_Int32 Value) override;
|
|
virtual void SAL_CALL writeHyper(sal_Int64 Value) override;
|
|
virtual void SAL_CALL writeFloat(float Value) override;
|
|
virtual void SAL_CALL writeDouble(double Value) override;
|
|
virtual void SAL_CALL writeUTF(const OUString& Value) override;
|
|
|
|
public: // XActiveDataSource
|
|
virtual void SAL_CALL setOutputStream(const Reference< XOutputStream > & aStream) override;
|
|
virtual Reference < XOutputStream > SAL_CALL getOutputStream() override;
|
|
|
|
public: // XConnectable
|
|
virtual void SAL_CALL setPredecessor(const Reference < XConnectable >& aPredecessor) override;
|
|
virtual Reference < XConnectable > SAL_CALL getPredecessor() override;
|
|
virtual void SAL_CALL setSuccessor(const Reference < XConnectable >& aSuccessor) override;
|
|
virtual Reference < XConnectable > SAL_CALL getSuccessor() override;
|
|
|
|
public: // XServiceInfo
|
|
OUString SAL_CALL getImplementationName() override;
|
|
Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
|
|
sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override;
|
|
|
|
protected:
|
|
Reference < XConnectable > m_succ;
|
|
Reference < XConnectable > m_pred;
|
|
Reference< XOutputStream > m_output;
|
|
bool m_bValidStream;
|
|
};
|
|
|
|
}
|
|
|
|
// XOutputStream
|
|
void ODataOutputStream::writeBytes(const Sequence< sal_Int8 >& aData)
|
|
{
|
|
if( !m_bValidStream )
|
|
throw NotConnectedException( );
|
|
m_output->writeBytes( aData );
|
|
}
|
|
|
|
void ODataOutputStream::flush()
|
|
{
|
|
if( !m_bValidStream )
|
|
throw NotConnectedException();
|
|
m_output->flush();
|
|
}
|
|
|
|
|
|
void ODataOutputStream::closeOutput()
|
|
{
|
|
if( !m_bValidStream )
|
|
throw NotConnectedException();
|
|
m_output->closeOutput();
|
|
setOutputStream( Reference< XOutputStream > () );
|
|
setPredecessor( Reference < XConnectable >() );
|
|
setSuccessor( Reference < XConnectable >() );
|
|
}
|
|
|
|
// XDataOutputStream
|
|
void ODataOutputStream::writeBoolean(sal_Bool Value)
|
|
{
|
|
if( Value )
|
|
{
|
|
writeByte( 1 );
|
|
}
|
|
else
|
|
{
|
|
writeByte( 0 );
|
|
}
|
|
}
|
|
|
|
|
|
void ODataOutputStream::writeByte(sal_Int8 Value)
|
|
{
|
|
writeBytes( { Value } );
|
|
}
|
|
|
|
void ODataOutputStream::writeChar(sal_Unicode Value)
|
|
{
|
|
writeBytes( { sal_Int8(Value >> 8),
|
|
sal_Int8(Value) } );
|
|
}
|
|
|
|
|
|
void ODataOutputStream::writeShort(sal_Int16 Value)
|
|
{
|
|
writeBytes( { sal_Int8(Value >> 8),
|
|
sal_Int8(Value) } );
|
|
}
|
|
|
|
void ODataOutputStream::writeLong(sal_Int32 Value)
|
|
{
|
|
writeBytes( { sal_Int8(Value >> 24),
|
|
sal_Int8(Value >> 16),
|
|
sal_Int8(Value >> 8),
|
|
sal_Int8(Value) } );
|
|
}
|
|
|
|
void ODataOutputStream::writeHyper(sal_Int64 Value)
|
|
{
|
|
writeBytes( { sal_Int8(Value >> 56),
|
|
sal_Int8(Value >> 48),
|
|
sal_Int8(Value >> 40),
|
|
sal_Int8(Value >> 32),
|
|
sal_Int8(Value >> 24),
|
|
sal_Int8(Value >> 16),
|
|
sal_Int8(Value >> 8),
|
|
sal_Int8(Value) } );
|
|
}
|
|
|
|
|
|
void ODataOutputStream::writeFloat(float Value)
|
|
{
|
|
union { float f; sal_uInt32 n; } a;
|
|
a.f = Value;
|
|
writeLong( a.n );
|
|
}
|
|
|
|
void ODataOutputStream::writeDouble(double Value)
|
|
{
|
|
union { double d; struct { sal_uInt32 n1; sal_uInt32 n2; } ad; } a;
|
|
a.d = Value;
|
|
#if defined OSL_LITENDIAN
|
|
writeLong( a.ad.n2 );
|
|
writeLong( a.ad.n1 );
|
|
#else
|
|
writeLong( a.ad.n1 );
|
|
writeLong( a.ad.n2 );
|
|
#endif
|
|
}
|
|
|
|
void ODataOutputStream::writeUTF(const OUString& Value)
|
|
{
|
|
sal_Int32 nStrLen = Value.getLength();
|
|
const sal_Unicode * pStr = Value.getStr();
|
|
sal_Int32 nUTFLen = 0;
|
|
sal_Int32 i;
|
|
|
|
for( i = 0 ; i < nStrLen ; i++ )
|
|
{
|
|
sal_uInt16 c = pStr[i];
|
|
if( (c >= 0x0001) && (c <= 0x007F) )
|
|
{
|
|
nUTFLen++;
|
|
}
|
|
else if( c > 0x07FF )
|
|
{
|
|
nUTFLen += 3;
|
|
}
|
|
else
|
|
{
|
|
nUTFLen += 2;
|
|
}
|
|
}
|
|
|
|
|
|
// compatibility mode for older implementations, where it was not possible
|
|
// to write blocks bigger than 64 k. Note that there is a tradeoff. Blocks,
|
|
// that are exactly 64k long can not be read by older routines when written
|
|
// with these routines and the other way round !!!!!
|
|
if( nUTFLen >= 0xFFFF ) {
|
|
writeShort( sal_Int16(-1) );
|
|
writeLong( nUTFLen );
|
|
}
|
|
else {
|
|
writeShort( static_cast<sal_uInt16>(nUTFLen) );
|
|
}
|
|
for( i = 0 ; i < nStrLen ; i++ )
|
|
{
|
|
sal_uInt16 c = pStr[i];
|
|
if( (c >= 0x0001) && (c <= 0x007F) )
|
|
{
|
|
writeByte(sal_Int8(c));
|
|
}
|
|
else if( c > 0x07FF )
|
|
{
|
|
writeByte(sal_Int8(0xE0 | ((c >> 12) & 0x0F)));
|
|
writeByte(sal_Int8(0x80 | ((c >> 6) & 0x3F)));
|
|
writeByte(sal_Int8(0x80 | ((c >> 0) & 0x3F)));
|
|
}
|
|
else
|
|
{
|
|
writeByte(sal_Int8(0xC0 | ((c >> 6) & 0x1F)));
|
|
writeByte(sal_Int8(0x80 | ((c >> 0) & 0x3F)));
|
|
}
|
|
}
|
|
}
|
|
|
|
// XActiveDataSource
|
|
void ODataOutputStream::setOutputStream(const Reference< XOutputStream > & aStream)
|
|
{
|
|
if( m_output != aStream ) {
|
|
m_output = aStream;
|
|
m_bValidStream = m_output.is();
|
|
|
|
Reference < XConnectable > succ( m_output , UNO_QUERY );
|
|
setSuccessor( succ );
|
|
}
|
|
}
|
|
|
|
Reference< XOutputStream > ODataOutputStream::getOutputStream()
|
|
{
|
|
return m_output;
|
|
}
|
|
|
|
|
|
// XDataSink
|
|
void ODataOutputStream::setSuccessor( const Reference < XConnectable > &r )
|
|
{
|
|
/// if the references match, nothing needs to be done
|
|
if( m_succ != r )
|
|
{
|
|
/// store the reference for later use
|
|
m_succ = r;
|
|
|
|
if( m_succ.is() )
|
|
{
|
|
/// set this instance as the sink !
|
|
m_succ->setPredecessor( Reference < XConnectable > (
|
|
static_cast< XConnectable * >(this) ));
|
|
}
|
|
}
|
|
}
|
|
Reference < XConnectable > ODataOutputStream::getSuccessor()
|
|
{
|
|
return m_succ;
|
|
}
|
|
|
|
|
|
// XDataSource
|
|
void ODataOutputStream::setPredecessor( const Reference < XConnectable > &r )
|
|
{
|
|
if( r != m_pred ) {
|
|
m_pred = r;
|
|
if( m_pred.is() ) {
|
|
m_pred->setSuccessor( Reference< XConnectable > (
|
|
static_cast< XConnectable * >(this) ));
|
|
}
|
|
}
|
|
}
|
|
Reference < XConnectable > ODataOutputStream::getPredecessor()
|
|
{
|
|
return m_pred;
|
|
}
|
|
|
|
|
|
// XServiceInfo
|
|
OUString ODataOutputStream::getImplementationName()
|
|
{
|
|
return u"com.sun.star.comp.io.stm.DataOutputStream"_ustr;
|
|
}
|
|
|
|
// XServiceInfo
|
|
sal_Bool ODataOutputStream::supportsService(const OUString& ServiceName)
|
|
{
|
|
return cppu::supportsService(this, ServiceName);
|
|
}
|
|
|
|
// XServiceInfo
|
|
Sequence< OUString > ODataOutputStream::getSupportedServiceNames()
|
|
{
|
|
return { u"com.sun.star.io.DataOutputStream"_ustr };
|
|
}
|
|
|
|
extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
|
|
io_ODataOutputStream_get_implementation(
|
|
css::uno::XComponentContext* , css::uno::Sequence<css::uno::Any> const&)
|
|
{
|
|
return cppu::acquire(new ODataOutputStream());
|
|
}
|
|
|
|
namespace {
|
|
|
|
struct equalObjectContainer_Impl
|
|
{
|
|
bool operator()(const Reference< XInterface > & s1,
|
|
const Reference< XInterface > & s2) const
|
|
{
|
|
return s1 == s2;
|
|
}
|
|
};
|
|
|
|
|
|
struct hashObjectContainer_Impl
|
|
{
|
|
size_t operator()(const Reference< XInterface > & xRef) const
|
|
{
|
|
return reinterpret_cast<size_t>(xRef.get());
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
typedef std::unordered_map
|
|
<
|
|
Reference< XInterface >,
|
|
sal_Int32,
|
|
hashObjectContainer_Impl,
|
|
equalObjectContainer_Impl
|
|
> ObjectContainer_Impl;
|
|
|
|
namespace {
|
|
|
|
class OObjectOutputStream:
|
|
public ImplInheritanceHelper<
|
|
ODataOutputStream, /* parent */
|
|
XObjectOutputStream, XMarkableStream >
|
|
{
|
|
public:
|
|
OObjectOutputStream()
|
|
: m_nMaxId(0) ,
|
|
m_bValidMarkable(false)
|
|
{
|
|
}
|
|
|
|
public:
|
|
// XOutputStream
|
|
virtual void SAL_CALL writeBytes(const Sequence< sal_Int8 >& aData) override
|
|
{ ODataOutputStream::writeBytes( aData ); }
|
|
|
|
virtual void SAL_CALL flush() override
|
|
{ ODataOutputStream::flush(); }
|
|
|
|
virtual void SAL_CALL closeOutput() override
|
|
{ ODataOutputStream::closeOutput(); }
|
|
|
|
public:
|
|
// XDataOutputStream
|
|
virtual void SAL_CALL writeBoolean(sal_Bool Value) override
|
|
{ ODataOutputStream::writeBoolean( Value ); }
|
|
virtual void SAL_CALL writeByte(sal_Int8 Value) override
|
|
{ ODataOutputStream::writeByte( Value ); }
|
|
virtual void SAL_CALL writeChar(sal_Unicode Value) override
|
|
{ ODataOutputStream::writeChar( Value ); }
|
|
virtual void SAL_CALL writeShort(sal_Int16 Value) override
|
|
{ ODataOutputStream::writeShort( Value ); }
|
|
virtual void SAL_CALL writeLong(sal_Int32 Value) override
|
|
{ ODataOutputStream::writeLong( Value ); }
|
|
virtual void SAL_CALL writeHyper(sal_Int64 Value) override
|
|
{ ODataOutputStream::writeHyper( Value ); }
|
|
virtual void SAL_CALL writeFloat(float Value) override
|
|
{ ODataOutputStream::writeFloat( Value ); }
|
|
virtual void SAL_CALL writeDouble(double Value) override
|
|
{ ODataOutputStream::writeDouble( Value ); }
|
|
virtual void SAL_CALL writeUTF(const OUString& Value) override
|
|
{ ODataOutputStream::writeUTF( Value );}
|
|
|
|
// XObjectOutputStream
|
|
virtual void SAL_CALL writeObject( const Reference< XPersistObject > & r ) override;
|
|
|
|
public: // XMarkableStream
|
|
virtual sal_Int32 SAL_CALL createMark() override;
|
|
virtual void SAL_CALL deleteMark(sal_Int32 Mark) override;
|
|
virtual void SAL_CALL jumpToMark(sal_Int32 nMark) override;
|
|
virtual void SAL_CALL jumpToFurthest() override;
|
|
virtual sal_Int32 SAL_CALL offsetToMark(sal_Int32 nMark) override;
|
|
|
|
public: // XServiceInfo
|
|
OUString SAL_CALL getImplementationName() override;
|
|
Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
|
|
sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override;
|
|
|
|
private:
|
|
void connectToMarkable();
|
|
private:
|
|
ObjectContainer_Impl m_mapObject;
|
|
sal_Int32 m_nMaxId;
|
|
Reference< XMarkableStream > m_rMarkable;
|
|
bool m_bValidMarkable;
|
|
};
|
|
|
|
}
|
|
|
|
void OObjectOutputStream::writeObject( const Reference< XPersistObject > & xPObj )
|
|
{
|
|
|
|
connectToMarkable();
|
|
bool bWriteObj = false;
|
|
// create Mark to write length of info
|
|
sal_uInt32 nInfoLenMark = m_rMarkable->createMark();
|
|
|
|
// length of the info data (is later rewritten)
|
|
OObjectOutputStream::writeShort( 0 );
|
|
|
|
// write the object identifier
|
|
if( xPObj.is() )
|
|
{
|
|
Reference< XInterface > rX( xPObj , UNO_QUERY );
|
|
|
|
ObjectContainer_Impl::const_iterator aIt
|
|
= m_mapObject.find( rX );
|
|
if( aIt == m_mapObject.end() )
|
|
{
|
|
// insert new object in hash table
|
|
m_mapObject[ rX ] = ++m_nMaxId;
|
|
ODataOutputStream::writeLong( m_nMaxId );
|
|
ODataOutputStream::writeUTF( xPObj->getServiceName() );
|
|
bWriteObj = true;
|
|
}
|
|
else
|
|
{
|
|
ODataOutputStream::writeLong( (*aIt).second );
|
|
ODataOutputStream::writeUTF( OUString() );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ODataOutputStream::writeLong( 0 );
|
|
ODataOutputStream::writeUTF( OUString() );
|
|
}
|
|
|
|
sal_uInt32 nObjLenMark = m_rMarkable->createMark();
|
|
ODataOutputStream::writeLong( 0 );
|
|
|
|
sal_Int32 nInfoLen = m_rMarkable->offsetToMark( nInfoLenMark );
|
|
m_rMarkable->jumpToMark( nInfoLenMark );
|
|
// write length of the info data
|
|
ODataOutputStream::writeShort( static_cast<sal_Int16>(nInfoLen) );
|
|
// jump to the end of the stream
|
|
m_rMarkable->jumpToFurthest();
|
|
|
|
if( bWriteObj )
|
|
xPObj->write( Reference< XObjectOutputStream > (
|
|
static_cast< XObjectOutputStream * >(this) ) );
|
|
|
|
sal_Int32 nObjLen = m_rMarkable->offsetToMark( nObjLenMark ) -4;
|
|
m_rMarkable->jumpToMark( nObjLenMark );
|
|
// write length of the info data
|
|
ODataOutputStream::writeLong( nObjLen );
|
|
// jump to the end of the stream
|
|
m_rMarkable->jumpToFurthest();
|
|
|
|
m_rMarkable->deleteMark( nObjLenMark );
|
|
m_rMarkable->deleteMark( nInfoLenMark );
|
|
}
|
|
|
|
|
|
void OObjectOutputStream::connectToMarkable()
|
|
{
|
|
if( m_bValidMarkable )
|
|
return;
|
|
|
|
if( ! m_bValidStream )
|
|
throw NotConnectedException();
|
|
|
|
// find the markable stream !
|
|
Reference< XInterface > rTry(m_output);
|
|
while( true ) {
|
|
if( ! rTry.is() )
|
|
{
|
|
throw NotConnectedException();
|
|
}
|
|
Reference < XMarkableStream > markable( rTry , UNO_QUERY );
|
|
if( markable.is() )
|
|
{
|
|
m_rMarkable = std::move(markable);
|
|
break;
|
|
}
|
|
Reference < XActiveDataSource > source( rTry , UNO_QUERY );
|
|
rTry = source;
|
|
}
|
|
m_bValidMarkable = true;
|
|
}
|
|
|
|
|
|
sal_Int32 OObjectOutputStream::createMark()
|
|
{
|
|
connectToMarkable(); // throws an exception, if a markable is not connected !
|
|
|
|
return m_rMarkable->createMark();
|
|
}
|
|
|
|
void OObjectOutputStream::deleteMark(sal_Int32 Mark)
|
|
{
|
|
if( ! m_bValidMarkable )
|
|
{
|
|
throw NotConnectedException();
|
|
}
|
|
m_rMarkable->deleteMark( Mark );
|
|
}
|
|
|
|
void OObjectOutputStream::jumpToMark(sal_Int32 nMark)
|
|
{
|
|
if( ! m_bValidMarkable )
|
|
{
|
|
throw NotConnectedException();
|
|
}
|
|
m_rMarkable->jumpToMark( nMark );
|
|
}
|
|
|
|
|
|
void OObjectOutputStream::jumpToFurthest()
|
|
{
|
|
connectToMarkable();
|
|
m_rMarkable->jumpToFurthest();
|
|
}
|
|
|
|
sal_Int32 OObjectOutputStream::offsetToMark(sal_Int32 nMark)
|
|
{
|
|
if( ! m_bValidMarkable )
|
|
{
|
|
throw NotConnectedException();
|
|
}
|
|
return m_rMarkable->offsetToMark( nMark );
|
|
}
|
|
|
|
// XServiceInfo
|
|
OUString OObjectOutputStream::getImplementationName()
|
|
{
|
|
return u"com.sun.star.comp.io.stm.ObjectOutputStream"_ustr;
|
|
}
|
|
|
|
// XServiceInfo
|
|
sal_Bool OObjectOutputStream::supportsService(const OUString& ServiceName)
|
|
{
|
|
return cppu::supportsService(this, ServiceName);
|
|
}
|
|
|
|
// XServiceInfo
|
|
Sequence< OUString > OObjectOutputStream::getSupportedServiceNames()
|
|
{
|
|
return { u"com.sun.star.io.ObjectOutputStream"_ustr };
|
|
}
|
|
|
|
extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
|
|
io_OObjectOutputStream_get_implementation(
|
|
css::uno::XComponentContext* , css::uno::Sequence<css::uno::Any> const&)
|
|
{
|
|
return cppu::acquire(new OObjectOutputStream());
|
|
}
|
|
|
|
namespace {
|
|
|
|
class OObjectInputStream:
|
|
public ImplInheritanceHelper<
|
|
ODataInputStream, /* parent */
|
|
XObjectInputStream, XMarkableStream >
|
|
{
|
|
public:
|
|
explicit OObjectInputStream( const Reference < XComponentContext > &r)
|
|
: m_rSMgr( r->getServiceManager() )
|
|
, m_rCxt( r )
|
|
, m_bValidMarkable(false)
|
|
{
|
|
}
|
|
|
|
public: // XInputStream
|
|
virtual sal_Int32 SAL_CALL readBytes(Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead) override
|
|
{ return ODataInputStream::readBytes( aData , nBytesToRead ); }
|
|
|
|
virtual sal_Int32 SAL_CALL readSomeBytes(Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead) override
|
|
{ return ODataInputStream::readSomeBytes( aData, nMaxBytesToRead ); }
|
|
|
|
virtual void SAL_CALL skipBytes(sal_Int32 nBytesToSkip) override
|
|
{ ODataInputStream::skipBytes( nBytesToSkip ); }
|
|
|
|
virtual sal_Int32 SAL_CALL available() override
|
|
{ return ODataInputStream::available(); }
|
|
|
|
virtual void SAL_CALL closeInput() override
|
|
{ ODataInputStream::closeInput(); }
|
|
|
|
public: // XDataInputStream
|
|
virtual sal_Int8 SAL_CALL readBoolean() override
|
|
{ return ODataInputStream::readBoolean(); }
|
|
virtual sal_Int8 SAL_CALL readByte() override
|
|
{ return ODataInputStream::readByte(); }
|
|
virtual sal_Unicode SAL_CALL readChar() override
|
|
{ return ODataInputStream::readChar(); }
|
|
virtual sal_Int16 SAL_CALL readShort() override
|
|
{ return ODataInputStream::readShort(); }
|
|
virtual sal_Int32 SAL_CALL readLong() override
|
|
{ return ODataInputStream::readLong(); }
|
|
virtual sal_Int64 SAL_CALL readHyper() override
|
|
{ return ODataInputStream::readHyper(); }
|
|
virtual float SAL_CALL readFloat() override
|
|
{ return ODataInputStream::readFloat(); }
|
|
virtual double SAL_CALL readDouble() override
|
|
{ return ODataInputStream::readDouble(); }
|
|
virtual OUString SAL_CALL readUTF() override
|
|
{ return ODataInputStream::readUTF(); }
|
|
|
|
public: // XObjectInputStream
|
|
virtual Reference< XPersistObject > SAL_CALL readObject( ) override;
|
|
|
|
public: // XMarkableStream
|
|
virtual sal_Int32 SAL_CALL createMark() override;
|
|
virtual void SAL_CALL deleteMark(sal_Int32 Mark) override;
|
|
virtual void SAL_CALL jumpToMark(sal_Int32 nMark) override;
|
|
virtual void SAL_CALL jumpToFurthest() override;
|
|
virtual sal_Int32 SAL_CALL offsetToMark(sal_Int32 nMark) override;
|
|
|
|
public: // XServiceInfo
|
|
OUString SAL_CALL getImplementationName() override;
|
|
Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
|
|
sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override;
|
|
|
|
private:
|
|
void connectToMarkable();
|
|
private:
|
|
Reference < XMultiComponentFactory > m_rSMgr;
|
|
Reference < XComponentContext > m_rCxt;
|
|
bool m_bValidMarkable;
|
|
Reference < XMarkableStream > m_rMarkable;
|
|
std::vector < Reference< XPersistObject > > m_aPersistVector;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
Reference< XPersistObject > OObjectInputStream::readObject()
|
|
{
|
|
// check if chain contains a XMarkableStream
|
|
connectToMarkable();
|
|
|
|
Reference< XPersistObject > xLoadedObj;
|
|
|
|
// create Mark to skip newer versions
|
|
sal_uInt32 nMark = m_rMarkable->createMark();
|
|
// length of the data
|
|
sal_Int32 nLen = static_cast<sal_uInt16>(ODataInputStream::readShort());
|
|
if( nLen < 0xc )
|
|
{
|
|
throw WrongFormatException();
|
|
}
|
|
|
|
// read the object identifier
|
|
sal_uInt32 nId = readLong();
|
|
|
|
// the name of the persist model
|
|
// MM ???
|
|
OUString aName = readUTF();
|
|
|
|
// Read the length of the object
|
|
sal_Int32 nObjLen = readLong();
|
|
if( 0 == nId && 0 != nObjLen )
|
|
{
|
|
throw WrongFormatException();
|
|
}
|
|
|
|
// skip data of new version
|
|
skipBytes( nLen - m_rMarkable->offsetToMark( nMark ) );
|
|
|
|
bool bLoadSuccessful = true;
|
|
if( nId )
|
|
{
|
|
if( !aName.isEmpty() )
|
|
{
|
|
// load the object
|
|
Reference< XInterface > x = m_rSMgr->createInstanceWithContext( aName, m_rCxt );
|
|
xLoadedObj.set( x, UNO_QUERY );
|
|
if( xLoadedObj.is() )
|
|
{
|
|
sal_uInt32 nSize = m_aPersistVector.size();
|
|
if( nSize <= nId )
|
|
{
|
|
// grow to the right size
|
|
Reference< XPersistObject > xEmpty;
|
|
m_aPersistVector.insert( m_aPersistVector.end(), nId - nSize + 1, xEmpty );
|
|
}
|
|
|
|
m_aPersistVector[nId] = xLoadedObj;
|
|
xLoadedObj->read( Reference< XObjectInputStream >(
|
|
static_cast< XObjectInputStream * >(this) ) );
|
|
}
|
|
else
|
|
{
|
|
// no service with this name could be instantiated
|
|
bLoadSuccessful = false;
|
|
}
|
|
}
|
|
else {
|
|
if (nId >= m_aPersistVector.size())
|
|
{
|
|
// id unknown, load failure !
|
|
bLoadSuccessful = false;
|
|
}
|
|
else
|
|
{
|
|
// Object has already been read,
|
|
xLoadedObj = m_aPersistVector[nId];
|
|
}
|
|
}
|
|
}
|
|
|
|
// skip to the position behind the object
|
|
skipBytes( nObjLen + nLen - m_rMarkable->offsetToMark( nMark ) );
|
|
m_rMarkable->deleteMark( nMark );
|
|
|
|
if( ! bLoadSuccessful )
|
|
{
|
|
throw WrongFormatException();
|
|
}
|
|
return xLoadedObj;
|
|
}
|
|
|
|
|
|
void OObjectInputStream::connectToMarkable()
|
|
{
|
|
if( m_bValidMarkable ) return;
|
|
|
|
if( ! m_bValidStream )
|
|
{
|
|
throw NotConnectedException( );
|
|
}
|
|
|
|
// find the markable stream !
|
|
Reference< XInterface > rTry(m_input);
|
|
while( true ) {
|
|
if( ! rTry.is() )
|
|
{
|
|
throw NotConnectedException( );
|
|
}
|
|
Reference< XMarkableStream > markable( rTry , UNO_QUERY );
|
|
if( markable.is() )
|
|
{
|
|
m_rMarkable = std::move(markable);
|
|
break;
|
|
}
|
|
Reference < XActiveDataSink > sink( rTry , UNO_QUERY );
|
|
rTry = sink;
|
|
}
|
|
m_bValidMarkable = true;
|
|
}
|
|
|
|
sal_Int32 OObjectInputStream::createMark()
|
|
{
|
|
connectToMarkable(); // throws an exception, if a markable is not connected !
|
|
|
|
return m_rMarkable->createMark();
|
|
}
|
|
|
|
void OObjectInputStream::deleteMark(sal_Int32 Mark)
|
|
{
|
|
if( ! m_bValidMarkable )
|
|
{
|
|
throw NotConnectedException();
|
|
}
|
|
m_rMarkable->deleteMark( Mark );
|
|
}
|
|
|
|
void OObjectInputStream::jumpToMark(sal_Int32 nMark)
|
|
{
|
|
if( ! m_bValidMarkable )
|
|
{
|
|
throw NotConnectedException();
|
|
}
|
|
m_rMarkable->jumpToMark( nMark );
|
|
}
|
|
void OObjectInputStream::jumpToFurthest()
|
|
{
|
|
connectToMarkable();
|
|
m_rMarkable->jumpToFurthest();
|
|
}
|
|
|
|
sal_Int32 OObjectInputStream::offsetToMark(sal_Int32 nMark)
|
|
{
|
|
if( ! m_bValidMarkable )
|
|
{
|
|
throw NotConnectedException();
|
|
}
|
|
return m_rMarkable->offsetToMark( nMark );
|
|
}
|
|
|
|
// XServiceInfo
|
|
OUString OObjectInputStream::getImplementationName()
|
|
{
|
|
return u"com.sun.star.comp.io.stm.ObjectInputStream"_ustr;
|
|
}
|
|
|
|
// XServiceInfo
|
|
sal_Bool OObjectInputStream::supportsService(const OUString& ServiceName)
|
|
{
|
|
return cppu::supportsService(this, ServiceName);
|
|
}
|
|
|
|
// XServiceInfo
|
|
Sequence< OUString > OObjectInputStream::getSupportedServiceNames()
|
|
{
|
|
return { u"com.sun.star.io.ObjectInputStream"_ustr };
|
|
}
|
|
|
|
extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
|
|
io_OObjectInputStream_get_implementation(
|
|
css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
|
|
{
|
|
return cppu::acquire(new OObjectInputStream(context));
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|