/**************************************************************
 * 
 * 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_sfx2.hxx"

#ifndef GCC
#endif

#include <sfx2/minarray.hxx>

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

SfxPtrArr::SfxPtrArr( sal_uInt8 nInitSize, sal_uInt8 nGrowSize ):
	nUsed( 0 ),
	nGrow( nGrowSize ? nGrowSize : 1 ),
	nUnused( nInitSize )
{
	DBG_MEMTEST();
	sal_uInt16 nMSCBug = nInitSize;

	if ( nMSCBug > 0 )
		pData = new void*[nMSCBug];
	else
		pData = 0;
}

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

SfxPtrArr::SfxPtrArr( const SfxPtrArr& rOrig )
{
	DBG_MEMTEST();
	nUsed = rOrig.nUsed;
	nGrow = rOrig.nGrow;
	nUnused = rOrig.nUnused;

	if ( rOrig.pData != 0 )
	{
		pData = new void*[nUsed+nUnused];
		memcpy( pData, rOrig.pData, nUsed*sizeof(void*) );
	}
	else
		pData = 0;
}

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

SfxPtrArr::~SfxPtrArr()
{
	DBG_MEMTEST();
	delete [] pData;
}

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

SfxPtrArr& SfxPtrArr::operator=( const SfxPtrArr& rOrig )
{
	DBG_MEMTEST();

	delete [] pData;

	nUsed = rOrig.nUsed;
	nGrow = rOrig.nGrow;
	nUnused = rOrig.nUnused;

	if ( rOrig.pData != 0 )
	{
		pData = new void*[nUsed+nUnused];
		memcpy( pData, rOrig.pData, nUsed*sizeof(void*) );
	}
	else
		pData = 0;
	return *this;
}

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

void SfxPtrArr::Append( void* aElem )
{
	DBG_MEMTEST();
	DBG_ASSERT( sal::static_int_cast< unsigned >(nUsed+1) < ( USHRT_MAX / sizeof(void*) ), "array too large" );
	// musz das Array umkopiert werden?
	if ( nUnused == 0 )
	{
		sal_uInt16 nNewSize = (nUsed == 1) ? (nGrow==1 ? 2 : nGrow) : nUsed+nGrow;
		void** pNewData = new void*[nNewSize];
		if ( pData )
		{
			DBG_ASSERT( nUsed <= nNewSize, "" );
			memmove( pNewData, pData, sizeof(void*)*nUsed );
			delete [] pData;
		}
		nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed);
		pData = pNewData;
	}

	// jetzt hinten in den freien Raum schreiben
	pData[nUsed] = aElem;
	++nUsed;
	--nUnused;
}

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

sal_uInt16 SfxPtrArr::Remove( sal_uInt16 nPos, sal_uInt16 nLen )
{
	DBG_MEMTEST();
	// nLen adjustieren, damit nicht ueber das Ende hinaus geloescht wird
	nLen = Min( (sal_uInt16)(nUsed-nPos), nLen );

	// einfache Aufgaben erfordern einfache Loesungen!
	if ( nLen == 0 )
		return 0;

	// bleibt vielleicht keiner uebrig
	if ( (nUsed-nLen) == 0 )
	{
		delete [] pData;
		pData = 0;
		nUsed = 0;
		nUnused = 0;
		return nLen;
	}

	// feststellen, ob das Array dadurch physikalisch schrumpft...
	if ( (nUnused+nLen) >= nGrow )
	{
		// auf die naechste Grow-Grenze aufgerundet verkleinern
		sal_uInt16 nNewUsed = nUsed-nLen;
		sal_uInt16 nNewSize = ((nNewUsed+nGrow-1)/nGrow) * nGrow;
		DBG_ASSERT( nNewUsed <= nNewSize && nNewUsed+nGrow > nNewSize,
					"shrink size computation failed" );
		void** pNewData = new void*[nNewSize];
		if ( nPos > 0 )
		{
			DBG_ASSERT( nPos <= nNewSize, "" );
			memmove( pNewData, pData, sizeof(void*)*nPos );
		}
		if ( nNewUsed != nPos )
			memmove( pNewData+nPos, pData+nPos+nLen,
					 sizeof(void*)*(nNewUsed-nPos) );
		delete [] pData;
		pData = pNewData;
		nUsed = nNewUsed;
		nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize - nNewUsed);
		return nLen;
	}

	// in allen anderen Faellen nur zusammenschieben
	if ( nUsed-nPos-nLen > 0 )
		memmove( pData+nPos, pData+nPos+nLen, (nUsed-nPos-nLen)*sizeof(void*) );
	nUsed = nUsed - nLen;
	nUnused = sal::static_int_cast< sal_uInt8 >(nUnused + nLen);
	return nLen;
}

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

sal_Bool SfxPtrArr::Remove( void* aElem )
{
	DBG_MEMTEST();
	// einfache Aufgaben ...
	if ( nUsed == 0 )
		return sal_False;

	// rueckwaerts, da meist der letzte zuerst wieder entfernt wird
	void* *pIter = pData + nUsed - 1;
	for ( sal_uInt16 n = 0; n < nUsed; ++n, --pIter )
		if ( *pIter == aElem )
		{
			Remove(nUsed-n-1, 1);
			return sal_True;
		}
	return sal_False;
}

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

sal_Bool SfxPtrArr::Replace( void* aOldElem, void* aNewElem )
{
	DBG_MEMTEST();
	// einfache Aufgaben ...
	if ( nUsed == 0 )
		return sal_False;

	// rueckwaerts, da meist der letzte zuerst wieder entfernt wird
	void* *pIter = pData + nUsed - 1;
	for ( sal_uInt16 n = 0; n < nUsed; ++n, --pIter )
		if ( *pIter == aOldElem )
		{
			pData[nUsed-n-1] = aNewElem;
			return sal_True;
		}
	return sal_False;
}

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

sal_Bool SfxPtrArr::Contains( const void* rItem ) const
{
	DBG_MEMTEST();
	if ( !nUsed )
		return sal_False;

	for ( sal_uInt16 n = 0; n < nUsed; ++n )
	{
		void* p = GetObject(n);
		if ( p == rItem )
			return sal_True;
	}

	return sal_False;
}

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

void SfxPtrArr::Insert( sal_uInt16 nPos, void* rElem )
{
	DBG_MEMTEST();
	DBG_ASSERT( sal::static_int_cast< unsigned >(nUsed+1) < ( USHRT_MAX / sizeof(void*) ), "array too large" );
	// musz das Array umkopiert werden?
	if ( nUnused == 0 )
	{
		// auf die naechste Grow-Grenze aufgerundet vergroeszern
		sal_uInt16 nNewSize = nUsed+nGrow;
		void** pNewData = new void*[nNewSize];

		if ( pData )
		{
			DBG_ASSERT( nUsed < nNewSize, "" );
			memmove( pNewData, pData, sizeof(void*)*nUsed );
			delete [] pData;
		}
		nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed);
		pData = pNewData;
	}

	// jetzt den hinteren Teil verschieben
	if ( nPos < nUsed )
		memmove( pData+nPos+1, pData+nPos, (nUsed-nPos)*sizeof(void*) );

	// jetzt in den freien Raum schreiben
	memmove( pData+nPos, &rElem, sizeof(void*) );
	nUsed += 1;
	nUnused -= 1;
}

// class ByteArr ---------------------------------------------------------

ByteArr::ByteArr( sal_uInt8 nInitSize, sal_uInt8 nGrowSize ):
	nUsed( 0 ),
	nGrow( nGrowSize ? nGrowSize : 1 ),
	nUnused( nInitSize )
{
	DBG_MEMTEST();
	sal_uInt16 nMSCBug = nInitSize;

	if ( nInitSize > 0 )
		pData = new char[nMSCBug];
	else
		pData = 0;
}

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

ByteArr::ByteArr( const ByteArr& rOrig )
{
	DBG_MEMTEST();
	nUsed = rOrig.nUsed;
	nGrow = rOrig.nGrow;
	nUnused = rOrig.nUnused;

	if ( rOrig.pData != 0 )
	{
		pData = new char[nUsed+nUnused];
		memcpy( pData, rOrig.pData, nUsed*sizeof(char) );
	}
	else
		pData = 0;
}

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

ByteArr::~ByteArr()
{
	DBG_MEMTEST();
	delete [] pData;
}

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

ByteArr& ByteArr::operator=( const ByteArr& rOrig )
{
	DBG_MEMTEST();

	delete [] pData;

	nUsed = rOrig.nUsed;
	nGrow = rOrig.nGrow;
	nUnused = rOrig.nUnused;

	if ( rOrig.pData != 0 )
	{
		pData = new char[nUsed+nUnused];
		memcpy( pData, rOrig.pData, nUsed*sizeof(char) );
	}
	else
		pData = 0;
	return *this;
}

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

void ByteArr::Append( char aElem )
{
	DBG_MEMTEST();
	// musz das Array umkopiert werden?
	if ( nUnused == 0 )
	{
		sal_uInt16 nNewSize = (nUsed == 1) ? (nGrow==1 ? 2 : nGrow) : nUsed+nGrow;
		char* pNewData = new char[nNewSize];
		if ( pData )
		{
			DBG_ASSERT( nUsed <= nNewSize, "" );
			memmove( pNewData, pData, sizeof(char)*nUsed );
			delete [] pData;
		}
		nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed);
		pData = pNewData;
	}

	// jetzt hinten in den freien Raum schreiben
	pData[nUsed] = aElem;
	++nUsed;
	--nUnused;
}

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

sal_uInt16 ByteArr::Remove( sal_uInt16 nPos, sal_uInt16 nLen )
{
	DBG_MEMTEST();
	// nLen adjustieren, damit nicht ueber das Ende hinaus geloescht wird
	nLen = Min( (sal_uInt16)(nUsed-nPos), nLen );

	// einfache Aufgaben erfordern einfache Loesungen!
	if ( nLen == 0 )
		return 0;

	// bleibt vielleicht keiner uebrig
	if ( (nUsed-nLen) == 0 )
	{
		delete [] pData;
		pData = 0;
		nUsed = 0;
		nUnused = 0;
		return nLen;
	}

	// feststellen, ob das Array dadurch physikalisch schrumpft...
	if ( (nUnused+nLen) >= nGrow )
	{
		// auf die naechste Grow-Grenze aufgerundet verkleinern
		sal_uInt16 nNewUsed = nUsed-nLen;
		sal_uInt16 nNewSize = ((nNewUsed+nGrow-1)/nGrow) * nGrow;
		DBG_ASSERT( nNewUsed <= nNewSize && nNewUsed+nGrow > nNewSize,
					"shrink size computation failed" );
		char* pNewData = new char[nNewSize];
		if ( nPos > 0 )
		{
			DBG_ASSERT( nPos <= nNewSize, "" );
			memmove( pNewData, pData, sizeof(char)*nPos );
		}
		if ( nNewUsed != nPos )
			memmove( pNewData+nPos, pData+nPos+nLen,
					 sizeof(char)*(nNewUsed-nPos) );
		delete [] pData;
		pData = pNewData;
		nUsed = nNewUsed;
		nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize - nNewUsed);
		return nLen;
	}

	// in allen anderen Faellen nur zusammenschieben
	if ( nUsed-nPos-nLen > 0 )
		memmove( pData+nPos, pData+nPos+nLen, (nUsed-nPos-nLen)*sizeof(char) );
	nUsed = nUsed - nLen;
	nUnused = sal::static_int_cast< sal_uInt8 >(nUnused + nLen);
	return nLen;
}

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

sal_Bool ByteArr::Remove( char aElem )
{
	DBG_MEMTEST();
	// einfache Aufgaben ...
	if ( nUsed == 0 )
		return sal_False;

	// rueckwaerts, da meist der letzte zuerst wieder entfernt wird
	char *pIter = pData + nUsed - 1;
	for ( sal_uInt16 n = 0; n < nUsed; ++n, --pIter )
		if ( *pIter == aElem )
		{
			Remove(nUsed-n-1, 1);
			return sal_True;
		}
	return sal_False;
}

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

sal_Bool ByteArr::Contains( const char rItem ) const
{
	DBG_MEMTEST();
	if ( !nUsed )
		return sal_False;

	for ( sal_uInt16 n = 0; n < nUsed; ++n )
	{
		char p = GetObject(n);
		if ( p == rItem )
			return sal_True;
	}

	return sal_False;
}

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

void ByteArr::Insert( sal_uInt16 nPos, char rElem )
{
	DBG_MEMTEST();
	// musz das Array umkopiert werden?
	if ( nUnused == 0 )
	{
		// auf die naechste Grow-Grenze aufgerundet vergroeszern
		sal_uInt16 nNewSize = nUsed+nGrow;
		char* pNewData = new char[nNewSize];

		if ( pData )
		{
			DBG_ASSERT( nUsed < nNewSize, "" );
			memmove( pNewData, pData, sizeof(char)*nUsed );
			delete [] pData;
		}
		nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed);
		pData = pNewData;
	}

	// jetzt den hinteren Teil verschieben
	if ( nPos < nUsed )
		memmove( pData+nPos+1, pData+nPos, (nUsed-nPos)*sizeof(char) );

	// jetzt in den freien Raum schreiben
	memmove( pData+nPos, &rElem, sizeof(char) );
	nUsed += 1;
	nUnused -= 1;
}

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

char ByteArr::operator[]( sal_uInt16 nPos ) const
{
	DBG_MEMTEST();
	DBG_ASSERT( nPos < nUsed, "" );
	return *(pData+nPos);
}

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

char& ByteArr::operator [] (sal_uInt16 nPos)
{
	DBG_MEMTEST();
	DBG_ASSERT( nPos < nUsed, "" );
	return *(pData+nPos);
}

// class WordArr ---------------------------------------------------------

WordArr::WordArr( sal_uInt8 nInitSize, sal_uInt8 nGrowSize ):
	nUsed( 0 ),
	nGrow( nGrowSize ? nGrowSize : 1 ),
	nUnused( nInitSize )
{
	DBG_MEMTEST();
	sal_uInt16 nMSCBug = nInitSize;

	if ( nInitSize > 0 )
		pData = new short[nMSCBug];
	else
		pData = 0;
}

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

WordArr::WordArr( const WordArr& rOrig )
{
	DBG_MEMTEST();
	nUsed = rOrig.nUsed;
	nGrow = rOrig.nGrow;
	nUnused = rOrig.nUnused;

	if ( rOrig.pData != 0 )
	{
		pData = new short[nUsed+nUnused];
		memcpy( pData, rOrig.pData, nUsed*sizeof(short) );
	}
	else
		pData = 0;
}

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

WordArr::~WordArr()
{
	DBG_MEMTEST();
	delete [] pData;
}

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

WordArr& WordArr::operator=( const WordArr& rOrig )
{
	DBG_MEMTEST();

	delete [] pData;

	nUsed = rOrig.nUsed;
	nGrow = rOrig.nGrow;
	nUnused = rOrig.nUnused;

	if ( rOrig.pData != 0 )
	{
		pData = new short[nUsed+nUnused];
		memcpy( pData, rOrig.pData, nUsed*sizeof(short) );
	}
	else
		pData = 0;
	return *this;
}

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

void WordArr::Append( short aElem )
{
	DBG_MEMTEST();
	// musz das Array umkopiert werden?
	if ( nUnused == 0 )
	{
		sal_uInt16 nNewSize = (nUsed == 1) ? (nGrow==1 ? 2 : nGrow) : nUsed+nGrow;
		short* pNewData = new short[nNewSize];
		if ( pData )
		{
			DBG_ASSERT( nUsed <= nNewSize, " " );
			memmove( pNewData, pData, sizeof(short)*nUsed );
			delete [] pData;
		}
		nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed);
		pData = pNewData;
	}

	// jetzt hinten in den freien Raum schreiben
	pData[nUsed] = aElem;
	++nUsed;
	--nUnused;
}

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

sal_uInt16 WordArr::Remove( sal_uInt16 nPos, sal_uInt16 nLen )
{
	DBG_MEMTEST();
	// nLen adjustieren, damit nicht ueber das Ende hinaus geloescht wird
	nLen = Min( (sal_uInt16)(nUsed-nPos), nLen );

	// einfache Aufgaben erfordern einfache Loesungen!
	if ( nLen == 0 )
		return 0;

	// bleibt vielleicht keiner uebrig
	if ( (nUsed-nLen) == 0 )
	{
		delete [] pData;
		pData = 0;
		nUsed = 0;
		nUnused = 0;
		return nLen;
	}

	// feststellen, ob das Array dadurch physikalisch schrumpft...
	if ( (nUnused+nLen) >= nGrow )
	{
		// auf die naechste Grow-Grenze aufgerundet verkleinern
		sal_uInt16 nNewUsed = nUsed-nLen;
		sal_uInt16 nNewSize = ((nNewUsed+nGrow-1)/nGrow) * nGrow;
		DBG_ASSERT( nNewUsed <= nNewSize && nNewUsed+nGrow > nNewSize,
					"shrink size computation failed" );
		short* pNewData = new short[nNewSize];
		if ( nPos > 0 )
		{
			DBG_ASSERT( nPos <= nNewSize, "" );
			memmove( pNewData, pData, sizeof(short)*nPos );
		}
		if ( nNewUsed != nPos )
			memmove( pNewData+nPos, pData+nPos+nLen,
					 sizeof(short)*(nNewUsed-nPos) );
			delete [] pData;
		pData = pNewData;
		nUsed = nNewUsed;
		nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize - nNewUsed);
		return nLen;
	}

	// in allen anderen Faellen nur zusammenschieben
	if ( nUsed-nPos-nLen > 0 )
		memmove( pData+nPos, pData+nPos+nLen, (nUsed-nPos-nLen)*sizeof(short) );
	nUsed = nUsed - nLen;
	nUnused = sal::static_int_cast< sal_uInt8 >(nUnused + nLen);
	return nLen;
}

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

sal_Bool WordArr::Remove( short aElem )
{
	DBG_MEMTEST();
	// einfache Aufgaben ...
	if ( nUsed == 0 )
		return sal_False;

	// rueckwaerts, da meist der letzte zuerst wieder entfernt wird
	short *pIter = pData + nUsed - 1;
	for ( sal_uInt16 n = 0; n < nUsed; ++n, --pIter )
		if ( *pIter == aElem )
		{
			Remove(nUsed-n-1, 1);
			return sal_True;
		}
	return sal_False;
}

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

sal_Bool WordArr::Contains( const short rItem ) const
{
	DBG_MEMTEST();
	if ( !nUsed )
		return sal_False;

	for ( sal_uInt16 n = 0; n < nUsed; ++n )
	{
		short p = GetObject(n);
		if ( p == rItem )
			return sal_True;
	}

	return sal_False;
}

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

void WordArr::Insert( sal_uInt16 nPos, short rElem )
{
	DBG_MEMTEST();
	// musz das Array umkopiert werden?
	if ( nUnused == 0 )
	{
		// auf die naechste Grow-Grenze aufgerundet vergroeszern
		sal_uInt16 nNewSize = nUsed+nGrow;
		short* pNewData = new short[nNewSize];

		if ( pData )
		{
			DBG_ASSERT( nUsed < nNewSize, "" );
			memmove( pNewData, pData, sizeof(short)*nUsed );
			delete [] pData;
		}
		nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed);
		pData = pNewData;
	}

	// jetzt den hinteren Teil verschieben
	if ( nPos < nUsed )
		memmove( pData+nPos+1, pData+nPos, (nUsed-nPos)*sizeof(short) );

	// jetzt in den freien Raum schreiben
	memmove( pData+nPos, &rElem, sizeof(short) );
	nUsed += 1;
	nUnused -= 1;
}

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

short WordArr::operator[]( sal_uInt16 nPos ) const
{
	DBG_MEMTEST();
	DBG_ASSERT( nPos < nUsed, "" );
	return *(pData+nPos);
}

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

short& WordArr::operator [] (sal_uInt16 nPos)
{
	DBG_MEMTEST();
	DBG_ASSERT( nPos < nUsed, "" );
	return *(pData+nPos);
}