OOCacheManager Class Reference

#include <OOCacheManager.h>

Inheritance diagram for OOCacheManager:

Collaboration diagram for OOCacheManager:

Instance Methods
(id)	- objectForKey:inCache:
(void)	- setObject:forKey:inCache:
(void)	- removeObjectForKey:inCache:
(void)	- clearCache:
(void)	- clearAllCaches
(void)	- reloadAllCaches
(void)	- setAllowCacheWrites:
(NSString *)	- cacheDirectoryPathCreatingIfNecessary:
(void)	- flush
(void)	- finishOngoingFlush
(id)	- init [implementation]
(void)	- dealloc [implementation]
(NSString *)	- description [implementation]
(NSString *)	- cachePathCreatingIfNecessary: [implementation]
(void)	- loadCache [implementation]
(void)	- write [implementation]
(void)	- clear [implementation]
(BOOL)	- dirty [implementation]
(void)	- markClean [implementation]
(NSDictionary *)	- loadDict [implementation]
(BOOL)	- writeDict: [implementation]
(void)	- buildCachesFromDictionary: [implementation]
(NSDictionary *)	- dictionaryOfCaches [implementation]
(BOOL)	- directoryExists:create: [implementation]
(id)	- copyWithZone: [implementation]
(id)	- retain [implementation]
(NSUInteger)	- retainCount [implementation]
(void)	- release [implementation]
(id)	- autorelease [implementation]

Class Methods
(OOCacheManager *)	+ sharedCache
(Octree *)	+ octreeForModel:
(void)	+ setOctree:forModel:
(static void)	+ VFRAddFace [implementation]
(static NSUInteger)	+ VFRGetCount [implementation]
(static NSUInteger)	+ VFRGetFaceAtIndex [implementation]
(NSDictionary *)	+ meshDataForName: [implementation]
(void)	+ setMeshData:forName: [implementation]
(id)	+ allocWithZone: [implementation]

Private Attributes
NSMutableDictionary *	_caches
id	_scheduledWrite
BOOL	_permitWrites
BOOL	_dirty

Detailed Description

Definition at line 35 of file OOCacheManager.h.

Method Documentation

allocWithZone:

+ (id) allocWithZone: (NSZone *) inZone

implementation

Provided by category OOCacheManager(Singleton).

Definition at line 114 of file OOCacheManager.m.

{
    if (sSingleton == nil)
    {
        sSingleton = [super allocWithZone:inZone];
        return sSingleton;
    }
    return nil;
}
 

autorelease

- (id) autorelease

implementation

Provided by category OOCacheManager(Singleton).

Definition at line 114 of file OOCacheManager.m.

{
    return self;
}
 

buildCachesFromDictionary:

- (void) buildCachesFromDictionary: (NSDictionary *) inDict

implementation

Provided by category OOCacheManager(Private).

Definition at line 114 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];
            }
        }
    }
}
 

cacheDirectoryPathCreatingIfNecessary:

- (NSString *) cacheDirectoryPathCreatingIfNecessary:

(BOOL)

create

Definition at line 114 of file OOCacheManager.m.

{
    /*  Construct the path to the directory for cache files, which is:
            ~/Library/Caches/org.aegidian.oolite/
            or
            ~/GNUStep/Library/Caches/org.aegidian.oolite/
        In addition to generally being the right place to put caches,
        ~/Library/Caches has the particular advantage of not being indexed by
        Spotlight or backed up by Time Machine.
    */
    NSString *cachePath = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) objectAtIndex:0];
    if (![self directoryExists:cachePath create:create]) return nil;
 
#if !OOLITE_MAC_OS_X
    // the old cache file on GNUstep was one level up, so remove it if it exists
    [[NSFileManager defaultManager] removeFileAtPath:[cachePath stringByAppendingPathComponent:@"Oolite-cache.plist"] handler:nil];
#endif
 
    cachePath = [cachePath stringByAppendingPathComponent:@"org.aegidian.oolite"];
    if (![self directoryExists:cachePath create:create]) return nil;
    return cachePath;
}
 

cachePathCreatingIfNecessary:

- (NSString *) cachePathCreatingIfNecessary: (BOOL) inCreate

implementation

Provided by category OOCacheManager(Private).

Definition at line 114 of file OOCacheManager.m.

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

clear

- (void) clear

implementation

Provided by category OOCacheManager(Private).

Definition at line 114 of file OOCacheManager.m.

{
    [_caches release];
    _caches = nil;
}
 

clearAllCaches

- (void) clearAllCaches

Definition at line 114 of file OOCacheManager.m.

{
    [self clear];
    _caches = [[NSMutableDictionary alloc] init];
    _dirty = YES;
}
 

clearCache:

- (void) clearCache:

(NSString *)

inCacheKey

Definition at line 114 of file OOCacheManager.m.

{
    NSParameterAssert(inCacheKey != nil);
    
    if (nil != [_caches objectForKey:inCacheKey])
    {
        [_caches removeObjectForKey:inCacheKey];
        _dirty = YES;
        OODebugLog(kOOLogDataCacheClearSuccess, @"Cleared cache \"%@\".", inCacheKey);
    }
    else
    {
        OODebugLog(kOOLogDataCacheClearSuccess, @"No need to clear non-existent cache \"%@\".", inCacheKey);
    }
}
 

copyWithZone:

- (id) copyWithZone: (NSZone *) inZone

implementation

Provided by category OOCacheManager(Singleton).

Definition at line 114 of file OOCacheManager.m.

{
    return self;
}
 

dealloc

- (void) dealloc

implementation

Definition at line 114 of file OOCacheManager.m.

{
    [self clear];
    
    [super dealloc];
}
 

description

- (NSString *) description

implementation

Definition at line 114 of file OOCacheManager.m.

{
    return [NSString stringWithFormat:@"<%@ %p>{dirty=%s}", [self class], self, [self dirty] ? "yes" : "no"];
}
 

dictionaryOfCaches

- (NSDictionary *) dictionaryOfCaches

implementation

Provided by category OOCacheManager(Private).

Definition at line 114 of file OOCacheManager.m.

{
    return [OODeepCopy(_caches) autorelease];
}
 

directoryExists:create:

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

implementation

Provided by category OOCacheManager(Private).

Definition at line 114 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;
}
 

dirty

- (BOOL) dirty

implementation

Provided by category OOCacheManager(Private).

Definition at line 114 of file OOCacheManager.m.

{
    return _dirty;
}
 

finishOngoingFlush

- (void) finishOngoingFlush

Definition at line 114 of file OOCacheManager.m.

{
#if WRITE_ASYNC
    [[OOAsyncWorkManager sharedAsyncWorkManager] waitForTaskToComplete:_scheduledWrite];
#endif
}
 

flush

- (void) flush

Definition at line 114 of file OOCacheManager.m.

{
    if (_permitWrites && [self dirty] && _scheduledWrite == nil)
    {
        [self write];
        [self markClean];
    }
}
 

init

- (id) init

implementation

Definition at line 114 of file OOCacheManager.m.

{
    self = [super init];
    if (self != nil)
    {
        _permitWrites = YES;
        [self loadCache];
    }
    return self;
}
 

loadCache

- (void) loadCache

implementation

Provided by category OOCacheManager(Private).

Definition at line 114 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];
}
 

loadDict

- (NSDictionary *) loadDict

implementation

Provided by category OOCacheManager(Private).

Definition at line 114 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;
}
 

markClean

- (void) markClean

implementation

Provided by category OOCacheManager(Private).

Definition at line 114 of file OOCacheManager.m.

{
    _dirty = NO;
}
 

meshDataForName:

+ (NSDictionary *) meshDataForName: (NSString *) inShipName

implementation

Provided by category OOCacheManager(OOMesh).

Definition at line 1792 of file OOMesh.m.

                                 :(NSString *)inShipName
{
    return [[self sharedCache] objectForKey:inShipName inCache:kOOCacheMeshes];
}

objectForKey:inCache:

- (id) objectForKey:		(NSString *)	inKey
inCache:		(NSString *)	inCacheKey

Definition at line 114 of file OOCacheManager.m.

{
    NSMutableDictionary     *cache = nil;
    id                      result = nil;
    
    NSParameterAssert(inKey != nil && inCacheKey != nil);
    
    cache = [_caches objectForKey:inCacheKey];
    if (cache != nil)
    {
        result = [cache objectForKey:inKey];
        if (result != nil)
        {
            OODebugLog(kOOLogDataCacheRetrieveSuccess, @"Retrieved \"%@\" cache object %@.", inCacheKey, inKey);
        }
        else
        {
            OODebugLog(kOOLogDataCacheRetrieveFailed, @"Failed to retrieve \"%@\" cache object %@ -- no such entry.", inCacheKey, inKey);
        }
    }
    else
    {
        OODebugLog(kOOLogDataCacheRetrieveFailed, @"Failed to retrieve \"%@\" cache object %@ -- no such cache.", inCacheKey, inKey);
    }
    
    return result;
}
 

Referenced by LoadScriptWithName().

Here is the caller graph for this function:

octreeForModel:

+ (Octree *) octreeForModel:

(NSString *)

inKey

Provided by category OOCacheManager(Octree).

Definition at line 1792 of file OOMesh.m.

                          :(NSString *)inKey
{
    NSDictionary        *dict = nil;
    Octree              *result = nil;
    
    if (inKey == nil)  return nil;
    
    dict = [[self sharedCache] objectForKey:inKey inCache:kOOCacheOctrees];
    if (dict != nil)
    {
        result = [[Octree alloc] initWithDictionary:dict];
        [result autorelease];
    }
    
    return result;
}

release

- (void) release

implementation

Provided by category OOCacheManager(Singleton).

Definition at line 114 of file OOCacheManager.m.

{}
 

reloadAllCaches

- (void) reloadAllCaches

Definition at line 114 of file OOCacheManager.m.

{
    [self clear];
    [self loadCache];
}
 

removeObjectForKey:inCache:

- (void) removeObjectForKey:		(NSString *)	inKey
inCache:		(NSString *)	inCacheKey

Definition at line 114 of file OOCacheManager.m.

{
    NSMutableDictionary     *cache = nil;
    
    NSParameterAssert(inKey != nil && inCacheKey != nil);
    
    cache = [_caches objectForKey:inCacheKey];
    if (cache != nil)
    {
        if (nil != [cache objectForKey:inKey])
        {
            [cache removeObjectForKey:inKey];
            _dirty = YES;
            OODebugLog(kOOLogDataCacheRemoveSuccess, @"Removed entry keyed %@ from cache \"%@\".", inKey, inCacheKey);
        }
        else
        {
            OODebugLog(kOOLogDataCacheRemoveSuccess, @"No need to remove non-existent entry keyed %@ from cache \"%@\".", inKey, inCacheKey);
        }
    }
    else
    {
        OODebugLog(kOOLogDataCacheRemoveSuccess, @"No need to remove entry keyed %@ from non-existent cache \"%@\".", inKey, inCacheKey);
    }
}
 

retain

- (id) retain

implementation

Provided by category OOCacheManager(Singleton).

Definition at line 114 of file OOCacheManager.m.

{
    return self;
}
 

retainCount

- (NSUInteger) retainCount

implementation

Provided by category OOCacheManager(Singleton).

Definition at line 114 of file OOCacheManager.m.

{
    return UINT_MAX;
}
 

setAllowCacheWrites:

- (void) setAllowCacheWrites:

(BOOL)

flag

Definition at line 114 of file OOCacheManager.m.

{
    _permitWrites = (flag != NO);
}
 

setMeshData:forName:

+ (void) setMeshData: (NSDictionary *) inData forName: (NSString *) inShipName

implementation

Provided by category OOCacheManager(OOMesh).

Definition at line 1792 of file OOMesh.m.

                   :(NSDictionary *)inData forName:(NSString *)inShipName
{
    if (inData != nil && inShipName != nil)
    {
        [[self sharedCache] setObject:inData forKey:inShipName inCache:kOOCacheMeshes];
    }
}

setObject:forKey:inCache:

- (void) setObject:		(id)	inElement
forKey:		(NSString *)	inKey
inCache:		(NSString *)	inCacheKey

Definition at line 114 of file OOCacheManager.m.

{
    NSMutableDictionary     *cache = nil;
    
    NSParameterAssert(inObject != nil && inKey != nil && inCacheKey != nil);
    
    if (EXPECT_NOT(_caches == nil))  return;
    
    cache = [_caches objectForKey:inCacheKey];
    if (cache == nil)
    {
        cache = [NSMutableDictionary dictionary];
        if (cache == nil)
        {
            OODebugLog(kOOLogDataCacheSetFailed, @"Failed to create cache for key \"%@\".", inCacheKey);
            return;
        }
        [_caches setObject:cache forKey:inCacheKey];
    }
    
    [cache setObject:inObject forKey:inKey];
    _dirty = YES;
    OODebugLog(kOOLogDataCacheSetSuccess, @"Updated entry %@ in cache \"%@\".", inKey, inCacheKey);
}
 

Referenced by LoadScriptWithName().

Here is the caller graph for this function:

setOctree:forModel:

+ (void) setOctree:		(Octree *)	inOctree
forModel:		(NSString *)	inKey

Provided by category OOCacheManager(Octree).

Definition at line 1792 of file OOMesh.m.

                 :(Octree *)inOctree forModel:(NSString *)inKey
{
    if (inOctree != nil && inKey != nil)
    {
        [[self sharedCache] setObject:[inOctree dictionaryRepresentation] forKey:inKey inCache:kOOCacheOctrees];
    }
}

sharedCache

+ (OOCacheManager *) sharedCache

Definition at line 114 of file OOCacheManager.m.

{
    // NOTE: assumes single-threaded access.
    if (sSingleton == nil)
    {
        sSingleton = [[self alloc] init];
    }
    
    return sSingleton;
}
 

Referenced by LoadScriptWithName().

Here is the caller graph for this function:

VFRAddFace

+ (static void) VFRAddFace (VertexFaceRef *) vfr (NSUInteger) index

implementation

Provided by category OOCacheManager(Octree).

Definition at line 2266 of file OOMesh.m.

{
    NSCParameterAssert(vfr != NULL);
    
    if (index < UINT16_MAX && vfr->internCount < kVertexFaceDefInternalCount)
    {
        vfr->internFaces[vfr->internCount++] = index;
    }
    else
    {
        if (vfr->extra == nil)  vfr->extra = [NSMutableArray array];
        [vfr->extra addObject:[NSNumber numberWithInteger:index]];
    }
}

VFRGetCount

+ (static NSUInteger) VFRGetCount (VertexFaceRef *) vfr

implementation

Provided by category OOCacheManager(Octree).

Definition at line 2282 of file OOMesh.m.

{
    NSCParameterAssert(vfr != NULL);
    
    return vfr->internCount + [vfr->extra count];
}

VFRGetFaceAtIndex

+ (static NSUInteger) VFRGetFaceAtIndex (VertexFaceRef *) vfr (NSUInteger) index

implementation

Provided by category OOCacheManager(Octree).

Definition at line 2290 of file OOMesh.m.

{
    NSCParameterAssert(vfr != NULL && index < VFRGetCount(vfr));
    
    if (index < vfr->internCount)  return vfr->internFaces[index];
    else  return [vfr->extra oo_unsignedIntegerAtIndex:index - vfr->internCount];
}

write

- (void) write

implementation

Provided by category OOCacheManager(Private).

Definition at line 114 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
}
 

writeDict:

- (BOOL) writeDict: (NSDictionary *) inDict

implementation

Provided by category OOCacheManager(Private).

Definition at line 114 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;
}
 

Member Data Documentation

_caches

- (NSMutableDictionary*) _caches

private

Definition at line 38 of file OOCacheManager.h.

_dirty

- (BOOL) _dirty

private

Definition at line 41 of file OOCacheManager.h.

_permitWrites

- (BOOL) _permitWrites

private

Definition at line 40 of file OOCacheManager.h.

_scheduledWrite

- (id) _scheduledWrite

private

Definition at line 39 of file OOCacheManager.h.

---

The documentation for this class was generated from the following files:

• src/Core/OOCacheManager.h
• src/Core/OOCacheManager.m