OOCacheManager(Private) Category Reference

Instance Methods
(void)	- loadCache
(void)	- write
(void)	- clear
(BOOL)	- dirty
(void)	- markClean
(NSDictionary *)	- loadDict
(BOOL)	- writeDict:
(void)	- buildCachesFromDictionary:
(NSDictionary *)	- dictionaryOfCaches
(BOOL)	- directoryExists:create:
(NSString *)	- cachePathCreatingIfNecessary: [implementation]

Detailed Description

Definition at line 83 of file OOCacheManager.m.

Method Documentation

buildCachesFromDictionary:

- (void) buildCachesFromDictionary:

(NSDictionary *)

inDict

Extends class OOCacheManager.

Definition at line 576 of file OOCacheManager.m.

{
    NSEnumerator                *keyEnum = nil;
    id                          key = nil;
    id                          value = nil;
    NSMutableDictionary         *cache = nil;
    
    if (inDict == nil ) return;
    
    [_caches release];
    _caches = [[NSMutableDictionary alloc] initWithCapacity:[inDict count]];
    
    for (keyEnum = [inDict keyEnumerator]; (key = [keyEnum nextObject]); )
    {
        value = [inDict oo_dictionaryForKey:key];
        if (value != nil)
        {
            cache = [NSMutableDictionary dictionaryWithDictionary:value];
            if (cache != nil)
            {
                [_caches setObject:cache forKey:key];
            }
        }
    }
}
 

References nil.

cachePathCreatingIfNecessary:

- (NSString *) cachePathCreatingIfNecessary: (BOOL) create

implementation

Extends class OOCacheManager.

Definition at line 637 of file OOCacheManager.m.

{
    NSString *cachePath = [self cacheDirectoryPathCreatingIfNecessary:create];
    return [cachePath stringByAppendingPathComponent:@"Data Cache.plist"];
}
 

References OOCacheManager::cacheDirectoryPathCreatingIfNecessary:.

Referenced by loadDict, and writeDict:.

Here is the call graph for this function:

Here is the caller graph for this function:

clear

- (void) clear

Extends class OOCacheManager.

Definition at line 475 of file OOCacheManager.m.

{
    [_caches release];
    _caches = nil;
}
 

References nil.

dictionaryOfCaches

- (NSDictionary *) dictionaryOfCaches

Extends class OOCacheManager.

Definition at line 603 of file OOCacheManager.m.

{
    return [OODeepCopy(_caches) autorelease];
}
 

directoryExists:create:

- (BOOL) directoryExists:		(NSString *)	inPath
create:		(BOOL)	inCreate

Extends class OOCacheManager.

Definition at line 609 of file OOCacheManager.m.

{
    BOOL                exists, directory;
    NSFileManager       *fmgr =  [NSFileManager defaultManager];
    
    exists = [fmgr fileExistsAtPath:inPath isDirectory:&directory];
    
    if (exists && !directory)
    {
        OOLog(kOOLogDataCacheBuildPathError, @"Expected %@ to be a folder, but it is a file.", inPath);
        return NO;
    }
    if (!exists)
    {
        if (!inCreate) return NO;
        if (![fmgr oo_createDirectoryAtPath:inPath attributes:nil])
        {
            OOLog(kOOLogDataCacheBuildPathError, @"Could not create folder %@.", inPath);
            return NO;
        }
    }
    
    return YES;
}
 

References kOOLogDataCacheBuildPathError, nil, and OOLog.

dirty

- (BOOL) dirty

Extends class OOCacheManager.

Definition at line 482 of file OOCacheManager.m.

{
    return _dirty;
}
 

loadCache

- (void) loadCache

Extends class OOCacheManager.

Definition at line 330 of file OOCacheManager.m.

{
    NSDictionary            *cache = nil;
    NSString                *cacheVersion = nil;
    NSString                *ooliteVersion = nil;
    NSData                  *endianTag = nil;
    NSNumber                *formatVersion = nil;
    BOOL                    accept = YES;
    uint64_t                endianTagValue = 0;
    
    ooliteVersion = [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleVersion"];
    
    [self clear];
    
    cache = [self loadDict];
    if (cache != nil)
    {
        // We have a cache
        OOLog(kOOLogDataCacheFound, @"%@", @"Found data cache.");
        OOLogIndentIf(kOOLogDataCacheFound);
        
        cacheVersion = [cache objectForKey:kCacheKeyVersion];
        if (![cacheVersion isEqual:ooliteVersion])
        {
            OOLog(kOOLogDataCacheRebuild, @"Data cache version (%@) does not match Oolite version (%@), rebuilding cache.", cacheVersion, ooliteVersion);
            accept = NO;
        }
        
        formatVersion = [cache objectForKey:kCacheKeyFormatVersion];
        if (accept && [formatVersion unsignedIntValue] != kFormatVersionValue)
        {
            OOLog(kOOLogDataCacheRebuild, @"Data cache format (%@) is not supported format (%u), rebuilding cache.", formatVersion, kFormatVersionValue);
            accept = NO;
        }
        
        if (accept)
        {
            endianTag = [cache objectForKey:kCacheKeyEndianTag];
            if (![endianTag isKindOfClass:[NSData class]] || [endianTag length] != sizeof endianTagValue)
            {
                OOLog(kOOLogDataCacheRebuild, @"%@", @"Data cache endian tag is invalid, rebuilding cache.");
                accept = NO;
            }
            else
            {
                endianTagValue = *(const uint64_t *)[endianTag bytes];
                if (endianTagValue != kEndianTagValue)
                {
                    OOLog(kOOLogDataCacheRebuild, @"%@", @"Data cache endianness is inappropriate for this system, rebuilding cache.");
                    accept = NO;
                }
            }
        }
        
        if (accept)
        {
            // We have a cache, and it's the right format.
            [self buildCachesFromDictionary:[cache objectForKey:kCacheKeyCaches]];
        }
        
        OOLogOutdentIf(kOOLogDataCacheFound);
    }
    else
    {
        // No cache
        OOLog(kOOLogDataCacheNotFound, @"%@", @"No data cache found, starting from scratch.");
    }
    
    // If loading failed, or there was a version or endianness conflict
    if (_caches == nil) _caches = [[NSMutableDictionary alloc] init];
    [self markClean];
}
 

References OOCacheManager::buildCachesFromDictionary:, OOCacheManager::clear, kEndianTagValue, kFormatVersionValue, kOOLogDataCacheFound, kOOLogDataCacheNotFound, kOOLogDataCacheRebuild, OOCacheManager::loadDict, OOCacheManager::markClean, nil, OOLog, OOLogIndentIf, and OOLogOutdentIf.

Here is the call graph for this function:

loadDict

- (NSDictionary *) loadDict

Extends class OOCacheManager.

Definition at line 494 of file OOCacheManager.m.

{
    NSString            *path = nil;
    NSData              *data = nil;
    NSString            *errorString = nil;
    id                  contents = nil;
    
    path = [self cachePathCreatingIfNecessary:NO];
    if (path == nil) return nil;
    
    @try
    {
        data = [NSData dataWithContentsOfFile:path];
        if (data == nil)  return nil;
        
        contents = [NSPropertyListSerialization propertyListFromData:data
                                                    mutabilityOption:NSPropertyListImmutable
                                                              format:NULL
                                                    errorDescription:&errorString];
    }
    @catch (NSException *exception)
    {
        errorString = [exception reason];
        contents = nil;
    }
    
    if (errorString != nil)
    {
        OOLog(@"dataCache.badData", @"Could not read data cache: %@", errorString);
#if OOLITE_RELEASE_PLIST_ERROR_STRINGS
        [errorString release];
#endif
        return nil;
    }
    if (![contents isKindOfClass:[NSDictionary class]])  return nil;
    
    return contents;
}
 

References OOCacheManager::cachePathCreatingIfNecessary:, nil, and OOLog.

Here is the call graph for this function:

markClean

- (void) markClean

Extends class OOCacheManager.

Definition at line 488 of file OOCacheManager.m.

{
    _dirty = NO;
}
 

write

- (void) write

Extends class OOCacheManager.

Definition at line 404 of file OOCacheManager.m.

{
    NSMutableDictionary     *newCache = nil;
    NSString                *ooliteVersion = nil;
    NSData                  *endianTag = nil;
    NSNumber                *formatVersion = nil;
    NSDictionary            *pListRep = nil;
    uint64_t                endianTagValue = kEndianTagValue;
    
    if (_caches == nil) return;
    if (_scheduledWrite != nil)  return;
    
#if PROFILE_WRITES
    OOProfilingStopwatch *stopwatch = [OOProfilingStopwatch stopwatch];
#endif
    
#if WRITE_ASYNC
    OOLog(@"dataCache.willWrite", @"%@", @"Scheduling data cache write.");
#else
    OOLog(@"dataCache.willWrite", @"%@", @"About to write cache.");
#endif
    
    ooliteVersion = [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleVersion"];
    endianTag = [NSData dataWithBytes:&endianTagValue length:sizeof endianTagValue];
    formatVersion = [NSNumber numberWithUnsignedInt:kFormatVersionValue];
    
    pListRep = [self dictionaryOfCaches];
    if (ooliteVersion == nil || endianTag == nil || formatVersion == nil || pListRep == nil)
    {
        OOLog(@"dataCache.cantWrite", @"%@", @"Failed to write data cache -- prerequisites not fulfilled. This is an internal error, please report it.");
        return;
    }
    
    newCache = [NSMutableDictionary dictionaryWithCapacity:4];
    [newCache setObject:ooliteVersion forKey:kCacheKeyVersion];
    [newCache setObject:formatVersion forKey:kCacheKeyFormatVersion];
    [newCache setObject:endianTag forKey:kCacheKeyEndianTag];
    [newCache setObject:pListRep forKey:kCacheKeyCaches];
    
#if PROFILE_WRITES && !WRITE_ASYNC
    OOTimeDelta prepareT = [stopwatch reset];
#endif
    
#if WRITE_ASYNC
    NSDictionary *cacheData = newCache;
    _scheduledWrite = [[OOAsyncCacheWriter alloc] initWithCacheContents:cacheData];
    
#if PROFILE_WRITES
    OOTimeDelta endT = [stopwatch reset];
    OOLog(@"dataCache.profile", @"Time to prepare cache data: %g seconds.", endT);
#endif
    
    [[OOAsyncWorkManager sharedAsyncWorkManager] addTask:_scheduledWrite priority:kOOAsyncPriorityLow];
#else
#if PROFILE_WRITES
    OOLog(@"dataCache.profile", @"Time to prepare cache data: %g seconds.", prepareT);
#endif
    
    if ([self writeDict:newCache])
    {
        [self markClean];
        OOLog(kOOLogDataCacheWriteSuccess, @"%@", @"Wrote data cache.");
    }
    else
    {
        OOLog(kOOLogDataCacheWriteFailed, @"%@", @"Failed to write data cache.");
    }
#endif
}
 

References OOAsyncWorkManager::addTask:priority:, OOCacheManager::dictionaryOfCaches, kEndianTagValue, kOOLogDataCacheWriteFailed, kOOLogDataCacheWriteSuccess, OOCacheManager::markClean, nil, OOLog, OOProfilingStopwatch::reset, OOAsyncWorkManager::sharedAsyncWorkManager, and OOProfilingStopwatch::stopwatch.

Here is the call graph for this function:

writeDict:

- (BOOL) writeDict:

(NSDictionary *)

inDict

Extends class OOCacheManager.

Definition at line 534 of file OOCacheManager.m.

{
    NSString            *path = nil;
    NSData              *plist = nil;
    NSString            *errorDesc = nil;
    
    path = [self cachePathCreatingIfNecessary:YES];
    if (path == nil) return NO;  
    
#if PROFILE_WRITES
    OOProfilingStopwatch *stopwatch = [OOProfilingStopwatch stopwatch];
#endif
    
    plist = [NSPropertyListSerialization dataFromPropertyList:inDict format:CACHE_PLIST_FORMAT errorDescription:&errorDesc];
    if (plist == nil)
    {
#if OOLITE_RELEASE_PLIST_ERROR_STRINGS
        [errorDesc autorelease];
#endif
        OOLog(kOOLogDataCacheSerializationError, @"Could not convert data cache to property list data: %@", errorDesc);
        return NO;
    }
    
#if PROFILE_WRITES
    OOTimeDelta serializeT = [stopwatch reset];
#endif
    
    BOOL result = [plist writeToFile:path atomically:NO];
    
#if PROFILE_WRITES
    OOTimeDelta writeT = [stopwatch reset];
    
    OOLog(@"dataCache.profile", @"Time to serialize cache: %g seconds. Time to write data: %g seconds.", serializeT, writeT);
#endif
    
#if WRITE_ASYNC
    DESTROY(_scheduledWrite);
#endif
    return result;
}
 

References OOCacheManager::cachePathCreatingIfNecessary:, DESTROY, kOOLogDataCacheSerializationError, nil, OOLog, OOProfilingStopwatch::reset, and OOProfilingStopwatch::stopwatch.

Here is the call graph for this function:

---

The documentation for this category was generated from the following file:

• src/Core/OOCacheManager.m