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_tools.hxx" 26 27 #define _DIR_CXX 28 29 #include <stdlib.h> 30 #include <cstdarg> 31 #include <limits.h> 32 #include <tools/debug.hxx> 33 #include <tools/list.hxx> 34 35 #ifndef _COMPED_HXX 36 #include "comdep.hxx" 37 #endif 38 #include <tools/fsys.hxx> 39 40 41 DBG_NAME( Dir ) 42 43 DECLARE_LIST( DirEntryList, DirEntry* ) 44 DECLARE_LIST( FSysSortList, FSysSort* ) 45 DECLARE_LIST( FileStatList, FileStat* ) 46 47 #define APPEND (sal_uInt16) 65535 48 49 /************************************************************************* 50 |* 51 |* Dir::InsertPointReached() 52 |* 53 |* Beschreibung stellt fest, ob eingefuegt werden musz 54 |* Ersterstellung MA 05.11.91 55 |* Letzte Aenderung MI 05.02.92 56 |* 57 *************************************************************************/ 58 59 sal_Bool Dir::ImpInsertPointReached( const DirEntry& rNewEntry, 60 const FileStat& rNewStat, 61 sal_uIntPtr nCurPos, sal_uIntPtr nSortIndex ) const 62 { 63 #define VALUE( nKindFlags ) \ 64 ( ( FSYS_KIND_FILE | FSYS_KIND_DIR | FSYS_KIND_DEV | \ 65 FSYS_KIND_CHAR | FSYS_KIND_BLOCK ) & nKindFlags ) 66 67 // einfache Dinge erfordern einfache Loesungen 68 if ( !pLst->Count() ) 69 return sal_True; 70 71 FSysSort nSort = *( pSortLst->GetObject( nSortIndex ) ); 72 FileStat *pOldStat = NULL; 73 DirEntry *pCurLstObj = pLst->GetObject( nCurPos ); 74 if ( pStatLst ) 75 pOldStat = pStatLst->GetObject( nCurPos ); 76 77 switch( nSort ) 78 { 79 case FSYS_SORT_NAME: 80 case (FSYS_SORT_NAME | FSYS_SORT_ASCENDING): 81 if ( pCurLstObj->aName > rNewEntry.aName ) 82 return sal_True; 83 if ( !(pCurLstObj->aName == rNewEntry.aName) ) 84 return sal_False; 85 break; 86 case (FSYS_SORT_NAME | FSYS_SORT_DESCENDING): 87 if ( pCurLstObj->aName < rNewEntry.aName ) 88 return sal_True; 89 if ( !(pCurLstObj->aName == rNewEntry.aName) ) 90 return sal_False; 91 break; 92 93 case FSYS_SORT_EXT: 94 case (FSYS_SORT_EXT | FSYS_SORT_ASCENDING): 95 { 96 if ( pCurLstObj->GetExtension() > rNewEntry.GetExtension() ) 97 return sal_True; 98 if ( !(pCurLstObj->GetExtension() == rNewEntry.GetExtension()) ) 99 return sal_False; 100 break; 101 } 102 case (FSYS_SORT_EXT | FSYS_SORT_DESCENDING): 103 { 104 if ( pCurLstObj->GetExtension() < rNewEntry.GetExtension() ) 105 return sal_True; 106 if ( !(pCurLstObj->GetExtension() == rNewEntry.GetExtension()) ) 107 return sal_False; 108 break; 109 } 110 111 case FSYS_SORT_KIND: 112 case (FSYS_SORT_KIND | FSYS_SORT_ASCENDING ): 113 if ( VALUE(pOldStat->nKindFlags) > VALUE(rNewStat.nKindFlags) ) 114 return sal_True; 115 if ( !(VALUE(pOldStat->nKindFlags) == VALUE(rNewStat.nKindFlags)) ) 116 return sal_False; 117 break; 118 case (FSYS_SORT_KIND | FSYS_SORT_DESCENDING): 119 if ( VALUE(pOldStat->nKindFlags) < VALUE(rNewStat.nKindFlags) ) 120 return sal_True; 121 if ( !(VALUE(pOldStat->nKindFlags) == VALUE(rNewStat.nKindFlags)) ) 122 return sal_False; 123 break; 124 125 case FSYS_SORT_SIZE: 126 case (FSYS_SORT_SIZE | FSYS_SORT_ASCENDING): 127 if ( pOldStat->nSize > rNewStat.nSize ) 128 return sal_True; 129 if ( !(pOldStat->nSize == rNewStat.nSize) ) 130 return sal_False; 131 break; 132 case (FSYS_SORT_SIZE | FSYS_SORT_DESCENDING): 133 if ( pOldStat->nSize < rNewStat.nSize ) 134 return sal_True; 135 if ( !(pOldStat->nSize == rNewStat.nSize) ) 136 return sal_False; 137 break; 138 139 case FSYS_SORT_MODIFYED: 140 case (FSYS_SORT_MODIFYED | FSYS_SORT_ASCENDING): 141 if ( (pOldStat->aDateModified >= rNewStat.aDateModified) && 142 (pOldStat->aTimeModified > rNewStat.aTimeModified) ) 143 return sal_True; 144 if ( !((pOldStat->aDateModified == rNewStat.aDateModified) && 145 (pOldStat->aTimeModified == rNewStat.aTimeModified)) ) 146 return sal_False; 147 break; 148 case (FSYS_SORT_MODIFYED | FSYS_SORT_DESCENDING): 149 if ( (pOldStat->aDateModified <= rNewStat.aDateModified) && 150 (pOldStat->aTimeModified < rNewStat.aTimeModified) ) 151 return sal_True; 152 if ( !((pOldStat->aDateModified == rNewStat.aDateModified) && 153 (pOldStat->aTimeModified == rNewStat.aTimeModified)) ) 154 return sal_False; 155 break; 156 157 case FSYS_SORT_CREATED: 158 case (FSYS_SORT_CREATED | FSYS_SORT_ASCENDING): 159 if ( (pOldStat->aDateCreated >= rNewStat.aDateCreated) && 160 (pOldStat->aTimeCreated > rNewStat.aTimeCreated) ) 161 return sal_True; 162 if ( !((pOldStat->aDateCreated == rNewStat.aDateCreated) && 163 (pOldStat->aTimeCreated == rNewStat.aTimeCreated)) ) 164 return sal_False; 165 break; 166 case (FSYS_SORT_CREATED | FSYS_SORT_DESCENDING): 167 if ( (pOldStat->aDateCreated <= rNewStat.aDateCreated) && 168 (pOldStat->aTimeCreated < rNewStat.aTimeCreated) ) 169 return sal_True; 170 if ( !((pOldStat->aDateCreated == rNewStat.aDateCreated) && 171 (pOldStat->aTimeCreated == rNewStat.aTimeCreated)) ) 172 return sal_False; 173 break; 174 175 case FSYS_SORT_ACCESSED: 176 case (FSYS_SORT_ACCESSED | FSYS_SORT_ASCENDING): 177 if ( (pOldStat->aDateAccessed >= rNewStat.aDateAccessed) && 178 (pOldStat->aTimeAccessed > rNewStat.aTimeAccessed) ) 179 return sal_True; 180 if ( !((pOldStat->aDateAccessed == rNewStat.aDateAccessed) && 181 (pOldStat->aTimeAccessed == rNewStat.aTimeAccessed)) ) 182 return sal_False; 183 break; 184 case (FSYS_SORT_ACCESSED | FSYS_SORT_DESCENDING): 185 if ( (pOldStat->aDateAccessed <= rNewStat.aDateAccessed) && 186 (pOldStat->aTimeAccessed < rNewStat.aTimeAccessed) ) 187 return sal_True; 188 if ( !((pOldStat->aDateAccessed == rNewStat.aDateAccessed) && 189 (pOldStat->aTimeAccessed == rNewStat.aTimeAccessed)) ) 190 return sal_False; 191 break; 192 default: /* Kann nicht sein */; 193 } 194 195 if ( nSortIndex == ( pSortLst->Count() - 1 ) ) 196 return sal_True; 197 else 198 //Rekursion 199 return ImpInsertPointReached( rNewEntry, rNewStat, 200 nCurPos, nSortIndex + 1 ); 201 #undef VALUE 202 } 203 204 /************************************************************************* 205 |* 206 |* Dir::ImpSortedInsert() 207 |* 208 |* Beschreibung fuegt sortiert ein 209 |* Ersterstellung MA 05.11.91 210 |* Letzte Aenderung MA 03.12.91 211 |* 212 *************************************************************************/ 213 214 void Dir::ImpSortedInsert( const DirEntry *pNewEntry, const FileStat *pNewStat ) 215 { 216 //Sonderfall, keine Sortierung gewuenscht. 217 if ( !pSortLst ) { 218 pLst->Insert( (DirEntry*)pNewEntry, APPEND ); 219 return; 220 } 221 222 pLst->First(); 223 do { 224 if ( ImpInsertPointReached( *pNewEntry, *pNewStat, pLst->GetCurPos(), 225 (sal_uIntPtr)0 ) ) 226 { 227 if ( pStatLst ) 228 pStatLst->Insert( (FileStat*)pNewStat, pLst->GetCurPos() ); 229 pLst->Insert( (DirEntry*)pNewEntry ); 230 return; 231 } 232 } while( pLst->Next() ); 233 234 if ( pStatLst ) 235 pStatLst->Insert( (FileStat*)pNewStat, APPEND ); 236 pLst->Insert( (DirEntry*)pNewEntry, APPEND ); 237 } 238 239 /************************************************************************* 240 |* 241 |* Dir::Construct() 242 |* 243 |* Beschreibung gemeinsame Implementation der Ctoren 244 |* Ersterstellung MI 02.06.93 245 |* Letzte Aenderung MI 02.06.93 246 |* 247 *************************************************************************/ 248 249 void Dir::Construct( DirEntryKind nKindFlags ) 250 { 251 pLst = NULL; 252 pSortLst = NULL; 253 pStatLst = NULL; 254 eAttrMask = nKindFlags; 255 ByteString aTempName( GetName(), osl_getThreadTextEncoding() ); 256 if ( aTempName.Search( "*" ) != STRING_NOTFOUND || 257 aTempName.Search( "?" ) != STRING_NOTFOUND ) 258 #if defined( WNT ) && !defined( WTC ) 259 { 260 ByteString aTStr(CutName(), osl_getThreadTextEncoding()); 261 char* pBuffer = new char[aTStr.Len()+1]; 262 strcpy( pBuffer, aTStr.GetBuffer() ); 263 CharLowerBuff( pBuffer, aTStr.Len() ); 264 aNameMask = WildCard( String(pBuffer, osl_getThreadTextEncoding()), ';' ); 265 delete [] pBuffer; 266 } 267 #else 268 aNameMask = WildCard( CutName(), ';' ); 269 #endif 270 else 271 aNameMask = String("*", osl_getThreadTextEncoding()); 272 } 273 274 /************************************************************************* 275 |* 276 |* Dir::Update() 277 |* 278 |* Beschreibung FSYS.SDW 279 |* Ersterstellung MI 16.05.91 280 |* Letzte Aenderung MI 19.09.96 281 |* 282 *************************************************************************/ 283 284 sal_Bool Dir::Update() 285 { 286 Reset(); 287 return Scan( USHRT_MAX ) > 0; 288 } 289 290 /************************************************************************* 291 |* 292 |* Dir::Reset() 293 |* 294 |* Beschreibung 295 |* Ersterstellung MI 22.10.96 296 |* Letzte Aenderung MI 22.10.96 297 |* 298 *************************************************************************/ 299 300 void Dir::Reset() 301 { 302 // ggf. alten Reader l"oschen 303 if ( pReader && pReader->bInUse ) 304 DELETEZ(pReader); 305 306 // alle DirEntries aus der Liste entfernen und deren Speicher freigeben 307 if ( pLst ) 308 { 309 DirEntry* pEntry = pLst->First(); 310 while (pEntry) 311 { 312 DirEntry* pNext = pLst->Next(); 313 delete pEntry; 314 pEntry = pNext; 315 } 316 pLst->Clear(); 317 } 318 else 319 pLst = new DirEntryList(); 320 321 // Alte File-Stat's Loeschen 322 if ( pStatLst ) 323 { 324 //Erstmal die alten Loeschen 325 FileStat* pEntry = pStatLst->First(); 326 while (pEntry) 327 { 328 FileStat* pNext = pStatLst->Next(); 329 delete pEntry; 330 pEntry = pNext; 331 } 332 pStatLst->Clear(); 333 delete pStatLst; 334 } 335 336 // Verlangen die Sortierkriterien FileStat's? 337 if ( pSortLst ) 338 { 339 pSortLst->First(); 340 do 341 { 342 if ( *( pSortLst->GetCurObject() ) & 343 ( FSYS_SORT_KIND | FSYS_SORT_SIZE | 344 FSYS_SORT_CREATED | FSYS_SORT_MODIFYED | FSYS_SORT_ACCESSED ) ) 345 pStatLst = new FileStatList(); 346 } while ( !pStatLst && pSortLst->Next() ); 347 } 348 349 #ifndef BOOTSTRAP 350 // ggf. einen neuen Reader aufsetzen 351 if ( !pReader ) 352 pReader = new DirReader_Impl( *this ); 353 #endif 354 355 // gibt es das zu oeffnende Verzeichnis ueberhaupt? 356 #if !defined(UNX) && !defined(OS2) //explanation: see DirReader_Impl::Read() in unx.cxx 357 if( !pReader->pDosDir ) 358 { 359 nError = FSYS_ERR_NOTADIRECTORY; 360 DELETEZ( pReader ); 361 return; 362 } 363 #endif 364 } 365 366 /************************************************************************* 367 |* 368 |* Dir::Scan() 369 |* 370 |* Beschreibung FSYS.SDW 371 |* Ersterstellung MI 18.09.96 372 |* Letzte Aenderung MI 19.09.96 373 |* 374 *************************************************************************/ 375 376 sal_uInt16 Dir::Scan( sal_uInt16 nCount ) 377 { 378 379 sal_uInt16 nRead = 0; // Anzahl in dieser Runde gelesener Eintr"age 380 FSysFailOnErrorImpl(); 381 382 // noch nicht fertig gewesen 383 if ( pReader ) 384 { 385 // frischer Reader? 386 if ( !pLst->Count() ) 387 { 388 // dann ggf. Laufwerke scannen 389 pReader->bInUse = sal_True; 390 nRead = pReader->Init(); 391 } 392 393 // weiterlesen... 394 while ( nRead <= nCount && !pReader->bReady ) 395 nRead = nRead + pReader->Read(); 396 397 // fertig? 398 if ( pReader && pReader->bReady ) 399 DELETEZ( pReader ); 400 } 401 402 // Anzahl der gelesenen zur"uckgeben 403 return nRead; 404 } 405 406 /************************************************************************* 407 |* 408 |* Dir::Dir() 409 |* 410 |* Beschreibung FSYS.SDW 411 |* Ersterstellung MI 16.05.91 412 |* Letzte Aenderung MI 04.03.92 413 |* 414 *************************************************************************/ 415 416 Dir::Dir( const DirEntry& rDirEntry, DirEntryKind nKindFlags, FSysSort nSort, ... ): 417 DirEntry( rDirEntry ), 418 pReader( 0 ) 419 { 420 DBG_CTOR( Dir, NULL ); 421 422 Construct( nKindFlags ); 423 424 std::va_list pArgs; 425 va_start( pArgs, nSort ); 426 ImpSetSort( pArgs, nSort ); 427 428 Reset(); 429 } 430 431 /************************************************************************* 432 |* 433 |* Dir::Dir() 434 |* 435 |* Beschreibung FSYS.SDW 436 |* Ersterstellung MI 02.06.93 437 |* Letzte Aenderung MI 02.06.93 438 |* 439 *************************************************************************/ 440 441 Dir::Dir( const DirEntry& rDirEntry, DirEntryKind nKindFlags ): 442 DirEntry( rDirEntry ), 443 pReader( 0 ) 444 { 445 DBG_CTOR( Dir, NULL ); 446 447 Construct( nKindFlags ); 448 Reset(); 449 } 450 451 /************************************************************************* 452 |* 453 |* Dir::Dir() 454 |* 455 |* Beschreibung FSYS.SDW 456 |* Ersterstellung MI 16.05.91 457 |* Letzte Aenderung MA 04.11.91 458 |* 459 *************************************************************************/ 460 461 Dir::Dir(): 462 pReader( 0 ) 463 { 464 DBG_CTOR( Dir, NULL ); 465 466 pLst = NULL; 467 pSortLst = NULL; 468 pStatLst = NULL; 469 eAttrMask = FSYS_KIND_ALL; 470 aNameMask = String("*", osl_getThreadTextEncoding()); 471 } 472 473 /************************************************************************* 474 |* 475 |* Dir::~Dir() 476 |* 477 |* Beschreibung FSYS.SDW 478 |* Ersterstellung MI 16.05.91 479 |* Letzte Aenderung MA 04.11.91 480 |* 481 *************************************************************************/ 482 483 Dir::~Dir() 484 { 485 DBG_DTOR( Dir, NULL ); 486 487 // alle DirEntries aus der Liste entfernen und deren Speicher freigeben 488 if ( pLst ) 489 { 490 DirEntry* pEntry = pLst->First(); 491 while (pEntry) 492 { 493 DirEntry* pNext = pLst->Next(); 494 delete pEntry; 495 pEntry = pNext; 496 } 497 pLst->Clear(); 498 499 delete pLst; 500 } 501 502 // alle Sorts aus der Liste entfernen und deren Speicher freigeben 503 if ( pSortLst ) 504 { 505 FSysSort* pEntry = pSortLst->First(); 506 while (pEntry) 507 { 508 FSysSort* pNext = pSortLst->Next(); 509 delete pEntry; 510 pEntry = pNext; 511 } 512 pSortLst->Clear(); 513 514 delete pSortLst; 515 } 516 517 // alle FileStat's aus der Liste entfernen und deren Speicher freigeben 518 if ( pStatLst ) 519 { 520 FileStat* pEntry = pStatLst->First(); 521 while (pEntry) 522 { 523 FileStat* pNext = pStatLst->Next(); 524 delete pEntry; 525 pEntry = pNext; 526 } 527 pStatLst->Clear(); 528 delete pStatLst; 529 } 530 531 // ggf. laufenden Reader freigeben 532 delete pReader; 533 } 534 535 /************************************************************************* 536 |* 537 |* Dir::ImpSetSort() 538 |* 539 |* Beschreibung FSYS.SDW 540 |* Ersterstellung MA 04.11.91 541 |* Letzte Aenderung MI 05.02.92 542 |* 543 *************************************************************************/ 544 545 FSysError Dir::ImpSetSort( std::va_list pArgs, int nFirstSort ) 546 { 547 sal_Bool bLast; 548 FSysSort *pSort; 549 FSysSortList *pNewSortLst = new FSysSortList; 550 551 *( pSort = new FSysSort ) = nFirstSort; 552 do 553 { 554 // letztes Kriterium? 555 bLast = FSYS_SORT_END == (*pSort & FSYS_SORT_END); 556 *pSort &= ~FSYS_SORT_END; 557 558 FSysSort nSort = *pSort & ~(sal_uInt16)FSYS_SORT_ASCENDING 559 & ~(sal_uInt16)FSYS_SORT_DESCENDING; 560 561 // g"utliges Sortierkriterium? 562 if ( ( nSort == FSYS_SORT_NAME ) || 563 ( nSort == FSYS_SORT_SIZE ) || 564 ( nSort == FSYS_SORT_EXT ) || 565 ( nSort == FSYS_SORT_CREATED ) || 566 ( nSort == FSYS_SORT_MODIFYED ) || 567 ( nSort == FSYS_SORT_ACCESSED ) || 568 ( nSort == FSYS_SORT_KIND ) ) 569 { 570 pNewSortLst->Insert( pSort, APPEND ); 571 *(pSort = new FSysSort) = va_arg( pArgs, FSysSort ); 572 } 573 else 574 { // ungueltiger Sort oder FSYS_SORT_NONE 575 FSysSort* pEntry = pNewSortLst->First(); 576 while (pEntry) 577 { 578 FSysSort* pNext = pNewSortLst->Next(); 579 delete pEntry; 580 pEntry = pNext; 581 } 582 pNewSortLst->Clear(); 583 delete pNewSortLst; 584 if ( *pSort == FSYS_SORT_NONE ) 585 { 586 delete pSort; 587 if ( pSortLst ) 588 delete pSortLst; 589 return FSYS_ERR_OK; 590 } 591 else 592 { 593 delete pSort; 594 return FSYS_ERR_NOTSUPPORTED; 595 } 596 } 597 } while ( !bLast ); 598 599 va_end( pArgs ); 600 delete pSort; // JP:6.3.00 - delete the initial pointer 601 602 //Enfernen der alten Sort-Elemente 603 if ( pSortLst ) 604 { 605 FSysSort* pEntry = pSortLst->First(); 606 while (pEntry) 607 { 608 FSysSort* pNext = pSortLst->Next(); 609 delete pEntry; 610 pEntry = pNext; 611 } 612 pSortLst->Clear(); 613 delete pSortLst; 614 } 615 pSortLst = pNewSortLst; 616 617 //Jetzt noch neu Sortieren... 618 619 //Wenn keine FileStats da sind, aber nun welche gebraucht werden, 620 //ist der Aufruf von Update() die einfachste Moeglichkeit 621 if ( !pStatLst && pSortLst ) 622 { 623 pSortLst->First(); 624 do 625 { 626 if ( *(pSortLst->GetCurObject()) & 627 ( FSYS_SORT_CREATED | FSYS_SORT_MODIFYED | FSYS_SORT_SIZE | 628 FSYS_SORT_ACCESSED | FSYS_SORT_KIND ) ) 629 { 630 Update(); 631 return FSYS_ERR_OK; 632 } 633 } while ( !pStatLst && pSortLst->Next() ); 634 } 635 636 if ( pLst ) { //Keine DirEntry's, kein Sort. 637 DirEntryList *pOldLst = pLst; //alte Liste merken 638 pLst = new DirEntryList(); //neue Liste (zu Sortieren) 639 640 FileStatList *pOldStatLst = NULL; //alte StatListe merken 641 if ( pStatLst ) { 642 pOldStatLst = pStatLst; 643 pStatLst = new FileStatList(); //neue StatListe (zu Sortieren) 644 } 645 pOldLst->First(); 646 do 647 { 648 //Sortiertes Einfuegen der Elemente aus den gemerkten Listen 649 //in die 'richtigen' Listen 650 if ( pOldStatLst ) 651 ImpSortedInsert( pOldLst->GetCurObject(), 652 pOldStatLst->GetObject( pOldLst->GetCurPos() ) ); 653 else 654 ImpSortedInsert( pOldLst->GetCurObject(), NULL ); 655 } while( pOldLst->Next() ); 656 657 delete pOldLst; 658 if ( pOldStatLst ) 659 delete pOldStatLst; 660 } 661 return FSYS_ERR_OK; 662 } 663 664 /************************************************************************* 665 |* 666 |* Dir::SetSort() 667 |* 668 |* Beschreibung FSYS.SDW 669 |* Ersterstellung MA 04.11.91 670 |* Letzte Aenderung MI 05.02.92 671 |* 672 *************************************************************************/ 673 674 FSysError Dir::SetSort( FSysSort nSort, ... ) 675 { 676 std::va_list pArgs; 677 va_start( pArgs, nSort ); 678 return ImpSetSort( pArgs, nSort ); 679 } 680 681 /************************************************************************* 682 |* 683 |* Dir::operator[]() 684 |* 685 |* Beschreibung FSYS.SDW 686 |* Ersterstellung MI 16.05.91 687 |* Letzte Aenderung MI 16.05.91 688 |* 689 *************************************************************************/ 690 691 DirEntry& Dir::operator[] ( sal_uInt16 nIndex ) const 692 { 693 DBG_ASSERT( nIndex < Count(), "Dir::operator[] : nIndex > Count()" ); 694 695 DirEntry *pEntry = pLst->GetObject( nIndex ); 696 return *pEntry; 697 } 698 699 /************************************************************************* 700 |* 701 |* Dir::operator+= () 702 |* 703 |* Beschreibung FSYS.SDW 704 |* Ersterstellung MI 16.05.91 705 |* Letzte Aenderung MI 16.05.91 706 |* 707 *************************************************************************/ 708 709 Dir& Dir::operator+=( const Dir& rDir ) 710 { 711 // ggf. erst den Rest lesen 712 if ( pReader ) 713 Scan( USHRT_MAX ); 714 DBG_ASSERT( !rDir.pReader, "Dir::+= with incomplete Dir" ); 715 716 // ggf. initiale Liste erzeugen 717 if ( !pLst ) 718 pLst = new DirEntryList(); 719 720 //Verlangen die Sortierkriterien FileStat's? 721 sal_Bool bStat = sal_False; 722 if ( pSortLst ) { 723 pSortLst->First(); 724 do { 725 if ( *(pSortLst->GetCurObject()) & 726 ( FSYS_SORT_CREATED | FSYS_SORT_MODIFYED | FSYS_SORT_SIZE | 727 FSYS_SORT_ACCESSED | FSYS_SORT_KIND ) ) 728 bStat = sal_True; 729 } while ( !bStat && pSortLst->Next() ); 730 } 731 FileStat * stat = NULL; 732 for ( sal_uInt16 nNr = 0; nNr < rDir.Count(); nNr++ ) 733 { 734 if ( bStat ) 735 { 736 if ( rDir.pStatLst ) 737 stat = new FileStat( *rDir.pStatLst->GetObject(nNr) ); 738 else 739 stat = new FileStat( rDir[nNr] ); 740 } 741 ImpSortedInsert( new DirEntry( rDir[nNr] ), stat ); 742 } 743 return *this; 744 } 745 746 /************************************************************************* 747 |* 748 |* Dir::Count() 749 |* 750 |* Beschreibung FSYS.SDW 751 |* Ersterstellung MI 16.05.91 752 |* Letzte Aenderung MI 18.09.96 753 |* 754 *************************************************************************/ 755 756 757 sal_uInt16 Dir::Count( sal_Bool bUpdated ) const 758 { 759 // ggf. erst den Rest lesen 760 if ( bUpdated && pReader ) 761 ((Dir*)this)->Scan( USHRT_MAX ); 762 763 return pLst == NULL ? 0 : (sal_uInt16) pLst->Count(); 764 } 765