source: branches/CoreData/SapphireFrappliance/MetaData/Support/SapphireBasicDirectoryFunctions.h @ 575

/*
 * SapphireBasicDirectoryFunctions.h
 * Sapphire
 *
 * Created by Graham Booker on Apr. 9, 2008.
 * Copyright 2008 Sapphire Development Team and/or www.nanopi.net
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it under the terms of the GNU
 * General Public License as published by the Free Software Foundation; either version 3 of the License,
 * or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
 * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
 * Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License along with this program; if not,
 * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

/* This file contains functions which are commonly used for all virtual directories.
   It assumes the definition of a few instance variables, which can be set using defines in SapphireBasicDirectoryFunctionsDefines. */

#ifndef RECURSIVE_FUNCTIONS_ALREADY_DEFINED
/*Function to invoke a command on all files in a subtree*/
- (void)invokeRecursivelyOnFiles:(NSInvocation *)fileInv
{
        NSArray *files = [self metaFiles];
        if([files count])
        {
                SapphireFileMetaData *file;
                NSEnumerator *fileEnum = [files objectEnumerator];
                while((file = [fileEnum nextObject]) != nil)
                {
                        [fileInv invokeWithTarget:file];
                }
        }
}

- (BOOL)checkPredicate:(NSComparisonPredicate *)pred
{
        NSPredicate *fetchPred = [self metaFileFetchPredicate];
        if(fetchPred != nil)
        {
                NSPredicate *final = [NSCompoundPredicate andPredicateWithSubpredicates:[NSArray arrayWithObjects:pred, fetchPred, nil]];
                return entityExists(SapphireFileMetaDataName, [self managedObjectContext], final);      
        }
        
        NSArray *files = [self metaFiles];
        int i, count = [files count];
        for(i=0; i<count; i++)
                if([pred evaluateWithObject:[files objectAtIndex:i]])
                        return YES;
        
        NSArray *dirs = [self directories];
        count = [dirs count];
        for(i=0; i<count; i++)
        {
                NSString *dirName = [dirs objectAtIndex:i];
                id <SapphireDirectory> dir = [self metaDataForDirectory:dirName];
                if([pred evaluateWithObject:dir])
                        return YES;
        }
        
        return NO;
}

- (void)getSubFileMetasWithDelegate:(id <SapphireMetaDataScannerDelegate>)subDelegate skipDirectories:(NSMutableSet *)skip
{
}

- (void)scanForNewFilesWithDelegate:(id <SapphireMetaDataScannerDelegate>)subDelegate skipDirectories:(NSMutableSet *)skip
{
}

- (void)cancelImport
{
}

- (void)resumeImport
{
}

#endif

- (BOOL)internalWatchedValue
{
        NSComparisonPredicate *predicate = (NSComparisonPredicate *)[NSPredicate predicateWithFormat:@"watched == NO"];
        BOOL ret = [self checkPredicate:predicate];
        return !ret;    
}

- (BOOL)watchedValue
{
        if(watchedCache != nil)
                return [watchedCache boolValue];
        BOOL ret = [self internalWatchedValue];
        watchedCache = [[NSNumber alloc] initWithBool:ret];
        return ret;
}

- (NSNumber *)watched
{
        if(watchedCache != nil)
                return watchedCache;
        NSNumber *ret = [NSNumber numberWithBool:[self internalWatchedValue]];
        watchedCache = [ret retain];
        return ret;
}

- (void)setWatchedValue:(BOOL)watched
{
        [self setWatched:[NSNumber numberWithBool:watched]];
}

- (void)setWatched:(NSNumber *)watched
{
        SEL select = @selector(setWatched:);
        NSInvocation *inv = [NSInvocation invocationWithMethodSignature:[[SapphireFileMetaData class] instanceMethodSignatureForSelector:select]];
        [inv setSelector:select];
        [inv setArgument:&watched atIndex:2];
        [self invokeRecursivelyOnFiles:inv];
        [SapphireMetaDataSupport save:[self managedObjectContext]];
        [watchedCache release];
        watchedCache = [watched retain];
}

- (BOOL)internalFavoriteValue
{
        NSComparisonPredicate *predicate = (NSComparisonPredicate *)[NSPredicate predicateWithFormat:@"favorite == YES"];
        BOOL ret = [self checkPredicate:predicate];
        return ret;
}

- (BOOL)favoriteValue
{
        if(favoriteCache != nil)
                return [favoriteCache boolValue];
        BOOL ret = [self internalFavoriteValue];
        favoriteCache = [[NSNumber alloc] initWithBool:ret];
        return ret;
}

- (NSNumber *)favorite
{
        if(favoriteCache != nil)
                return favoriteCache;
        NSNumber *ret = [NSNumber numberWithBool:[self internalFavoriteValue]];
        favoriteCache = [ret retain];
        return ret;
}

- (void)setFavoriteValue:(BOOL)favorite
{
        [self setFavorite:[NSNumber numberWithBool:favorite]];
}

- (void)setFavorite:(NSNumber *)favorite
{
        SEL select = @selector(setFavorite:);
        NSInvocation *inv = [NSInvocation invocationWithMethodSignature:[[SapphireFileMetaData class] instanceMethodSignatureForSelector:select]];
        [inv setSelector:select];
        [inv setArgument:&favorite atIndex:2];
        [self invokeRecursivelyOnFiles:inv];
        [SapphireMetaDataSupport save:[self managedObjectContext]];
        [favoriteCache release];
        favoriteCache = [favorite retain];
}

- (void)clearPredicateCache
{
        BOOL report = NO;
        id <SapphireDirectory> myParentDir = [self parentDirectory];
        if(watchedCache != nil)
        {
                BOOL oldWatched = [watchedCache boolValue];
                [watchedCache release];
                watchedCache = nil;
                BOOL doCheck = [myParentDir watched] != nil;
                if(doCheck && [self watchedValue] != oldWatched)
                        report = YES;
        }
        if(favoriteCache != nil)
        {
                BOOL oldFavorite = [favoriteCache boolValue];
                [favoriteCache release];
                favoriteCache = nil;
                BOOL doCheck = !report && [myParentDir watched] != nil;
                if(doCheck && [self favoriteValue] != oldFavorite)
                        report = YES;
        }
        if(report)
                [myParentDir clearPredicateCache];
}

- (void)setFilterPredicate:(NSPredicate *)predicate
{
        [filterPredicate release];
        filterPredicate = [predicate retain];
        [self clearPredicateCache];
}

- (NSPredicate *)filterPredicate
{
        return filterPredicate;
}

- (id <SapphireMetaDataDelegate>)delegate
{
        return delegate;
}

- (void)setDelegate:(id <SapphireMetaDataDelegate>)newDelegate
{
        [newDelegate retain];
        [delegate release];
        delegate = newDelegate;
        if(delegate == nil)
                [self refreshAllObjects];
}

- (NSMutableDictionary *)getDisplayedMetaDataInOrder:(NSArray * *)order;
{
        if(order != nil)
                *order = nil;
        return [NSMutableDictionary dictionaryWithObjectsAndKeys:
                        [[self path] lastPathComponent], META_TITLE_KEY,
                        nil];
}

- (void)setToReimportFromMask:(int)mask
{
        SEL select = @selector(setToReimportFromMask:);
        NSInvocation *inv = [NSInvocation invocationWithMethodSignature:[[SapphireFileMetaData class] instanceMethodSignatureForSelector:select]];
        [inv setSelector:select];
        NSNumber *num = [NSNumber numberWithInt:mask];
        [inv setArgument:&num atIndex:2];
        [self invokeRecursivelyOnFiles:inv];
        [SapphireMetaDataSupport save:[self managedObjectContext]];
}

- (void)clearMetaData
{
        SEL select = @selector(clearMetaData);
        NSInvocation *inv = [NSInvocation invocationWithMethodSignature:[[SapphireFileMetaData class] instanceMethodSignatureForSelector:select]];
        [inv setSelector:select];
        [self invokeRecursivelyOnFiles:inv];
        [SapphireMetaDataSupport save:[self managedObjectContext]];
}