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_sfx2.hxx" 26 27 #ifndef GCC 28 #endif 29 30 #include <sfx2/minarray.hxx> 31 32 // ----------------------------------------------------------------------- 33 34 SfxPtrArr::SfxPtrArr( sal_uInt8 nInitSize, sal_uInt8 nGrowSize ): 35 nUsed( 0 ), 36 nGrow( nGrowSize ? nGrowSize : 1 ), 37 nUnused( nInitSize ) 38 { 39 DBG_MEMTEST(); 40 sal_uInt16 nMSCBug = nInitSize; 41 42 if ( nMSCBug > 0 ) 43 pData = new void*[nMSCBug]; 44 else 45 pData = 0; 46 } 47 48 // ----------------------------------------------------------------------- 49 50 SfxPtrArr::SfxPtrArr( const SfxPtrArr& rOrig ) 51 { 52 DBG_MEMTEST(); 53 nUsed = rOrig.nUsed; 54 nGrow = rOrig.nGrow; 55 nUnused = rOrig.nUnused; 56 57 if ( rOrig.pData != 0 ) 58 { 59 pData = new void*[nUsed+nUnused]; 60 memcpy( pData, rOrig.pData, nUsed*sizeof(void*) ); 61 } 62 else 63 pData = 0; 64 } 65 66 // ----------------------------------------------------------------------- 67 68 SfxPtrArr::~SfxPtrArr() 69 { 70 DBG_MEMTEST(); 71 delete [] pData; 72 } 73 74 // ----------------------------------------------------------------------- 75 76 SfxPtrArr& SfxPtrArr::operator=( const SfxPtrArr& rOrig ) 77 { 78 DBG_MEMTEST(); 79 80 delete [] pData; 81 82 nUsed = rOrig.nUsed; 83 nGrow = rOrig.nGrow; 84 nUnused = rOrig.nUnused; 85 86 if ( rOrig.pData != 0 ) 87 { 88 pData = new void*[nUsed+nUnused]; 89 memcpy( pData, rOrig.pData, nUsed*sizeof(void*) ); 90 } 91 else 92 pData = 0; 93 return *this; 94 } 95 96 // ----------------------------------------------------------------------- 97 98 void SfxPtrArr::Append( void* aElem ) 99 { 100 DBG_MEMTEST(); 101 DBG_ASSERT( sal::static_int_cast< unsigned >(nUsed+1) < ( USHRT_MAX / sizeof(void*) ), "array too large" ); 102 // musz das Array umkopiert werden? 103 if ( nUnused == 0 ) 104 { 105 sal_uInt16 nNewSize = (nUsed == 1) ? (nGrow==1 ? 2 : nGrow) : nUsed+nGrow; 106 void** pNewData = new void*[nNewSize]; 107 if ( pData ) 108 { 109 DBG_ASSERT( nUsed <= nNewSize, "" ); 110 memmove( pNewData, pData, sizeof(void*)*nUsed ); 111 delete [] pData; 112 } 113 nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed); 114 pData = pNewData; 115 } 116 117 // jetzt hinten in den freien Raum schreiben 118 pData[nUsed] = aElem; 119 ++nUsed; 120 --nUnused; 121 } 122 123 // ----------------------------------------------------------------------- 124 125 sal_uInt16 SfxPtrArr::Remove( sal_uInt16 nPos, sal_uInt16 nLen ) 126 { 127 DBG_MEMTEST(); 128 // nLen adjustieren, damit nicht ueber das Ende hinaus geloescht wird 129 nLen = Min( (sal_uInt16)(nUsed-nPos), nLen ); 130 131 // einfache Aufgaben erfordern einfache Loesungen! 132 if ( nLen == 0 ) 133 return 0; 134 135 // bleibt vielleicht keiner uebrig 136 if ( (nUsed-nLen) == 0 ) 137 { 138 delete [] pData; 139 pData = 0; 140 nUsed = 0; 141 nUnused = 0; 142 return nLen; 143 } 144 145 // feststellen, ob das Array dadurch physikalisch schrumpft... 146 if ( (nUnused+nLen) >= nGrow ) 147 { 148 // auf die naechste Grow-Grenze aufgerundet verkleinern 149 sal_uInt16 nNewUsed = nUsed-nLen; 150 sal_uInt16 nNewSize = ((nNewUsed+nGrow-1)/nGrow) * nGrow; 151 DBG_ASSERT( nNewUsed <= nNewSize && nNewUsed+nGrow > nNewSize, 152 "shrink size computation failed" ); 153 void** pNewData = new void*[nNewSize]; 154 if ( nPos > 0 ) 155 { 156 DBG_ASSERT( nPos <= nNewSize, "" ); 157 memmove( pNewData, pData, sizeof(void*)*nPos ); 158 } 159 if ( nNewUsed != nPos ) 160 memmove( pNewData+nPos, pData+nPos+nLen, 161 sizeof(void*)*(nNewUsed-nPos) ); 162 delete [] pData; 163 pData = pNewData; 164 nUsed = nNewUsed; 165 nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize - nNewUsed); 166 return nLen; 167 } 168 169 // in allen anderen Faellen nur zusammenschieben 170 if ( nUsed-nPos-nLen > 0 ) 171 memmove( pData+nPos, pData+nPos+nLen, (nUsed-nPos-nLen)*sizeof(void*) ); 172 nUsed = nUsed - nLen; 173 nUnused = sal::static_int_cast< sal_uInt8 >(nUnused + nLen); 174 return nLen; 175 } 176 177 // ----------------------------------------------------------------------- 178 179 sal_Bool SfxPtrArr::Remove( void* aElem ) 180 { 181 DBG_MEMTEST(); 182 // einfache Aufgaben ... 183 if ( nUsed == 0 ) 184 return sal_False; 185 186 // rueckwaerts, da meist der letzte zuerst wieder entfernt wird 187 void* *pIter = pData + nUsed - 1; 188 for ( sal_uInt16 n = 0; n < nUsed; ++n, --pIter ) 189 if ( *pIter == aElem ) 190 { 191 Remove(nUsed-n-1, 1); 192 return sal_True; 193 } 194 return sal_False; 195 } 196 197 // ----------------------------------------------------------------------- 198 199 sal_Bool SfxPtrArr::Replace( void* aOldElem, void* aNewElem ) 200 { 201 DBG_MEMTEST(); 202 // einfache Aufgaben ... 203 if ( nUsed == 0 ) 204 return sal_False; 205 206 // rueckwaerts, da meist der letzte zuerst wieder entfernt wird 207 void* *pIter = pData + nUsed - 1; 208 for ( sal_uInt16 n = 0; n < nUsed; ++n, --pIter ) 209 if ( *pIter == aOldElem ) 210 { 211 pData[nUsed-n-1] = aNewElem; 212 return sal_True; 213 } 214 return sal_False; 215 } 216 217 // ----------------------------------------------------------------------- 218 219 sal_Bool SfxPtrArr::Contains( const void* rItem ) const 220 { 221 DBG_MEMTEST(); 222 if ( !nUsed ) 223 return sal_False; 224 225 for ( sal_uInt16 n = 0; n < nUsed; ++n ) 226 { 227 void* p = GetObject(n); 228 if ( p == rItem ) 229 return sal_True; 230 } 231 232 return sal_False; 233 } 234 235 // ----------------------------------------------------------------------- 236 237 void SfxPtrArr::Insert( sal_uInt16 nPos, void* rElem ) 238 { 239 DBG_MEMTEST(); 240 DBG_ASSERT( sal::static_int_cast< unsigned >(nUsed+1) < ( USHRT_MAX / sizeof(void*) ), "array too large" ); 241 // musz das Array umkopiert werden? 242 if ( nUnused == 0 ) 243 { 244 // auf die naechste Grow-Grenze aufgerundet vergroeszern 245 sal_uInt16 nNewSize = nUsed+nGrow; 246 void** pNewData = new void*[nNewSize]; 247 248 if ( pData ) 249 { 250 DBG_ASSERT( nUsed < nNewSize, "" ); 251 memmove( pNewData, pData, sizeof(void*)*nUsed ); 252 delete [] pData; 253 } 254 nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed); 255 pData = pNewData; 256 } 257 258 // jetzt den hinteren Teil verschieben 259 if ( nPos < nUsed ) 260 memmove( pData+nPos+1, pData+nPos, (nUsed-nPos)*sizeof(void*) ); 261 262 // jetzt in den freien Raum schreiben 263 memmove( pData+nPos, &rElem, sizeof(void*) ); 264 nUsed += 1; 265 nUnused -= 1; 266 } 267 268 // class ByteArr --------------------------------------------------------- 269 270 ByteArr::ByteArr( sal_uInt8 nInitSize, sal_uInt8 nGrowSize ): 271 nUsed( 0 ), 272 nGrow( nGrowSize ? nGrowSize : 1 ), 273 nUnused( nInitSize ) 274 { 275 DBG_MEMTEST(); 276 sal_uInt16 nMSCBug = nInitSize; 277 278 if ( nInitSize > 0 ) 279 pData = new char[nMSCBug]; 280 else 281 pData = 0; 282 } 283 284 // ----------------------------------------------------------------------- 285 286 ByteArr::ByteArr( const ByteArr& rOrig ) 287 { 288 DBG_MEMTEST(); 289 nUsed = rOrig.nUsed; 290 nGrow = rOrig.nGrow; 291 nUnused = rOrig.nUnused; 292 293 if ( rOrig.pData != 0 ) 294 { 295 pData = new char[nUsed+nUnused]; 296 memcpy( pData, rOrig.pData, nUsed*sizeof(char) ); 297 } 298 else 299 pData = 0; 300 } 301 302 // ----------------------------------------------------------------------- 303 304 ByteArr::~ByteArr() 305 { 306 DBG_MEMTEST(); 307 delete [] pData; 308 } 309 310 // ----------------------------------------------------------------------- 311 312 ByteArr& ByteArr::operator=( const ByteArr& rOrig ) 313 { 314 DBG_MEMTEST(); 315 316 delete [] pData; 317 318 nUsed = rOrig.nUsed; 319 nGrow = rOrig.nGrow; 320 nUnused = rOrig.nUnused; 321 322 if ( rOrig.pData != 0 ) 323 { 324 pData = new char[nUsed+nUnused]; 325 memcpy( pData, rOrig.pData, nUsed*sizeof(char) ); 326 } 327 else 328 pData = 0; 329 return *this; 330 } 331 332 // ----------------------------------------------------------------------- 333 334 void ByteArr::Append( char aElem ) 335 { 336 DBG_MEMTEST(); 337 // musz das Array umkopiert werden? 338 if ( nUnused == 0 ) 339 { 340 sal_uInt16 nNewSize = (nUsed == 1) ? (nGrow==1 ? 2 : nGrow) : nUsed+nGrow; 341 char* pNewData = new char[nNewSize]; 342 if ( pData ) 343 { 344 DBG_ASSERT( nUsed <= nNewSize, "" ); 345 memmove( pNewData, pData, sizeof(char)*nUsed ); 346 delete [] pData; 347 } 348 nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed); 349 pData = pNewData; 350 } 351 352 // jetzt hinten in den freien Raum schreiben 353 pData[nUsed] = aElem; 354 ++nUsed; 355 --nUnused; 356 } 357 358 // ----------------------------------------------------------------------- 359 360 sal_uInt16 ByteArr::Remove( sal_uInt16 nPos, sal_uInt16 nLen ) 361 { 362 DBG_MEMTEST(); 363 // nLen adjustieren, damit nicht ueber das Ende hinaus geloescht wird 364 nLen = Min( (sal_uInt16)(nUsed-nPos), nLen ); 365 366 // einfache Aufgaben erfordern einfache Loesungen! 367 if ( nLen == 0 ) 368 return 0; 369 370 // bleibt vielleicht keiner uebrig 371 if ( (nUsed-nLen) == 0 ) 372 { 373 delete [] pData; 374 pData = 0; 375 nUsed = 0; 376 nUnused = 0; 377 return nLen; 378 } 379 380 // feststellen, ob das Array dadurch physikalisch schrumpft... 381 if ( (nUnused+nLen) >= nGrow ) 382 { 383 // auf die naechste Grow-Grenze aufgerundet verkleinern 384 sal_uInt16 nNewUsed = nUsed-nLen; 385 sal_uInt16 nNewSize = ((nNewUsed+nGrow-1)/nGrow) * nGrow; 386 DBG_ASSERT( nNewUsed <= nNewSize && nNewUsed+nGrow > nNewSize, 387 "shrink size computation failed" ); 388 char* pNewData = new char[nNewSize]; 389 if ( nPos > 0 ) 390 { 391 DBG_ASSERT( nPos <= nNewSize, "" ); 392 memmove( pNewData, pData, sizeof(char)*nPos ); 393 } 394 if ( nNewUsed != nPos ) 395 memmove( pNewData+nPos, pData+nPos+nLen, 396 sizeof(char)*(nNewUsed-nPos) ); 397 delete [] pData; 398 pData = pNewData; 399 nUsed = nNewUsed; 400 nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize - nNewUsed); 401 return nLen; 402 } 403 404 // in allen anderen Faellen nur zusammenschieben 405 if ( nUsed-nPos-nLen > 0 ) 406 memmove( pData+nPos, pData+nPos+nLen, (nUsed-nPos-nLen)*sizeof(char) ); 407 nUsed = nUsed - nLen; 408 nUnused = sal::static_int_cast< sal_uInt8 >(nUnused + nLen); 409 return nLen; 410 } 411 412 // ----------------------------------------------------------------------- 413 414 sal_Bool ByteArr::Remove( char aElem ) 415 { 416 DBG_MEMTEST(); 417 // einfache Aufgaben ... 418 if ( nUsed == 0 ) 419 return sal_False; 420 421 // rueckwaerts, da meist der letzte zuerst wieder entfernt wird 422 char *pIter = pData + nUsed - 1; 423 for ( sal_uInt16 n = 0; n < nUsed; ++n, --pIter ) 424 if ( *pIter == aElem ) 425 { 426 Remove(nUsed-n-1, 1); 427 return sal_True; 428 } 429 return sal_False; 430 } 431 432 // ----------------------------------------------------------------------- 433 434 sal_Bool ByteArr::Contains( const char rItem ) const 435 { 436 DBG_MEMTEST(); 437 if ( !nUsed ) 438 return sal_False; 439 440 for ( sal_uInt16 n = 0; n < nUsed; ++n ) 441 { 442 char p = GetObject(n); 443 if ( p == rItem ) 444 return sal_True; 445 } 446 447 return sal_False; 448 } 449 450 // ----------------------------------------------------------------------- 451 452 void ByteArr::Insert( sal_uInt16 nPos, char rElem ) 453 { 454 DBG_MEMTEST(); 455 // musz das Array umkopiert werden? 456 if ( nUnused == 0 ) 457 { 458 // auf die naechste Grow-Grenze aufgerundet vergroeszern 459 sal_uInt16 nNewSize = nUsed+nGrow; 460 char* pNewData = new char[nNewSize]; 461 462 if ( pData ) 463 { 464 DBG_ASSERT( nUsed < nNewSize, "" ); 465 memmove( pNewData, pData, sizeof(char)*nUsed ); 466 delete [] pData; 467 } 468 nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed); 469 pData = pNewData; 470 } 471 472 // jetzt den hinteren Teil verschieben 473 if ( nPos < nUsed ) 474 memmove( pData+nPos+1, pData+nPos, (nUsed-nPos)*sizeof(char) ); 475 476 // jetzt in den freien Raum schreiben 477 memmove( pData+nPos, &rElem, sizeof(char) ); 478 nUsed += 1; 479 nUnused -= 1; 480 } 481 482 // ----------------------------------------------------------------------- 483 484 char ByteArr::operator[]( sal_uInt16 nPos ) const 485 { 486 DBG_MEMTEST(); 487 DBG_ASSERT( nPos < nUsed, "" ); 488 return *(pData+nPos); 489 } 490 491 // ----------------------------------------------------------------------- 492 493 char& ByteArr::operator [] (sal_uInt16 nPos) 494 { 495 DBG_MEMTEST(); 496 DBG_ASSERT( nPos < nUsed, "" ); 497 return *(pData+nPos); 498 } 499 500 // class WordArr --------------------------------------------------------- 501 502 WordArr::WordArr( sal_uInt8 nInitSize, sal_uInt8 nGrowSize ): 503 nUsed( 0 ), 504 nGrow( nGrowSize ? nGrowSize : 1 ), 505 nUnused( nInitSize ) 506 { 507 DBG_MEMTEST(); 508 sal_uInt16 nMSCBug = nInitSize; 509 510 if ( nInitSize > 0 ) 511 pData = new short[nMSCBug]; 512 else 513 pData = 0; 514 } 515 516 // ----------------------------------------------------------------------- 517 518 WordArr::WordArr( const WordArr& rOrig ) 519 { 520 DBG_MEMTEST(); 521 nUsed = rOrig.nUsed; 522 nGrow = rOrig.nGrow; 523 nUnused = rOrig.nUnused; 524 525 if ( rOrig.pData != 0 ) 526 { 527 pData = new short[nUsed+nUnused]; 528 memcpy( pData, rOrig.pData, nUsed*sizeof(short) ); 529 } 530 else 531 pData = 0; 532 } 533 534 // ----------------------------------------------------------------------- 535 536 WordArr::~WordArr() 537 { 538 DBG_MEMTEST(); 539 delete [] pData; 540 } 541 542 // ----------------------------------------------------------------------- 543 544 WordArr& WordArr::operator=( const WordArr& rOrig ) 545 { 546 DBG_MEMTEST(); 547 548 delete [] pData; 549 550 nUsed = rOrig.nUsed; 551 nGrow = rOrig.nGrow; 552 nUnused = rOrig.nUnused; 553 554 if ( rOrig.pData != 0 ) 555 { 556 pData = new short[nUsed+nUnused]; 557 memcpy( pData, rOrig.pData, nUsed*sizeof(short) ); 558 } 559 else 560 pData = 0; 561 return *this; 562 } 563 564 // ----------------------------------------------------------------------- 565 566 void WordArr::Append( short aElem ) 567 { 568 DBG_MEMTEST(); 569 // musz das Array umkopiert werden? 570 if ( nUnused == 0 ) 571 { 572 sal_uInt16 nNewSize = (nUsed == 1) ? (nGrow==1 ? 2 : nGrow) : nUsed+nGrow; 573 short* pNewData = new short[nNewSize]; 574 if ( pData ) 575 { 576 DBG_ASSERT( nUsed <= nNewSize, " " ); 577 memmove( pNewData, pData, sizeof(short)*nUsed ); 578 delete [] pData; 579 } 580 nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed); 581 pData = pNewData; 582 } 583 584 // jetzt hinten in den freien Raum schreiben 585 pData[nUsed] = aElem; 586 ++nUsed; 587 --nUnused; 588 } 589 590 // ----------------------------------------------------------------------- 591 592 sal_uInt16 WordArr::Remove( sal_uInt16 nPos, sal_uInt16 nLen ) 593 { 594 DBG_MEMTEST(); 595 // nLen adjustieren, damit nicht ueber das Ende hinaus geloescht wird 596 nLen = Min( (sal_uInt16)(nUsed-nPos), nLen ); 597 598 // einfache Aufgaben erfordern einfache Loesungen! 599 if ( nLen == 0 ) 600 return 0; 601 602 // bleibt vielleicht keiner uebrig 603 if ( (nUsed-nLen) == 0 ) 604 { 605 delete [] pData; 606 pData = 0; 607 nUsed = 0; 608 nUnused = 0; 609 return nLen; 610 } 611 612 // feststellen, ob das Array dadurch physikalisch schrumpft... 613 if ( (nUnused+nLen) >= nGrow ) 614 { 615 // auf die naechste Grow-Grenze aufgerundet verkleinern 616 sal_uInt16 nNewUsed = nUsed-nLen; 617 sal_uInt16 nNewSize = ((nNewUsed+nGrow-1)/nGrow) * nGrow; 618 DBG_ASSERT( nNewUsed <= nNewSize && nNewUsed+nGrow > nNewSize, 619 "shrink size computation failed" ); 620 short* pNewData = new short[nNewSize]; 621 if ( nPos > 0 ) 622 { 623 DBG_ASSERT( nPos <= nNewSize, "" ); 624 memmove( pNewData, pData, sizeof(short)*nPos ); 625 } 626 if ( nNewUsed != nPos ) 627 memmove( pNewData+nPos, pData+nPos+nLen, 628 sizeof(short)*(nNewUsed-nPos) ); 629 delete [] pData; 630 pData = pNewData; 631 nUsed = nNewUsed; 632 nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize - nNewUsed); 633 return nLen; 634 } 635 636 // in allen anderen Faellen nur zusammenschieben 637 if ( nUsed-nPos-nLen > 0 ) 638 memmove( pData+nPos, pData+nPos+nLen, (nUsed-nPos-nLen)*sizeof(short) ); 639 nUsed = nUsed - nLen; 640 nUnused = sal::static_int_cast< sal_uInt8 >(nUnused + nLen); 641 return nLen; 642 } 643 644 // ----------------------------------------------------------------------- 645 646 sal_Bool WordArr::Remove( short aElem ) 647 { 648 DBG_MEMTEST(); 649 // einfache Aufgaben ... 650 if ( nUsed == 0 ) 651 return sal_False; 652 653 // rueckwaerts, da meist der letzte zuerst wieder entfernt wird 654 short *pIter = pData + nUsed - 1; 655 for ( sal_uInt16 n = 0; n < nUsed; ++n, --pIter ) 656 if ( *pIter == aElem ) 657 { 658 Remove(nUsed-n-1, 1); 659 return sal_True; 660 } 661 return sal_False; 662 } 663 664 // ----------------------------------------------------------------------- 665 666 sal_Bool WordArr::Contains( const short rItem ) const 667 { 668 DBG_MEMTEST(); 669 if ( !nUsed ) 670 return sal_False; 671 672 for ( sal_uInt16 n = 0; n < nUsed; ++n ) 673 { 674 short p = GetObject(n); 675 if ( p == rItem ) 676 return sal_True; 677 } 678 679 return sal_False; 680 } 681 682 // ----------------------------------------------------------------------- 683 684 void WordArr::Insert( sal_uInt16 nPos, short rElem ) 685 { 686 DBG_MEMTEST(); 687 // musz das Array umkopiert werden? 688 if ( nUnused == 0 ) 689 { 690 // auf die naechste Grow-Grenze aufgerundet vergroeszern 691 sal_uInt16 nNewSize = nUsed+nGrow; 692 short* pNewData = new short[nNewSize]; 693 694 if ( pData ) 695 { 696 DBG_ASSERT( nUsed < nNewSize, "" ); 697 memmove( pNewData, pData, sizeof(short)*nUsed ); 698 delete [] pData; 699 } 700 nUnused = sal::static_int_cast< sal_uInt8 >(nNewSize-nUsed); 701 pData = pNewData; 702 } 703 704 // jetzt den hinteren Teil verschieben 705 if ( nPos < nUsed ) 706 memmove( pData+nPos+1, pData+nPos, (nUsed-nPos)*sizeof(short) ); 707 708 // jetzt in den freien Raum schreiben 709 memmove( pData+nPos, &rElem, sizeof(short) ); 710 nUsed += 1; 711 nUnused -= 1; 712 } 713 714 // ----------------------------------------------------------------------- 715 716 short WordArr::operator[]( sal_uInt16 nPos ) const 717 { 718 DBG_MEMTEST(); 719 DBG_ASSERT( nPos < nUsed, "" ); 720 return *(pData+nPos); 721 } 722 723 // ----------------------------------------------------------------------- 724 725 short& WordArr::operator [] (sal_uInt16 nPos) 726 { 727 DBG_MEMTEST(); 728 DBG_ASSERT( nPos < nUsed, "" ); 729 return *(pData+nPos); 730 } 731 732 733