/**************************************************************
 * 
 * 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
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_svl.hxx"
#include <svl/filerec.hxx>
#include <osl/endian.h>

//========================================================================

SV_IMPL_VARARR( SfxUINT32s, sal_uInt32 );

//========================================================================

/*	Die folgenden Makros extrahieren Teilbereiche aus einem sal_uInt32 Wert.
	Diese sal_uInt32-Werte werden anstelle der einzelnen Werte gestreamt,
	um Calls zu sparen.
*/

#define SFX_REC_PRE(n) ( ((n) & 0x000000FF) )
#define SFX_REC_OFS(n) ( ((n) & 0xFFFFFF00) >> 8 )
#define SFX_REC_TYP(n) ( ((n) & 0x000000FF) )
#define SFX_REC_VER(n) ( ((n) & 0x0000FF00) >> 8 )
#define SFX_REC_TAG(n) ( ((n) & 0xFFFF0000) >> 16 )

#define SFX_REC_CONTENT_VER(n) ( ((n) & 0x000000FF) )
#define SFX_REC_CONTENT_OFS(n) ( ((n) & 0xFFFFFF00) >> 8 )

//-------------------------------------------------------------------------

/*	Die folgenden Makros setzen Teilbereiche zu einem sal_uInt32 Wert zusammen.
	Diese sal_uInt32-Werte werden anstelle der einzelnen Werte gestreamt,
	um Calls zu sparen.
*/

#define SFX_REC_MINI_HEADER(nPreTag,nStartPos,nEndPos) \
					( sal_uInt32(nPreTag) | \
					  sal_uInt32(nEndPos-nStartPos-SFX_REC_HEADERSIZE_MINI) << 8 )

#define SFX_REC_HEADER(nRecType,nContentTag,nContentVer) \
					( sal_uInt32(nRecType) | \
					  ( sal_uInt32(nContentVer) << 8 ) | \
					  ( sal_uInt32(nContentTag) << 16 ) )

#define SFX_REC_CONTENT_HEADER(nContentVer,n1StStartPos,nCurStartPos) \
					( sal_uInt32(nContentVer) | \
					  sal_uInt32( nCurStartPos - n1StStartPos ) << 8 )

//=========================================================================

sal_uInt32 SfxMiniRecordWriter::Close
(
	FASTBOOL	bSeekToEndOfRec 	/*	sal_True (default)
										Der Stream wird an das Ende des Records
										positioniert.

										sal_False
										Der Stream wird an den Anfang des
										Contents (also hinter den Header)
										positioniert.
									*/
)

/*	[Beschreibung]

	Diese Methode schlie\st den Record. Dabei wird haupts"achlich der
	Header geschrieben.

	Wurde der Header bereits geschrieben, hat der Aufruf keine Wirkung.


	[R"uckgabewert]

	sal_uInt32		!= 0
				Position im Stream, die direkt hinter dem Record liegt.
				'bSeekToEndOfRecord==sal_True'
				=> R"uckgabewert == aktuelle Stream-Position nach Aufruf

				== 0
				Der Header war bereits geschrieben worden.
*/

{
	// wurde der Header noch nicht geschrieben?
	if ( !_bHeaderOk )
	{
		// Header an den Anfang des Records schreiben
		sal_uInt32 nEndPos = _pStream->Tell();
		_pStream->Seek( _nStartPos );
		*_pStream << SFX_REC_MINI_HEADER( _nPreTag, _nStartPos, nEndPos );

		// je nachdem ans Ende des Records seeken oder hinter Header bleiben
		if ( bSeekToEndOfRec )
			_pStream->Seek( nEndPos );

		// Header wurde JETZT geschrieben
		_bHeaderOk = sal_True;
		return nEndPos;
	}
#ifdef DBG_UTIL
	// mu\s Fix-Size-Record gepr"uft werden?
	else if ( SFX_BOOL_DONTCARE == _bHeaderOk )
	{
		// Header auslesen, um Soll-Gr"o\se zu bestimmen
		sal_uInt32 nEndPos = _pStream->Tell();
		_pStream->Seek( _nStartPos );
		sal_uInt32 nHeader;
		*_pStream >> nHeader;
		_pStream->Seek( nEndPos );

		// Soll-Gr"o\se mit Ist-Gr"o\se vergleichen
		DBG_ASSERT( nEndPos - SFX_REC_OFS(nHeader) == _nStartPos + sizeof(sal_uInt32),
					"fixed record size incorrect" );
		DbgOutf( "SfxFileRec: written record until %ul", nEndPos );
	}
#endif

	// Record war bereits geschlossen
	return 0;
}

//=========================================================================

sal_uInt16 SfxMiniRecordReader::ScanRecordType
(
	SvStream*	pStream 		/*	<SvStream> an dessen aktueller Position
									ein Record liegt, dessen Typ erkannt werden
									soll.
								*/
)

/*	[Beschreibung]

	Mit dieser statischen Methode kann ermittelt werden, ob sich an der
	aktuellen Position in einem Stream ein Record befindet, und der Typ
	des Records kann ermittelt werden.

	Die Position im Stream ist nach dem Aufruf aufver"andert.


	[Anmerkung]

	Die Record-Typen k"onnen zwar (abgesehen vom Drawing-Enginge-Record)
	untereinander eindeutig erkannt werden, es besteht jedoch die Gefahr
	der Verwechslung von Records mit normalen Daten. File-Formate sollten
	darauf R"ucksicht nehmen. Handelt es sich um keinen Record, wird
	am wahrscheinlichsten SFX_REC_TYPE_MINI zur"uckgeliefert, da dieser
	Typ sich aufgrund seines sparsam kurzen Headers durch die k"urzeste
	Kennung auszeichnet.


	[R"uckgabewert]

	sal_uInt16							SFX_REC_TYPE_EOR
									An der aktuellen Position des Streams
									steht eine End-Of-Records-Kennung.

									SFX_REC_TYPE_MINI
									Es handelt sich um einen SW3 kompatiblen
									Mini-Record, dessen einzige Kennung sein
									'Mini-Tag' ist.

									SFX_REC_TYPE_SINGLE
									Es handelt sich um einen Extended-Record
									mit einem einzigen Content, der durch eine
									Version und ein Tag n"aher gekennzeichnet
									ist.

									SFX_REC_TYPE_FIXSIZE
									Es handelt sich um einen Extended-Record
									mit mehreren Contents gleicher Gr"o\se,
									die gemeinsam durch eine einzige Version
									und ein einziges gemeinsames Tag n"aher
									gekennzeichnet sind.

									SFX_REC_TYPE_VARSIZE
									Es handelt sich um einen Extended-Record
									mit mehreren Contents variabler Gr"o\se,
									die gemeinsam durch eine einzige Version
									und ein einziges gemeinsames Tag n"aher
									gekennzeichnet sind.

									SFX_REC_TYPE_MIXTAGS
									Es handelt sich um einen Extended-Record
									mit mehreren Contents variabler Gr"o\se,
									die jeweils durch ein eignes Tag und
									eine eigene Versions-Nummer n"aher
									gekennzeichnet sind.

									SFX_REC_TYPE_DRAWENG
									Es handelt sich wahrscheinlich um einen
									Drawing-Engine-Record. Dieser Record-Typ
									kann von den Klassen dieser Gruppe nicht
									interpretiert werden.
*/

{
	// die ersten 4 Bytes als Mini-Header lesen
	sal_uInt32 nHeader;
	*pStream >> nHeader;

	// k"onnte es sich um einen extended-Record handeln?
	sal_uInt16 nPreTag = sal::static_int_cast< sal_uInt16 >(SFX_REC_PRE(nHeader));
	if ( SFX_REC_PRETAG_EXT == nPreTag )
	{
		// die n"achsten 4 Bytes als extended-Header lesen
		*pStream >> nHeader;

		// Stream-Position restaurieren
		pStream->SeekRel(-8);

		// liegt eine g"ultige Record-Kennung vor?
		sal_uInt16 nType = sal::static_int_cast< sal_uInt16 >(SFX_REC_TYP(nHeader));
		if ( nType >= SFX_REC_TYPE_FIRST && nType <= SFX_REC_TYPE_LAST )
			// entsprechenden extended-Record-Typ zur"uckliefern
			return nType;

		// sonst ist der Record-Typ unbekannt
		return SFX_REC_TYPE_NONE;
	}

	// Stream-Position restaurieren
	pStream->SeekRel(-4);

	// liegt eine End-Of-Record-Kennung vor?
	if ( SFX_REC_PRETAG_EOR == nPreTag )
		return nPreTag;

	// liegt ein Drawin-Engine-Record vor?
	if ( nHeader == sal_uInt32(*"DRMD") || nHeader == sal_uInt32(*"DRVW") )
		return SFX_REC_TYPE_DRAWENG;

	// alle anderen sind grunds"atzlich g"ultige Mini-Records
	return SFX_REC_TYPE_MINI;
}

//-------------------------------------------------------------------------

FASTBOOL SfxMiniRecordReader::SetHeader_Impl( sal_uInt32 nHeader )

/*	[Beschreibung]

	Interne Methode zum nachtr"aglichen Verarbeiten eines extern gelesenen
	Headers. Falls der Header eine End-Of-Records-Kennung darstellt,
	wird am Stream ein Errorcode gesetzt und sal_False zur"uckgeliefert. Im
	Fehlerfall wird der Stream jedoch nicht auf den Record-Anfang zur"uck-
	gesetzt.
*/

{
	FASTBOOL bRet = sal_True;

	// Record-Ende und Pre-Tag aus dem Header ermitteln
	_nEofRec = _pStream->Tell() + SFX_REC_OFS(nHeader);
	_nPreTag = sal::static_int_cast< sal_uInt8 >(SFX_REC_PRE(nHeader));

	// wenn End-Of-Record-Kennung, dann Fehler
	if ( _nPreTag == SFX_REC_PRETAG_EOR )
	{
		_pStream->SetError( ERRCODE_IO_WRONGFORMAT );
		bRet = sal_False;
	}
	return bRet;
}

//-------------------------------------------------------------------------

SfxMiniRecordReader::SfxMiniRecordReader
(
	SvStream*		pStream 		/*	<SvStream>, an dessen aktueller
										Position sich ein <SfxMiniRecord>
										befindet.
									*/
)

/*	[Beschreibung]

	Dieser Ctor liest den Header eines <SfxMiniRecord> ab der aktuellen
	Position von 'pStream'. Da grunds"atzlich fast 4-Byte Kombination ein
	g"ultiger SfxMiniRecord-Header ist, bleiben die einzig m"oglichen
	Fehler der EOF-Status des Streams, und ein SFX_REC_PRETAG_EOR
	als Pre-Tag. Ein entsprechender Error-Code (ERRCODE_IO_EOF bzw.
	ERRCODE_IO_WRONGFORMAT) ist dann am Stream gesetzt, dessen Position
	dann au\serdem unver"andert ist.
*/

:	_pStream( pStream ),
	_bSkipped( sal_False )
{
	// Header einlesen
	sal_uInt32 nStartPos = pStream->Tell(); // um im Fehlerfall zur"uck zu-seeken
	DBG( DbgOutf( "SfxFileRec: reading record at %ul", nStartPos ) );
	sal_uInt32 nHeader;
	*pStream >> nHeader;

	// Headerdaten extrahieren
	SetHeader_Impl( nHeader );

	// Fehlerbehandlung
	if ( pStream->IsEof() )
		_nPreTag = SFX_REC_PRETAG_EOR;
	else if ( _nPreTag == SFX_REC_PRETAG_EOR )
		pStream->SetError( ERRCODE_IO_WRONGFORMAT );
	if ( !IsValid() )
		pStream->Seek( nStartPos );
}

//-------------------------------------------------------------------------

SfxMiniRecordReader::SfxMiniRecordReader
(
	SvStream*		pStream,		/*	<SvStream>, an dessen aktueller
										Position sich ein <SfxMiniRecord>
										befindet.
									*/
	sal_uInt8			nTag			//	Pre-Tag des gew"unschten Records
)

/*	[Beschreibung]

	Dieser Ctor interpretiert 'pStream' ab der aktuellen Position als
	eine l"uckenlose Folge von, von dieser Klassen-Gruppe interpretierbaren,
	Records. Der in dieser Folge erste als <SfxMiniRecord> interpretierbare
	(also ggf. auch ein extended-Record) mit dem PreTag 'nTag' wird ge"offnet
	und durch diese Instanz repr"asentiert.

	Wird das Ende des Streams oder die Kennung SFX_REC_PRETAG_EOR
	erreicht, bevor ein Record mit dem ge"unschten Pre-Tag gefunden wird,
	ist die erzeugte Instanz ung"ultig ('IsValid() == sal_False'). Ein ent-
	sprechender Error-Code (ERRCODE_IO_EOF bzw. ERRCODE_IO_WRONGFORMAT)
	ist dann am Stream gesetzt, dessen Position ist dann au\serdem unver-
	"andert.

	Bei 'nTag==SFX_FILEREC_PRETAG_EOR' wird nicht versucht, einen Record
	zu lesen, es wird sofort 'IsValid()' auf sal_False gesetzt und kein Error-Code
	am Stream gesetzt. Dies ist dauzu gedacht, ohne 'new' und 'delete'
	abw"rtskompatibel SfxMiniRecords einbauen zu k"onnen. Siehe dazu
	<SfxItemSet::Load()>.


	[Anwendungsvorschlag]

	Wird dieser Ctor in einer bereits ausgelieferten Programmversion
	verwendet, k"onnen in das File-Format jeweils davor kompatibel neue
	Records mit einer anderen Kennung eingef"ugt werden. Diese werden
	schlie\slich automatisch "uberlesen. Erkauft wird diese M"oglichkeit
	allerdings mit etwas schlechterem Laufzeitverhalten im Vergleich mit
	direktem 'drauf-los-lesen', der sich jedoch auf einen Vergleich zweier
	Bytes reduziert, falls der gesuchte Record der erste in der Folge ist.
*/

:   _pStream( pStream ),
	_bSkipped( nTag == SFX_REC_PRETAG_EOR )
{
	// ggf. ignorieren (s.o.)
	if ( _bSkipped )
	{
		_nPreTag = nTag;
		return;
	}

	// StartPos merken, um im Fehlerfall zur"uck-seeken zu k"onnen
	sal_uInt32 nStartPos = pStream->Tell();

	// passenden Record suchen
	while(sal_True)
	{
		// Header lesen
		DBG( DbgOutf( "SfxFileRec: searching record at %ul", pStream->Tell() ) );
		sal_uInt32 nHeader;
		*pStream >> nHeader;

		// Headerdaten von Basisklasse extrahieren lassen
		SetHeader_Impl( nHeader );

		// ggf. Fehler behandeln
		if ( pStream->IsEof() )
			_nPreTag = SFX_REC_PRETAG_EOR;
		else if ( _nPreTag == SFX_REC_PRETAG_EOR )
			pStream->SetError( ERRCODE_IO_WRONGFORMAT );
		else
		{
			// wenn gefunden, dann Schleife abbrechen
			if ( _nPreTag == nTag )
				break;

			// sonst skippen und weitersuchen
			pStream->Seek( _nEofRec );
			continue;
		}

		// Fehler => zur"uck-seeken
		pStream->Seek( nStartPos );
		break;
	}
}

//=========================================================================

SfxSingleRecordWriter::SfxSingleRecordWriter
(
	sal_uInt8			nRecordType,	// f"ur Subklassen
	SvStream*		pStream,		// Stream, in dem der Record angelegt wird
	sal_uInt16			nContentTag,	// Inhalts-Art-Kennung
	sal_uInt8			nContentVer 	// Inhalts-Versions-Kennung
)

/*	[Beschreibung]

	Interner Ctor f"ur Subklassen.
*/

:	SfxMiniRecordWriter( pStream, SFX_REC_PRETAG_EXT )
{
	// Erweiterten Header hiner den des SfxMiniRec schreiben
	*pStream << SFX_REC_HEADER(nRecordType, nContentTag, nContentVer);
}

//-------------------------------------------------------------------------

SfxSingleRecordWriter::SfxSingleRecordWriter
(
	SvStream*		pStream,		// Stream, in dem der Record angelegt wird
	sal_uInt16			nContentTag,	// Inhalts-Art-Kennung
	sal_uInt8			nContentVer 	// Inhalts-Versions-Kennung
)

/*	[Beschreibung]

	Legt in 'pStream' einen 'SfxSingleRecord' an, dessen Content-Gr"o\se
	nicht bekannt ist, sondern nach dam Streamen des Contents errechnet
	werden soll.
*/

:	SfxMiniRecordWriter( pStream, SFX_REC_PRETAG_EXT )
{
	// Erweiterten Header hiner den des SfxMiniRec schreiben
	*pStream << SFX_REC_HEADER( SFX_REC_TYPE_SINGLE, nContentTag, nContentVer);
}

//-------------------------------------------------------------------------

SfxSingleRecordWriter::SfxSingleRecordWriter
(
	SvStream*		pStream,		// Stream, in dem der Record angelegt wird
	sal_uInt16			nContentTag,	// Inhalts-Art-Kennung
	sal_uInt8			nContentVer,	// Inhalts-Versions-Kennung
	sal_uInt32			nContentSize	// Gr"o\se des Inhalts in Bytes
)

/*  [Beschreibung]

	Legt in 'pStream' einen 'SfxSingleRecord' an, dessen Content-Gr"o\se
	von vornherein bekannt ist.
*/

:	SfxMiniRecordWriter( pStream, SFX_REC_PRETAG_EXT,
						 nContentSize + SFX_REC_HEADERSIZE_SINGLE )
{
	// Erweiterten Header hinter den des SfxMiniRec schreiben
	*pStream << SFX_REC_HEADER( SFX_REC_TYPE_SINGLE, nContentTag, nContentVer);
}

//=========================================================================

inline FASTBOOL SfxSingleRecordReader::ReadHeader_Impl( sal_uInt16 nTypes )

/*  [Beschreibung]

	Interne Methode zum Einlesen eines SfxMultiRecord-Headers, nachdem
	die Basisklasse bereits initialisiert und deren Header gelesen ist.
	Ggf. ist ein Error-Code am Stream gesetzt, im Fehlerfall wird jedoch
	nicht zur"uckge-seekt.
*/

{
	FASTBOOL bRet;

	// Basisklassen-Header einlesen
	sal_uInt32 nHeader=0;
	*_pStream >> nHeader;
	if ( !SetHeader_Impl( nHeader ) )
		bRet = sal_False;
	else
	{
		// eigenen Header einlesen
		*_pStream >> nHeader;
		_nRecordVer = sal::static_int_cast< sal_uInt8 >(SFX_REC_VER(nHeader));
		_nRecordTag = sal::static_int_cast< sal_uInt16 >(SFX_REC_TAG(nHeader));

		// falscher Record-Typ?
		_nRecordType = sal::static_int_cast< sal_uInt8 >(SFX_REC_TYP(nHeader));
		bRet = 0 != ( nTypes & _nRecordType);
	}
	return bRet;
}

//-------------------------------------------------------------------------

SfxSingleRecordReader::SfxSingleRecordReader( SvStream *pStream )
:	SfxMiniRecordReader()
{
	// Startposition merken, um im Fehlerfall zur"uck-seeken zu k"onnen
    #ifdef DBG_UTIL
	sal_uInt32 nStartPos = pStream->Tell();
	DBG( DbgOutf( "SfxFileRec: reading record at %ul", nStartPos ) );
    #endif

	// Basisklasse initialisieren (nicht via Ctor, da der nur MiniRecs akzept.)
	Construct_Impl( pStream );

	// nur Header mit korrektem Record-Type akzeptieren
	if ( !ReadHeader_Impl( SFX_REC_TYPE_SINGLE ) )
	{
		// Error-Code setzen und zur"uck-seeken
		pStream->SeekRel( - SFX_REC_HEADERSIZE_SINGLE );
		pStream->SetError( ERRCODE_IO_WRONGFORMAT );
	}
}

//-------------------------------------------------------------------------

SfxSingleRecordReader::SfxSingleRecordReader( SvStream *pStream, sal_uInt16 nTag )
{
	// StartPos merken, um im Fehlerfall zur"uck-seeken zu k"onnen
	sal_uInt32 nStartPos = pStream->Tell();

	// richtigen Record suchen, ggf. Error-Code setzen und zur"uck-seeken
	Construct_Impl( pStream );
	if ( !FindHeader_Impl( SFX_REC_TYPE_SINGLE, nTag ) )
	{
		// Error-Code setzen und zur"uck-seeken
		pStream->Seek( nStartPos );
		pStream->SetError( ERRCODE_IO_WRONGFORMAT );
	}
}

//-------------------------------------------------------------------------

FASTBOOL SfxSingleRecordReader::FindHeader_Impl
(
	sal_uInt16		nTypes, 	// arithm. Veroderung erlaubter Record-Typen
	sal_uInt16		nTag		// zu findende Record-Art-Kennung
)

/*	[Beschreibung]

	Interne Methode zum lesen des Headers des ersten Record, der einem
	der Typen in 'nTypes' entspricht und mit der Art-Kennung 'nTag'
	gekennzeichnet ist.

	Kann ein solcher Record nicht gefunden werden, wird am Stream ein
	Errorcode gesetzt, zur"uck-geseekt und sal_False zur"uckgeliefert.
*/

{
	// StartPos merken, um im Fehlerfall zur"uck-seeken zu k"onnen
	sal_uInt32 nStartPos = _pStream->Tell();

	// richtigen Record suchen
	while ( !_pStream->IsEof() )
	{
		// Header lesen
		sal_uInt32 nHeader;
		DBG( DbgOutf( "SfxFileRec: searching record at %ul", _pStream->Tell() ) );
		*_pStream >> nHeader;
		if ( !SetHeader_Impl( nHeader ) )
			// EOR => Such-Schleife abbreichen
			break;

		// Extended Record gefunden?
		if ( _nPreTag == SFX_REC_PRETAG_EXT )
		{
			// Extended Header lesen
			*_pStream >> nHeader;
			_nRecordTag = sal::static_int_cast< sal_uInt16 >(SFX_REC_TAG(nHeader));

			// richtigen Record gefunden?
			if ( _nRecordTag == nTag )
			{
				// gefundener Record-Typ passend?
				_nRecordType = sal::static_int_cast< sal_uInt8 >(
                    SFX_REC_TYP(nHeader));
				if ( nTypes & _nRecordType )
					// ==> gefunden
					return sal_True;

				// error => Such-Schleife abbrechen
				break;
			}
		}

		// sonst skippen
		if ( !_pStream->IsEof() )
			_pStream->Seek( _nEofRec );
	}

	// Fehler setzen und zur"uck-seeken
	_pStream->SetError( ERRCODE_IO_WRONGFORMAT );
	_pStream->Seek( nStartPos );
	return sal_False;
}

//=========================================================================

SfxMultiFixRecordWriter::SfxMultiFixRecordWriter
(
	sal_uInt8			nRecordType,	// Subklassen Record-Kennung
	SvStream*		pStream,		// Stream, in dem der Record angelegt wird
	sal_uInt16			nContentTag,	// Content-Art-Kennung
	sal_uInt8			nContentVer,	// Content-Versions-Kennung
	sal_uInt32			              	// Gr"o\se jedes einzelnen Contents in Bytes
)

/*  [Beschreibung]

	Interne Methode f"ur Subklassen.
*/

:   SfxSingleRecordWriter( nRecordType, pStream, nContentTag, nContentVer ),
	_nContentCount( 0 )
{
	// Platz f"ur eigenen Header
	pStream->SeekRel( + SFX_REC_HEADERSIZE_MULTI );
}

//------------------------------------------------------------------------

SfxMultiFixRecordWriter::SfxMultiFixRecordWriter
(
	SvStream*		pStream,		// Stream, in dem der Record angelegt wird
	sal_uInt16			nContentTag,	// Content-Art-Kennung
	sal_uInt8			nContentVer,	// Content-Versions-Kennung
	sal_uInt32			             	// Gr"o\se jedes einzelnen Contents in Bytes
)

/*  [Beschreibung]

	Legt in 'pStream' einen 'SfxMultiFixRecord' an, dessen Content-Gr"o\se
	konstant und von vornherein bekannt ist.
*/

:   SfxSingleRecordWriter( SFX_REC_TYPE_FIXSIZE,
						   pStream, nContentTag, nContentVer ),
	_nContentCount( 0 )
{
	// Platz f"ur eigenen Header
	pStream->SeekRel( + SFX_REC_HEADERSIZE_MULTI );
}

//------------------------------------------------------------------------

sal_uInt32 SfxMultiFixRecordWriter::Close( FASTBOOL bSeekToEndOfRec )

//	siehe <SfxMiniRecordWriter>

{
	// Header noch nicht geschrieben?
	if ( !_bHeaderOk )
	{
		// Position hinter Record merken, um sie restaurieren zu k"onnen
		sal_uInt32 nEndPos = SfxSingleRecordWriter::Close( sal_False );

		// gegen"uber SfxSingleRecord erweiterten Header schreiben
		*_pStream << _nContentCount;
		*_pStream << _nContentSize;

		// je nachdem ans Ende des Records seeken oder hinter Header bleiben
		if ( bSeekToEndOfRec )
			_pStream->Seek(nEndPos);
		return nEndPos;
	}

	// Record war bereits geschlossen
	return 0;
}

//=========================================================================

SfxMultiVarRecordWriter::SfxMultiVarRecordWriter
(
	sal_uInt8			nRecordType,	// Record-Kennung der Subklasse
	SvStream*       pStream,        // Stream, in dem der Record angelegt wird
	sal_uInt16			nRecordTag, 	// Gesamt-Art-Kennung
	sal_uInt8			nRecordVer		// Gesamt-Versions-Kennung
)

/*  [Beschreibung]

	Interner Ctor f"ur Subklassen.
*/

:   SfxMultiFixRecordWriter( nRecordType, pStream, nRecordTag, nRecordVer, 0 ),
	_nContentVer( 0 )
{
}

//-------------------------------------------------------------------------

SfxMultiVarRecordWriter::SfxMultiVarRecordWriter
(
	SvStream*       pStream,        // Stream, in dem der Record angelegt wird
	sal_uInt16			nRecordTag, 	// Gesamt-Art-Kennung
	sal_uInt8			nRecordVer		// Gesamt-Versions-Kennung
)

/*  [Beschreibung]

	Legt in 'pStream' einen 'SfxMultiVarRecord' an, dessen Content-Gr"o\sen
	weder bekannt sind noch identisch sein m"ussen, sondern jeweils nach dem
	Streamen jedes einzelnen Contents errechnet werden sollen.


	[Anmerkung]

	Diese Methode ist nicht inline, da f"ur die Initialisierung eines
	<SvULongs>-Members zu viel Code generiert werden w"urde.
*/

:   SfxMultiFixRecordWriter( SFX_REC_TYPE_VARSIZE,
							 pStream, nRecordTag, nRecordVer, 0 ),
	_nContentVer( 0 )
{
}

//-------------------------------------------------------------------------

SfxMultiVarRecordWriter::~SfxMultiVarRecordWriter()

/*	[Beschreibung]

	Der Dtor der Klasse <SfxMultiVarRecordWriter> schlie\st den Record
	automatisch, falls <SfxMultiVarRecordWriter::Close()> nicht bereits
	explizit gerufen wurde.
*/

{
	// wurde der Header noch nicht geschrieben oder mu\s er gepr"uft werden
	if ( !_bHeaderOk )
		Close();
}

//-------------------------------------------------------------------------

void SfxMultiVarRecordWriter::FlushContent_Impl()

/*	[Beschreibung]

	Interne Methode zum Abschlie\sen eines einzelnen Contents.
*/

{
	// Versions-Kennung und Positions-Offset des aktuellen Contents merken;
	// das Positions-Offset ist relativ zur Startposition des ersten Contents
	_aContentOfs.Insert(
			SFX_REC_CONTENT_HEADER(_nContentVer,_nStartPos,_nContentStartPos),
			_nContentCount-1 );
}

//-------------------------------------------------------------------------

void SfxMultiVarRecordWriter::NewContent()

// siehe <SfxMultiFixRecordWriter>

{
	// schon ein Content geschrieben?
	if ( _nContentCount )
		FlushContent_Impl();

	// neuen Content beginnen
	_nContentStartPos = _pStream->Tell();
	++_nContentCount;
}

//-------------------------------------------------------------------------

sal_uInt32 SfxMultiVarRecordWriter::Close( FASTBOOL bSeekToEndOfRec )

// siehe <SfxMiniRecordWriter>

{
	// Header noch nicht geschrieben?
	if ( !_bHeaderOk )
	{
		// ggf. letzten Content abschlie\sen
		if ( _nContentCount )
			FlushContent_Impl();

		// Content-Offset-Tabelle schreiben
		sal_uInt32 nContentOfsPos = _pStream->Tell();
		//! darf man das so einr"ucken?
		#if defined(OSL_LITENDIAN)
			_pStream->Write( _aContentOfs.GetData(),
							 sizeof(sal_uInt32)*_nContentCount );
		#else
			for ( sal_uInt16 n = 0; n < _nContentCount; ++n )
				*_pStream << sal_uInt32(_aContentOfs[n]);
		#endif

		// SfxMultiFixRecordWriter::Close() "uberspringen!
		sal_uInt32 nEndPos = SfxSingleRecordWriter::Close( sal_False );

		// eigenen Header schreiben
		*_pStream << _nContentCount;
		if ( SFX_REC_TYPE_VARSIZE_RELOC == _nPreTag ||
			 SFX_REC_TYPE_MIXTAGS_RELOC == _nPreTag )
			*_pStream << static_cast<sal_uInt32>(nContentOfsPos - ( _pStream->Tell() + sizeof(sal_uInt32) ));
		else
			*_pStream << nContentOfsPos;

		// ans Ende des Records seeken bzw. am Ende des Headers bleiben
		if ( bSeekToEndOfRec )
			 _pStream->Seek(nEndPos);
		return nEndPos;
	}

	// Record war bereits vorher geschlossen
	return 0;
}

//=========================================================================

void SfxMultiMixRecordWriter::NewContent
(
	sal_uInt16		nContentTag,	// Kennung f"ur die Art des Contents
	sal_uInt8		nContentVer 	// Kennung f"ur die Version des Contents
)

/*	[Beschreibung]

	Mit dieser Methode wird in den Record ein neuer Content eingef"ugt
	und dessen Content-Tag sowie dessen Content-Version angegeben. Jeder,
	auch der 1. Record mu\s durch Aufruf dieser Methode eingeleitet werden.
*/

{
	// ggf. vorherigen Record abschlie\sen
	if ( _nContentCount )
		FlushContent_Impl();

	// Tag vor den Content schreiben, Version und Startposition merken
	_nContentStartPos = _pStream->Tell();
	++_nContentCount;
	*_pStream << nContentTag;
	_nContentVer = nContentVer;
}

//=========================================================================

FASTBOOL SfxMultiRecordReader::ReadHeader_Impl()

/*  [Beschreibung]

	Interne Methode zum Einlesen eines SfxMultiRecord-Headers, nachdem
	die Basisklasse bereits initialisiert und deren Header gelesen ist.
	Ggf. ist ein Error-Code am Stream gesetzt, im Fehlerfall wird jedoch
	nicht zur"uckge-seekt.
*/

{
	// eigenen Header lesen
	*_pStream >> _nContentCount;
	*_pStream >> _nContentSize; // Fix: jedes einzelnen, Var|Mix: Tabellen-Pos.

	// mu\s noch eine Tabelle mit Content-Offsets geladen werden?
	if ( _nRecordType != SFX_REC_TYPE_FIXSIZE )
	{
		// Tabelle aus dem Stream einlesen
		sal_uInt32 nContentPos = _pStream->Tell();
		if ( _nRecordType == SFX_REC_TYPE_VARSIZE_RELOC ||
			 _nRecordType == SFX_REC_TYPE_MIXTAGS_RELOC )
			_pStream->SeekRel( + _nContentSize );
		else
			_pStream->Seek( _nContentSize );
		_pContentOfs = new sal_uInt32[_nContentCount];
        memset(_pContentOfs, 0, _nContentCount*sizeof(sal_uInt32));
	//! darf man jetzt so einr"ucken
		#if defined(OSL_LITENDIAN)
			_pStream->Read( _pContentOfs, sizeof(sal_uInt32)*_nContentCount );
		#else
			for ( sal_uInt16 n = 0; n < _nContentCount; ++n )
				*_pStream >> _pContentOfs[n];
		#endif
		_pStream->Seek( nContentPos );
	}

	// Header konnte gelesen werden, wenn am Stream kein Error gesetzt ist
	return !_pStream->GetError();
}

//-------------------------------------------------------------------------

SfxMultiRecordReader::SfxMultiRecordReader( SvStream *pStream )
    : _pContentOfs(0)
    , _nContentSize(0)
    , _nContentCount(0)
    , _nContentNo(0)
{
	// Position im Stream merken, um im Fehlerfall zur"uck-seeken zu k"onnen
	_nStartPos = pStream->Tell();

	// Basisklasse konstruieren (normaler Ctor w"urde nur SingleRecs lesen)
	SfxSingleRecordReader::Construct_Impl( pStream );

	// Header der Basisklasse lesen
	if ( !SfxSingleRecordReader::ReadHeader_Impl( SFX_REC_TYPE_FIXSIZE |
				SFX_REC_TYPE_VARSIZE | SFX_REC_TYPE_VARSIZE_RELOC |
				SFX_REC_TYPE_MIXTAGS | SFX_REC_TYPE_MIXTAGS_RELOC ) ||
		 !ReadHeader_Impl() )
		// als ung"ultig markieren und zur"uck-seeken
		SetInvalid_Impl( _nStartPos );
}

//-------------------------------------------------------------------------

SfxMultiRecordReader::SfxMultiRecordReader( SvStream *pStream, sal_uInt16 nTag )
:	_nContentNo(0)
{
	// Position im Stream merken, um im Fehlerfall zur"uck-seeken zu k"onnen
	_nStartPos = pStream->Tell();

	// passenden Record suchen und Basisklasse initialisieren
	SfxSingleRecordReader::Construct_Impl( pStream );
	if ( SfxSingleRecordReader::FindHeader_Impl( SFX_REC_TYPE_FIXSIZE |
			SFX_REC_TYPE_VARSIZE | SFX_REC_TYPE_VARSIZE_RELOC |
			SFX_REC_TYPE_MIXTAGS | SFX_REC_TYPE_MIXTAGS_RELOC,
			nTag ) )
	{
		// eigenen Header dazu-lesen
		if ( !ReadHeader_Impl() )
			// nicht lesbar => als ung"ultig markieren und zur"uck-seeken
			SetInvalid_Impl( _nStartPos);
	}
}

//-------------------------------------------------------------------------

SfxMultiRecordReader::~SfxMultiRecordReader()
{
	delete[] _pContentOfs;
}

//-------------------------------------------------------------------------

FASTBOOL SfxMultiRecordReader::GetContent()

/*	[Beschreibung]

	Positioniert den Stream an den Anfang des n"chsten bzw. beim 1. Aufruf
	auf den Anfang des ersten Contents im Record und liest ggf. dessen
	Header ein.

	Liegt laut Record-Header kein Content mehr vor, wird sal_False zur"uck-
	gegeben. Trotz einem sal_True-Returnwert kann am Stream ein Fehlercode
	gesetzt sein, z.B. falls er unvorhergesehenerweise (kaputtes File)
	zuende ist.
*/

{
	// noch ein Content vorhanden?
	if ( _nContentNo < _nContentCount )
	{
		// den Stream an den Anfang des Contents positionieren
		sal_uInt32 nOffset = _nRecordType == SFX_REC_TYPE_FIXSIZE
					? _nContentNo * _nContentSize
					: SFX_REC_CONTENT_OFS(_pContentOfs[_nContentNo]);
		sal_uInt32 nNewPos = _nStartPos + nOffset;
		DBG_ASSERT( nNewPos >= _pStream->Tell(), "SfxMultiRecordReader::GetContent() - New position before current, to much data red!" );

		// #99366#: correct stream pos in every case;
        // the if clause was added by MT  a long time ago,
        // maybe to 'repair' other corrupt documents; but this 
        // gives errors when writing with 5.1 and reading with current
        // versions, so we decided to remove the if clause (KA-05/17/2002)
        // if ( nNewPos > _pStream->Tell() )
		_pStream->Seek( nNewPos );

		// ggf. Content-Header lesen
		if ( _nRecordType == SFX_REC_TYPE_MIXTAGS ||
			 _nRecordType == SFX_REC_TYPE_MIXTAGS_RELOC )
		{
			_nContentVer = sal::static_int_cast< sal_uInt8 >(
                SFX_REC_CONTENT_VER(_pContentOfs[_nContentNo]));
			*_pStream >> _nContentTag;
		}

		// ContentNo weiterz"ahlen
		++_nContentNo;
		return sal_True;
	}

	return sal_False;
}