xref: /aoo4110/main/svl/source/memtools/svarray.cxx (revision b1cdbd2c)

/**************************************************************
 *
 * 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"

#define _SVARRAY_CXX

#define _SVSTDARR_BOOLS
#define _SVSTDARR_BYTES
#define _SVSTDARR_ULONGS
#define _SVSTDARR_ULONGSSORT
#define _SVSTDARR_USHORTS
#define _SVSTDARR_LONGS
#define _SVSTDARR_LONGSSORT
#define _SVSTDARR_SHORTS
#define _SVSTDARR_STRINGS
#define _SVSTDARR_STRINGSDTOR
#define _SVSTDARR_STRINGSSORT
#define _SVSTDARR_STRINGSSORTDTOR
#define _SVSTDARR_STRINGSISORT
#define _SVSTDARR_STRINGSISORTDTOR
#define _SVSTDARR_USHORTSSORT

#define _SVSTDARR_BYTESTRINGS
#define _SVSTDARR_BYTESTRINGSDTOR
#define _SVSTDARR_BYTESTRINGSSORT
#define _SVSTDARR_BYTESTRINGSSORTDTOR
#define _SVSTDARR_BYTESTRINGSISORT
#define _SVSTDARR_BYTESTRINGSISORTDTOR

#define _SVSTDARR_XUB_STRLEN
#define _SVSTDARR_XUB_STRLENSORT

#include <svl/svstdarr.hxx>
#include <tools/string.hxx>
#include <tools/debug.hxx>

SV_IMPL_VARARR(SvPtrarr,VoidPtr)

sal_uInt16 SvPtrarr::GetPos( const VoidPtr& aElement ) const
{	sal_uInt16 n;
	for( n=0; n < nA && *(GetData()+n) != aElement; ) n++;
	return ( n >= nA ? USHRT_MAX : n );
}

SV_IMPL_VARARR( SvULongs, sal_uLong )
SV_IMPL_VARARR( SvUShorts, sal_uInt16 )
SV_IMPL_VARARR( SvLongs, long)

SV_IMPL_VARARR_SORT( SvULongsSort, sal_uLong )
SV_IMPL_VARARR_SORT( SvLongsSort, long )

SV_IMPL_PTRARR( SvStrings, StringPtr )
SV_IMPL_PTRARR( SvStringsDtor, StringPtr )
SV_IMPL_OP_PTRARR_SORT( SvStringsSort, StringPtr )
SV_IMPL_OP_PTRARR_SORT( SvStringsSortDtor, StringPtr )

SV_IMPL_PTRARR( SvByteStrings, ByteStringPtr )
SV_IMPL_PTRARR( SvByteStringsDtor, ByteStringPtr )
SV_IMPL_OP_PTRARR_SORT( SvByteStringsSort, ByteStringPtr )
SV_IMPL_OP_PTRARR_SORT( SvByteStringsSortDtor, ByteStringPtr )



// ---------------- strings -------------------------------------

// Array mit anderer Seek-Methode!
_SV_IMPL_SORTAR_ALG( SvStringsISort, StringPtr )
void SvStringsISort::DeleteAndDestroy( sal_uInt16 nP, sal_uInt16 nL )
{
	if( nL )
	{
		DBG_ASSERT( nP < nA && nP + nL <= nA, "ERR_VAR_DEL" );
		for( sal_uInt16 n=nP; n < nP + nL; n++ )
			delete *((StringPtr*)pData+n);
		SvPtrarr::Remove( nP, nL );
	}
}
sal_Bool SvStringsISort::Seek_Entry( const StringPtr aE, sal_uInt16* pP ) const
{
	register sal_uInt16 nO  = SvStringsISort_SAR::Count(),
			nM,
			nU = 0;
	if( nO > 0 )
	{
		nO--;
		while( nU <= nO )
		{
			nM = nU + ( nO - nU ) / 2;
			StringCompare eCmp = (*((StringPtr*)pData + nM))->
										CompareIgnoreCaseToAscii( *(aE) );
			if( COMPARE_EQUAL == eCmp )
			{
				if( pP ) *pP = nM;
				return sal_True;
			}
			else if( COMPARE_LESS == eCmp )
				nU = nM + 1;
			else if( nM == 0 )
			{
				if( pP ) *pP = nU;
				return sal_False;
			}
			else
				nO = nM - 1;
		}
	}
	if( pP ) *pP = nU;
	return sal_False;
}

// ---------------- strings -------------------------------------

// Array mit anderer Seek-Methode!
_SV_IMPL_SORTAR_ALG( SvStringsISortDtor, StringPtr )
void SvStringsISortDtor::DeleteAndDestroy( sal_uInt16 nP, sal_uInt16 nL )
{
	if( nL )
	{
		DBG_ASSERT( nP < nA && nP + nL <= nA, "ERR_VAR_DEL" );
		for( sal_uInt16 n=nP; n < nP + nL; n++ )
			delete *((StringPtr*)pData+n);
		SvPtrarr::Remove( nP, nL );
	}
}
sal_Bool SvStringsISortDtor::Seek_Entry( const StringPtr aE, sal_uInt16* pP ) const
{
	register sal_uInt16 nO  = SvStringsISortDtor_SAR::Count(),
			nM,
			nU = 0;
	if( nO > 0 )
	{
		nO--;
		while( nU <= nO )
		{
			nM = nU + ( nO - nU ) / 2;
			StringCompare eCmp = (*((StringPtr*)pData + nM))->
									CompareIgnoreCaseToAscii( *(aE) );
			if( COMPARE_EQUAL == eCmp )
			{
				if( pP ) *pP = nM;
				return sal_True;
			}
			else if( COMPARE_LESS == eCmp )
				nU = nM + 1;
			else if( nM == 0 )
			{
				if( pP ) *pP = nU;
				return sal_False;
			}
			else
				nO = nM - 1;
		}
	}
	if( pP ) *pP = nU;
	return sal_False;
}

// ---------------- Ushorts -------------------------------------

/* SortArray fuer UShorts */
sal_Bool SvUShortsSort::Seek_Entry( const sal_uInt16 aE, sal_uInt16* pP ) const
{
	register sal_uInt16 nO  = SvUShorts::Count(),
			nM,
			nU = 0;
	if( nO > 0 )
	{
		nO--;
		while( nU <= nO )
		{
			nM = nU + ( nO - nU ) / 2;
			if( *(pData + nM) == aE )
			{
				if( pP ) *pP = nM;
				return sal_True;
			}
			else if( *(pData + nM) < aE )
				nU = nM + 1;
			else if( nM == 0 )
			{
				if( pP ) *pP = nU;
				return sal_False;
			}
			else
				nO = nM - 1;
		}
	}
	if( pP ) *pP = nU;
	return sal_False;
}

void SvUShortsSort::Insert( const SvUShortsSort * pI, sal_uInt16 nS, sal_uInt16 nE )
{
	if( USHRT_MAX == nE )
		nE = pI->Count();
	sal_uInt16 nP;
	const sal_uInt16 * pIArr = pI->GetData();
	for( ; nS < nE; ++nS )
	{
		if( ! Seek_Entry( *(pIArr+nS), &nP) )
				SvUShorts::Insert( *(pIArr+nS), nP );
		if( ++nP >= Count() )
		{
			SvUShorts::Insert( pI, nP, nS+1, nE );
			nS = nE;
		}
	}
}

sal_Bool SvUShortsSort::Insert( const sal_uInt16 aE )
{
	sal_uInt16 nP;
	sal_Bool bExist = Seek_Entry( aE, &nP );
	if( !bExist )
		SvUShorts::Insert( aE, nP );
	return !bExist;
}

sal_Bool SvUShortsSort::Insert( const sal_uInt16 aE, sal_uInt16& rP )
{
	sal_Bool bExist = Seek_Entry( aE, &rP );
	if( !bExist )
		SvUShorts::Insert( aE, rP );
	return !bExist;
}

void SvUShortsSort::Insert( const sal_uInt16* pE, sal_uInt16 nL)
{
	sal_uInt16 nP;
	for( sal_uInt16 n = 0; n < nL; ++n )
		if( ! Seek_Entry( *(pE+n), &nP ))
			SvUShorts::Insert( *(pE+n), nP );
}

// remove ab Pos
void SvUShortsSort::RemoveAt( const sal_uInt16 nP, sal_uInt16 nL )
{
	if( nL )
		SvUShorts::Remove( nP, nL);
}

// remove ab dem Eintrag
void SvUShortsSort::Remove( const sal_uInt16 aE, sal_uInt16 nL )
{
	sal_uInt16 nP;
	if( nL && Seek_Entry( aE, &nP ) )
		SvUShorts::Remove( nP, nL);
}

// ---------------- bytestrings -------------------------------------

// Array mit anderer Seek-Methode!
_SV_IMPL_SORTAR_ALG( SvByteStringsISort, ByteStringPtr )
void SvByteStringsISort::DeleteAndDestroy( sal_uInt16 nP, sal_uInt16 nL )
{
	if( nL )
	{
		DBG_ASSERT( nP < nA && nP + nL <= nA, "ERR_VAR_DEL" );
		for( sal_uInt16 n=nP; n < nP + nL; n++ )
			delete *((ByteStringPtr*)pData+n);
		SvPtrarr::Remove( nP, nL );
	}
}
sal_Bool SvByteStringsISort::Seek_Entry( const ByteStringPtr aE, sal_uInt16* pP ) const
{
	register sal_uInt16 nO  = SvByteStringsISort_SAR::Count(),
			nM,
			nU = 0;
	if( nO > 0 )
	{
		nO--;
		while( nU <= nO )
		{
			nM = nU + ( nO - nU ) / 2;
			StringCompare eCmp = (*((ByteStringPtr*)pData + nM))->
						CompareIgnoreCaseToAscii( *(aE) );
			if( COMPARE_EQUAL == eCmp )
			{
				if( pP ) *pP = nM;
				return sal_True;
			}
			else if( COMPARE_LESS == eCmp )
				nU = nM + 1;
			else if( nM == 0 )
			{
				if( pP ) *pP = nU;
				return sal_False;
			}
			else
				nO = nM - 1;
		}
	}
	if( pP ) *pP = nU;
	return sal_False;
}


// Array mit anderer Seek-Methode!
_SV_IMPL_SORTAR_ALG( SvByteStringsISortDtor, ByteStringPtr )
void SvByteStringsISortDtor::DeleteAndDestroy( sal_uInt16 nP, sal_uInt16 nL )
{
	if( nL )
	{
		DBG_ASSERT( nP < nA && nP + nL <= nA, "ERR_VAR_DEL" );
		for( sal_uInt16 n=nP; n < nP + nL; n++ )
			delete *((ByteStringPtr*)pData+n);
		SvPtrarr::Remove( nP, nL );
	}
}
sal_Bool SvByteStringsISortDtor::Seek_Entry( const ByteStringPtr aE, sal_uInt16* pP ) const
{
	register sal_uInt16 nO  = SvByteStringsISortDtor_SAR::Count(),
			nM,
			nU = 0;
	if( nO > 0 )
	{
		nO--;
		while( nU <= nO )
		{
			nM = nU + ( nO - nU ) / 2;
			StringCompare eCmp = (*((ByteStringPtr*)pData + nM))->
									CompareIgnoreCaseToAscii( *(aE) );
			if( COMPARE_EQUAL == eCmp )
			{
				if( pP ) *pP = nM;
				return sal_True;
			}
			else if( COMPARE_LESS == eCmp )
				nU = nM + 1;
			else if( nM == 0 )
			{
				if( pP ) *pP = nU;
				return sal_False;
			}
			else
				nO = nM - 1;
		}
	}
	if( pP ) *pP = nU;
	return sal_False;
}