1*cdf0e10cSrcweir /************************************************************************* 2*cdf0e10cSrcweir * 3*cdf0e10cSrcweir * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4*cdf0e10cSrcweir * 5*cdf0e10cSrcweir * Copyright 2000, 2010 Oracle and/or its affiliates. 6*cdf0e10cSrcweir * 7*cdf0e10cSrcweir * OpenOffice.org - a multi-platform office productivity suite 8*cdf0e10cSrcweir * 9*cdf0e10cSrcweir * This file is part of OpenOffice.org. 10*cdf0e10cSrcweir * 11*cdf0e10cSrcweir * OpenOffice.org is free software: you can redistribute it and/or modify 12*cdf0e10cSrcweir * it under the terms of the GNU Lesser General Public License version 3 13*cdf0e10cSrcweir * only, as published by the Free Software Foundation. 14*cdf0e10cSrcweir * 15*cdf0e10cSrcweir * OpenOffice.org is distributed in the hope that it will be useful, 16*cdf0e10cSrcweir * but WITHOUT ANY WARRANTY; without even the implied warranty of 17*cdf0e10cSrcweir * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18*cdf0e10cSrcweir * GNU Lesser General Public License version 3 for more details 19*cdf0e10cSrcweir * (a copy is included in the LICENSE file that accompanied this code). 20*cdf0e10cSrcweir * 21*cdf0e10cSrcweir * You should have received a copy of the GNU Lesser General Public License 22*cdf0e10cSrcweir * version 3 along with OpenOffice.org. If not, see 23*cdf0e10cSrcweir * <http://www.openoffice.org/license.html> 24*cdf0e10cSrcweir * for a copy of the LGPLv3 License. 25*cdf0e10cSrcweir * 26*cdf0e10cSrcweir ************************************************************************/ 27*cdf0e10cSrcweir 28*cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove 29*cdf0e10cSrcweir #include "precompiled_tools.hxx" 30*cdf0e10cSrcweir 31*cdf0e10cSrcweir #include <tools/debug.hxx> 32*cdf0e10cSrcweir #include <tools/pstm.hxx> 33*cdf0e10cSrcweir 34*cdf0e10cSrcweir #define STOR_NO_OPTIMIZE 35*cdf0e10cSrcweir 36*cdf0e10cSrcweir /***********************************************************************/ 37*cdf0e10cSrcweir /************************************************************************ 38*cdf0e10cSrcweir |* SvClassManager::Register() 39*cdf0e10cSrcweir *************************************************************************/ 40*cdf0e10cSrcweir void SvClassManager::Register( sal_uInt16 nClassId, SvCreateInstancePersist pFunc ) 41*cdf0e10cSrcweir { 42*cdf0e10cSrcweir #ifdef DBG_UTIL 43*cdf0e10cSrcweir SvCreateInstancePersist p; 44*cdf0e10cSrcweir p = Get( nClassId ); 45*cdf0e10cSrcweir DBG_ASSERT( !p || p == pFunc, "register class with same id" ); 46*cdf0e10cSrcweir #endif 47*cdf0e10cSrcweir aAssocTable.insert(Map::value_type(nClassId, pFunc)); 48*cdf0e10cSrcweir } 49*cdf0e10cSrcweir 50*cdf0e10cSrcweir /************************************************************************ 51*cdf0e10cSrcweir |* SvClassManager::Get() 52*cdf0e10cSrcweir *************************************************************************/ 53*cdf0e10cSrcweir SvCreateInstancePersist SvClassManager::Get( sal_uInt16 nClassId ) 54*cdf0e10cSrcweir { 55*cdf0e10cSrcweir Map::const_iterator i(aAssocTable.find(nClassId)); 56*cdf0e10cSrcweir return i == aAssocTable.end() ? 0 : i->second; 57*cdf0e10cSrcweir } 58*cdf0e10cSrcweir 59*cdf0e10cSrcweir /****************** SvRttiBase *******************************************/ 60*cdf0e10cSrcweir TYPEINIT0( SvRttiBase ); 61*cdf0e10cSrcweir 62*cdf0e10cSrcweir /****************** SvPersistBaseMemberList ******************************/ 63*cdf0e10cSrcweir 64*cdf0e10cSrcweir SvPersistBaseMemberList::SvPersistBaseMemberList(){} 65*cdf0e10cSrcweir SvPersistBaseMemberList::SvPersistBaseMemberList( 66*cdf0e10cSrcweir sal_uInt16 nInitSz, sal_uInt16 nResize ) 67*cdf0e10cSrcweir : SuperSvPersistBaseMemberList( nInitSz, nResize ){} 68*cdf0e10cSrcweir 69*cdf0e10cSrcweir #define PERSIST_LIST_VER (sal_uInt8)0 70*cdf0e10cSrcweir #define PERSIST_LIST_DBGUTIL (sal_uInt8)0x80 71*cdf0e10cSrcweir 72*cdf0e10cSrcweir /************************************************************************ 73*cdf0e10cSrcweir |* SvPersistBaseMemberList::WriteOnlyStreamedObjects() 74*cdf0e10cSrcweir *************************************************************************/ 75*cdf0e10cSrcweir void SvPersistBaseMemberList::WriteObjects( SvPersistStream & rStm, 76*cdf0e10cSrcweir sal_Bool bOnlyStreamed ) const 77*cdf0e10cSrcweir { 78*cdf0e10cSrcweir #ifdef STOR_NO_OPTIMIZE 79*cdf0e10cSrcweir rStm << (sal_uInt8)(PERSIST_LIST_VER | PERSIST_LIST_DBGUTIL); 80*cdf0e10cSrcweir sal_uInt32 nObjPos = rStm.WriteDummyLen(); 81*cdf0e10cSrcweir #else 82*cdf0e10cSrcweir sal_uInt8 bTmp = PERSIST_LIST_VER; 83*cdf0e10cSrcweir rStm << bTmp; 84*cdf0e10cSrcweir #endif 85*cdf0e10cSrcweir sal_uInt32 nCountMember = Count(); 86*cdf0e10cSrcweir sal_uIntPtr nCountPos = rStm.Tell(); 87*cdf0e10cSrcweir sal_uInt32 nWriteCount = 0; 88*cdf0e10cSrcweir rStm << nCountMember; 89*cdf0e10cSrcweir //bloss die Liste nicht veraendern, 90*cdf0e10cSrcweir //wegen Seiteneffekten beim Save 91*cdf0e10cSrcweir for( sal_uIntPtr n = 0; n < nCountMember; n++ ) 92*cdf0e10cSrcweir { 93*cdf0e10cSrcweir SvPersistBase * pObj = GetObject( n ); 94*cdf0e10cSrcweir if( !bOnlyStreamed || rStm.IsStreamed( pObj ) ) 95*cdf0e10cSrcweir { // Objekt soll geschrieben werden 96*cdf0e10cSrcweir rStm << GetObject( n ); 97*cdf0e10cSrcweir nWriteCount++; 98*cdf0e10cSrcweir } 99*cdf0e10cSrcweir } 100*cdf0e10cSrcweir if( nWriteCount != nCountMember ) 101*cdf0e10cSrcweir { 102*cdf0e10cSrcweir // nicht alle Objekte geschrieben, Count anpassen 103*cdf0e10cSrcweir sal_uIntPtr nPos = rStm.Tell(); 104*cdf0e10cSrcweir rStm.Seek( nCountPos ); 105*cdf0e10cSrcweir rStm << nWriteCount; 106*cdf0e10cSrcweir rStm.Seek( nPos ); 107*cdf0e10cSrcweir } 108*cdf0e10cSrcweir #ifdef STOR_NO_OPTIMIZE 109*cdf0e10cSrcweir rStm.WriteLen( nObjPos ); 110*cdf0e10cSrcweir #endif 111*cdf0e10cSrcweir } 112*cdf0e10cSrcweir 113*cdf0e10cSrcweir /************************************************************************ 114*cdf0e10cSrcweir |* operator << () 115*cdf0e10cSrcweir *************************************************************************/ 116*cdf0e10cSrcweir SvPersistStream& operator << ( SvPersistStream & rStm, 117*cdf0e10cSrcweir const SvPersistBaseMemberList & rLst ) 118*cdf0e10cSrcweir { 119*cdf0e10cSrcweir rLst.WriteObjects( rStm ); 120*cdf0e10cSrcweir return rStm; 121*cdf0e10cSrcweir } 122*cdf0e10cSrcweir 123*cdf0e10cSrcweir /************************************************************************ 124*cdf0e10cSrcweir |* operator >> () 125*cdf0e10cSrcweir *************************************************************************/ 126*cdf0e10cSrcweir SvPersistStream& operator >> ( SvPersistStream & rStm, 127*cdf0e10cSrcweir SvPersistBaseMemberList & rLst ) 128*cdf0e10cSrcweir { 129*cdf0e10cSrcweir sal_uInt8 nVer; 130*cdf0e10cSrcweir rStm >> nVer; 131*cdf0e10cSrcweir 132*cdf0e10cSrcweir if( (nVer & ~PERSIST_LIST_DBGUTIL) != PERSIST_LIST_VER ) 133*cdf0e10cSrcweir { 134*cdf0e10cSrcweir rStm.SetError( SVSTREAM_GENERALERROR ); 135*cdf0e10cSrcweir DBG_ERROR( "persist list, false version" ); 136*cdf0e10cSrcweir } 137*cdf0e10cSrcweir 138*cdf0e10cSrcweir sal_uInt32 nObjLen(0), nObjPos(0); 139*cdf0e10cSrcweir if( nVer & PERSIST_LIST_DBGUTIL ) 140*cdf0e10cSrcweir nObjLen = rStm.ReadLen( &nObjPos ); 141*cdf0e10cSrcweir 142*cdf0e10cSrcweir sal_uInt32 nCount; 143*cdf0e10cSrcweir rStm >> nCount; 144*cdf0e10cSrcweir for( sal_uIntPtr n = 0; n < nCount && rStm.GetError() == SVSTREAM_OK; n++ ) 145*cdf0e10cSrcweir { 146*cdf0e10cSrcweir SvPersistBase * pObj; 147*cdf0e10cSrcweir rStm >> pObj; 148*cdf0e10cSrcweir if( pObj ) 149*cdf0e10cSrcweir rLst.Append( pObj ); 150*cdf0e10cSrcweir } 151*cdf0e10cSrcweir #ifdef DBG_UTIL 152*cdf0e10cSrcweir if( nObjLen + nObjPos != rStm.Tell() ) 153*cdf0e10cSrcweir { 154*cdf0e10cSrcweir ByteString aStr( "false list len: read = " ); 155*cdf0e10cSrcweir aStr += ByteString::CreateFromInt32( (long)(rStm.Tell() - nObjPos) ); 156*cdf0e10cSrcweir aStr += ", should = "; 157*cdf0e10cSrcweir aStr += ByteString::CreateFromInt64(nObjLen); 158*cdf0e10cSrcweir DBG_ERROR( aStr.GetBuffer() ); 159*cdf0e10cSrcweir } 160*cdf0e10cSrcweir #endif 161*cdf0e10cSrcweir return rStm; 162*cdf0e10cSrcweir } 163*cdf0e10cSrcweir 164*cdf0e10cSrcweir //========================================================================= 165*cdf0e10cSrcweir SvPersistStream::SvPersistStream 166*cdf0e10cSrcweir ( 167*cdf0e10cSrcweir SvClassManager & rMgr, /* Alle Factorys, deren Objekt geladen und 168*cdf0e10cSrcweir gespeichert werdn k"onnen */ 169*cdf0e10cSrcweir SvStream * pStream, /* Dieser Stream wird als Medium genommen, auf 170*cdf0e10cSrcweir dem der PersistStream arbeitet */ 171*cdf0e10cSrcweir sal_uInt32 nStartIdxP /* Ab diesem Index werden die Id's f"ur 172*cdf0e10cSrcweir die Objekte vergeben, er muss gr"osser 173*cdf0e10cSrcweir als Null sein. */ 174*cdf0e10cSrcweir ) 175*cdf0e10cSrcweir : rClassMgr( rMgr ) 176*cdf0e10cSrcweir , pStm( pStream ) 177*cdf0e10cSrcweir , aPUIdx( nStartIdxP ) 178*cdf0e10cSrcweir , nStartIdx( nStartIdxP ) 179*cdf0e10cSrcweir , pRefStm( NULL ) 180*cdf0e10cSrcweir , nFlags( 0 ) 181*cdf0e10cSrcweir /* [Beschreibung] 182*cdf0e10cSrcweir 183*cdf0e10cSrcweir Der Konstruktor der Klasse SvPersistStream. Die Objekte rMgr und 184*cdf0e10cSrcweir pStream d"urfen nicht ver"andert werden, solange sie in einem 185*cdf0e10cSrcweir SvPersistStream eingesetzt sind. Eine Aussnahme gibt es f"ur 186*cdf0e10cSrcweir pStream (siehe <SvPersistStream::SetStream>). 187*cdf0e10cSrcweir */ 188*cdf0e10cSrcweir { 189*cdf0e10cSrcweir DBG_ASSERT( nStartIdx != 0, "zero index not allowed" ); 190*cdf0e10cSrcweir bIsWritable = sal_True; 191*cdf0e10cSrcweir if( pStm ) 192*cdf0e10cSrcweir { 193*cdf0e10cSrcweir SetVersion( pStm->GetVersion() ); 194*cdf0e10cSrcweir SetError( pStm->GetError() ); 195*cdf0e10cSrcweir SyncSvStream( pStm->Tell() ); 196*cdf0e10cSrcweir } 197*cdf0e10cSrcweir } 198*cdf0e10cSrcweir 199*cdf0e10cSrcweir //========================================================================= 200*cdf0e10cSrcweir SvPersistStream::SvPersistStream 201*cdf0e10cSrcweir ( 202*cdf0e10cSrcweir SvClassManager & rMgr, /* Alle Factorys, deren Objekt geladen und 203*cdf0e10cSrcweir gespeichert werdn k"onnen */ 204*cdf0e10cSrcweir SvStream * pStream, /* Dieser Stream wird als Medium genommen, auf 205*cdf0e10cSrcweir dem der PersistStream arbeitet */ 206*cdf0e10cSrcweir const SvPersistStream & rPersStm 207*cdf0e10cSrcweir /* Wenn PersistStream's verschachtelt werden, 208*cdf0e10cSrcweir dann ist dies der Parent-Stream. */ 209*cdf0e10cSrcweir ) 210*cdf0e10cSrcweir : rClassMgr( rMgr ) 211*cdf0e10cSrcweir , pStm( pStream ) 212*cdf0e10cSrcweir // Bereiche nicht ueberschneiden, deshalb nur groessere Indexe 213*cdf0e10cSrcweir , aPUIdx( rPersStm.GetCurMaxIndex() +1 ) 214*cdf0e10cSrcweir , nStartIdx( rPersStm.GetCurMaxIndex() +1 ) 215*cdf0e10cSrcweir , pRefStm( &rPersStm ) 216*cdf0e10cSrcweir , nFlags( 0 ) 217*cdf0e10cSrcweir /* [Beschreibung] 218*cdf0e10cSrcweir 219*cdf0e10cSrcweir Der Konstruktor der Klasse SvPersistStream. Die Objekte rMgr und 220*cdf0e10cSrcweir pStream d"urfen nicht ver"andert werden, solange sie in einem 221*cdf0e10cSrcweir SvPersistStream eingesetzt sind. Eine Aussnahme gibt es f"ur 222*cdf0e10cSrcweir pStream (siehe <SvPersistStream::SetStream>). 223*cdf0e10cSrcweir Durch diesen Konstruktor wird eine Hierarchiebildung unterst"utzt. 224*cdf0e10cSrcweir Alle Objekte aus einer Hierarchie m"ussen erst geladen werden, 225*cdf0e10cSrcweir wenn das erste aus dieser Hierarchie benutzt werden soll. 226*cdf0e10cSrcweir */ 227*cdf0e10cSrcweir { 228*cdf0e10cSrcweir bIsWritable = sal_True; 229*cdf0e10cSrcweir if( pStm ) 230*cdf0e10cSrcweir { 231*cdf0e10cSrcweir SetVersion( pStm->GetVersion() ); 232*cdf0e10cSrcweir SetError( pStm->GetError() ); 233*cdf0e10cSrcweir SyncSvStream( pStm->Tell() ); 234*cdf0e10cSrcweir } 235*cdf0e10cSrcweir } 236*cdf0e10cSrcweir 237*cdf0e10cSrcweir //========================================================================= 238*cdf0e10cSrcweir SvPersistStream::~SvPersistStream() 239*cdf0e10cSrcweir /* [Beschreibung] 240*cdf0e10cSrcweir 241*cdf0e10cSrcweir Der Detruktor ruft die Methode <SvPersistStream::SetStream> 242*cdf0e10cSrcweir mit NULL. 243*cdf0e10cSrcweir */ 244*cdf0e10cSrcweir { 245*cdf0e10cSrcweir SetStream( NULL ); 246*cdf0e10cSrcweir } 247*cdf0e10cSrcweir 248*cdf0e10cSrcweir //========================================================================= 249*cdf0e10cSrcweir void SvPersistStream::SetStream 250*cdf0e10cSrcweir ( 251*cdf0e10cSrcweir SvStream * pStream /* auf diesem Stream arbeitet der PersistStream */ 252*cdf0e10cSrcweir 253*cdf0e10cSrcweir ) 254*cdf0e10cSrcweir /* [Beschreibung] 255*cdf0e10cSrcweir 256*cdf0e10cSrcweir Es wird ein Medium (pStream) eingesetzt, auf dem PersistStream arbeitet. 257*cdf0e10cSrcweir Dieses darf nicht von aussen modifiziert werden, solange es 258*cdf0e10cSrcweir eingesetzt ist. Es sei denn, w"ahrend auf dem Medium gearbeitet 259*cdf0e10cSrcweir wird, wird keine Methode von SvPersistStream gerufen, bevor 260*cdf0e10cSrcweir nicht <SvPersistStream::SetStream> mit demselben Medium gerufen 261*cdf0e10cSrcweir wurde. 262*cdf0e10cSrcweir */ 263*cdf0e10cSrcweir { 264*cdf0e10cSrcweir if( pStm != pStream ) 265*cdf0e10cSrcweir { 266*cdf0e10cSrcweir if( pStm ) 267*cdf0e10cSrcweir { 268*cdf0e10cSrcweir SyncSysStream(); 269*cdf0e10cSrcweir pStm->SetError( GetError() ); 270*cdf0e10cSrcweir } 271*cdf0e10cSrcweir pStm = pStream; 272*cdf0e10cSrcweir } 273*cdf0e10cSrcweir if( pStm ) 274*cdf0e10cSrcweir { 275*cdf0e10cSrcweir SetVersion( pStm->GetVersion() ); 276*cdf0e10cSrcweir SetError( pStm->GetError() ); 277*cdf0e10cSrcweir SyncSvStream( pStm->Tell() ); 278*cdf0e10cSrcweir } 279*cdf0e10cSrcweir } 280*cdf0e10cSrcweir 281*cdf0e10cSrcweir //========================================================================= 282*cdf0e10cSrcweir sal_uInt16 SvPersistStream::IsA() const 283*cdf0e10cSrcweir /* [Beschreibung] 284*cdf0e10cSrcweir 285*cdf0e10cSrcweir Gibt den Identifier dieses Streamklasse zur"uck. 286*cdf0e10cSrcweir 287*cdf0e10cSrcweir [R"uckgabewert] 288*cdf0e10cSrcweir 289*cdf0e10cSrcweir sal_uInt16 ID_PERSISTSTREAM wird zur"uckgegeben. 290*cdf0e10cSrcweir 291*cdf0e10cSrcweir 292*cdf0e10cSrcweir [Querverweise] 293*cdf0e10cSrcweir 294*cdf0e10cSrcweir <SvStream::IsA> 295*cdf0e10cSrcweir */ 296*cdf0e10cSrcweir { 297*cdf0e10cSrcweir return ID_PERSISTSTREAM; 298*cdf0e10cSrcweir } 299*cdf0e10cSrcweir 300*cdf0e10cSrcweir 301*cdf0e10cSrcweir /************************************************************************* 302*cdf0e10cSrcweir |* SvPersistStream::ResetError() 303*cdf0e10cSrcweir *************************************************************************/ 304*cdf0e10cSrcweir void SvPersistStream::ResetError() 305*cdf0e10cSrcweir { 306*cdf0e10cSrcweir SvStream::ResetError(); 307*cdf0e10cSrcweir DBG_ASSERT( pStm, "stream not set" ); 308*cdf0e10cSrcweir pStm->ResetError(); 309*cdf0e10cSrcweir } 310*cdf0e10cSrcweir 311*cdf0e10cSrcweir /************************************************************************* 312*cdf0e10cSrcweir |* SvPersistStream::GetData() 313*cdf0e10cSrcweir *************************************************************************/ 314*cdf0e10cSrcweir sal_uIntPtr SvPersistStream::GetData( void* pData, sal_uIntPtr nSize ) 315*cdf0e10cSrcweir { 316*cdf0e10cSrcweir DBG_ASSERT( pStm, "stream not set" ); 317*cdf0e10cSrcweir sal_uIntPtr nRet = pStm->Read( pData, nSize ); 318*cdf0e10cSrcweir SetError( pStm->GetError() ); 319*cdf0e10cSrcweir return nRet; 320*cdf0e10cSrcweir } 321*cdf0e10cSrcweir 322*cdf0e10cSrcweir /************************************************************************* 323*cdf0e10cSrcweir |* SvPersistStream::PutData() 324*cdf0e10cSrcweir *************************************************************************/ 325*cdf0e10cSrcweir sal_uIntPtr SvPersistStream::PutData( const void* pData, sal_uIntPtr nSize ) 326*cdf0e10cSrcweir { 327*cdf0e10cSrcweir DBG_ASSERT( pStm, "stream not set" ); 328*cdf0e10cSrcweir sal_uIntPtr nRet = pStm->Write( pData, nSize ); 329*cdf0e10cSrcweir SetError( pStm->GetError() ); 330*cdf0e10cSrcweir return nRet; 331*cdf0e10cSrcweir } 332*cdf0e10cSrcweir 333*cdf0e10cSrcweir /************************************************************************* 334*cdf0e10cSrcweir |* SvPersistStream::Seek() 335*cdf0e10cSrcweir *************************************************************************/ 336*cdf0e10cSrcweir sal_uIntPtr SvPersistStream::SeekPos( sal_uIntPtr nPos ) 337*cdf0e10cSrcweir { 338*cdf0e10cSrcweir DBG_ASSERT( pStm, "stream not set" ); 339*cdf0e10cSrcweir sal_uIntPtr nRet = pStm->Seek( nPos ); 340*cdf0e10cSrcweir SetError( pStm->GetError() ); 341*cdf0e10cSrcweir return nRet; 342*cdf0e10cSrcweir } 343*cdf0e10cSrcweir 344*cdf0e10cSrcweir /************************************************************************* 345*cdf0e10cSrcweir |* SvPersistStream::FlushData() 346*cdf0e10cSrcweir *************************************************************************/ 347*cdf0e10cSrcweir void SvPersistStream::FlushData() 348*cdf0e10cSrcweir { 349*cdf0e10cSrcweir } 350*cdf0e10cSrcweir 351*cdf0e10cSrcweir /************************************************************************* 352*cdf0e10cSrcweir |* SvPersistStream::GetCurMaxIndex() 353*cdf0e10cSrcweir *************************************************************************/ 354*cdf0e10cSrcweir sal_uIntPtr SvPersistStream::GetCurMaxIndex( const SvPersistUIdx & rIdx ) const 355*cdf0e10cSrcweir { 356*cdf0e10cSrcweir // const bekomme ich nicht den hoechsten Index 357*cdf0e10cSrcweir SvPersistUIdx * p = (SvPersistUIdx *)&rIdx; 358*cdf0e10cSrcweir // alten merken 359*cdf0e10cSrcweir sal_uIntPtr nCurIdx = p->GetCurIndex(); 360*cdf0e10cSrcweir p->Last(); 361*cdf0e10cSrcweir // Bereiche nicht ueberschneiden, deshalb nur groessere Indexe 362*cdf0e10cSrcweir sal_uIntPtr nMaxIdx = p->GetCurIndex(); 363*cdf0e10cSrcweir // wieder herstellen 364*cdf0e10cSrcweir p->Seek( nCurIdx ); 365*cdf0e10cSrcweir return nMaxIdx; 366*cdf0e10cSrcweir } 367*cdf0e10cSrcweir 368*cdf0e10cSrcweir /************************************************************************* 369*cdf0e10cSrcweir |* SvPersistStream::GetIndex() 370*cdf0e10cSrcweir *************************************************************************/ 371*cdf0e10cSrcweir sal_uIntPtr SvPersistStream::GetIndex( SvPersistBase * pObj ) const 372*cdf0e10cSrcweir { 373*cdf0e10cSrcweir sal_uIntPtr nId = (sal_uIntPtr)aPTable.Get( (sal_uIntPtr)pObj ); 374*cdf0e10cSrcweir if( !nId && pRefStm ) 375*cdf0e10cSrcweir return pRefStm->GetIndex( pObj ); 376*cdf0e10cSrcweir return nId; 377*cdf0e10cSrcweir } 378*cdf0e10cSrcweir 379*cdf0e10cSrcweir /************************************************************************* 380*cdf0e10cSrcweir |* SvPersistStream::GetObject) 381*cdf0e10cSrcweir *************************************************************************/ 382*cdf0e10cSrcweir SvPersistBase * SvPersistStream::GetObject( sal_uIntPtr nIdx ) const 383*cdf0e10cSrcweir { 384*cdf0e10cSrcweir if( nIdx >= nStartIdx ) 385*cdf0e10cSrcweir return aPUIdx.Get( nIdx ); 386*cdf0e10cSrcweir else if( pRefStm ) 387*cdf0e10cSrcweir return pRefStm->GetObject( nIdx ); 388*cdf0e10cSrcweir return NULL; 389*cdf0e10cSrcweir } 390*cdf0e10cSrcweir 391*cdf0e10cSrcweir //========================================================================= 392*cdf0e10cSrcweir #define LEN_1 0x80 393*cdf0e10cSrcweir #define LEN_2 0x40 394*cdf0e10cSrcweir #define LEN_4 0x20 395*cdf0e10cSrcweir #define LEN_5 0x10 396*cdf0e10cSrcweir sal_uInt32 SvPersistStream::ReadCompressed 397*cdf0e10cSrcweir ( 398*cdf0e10cSrcweir SvStream & rStm /* Aus diesem Stream werden die komprimierten Daten 399*cdf0e10cSrcweir gelesen */ 400*cdf0e10cSrcweir ) 401*cdf0e10cSrcweir /* [Beschreibung] 402*cdf0e10cSrcweir 403*cdf0e10cSrcweir Ein im Stream komprimiert abgelegtes Wort wird gelesen. In welchem 404*cdf0e10cSrcweir Format komprimiert wird, siehe <SvPersistStream::WriteCompressed>. 405*cdf0e10cSrcweir 406*cdf0e10cSrcweir [R"uckgabewert] 407*cdf0e10cSrcweir 408*cdf0e10cSrcweir sal_uInt32 Das nicht komprimierte Wort wird zur"uckgegeben. 409*cdf0e10cSrcweir 410*cdf0e10cSrcweir [Querverweise] 411*cdf0e10cSrcweir 412*cdf0e10cSrcweir */ 413*cdf0e10cSrcweir { 414*cdf0e10cSrcweir sal_uInt32 nRet(0); 415*cdf0e10cSrcweir sal_uInt8 nMask; 416*cdf0e10cSrcweir rStm >> nMask; 417*cdf0e10cSrcweir if( nMask & LEN_1 ) 418*cdf0e10cSrcweir nRet = ~LEN_1 & nMask; 419*cdf0e10cSrcweir else if( nMask & LEN_2 ) 420*cdf0e10cSrcweir { 421*cdf0e10cSrcweir nRet = ~LEN_2 & nMask; 422*cdf0e10cSrcweir nRet <<= 8; 423*cdf0e10cSrcweir rStm >> nMask; 424*cdf0e10cSrcweir nRet |= nMask; 425*cdf0e10cSrcweir } 426*cdf0e10cSrcweir else if( nMask & LEN_4 ) 427*cdf0e10cSrcweir { 428*cdf0e10cSrcweir nRet = ~LEN_4 & nMask; 429*cdf0e10cSrcweir nRet <<= 8; 430*cdf0e10cSrcweir rStm >> nMask; 431*cdf0e10cSrcweir nRet |= nMask; 432*cdf0e10cSrcweir nRet <<= 16; 433*cdf0e10cSrcweir sal_uInt16 n; 434*cdf0e10cSrcweir rStm >> n; 435*cdf0e10cSrcweir nRet |= n; 436*cdf0e10cSrcweir } 437*cdf0e10cSrcweir else if( nMask & LEN_5 ) 438*cdf0e10cSrcweir { 439*cdf0e10cSrcweir if( nMask & 0x0F ) 440*cdf0e10cSrcweir { 441*cdf0e10cSrcweir rStm.SetError( SVSTREAM_FILEFORMAT_ERROR ); 442*cdf0e10cSrcweir DBG_ERROR( "format error" ); 443*cdf0e10cSrcweir } 444*cdf0e10cSrcweir rStm >> nRet; 445*cdf0e10cSrcweir } 446*cdf0e10cSrcweir else 447*cdf0e10cSrcweir { 448*cdf0e10cSrcweir rStm.SetError( SVSTREAM_FILEFORMAT_ERROR ); 449*cdf0e10cSrcweir DBG_ERROR( "format error" ); 450*cdf0e10cSrcweir } 451*cdf0e10cSrcweir return nRet; 452*cdf0e10cSrcweir } 453*cdf0e10cSrcweir 454*cdf0e10cSrcweir //========================================================================= 455*cdf0e10cSrcweir void SvPersistStream::WriteCompressed 456*cdf0e10cSrcweir ( 457*cdf0e10cSrcweir SvStream & rStm,/* Aus diesem Stream werden die komprimierten Daten 458*cdf0e10cSrcweir gelesen */ 459*cdf0e10cSrcweir sal_uInt32 nVal /* Dieser Wert wird komprimiert geschrieben */ 460*cdf0e10cSrcweir ) 461*cdf0e10cSrcweir /* [Beschreibung] 462*cdf0e10cSrcweir 463*cdf0e10cSrcweir Das "ubergebene Wort wird komprimiert und in den Stream 464*cdf0e10cSrcweir geschrieben. Folgendermassen wir komprimiert. 465*cdf0e10cSrcweir nVal < 0x80 => 0x80 + nVal ist 1 Byte gross. 466*cdf0e10cSrcweir nVal < 0x4000 => 0x4000 + nVal ist 2 Byte gross. 467*cdf0e10cSrcweir nVal < 0x20000000 => 0x20000000 + nVal ist 4 Byte gross. 468*cdf0e10cSrcweir nVal > 0x1FFFFFFF => 0x1000000000+ nVal ist 5 Byte gross. 469*cdf0e10cSrcweir 470*cdf0e10cSrcweir [Querverweise] 471*cdf0e10cSrcweir 472*cdf0e10cSrcweir <SvPersistStream::ReadCompressed> 473*cdf0e10cSrcweir */ 474*cdf0e10cSrcweir { 475*cdf0e10cSrcweir #ifdef STOR_NO_OPTIMIZE 476*cdf0e10cSrcweir if( nVal < 0x80 ) 477*cdf0e10cSrcweir rStm << (sal_uInt8)(LEN_1 | nVal); 478*cdf0e10cSrcweir else if( nVal < 0x4000 ) 479*cdf0e10cSrcweir { 480*cdf0e10cSrcweir rStm << (sal_uInt8)(LEN_2 | (nVal >> 8)); 481*cdf0e10cSrcweir rStm << (sal_uInt8)nVal; 482*cdf0e10cSrcweir } 483*cdf0e10cSrcweir else if( nVal < 0x20000000 ) 484*cdf0e10cSrcweir { 485*cdf0e10cSrcweir // hoechstes sal_uInt8 486*cdf0e10cSrcweir rStm << (sal_uInt8)(LEN_4 | (nVal >> 24)); 487*cdf0e10cSrcweir // 2. hoechstes sal_uInt8 488*cdf0e10cSrcweir rStm << (sal_uInt8)(nVal >> 16); 489*cdf0e10cSrcweir rStm << (sal_uInt16)(nVal); 490*cdf0e10cSrcweir } 491*cdf0e10cSrcweir else 492*cdf0e10cSrcweir #endif 493*cdf0e10cSrcweir { 494*cdf0e10cSrcweir rStm << (sal_uInt8)LEN_5; 495*cdf0e10cSrcweir rStm << nVal; 496*cdf0e10cSrcweir } 497*cdf0e10cSrcweir } 498*cdf0e10cSrcweir 499*cdf0e10cSrcweir //========================================================================= 500*cdf0e10cSrcweir sal_uInt32 SvPersistStream::WriteDummyLen() 501*cdf0e10cSrcweir /* [Beschreibung] 502*cdf0e10cSrcweir 503*cdf0e10cSrcweir Die Methode schreibt 4 Byte in den Stream und gibt die Streamposition 504*cdf0e10cSrcweir zur"uck. 505*cdf0e10cSrcweir 506*cdf0e10cSrcweir [R"uckgabewert] 507*cdf0e10cSrcweir 508*cdf0e10cSrcweir sal_uInt32 Die Position hinter der L"angenangabe wird zur"uckgegeben. 509*cdf0e10cSrcweir 510*cdf0e10cSrcweir [Beispiel] 511*cdf0e10cSrcweir 512*cdf0e10cSrcweir sal_uInt32 nObjPos = rStm.WriteDummyLen(); 513*cdf0e10cSrcweir ... 514*cdf0e10cSrcweir // Daten schreiben 515*cdf0e10cSrcweir ... 516*cdf0e10cSrcweir rStm.WriteLen( nObjPos ); 517*cdf0e10cSrcweir 518*cdf0e10cSrcweir [Querverweise] 519*cdf0e10cSrcweir 520*cdf0e10cSrcweir <SvPersistStream::ReadLen>, <SvPersistStream::WriteLen> 521*cdf0e10cSrcweir 522*cdf0e10cSrcweir */ 523*cdf0e10cSrcweir { 524*cdf0e10cSrcweir #ifdef DBG_UTIL 525*cdf0e10cSrcweir sal_uInt32 nPos = Tell(); 526*cdf0e10cSrcweir #endif 527*cdf0e10cSrcweir sal_uInt32 n0 = 0; 528*cdf0e10cSrcweir *this << n0; // wegen Sun sp 529*cdf0e10cSrcweir // keine Assertion bei Streamfehler 530*cdf0e10cSrcweir DBG_ASSERT( GetError() != SVSTREAM_OK 531*cdf0e10cSrcweir || (sizeof( sal_uInt32 ) == Tell() -nPos), 532*cdf0e10cSrcweir "keine 4-Byte fuer Langenangabe" ); 533*cdf0e10cSrcweir return Tell(); 534*cdf0e10cSrcweir } 535*cdf0e10cSrcweir 536*cdf0e10cSrcweir //========================================================================= 537*cdf0e10cSrcweir void SvPersistStream::WriteLen 538*cdf0e10cSrcweir ( 539*cdf0e10cSrcweir sal_uInt32 nObjPos /* die Position + 4, an der die L"ange geschrieben 540*cdf0e10cSrcweir wird. */ 541*cdf0e10cSrcweir ) 542*cdf0e10cSrcweir /* [Beschreibung] 543*cdf0e10cSrcweir 544*cdf0e10cSrcweir Die Methode schreibt die Differenz zwischen der aktuellen und 545*cdf0e10cSrcweir nObjPos als sal_uInt32 an die Position nObjPos -4 im Stream. Danach 546*cdf0e10cSrcweir wird der Stream wieder auf die alte Position gestellt. 547*cdf0e10cSrcweir 548*cdf0e10cSrcweir [Beispiel] 549*cdf0e10cSrcweir 550*cdf0e10cSrcweir Die Differenz enth"alt nicht die L"angenangabe. 551*cdf0e10cSrcweir 552*cdf0e10cSrcweir sal_uInt32 nObjPos = rStm.WriteDummyLen(); 553*cdf0e10cSrcweir ... 554*cdf0e10cSrcweir // Daten schreiben 555*cdf0e10cSrcweir ... 556*cdf0e10cSrcweir rStm.WriteLen( nObjPos ); 557*cdf0e10cSrcweir // weitere Daten schreiben 558*cdf0e10cSrcweir 559*cdf0e10cSrcweir [Querverweise] 560*cdf0e10cSrcweir 561*cdf0e10cSrcweir <SvPersistStream::ReadLen>, <SvPersistStream::WriteDummyLen> 562*cdf0e10cSrcweir */ 563*cdf0e10cSrcweir { 564*cdf0e10cSrcweir sal_uInt32 nPos = Tell(); 565*cdf0e10cSrcweir sal_uInt32 nLen = nPos - nObjPos; 566*cdf0e10cSrcweir // die Laenge mu� im stream 4-Byte betragen 567*cdf0e10cSrcweir Seek( nObjPos - sizeof( sal_uInt32 ) ); 568*cdf0e10cSrcweir // Laenge schreiben 569*cdf0e10cSrcweir *this << nLen; 570*cdf0e10cSrcweir Seek( nPos ); 571*cdf0e10cSrcweir } 572*cdf0e10cSrcweir 573*cdf0e10cSrcweir //========================================================================= 574*cdf0e10cSrcweir sal_uInt32 SvPersistStream::ReadLen 575*cdf0e10cSrcweir ( 576*cdf0e10cSrcweir sal_uInt32 * pTestPos /* Die Position des Streams, nach dem Lesen der 577*cdf0e10cSrcweir L"ange, wird zur"uckgegeben. Es darf auch NULL 578*cdf0e10cSrcweir "ubergeben werden. */ 579*cdf0e10cSrcweir ) 580*cdf0e10cSrcweir /* [Beschreibung] 581*cdf0e10cSrcweir 582*cdf0e10cSrcweir Liest die L"ange die vorher mit <SvPersistStream::WriteDummyLen> 583*cdf0e10cSrcweir und <SvPersistStream::WriteLen> geschrieben wurde. 584*cdf0e10cSrcweir */ 585*cdf0e10cSrcweir { 586*cdf0e10cSrcweir sal_uInt32 nLen; 587*cdf0e10cSrcweir *this >> nLen; 588*cdf0e10cSrcweir if( pTestPos ) 589*cdf0e10cSrcweir *pTestPos = Tell(); 590*cdf0e10cSrcweir return nLen; 591*cdf0e10cSrcweir } 592*cdf0e10cSrcweir 593*cdf0e10cSrcweir //========================================================================= 594*cdf0e10cSrcweir // Dateirormat abw"arts kompatibel 595*cdf0e10cSrcweir #ifdef STOR_NO_OPTIMIZE 596*cdf0e10cSrcweir #define P_VER (sal_uInt8)0x00 597*cdf0e10cSrcweir #else 598*cdf0e10cSrcweir #define P_VER (sal_uInt8)0x01 599*cdf0e10cSrcweir #endif 600*cdf0e10cSrcweir #define P_VER_MASK (sal_uInt8)0x0F 601*cdf0e10cSrcweir #define P_ID_0 (sal_uInt8)0x80 602*cdf0e10cSrcweir #define P_OBJ (sal_uInt8)0x40 603*cdf0e10cSrcweir #define P_DBGUTIL (sal_uInt8)0x20 604*cdf0e10cSrcweir #define P_ID (sal_uInt8)0x10 605*cdf0e10cSrcweir #ifdef STOR_NO_OPTIMIZE 606*cdf0e10cSrcweir #define P_STD P_DBGUTIL 607*cdf0e10cSrcweir #else 608*cdf0e10cSrcweir #define P_STD 0 609*cdf0e10cSrcweir #endif 610*cdf0e10cSrcweir 611*cdf0e10cSrcweir static void WriteId 612*cdf0e10cSrcweir ( 613*cdf0e10cSrcweir SvStream & rStm, 614*cdf0e10cSrcweir sal_uInt8 nHdr, 615*cdf0e10cSrcweir sal_uInt32 nId, 616*cdf0e10cSrcweir sal_uInt16 nClassId 617*cdf0e10cSrcweir ) 618*cdf0e10cSrcweir { 619*cdf0e10cSrcweir #ifdef STOR_NO_OPTIMIZE 620*cdf0e10cSrcweir nHdr |= P_ID; 621*cdf0e10cSrcweir #endif 622*cdf0e10cSrcweir nHdr |= P_VER; 623*cdf0e10cSrcweir if( nHdr & P_ID ) 624*cdf0e10cSrcweir { 625*cdf0e10cSrcweir if( (nHdr & P_OBJ) || nId != 0 ) 626*cdf0e10cSrcweir { // Id nur bei Zeiger, oder DBGUTIL 627*cdf0e10cSrcweir rStm << (sal_uInt8)(nHdr); 628*cdf0e10cSrcweir SvPersistStream::WriteCompressed( rStm, nId ); 629*cdf0e10cSrcweir } 630*cdf0e10cSrcweir else 631*cdf0e10cSrcweir { // NULL Pointer 632*cdf0e10cSrcweir rStm << (sal_uInt8)(nHdr | P_ID_0); 633*cdf0e10cSrcweir return; 634*cdf0e10cSrcweir } 635*cdf0e10cSrcweir } 636*cdf0e10cSrcweir else 637*cdf0e10cSrcweir rStm << nHdr; 638*cdf0e10cSrcweir 639*cdf0e10cSrcweir if( (nHdr & P_DBGUTIL) || (nHdr & P_OBJ) ) 640*cdf0e10cSrcweir // Objekte haben immer eine Klasse, 641*cdf0e10cSrcweir // Pointer nur bei DBG_UTIL und != NULL 642*cdf0e10cSrcweir SvPersistStream::WriteCompressed( rStm, nClassId ); 643*cdf0e10cSrcweir } 644*cdf0e10cSrcweir 645*cdf0e10cSrcweir //========================================================================= 646*cdf0e10cSrcweir static void ReadId 647*cdf0e10cSrcweir ( 648*cdf0e10cSrcweir SvStream & rStm, 649*cdf0e10cSrcweir sal_uInt8 & nHdr, 650*cdf0e10cSrcweir sal_uInt32 & nId, 651*cdf0e10cSrcweir sal_uInt16 & nClassId 652*cdf0e10cSrcweir ) 653*cdf0e10cSrcweir { 654*cdf0e10cSrcweir nClassId = 0; 655*cdf0e10cSrcweir rStm >> nHdr; 656*cdf0e10cSrcweir if( nHdr & P_ID_0 ) 657*cdf0e10cSrcweir nId = 0; 658*cdf0e10cSrcweir else 659*cdf0e10cSrcweir { 660*cdf0e10cSrcweir if( (nHdr & P_VER_MASK) == 0 ) 661*cdf0e10cSrcweir { 662*cdf0e10cSrcweir if( (nHdr & P_DBGUTIL) || !(nHdr & P_OBJ) ) 663*cdf0e10cSrcweir nId = SvPersistStream::ReadCompressed( rStm ); 664*cdf0e10cSrcweir else 665*cdf0e10cSrcweir nId = 0; 666*cdf0e10cSrcweir } 667*cdf0e10cSrcweir else if( nHdr & P_ID ) 668*cdf0e10cSrcweir nId = SvPersistStream::ReadCompressed( rStm ); 669*cdf0e10cSrcweir 670*cdf0e10cSrcweir if( (nHdr & P_DBGUTIL) || (nHdr & P_OBJ) ) 671*cdf0e10cSrcweir nClassId = (sal_uInt16)SvPersistStream::ReadCompressed( rStm ); 672*cdf0e10cSrcweir } 673*cdf0e10cSrcweir } 674*cdf0e10cSrcweir 675*cdf0e10cSrcweir //========================================================================= 676*cdf0e10cSrcweir void SvPersistStream::WriteObj 677*cdf0e10cSrcweir ( 678*cdf0e10cSrcweir sal_uInt8 nHdr, 679*cdf0e10cSrcweir SvPersistBase * pObj 680*cdf0e10cSrcweir ) 681*cdf0e10cSrcweir { 682*cdf0e10cSrcweir #ifdef STOR_NO_OPTIMIZE 683*cdf0e10cSrcweir sal_uInt32 nObjPos = 0; 684*cdf0e10cSrcweir if( nHdr & P_DBGUTIL ) 685*cdf0e10cSrcweir // Position fuer Laenge merken 686*cdf0e10cSrcweir nObjPos = WriteDummyLen(); 687*cdf0e10cSrcweir #endif 688*cdf0e10cSrcweir pObj->Save( *this ); 689*cdf0e10cSrcweir #ifdef STOR_NO_OPTIMIZE 690*cdf0e10cSrcweir if( nHdr & P_DBGUTIL ) 691*cdf0e10cSrcweir WriteLen( nObjPos ); 692*cdf0e10cSrcweir #endif 693*cdf0e10cSrcweir } 694*cdf0e10cSrcweir 695*cdf0e10cSrcweir //========================================================================= 696*cdf0e10cSrcweir SvPersistStream& SvPersistStream::WritePointer 697*cdf0e10cSrcweir ( 698*cdf0e10cSrcweir SvPersistBase * pObj 699*cdf0e10cSrcweir ) 700*cdf0e10cSrcweir { 701*cdf0e10cSrcweir sal_uInt8 nP = P_STD; 702*cdf0e10cSrcweir 703*cdf0e10cSrcweir if( pObj ) 704*cdf0e10cSrcweir { 705*cdf0e10cSrcweir sal_uIntPtr nId = GetIndex( pObj ); 706*cdf0e10cSrcweir if( nId ) 707*cdf0e10cSrcweir nP |= P_ID; 708*cdf0e10cSrcweir else 709*cdf0e10cSrcweir { 710*cdf0e10cSrcweir nId = aPUIdx.Insert( pObj ); 711*cdf0e10cSrcweir aPTable.Insert( (sal_uIntPtr)pObj, (void *)nId ); 712*cdf0e10cSrcweir nP |= P_OBJ; 713*cdf0e10cSrcweir } 714*cdf0e10cSrcweir WriteId( *this, nP, nId, pObj->GetClassId() ); 715*cdf0e10cSrcweir if( nP & P_OBJ ) 716*cdf0e10cSrcweir WriteObj( nP, pObj ); 717*cdf0e10cSrcweir } 718*cdf0e10cSrcweir else 719*cdf0e10cSrcweir { // NULL Pointer 720*cdf0e10cSrcweir WriteId( *this, nP | P_ID, 0, 0 ); 721*cdf0e10cSrcweir } 722*cdf0e10cSrcweir return *this; 723*cdf0e10cSrcweir } 724*cdf0e10cSrcweir 725*cdf0e10cSrcweir //========================================================================= 726*cdf0e10cSrcweir sal_uInt32 SvPersistStream::ReadObj 727*cdf0e10cSrcweir ( 728*cdf0e10cSrcweir SvPersistBase * & rpObj, 729*cdf0e10cSrcweir sal_Bool bRegister 730*cdf0e10cSrcweir ) 731*cdf0e10cSrcweir { 732*cdf0e10cSrcweir sal_uInt8 nHdr; 733*cdf0e10cSrcweir sal_uInt32 nId = 0; 734*cdf0e10cSrcweir sal_uInt16 nClassId; 735*cdf0e10cSrcweir 736*cdf0e10cSrcweir rpObj = NULL; // Spezifikation: Im Fehlerfall 0. 737*cdf0e10cSrcweir ReadId( *this, nHdr, nId, nClassId ); 738*cdf0e10cSrcweir 739*cdf0e10cSrcweir // reine Versionsnummer durch maskieren 740*cdf0e10cSrcweir if( P_VER < (nHdr & P_VER_MASK) ) 741*cdf0e10cSrcweir { 742*cdf0e10cSrcweir SetError( SVSTREAM_FILEFORMAT_ERROR ); 743*cdf0e10cSrcweir DBG_ERROR( "false version" ); 744*cdf0e10cSrcweir } 745*cdf0e10cSrcweir 746*cdf0e10cSrcweir if( !(nHdr & P_ID_0) && GetError() == SVSTREAM_OK ) 747*cdf0e10cSrcweir { 748*cdf0e10cSrcweir if( P_OBJ & nHdr ) 749*cdf0e10cSrcweir { // read object, nId nur bei P_DBGUTIL gesetzt 750*cdf0e10cSrcweir DBG_ASSERT( !(nHdr & P_DBGUTIL) || NULL == aPUIdx.Get( nId ), 751*cdf0e10cSrcweir "object already exist" ); 752*cdf0e10cSrcweir SvCreateInstancePersist pFunc = rClassMgr.Get( nClassId ); 753*cdf0e10cSrcweir 754*cdf0e10cSrcweir sal_uInt32 nObjLen(0), nObjPos(0); 755*cdf0e10cSrcweir if( nHdr & P_DBGUTIL ) 756*cdf0e10cSrcweir nObjLen = ReadLen( &nObjPos ); 757*cdf0e10cSrcweir if( !pFunc ) 758*cdf0e10cSrcweir { 759*cdf0e10cSrcweir #ifdef DBG_UTIL 760*cdf0e10cSrcweir ByteString aStr( "no class with id: " ); 761*cdf0e10cSrcweir aStr += ByteString::CreateFromInt32( nClassId ); 762*cdf0e10cSrcweir aStr += " registered"; 763*cdf0e10cSrcweir DBG_WARNING( aStr.GetBuffer() ); 764*cdf0e10cSrcweir #endif 765*cdf0e10cSrcweir SetError( ERRCODE_IO_NOFACTORY ); 766*cdf0e10cSrcweir return 0; 767*cdf0e10cSrcweir } 768*cdf0e10cSrcweir pFunc( &rpObj ); 769*cdf0e10cSrcweir // Sichern 770*cdf0e10cSrcweir rpObj->AddRef(); 771*cdf0e10cSrcweir 772*cdf0e10cSrcweir if( bRegister ) 773*cdf0e10cSrcweir { 774*cdf0e10cSrcweir // unbedingt erst in Tabelle eintragen 775*cdf0e10cSrcweir sal_uIntPtr nNewId = aPUIdx.Insert( rpObj ); 776*cdf0e10cSrcweir // um den gleichen Zustand, wie nach dem Speichern herzustellen 777*cdf0e10cSrcweir aPTable.Insert( (sal_uIntPtr)rpObj, (void *)nNewId ); 778*cdf0e10cSrcweir DBG_ASSERT( !(nHdr & P_DBGUTIL) || nId == nNewId, 779*cdf0e10cSrcweir "read write id conflict: not the same" ); 780*cdf0e10cSrcweir } 781*cdf0e10cSrcweir // und dann Laden 782*cdf0e10cSrcweir rpObj->Load( *this ); 783*cdf0e10cSrcweir #ifdef DBG_UTIL 784*cdf0e10cSrcweir if( nObjLen + nObjPos != Tell() ) 785*cdf0e10cSrcweir { 786*cdf0e10cSrcweir ByteString aStr( "false object len: read = " ); 787*cdf0e10cSrcweir aStr += ByteString::CreateFromInt32( (long)(Tell() - nObjPos) ); 788*cdf0e10cSrcweir aStr += ", should = "; 789*cdf0e10cSrcweir aStr += ByteString::CreateFromInt32( nObjLen ); 790*cdf0e10cSrcweir DBG_ERROR( aStr.GetBuffer() ); 791*cdf0e10cSrcweir } 792*cdf0e10cSrcweir #endif 793*cdf0e10cSrcweir rpObj->RestoreNoDelete(); 794*cdf0e10cSrcweir rpObj->ReleaseRef(); 795*cdf0e10cSrcweir } 796*cdf0e10cSrcweir else 797*cdf0e10cSrcweir { 798*cdf0e10cSrcweir rpObj = GetObject( nId ); 799*cdf0e10cSrcweir DBG_ASSERT( rpObj != NULL, "object does not exist" ); 800*cdf0e10cSrcweir DBG_ASSERT( rpObj->GetClassId() == nClassId, "class mismatch" ); 801*cdf0e10cSrcweir } 802*cdf0e10cSrcweir } 803*cdf0e10cSrcweir return nId; 804*cdf0e10cSrcweir } 805*cdf0e10cSrcweir 806*cdf0e10cSrcweir //========================================================================= 807*cdf0e10cSrcweir SvPersistStream& SvPersistStream::ReadPointer 808*cdf0e10cSrcweir ( 809*cdf0e10cSrcweir SvPersistBase * & rpObj 810*cdf0e10cSrcweir ) 811*cdf0e10cSrcweir { 812*cdf0e10cSrcweir ReadObj( rpObj, sal_True ); 813*cdf0e10cSrcweir return *this; 814*cdf0e10cSrcweir } 815*cdf0e10cSrcweir 816*cdf0e10cSrcweir //========================================================================= 817*cdf0e10cSrcweir SvPersistStream& operator << 818*cdf0e10cSrcweir ( 819*cdf0e10cSrcweir SvPersistStream & rStm, 820*cdf0e10cSrcweir SvPersistBase * pObj 821*cdf0e10cSrcweir ) 822*cdf0e10cSrcweir { 823*cdf0e10cSrcweir return rStm.WritePointer( pObj ); 824*cdf0e10cSrcweir } 825*cdf0e10cSrcweir 826*cdf0e10cSrcweir //========================================================================= 827*cdf0e10cSrcweir SvPersistStream& operator >> 828*cdf0e10cSrcweir ( 829*cdf0e10cSrcweir SvPersistStream & rStm, 830*cdf0e10cSrcweir SvPersistBase * & rpObj 831*cdf0e10cSrcweir ) 832*cdf0e10cSrcweir { 833*cdf0e10cSrcweir return rStm.ReadPointer( rpObj ); 834*cdf0e10cSrcweir } 835*cdf0e10cSrcweir 836*cdf0e10cSrcweir //========================================================================= 837*cdf0e10cSrcweir SvStream& operator << 838*cdf0e10cSrcweir ( 839*cdf0e10cSrcweir SvStream & rStm, 840*cdf0e10cSrcweir SvPersistStream & rThis 841*cdf0e10cSrcweir ) 842*cdf0e10cSrcweir { 843*cdf0e10cSrcweir SvStream * pOldStm = rThis.GetStream(); 844*cdf0e10cSrcweir rThis.SetStream( &rStm ); 845*cdf0e10cSrcweir 846*cdf0e10cSrcweir sal_uInt8 bTmp = 0; 847*cdf0e10cSrcweir rThis << bTmp; // Version 848*cdf0e10cSrcweir sal_uInt32 nCount = (sal_uInt32)rThis.aPUIdx.Count(); 849*cdf0e10cSrcweir rThis << nCount; 850*cdf0e10cSrcweir SvPersistBase * pEle = rThis.aPUIdx.First(); 851*cdf0e10cSrcweir for( sal_uInt32 i = 0; i < nCount; i++ ) 852*cdf0e10cSrcweir { 853*cdf0e10cSrcweir sal_uInt8 nP = P_OBJ | P_ID | P_STD; 854*cdf0e10cSrcweir WriteId( rThis, nP, rThis.aPUIdx.GetCurIndex(), 855*cdf0e10cSrcweir pEle->GetClassId() ); 856*cdf0e10cSrcweir rThis.WriteObj( nP, pEle ); 857*cdf0e10cSrcweir pEle = rThis.aPUIdx.Next(); 858*cdf0e10cSrcweir } 859*cdf0e10cSrcweir rThis.SetStream( pOldStm ); 860*cdf0e10cSrcweir return rStm; 861*cdf0e10cSrcweir } 862*cdf0e10cSrcweir 863*cdf0e10cSrcweir //========================================================================= 864*cdf0e10cSrcweir SvStream& operator >> 865*cdf0e10cSrcweir ( 866*cdf0e10cSrcweir SvStream & rStm, 867*cdf0e10cSrcweir SvPersistStream & rThis 868*cdf0e10cSrcweir ) 869*cdf0e10cSrcweir { 870*cdf0e10cSrcweir SvStream * pOldStm = rThis.GetStream(); 871*cdf0e10cSrcweir rThis.SetStream( &rStm ); 872*cdf0e10cSrcweir 873*cdf0e10cSrcweir sal_uInt8 nVers; 874*cdf0e10cSrcweir rThis >> nVers; // Version 875*cdf0e10cSrcweir if( 0 == nVers ) 876*cdf0e10cSrcweir { 877*cdf0e10cSrcweir sal_uInt32 nCount = 0; 878*cdf0e10cSrcweir rThis >> nCount; 879*cdf0e10cSrcweir for( sal_uInt32 i = 0; i < nCount; i++ ) 880*cdf0e10cSrcweir { 881*cdf0e10cSrcweir SvPersistBase * pEle; 882*cdf0e10cSrcweir // Lesen, ohne in die Tabellen einzutragen 883*cdf0e10cSrcweir sal_uInt32 nId = rThis.ReadObj( pEle, sal_False ); 884*cdf0e10cSrcweir if( rThis.GetError() ) 885*cdf0e10cSrcweir break; 886*cdf0e10cSrcweir 887*cdf0e10cSrcweir // Die Id eines Objektes wird nie modifiziert 888*cdf0e10cSrcweir rThis.aPUIdx.Insert( nId, pEle ); 889*cdf0e10cSrcweir rThis.aPTable.Insert( (sal_uIntPtr)pEle, (void *)nId ); 890*cdf0e10cSrcweir } 891*cdf0e10cSrcweir } 892*cdf0e10cSrcweir else 893*cdf0e10cSrcweir rThis.SetError( SVSTREAM_FILEFORMAT_ERROR ); 894*cdf0e10cSrcweir 895*cdf0e10cSrcweir rThis.SetStream( pOldStm ); 896*cdf0e10cSrcweir return rStm; 897*cdf0e10cSrcweir } 898*cdf0e10cSrcweir 899*cdf0e10cSrcweir //========================================================================= 900*cdf0e10cSrcweir sal_uIntPtr SvPersistStream::InsertObj( SvPersistBase * pObj ) 901*cdf0e10cSrcweir { 902*cdf0e10cSrcweir sal_uIntPtr nId = aPUIdx.Insert( pObj ); 903*cdf0e10cSrcweir aPTable.Insert( (sal_uIntPtr)pObj, (void *)nId ); 904*cdf0e10cSrcweir return nId; 905*cdf0e10cSrcweir } 906*cdf0e10cSrcweir 907*cdf0e10cSrcweir //========================================================================= 908*cdf0e10cSrcweir sal_uIntPtr SvPersistStream::RemoveObj( SvPersistBase * pObj ) 909*cdf0e10cSrcweir { 910*cdf0e10cSrcweir sal_uIntPtr nIdx = GetIndex( pObj ); 911*cdf0e10cSrcweir aPUIdx.Remove( nIdx ); 912*cdf0e10cSrcweir aPTable.Remove( (sal_uIntPtr)pObj ); 913*cdf0e10cSrcweir return nIdx; 914*cdf0e10cSrcweir } 915*cdf0e10cSrcweir 916