Changeset 650

Show
Ignore:
Timestamp:
08/02/08 14:03:58 (4 months ago)
Author:
gbooker
Message:

Some changes to the directory scanning. This is a bit faster, but still not fast enough

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/CoreData/SapphireFrappliance/MetaData/SapphireMObjects/SapphireDirectoryMetaData.h

    r578 r650  
    2121+ (SapphireDirectoryMetaData *)createDirectoryWithPath:(NSString *)path parent:(SapphireDirectoryMetaData *)parent inContext:(NSManagedObjectContext *)moc; 
    2222- (void)insertDictionary:(NSDictionary *)dict withDefer:(NSMutableDictionary *)defer andDisplay:(SapphireMetaDataUpgrading *)display; 
     23- (void)rescanDirWithExistingDirs:(NSMutableArray *)existingDirs files:(NSMutableArray *)existingFiles symDirs:(NSMutableArray *)existingSymDirs symFiles:(NSMutableArray *)existingSymFiles; 
    2324@end 
  • branches/CoreData/SapphireFrappliance/MetaData/SapphireMObjects/SapphireDirectoryMetaData.m

    r637 r650  
    242242} 
    243243 
    244 - (void)reloadDirectoryContents 
    245 
    246         NSManagedObjectContext *moc = [self managedObjectContext]; 
    247         [moc refreshObject:self mergeChanges:NO]; 
    248          
     244- (void)rescanDirWithExistingDirs:(NSMutableArray *)existingDirs files:(NSMutableArray *)existingFiles symDirs:(NSMutableArray *)existingSymDirs symFiles:(NSMutableArray *)existingSymFiles; 
     245
    249246        [importArray release]; 
    250247        importArray = [[NSMutableArray alloc] init]; 
    251         [cachedLookup release]; 
    252         cachedLookup = [[NSMutableDictionary alloc] init]; 
    253  
    254         NSPredicate *fetchPred = [NSPredicate predicateWithFormat:@"parent == %@", self]; 
    255         NSArray *fetchedFiles = doFetchRequest(SapphireFileMetaDataName, moc, fetchPred); 
    256         NSMutableSet *files; 
    257         if([fetchedFiles count]) 
    258                 files = [[NSMutableSet alloc] initWithArray:[fetchedFiles valueForKeyPath:@"path.lastPathComponent"]]; 
    259         else 
    260                 files = [[NSMutableSet alloc] init]; 
    261  
    262         NSArray *fetchedDirs = doFetchRequest(SapphireDirectoryMetaDataName, moc, fetchPred); 
    263         NSMutableSet *dirs; 
    264         if([fetchedDirs count]) 
    265                 dirs = [[NSMutableSet alloc] initWithArray:[fetchedDirs valueForKeyPath:@"path.lastPathComponent"]]; 
    266         else 
    267                 dirs = [[NSMutableSet alloc] init]; 
    268  
    269         //These are rare; so don't need to prefetch 
    270         NSMutableSet *linkedFiles = [[self.linkedFilesSet valueForKeyPath:@"path.lastPathComponent"] mutableCopy]; 
    271         NSMutableSet *linkedDirs = [[self.linkedDirsSet valueForKeyPath:@"path.lastPathComponent"] mutableCopy]; 
     248 
     249        NSMutableDictionary *dirs = [[NSMutableDictionary alloc] init]; 
     250        NSEnumerator *cachedEnum = [existingDirs objectEnumerator]; 
     251        NSManagedObject *object; 
     252        while((object = [cachedEnum nextObject]) != nil) 
     253        { 
     254                [dirs setObject:object forKey:[object valueForKeyPath:@"path.lastPathComponent"]]; 
     255        } 
     256         
     257        NSMutableDictionary *files = [[NSMutableDictionary alloc] init]; 
     258        cachedEnum = [existingFiles objectEnumerator]; 
     259        while((object = [cachedEnum nextObject]) != nil) 
     260        { 
     261                [files setObject:object forKey:[object valueForKeyPath:@"path.lastPathComponent"]]; 
     262        } 
     263 
     264        NSMutableDictionary *linkedDirs = [[NSMutableDictionary alloc] init]; 
     265        cachedEnum = [existingSymDirs objectEnumerator]; 
     266        while((object = [cachedEnum nextObject]) != nil) 
     267        { 
     268                [linkedDirs setObject:object forKey:[object valueForKeyPath:@"path.lastPathComponent"]]; 
     269        } 
     270 
     271        NSMutableDictionary *linkedFiles = [[NSMutableDictionary alloc] init]; 
     272        cachedEnum = [existingSymFiles objectEnumerator]; 
     273        while((object = [cachedEnum nextObject]) != nil) 
     274        { 
     275                [linkedFiles setObject:object forKey:[object valueForKeyPath:@"path.lastPathComponent"]]; 
     276        } 
    272277         
    273278        NSFileManager *fm = [NSFileManager defaultManager]; 
     279        NSManagedObjectContext *moc = [self managedObjectContext]; 
    274280         
    275281        NSArray *names = [fm directoryContentsAtPath:self.path]; 
    276282        NSEnumerator *nameEnum = [names objectEnumerator]; 
    277283        NSString *name; 
    278         BOOL modified = NO; 
     284        BOOL modified = NO;     
    279285        while((name = [nameEnum nextObject]) != nil) 
    280286        { 
     
    282288                if(![fm acceptFilePath:filePath]) 
    283289                        continue; 
    284  
     290                 
    285291                NSDictionary *attributes = [fm fileAttributesAtPath:filePath traverseLink:NO]; 
    286292                if([[attributes fileType] isEqualToString:NSFileTypeSymbolicLink]) 
     
    293299                        if([fm isDirectory:resolvedPath]) 
    294300                        { 
    295                                 if([dirs containsObject:name]
     301                                if([dirs objectForKey:name] != nil
    296302                                { 
    297303                                        //Dir moved, but original data is still here 
     
    299305                                        if(resolved != nil) 
    300306                                                [moc deleteObject:resolved]; 
    301  
     307                                         
    302308                                        resolved = (SapphireDirectoryMetaData *)[self metaDataForDirectory:name]; 
    303309                                        resolved.parent = [SapphireDirectoryMetaData createDirectoryWithPath:[resolvedPath stringByDeletingLastPathComponent] inContext:moc]; 
    304310                                        resolved.path = resolvedPath; 
    305                                         [dirs removeObject:name]; 
     311                                        [dirs removeObjectForKey:name]; 
    306312                                } 
    307                                 [SapphireDirectorySymLink createDirectoryLinkWithPath:filePath toPath:resolvedPath inContext:moc]; 
    308                                 [linkedDirs removeObject:name]; 
     313                                SapphireDirectorySymLink *newLink = [SapphireDirectorySymLink createDirectoryLinkWithPath:filePath toPath:resolvedPath inContext:moc]; 
     314                                if([linkedDirs objectForKey:name] != nil) 
     315                                        [linkedDirs removeObjectForKey:name]; 
     316                                else 
     317                                        [existingSymDirs addObject:newLink]; 
    309318                        } 
    310319                        else 
    311320                        { 
    312                                 if([files containsObject:name]
     321                                if([files objectForKey:name] != nil
    313322                                { 
    314323                                        //File moved, but original data is still here 
     
    316325                                        if(resolved != nil) 
    317326                                                [moc deleteObject:resolved]; 
    318  
     327                                         
    319328                                        resolved = [self metaDataForFile:name]; 
    320329                                        resolved.parent = [SapphireDirectoryMetaData createDirectoryWithPath:[resolvedPath stringByDeletingLastPathComponent] inContext:moc]; 
    321330                                        resolved.path = resolvedPath; 
    322                                         [files removeObject:name]; 
     331                                        [files removeObjectForKey:name]; 
    323332                                } 
    324                                 [SapphireFileSymLink createFileLinkWithPath:filePath toPath:resolvedPath inContext:moc]; 
    325                                 [linkedFiles removeObject:name]; 
     333                                SapphireFileSymLink *newLink = [SapphireFileSymLink createFileLinkWithPath:filePath toPath:resolvedPath inContext:moc]; 
     334                                if([linkedFiles objectForKey:name] != nil) 
     335                                        [linkedFiles removeObjectForKey:name]; 
     336                                else 
     337                                        [existingSymFiles addObject:newLink]; 
    326338                        } 
    327339                        /*      It's not always modified, but rather than figuring out all the cases where it is or isn't 
    328                                just set it to YES for a rare case and figure it out later if it's an issue*/ 
     340                        just set it to YES for a rare case and figure it out later if it's an issue*/ 
    329341                        modified = YES; 
    330342                } 
    331343                else if([fm isDirectory:filePath]) 
    332344                { 
    333                         if(![dirs containsObject:name]) 
    334                         { 
    335                                 [SapphireDirectoryMetaData createDirectoryWithPath:filePath parent:self inContext:moc]; 
     345                        SapphireDirectoryMetaData *subDir = [dirs objectForKey:name]; 
     346                        if(subDir == nil) 
     347                        { 
     348                                subDir = [SapphireDirectoryMetaData createDirectoryWithPath:filePath parent:self inContext:moc]; 
     349                                [existingDirs addObject:subDir]; 
    336350                                modified = YES; 
    337351                        } 
    338                         [dirs removeObject:name]; 
     352                        else 
     353                                [dirs removeObjectForKey:name]; 
    339354                } 
    340355                else 
    341356                { 
    342                         if(![files containsObject:name]) 
    343                         { 
    344                                 SapphireFileMetaData *file = [SapphireFileMetaData createFileWithPath:filePath parent:self inContext:moc]; 
    345                                 [importArray addObject:file]; 
     357                        SapphireFileMetaData *subFile = [files objectForKey:name]; 
     358                        if(subFile == nil) 
     359                        { 
     360                                subFile = [SapphireFileMetaData createFileWithPath:filePath parent:self inContext:moc]; 
     361                                [existingFiles addObject:subFile]; 
     362                                [importArray addObject:subFile]; 
    346363                                modified = YES; 
    347364                        } 
    348365                        else 
    349366                        { 
    350                                 SapphireFileMetaData *file = [self metaDataForFile:name]; 
    351                                 if([file needsUpdating]) 
    352                                         [importArray addObject:file];                            
    353                         } 
    354                         [files removeObject:name]; 
    355                 } 
     367                                [files removeObjectForKey:name]; 
     368                                if([subFile needsUpdating]) 
     369                                        [importArray addObject:subFile];                                 
     370                        } 
     371                } 
     372        } 
     373         
     374        NSEnumerator *objectEnum = [files objectEnumerator]; 
     375        while((object = [objectEnum nextObject]) != nil) 
     376        { 
     377                [existingFiles removeObject:object]; 
     378                [moc deleteObject:object]; 
     379                modified = YES; 
     380        } 
     381         
     382        objectEnum = [dirs objectEnumerator]; 
     383        while((object = [objectEnum nextObject]) != nil) 
     384        { 
     385                [existingDirs removeObject:object]; 
     386                [moc deleteObject:object]; 
     387                modified = YES; 
     388        } 
     389         
     390        objectEnum = [linkedFiles objectEnumerator]; 
     391        while((object = [objectEnum nextObject]) != nil) 
     392        { 
     393                [existingSymFiles removeObject:object]; 
     394                [moc deleteObject:object]; 
     395                modified = YES; 
     396        } 
     397         
     398        objectEnum = [linkedDirs objectEnumerator]; 
     399        while((object = [objectEnum nextObject]) != nil) 
     400        { 
     401                [existingSymDirs removeObject:object]; 
     402                [moc deleteObject:object]; 
     403                modified = YES; 
    356404        } 
    357405         
    358406        if(modified) 
    359407                [self clearPredicateCache]; 
    360          
    361         nameEnum = [files objectEnumerator]; 
    362         while((name = [nameEnum nextObject]) != nil) 
    363         { 
    364                 NSLog(@"Need to delete file %@ in %@", name, self.path); 
    365                 SapphireFileMetaData *file = [SapphireFileMetaData fileWithPath:[self.path stringByAppendingPathComponent:name] inContext:moc]; 
    366                 if(file != nil) 
    367                         [moc deleteObject:file]; 
    368         } 
    369          
    370         nameEnum = [dirs objectEnumerator]; 
    371         while((name = [nameEnum nextObject]) != nil) 
    372         { 
    373                 NSLog(@"Need to delete dir %@ in %@", name, self.path); 
    374                 SapphireDirectoryMetaData *dir = [SapphireDirectoryMetaData directoryWithPath:[self.path stringByAppendingPathComponent:name] inContext:moc]; 
    375                 if(dir != nil) 
    376                         [moc deleteObject:dir]; 
    377         } 
    378          
    379         nameEnum = [linkedFiles objectEnumerator]; 
    380         while((name = [nameEnum nextObject]) != nil) 
    381         { 
    382                 NSLog(@"Need to delete file link %@ in %@", name, self.path); 
    383                 SapphireFileSymLink *link = [SapphireFileSymLink fileLinkWithPath:[self.path stringByAppendingPathComponent:name] inContext:moc]; 
    384                 [moc deleteObject:link]; 
    385         } 
    386          
    387         nameEnum = [linkedDirs objectEnumerator]; 
    388         while((name = [nameEnum nextObject]) != nil) 
    389         { 
    390                 NSLog(@"Need to delete dir link %@ in %@", name, self.path); 
    391                 SapphireDirectorySymLink *link = [SapphireDirectorySymLink directoryLinkWithPath:[self.path stringByAppendingPathComponent:name] inContext:moc]; 
    392                 [moc deleteObject:link]; 
    393         } 
    394408        [SapphireMetaDataSupport save:moc]; 
    395          
    396         NSArray *fileObjects = fetchedFiles = doFetchRequest(SapphireFileMetaDataName, moc, fetchPred); 
    397         NSMutableArray *allFiles = [fileObjects mutableCopy]; 
    398         [allFiles addObjectsFromArray:[self.linkedFilesSet allObjects]]; 
     409
     410 
     411- (void)reloadDirectoryContents 
     412
     413        NSManagedObjectContext *moc = [self managedObjectContext]; 
     414        [moc refreshObject:self mergeChanges:NO]; 
     415         
     416        [cachedLookup release]; 
     417        cachedLookup = [[NSMutableDictionary alloc] init]; 
     418 
     419        NSPredicate *fetchPred = [NSPredicate predicateWithFormat:@"parent == %@", self]; 
     420        NSMutableArray *fetchedFiles = [doFetchRequest(SapphireFileMetaDataName, moc, fetchPred) mutableCopy]; 
     421        NSMutableArray *fetchedDirs = [doFetchRequest(SapphireDirectoryMetaDataName, moc, fetchPred) mutableCopy]; 
     422        NSMutableArray *linkedFiles = [[self.linkedFilesSet allObjects] mutableCopy]; 
     423        NSMutableArray *linkedDirs = [[self.linkedDirsSet allObjects] mutableCopy]; 
     424         
     425        [self rescanDirWithExistingDirs:fetchedDirs files:fetchedFiles symDirs:linkedDirs symFiles:linkedFiles]; 
     426         
     427        NSMutableArray *allFiles = [fetchedFiles mutableCopy]; 
     428        [allFiles addObjectsFromArray:linkedFiles]; 
    399429        if(filterPredicate != nil) 
    400         { 
    401430                [allFiles filterUsingPredicate:filterPredicate]; 
    402                 //nil predicate means we are directory scanning, so don't prefetch this 
    403                if([fileObjects count]) 
    404                
    405                        NSSet *files = [NSSet setWithArray:fileObjects]; 
    406                        NSSet *allEps = [files valueForKeyPath:@"tvEpisode.objectID"]; 
    407                        if([allEps count]) 
    408                        { 
    409                                NSPredicate *fetchPred = [NSPredicate predicateWithFormat:@"SELF IN %@", allEps]; 
    410                                NSArray *episodes = doFetchRequest(SapphireEpisodeName, moc, fetchPred)
    411                                if([episodes count]) 
    412                                { 
    413                                        fetchPred = [NSPredicate predicateWithFormat:@"episode IN %@", episodes]; 
    414                                        doFetchRequest(SapphireSubEpisodeName, moc, fetchPred)
    415                                 } 
    416                         } 
    417                        NSSet *allMovies = [files valueForKeyPath:@"movie.objectID"]; 
    418                        if([allMovies count]) 
    419                        { 
    420                                NSPredicate *fetchPred = [NSPredicate predicateWithFormat:@"SELF IN %@", allMovies]; 
    421                                doFetchRequest(SapphireMovieName, moc, fetchPred)
    422                         } 
    423                 }               
    424         } 
     431 
     432        if([allFiles count]) 
     433       
     434                NSMutableSet *files = [NSMutableSet setWithArray:fetchedFiles]; 
     435                [files addObjectsFromArray:[linkedFiles valueForKey:@"file"]]; 
     436                NSSet *allEps = [files valueForKeyPath:@"tvEpisode.objectID"]; 
     437                if([allEps count]) 
     438                { 
     439                        NSPredicate *fetchPred = [NSPredicate predicateWithFormat:@"SELF IN %@", allEps]
     440                        NSArray *episodes = doFetchRequest(SapphireEpisodeName, moc, fetchPred); 
     441                        if([episodes count]) 
     442                        { 
     443                                fetchPred = [NSPredicate predicateWithFormat:@"episode IN %@", episodes]
     444                                doFetchRequest(SapphireSubEpisodeName, moc, fetchPred); 
     445                        } 
     446                } 
     447                NSSet *allMovies = [files valueForKeyPath:@"movie.objectID"]; 
     448                if([allMovies count]) 
     449                { 
     450                        NSPredicate *fetchPred = [NSPredicate predicateWithFormat:@"SELF IN %@", allMovies]
     451                        doFetchRequest(SapphireMovieName, moc, fetchPred); 
     452                } 
     453        }               
    425454        [allFiles sortUsingFunction:fileAndLinkEpisodeCompare context:nil]; 
    426455        [cachedFiles release]; 
     
    435464        } 
    436465        [allFiles release]; 
    437          
    438         NSMutableArray *allDirs = [[self.metaDirsSet allObjects] mutableCopy]; 
     466        [fetchedFiles release]; 
     467        [linkedDirs release]; 
     468         
     469        NSMutableArray *allDirs = [fetchedDirs mutableCopy]; 
    439470        if(filterPredicate != nil) 
    440471        { 
     
    455486                } 
    456487        } 
    457         NSArray *linkedDirsObjects = [self.linkedDirsSet allObjects]; 
    458488        if(filterPredicate != nil) 
    459489        { 
    460                 int i, count = [linkedDirsObjects count]; 
     490                int i, count = [linkedDirs count]; 
    461491                for(i=0; i<count; i++) 
    462492                { 
    463                         SapphireDirectorySymLink *link = [linkedDirsObjects objectAtIndex:i]; 
     493                        SapphireDirectorySymLink *link = [linkedDirs objectAtIndex:i]; 
    464494                        SapphireDirectoryMetaData *dir = [link directory]; 
    465495                        if([dir containsFileMatchingFilterPredicate:filterPredicate]) 
     
    471501        } 
    472502        else 
    473                 [allDirs addObjectsFromArray:linkedDirsObjects]; 
     503                [allDirs addObjectsFromArray:linkedDirs]; 
    474504        [allDirs sortUsingFunction:dirAndLinkPathCompare context:nil]; 
    475505        [cachedDirs release]; 
     
    484514        } 
    485515        [allDirs release]; 
     516        [fetchedDirs release]; 
     517        [linkedDirs release]; 
    486518        [delegate directoryContentsChanged]; 
    487519} 
     
    534566} 
    535567 
    536 - (void)getSubFileMetasWithDelegate:(id <SapphireMetaDataScannerDelegate>)subDelegate skipDirectories:(NSMutableSet *)skip 
     568- (void)conductScanWithDelegate:(id <SapphireMetaDataScannerDelegate>)subDelegate skipDirectories:(NSMutableSet *)skip andResults:(BOOL)results 
    537569{ 
    538570        /*Scan dir and create scanner*/ 
    539         [self setFilterPredicate:[SapphireApplianceController unfilteredPredicate]]; 
    540         [self reloadDirectoryContents]; 
    541571        SapphireMetaDataScanner *scanner = [[SapphireMetaDataScanner alloc] initWithDirectoryMetaData:self delegate:subDelegate]; 
     572         
     573        NSPredicate *fetchPredicate = [NSPredicate predicateWithFormat:@"parent = %@", self]; 
     574        NSSortDescriptor *sort = [[NSSortDescriptor alloc] initWithKey:@"path" ascending:YES]; 
     575        NSManagedObjectContext *moc = [self managedObjectContext]; 
     576        NSArray *dirs = doSortedFetchRequest(SapphireDirectoryMetaDataName, moc, fetchPredicate, sort); 
     577        NSArray *files = doSortedFetchRequest(SapphireFileMetaDataName, moc, fetchPredicate, sort); 
     578        fetchPredicate = [NSPredicate predicateWithFormat:@"containingDirectory = %@", self]; 
     579        NSArray *symDirs = doSortedFetchRequest(SapphireDirectorySymLinkName, moc, fetchPredicate, sort); 
     580        NSArray *symFiles = doSortedFetchRequest(SapphireFileSymLinkName, moc, fetchPredicate, sort); 
     581        [sort release]; 
     582         
     583        [scanner setSubDirs:dirs files:files symDirs:symDirs symFiles:symFiles]; 
     584         
    542585        /*Add ourselves to not rescan*/ 
    543586        [skip addObject:self.path]; 
    544587        [scanner setSkipDirectories:skip]; 
    545588        /*We want results*/ 
    546         [scanner setGivesResults:YES]; 
     589        [scanner setGivesResults:results]; 
    547590        [scanner release]; 
    548591} 
    549592 
     593- (void)getSubFileMetasWithDelegate:(id <SapphireMetaDataScannerDelegate>)subDelegate skipDirectories:(NSMutableSet *)skip 
     594{ 
     595        [self conductScanWithDelegate:subDelegate skipDirectories:skip andResults:YES]; 
     596} 
     597 
    550598- (void)scanForNewFilesWithDelegate:(id <SapphireMetaDataScannerDelegate>)subDelegate skipDirectories:(NSMutableSet *)skip 
    551599{ 
    552         /*Scan dir and create scanner*/ 
    553         [self reloadDirectoryContents]; 
    554         SapphireMetaDataScanner *scanner = [[SapphireMetaDataScanner alloc] initWithDirectoryMetaData:self delegate:subDelegate]; 
    555         /*Add ourselves to not rescan*/ 
    556         [skip addObject:[self path]]; 
    557         [scanner setSkipDirectories:skip]; 
    558         /*We don't want results*/ 
    559         [scanner setGivesResults:NO]; 
    560         [scanner release]; 
     600        [self conductScanWithDelegate:subDelegate skipDirectories:skip andResults:NO]; 
    561601} 
    562602 
  • branches/CoreData/SapphireFrappliance/MetaData/Support/SapphireMetaDataScanner.h

    r599 r650  
    1919 */ 
    2020 
    21 #import <Cocoa/Cocoa.h> 
     21#import "SapphireDirectory.h" 
    2222 
    23 #import "SapphireDirectory.h" 
     23@class SapphireDirectoryMetaData; 
    2424 
    2525/*! 
     
    2929 */ 
    3030@interface SapphireMetaDataScanner : NSObject <SapphireMetaDataScannerDelegate> { 
    31         id <SapphireDirectory>                                 metaDir;                       /*!< @brief The scanning directory*/ 
    32         NSMutableArray                                                  *remaining;                     /*!< @brief The reaming objects to scan*/ 
     31        SapphireDirectoryMetaData                              *metaDir;                      /*!< @brief The scanning directory*/ 
     32        NSMutableArray                                                  *remaining;                     /*!< @brief The reaming directories to scan*/ 
    3333        NSMutableArray                                                  *results;                       /*!< @brief The current results of the scan*/ 
    3434        NSMutableSet                                                    *skipDirectories;       /*!< @brief The directories to skip*/ 
    3535        id <SapphireMetaDataScannerDelegate>    delegate;                       /*!< @brief The delegate to inform about the results*/ 
    3636        NSTimer                                                                 *nextFileTimer;         /*!< @brief The timer to get the next file*/ 
     37         
     38        NSMutableArray                                                  *dirs;                          /*!< @brief The list of dirs in this directory*/ 
     39        NSMutableArray                                                  *files;                         /*!< @brief The list of files in this directory*/ 
     40        NSMutableArray                                                  *symDirs;                       /*!< @brief The list of symbolic linked dirs in this directory*/ 
     41        NSMutableArray                                                  *symFiles;                      /*!< @brief The list of symbolic linked files in this directory*/ 
     42        int                                                                             depth;                          /*!< @brief The directory depth of this scanner*/ 
    3743} 
    3844 
     
    4450 * @return The scanner 
    4551 */ 
    46 - (id)initWithDirectoryMetaData:(id <SapphireDirectory>)meta delegate:(id <SapphireMetaDataScannerDelegate>)newDelegate; 
     52- (id)initWithDirectoryMetaData:(SapphireDirectoryMetaData *)meta delegate:(id <SapphireMetaDataScannerDelegate>)newDelegate; 
    4753 
    4854/*! 
     
    5662 
    5763/*! 
     64 * @brief Set the prefetched subdirs/files/etc for this scanner 
     65 * 
     66 * @param subDirs The prefetched dirs contained within this directory 
     67 * @param subFiles The prefetched files contained within this directory 
     68 * @param subSymDirs The prefetched symbolic linked dirs contained within this directory 
     69 * @param subSymFiles The prefetched symbolic linked files contained within this directory 
     70 */ 
     71- (void)setSubDirs:(NSArray *)subDirs files:(NSArray *)subFiles symDirs:(NSArray *)subSymDirs symFiles:(NSArray *)subSymFiles; 
     72 
     73/*! 
    5874 * @brief Sets whether we wish results 
    5975 * 
  • branches/CoreData/SapphireFrappliance/MetaData/Support/SapphireMetaDataScanner.m

    r620 r650  
    2222#import "SapphireMetaData.h" 
    2323#import "SapphireApplianceController.h" 
     24#import "SapphireDirectoryMetaData.h" 
    2425 
    2526@implementation SapphireMetaDataScanner 
    2627 
    27 - (id)initWithDirectoryMetaData:(id <SapphireDirectory>)meta delegate:(id <SapphireMetaDataScannerDelegate>)newDelegate 
     28- (id)initWithDirectoryMetaData:(SapphireDirectoryMetaData *)meta delegate:(id <SapphireMetaDataScannerDelegate>)newDelegate 
    2829{ 
    2930        self = [super init]; 
    3031        if (self != nil) { 
    3132                metaDir = [meta retain]; 
    32                 remaining = [[meta directories] mutableCopy]
    33                 results = [NSMutableArray new]
     33                remaining = nil
     34                results = nil
    3435                delegate = [newDelegate retain]; 
     36                dirs = files = symDirs = symFiles = nil; 
    3537        } 
    3638        return self; 
     
    4446        [skipDirectories release]; 
    4547        [delegate release]; 
     48        [dirs release]; 
     49        [files release]; 
     50        [symDirs release]; 
     51        [symFiles release]; 
    4652        [super dealloc]; 
    4753} 
     
    5561        { 
    5662                /*Remove any in our remaining that are to be skipped*/ 
    57                 NSString *checkPath = [[metaDir metaDataForDirectory:[remaining objectAtIndex:i]] path]; 
     63                NSString *checkPath = [[remaining objectAtIndex:i] path]; 
    5864                if([skipDirectories containsObject:checkPath]) 
    5965                        [remaining removeObjectAtIndex:i]; 
     
    6268                        [skipDirectories addObject:checkPath]; 
    6369        } 
     70} 
     71 
     72- (void)setSubDirs:(NSArray *)subDirs files:(NSArray *)subFiles symDirs:(NSArray *)subSymDirs symFiles:(NSArray *)subSymFiles 
     73{ 
     74        dirs = [subDirs mutableCopy]; 
     75        files = [subFiles mutableCopy]; 
     76        symDirs = [subSymDirs mutableCopy]; 
     77        symFiles = [subSymFiles mutableCopy]; 
     78        [metaDir rescanDirWithExistingDirs:dirs files:files symDirs:symDirs symFiles:symFiles]; 
     79        remaining = [dirs mutableCopy]; 
     80        [remaining addObjectsFromArray:[symDirs valueForKey:@"directory"]]; 
    6481} 
    6582 
     
    7996{ 
    8097        /*Include the files in this dir*/ 
    81         NSEnumerator *fileEnum = [[metaDir files] objectEnumerator]; 
    82         NSString *file = nil; 
    83         while((file = [fileEnum nextObject]) != nil) 
     98        if(results != nil) 
    8499        { 
    85                 SapphireFileMetaData *fileMeta = [metaDir metaDataForFile:file]; 
    86                 if(fileMeta != nil) 
    87                         [results addObject:fileMeta]; 
     100                [results addObjectsFromArray:files]; 
     101                [results addObjectsFromArray:[symFiles valueForKey:@"file"]]; 
    88102        } 
    89103        /*Send results*/ 
    90104        [delegate gotSubFiles:results]; 
    91         if([metaDir delegate] == nil) 
    92                 [metaDir refreshAllObjects]; 
    93105        [self autorelease]; 
    94106} 
     
    142154                { 
    143155                        /*Scan the next directory*/ 
    144                         id <SapphireDirectory> next = [metaDir metaDataForDirectory:[remaining objectAtIndex:0]]; 
     156                        SapphireDirectoryMetaData *next = [remaining objectAtIndex:0]; 
    145157                        /*State whether we care for results*/ 
    146158                        if(results != nil) 
  • branches/CoreData/SapphireFrappliance/MetaDataImporting/SapphireImporterDataMenu.h

    r560 r650  
    119119        int                                                             collectionIndex;                /*!< @brief The current index in the directories*/ 
    120120        NSMutableArray                                  *importItems;                   /*!< @brief The items remaining to import*/ 
     121        NSMutableSet                                    *skipSet;                               /*!< @brief The directories to skip*/ 
    121122        NSTimer                                                 *importTimer;                   /*!< @brief The timer to do the next import (so we don't freeze the UI)*/ 
    122123        float                                                   max;                                    /*!< @brief The max number to import*/ 
  • branches/CoreData/SapphireFrappliance/MetaDataImporting/SapphireImporterDataMenu.m

    r610 r650  
    8282        [moc release]; 
    8383        [collectionDirectories release]; 
     84        [skipSet release]; 
    8485        [importItems release]; 
    8586        [importTimer invalidate]; 
     
    170171                return; 
    171172        } 
    172            SapphireDirectoryMetaData *meta = [collection directory]; 
    173         NSArray *skipCol = [SapphireCollectionDirectory skippedCollectionDirectoriesInContext:moc]; 
    174         NSMutableSet *skipSet = [NSMutableSet setWithSet:[skipCol valueForKeyPath:@"directory.path"]]; 
     173        SapphireDirectoryMetaData *meta = [collection directory]; 
     174        //Prefetch 
     175/*      NSPredicate *fetchPredicate = [NSPredicate predicateWithFormat:@"path BEGINSWITH %@", [[meta path] stringByAppendingString:@"/"]]; 
     176        NSSortDescriptor *sort = [[NSSortDescriptor alloc] initWithKey:@"path" ascending:YES]; 
     177        doSortedFetchRequest(SapphireDirectoryMetaDataName, moc, fetchPredicate, sort); 
     178        doSortedFetchRequest(SapphireFileMetaDataName, moc, fetchPredicate, sort); 
     179        doSortedFetchRequest(SapphireDirectorySymLinkName, moc, fetchPredicate, sort); 
     180        doSortedFetchRequest(SapphireFileSymLinkName, moc, fetchPredicate, sort); 
     181        [sort release];*/ 
     182 
    175183        [meta getSubFileMetasWithDelegate:self skipDirectories:skipSet]; 
    176184        collectionIndex++; 
     
    207215        [collectionDirectories release]; 
    208216        collectionDirectories = [[SapphireCollectionDirectory availableCollectionDirectoriesInContext:moc] retain]; 
     217        NSArray *skipCol = [SapphireCollectionDirectory skippedCollectionDirectoriesInContext:moc]; 
     218        [skipSet release]; 
     219        skipSet = [NSMutableSet setWithSet:[skipCol valueForKeyPath:@"directory.path"]]; 
    209220        [self getItems]; 
    210221} 
     
    348359                        [self setCompletionText]; 
    349360                        [SapphireFrontRowCompat renderScene:[self scene]]; 
     361                         
     362                        NSEnumerator *colEnum = [collectionDirectories objectEnumerator]; 
     363                        SapphireCollectionDirectory *col; 
     364                        while((col = [colEnum nextObject]) != nil) 
     365                                [col.directory refreshAllObjects]; 
    350366                } 
    351367                else