1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_svl.hxx" 26 27 #define _SVARRAY_CXX 28 29 #define _SVSTDARR_BOOLS 30 #define _SVSTDARR_BYTES 31 #define _SVSTDARR_ULONGS 32 #define _SVSTDARR_ULONGSSORT 33 #define _SVSTDARR_USHORTS 34 #define _SVSTDARR_LONGS 35 #define _SVSTDARR_LONGSSORT 36 #define _SVSTDARR_SHORTS 37 #define _SVSTDARR_STRINGS 38 #define _SVSTDARR_STRINGSDTOR 39 #define _SVSTDARR_STRINGSSORT 40 #define _SVSTDARR_STRINGSSORTDTOR 41 #define _SVSTDARR_STRINGSISORT 42 #define _SVSTDARR_STRINGSISORTDTOR 43 #define _SVSTDARR_USHORTSSORT 44 45 #define _SVSTDARR_BYTESTRINGS 46 #define _SVSTDARR_BYTESTRINGSDTOR 47 #define _SVSTDARR_BYTESTRINGSSORT 48 #define _SVSTDARR_BYTESTRINGSSORTDTOR 49 #define _SVSTDARR_BYTESTRINGSISORT 50 #define _SVSTDARR_BYTESTRINGSISORTDTOR 51 52 #define _SVSTDARR_XUB_STRLEN 53 #define _SVSTDARR_XUB_STRLENSORT 54 55 #include <svl/svstdarr.hxx> 56 #include <tools/string.hxx> 57 #include <tools/debug.hxx> 58 59 SV_IMPL_VARARR(SvPtrarr,VoidPtr) 60 61 sal_uInt16 SvPtrarr::GetPos( const VoidPtr& aElement ) const 62 { sal_uInt16 n; 63 for( n=0; n < nA && *(GetData()+n) != aElement; ) n++; 64 return ( n >= nA ? USHRT_MAX : n ); 65 } 66 67 SV_IMPL_VARARR( SvULongs, sal_uLong ) 68 SV_IMPL_VARARR( SvUShorts, sal_uInt16 ) 69 SV_IMPL_VARARR( SvLongs, long) 70 71 SV_IMPL_VARARR_SORT( SvULongsSort, sal_uLong ) 72 SV_IMPL_VARARR_SORT( SvLongsSort, long ) 73 74 SV_IMPL_PTRARR( SvStrings, StringPtr ) 75 SV_IMPL_PTRARR( SvStringsDtor, StringPtr ) 76 SV_IMPL_OP_PTRARR_SORT( SvStringsSort, StringPtr ) 77 SV_IMPL_OP_PTRARR_SORT( SvStringsSortDtor, StringPtr ) 78 79 SV_IMPL_PTRARR( SvByteStrings, ByteStringPtr ) 80 SV_IMPL_PTRARR( SvByteStringsDtor, ByteStringPtr ) 81 SV_IMPL_OP_PTRARR_SORT( SvByteStringsSort, ByteStringPtr ) 82 SV_IMPL_OP_PTRARR_SORT( SvByteStringsSortDtor, ByteStringPtr ) 83 84 85 86 // ---------------- strings ------------------------------------- 87 88 // Array mit anderer Seek-Methode! 89 _SV_IMPL_SORTAR_ALG( SvStringsISort, StringPtr ) 90 void SvStringsISort::DeleteAndDestroy( sal_uInt16 nP, sal_uInt16 nL ) 91 { 92 if( nL ) 93 { 94 DBG_ASSERT( nP < nA && nP + nL <= nA, "ERR_VAR_DEL" ); 95 for( sal_uInt16 n=nP; n < nP + nL; n++ ) 96 delete *((StringPtr*)pData+n); 97 SvPtrarr::Remove( nP, nL ); 98 } 99 } 100 sal_Bool SvStringsISort::Seek_Entry( const StringPtr aE, sal_uInt16* pP ) const 101 { 102 register sal_uInt16 nO = SvStringsISort_SAR::Count(), 103 nM, 104 nU = 0; 105 if( nO > 0 ) 106 { 107 nO--; 108 while( nU <= nO ) 109 { 110 nM = nU + ( nO - nU ) / 2; 111 StringCompare eCmp = (*((StringPtr*)pData + nM))-> 112 CompareIgnoreCaseToAscii( *(aE) ); 113 if( COMPARE_EQUAL == eCmp ) 114 { 115 if( pP ) *pP = nM; 116 return sal_True; 117 } 118 else if( COMPARE_LESS == eCmp ) 119 nU = nM + 1; 120 else if( nM == 0 ) 121 { 122 if( pP ) *pP = nU; 123 return sal_False; 124 } 125 else 126 nO = nM - 1; 127 } 128 } 129 if( pP ) *pP = nU; 130 return sal_False; 131 } 132 133 // ---------------- strings ------------------------------------- 134 135 // Array mit anderer Seek-Methode! 136 _SV_IMPL_SORTAR_ALG( SvStringsISortDtor, StringPtr ) 137 void SvStringsISortDtor::DeleteAndDestroy( sal_uInt16 nP, sal_uInt16 nL ) 138 { 139 if( nL ) 140 { 141 DBG_ASSERT( nP < nA && nP + nL <= nA, "ERR_VAR_DEL" ); 142 for( sal_uInt16 n=nP; n < nP + nL; n++ ) 143 delete *((StringPtr*)pData+n); 144 SvPtrarr::Remove( nP, nL ); 145 } 146 } 147 sal_Bool SvStringsISortDtor::Seek_Entry( const StringPtr aE, sal_uInt16* pP ) const 148 { 149 register sal_uInt16 nO = SvStringsISortDtor_SAR::Count(), 150 nM, 151 nU = 0; 152 if( nO > 0 ) 153 { 154 nO--; 155 while( nU <= nO ) 156 { 157 nM = nU + ( nO - nU ) / 2; 158 StringCompare eCmp = (*((StringPtr*)pData + nM))-> 159 CompareIgnoreCaseToAscii( *(aE) ); 160 if( COMPARE_EQUAL == eCmp ) 161 { 162 if( pP ) *pP = nM; 163 return sal_True; 164 } 165 else if( COMPARE_LESS == eCmp ) 166 nU = nM + 1; 167 else if( nM == 0 ) 168 { 169 if( pP ) *pP = nU; 170 return sal_False; 171 } 172 else 173 nO = nM - 1; 174 } 175 } 176 if( pP ) *pP = nU; 177 return sal_False; 178 } 179 180 // ---------------- Ushorts ------------------------------------- 181 182 /* SortArray fuer UShorts */ 183 sal_Bool SvUShortsSort::Seek_Entry( const sal_uInt16 aE, sal_uInt16* pP ) const 184 { 185 register sal_uInt16 nO = SvUShorts::Count(), 186 nM, 187 nU = 0; 188 if( nO > 0 ) 189 { 190 nO--; 191 while( nU <= nO ) 192 { 193 nM = nU + ( nO - nU ) / 2; 194 if( *(pData + nM) == aE ) 195 { 196 if( pP ) *pP = nM; 197 return sal_True; 198 } 199 else if( *(pData + nM) < aE ) 200 nU = nM + 1; 201 else if( nM == 0 ) 202 { 203 if( pP ) *pP = nU; 204 return sal_False; 205 } 206 else 207 nO = nM - 1; 208 } 209 } 210 if( pP ) *pP = nU; 211 return sal_False; 212 } 213 214 void SvUShortsSort::Insert( const SvUShortsSort * pI, sal_uInt16 nS, sal_uInt16 nE ) 215 { 216 if( USHRT_MAX == nE ) 217 nE = pI->Count(); 218 sal_uInt16 nP; 219 const sal_uInt16 * pIArr = pI->GetData(); 220 for( ; nS < nE; ++nS ) 221 { 222 if( ! Seek_Entry( *(pIArr+nS), &nP) ) 223 SvUShorts::Insert( *(pIArr+nS), nP ); 224 if( ++nP >= Count() ) 225 { 226 SvUShorts::Insert( pI, nP, nS+1, nE ); 227 nS = nE; 228 } 229 } 230 } 231 232 sal_Bool SvUShortsSort::Insert( const sal_uInt16 aE ) 233 { 234 sal_uInt16 nP; 235 sal_Bool bExist = Seek_Entry( aE, &nP ); 236 if( !bExist ) 237 SvUShorts::Insert( aE, nP ); 238 return !bExist; 239 } 240 241 sal_Bool SvUShortsSort::Insert( const sal_uInt16 aE, sal_uInt16& rP ) 242 { 243 sal_Bool bExist = Seek_Entry( aE, &rP ); 244 if( !bExist ) 245 SvUShorts::Insert( aE, rP ); 246 return !bExist; 247 } 248 249 void SvUShortsSort::Insert( const sal_uInt16* pE, sal_uInt16 nL) 250 { 251 sal_uInt16 nP; 252 for( sal_uInt16 n = 0; n < nL; ++n ) 253 if( ! Seek_Entry( *(pE+n), &nP )) 254 SvUShorts::Insert( *(pE+n), nP ); 255 } 256 257 // remove ab Pos 258 void SvUShortsSort::RemoveAt( const sal_uInt16 nP, sal_uInt16 nL ) 259 { 260 if( nL ) 261 SvUShorts::Remove( nP, nL); 262 } 263 264 // remove ab dem Eintrag 265 void SvUShortsSort::Remove( const sal_uInt16 aE, sal_uInt16 nL ) 266 { 267 sal_uInt16 nP; 268 if( nL && Seek_Entry( aE, &nP ) ) 269 SvUShorts::Remove( nP, nL); 270 } 271 272 // ---------------- bytestrings ------------------------------------- 273 274 // Array mit anderer Seek-Methode! 275 _SV_IMPL_SORTAR_ALG( SvByteStringsISort, ByteStringPtr ) 276 void SvByteStringsISort::DeleteAndDestroy( sal_uInt16 nP, sal_uInt16 nL ) 277 { 278 if( nL ) 279 { 280 DBG_ASSERT( nP < nA && nP + nL <= nA, "ERR_VAR_DEL" ); 281 for( sal_uInt16 n=nP; n < nP + nL; n++ ) 282 delete *((ByteStringPtr*)pData+n); 283 SvPtrarr::Remove( nP, nL ); 284 } 285 } 286 sal_Bool SvByteStringsISort::Seek_Entry( const ByteStringPtr aE, sal_uInt16* pP ) const 287 { 288 register sal_uInt16 nO = SvByteStringsISort_SAR::Count(), 289 nM, 290 nU = 0; 291 if( nO > 0 ) 292 { 293 nO--; 294 while( nU <= nO ) 295 { 296 nM = nU + ( nO - nU ) / 2; 297 StringCompare eCmp = (*((ByteStringPtr*)pData + nM))-> 298 CompareIgnoreCaseToAscii( *(aE) ); 299 if( COMPARE_EQUAL == eCmp ) 300 { 301 if( pP ) *pP = nM; 302 return sal_True; 303 } 304 else if( COMPARE_LESS == eCmp ) 305 nU = nM + 1; 306 else if( nM == 0 ) 307 { 308 if( pP ) *pP = nU; 309 return sal_False; 310 } 311 else 312 nO = nM - 1; 313 } 314 } 315 if( pP ) *pP = nU; 316 return sal_False; 317 } 318 319 320 // Array mit anderer Seek-Methode! 321 _SV_IMPL_SORTAR_ALG( SvByteStringsISortDtor, ByteStringPtr ) 322 void SvByteStringsISortDtor::DeleteAndDestroy( sal_uInt16 nP, sal_uInt16 nL ) 323 { 324 if( nL ) 325 { 326 DBG_ASSERT( nP < nA && nP + nL <= nA, "ERR_VAR_DEL" ); 327 for( sal_uInt16 n=nP; n < nP + nL; n++ ) 328 delete *((ByteStringPtr*)pData+n); 329 SvPtrarr::Remove( nP, nL ); 330 } 331 } 332 sal_Bool SvByteStringsISortDtor::Seek_Entry( const ByteStringPtr aE, sal_uInt16* pP ) const 333 { 334 register sal_uInt16 nO = SvByteStringsISortDtor_SAR::Count(), 335 nM, 336 nU = 0; 337 if( nO > 0 ) 338 { 339 nO--; 340 while( nU <= nO ) 341 { 342 nM = nU + ( nO - nU ) / 2; 343 StringCompare eCmp = (*((ByteStringPtr*)pData + nM))-> 344 CompareIgnoreCaseToAscii( *(aE) ); 345 if( COMPARE_EQUAL == eCmp ) 346 { 347 if( pP ) *pP = nM; 348 return sal_True; 349 } 350 else if( COMPARE_LESS == eCmp ) 351 nU = nM + 1; 352 else if( nM == 0 ) 353 { 354 if( pP ) *pP = nU; 355 return sal_False; 356 } 357 else 358 nO = nM - 1; 359 } 360 } 361 if( pP ) *pP = nU; 362 return sal_False; 363 } 364 365