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