/************************************************************** * * 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 #include #include 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; }