tools/source/memtools/unqidx.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: unqidx.cxx,v $
  10  * $Revision: 1.6 $
  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_tools.hxx"
  33 #include <impcont.hxx>
  34 #include <tools/unqidx.hxx>
  35 #include <tools/unqid.hxx>
  36
  37 /*************************************************************************
  38 |*
  39 |*    UniqueIndex::UniqueIndex()
  40 |*
  41 |*    Beschreibung      UNQIDX.SDW
  42 |*    Ersterstellung    TH 24.09.91
  43 |*    Letzte Aenderung  TH 24.09.91
  44 |*
  45 *************************************************************************/
  46
  47 UniqueIndex::UniqueIndex( ULONG _nStartIndex,
  48                           ULONG _nInitSize, ULONG _nReSize ) :
  49                  Container( _nInitSize )
  50 {
  51     nReSize             = _nReSize;
  52     nStartIndex         = _nStartIndex;
  53     nUniqIndex          = 0;
  54     nCount              = 0;
  55 }
  56
  57 /*************************************************************************
  58 |*
  59 |*    UniqueIndex::UniqueIndex()
  60 |*
  61 |*    Beschreibung      UNQIDX.SDW
  62 |*    Ersterstellung    TH 24.09.91
  63 |*    Letzte Aenderung  TH 24.09.91
  64 |*
  65 *************************************************************************/
  66
  67 UniqueIndex::UniqueIndex( const UniqueIndex& rIdx ) :
  68                  Container( rIdx )
  69 {
  70     nReSize     = rIdx.nReSize;
  71     nStartIndex = rIdx.nStartIndex;
  72     nUniqIndex  = rIdx.nUniqIndex;
  73     nCount      = rIdx.nCount;
  74 }
  75
  76 /*************************************************************************
  77 |*
  78 |*    UniqueIndex::Insert()
  79 |*
  80 |*    Beschreibung      UNQIDX.SDW
  81 |*    Ersterstellung    TH 24.09.91
  82 |*    Letzte Aenderung  TH 24.09.91
  83 |*
  84 *************************************************************************/
  85
  86 ULONG UniqueIndex::Insert( void* p )
  87 {
  88     // NULL-Pointer ist nicht erlaubt
  89     if ( !p )
  90         return UNIQUEINDEX_ENTRY_NOTFOUND;
  91
  92     // Ist Array voll, dann expandieren
  93     if ( nCount == Container::GetSize() )
  94         SetSize( nCount + nReSize );
  95
  96     // Damit UniqIndex nicht ueberlaeuft, wenn Items geloescht wurden
  97     nUniqIndex = nUniqIndex % Container::GetSize();
  98
  99     // Leeren Eintrag suchen
 100     while ( Container::ImpGetObject( nUniqIndex ) != NULL )
 101         nUniqIndex = (nUniqIndex+1) % Container::GetSize();
 102
 103     // Object im Array speichern
 104     Container::Replace( p, nUniqIndex );
 105
 106     // Anzahl der Eintraege erhoehen und Index zurueckgeben
 107     nCount++;
 108     nUniqIndex++;
 109     return ( nUniqIndex + nStartIndex - 1 );
 110 }
 111
 112 /*************************************************************************
 113 |*
 114 |*    UniqueIndex::Insert()
 115 |*
 116 |*    Beschreibung      UNQIDX.SDW
 117 |*    Ersterstellung    MM 21.04.96
 118 |*    Letzte Aenderung  MM 21.04.96
 119 |*
 120 *************************************************************************/
 121
 122 ULONG UniqueIndex::Insert( ULONG nIndex, void* p )
 123 {
 124     // NULL-Pointer ist nicht erlaubt
 125     if ( !p )
 126         return UNIQUEINDEX_ENTRY_NOTFOUND;
 127
 128     ULONG nContIndex = nIndex - nStartIndex;
 129     // Ist Array voll, dann expandieren
 130     if ( nContIndex >= Container::GetSize() )
 131         SetSize( nContIndex + nReSize );
 132
 133     // Object im Array speichern
 134     Container::Replace( p, nContIndex );
 135
 136     // Anzahl der Eintraege erhoehen und Index zurueckgeben
 137     nCount++;
 138     return nIndex;
 139 }
 140
 141 /*************************************************************************
 142 |*
 143 |*    UniqueIndex::Remove()
 144 |*
 145 |*    Beschreibung      UNQIDX.SDW
 146 |*    Ersterstellung    TH 24.09.91
 147 |*    Letzte Aenderung  TH 24.09.91
 148 |*
 149 *************************************************************************/
 150
 151 void* UniqueIndex::Remove( ULONG nIndex )
 152 {
 153     // Ist Index zulaessig
 154     if ( (nIndex >= nStartIndex) &&
 155          (nIndex < (Container::GetSize()+nStartIndex)) )
 156     {
 157         // Index-Eintrag als leeren Eintrag setzen und Anzahl der
 158         // gespeicherten Indexe erniedriegen, wenn Eintrag belegt war
 159         void* p = Container::Replace( NULL, nIndex-nStartIndex );
 160         if ( p )
 161             nCount--;
 162         return p;
 163     }
 164     else
 165         return NULL;
 166 }
 167
 168 /*************************************************************************
 169 |*
 170 |*    UniqueIndex::Replace()
 171 |*
 172 |*    Beschreibung      UNQIDX.SDW
 173 |*    Ersterstellung    TH 24.09.91
 174 |*    Letzte Aenderung  TH 24.09.91
 175 |*
 176 *************************************************************************/
 177
 178 void* UniqueIndex::Replace( ULONG nIndex, void* p )
 179 {
 180     // NULL-Pointer ist nicht erlaubt
 181     if ( !p )
 182         return NULL;
 183
 184     // Ist Index zulaessig
 185     if ( IsIndexValid( nIndex ) )
 186     {
 187         // Index-Eintrag ersetzen und alten zurueckgeben
 188         return Container::Replace( p, nIndex-nStartIndex );
 189     }
 190     else
 191         return NULL;
 192 }
 193
 194 /*************************************************************************
 195 |*
 196 |*    UniqueIndex::Get()
 197 |*
 198 |*    Beschreibung      UNQIDX.SDW
 199 |*    Ersterstellung    TH 24.09.91
 200 |*    Letzte Aenderung  TH 24.09.91
 201 |*
 202 *************************************************************************/
 203
 204 void* UniqueIndex::Get( ULONG nIndex ) const
 205 {
 206     // Ist Index zulaessig
 207     if ( (nIndex >= nStartIndex) &&
 208          (nIndex < (Container::GetSize()+nStartIndex)) )
 209         return Container::ImpGetObject( nIndex-nStartIndex );
 210     else
 211         return NULL;
 212 }
 213
 214 /*************************************************************************
 215 |*
 216 |*    UniqueIndex::GetCurIndex()
 217 |*
 218 |*    Beschreibung      UNQIDX.SDW
 219 |*    Ersterstellung    TH 24.09.91
 220 |*    Letzte Aenderung  TH 24.09.91
 221 |*
 222 *************************************************************************/
 223
 224 ULONG UniqueIndex::GetCurIndex() const
 225 {
 226     ULONG nPos = Container::GetCurPos();
 227
 228     // Ist der Current-Index nicht belegt, dann gibt es keinen Current-Index
 229     if ( !Container::ImpGetObject( nPos ) )
 230         return UNIQUEINDEX_ENTRY_NOTFOUND;
 231     else
 232         return nPos+nStartIndex;
 233 }
 234
 235 /*************************************************************************
 236 |*
 237 |*    UniqueIndex::GetIndex()
 238 |*
 239 |*    Beschreibung      UNQIDX.SDW
 240 |*    Ersterstellung    TH 24.09.91
 241 |*    Letzte Aenderung  TH 24.09.91
 242 |*
 243 *************************************************************************/
 244
 245 ULONG UniqueIndex::GetIndex( const void* p ) const
 246 {
 247     // Wird ein NULL-Pointer uebergeben, dann wurde Pointer nicht gefunden
 248     if ( !p )
 249         return UNIQUEINDEX_ENTRY_NOTFOUND;
 250
 251     ULONG nIndex = Container::GetPos( p );
 252
 253     if ( nIndex != CONTAINER_ENTRY_NOTFOUND )
 254         return nIndex+nStartIndex;
 255     else
 256         return UNIQUEINDEX_ENTRY_NOTFOUND;
 257 }
 258
 259 /*************************************************************************
 260 |*
 261 |*    UniqueIndex::IsIndexValid()
 262 |*
 263 |*    Beschreibung      UNQIDX.SDW
 264 |*    Ersterstellung    TH 24.09.91
 265 |*    Letzte Aenderung  TH 24.09.91
 266 |*
 267 *************************************************************************/
 268
 269 BOOL UniqueIndex::IsIndexValid( ULONG nIndex ) const
 270 {
 271     // Ist Index zulaessig
 272     if ( (nIndex >= nStartIndex) &&
 273          (nIndex < (Container::GetSize()+nStartIndex)) )
 274     {
 275         // Index ist nur zulaessig, wenn Eintrag auch belegt ist
 276         if ( Container::ImpGetObject( nIndex-nStartIndex ) )
 277             return TRUE;
 278         else
 279             return FALSE;
 280     }
 281     else
 282         return FALSE;
 283 }
 284
 285 /*************************************************************************
 286 |*
 287 |*    UniqueIndex::Seek()
 288 |*
 289 |*    Beschreibung      UNQIDX.SDW
 290 |*    Ersterstellung    TH 24.09.91
 291 |*    Letzte Aenderung  TH 24.09.91
 292 |*
 293 *************************************************************************/
 294
 295 void* UniqueIndex::Seek( ULONG nIndex )
 296 {
 297     // Index-Eintrag als aktuellen setzten, wenn er gueltig ist
 298     if ( IsIndexValid( nIndex ) )
 299         return Container::Seek( nIndex-nStartIndex );
 300     else
 301         return NULL;
 302 }
 303
 304 /*************************************************************************
 305 |*
 306 |*    UniqueIndex::Seek()
 307 |*
 308 |*    Beschreibung      UNQIDX.SDW
 309 |*    Ersterstellung    TH 24.09.91
 310 |*    Letzte Aenderung  TH 24.09.91
 311 |*
 312 *************************************************************************/
 313
 314 void* UniqueIndex::Seek( void* p )
 315 {
 316     // Wird ein NULL-Pointer uebergeben, dann wurde Pointer nicht gefunden
 317     if ( !p )
 318         return NULL;
 319
 320     ULONG nIndex = GetIndex( p );
 321
 322     // Ist Index vorhanden, dann als aktuellen Eintrag setzen
 323     if ( nIndex != UNIQUEINDEX_ENTRY_NOTFOUND )
 324         return Container::Seek( nIndex-nStartIndex );
 325     else
 326         return NULL;
 327 }
 328
 329 /*************************************************************************
 330 |*
 331 |*    UniqueIndex::First()
 332 |*
 333 |*    Beschreibung      UNQIDX.SDW
 334 |*    Ersterstellung    TH 24.09.91
 335 |*    Letzte Aenderung  TH 24.09.91
 336 |*
 337 *************************************************************************/
 338
 339 void* UniqueIndex::First()
 340 {
 341     void* p = Container::First();
 342
 343     while ( !p && (Container::GetCurPos() < (Container::GetSize()-1)) )
 344         p = Container::Next();
 345
 346     return p;
 347 }
 348
 349 /*************************************************************************
 350 |*
 351 |*    UniqueIndex::Last()
 352 |*
 353 |*    Beschreibung      UNQIDX.SDW
 354 |*    Ersterstellung    TH 24.09.91
 355 |*    Letzte Aenderung  TH 24.09.91
 356 |*
 357 *************************************************************************/
 358
 359 void* UniqueIndex::Last()
 360 {
 361     void* p = Container::Last();
 362
 363     while ( !p && Container::GetCurPos() )
 364         p = Container::Prev();
 365
 366     return p;
 367 }
 368
 369 /*************************************************************************
 370 |*
 371 |*    UniqueIndex::Next()
 372 |*
 373 |*    Beschreibung      UNQIDX.SDW
 374 |*    Ersterstellung    TH 24.09.91
 375 |*    Letzte Aenderung  TH 24.09.91
 376 |*
 377 *************************************************************************/
 378
 379 void* UniqueIndex::Next()
 380 {
 381     void* p = NULL;
 382
 383     while ( !p && (Container::GetCurPos() < (Container::GetSize()-1)) )
 384         p = Container::Next();
 385
 386     return p;
 387 }
 388
 389 /*************************************************************************
 390 |*
 391 |*    UniqueIndex::Prev()
 392 |*
 393 |*    Beschreibung      UNQIDX.SDW
 394 |*    Ersterstellung    TH 24.09.91
 395 |*    Letzte Aenderung  TH 24.09.91
 396 |*
 397 *************************************************************************/
 398
 399 void* UniqueIndex::Prev()
 400 {
 401     void* p = NULL;
 402
 403     while ( !p && Container::GetCurPos() )
 404         p = Container::Prev();
 405
 406     return p;
 407 }
 408
 409 /*************************************************************************
 410 |*
 411 |*    UniqueIndex::operator =()
 412 |*
 413 |*    Beschreibung      UNQIDX.SDW
 414 |*    Ersterstellung    TH 24.09.91
 415 |*    Letzte Aenderung  TH 24.09.91
 416 |*
 417 *************************************************************************/
 418
 419 UniqueIndex& UniqueIndex::operator =( const UniqueIndex& rIdx )
 420 {
 421     // Neue Werte zuweisen
 422     Container::operator =( rIdx );
 423     nReSize     = rIdx.nReSize;
 424     nStartIndex = rIdx.nStartIndex;
 425     nUniqIndex  = rIdx.nUniqIndex;
 426     nCount      = rIdx.nCount;
 427     return *this;
 428 }
 429
 430 /*************************************************************************
 431 |*
 432 |*    UniqueIndex::operator ==()
 433 |*
 434 |*    Beschreibung      UNQIDX.SDW
 435 |*    Ersterstellung    TH 24.09.91
 436 |*    Letzte Aenderung  TH 24.09.91
 437 |*
 438 *************************************************************************/
 439
 440 BOOL UniqueIndex::operator ==( const UniqueIndex& rIdx ) const
 441 {
 442     // Neue Werte zuweisen
 443     if ( (nStartIndex == rIdx.nStartIndex) &&
 444          (nCount      == rIdx.nCount)      &&
 445          (Container::operator ==( rIdx )) )
 446         return TRUE;
 447     else
 448         return FALSE;
 449 }
 450 /*************************************************************************
 451 |*
 452 |*    UniqueIdContainer::UniqueIdContainer ()
 453 |*
 454 |*    Beschreibung      UNQIDX.SDW
 455 |*    Ersterstellung    MM 29.04.96
 456 |*    Letzte Aenderung  MM 29.04.96
 457 |*
 458 *************************************************************************/
 459
 460 UniqueIdContainer::UniqueIdContainer( const UniqueIdContainer& rObj )
 461     : UniqueIndex( rObj )
 462     , nCollectCount( rObj.nCollectCount )
 463 {
 464     ULONG nCur = GetCurIndex();
 465
 466     ImpUniqueId * pEle = (ImpUniqueId *)First();
 467     while( pEle )
 468     {
 469         pEle->nRefCount++;
 470         pEle = (ImpUniqueId *)Next();
 471     }
 472     Seek( nCur );
 473 }
 474
 475 /*************************************************************************
 476 |*
 477 |*    UniqueIdContainer::operator = ()
 478 |*
 479 |*    Beschreibung      UNQIDX.SDW
 480 |*    Ersterstellung    MM 01.08.94
 481 |*    Letzte Aenderung  MM 01.08.94
 482 |*
 483 *************************************************************************/
 484
 485 UniqueIdContainer& UniqueIdContainer::operator = ( const UniqueIdContainer & rObj )
 486 {
 487     UniqueIndex::operator = ( rObj );
 488     nCollectCount = rObj.nCollectCount;
 489
 490     ULONG nCur = GetCurIndex();
 491
 492     ImpUniqueId * pEle = (ImpUniqueId *)First();
 493     while( pEle )
 494     {
 495         pEle->nRefCount++;
 496         pEle = (ImpUniqueId *)Next();
 497     }
 498     Seek( nCur );
 499     return *this;
 500 }
 501
 502 /*************************************************************************
 503 |*
 504 |*    UniqueIdContainer::Clear()
 505 |*
 506 |*    Beschreibung      UNQIDX.SDW
 507 |*    Ersterstellung    MM 01.08.94
 508 |*    Letzte Aenderung  MM 01.08.94
 509 |*
 510 *************************************************************************/
 511
 512 void UniqueIdContainer::Clear( BOOL bAll )
 513 {
 514     USHORT nFree = bAll ? 0xFFFF : 1;
 515
 516     ImpUniqueId* pId = (ImpUniqueId*)Last();
 517     BOOL bLast = TRUE;
 518     while ( pId )
 519     {
 520         if ( pId->nRefCount <= nFree )
 521         {
 522             ((ImpUniqueId *)Remove( pId->nId ))->Release();
 523             if( bLast )
 524                 pId = (ImpUniqueId *)Last();
 525             else
 526                 pId = (ImpUniqueId *)Prev();
 527         }
 528         else
 529         {
 530             pId = (ImpUniqueId *)Prev();
 531             bLast = FALSE;
 532         }
 533     }
 534 }
 535
 536 /*************************************************************************
 537 |*
 538 |*    UniqueIdContainer::CreateId()
 539 |*
 540 |*    Beschreibung      UNQIDX.SDW
 541 |*    Ersterstellung    MM 01.08.94
 542 |*    Letzte Aenderung  MM 01.08.94
 543 |*
 544 *************************************************************************/
 545
 546 UniqueItemId UniqueIdContainer::CreateId()
 547 {
 548     if( nCollectCount > 50 )
 549     { // aufraeumen
 550         Clear( FALSE );
 551         nCollectCount = 0;
 552     }
 553     nCollectCount++;
 554
 555     ImpUniqueId * pId = new ImpUniqueId;
 556     pId->nRefCount = 1;
 557     pId->nId = Insert( pId );
 558     return UniqueItemId( pId );
 559 }
 560
 561 /*************************************************************************
 562 |*
 563 |*    UniqueIdContainer::CreateIdProt()
 564 |*
 565 |*    Beschreibung      UNQIDX.SDW
 566 |*    Ersterstellung    MM 01.08.94
 567 |*    Letzte Aenderung  MM 01.08.94
 568 |*
 569 *************************************************************************/
 570
 571 UniqueItemId UniqueIdContainer::CreateFreeId( ULONG nId )
 572 {
 573     // Einfach erzeugen, fuer abgeleitete Klasse
 574     ImpUniqueId * pId = new ImpUniqueId;
 575     pId->nRefCount = 0;
 576     pId->nId = nId;
 577     return UniqueItemId( pId );
 578 }
 579
 580 /*************************************************************************
 581 |*
 582 |*    UniqueIdContainer::CreateIdProt()
 583 |*
 584 |*    Beschreibung      UNQIDX.SDW
 585 |*    Ersterstellung    MM 01.08.94
 586 |*    Letzte Aenderung  MM 01.08.94
 587 |*
 588 *************************************************************************/
 589
 590 UniqueItemId UniqueIdContainer::CreateIdProt( ULONG nId )
 591 {
 592     if ( IsIndexValid( nId ) )
 593         return UniqueItemId( (ImpUniqueId *)Get( nId ) );
 594
 595     ImpUniqueId * pId;
 596     do
 597     {
 598         pId = new ImpUniqueId;
 599         pId->nRefCount = 1;
 600         pId->nId = Insert( pId );
 601     }
 602     while( pId->nId != nId );
 603     return UniqueItemId( pId );
 604 }