Synnefo » Pithos iOS Client

//

//  Folder.m

//  OpenStack

//

//  Created by Mike Mayo on 12/7/10.

//  The OpenStack project is provided under the Apache 2.0 license.

//

#import "Folder.h"

#import "StorageObject.h"

#import "NSObject+NSCoding.h"

#import "PithosUtilities.h"

@implementation Folder

@synthesize folderObject, parent, objects, folders, objectsAndFoldersCount;

@synthesize name, sharing, contentType, lastModifiedString, metadata;

@synthesize sortedContentsByName, sortedContentsByDate;

#pragma mark - Object lifecycle

- (id)initWithObject:(StorageObject *)anObject {

    if ((self = [super init])) {

        self.folderObject = anObject;

        self.objects = [NSMutableDictionary dictionary];

        self.folders = [NSMutableDictionary dictionary];

    }

    return self;

}

- (id)init {

    StorageObject *anObject = [[[StorageObject alloc] init] autorelease];

    return [self initWithObject:anObject];

}

+ (id)folderWithObject:(StorageObject *)anObject {

    return [[[self alloc] initWithObject:anObject] autorelease];

}

+ (id)folder {

    return [[[self alloc] init] autorelease];

}

- (NSComparisonResult)compareByName:(id)item {

    return [self.name caseInsensitiveCompare:[item name]];

}

- (NSComparisonResult)compareByDate:(id)item {

    return [self.lastModifiedString caseInsensitiveCompare:[item lastModifiedString]];

}

#pragma mark - Serialization

- (id)initWithCoder:(NSCoder *)coder {

    if ((self = [super init])) {

        [self autoDecode:coder];

    }

    return self;

}

- (void)encodeWithCoder:(NSCoder *)coder {

    [self autoEncodeWithCoder:coder];

}

#pragma mark - Memory management

-(void)dealloc {

    [folderObject release];

	[parent release];

	[folders release];

	[objects release];

    [sortedContentsByName release];

    [sortedContentsByDate release];

	[super dealloc];

}

#pragma mark - Properties

- (void)setName:(NSString *)aName {

    self.folderObject.name = aName;

}

- (NSString *)name {

    return self.folderObject.name;

}

- (void)setSharing:(NSString *)aSharing {

    self.folderObject.sharing = aSharing;

}

- (NSString *)sharing {

    return self.folderObject.sharing;

}

- (void)setContentType:(NSString *)aContentType {

    self.folderObject.contentType = aContentType;

}

- (NSString *)contentType {

    return self.folderObject.contentType;

}

- (void)setMetadata:(NSMutableDictionary *)aMetadata {

    self.folderObject.metadata = aMetadata;

}

- (NSMutableDictionary *)metadata {

    return self.folderObject.metadata;

}

- (void)setLastModifiedString:(NSString *)aLastModifiedString {

    self.folderObject.lastModifiedString = aLastModifiedString;

}

- (NSString *)lastModifiedString {

    return self.folderObject.lastModifiedString;

}

- (void)setObjects:(NSMutableDictionary *)objs {

    if (![objects isEqualToDictionary:objs]) {

        [objects release];

        NSMutableDictionary *folderedFiles = [NSMutableDictionary dictionary];

        NSMutableDictionary *files = [NSMutableDictionary dictionary];

        self.folders = [[NSMutableDictionary alloc] init];

        for (NSString *key in objs) {

            StorageObject *object = [objs objectForKey:key];

            BOOL objectHasTrailingSlash = NO;

            if ([object.name hasSuffix:@"/"]) {

                objectHasTrailingSlash = YES;

                object.name = [object.name substringToIndex:(object.name.length - 1)];

            }

            NSRange slashRange = [object.name rangeOfString:@"/"];

            if (slashRange.location != NSNotFound) {

                // build up the folder structure

                NSString *folderName = [object.name substringToIndex:slashRange.location];

                object.name = [object.name substringFromIndex:(slashRange.location + 1)];

                if (objectHasTrailingSlash)

                    object.name = [object.name stringByAppendingString:@"/"];

                if (![folderedFiles objectForKey:folderName]) {

                    [folderedFiles setObject:[NSMutableDictionary dictionary] forKey:folderName];

                }

                NSMutableDictionary *folderFiles = [folderedFiles objectForKey:folderName];

                [folderFiles setObject:object forKey:object.name]; 

            } else if ([PithosUtilities isContentTypeDirectory:object.contentType]) {

                Folder *folder = [Folder folderWithObject:object];

                if (objectHasTrailingSlash)

                    folder.name = [folder.name stringByAppendingString:@"/"];

                folder.parent = self;

                [self.folders setObject:folder forKey:folder.name];

            } else {

                // put the files in this folder 

                if (objectHasTrailingSlash)

                    object.name = [object.name stringByAppendingString:@"/"];

                [files setObject:object forKey:object.name];

            }

        }

        // take the foldered files and recursively build the rest of the folder structure

        for (NSString *folderName in [folderedFiles allKeys]) {

            Folder *folder;

            StorageObject *object = [objs objectForKey:folderName];

            if (object && [PithosUtilities isContentTypeDirectory:object.contentType]) {

                folder = [Folder folderWithObject:object];

            } else {

                folder = [Folder folder];

                folder.name = folderName;

                folder.metadata = [NSMutableDictionary dictionary];

            }

            folder.parent = self;

            folder.objects = [folderedFiles objectForKey:folderName];

            [self.folders setObject:folder forKey:folder.name];

        }

        objects = [files retain];

        [sortedContentsByName release];

        sortedContentsByName = nil;

        [sortedContentsByDate release];

        sortedContentsByDate = nil;

    }

}

- (NSArray *)sortedContentsByName {

    if (!sortedContentsByName) {

        NSMutableArray *contents = [[NSMutableArray alloc] initWithArray:[self.folders allValues]];

        [contents addObjectsFromArray:[self.objects allValues]];

        sortedContentsByName = [[NSArray alloc] initWithArray:[contents sortedArrayUsingSelector:@selector(compareByName:)]];

    }

    return sortedContentsByName;

}

- (NSArray *)sortedContentsByDate {

    if (!sortedContentsByDate) {

        NSMutableArray *contents = [[NSMutableArray alloc] initWithArray:[self.folders allValues]];

        [contents addObjectsFromArray:[self.objects allValues]];

        sortedContentsByDate = [[NSArray alloc] initWithArray:[contents sortedArrayUsingSelector:@selector(compareByDate:)]];

    }

    return sortedContentsByDate;

}

- (NSUInteger)objectsAndFoldersCount {

    return (self.objects.count + self.folders.count);

}

#pragma mark - Actions

- (NSArray *)sortedContentsUsingFilter:(NSString *)filter scope:(NSString *)scope

                              sortType:(NSString *)sortType sortDirection:(NSString *)sortDirection {

    NSArray *sortedContents = nil;

    if ([sortType isEqualToString:@"date"]) {

        sortedContents = self.sortedContentsByDate;

    } else {

        sortedContents = self.sortedContentsByName;

    }

    if ([sortDirection isEqualToString:@"Z-A"]) {

        sortedContents = [[sortedContents reverseObjectEnumerator] allObjects];

    }

    if (!filter || !filter.length) {

        return sortedContents;

    }

    return [sortedContents objectsAtIndexes:

            [[NSIndexSet indexSetWithIndexesInRange:NSMakeRange(0, sortedContents.count)] indexesPassingTest:^(NSUInteger idx, BOOL *stop) {

        id item = [sortedContents objectAtIndex:idx];

        if ([scope isEqualToString:@"name"] || [scope isEqualToString:@"all"]) {

            NSString *itemName = [item name];

            if (itemName) {

                NSUInteger nameLocation = [itemName rangeOfString:filter

                                                          options:NSCaseInsensitiveSearch|NSDiacriticInsensitiveSearch].location;

                if (nameLocation != NSNotFound)

                    return YES;

            }

        }

        if ([scope isEqualToString:@"date"] || [scope isEqualToString:@"all"]) {

            NSString *itemDate = [item lastModifiedString];

            if (itemDate) {

                NSUInteger dateLocation = [itemDate rangeOfString:filter

                                                          options:NSCaseInsensitiveSearch|NSDiacriticInsensitiveSearch].location;

                if (dateLocation != NSNotFound)

                    return YES;

            }

        }

        if ([scope isEqualToString:@"type"] || [scope isEqualToString:@"all"]) {

            NSString *itemType = [item contentType];

            if (itemType) {

                NSUInteger typeLocation = [itemType rangeOfString:filter

                                                          options:NSCaseInsensitiveSearch|NSDiacriticInsensitiveSearch].location;

                if (typeLocation != NSNotFound)

                    return YES;

            }

        }

        // Consider searching additional metadata when the scope is all

        return NO;

    }]];

}

- (NSString *)fullPath {

    if (self.parent) {

        return [[self.parent fullPath] stringByAppendingFormat:@"/%@", self.name];

    } else if (self.name) {

        return self.name;

    } else {

        return @"";

    }

}

- (void)addFolder:(Folder *)aFolder {

    [self.folders setObject:aFolder forKey:aFolder.name];

    [sortedContentsByName release];

    sortedContentsByName = nil;

    [sortedContentsByDate release];

    sortedContentsByDate = nil;

}

- (void)addObject:(StorageObject *)anObject {

    [self.objects setObject:anObject forKey:anObject.name];

    [sortedContentsByName release];

    sortedContentsByName = nil;

    [sortedContentsByDate release];

    sortedContentsByDate = nil;

}

- (void)removeFolder:(Folder *)aFolder {

    if ([self.folders objectForKey:aFolder.name]) {

        [self.folders removeObjectForKey:aFolder.name];

        [sortedContentsByName release];

        sortedContentsByName = nil;

        [sortedContentsByDate release];

        sortedContentsByDate = nil;

    }

}

- (void)removeObject:(StorageObject *)anObject {

    if ([self.objects objectForKey:anObject.name]) {

        [self.objects removeObjectForKey:anObject.name];

        [sortedContentsByName release];

        sortedContentsByName = nil;

        [sortedContentsByDate release];

        sortedContentsByDate = nil;

    }

}

@end