/Users/awniemel/Notepad-SVN/svn/trunk/CatNiP/CatNiP/LocalDataHandler.m

Go to the documentation of this file.

#import "LocalDataHandler.h"

@implementation LocalDataHandler


-(id)init
{
    self = [super init];
    return self;
}

+(void)deleteFile:(NSString *)filepath 

{
    NSFileManager *fileMgr = [NSFileManager defaultManager];
    NSError *error;
    
    if ([fileMgr removeItemAtPath:filepath error:&error] != YES) 
    {
        NSLog(@"Unable to delete file at filepath: %@, error:%@", filepath, error);
    }
    else NSLog(@"Deleted file at filepath: %@", filepath);
}

+(void)deleteFiles:(NSArray *)filepaths 
{
    NSFileManager *fileMgr = [NSFileManager defaultManager];
    NSError *error;
    
    for (NSString *file in filepaths) {
        if ([fileMgr removeItemAtPath:file error:&error] != YES) 
        {
            NSLog(@"Unable to delete file at filepath: %@, error:%@", file, error);
        }
        else NSLog(@"Deleted file at filepath: %@", file);
    }
}

+(void)saveScoresToDefaultFile:(NSMutableArray *)scores 
{
    NSArray *documentDirectories = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
        NSString *documentDirectory = [documentDirectories objectAtIndex:0];
        NSString *filePath = [documentDirectory stringByAppendingPathComponent:@"catnip_local.data"];
    
    NSLog(@"Saving %d scores", [scores count]);
        [NSKeyedArchiver archiveRootObject:scores toFile:filePath];
}

//+(void)saveDictionaryToDefaultFile:(NSMutableDictionary *)dict
//{
//    NSArray *documentDirectories = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
//      NSString *documentDirectory = [documentDirectories objectAtIndex:0];
//      NSString *filePath = [documentDirectory stringByAppendingPathComponent:@"catnip_dictionary.data"];
//    
//    NSLog(@"Saving %d composers and %d compositions", [[dict allKeys] count], [[dict allValues] count]);
//      [NSKeyedArchiver archiveRootObject:dict toFile:filePath];
//}

+(void)savePlaylistsToDefaultFile:(NSMutableArray *)playlists
{
    NSArray *documentDirectories = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
        NSString *documentDirectory = [documentDirectories objectAtIndex:0];
        NSString *filePath = [documentDirectory stringByAppendingPathComponent:@"catnip_playlists.data"];
    NSMutableArray *playlistsToSave = [[NSMutableArray alloc] init];
    
    for (Playlist *p in playlists) 
    {
        Playlist *s = [[Playlist alloc] initWithName:p.name andArray:nil];
        NSMutableArray *a = [[NSMutableArray alloc] init];
        for (LocalScoreData *l in p.scorelist) 
        {
            [a addObject:[NSNumber numberWithInt:l.index]];
        }
        s.scorelist = a;
        [playlistsToSave addObject:s];
        [a release];
        [s release]; 
    }
    
    NSLog(@"Saving %d playlists from original %d", [playlistsToSave count], [playlists count]);
        [NSKeyedArchiver archiveRootObject:playlistsToSave toFile:filePath];
    [playlistsToSave release];
}

+(NSMutableArray *)loadLocalScoresFromDefaultFile 
{
    NSArray *documentDirectories = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
        NSString *documentDirectory = [documentDirectories objectAtIndex:0];
        NSString *filePath = [documentDirectory stringByAppendingPathComponent:@"catnip_local.data"];
    
        NSMutableArray *scores = [NSKeyedUnarchiver unarchiveObjectWithFile:filePath];
        if (!scores)
                scores = [[NSMutableArray alloc] init ];        
    else NSLog(@"Read %d scores from memory", [scores count]);

    return scores;
}

//+(NSMutableDictionary *)loadDictionaryFromDefaultFile 
//{
//    NSArray *documentDirectories = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
//      NSString *documentDirectory = [documentDirectories objectAtIndex:0];
//      NSString *filePath = [documentDirectory stringByAppendingPathComponent:@"catnip_dictionary.data"];
//    
//      NSMutableDictionary *dict = [NSKeyedUnarchiver unarchiveObjectWithFile:filePath];
//      if (!dict)
//              dict = [[NSMutableArray alloc] init ];  
//    else NSLog(@"Read %d composers and %d compositions from memory", [[dict allKeys] count], [[dict allValues] count]);
//    
//    return dict;
//}

+(NSMutableArray *)loadPlaylistsFromDefaultFile:(NSArray *)allScores 
{
    NSArray *documentDirectories = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
        NSString *documentDirectory = [documentDirectories objectAtIndex:0];
        NSString *filePath = [documentDirectory stringByAppendingPathComponent:@"catnip_playlists.data"];
    NSMutableArray *playlists = [NSKeyedUnarchiver unarchiveObjectWithFile:filePath];
        if ([playlists count] == 0) 
    {
        return [[NSMutableArray alloc] init];
    }
    else 
    {
        NSLog(@"Read %d playlists from memory", [playlists count]);
        
        // create temporary dictionary for index - score pairs from allLocalScores
        NSMutableDictionary *tempDict = [[NSMutableDictionary alloc] init];
        for (LocalScoreData *l in allScores) [tempDict setObject:l forKey:[NSNumber numberWithInt:l.index]];
        // create playlist array to be used on application lifetime
        NSMutableArray *playlistsToUse = [[NSMutableArray alloc] init];
        
        // and add all saved index-playlists to it with references to real LocalScoreData objects
        for (Playlist *p in playlists)
        {
            Playlist *s = [[Playlist alloc] initWithName:p.name andArray:nil];
            NSMutableArray *a = [[NSMutableArray alloc] init];
            
            // get LocalScoreDatas in this playlist from allLocalScores as references
            for (NSNumber *n in p.scorelist)
            {
                NSNumber *temp = n;
                if ([tempDict objectForKey:temp] != NULL) 
                {
                    [a addObject:[tempDict objectForKey:temp]];
                }
            }
            
            s.scorelist = a;
            [playlistsToUse addObject:s];
            [s release];
            [a release];
        }
        [tempDict release];
        NSLog(@"Returning %d playlists.", [playlistsToUse count]);
        return playlistsToUse;
    }
}

+(LocalScoreData *)createLocalScoreData:(NSArray *)fileNameParams ofComposition:(CompositionData *)comp
localScores:(NSArray *)scores
{
    ScoreData *thisData; 
    for (int i = 0; i< [comp.musicScores count]; i++) 
    {
        if ([[[comp.musicScores objectAtIndex:i] pdf] compare:[fileNameParams objectAtIndex:0]] == 0) 
        {
            thisData = [comp.musicScores objectAtIndex:i];
        }
    }
    if (thisData == NULL) {
        NSLog(@"Could not find score data for %@", [fileNameParams objectAtIndex:0]);
        return NULL;
    }
    
    LocalScoreData *thisScore = [[LocalScoreData alloc] init];
    thisScore.fullMetaData = thisData.fullMetaData;
    thisScore.metaDataDict = thisData.metaDataDict;
    thisScore.description = thisData.description;
    thisScore.pdf = [fileNameParams objectAtIndex:1];
    thisScore.composer = comp.composerName;
    thisScore.composition = comp.compositionName;
    thisScore.userNotes = @"";
    thisScore.index = [self searchFreeIndexForScore:scores];
    NSLog(@"Giving index %d", thisScore.index);
    
    return thisScore;
}

int int_cmp(const void *a, const void *b) 
{ 
    const int *ia = (const int *)a; // casting pointer types 
    const int *ib = (const int *)b;
    return *ia  - *ib; 
        /* integer comparison: returns negative if b > a 
     and positive if a > b */ 
} 

+(NSInteger)searchFreeIndexForScore:(NSArray *)scores 
{
    if (!scores) return 1;
    if ([scores count] == 0) return 1;
    else {
        /* takes all indeces from local scores and sort them */
        int indeces[[scores count]];
        for (int i = 0; i < [scores count]; i++) 
        {
            indeces[i] = [[scores objectAtIndex:i] index];
        }
        size_t len = sizeof(indeces)/sizeof(int);
        qsort(indeces, len, sizeof(int), int_cmp);
        
        /* return first positive integer which is not assigned to any score. */ 
        int lastIndex = 0;
        for (int i = 0; i < len; i++) 
        {
            if (indeces[i] - lastIndex > 1)
                return lastIndex +1;
            else lastIndex = indeces[i];
        }
        return lastIndex +1;
    }
    return -1;
}

+(NSMutableDictionary *)createComposerDictionary:(NSArray *)scores
{
    NSMutableDictionary *compDict = [[NSMutableDictionary alloc] init];
    for (int i = 0; i < [scores count]; i++) 
    {
        LocalScoreData *score = [scores objectAtIndex:i];
        if ([compDict objectForKey:score.composer] == NULL) 
        {
            NSLog(@"No entry for %@", score.composer);
            CompositionData *entry = [[CompositionData alloc] init];
            entry.composerName = score.composer;
            entry.compositionName = score.composition;
            entry.musicScores = [[NSMutableArray alloc] initWithObjects:score, nil];
            NSMutableArray *entries = [[NSMutableArray alloc] initWithObjects:entry, nil];
            [compDict setObject:entries forKey:score.composer]; 
            [entry release];
            [entries release];
        }
        else 
        {
            NSLog(@"Found entry for %@", score.composer);
            NSMutableArray *entries = [compDict valueForKey:score.composer];
            for (int j = 0; j < [entries count]; j++) 
            {
                CompositionData *entry = [entries objectAtIndex:j];
                
                if ([[entry compositionName] compare:score.composition] == 0) 
                // composition already found, check for possible duplicate score
                {
                    for (int k = 0; k < [[entry musicScores] count]; k++) 
                    {
                        LocalScoreData *s = [[entry musicScores] objectAtIndex:k];
                        if ([s.pdf compare:score.pdf] == 0) break; // score already found, don't add it
                        if (k == [[entry musicScores] count] -1) 
                        {
                            [[entry musicScores] addObject:score];
                        }
                    }
                }
                else 
                {
                    if (j == [entries count] -1) 
                    // create new CompositionData object and add it to entries 
                    {
                        CompositionData *entry = [[CompositionData alloc] init];
                        entry.composerName = score.composer;
                        entry.compositionName = score.composition;
                        entry.musicScores = [[NSMutableArray alloc] initWithObjects:score, nil];
                        [entries addObject:entry];
                        [entry release];
                    }
                }
            }
        }
    }
    return compDict;
}


+(void)removeLocalScoreData:(LocalScoreData *)score fromScoreArray:(NSMutableArray *)sarray
{
    NSMutableArray *scoresToRemove = [[NSMutableArray alloc] init];
    
    for (int i = 0; i < [sarray count]; i++) 
    {
        LocalScoreData *s = [sarray objectAtIndex:i];
        if ([s.pdf compare:score.pdf] == 0) 
        {    
            [scoresToRemove addObject:s];
        }
    }
    NSLog(@"local scores count %d, scores to remove count %d", [sarray count], [scoresToRemove count]);
    [sarray removeObjectsInArray:scoresToRemove];
    NSLog(@"local scores count after removing %d", [sarray count]);
    [scoresToRemove release];
}

+(void)removeLocalScoreData:(LocalScoreData *)score fromDictionary:(NSMutableDictionary *)dict
{
    [score retain];
    NSMutableArray *scoresToRemove = [[NSMutableArray alloc] init];
    NSMutableArray *composersCompositions = [dict objectForKey:score.composer];
    NSMutableArray *compositionsToRemove = [[NSMutableArray alloc] init];
    
    for (int i = 0; i < [composersCompositions count]; i++) 
    {
        CompositionData *c = [composersCompositions objectAtIndex:i];
        if ([c.compositionName compare:score.composition] == 0) 
        {    
            for (LocalScoreData *s in c.musicScores) 
            {
                if ([s.pdf compare:score.pdf] == 0) // remove all scores with same pdf filepath
                {
                    [scoresToRemove addObject:s];
                }
            }
            [c.musicScores removeObjectsInArray:scoresToRemove];
            [scoresToRemove removeAllObjects];
        }
        if ([c.musicScores count] == 0) // if all scores are removed compositionData can be removed also
        {
            NSLog(@"Adding compositionData of %@ - %@ to remove array", c.composerName, c.compositionName);
            [compositionsToRemove addObject:c];
        }    
    }
    [composersCompositions removeObjectsInArray:compositionsToRemove];
    
    if ([composersCompositions count] == 0) // if all compositions from a composer are removed, composer can be removed too
    {
        NSLog(@"Removing composer from dictionary");
        [dict removeObjectForKey:score.composer];
    }
    [scoresToRemove release];
    [compositionsToRemove release];
    [score release];
}

+(void)removeLocalScoreData:(LocalScoreData *)score fromPlaylistArray:(NSMutableArray *)parray
{
    for (int i = 0; i < [parray count]; i++) 
    {
        [LocalDataHandler removeLocalScoreData:score fromScoreArray:[[parray objectAtIndex:i] scorelist]];
    }
}

+(void)removeAndDeleteLocalScoreData:(LocalScoreData*)score fromScoreArray:(NSMutableArray *)sarray andDictionary:(NSMutableDictionary *)dict andPlaylistArray:(NSMutableArray *)parray
{
    [score retain];
    [LocalDataHandler removeLocalScoreData:score fromScoreArray:sarray];
    [LocalDataHandler removeLocalScoreData:score fromDictionary:dict];
    [LocalDataHandler removeLocalScoreData:score fromPlaylistArray:parray];
    [LocalDataHandler deleteFile:score.pdf];
    [score release];
}

+(void)removeScoreDataArray:(NSArray *)sdarray fromScoreArray:(NSMutableArray *)sarray 
{
    for (int i = 0; i < [sdarray count]; i++) 
    {
        LocalScoreData *s = [sdarray objectAtIndex:i];
        [LocalDataHandler removeLocalScoreData:s fromScoreArray:sarray];
    }
}

+(void)removeScoreDataArray:(NSArray *)sdarray fromDictionary:(NSMutableDictionary *)dict
{
    for (int i = 0; i < [sdarray count]; i++) 
    {
        LocalScoreData *s = [sdarray objectAtIndex:i];
        [LocalDataHandler removeLocalScoreData:s fromDictionary:dict];
    }
}

+(void)removeScoreDataArray:(NSArray *)sdarray fromPlaylistArray:(NSMutableArray *)parray 
{
    for (Playlist *p in parray)
    {
        NSMutableArray *scoresToRemove = [[NSMutableArray alloc] init];
        for (LocalScoreData *s in sdarray) 
        {
            for (LocalScoreData *ps in p.scorelist)
            {
                if ([ps.pdf compare:s.pdf] == 0)
                {
                    [scoresToRemove addObject:ps];
                    //NSLog(@"removing %@ from %@", ps.pdf, p.name);
                }
                    
            }
        }
        NSLog(@"removing %d scores from %@", [scoresToRemove count], p.name);
        [p.scorelist removeObjectsInArray:scoresToRemove];
        [scoresToRemove release];
    }
}

+(void)removeAndDeleteScoreDataArray:(NSArray *)sdarray fromScoreArray:(NSMutableArray *)sarray andDictionary:(NSMutableDictionary *)dict andPlaylistArray:(NSMutableArray *)parray
{
    for (LocalScoreData *s in sdarray) 
    {
        [LocalDataHandler removeAndDeleteLocalScoreData:s fromScoreArray:sarray andDictionary:dict andPlaylistArray:parray];
    }
}

+(void)removeCompositionDataArray:(NSArray *)cdarray fromScoreArray:(NSMutableArray *)sarray
{
    for (int i = 0; i < [cdarray count]; i++) 
    {
        CompositionData *cd = [cdarray objectAtIndex:i];
        NSArray *sa = [cd musicScores];
        [LocalDataHandler removeScoreDataArray:sa fromScoreArray:sarray];
    }
}

+(void)removeCompositionDataArray:(NSArray *)cdarray fromDictionary:(NSMutableDictionary *)dict
{
    for (int i = 0; i < [cdarray count]; i++) 
    {
        CompositionData *cd = [cdarray objectAtIndex:i];
        NSArray *sa = [cd musicScores];
        [LocalDataHandler removeScoreDataArray:sa fromDictionary:dict];
    }
}

+(void)removeCompositionDataArray:(NSArray *)cdarray fromPlaylistArray:(NSMutableArray *)parray
{
    for (int i = 0; i < [cdarray count]; i++) 
    {
        CompositionData *cd = [cdarray objectAtIndex:i];
        NSArray *sa = [cd musicScores];
        [LocalDataHandler removeScoreDataArray:sa fromPlaylistArray:parray];
    }
}

+(void)removeAndDeleteCompositionDataArray:(NSArray *)cdarray fromScoreArray:(NSMutableArray *)sarray andDictionary:(NSMutableDictionary *)dict andPlaylistArray:(NSMutableArray *)parray 
{
    [cdarray retain];
    for (int i = 0; i < [cdarray count]; i++) 
    {
        CompositionData *cd = [cdarray objectAtIndex:i]; 
        NSArray *sa = [[NSArray alloc] initWithArray:cd.musicScores copyItems:NO];
        [sa retain];
        [LocalDataHandler removeScoreDataArray:sa fromScoreArray:sarray];
        [LocalDataHandler removeScoreDataArray:sa fromPlaylistArray:parray];
        NSMutableArray *filepaths = [[NSMutableArray alloc] init];
        for (LocalScoreData *s in sa) [filepaths addObject:s.pdf];
        [LocalDataHandler deleteFiles:filepaths];
        [filepaths release];
        [sa release];
    }
    [LocalDataHandler removeCompositionDataArray:cdarray fromDictionary:dict];
    [cdarray release];
}

+(BOOL)scoreArray:(NSArray *)sarray hasScoreWithPdfFileName:(NSString *)filename 
{
    for (LocalScoreData *s in sarray)
    {
       if ([[s.pdf lastPathComponent] compare:filename] == 0)
           return YES;
    }
    return NO;
}

+(BOOL)scoreArray:(NSArray *)sarray hasScoreWithPdfFilePath:(NSString *)filepath 
{
    for (LocalScoreData *s in sarray)
    {
        if ([s.pdf compare:filepath] == 0)
            return YES;
    }
    return NO;
}

+(BOOL)compositionDataArray:(NSArray *)cdarray hasScoreWithPdfInScoreArray:(NSArray *)sarray
{
    for (LocalScoreData *s in sarray)
    {
        NSString *filepath = s.pdf;
        
        for (int i = 0 ; i < [cdarray count] ; i++) 
        {
            CompositionData *cd = [cdarray objectAtIndex:i];
            if ([LocalDataHandler scoreArray:cd.musicScores hasScoreWithPdfFilePath:filepath])
                return YES;
        }
    }
    return NO;
}

@end