Commits

Anonymous committed 23defb4

cws tl77: #i111876# removed some now superfluous code with MST

  • Participants
  • Parent commits 35e8896

Comments (0)

Files changed (1)

File svl/source/items/poolio.cxx

-/*************************************************************************
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * 
- * Copyright 2000, 2010 Oracle and/or its affiliates.
- *
- * OpenOffice.org - a multi-platform office productivity suite
- *
- * This file is part of OpenOffice.org.
- *
- * OpenOffice.org is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 3
- * only, as published by the Free Software Foundation.
- *
- * OpenOffice.org is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License version 3 for more details
- * (a copy is included in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with OpenOffice.org.  If not, see
- * <http://www.openoffice.org/license.html>
- * for a copy of the LGPLv3 License.
- *
- ************************************************************************/
-
-// MARKER(update_precomp.py): autogen include statement, do not remove
-#include "precompiled_svl.hxx"
-
-#include <string.h>
-#include <stdio.h>
-
-#ifndef GCC
-#endif
-
-#include <tools/solar.h>
-#include <svl/itempool.hxx>
-#include "whassert.hxx"
-#include <svl/brdcst.hxx>
-#include <svl/filerec.hxx>
-#include <svl/svldata.hxx>
-#include "poolio.hxx"
-
-// STATIC DATA -----------------------------------------------------------
-
-DBG_NAME(SfxItemPool);
-
-//========================================================================
-
-void SfxItemPool::SetStoringPool( const SfxItemPool *pStoringPool )
-
-/*	[Beschreibung]
-
-	Diese Methode setzt den <SfxItemPool>, der gerade gespeichert wird.
-	Sie sollte nur in Notf"allen verwendet werden, um z.B. File-Format-
-	Kompatibilit"at zu gew"ahrleisten o."o. - z.B. in der "uberladung eines
-	<SfxPoolItem::Store()> zus"atzliche Daten aus dem dazuge"horigen
-	Pool mit <SfxItemPool::GetStoringPool()> zu besorgen.
-
-	Sie wird von <SfxItemPool::Store()> bedient, kann jedoch f"ur nicht
-	poolable Items auch direkt gerufen werden. Bitte m"oglichst nicht
-	f"ur jedes Item einzeln, da 2 Calls!
-*/
-
-{
-	ImpSvlData::GetSvlData().pStoringPool = pStoringPool;
-}
-
-//-------------------------------------------------------------------------
-
-const SfxItemPool* SfxItemPool::GetStoringPool()
-
-/*	[Beschreibung]
-
-	Diese Methode liefert den <SfxItemPool>, der gerade gespeichert wird.
-	Sie sollte nur in Notf"allen verwendet werden, um z.B. File-Format-
-	Kompatibilit"at zu gew"ahrleisten o."o. - z.B. in der "uberladung eines
-	<SfxPoolItem::Store()> zus"atzliche Daten aus dem dazuge"horigen
-	Pool zu besorgen.
-*/
-
-{
-	return ImpSvlData::GetSvlData().pStoringPool;
-}
-
-// -----------------------------------------------------------------------
-
-void SfxItemPool::LoadCompleted()
-
-/*	[Beschreibung]
-
-	Wurde der SfxItemPool mit 'bRefCounts' == FALSE geladen, mu\s das
-	Laden der Dokumentinhalte mit einem Aufruf dieser Methode beendet
-	werden. Ansonsten hat der Aufruf dieser Methode keine Funktion.
-
-
-	[Anmerkung]
-
-	Beim Laden ohne Ref-Counts werden diese tats"achlich auf 1 gesetzt,
-	damit nicht w"ahrend des Ladevorgangs SfxPoolItems gel"oscht werden,
-	die danach, aber auch noch beim Ladevorgang, ben"otigt werden. Diese
-	Methode setzt den Ref-Count wieder zur"uck und entfernt dabei
-	gleichzeitig alle nicht mehr ben"otigten Items.
-
-
-	[Querverweise]
-
-	<SfxItemPool::Load()>
-*/
-
-{
-	// wurden keine Ref-Counts mitgeladen?
-	if ( pImp->nInitRefCount > 1 )
-	{
-
-		// "uber alle Which-Werte iterieren
-		SfxPoolItemArray_Impl** ppItemArr = pImp->ppPoolItems;
-		for( USHORT nArrCnt = GetSize_Impl(); nArrCnt; --nArrCnt, ++ppItemArr )
-		{
-			// ist "uberhaupt ein Item mit dem Which-Wert da?
-			if ( *ppItemArr )
-			{
-				// "uber alle Items mit dieser Which-Id iterieren
-				SfxPoolItem** ppHtArr = (SfxPoolItem**)(*ppItemArr)->GetData();
-				for( USHORT n = (*ppItemArr)->Count(); n; --n, ++ppHtArr )
-					if (*ppHtArr)
-					{
-                        #ifdef DBG_UTIL
-						const SfxPoolItem &rItem = **ppHtArr;
-						DBG_ASSERT( !rItem.ISA(SfxSetItem) ||
-									0 != &((const SfxSetItem&)rItem).GetItemSet(),
-									"SetItem without ItemSet" );
-                        #endif
-
-						if ( !ReleaseRef( **ppHtArr, 1 ) )
-							DELETEZ( *ppHtArr );
-					}
-			}
-		}
-
-		// from now on normal initial ref count
-		pImp->nInitRefCount = 1;
-	}
-
-	// notify secondary pool
-	if ( pSecondary )
-		pSecondary->LoadCompleted();
-}
-
-//============================================================================
-
-const SfxPoolItem* SfxItemPool::LoadSurrogate
-(
-	SvStream&			rStream,	// vor einem Surrogat positionierter Stream
-	USHORT& 			rWhich, 	// Which-Id des zu ladenden <SfxPoolItem>s
-	USHORT				nSlotId,	// Slot-Id des zu ladenden <SfxPoolItem>s
-	const SfxItemPool*	pRefPool	// <SfxItemPool> in dem das Surrogat gilt
-)
-
-/*	[Beschreibung]
-
-	L"adt Surrogat aus 'rStream' und liefert das dadurch in 'rRefPool'
-	repr"asentierte SfxPoolItem zu"ruck. Ist das im Stream befindliche
-	Surrogat == SFX_ITEMS_DIRECT (!SFX_ITEM_POOLABLE) wird 0 zur"uckgegeben,
-	das Item ist direkt aus dem Stream zu laden. Bei 0xfff0 (SFX_ITEMS_NULL)
-	wird auch 0 zurueckgegeben und rWhich auf 0 gesetzt, das Item ist nicht
-	verfuegbar.
-
-	Ansonsten wird ber"ucksichtigt, ob der betroffene Pool ohne Ref-Counts
-	geladen wird, ob aus einem neuen Pool nachgeladen wird (&rRefPool != this)
-	oder ob aus einem g"anzlich anders aufgebauten Pool geladen wird.
-
-	Wird aus einem anders aufgebauten Pool geladen und die 'nSlotId' kann
-	nicht in eine Which-Id dieses Pools gemappt werden, wird ebenfalls 0
-	zur"uckgeliefert.
-
-	Preconditions:	- Pool mu\s geladen sein
-					- LoadCompleted darf noch nicht gerufen worden sein
-					- 'rStream' steht genau an der Position, an der ein
-					  Surrogat f"ur ein Item mit der SlotId 'nSlotId' und
-					  der WhichId 'rWhichId' mit StoreSurrogate gepeichert
-					  wurde
-
-	Postconditions:	- 'rStream' ist so positioniert, wie auch StoreSurrogate
-					  sein speichern beendet hatte
-					- konnte ein Item geladen werden, befindet es sich
-					  in diesem SfxItemPool
-					- 'rWhichId' enth"alt die ggf. gemappte Which-Id
-	Laufzeit:       Tiefe des Ziel Sekund"arpools * 10 + 10
-
-	[Querverweise]
-
-	<SfxItemPool::StoreSurrogate(SvStream&,const SfxPoolItem &)const>
-*/
-
-{
-	// erstmal das Surrogat lesen
-	USHORT nSurrogat;
-	rStream >> nSurrogat;
-
-	// direkt gespeichertes Item?
-	if ( SFX_ITEMS_DIRECT == nSurrogat )
-		return 0;
-
-	// nicht vorhandenes Item?
-	if ( SFX_ITEMS_NULL == nSurrogat )
-	{
-		rWhich = 0;
-		return 0;
-	}
-
-	// Bei einem identisch aufgebauten Pool (im Stream) kann das Surrogat
-	// auf jeden Fall aufgel"ost werden.
-	if ( !pRefPool )
-		pRefPool = this;
-	FASTBOOL bResolvable = pRefPool->GetName().Len() > 0;
-	if ( !bResolvable )
-	{
-		// Bei einem anders aufgebauten Pool im Stream, mu\s die SlotId
-		// aus dem Stream in eine Which-Id gemappt werden k"onnen.
-		USHORT nMappedWhich = nSlotId ? GetWhich(nSlotId, TRUE) : 0;
-		if ( IsWhich(nMappedWhich) )
-		{
-			// gemappte SlotId kann "ubernommen werden
-			rWhich = nMappedWhich;
-			bResolvable = TRUE;
-		}
-	}
-
-	// kann Surrogat aufgel"ost werden?
-	const SfxPoolItem *pItem = 0;
-	if ( bResolvable )
-	{
-		for ( SfxItemPool *pTarget = this; pTarget; pTarget = pTarget->pSecondary )
-		{
-			// richtigen (Folge-) Pool gefunden?
-			if ( pTarget->IsInRange(rWhich) )
-			{
-				// dflt-Attribut?
-				if ( SFX_ITEMS_STATICDEFAULT == nSurrogat )
-					return *(pTarget->ppStaticDefaults +
-							pTarget->GetIndex_Impl(rWhich));
-
-				SfxPoolItemArray_Impl* pItemArr = *(pTarget->pImp->ppPoolItems +
-						pTarget->GetIndex_Impl(rWhich));
-				pItem = pItemArr && nSurrogat < pItemArr->Count()
-							? (*pItemArr)[nSurrogat]
-							: 0;
-				if ( !pItem )
-				{
-					DBG_ERROR( "can't resolve surrogate" );
-					rWhich = 0; // nur zur Sicherheit fuer richtige Stream-Pos
-					return 0;
-				}
-
-				// Nachladen aus Ref-Pool?
-				if ( pRefPool != pMaster )
-					return &pTarget->Put( *pItem );
-
-				// Referenzen sind NICHT schon mit Pool geladen worden?
-				if ( !pTarget->HasPersistentRefCounts() )
-					AddRef( *pItem, 1 );
-				else
-					return pItem;
-
-				return pItem;
-			}
-		}
-
-		SFX_ASSERT( FALSE, rWhich, "can't resolve Which-Id in LoadSurrogate" );
-	}
-
-	return 0;
-}
-
-//-------------------------------------------------------------------------
-
-
-FASTBOOL SfxItemPool::StoreSurrogate
-(
-	SvStream&			rStream,
-	const SfxPoolItem* 	pItem
-)	const
-
-/*	[Beschreibung]
-
-	Speichert ein Surrogat f"ur '*pItem' in 'rStream'.
-
-
-	[R"uckgabewert]
-
-	FASTBOOL				TRUE
-							es wurde ein echtes Surrogat gespeichert, auch
-							SFX_ITEMS_NULL bei 'pItem==0',
-							SFX_ITEMS_STATICDEFAULT und SFX_ITEMS_POOLDEFAULT
-							gelten als 'echte' Surrogate
-
-							FALSE
-							es wurde ein Dummy-Surrogat (SFX_ITEMS_DIRECT)
-							gespeichert, das eigentliche Item mu\s direkt
-							hinterher selbst gespeichert werden
-*/
-
-{
-	if ( pItem )
-	{
-		FASTBOOL bRealSurrogate = IsItemFlag(*pItem, SFX_ITEM_POOLABLE);
-		rStream << ( bRealSurrogate
-						? GetSurrogate( pItem )
-						: (UINT16) SFX_ITEMS_DIRECT );
-		return bRealSurrogate;
-	}
-
-	rStream << (UINT16) SFX_ITEMS_NULL;
-	return TRUE;
-}
-
-// -----------------------------------------------------------------------
-
-USHORT SfxItemPool::GetSurrogate(const SfxPoolItem *pItem) const
-{
-	DBG_CHKTHIS(SfxItemPool, 0);
-	DBG_ASSERT( pItem, "no 0-Pointer Surrogate" );
-	DBG_ASSERT( !IsInvalidItem(pItem), "no Invalid-Item Surrogate" );
-	DBG_ASSERT( !IsPoolDefaultItem(pItem), "no Pool-Default-Item Surrogate" );
-
-	if ( !IsInRange(pItem->Which()) )
-	{
-		if ( pSecondary )
-			return pSecondary->GetSurrogate( pItem );
-		SFX_ASSERT( 0, pItem->Which(), "unknown Which-Id - dont ask me for surrogates" );
-	}
-
-	// Pointer auf static- oder pool-dflt-Attribut?
-	if( IsStaticDefaultItem(pItem) || IsPoolDefaultItem(pItem) )
-		return SFX_ITEMS_STATICDEFAULT;
-
-	SfxPoolItemArray_Impl* pItemArr = *(pImp->ppPoolItems + GetIndex_Impl(pItem->Which()));
-	DBG_ASSERT(pItemArr, "ItemArr nicht vorhanden");
-	const USHORT nCount = pItemArr->Count();
-	for ( USHORT i = 0; i < nCount; ++i )
-	{
-		const SfxPoolItem *p = (*pItemArr)[i];
-		if ( p == pItem )
-			return i;
-	}
-	SFX_ASSERT( 0, pItem->Which(), "Item nicht im Pool");
-	return SFX_ITEMS_NULL;
-}
-
-// -----------------------------------------------------------------------
-
-FASTBOOL SfxItemPool::IsInStoringRange( USHORT nWhich ) const
-{
-	return nWhich >= pImp->nStoringStart &&
-		   nWhich <= pImp->nStoringEnd;
-}
-
-//------------------------------------------------------------------------
-
-void SfxItemPool::SetStoringRange( USHORT nFrom, USHORT nTo )
-
-/*	[Beschreibung]
-
-	Mit dieser Methode kann der Which-Bereich eingeengt werden, der
-	von ItemSets dieses Pool (und dem Pool selbst) gespeichert wird.
-	Die Methode muss dazu vor <SfxItemPool::Store()> gerufen werden
-	und die Werte muessen auch noch gesetzt sein, wenn das eigentliche
-	Dokument (also die ItemSets gespeicher werden).
-
-	Ein Zuruecksetzen ist dann nicht noetig, wenn dieser Range vor
-	JEDEM Speichern richtig gesetzt wird, da er nur beim Speichern
-	beruecksichtigt wird.
-
-	Dieses muss fuer das 3.1-Format gemacht werden, da dort eine
-	Bug in der Pool-Lade-Methode vorliegt.
-*/
-
-{
-	pImp->nStoringStart = nFrom;
-	pImp->nStoringEnd = nTo;
-}
-
-// -----------------------------------------------------------------------
-
-void SfxItemPool::SetVersionMap
-(
-	USHORT 	nVer, 				/* 	neue Versionsnummer */
-	USHORT  nOldStart,          /*  alte erste Which-Id */
-	USHORT  nOldEnd,            /*  alte letzte Which-Id */
-	USHORT*	pOldWhichIdTab		/* 	Array mit genau dem Aufbau der Which-Ids
-									der vorhergehenden Version, in denen
-									die jeweils neue Which-Id steht. */
-)
-
-/*	[Beschreibung]
-
-	Mit dieser Methode k"onnen neue, inkompatible Which-Id-Folgen oder
-	Verteilungen realisiert werden. Pools, die noch mit alten Versionen
-	gespeichert wurden, werden dann "uber die angegebene Tabelle solange
-	gemappt, bis die aktuelle Version erreicht ist. Neuere Pools k"onnen
-	unter Verlust neuer Attribute geladen werden, da die Map mit dem Pool
-	gespeichert wird.
-
-	Precondition:	Pool darf noch nicht geladen sein
-	Postcondition:	Which-Ids aus fr"uheren Versionen k"onnen bei Laden auf
-					Version 'nVer' gemappt werden
-	Laufzeit:       1.5 * new + 10
-
-	[Anmerkung]
-
-	F"ur neue Which-Ranges (nStart,nEnd) m"ssen im Vergleich zur Vorg"anger-
-	Version (nOldStart,nOldEnd) immer gelten, da\s (nOldStart,nOldEnd)
-	vollst"andig in (nStart,nEnd) enthalten ist. Es ist also zul"assig, den
-	Which-Range in beide Richtungen zu erweitern, auch durch Einf"ugung
-	von Which-Ids, nicht aber ihn zu beschneiden.
-
-	Diese Methode sollte nur im oder direkt nach Aufruf des Konstruktors
-	gerufen werden.
-
-	Das Array mu\s statisch sein, da es nicht kopiert wird und au\serdem
-	im Copy-Ctor des SfxItemPool wiederverwendet wird.
-
-
-	[Beispiel]
-
-	Urspr"unglich (Version 0) hatte der Pool folgende Which-Ids:
-
-		1:A, 2:B, 3:C, 4:D
-
-	Nun soll eine neue Version (Version 1) zwei zus"atzliche Ids X und Y
-	zwischen B und C erhalten, also wie folgt aussehen:
-
-		1:A, 2:B, 3:X, 4:Y, 5:C, 6:D
-
-	Dabei haben sich also die Ids 3 und 4 ge"andert. F"ur die neue Version
-	m"u\ste am Pool folgendes gesetzt werden:
-
-		static USHORT nVersion1Map = { 1, 2, 5, 6 };
-		pPool->SetVersionMap( 1, 1, 4, &nVersion1Map );
-
-
-	[Querverweise]
-
-	<SfxItemPool::IsLoadingVersionCurrent()const>
-	<SfxItemPool::GetNewWhich(USHORT)>
-	<SfxItemPool::GetVersion()const>
-	<SfxItemPool::GetLoadingVersion()const>
-*/
-
-{
-	// neuen Map-Eintrag erzeugen und einf"ugen
-	const SfxPoolVersion_Impl *pVerMap = new SfxPoolVersion_Impl(
-				nVer, nOldStart, nOldEnd, pOldWhichIdTab );
-	pImp->aVersions.Insert( pVerMap, pImp->aVersions.Count() );
-
-	DBG_ASSERT( nVer > pImp->nVersion, "Versions not sorted" );
-	pImp->nVersion = nVer;
-
-	// Versions-Range anpassen
-	for ( USHORT n = 0; n < nOldEnd-nOldStart+1; ++n )
-	{
-		USHORT nWhich = pOldWhichIdTab[n];
-		if ( nWhich < pImp->nVerStart )
-		{
-			if ( !nWhich )
-				nWhich = 0;
-			pImp->nVerStart = nWhich;
-		}
-		else if ( nWhich > pImp->nVerEnd )
-			pImp->nVerEnd = nWhich;
-	}
-}
-
-// -----------------------------------------------------------------------
-
-USHORT SfxItemPool::GetNewWhich
-(
-	USHORT	nFileWhich		// die aus dem Stream geladene Which-Id
-)	const
-
-/*	[Beschreibung]
-
-	Diese Methoden rechnet Which-Ids aus einem File-Format in die der
-	aktuellen Pool-Version um. Ist das File-Format "alter, werden die vom
-	Pool-Entwickler mit SetVersion() gesetzten Tabellen verwendet,
-	ist das File-Format neuer, dann die aus dem File geladenen Tabellen.
-	Im letzteren Fall kann ggf. nicht jede Which-Id gemappt werden,
-	so da\s 0 zur"uckgeliefert wird.
-
-	Die Berechnung ist nur f"ur Which-Ids definiert, die in der betreffenden
-	File-Version unterst"utzt wurden. Dies ist per Assertion abgesichert.
-
-	Precondition:	Pool mu\s geladen sein
-	Postcondition:	unver"andert
-	Laufzeit:		linear(Anzahl der Sekund"arpools) +
-					linear(Differenz zwischen alter und neuer Version)
-
-
-	[Querverweise]
-
-	<SfxItemPool::IsLoadingVersionCurrent()const>
-	<SfxItemPool::SetVersionMap(USHORT,USHORT,USHORT,USHORT*)>
-	<SfxItemPool::GetVersion()const>
-	<SfxItemPool::GetLoadingVersion()const>
-*/
-
-{
-	// (Sekund"ar-) Pool bestimmen
-	if ( !IsInVersionsRange(nFileWhich) )
-	{
-		if ( pSecondary )
-			return pSecondary->GetNewWhich( nFileWhich );
-		SFX_ASSERT( 0, nFileWhich, "unknown which in GetNewWhich()" );
-	}
-
-	// Version neuer/gleich/"alter?
-	short nDiff = (short)pImp->nLoadingVersion - (short)pImp->nVersion;
-
-	// Which-Id einer neueren Version?
-	if ( nDiff > 0 )
-	{
-		// von der Top-Version bis runter zur File-Version stufenweise mappen
-		for ( USHORT nMap = pImp->aVersions.Count(); nMap > 0; --nMap )
-		{
-			SfxPoolVersion_Impl *pVerInfo = pImp->aVersions[nMap-1];
-			if ( pVerInfo->_nVer > pImp->nVersion )
-			{	USHORT nOfs;
-				USHORT nCount = pVerInfo->_nEnd - pVerInfo->_nStart + 1;
-				for ( nOfs = 0;
-					  nOfs <= nCount &&
-						pVerInfo->_pMap[nOfs] != nFileWhich;
-					  ++nOfs )
-					continue;
-
-				if ( pVerInfo->_pMap[nOfs] == nFileWhich )
-					nFileWhich = pVerInfo->_nStart + nOfs;
-				else
-					return 0;
-			}
-			else
-				break;
-		}
-	}
-
-	// Which-Id einer neueren Version?
-	else if ( nDiff < 0 )
-	{
-		// von der File-Version bis zur aktuellen Version stufenweise mappen
-		for ( USHORT nMap = 0; nMap < pImp->aVersions.Count(); ++nMap )
-		{
-			SfxPoolVersion_Impl *pVerInfo = pImp->aVersions[nMap];
-			if ( pVerInfo->_nVer > pImp->nLoadingVersion )
-			{
-				DBG_ASSERT( nFileWhich >= pVerInfo->_nStart &&
-							nFileWhich <= pVerInfo->_nEnd,
-							"which-id unknown in version" );
-				nFileWhich = pVerInfo->_pMap[nFileWhich - pVerInfo->_nStart];
-			}
-		}
-	}
-
-	// originale (nDiff==0) bzw. gemappte (nDiff!=0) Id zur"uckliefern
-	return nFileWhich;
-}
-
-// -----------------------------------------------------------------------
-
-
-FASTBOOL SfxItemPool::IsInVersionsRange( USHORT nWhich ) const
-{
-	return nWhich >= pImp->nVerStart && nWhich <= pImp->nVerEnd;
-}
-
-// -----------------------------------------------------------------------
-
-FASTBOOL SfxItemPool::IsCurrentVersionLoading() const
-
-/*	[Beschreibung]
-
-	Mit dieser Methode kann festgestellt werden, ob die geladene Pool-Version
-	dem aktuellen Pool-Aufbau entspricht.
-
-	Precondition:	Pool mu\s geladen sein
-	Postcondition:	unver"andert
-	Laufzeit:		linear(Anzahl der Sekund"arpools)
-
-
-	[Querverweise]
-
-	<SfxItemPool::SetVersionMap(USHORT,USHORT,USHORT,USHORT*)>
-	<SfxItemPool::GetNewWhich(USHORT)const>
-	<SfxItemPool::GetVersion()const>
-	<SfxItemPool::GetLoadingVersion()const>
-*/
-
-{
-	return ( pImp->nVersion == pImp->nLoadingVersion ) &&
-		   ( !pSecondary || pSecondary->IsCurrentVersionLoading() );
-}
-
-// -----------------------------------------------------------------------
-
-USHORT SfxItemPool::GetVersion() const
-
-/*	[Beschreibung]
-
-	Diese Methode liefert die aktuelle Versionsnummer des SfxItemPool-Aufbaus
-	(also des Which-Bereichs).
-
-	Precondition:	keine
-	Postcondition:	unver"andert
-	Laufzeit:       2
-
-
-	[Anmerkung]
-
-	Achtung: Es mu\s ggf. die Versionsnummer von Sekund"arpools
-	ber"ucksichtigt werden.
-
-
-	[Querverweise]
-
-	<SfxItemPool::IsLoadingVersionCurrent()const>
-	<SfxItemPool::SetVersionMap(USHORT,USHORT,USHORT,USHORT*)>
-	<SfxItemPool::GetNewWhich(USHORT)const>
-	<SfxItemPool::GetLoadingVersion()const>
-*/
-
-{
-	return pImp->nVersion;
-}
-
-// -----------------------------------------------------------------------
-
-USHORT SfxItemPool::GetLoadingVersion() const
-
-/*	[Beschreibung]
-
-	Diese Methode liefert die Versionsnummer des SfxItemPool-Aufbaus
-	(also des Which-Bereichs), die bei Laden vorgefunden wurde.
-
-	Precondition:	Pool mu\s geladen sein
-	Postcondition:	unver"andert
-	Laufzeit:       2
-
-
-	[Anmerkung]
-
-	Achtung: Es mu\s ggf. die Versionsnummer von Sekund"arpools
-	ber"ucksichtigt werden.
-
-
-	[Querverweise]
-
-	<SfxItemPool::IsLoadingVersionCurrent()const>
-	<SfxItemPool::SetVersionMap(USHORT,USHORT,USHORT,USHORT*)>
-	<SfxItemPool::GetNewWhich(USHORT)const>
-	<SfxItemPool::GetVersion()const>
-*/
-
-{
-	return pImp->nLoadingVersion;
-}
-
-//-------------------------------------------------------------------------
-
-FASTBOOL SfxItemPool::IsVer2_Impl() const
-{
-	return pMaster->pImp->nMajorVer >= 2;
-}
-
-