sw/source/core/bastyp/index.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: index.cxx,v $
  10  * $Revision: 1.11 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sw.hxx"
  33
  34
  35 #include <stdlib.h>                             // fuer qsort
  36 #include <tools/solar.h>
  37
  38 #include "errhdl.hxx"                   // fuers ASSERT
  39 #include "index.hxx"
  40 #include "error.h"                              // fuers ASSERT
  41
  42 #ifndef PRODUCT
  43 int SwIndex::nSerial = 0;
  44 #endif
  45
  46
  47 TYPEINIT0(SwIndexReg);  // rtti
  48
  49
  50 #ifdef CHK
  51
  52 #define IDX_CHK_ARRAY       pArray->ChhkArr();
  53 #define ARR_CHK_ARRAY       ChhkArr();
  54
  55
  56 void SwIndexReg::ChkArr()
  57 {
  58     ASSERT( (pFirst && pLast) || (!pFirst && !pLast),
  59             "Array falsch Indiziert" );
  60
  61     if( !pFirst )
  62         return;
  63
  64     xub_StrLen nVal = 0;
  65     const SwIndex* pIdx = pFirst, *pPrev = 0;
  66     ASSERT( !pIdx->pPrev, "Array-pFirst nicht am Anfang" );
  67
  68     while( pIdx != pLast )
  69     {
  70         ASSERT( pIdx->pPrev != pIdx && pIdx->pNext != pIdx,
  71                 "Index zeigt auf sich selbst" )
  72
  73         ASSERT( pIdx->nIndex >= nVal, "Reihenfolge stimmt nicht" );
  74         ASSERT( pPrev == pIdx->pPrev, "Verkettung stimmt nicht" );
  75         pPrev = pIdx;
  76         pIdx = pIdx->pNext;
  77         nVal = pPrev->nIndex;
  78     }
  79 }
  80
  81 #else                                       // CHK
  82
  83 #define IDX_CHK_ARRAY
  84 #define ARR_CHK_ARRAY
  85
  86 #endif                                                                  // CHK
  87
  88
  89
  90 SwIndex::SwIndex( SwIndexReg* pArr, xub_StrLen nIdx )
  91     : nIndex( nIdx ), pArray( pArr ), pNext( 0 ), pPrev( 0 )
  92 {
  93     if( !pArray )
  94     {
  95         pArray = SwIndexReg::pEmptyIndexArray;
  96         nIndex = 0;             // steht immer auf 0 !!!
  97     }
  98
  99     if( !pArray->pFirst )         // 1. Index ??
 100         pArray->pFirst = pArray->pLast = this;
 101     else if( nIdx > ((pArray->pLast->nIndex - pArray->pFirst->nIndex) / 2) )
 102         ChgValue( *pArray->pLast, nIdx );
 103     else
 104         ChgValue( *pArray->pFirst, nIdx );
 105
 106 #ifndef PRODUCT
 107     MySerial = ++nSerial;               // nur in der nicht PRODUCT-Version
 108 #endif
 109 IDX_CHK_ARRAY
 110 }
 111
 112
 113 SwIndex::SwIndex( const SwIndex& rIdx, short nIdx )
 114     : pArray( rIdx.pArray ), pNext( 0 ), pPrev( 0 )
 115 {
 116     ChgValue( rIdx, rIdx.nIndex + nIdx );
 117
 118 #ifndef PRODUCT
 119     MySerial = ++nSerial;               // nur in der nicht PRODUCT-Version
 120 #endif
 121 IDX_CHK_ARRAY
 122 }
 123
 124
 125 SwIndex::SwIndex( const SwIndex& rIdx )
 126     : nIndex( rIdx.nIndex ), pArray( rIdx.pArray ), pNext( 0 ), pPrev( 0 )
 127 {
 128     ChgValue( rIdx, rIdx.nIndex );
 129 #ifndef PRODUCT
 130     MySerial = ++nSerial;               // nur in der nicht PRODUCT-Version
 131 #endif
 132 IDX_CHK_ARRAY
 133 }
 134
 135
 136 SwIndex& SwIndex::ChgValue( const SwIndex& rIdx, xub_StrLen nNewValue )
 137 {
 138     SwIndex* pFnd = (SwIndex*)&rIdx;
 139     if( rIdx.nIndex > nNewValue )                               // nach vorne versuchen
 140     {
 141         SwIndex* pPrv;
 142         while( 0 != ( pPrv = pFnd->pPrev ) && pPrv->nIndex > nNewValue )
 143             pFnd = pPrv;
 144
 145         if( pFnd != this )
 146         {
 147             // an alter Position ausketten
 148             // erstmal an alter Position ausketten
 149             if( pPrev )
 150                 pPrev->pNext = pNext;
 151             else if( pArray->pFirst == this )
 152                 pArray->pFirst = pNext;
 153
 154             if( pNext )
 155                 pNext->pPrev = pPrev;
 156             else if( pArray->pLast == this )
 157                 pArray->pLast = pPrev;
 158
 159             pNext = pFnd;
 160             pPrev = pFnd->pPrev;
 161             if( pPrev )
 162                 pPrev->pNext = this;
 163             else
 164                 pArray->pFirst = this;
 165             pFnd->pPrev = this;
 166         }
 167     }
 168     else if( rIdx.nIndex < nNewValue )
 169     {
 170         SwIndex* pNxt;
 171         while( 0 != ( pNxt = pFnd->pNext ) && pNxt->nIndex < nNewValue )
 172             pFnd = pNxt;
 173
 174         if( pFnd != this )
 175         {
 176             // erstmal an alter Position ausketten
 177             if( pPrev )
 178                 pPrev->pNext = pNext;
 179             else if( pArray->pFirst == this )
 180                 pArray->pFirst = pNext;
 181
 182             if( pNext )
 183                 pNext->pPrev = pPrev;
 184             else if( pArray->pLast == this )
 185                 pArray->pLast = pPrev;
 186
 187             pPrev = pFnd;
 188             pNext = pFnd->pNext;
 189             if( pNext )
 190                 pNext->pPrev = this;
 191             else
 192                 pArray->pLast = this;
 193             pFnd->pNext = this;
 194         }
 195     }
 196     else if( pFnd != this )
 197     {
 198         // erstmal an alter Position ausketten
 199         if( pPrev )
 200             pPrev->pNext = pNext;
 201         else if( pArray->pFirst == this )
 202             pArray->pFirst = pNext;
 203
 204         if( pNext )
 205             pNext->pPrev = pPrev;
 206         else if( pArray->pLast == this )
 207             pArray->pLast = pPrev;
 208
 209         pPrev = (SwIndex*)&rIdx;
 210         pNext = rIdx.pNext;
 211         pPrev->pNext = this;
 212
 213         if( !pNext )                    // im IndexArray als letzes
 214             pArray->pLast = this;
 215         else
 216             pNext->pPrev = this;
 217     }
 218     pArray = rIdx.pArray;
 219
 220     if( pArray->pFirst == pNext )
 221         pArray->pFirst = this;
 222     if( pArray->pLast == pPrev )
 223         pArray->pLast = this;
 224
 225     nIndex = nNewValue;
 226
 227 IDX_CHK_ARRAY
 228
 229     return *this; }
 230
 231
 232 void SwIndex::Remove()
 233 {
 234     if( !pPrev )
 235         pArray->pFirst = pNext;
 236     else
 237         pPrev->pNext = pNext;
 238
 239     if( !pNext )
 240         pArray->pLast = pPrev;
 241     else
 242         pNext->pPrev = pPrev;
 243
 244 IDX_CHK_ARRAY
 245 }
 246
 247 /*************************************************************************
 248 |*
 249 |*        SwIndex & SwIndex::operator=( const SwIndex & aSwIndex )
 250 |*
 251 |*        Beschreibung
 252 |*        Ersterstellung        JP 07.11.90
 253 |*        Letzte Aenderung      JP 07.03.94
 254 |*
 255 *************************************************************************/
 256
 257
 258 SwIndex& SwIndex::operator=( const SwIndex& rIdx )
 259 {
 260     int bEqual;
 261     if( rIdx.pArray != pArray )                 // im alten abmelden !!
 262     {
 263         Remove();
 264         pArray = rIdx.pArray;
 265         pNext = pPrev = 0;
 266         bEqual = FALSE;
 267     }
 268     else
 269         bEqual = rIdx.nIndex == nIndex;
 270
 271     if( !bEqual )
 272         ChgValue( rIdx, rIdx.nIndex );
 273     return *this;
 274 }
 275
 276 /*************************************************************************
 277 |*
 278 |*        SwIndex &SwIndex::Assign
 279 |*
 280 |*        Beschreibung
 281 |*        Ersterstellung        VB 25.03.91
 282 |*        Letzte Aenderung      JP 07.03.94
 283 |*
 284 *************************************************************************/
 285
 286
 287 SwIndex& SwIndex::Assign( SwIndexReg* pArr, xub_StrLen nIdx )
 288 {
 289     if( !pArr )
 290     {
 291         pArr = SwIndexReg::pEmptyIndexArray;
 292         nIdx = 0;               // steht immer auf 0 !!!
 293     }
 294
 295     if( pArr != pArray )                        // im alten abmelden !!
 296     {
 297         Remove();
 298         pArray = pArr;
 299         pNext = pPrev = 0;
 300         if( !pArr->pFirst )         // 1. Index ??
 301         {
 302             pArr->pFirst = pArr->pLast = this;
 303             nIndex = nIdx;
 304         }
 305         else if( pArr->pLast && (nIdx > ((pArr->pLast->nIndex - pArr->pFirst->nIndex) / 2)) )
 306             ChgValue( *pArr->pLast, nIdx );
 307         else
 308             ChgValue( *pArr->pFirst, nIdx );
 309     }
 310     else if( nIndex != nIdx )
 311         ChgValue( *this, nIdx );
 312 IDX_CHK_ARRAY
 313     return *this;
 314 }
 315
 316
 317 SwIndexReg::SwIndexReg()
 318     : pFirst( 0 ), pLast( 0 )
 319 {
 320 }
 321
 322
 323
 324 SwIndexReg::~SwIndexReg()
 325 {
 326     ASSERT( !pFirst || !pLast, "Es sind noch Indizies angemeldet" );
 327 }
 328
 329
 330
 331 void SwIndexReg::Update( SwIndex const & rIdx, const xub_StrLen nDiff,
 332     const bool bNeg, const bool /* argument is only used in derived class*/ )
 333 {
 334     SwIndex* pStt = const_cast<SwIndex*>(&rIdx);
 335     xub_StrLen nNewVal = rIdx.nIndex;
 336     if( bNeg )
 337     {
 338         xub_StrLen nLast = rIdx.GetIndex() + nDiff;
 339         while( pStt && pStt->nIndex == nNewVal )
 340         {
 341             pStt->nIndex = nNewVal;
 342             pStt = pStt->pPrev;
 343         }
 344         pStt = rIdx.pNext;
 345         while( pStt && pStt->nIndex >= nNewVal &&
 346                 pStt->nIndex <= nLast )
 347         {
 348             pStt->nIndex = nNewVal;
 349             pStt = pStt->pNext;
 350         }
 351         while( pStt )
 352         {
 353             pStt->nIndex = pStt->nIndex - nDiff;
 354             pStt = pStt->pNext;
 355         }
 356     }
 357     else
 358     {
 359         while( pStt && pStt->nIndex == nNewVal )
 360         {
 361             pStt->nIndex = pStt->nIndex + nDiff;
 362             pStt = pStt->pPrev;
 363         }
 364         pStt = rIdx.pNext;
 365         while( pStt )
 366         {
 367             pStt->nIndex = pStt->nIndex + nDiff;
 368             pStt = pStt->pNext;
 369         }
 370     }
 371 ARR_CHK_ARRAY
 372 }
 373
 374 #ifndef PRODUCT
 375 #ifndef CFRONT
 376
 377 /*************************************************************************
 378 |*
 379 |*    SwIndex::operator++()
 380 |*
 381 |*    Beschreibung
 382 |*    Ersterstellung    JP 07.11.90
 383 |*    Letzte Aenderung  JP 07.03.94
 384 |*
 385 *************************************************************************/
 386 xub_StrLen SwIndex::operator++(int)
 387 {
 388     ASSERT_ID( nIndex < INVALID_INDEX, ERR_OUTOFSCOPE );
 389
 390     xub_StrLen nOldIndex = nIndex;
 391     ChgValue( *this, nIndex+1 );
 392     return nOldIndex;
 393 }
 394
 395 #endif
 396
 397 xub_StrLen SwIndex::operator++()
 398 {
 399     ASSERT_ID( nIndex < INVALID_INDEX, ERR_OUTOFSCOPE );
 400
 401     ChgValue( *this, nIndex+1 );
 402     return nIndex;
 403 }
 404
 405 /*************************************************************************
 406 |*
 407 |*    SwIndex::operator--()
 408 |*
 409 |*    Beschreibung
 410 |*    Ersterstellung    JP 07.11.90
 411 |*    Letzte Aenderung  JP 07.03.94
 412 |*
 413 *************************************************************************/
 414
 415 #ifndef CFRONT
 416
 417 xub_StrLen SwIndex::operator--(int)
 418 {
 419     ASSERT_ID( nIndex, ERR_OUTOFSCOPE );
 420
 421     xub_StrLen nOldIndex = nIndex;
 422     ChgValue( *this, nIndex-1 );
 423     return nOldIndex;
 424 }
 425
 426 #endif
 427
 428 xub_StrLen SwIndex::operator--()
 429 {
 430     ASSERT_ID( nIndex, ERR_OUTOFSCOPE );
 431     return ChgValue( *this, nIndex-1 ).nIndex;
 432 }
 433
 434 /*************************************************************************
 435 |*
 436 |*    SwIndex::operator+=( xub_StrLen )
 437 |*
 438 |*    Beschreibung
 439 |*    Ersterstellung    JP 07.11.90
 440 |*    Letzte Aenderung  JP 07.03.94
 441 |*
 442 *************************************************************************/
 443
 444 xub_StrLen SwIndex::operator+=( xub_StrLen nWert )
 445 {
 446     ASSERT_ID( nIndex < INVALID_INDEX - nWert, ERR_OUTOFSCOPE);
 447     return ChgValue( *this, nIndex + nWert ).nIndex;
 448 }
 449
 450 /*************************************************************************
 451 |*
 452 |*    SwIndex::operator-=( xub_StrLen )
 453 |*
 454 |*    Beschreibung
 455 |*    Ersterstellung    JP 07.11.90
 456 |*    Letzte Aenderung  JP 07.03.94
 457 |*
 458 *************************************************************************/
 459
 460 xub_StrLen SwIndex::operator-=( xub_StrLen nWert )
 461 {
 462     ASSERT_ID( nIndex >= nWert, ERR_OUTOFSCOPE );
 463     return ChgValue( *this, nIndex - nWert ).nIndex;
 464 }
 465
 466 /*************************************************************************
 467 |*
 468 |*    SwIndex::operator+=( const SwIndex & )
 469 |*
 470 |*    Beschreibung
 471 |*    Ersterstellung    JP 07.11.90
 472 |*    Letzte Aenderung  JP 07.03.94
 473 |*
 474 *************************************************************************/
 475
 476 xub_StrLen SwIndex::operator+=( const SwIndex & rIndex )
 477 {
 478     ASSERT_ID( nIndex < INVALID_INDEX - rIndex.nIndex, ERR_OUTOFSCOPE );
 479     return ChgValue( *this, nIndex + rIndex.nIndex ).nIndex;
 480 }
 481
 482 /*************************************************************************
 483 |*
 484 |*    SwIndex::operator-=( const SwIndex & )
 485 |*
 486 |*    Beschreibung
 487 |*    Ersterstellung    JP 07.11.90
 488 |*    Letzte Aenderung  JP 07.03.94
 489 |*
 490 *************************************************************************/
 491
 492 xub_StrLen SwIndex::operator-=( const SwIndex & rIndex )
 493 {
 494     ASSERT_ID( nIndex >= rIndex.nIndex, ERR_OUTOFSCOPE );
 495     return ChgValue( *this, nIndex - rIndex.nIndex ).nIndex;
 496 }
 497
 498 /*************************************************************************
 499 |*
 500 |*    SwIndex::operator<( const SwIndex & )
 501 |*
 502 |*    Beschreibung
 503 |*    Ersterstellung    JP 07.11.90
 504 |*    Letzte Aenderung  JP 07.03.94
 505 |*
 506 *************************************************************************/
 507
 508 BOOL SwIndex::operator<( const SwIndex & rIndex ) const
 509 {
 510     ASSERT( pArray == rIndex.pArray, "Attempt to compare indices into different arrays.");
 511     return nIndex < rIndex.nIndex;
 512 }
 513
 514 /*************************************************************************
 515 |*
 516 |*    SwIndex::operator<=( const SwIndex & )
 517 |*
 518 |*    Beschreibung
 519 |*    Ersterstellung    JP 07.11.90
 520 |*    Letzte Aenderung  JP 04.06.92
 521 |*
 522 *************************************************************************/
 523
 524 BOOL SwIndex::operator<=( const SwIndex & rIndex ) const
 525 {
 526     ASSERT( pArray == rIndex.pArray, "Attempt to compare indices into different arrays.");
 527     return nIndex <= rIndex.nIndex;
 528 }
 529
 530 /*************************************************************************
 531 |*
 532 |*    SwIndex::operator>( const SwIndex & )
 533 |*
 534 |*    Beschreibung
 535 |*    Ersterstellung    JP 07.11.90
 536 |*    Letzte Aenderung  JP 04.06.92
 537 |*
 538 *************************************************************************/
 539
 540 BOOL SwIndex::operator>( const SwIndex & rIndex ) const
 541 {
 542     ASSERT( pArray == rIndex.pArray, "Attempt to compare indices into different arrays.");
 543     return nIndex > rIndex.nIndex;
 544 }
 545
 546 /*************************************************************************
 547 |*
 548 |*    SwIndex::operator>=( const SwIndex & )
 549 |*
 550 |*    Beschreibung
 551 |*    Ersterstellung    JP 07.11.90
 552 |*    Letzte Aenderung  JP 04.06.92
 553 |*
 554 *************************************************************************/
 555
 556 BOOL SwIndex::operator>=( const SwIndex & rIndex ) const
 557 {
 558     ASSERT( pArray == rIndex.pArray, "Attempt to compare indices into different arrays.");
 559     return nIndex >= rIndex.nIndex;
 560 }
 561
 562 /*************************************************************************
 563 |*
 564 |*    SwIndex & SwIndex::operator=( xub_StrLen )
 565 |*
 566 |*    Beschreibung
 567 |*    Ersterstellung    JP 10.12.90
 568 |*    Letzte Aenderung  JP 07.03.94
 569 |*
 570 *************************************************************************/
 571
 572 SwIndex& SwIndex::operator=( xub_StrLen nWert )
 573 {
 574     // Werte kopieren und im neuen Array anmelden
 575     if( nIndex != nWert )
 576         ChgValue( *this, nWert );
 577
 578     return *this;
 579 }
 580
 581 #endif // ifndef PRODUCT
 582
 583 void SwIndexReg::MoveTo( SwIndexReg& rArr )
 584 {
 585     if( this != &rArr && pFirst )
 586     {
 587         SwIndex* pIdx = (SwIndex*)pFirst, *pNext;
 588         while( pIdx )
 589         {
 590             pNext = pIdx->pNext;
 591             pIdx->Assign( &rArr, pIdx->GetIndex() );
 592             pIdx = pNext;
 593         }
 594         pFirst = 0, pLast = 0;
 595     }
 596 }