ResourceManager Class Reference

#include <ResourceManager.h>

Inheritance diagram for ResourceManager:

Collaboration diagram for ResourceManager:

Class Methods
(void)	+ reset
(void)	+ resetManifestKnowledgeForOXZManager
(NSArray *)	+ rootPaths
(NSArray *)	+ userRootPaths
(NSString *)	+ builtInPath
(NSArray *)	+ pathsWithAddOns
(NSArray *)	+ paths
(NSArray *)	+ maskUserNameInPathArray:
(NSString *)	+ maskUserName:inPath:
(NSString *)	+ useAddOns
(NSArray *)	+ OXPsWithMessagesFound
(void)	+ setUseAddOns:
(void)	+ addExternalPath:
(NSEnumerator *)	+ pathEnumerator
(NSEnumerator *)	+ reversePathEnumerator
(NSDictionary *)	+ manifestForIdentifier:
(BOOL)	+ checkVersionCompatibility:forOXP:
(BOOL)	+ manifestHasConflicts:logErrors:
(BOOL)	+ manifestHasMissingDependencies:logErrors:
(BOOL)	+ manifest:HasUnmetDependency:logErrors:
(BOOL)	+ matchVersions:withVersion:
(void)	+ handleEquipmentListMerging:forLookupIndex:
(void)	+ handleEquipmentOverrides:
(void)	+ handleStarNebulaListMerging:
(NSString *)	+ errors
(NSString *)	+ pathForFileNamed:inFolder:
(NSString *)	+ pathForFileNamed:inFolder:cache:
(BOOL)	+ corePlist:excludedAt:
(NSDictionary *)	+ dictionaryFromFilesNamed:inFolder:andMerge:
(NSDictionary *)	+ dictionaryFromFilesNamed:inFolder:mergeMode:cache:
(NSArray *)	+ arrayFromFilesNamed:inFolder:andMerge:
(NSArray *)	+ arrayFromFilesNamed:inFolder:andMerge:cache:
(NSDictionary *)	+ whitelistDictionary
(NSDictionary *)	+ shaderBindingTypesDictionary
(NSDictionary *)	+ logControlDictionary
(NSDictionary *)	+ roleCategoriesDictionary
(OOSystemDescriptionManager *)	+ systemDescriptionManager
(OOSound *)	+ ooSoundNamed:inFolder:
(OOMusic *)	+ ooMusicNamed:inFolder:
(NSString *)	+ stringFromFilesNamed:inFolder:
(NSString *)	+ stringFromFilesNamed:inFolder:cache:
(NSDictionary *)	+ loadScripts
(BOOL)	+ writeDiagnosticData:toFileNamed:
(BOOL)	+ writeDiagnosticString:toFileNamed:
(BOOL)	+ writeDiagnosticPList:toFileNamed:
(NSString *)	+ diagnosticFileLocation
(NSDictionary *)	+ materialDefaults
(void)	+ clearCaches
(void)	+ preloadFileLists [implementation]
(void)	+ preloadFileListFromOXZ:forFolders: [implementation]
(void)	+ preloadFileListFromFolder:forFolders: [implementation]
(void)	+ preloadFilePathFor:inFolder:atPath: [implementation]
(void)	+ checkOXPMessagesInPath: [implementation]
(void)	+ checkPotentialPath:path: [implementation]
(BOOL)	+ validateManifest:forOXP: [implementation]
(BOOL)	+ areRequirementsFulfilled:forOXP:andFile: [implementation]
(void)	+ filterSearchPathsForConflicts: [implementation]
(BOOL)	+ filterSearchPathsForRequirements: [implementation]
(void)	+ filterSearchPathsToExcludeScenarioOnlyPaths: [implementation]
(void)	+ filterSearchPathsByScenario: [implementation]
(BOOL)	+ manifestAllowedByScenario: [implementation]
(BOOL)	+ manifestAllowedByScenario:withIdentifier: [implementation]
(BOOL)	+ manifestAllowedByScenario:withTag: [implementation]
(void)	+ addErrorWithKey:param1:param2: [implementation]
(BOOL)	+ checkCacheUpToDateForPaths: [implementation]
(static NSString *)	+ LogClassKeyRoot [implementation]
(void)	+ mergeRoleCategories:intoDictionary: [implementation]
(id)	+ retrieveFileNamed:inFolder:cache:key:class:usePathCache: [implementation]
(BOOL)	+ directoryExists:create: [implementation]
(void)	+ logPaths [implementation]

Detailed Description

Definition at line 55 of file ResourceManager.h.

Method Documentation

addErrorWithKey:param1:param2:

+ (void) addErrorWithKey: (NSString *) descriptionKey param1: (id) param1 param2: (id) param2

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 1133 of file ResourceManager.m.

                        :(NSString *)descriptionKey param1:(id)param1 param2:(id)param2
{
    if (descriptionKey != nil)
    {
        if (sErrors == nil)  sErrors = [[NSMutableArray alloc] init];
        [sErrors addObject:[NSArray arrayWithObjects:descriptionKey, param1 ?: (id)@"", param2 ?: (id)@"", nil]];
    }
}

References nil, and sErrors.

Referenced by checkPotentialPath:path:, manifest:HasUnmetDependency:logErrors:, manifestHasConflicts:logErrors:, and validateManifest:forOXP:.

Here is the caller graph for this function:

addExternalPath:

+ (void) addExternalPath:

(NSString *)

fileName

Definition at line 546 of file ResourceManager.m.

                        :(NSString *)path
{
    if (sSearchPaths == nil)  sSearchPaths = [[NSMutableArray alloc] init];
    if (![sSearchPaths containsObject:path])
    {
        [sSearchPaths addObject:path];
        
        if (sExternalPaths == nil)  sExternalPaths = [[NSMutableArray alloc] init];
        [sExternalPaths addObject:path];
    }
}

References nil, sExternalPaths, and sSearchPaths.

Referenced by GameController::applicationDidFinishLaunching:.

Here is the caller graph for this function:

areRequirementsFulfilled:forOXP:andFile:

+ (BOOL) areRequirementsFulfilled: (NSDictionary*) requirements forOXP: (NSString *) path andFile: (NSString *) file

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 742 of file ResourceManager.m.

                                 :(NSDictionary*)requirements forOXP:(NSString *)path andFile:(NSString *)file
{
    BOOL                OK = YES;
    NSString            *requiredVersion = nil;
    NSString            *maxVersion = nil;
    unsigned            conditionsHandled = 0;
    static NSArray      *ooVersionComponents = nil;
    NSArray             *oxpVersionComponents = nil;
    
    if (requirements == nil)  return YES;
    
    if (ooVersionComponents == nil)
    {
        ooVersionComponents = ComponentsFromVersionString([[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleVersion"]);
        [ooVersionComponents retain];
    }
    
    // Check "version" (minimum version)
    if (OK)
    {
        // Not oo_stringForKey:, because we need to be able to complain about non-strings.
        requiredVersion = [requirements objectForKey:@"version"];
        if (requiredVersion != nil)
        {
            ++conditionsHandled;
            if ([requiredVersion isKindOfClass:[NSString class]])
            {
                oxpVersionComponents = ComponentsFromVersionString(requiredVersion);
                if (NSOrderedAscending == CompareVersions(ooVersionComponents, oxpVersionComponents))  OK = NO;
            }
            else
            {
                OOLog(@"requirements.wrongType", @"Expected %@ entry \"%@\" to be string, but got %@ in OXP %@.", file, @"version", [requirements class], [path lastPathComponent]);
                OK = NO;
            }
        }
    }
    
    // Check "max_version" (minimum max_version)
    if (OK)
    {
        // Not oo_stringForKey:, because we need to be able to complain about non-strings.
        maxVersion = [requirements objectForKey:@"max_version"];
        if (maxVersion != nil)
        {
            ++conditionsHandled;
            if ([maxVersion isKindOfClass:[NSString class]])
            {
                oxpVersionComponents = ComponentsFromVersionString(maxVersion);
                if (NSOrderedDescending == CompareVersions(ooVersionComponents, oxpVersionComponents))  OK = NO;
            }
            else
            {
                OOLog(@"requirements.wrongType", @"Expected %@ entry \"%@\" to be string, but got %@ in OXP %@.", file, @"max_version", [requirements class], [path lastPathComponent]);
                OK = NO;
            }
        }
    }
    
    if (OK && conditionsHandled < [requirements count])
    {
        // There are unknown requirement keys - don't support. NOTE: this check was not made pre 1.69!
        OOLog(@"requirements.unknown", @"requires.plist for OXP %@ contains unknown keys, rejecting.", [path lastPathComponent]);
        OK = NO;
    }
    
    return OK;
}

References CompareVersions(), ComponentsFromVersionString(), count, nil, and OOLog.

Referenced by checkPotentialPath:path:, and checkVersionCompatibility:forOXP:.

Here is the call graph for this function:

Here is the caller graph for this function:

arrayFromFilesNamed:inFolder:andMerge:

+ (NSArray *) arrayFromFilesNamed:		(NSString *)	fileName
inFolder:		(NSString *)	folderName
andMerge:		(BOOL)	mergeFiles

Definition at line 1361 of file ResourceManager.m.

                                 :(NSString *)fileName inFolder:(NSString *)folderName andMerge:(BOOL) mergeFiles
{
    return [self arrayFromFilesNamed:fileName inFolder:folderName andMerge:mergeFiles cache:YES];
}

References arrayFromFilesNamed:inFolder:andMerge:cache:.

Referenced by OOProbabilisticTextureManager::initWithPListName:options:anisotropy:lodBias:seed:, Universe(OOPrivate)::loadScenarios, roleCategoriesDictionary, OODebugController::setUpLogMessageClassMenu, and Universe::setUpSettings.

Here is the call graph for this function:

Here is the caller graph for this function:

arrayFromFilesNamed:inFolder:andMerge:cache:

+ (NSArray *) arrayFromFilesNamed:		(NSString *)	fileName
inFolder:		(NSString *)	folderName
andMerge:		(BOOL)	mergeFiles
cache:		(BOOL)	useCache

Definition at line 1367 of file ResourceManager.m.

                                 :(NSString *)fileName inFolder:(NSString *)folderName andMerge:(BOOL) mergeFiles cache:(BOOL)useCache
{
    id              result = nil;
    NSMutableArray  *results = nil;
    NSString        *cacheKey = nil;
    OOCacheManager  *cache = [OOCacheManager sharedCache];
    NSEnumerator    *enumerator = nil;
    NSString        *path = nil;
    NSString        *arrayPath = nil;
    NSMutableArray  *array = nil;
    NSArray         *arrayNonEditable = nil;
    
    if (fileName == nil)  return nil;
    
    if (useCache)
    {
        cacheKey = [NSString stringWithFormat:@"%@%@ merge:%@", (folderName != nil) ? [folderName stringByAppendingString:@"/"] : (NSString *)@"", fileName, mergeFiles ? @"yes" : @"no"];
        result = [cache objectForKey:cacheKey inCache:@"arrays"];
        if (result != nil)  return result;
    }
    
    if (!mergeFiles)
    {
        // Find "last" matching array
        for (enumerator = [ResourceManager reversePathEnumerator]; (path = [enumerator nextObject]); )
        {
            if (folderName != nil)
            {
                arrayPath = [[path stringByAppendingPathComponent:folderName] stringByAppendingPathComponent:fileName];
                arrayNonEditable = OOArrayFromFile(arrayPath);
                if (arrayNonEditable != nil)  break;
            }
            arrayPath = [path stringByAppendingPathComponent:fileName];
            arrayNonEditable = OOArrayFromFile(arrayPath);
            if (arrayNonEditable != nil)  break;
        }
        result = arrayNonEditable;
    }
    else
    {
        // Find all matching arrays
        results = [NSMutableArray array];
        for (enumerator = [ResourceManager pathEnumerator]; (path = [enumerator nextObject]); )
        {
            if ([ResourceManager corePlist:fileName excludedAt:path])
            {
                continue;
            }
 
            arrayPath = [path stringByAppendingPathComponent:fileName];
            array = [[OOArrayFromFile(arrayPath) mutableCopy] autorelease];
            if (array != nil) [results addObject:array];
    
            // Special handling for arrays merging. Currently, only equipment.plist, nebulatextures.plist and 
            // startextures.plist gets their objects merged.
            // A lookup index is required. For the equipment.plist items, this is the index corresponding to the
            // EQ_* string, which describes the role of an equipment item and is unique.
            // For nebula and star textures, this is the texture filename, although it can be overridden with a 
            // "key" property
            if ([array count] != 0 && ([[fileName lowercaseString] isEqualToString:@"nebulatextures.plist"] || 
                [[fileName lowercaseString] isEqualToString:@"startextures.plist"]))
                [self handleStarNebulaListMerging:results];
 
            if ([array count] != 0 && [[array objectAtIndex:0] isKindOfClass:[NSArray class]])
            {
                if ([[fileName lowercaseString] isEqualToString:@"equipment.plist"])
                    [self handleEquipmentListMerging:results forLookupIndex:3]; // Index 3 is the role string (EQ_*).
            }
            if (folderName != nil)
            {
                arrayPath = [[path stringByAppendingPathComponent:folderName] stringByAppendingPathComponent:fileName];
                array = [[OOArrayFromFile(arrayPath) mutableCopy] autorelease];
                if (array != nil)  [results addObject:array];
 
                if ([array count] != 0 && ([[fileName lowercaseString] isEqualToString:@"nebulatextures.plist"] || 
                    [[fileName lowercaseString] isEqualToString:@"startextures.plist"]))
                    [self handleStarNebulaListMerging:results];
 
                if ([array count] != 0 && [[array objectAtIndex:0] isKindOfClass:[NSArray class]])
                {
                    if ([[fileName lowercaseString] isEqualToString:@"equipment.plist"])
                        [self handleEquipmentListMerging:results forLookupIndex:3]; // Index 3 is the role string (EQ_*).
                }
            }
        }
        
        if ([results count] == 0)  return nil;
        
        // Merge result
        result = [NSMutableArray array];
        
        for (enumerator = [results objectEnumerator]; (array = [enumerator nextObject]); )
        {
            [result addObjectsFromArray:array];
        }
        // if we're doing equipment.plist, do equipment overrides now, while the array is still mutable
        if ([[fileName lowercaseString] isEqualToString:@"equipment.plist"]) 
        {
            [self handleEquipmentOverrides:result];
        }
        result = [[result copy] autorelease];   // Make immutable
    }
    
    if (useCache && result != nil)  [cache setObject:result forKey:cacheKey inCache:@"arrays"];
    
    return [NSArray arrayWithArray:result];
}

References count, handleEquipmentListMerging:forLookupIndex:, handleEquipmentOverrides:, handleStarNebulaListMerging:, nil, OOCacheManager::objectForKey:inCache:, OOArrayFromFile(), pathEnumerator, reversePathEnumerator, OOCacheManager::setObject:forKey:inCache:, and OOCacheManager::sharedCache.

Referenced by arrayFromFilesNamed:inFolder:andMerge:, OOShipRegistry(OODataLoader)::loadDemoShipConditions, and OOShipRegistry(OODataLoader)::loadDemoShips.

Here is the call graph for this function:

Here is the caller graph for this function:

builtInPath

+ (NSString *) builtInPath

Definition at line 205 of file ResourceManager.m.

{
#if OOLITE_WINDOWS
    /*  [[NSBundle mainBundle] resourcePath] causes complaints under Windows,
        because we don't have a properly-built bundle.
    */
    return @"Resources";
#else
    return [[NSBundle mainBundle] resourcePath];
#endif
}

References builtInPath.

Referenced by builtInPath, corePlist:excludedAt:, Universe::descriptions, OOOXPVerifier(OOPrivate)::initWithPath:, LoadExplicitSettings(), logControlDictionary, pathsWithAddOns, rootPaths, shaderBindingTypesDictionary, and whitelistDictionary.

Here is the call graph for this function:

Here is the caller graph for this function:

checkCacheUpToDateForPaths:

+ (BOOL) checkCacheUpToDateForPaths: (NSArray *) searchPaths

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 1143 of file ResourceManager.m.

                                  :(NSArray *)searchPaths
{
    /*  Check if caches are up to date.
        The strategy is to use a two-entry cache. One entry is an array
        containing the search paths, the other an array of modification dates
        (in the same order). If either fails to match the correct settings,
        we delete both.
    */
    OOCacheManager      *cacheMgr = [OOCacheManager sharedCache];
    NSFileManager       *fmgr = [NSFileManager defaultManager];
    BOOL                upToDate = YES;
    id                  oldPaths = nil;
    NSMutableArray      *modDates = nil;
    NSEnumerator        *pathEnum = nil;
    NSString            *path = nil;
    id                  modDate = nil;
    
    if (EXPECT_NOT([[NSUserDefaults standardUserDefaults] boolForKey:@"always-flush-cache"]))
    {
        OOLog(kOOLogCacheExplicitFlush, @"%@", @"Cache explicitly flushed with always-flush-cache preference. Rebuilding from scratch.");
        upToDate = NO;
    }
    else if ([MyOpenGLView pollShiftKey])
    {
        OOLog(kOOLogCacheExplicitFlush, @"%@", @"Cache explicitly flushed with shift key. Rebuilding from scratch.");
        upToDate = NO;
    }
    
    oldPaths = [cacheMgr objectForKey:kOOCacheKeySearchPaths inCache:kOOCacheSearchPathModDates];
    if (upToDate && ![oldPaths isEqual:searchPaths])
    {
        // OXPs added/removed
        if (oldPaths != nil) OOLog(kOOLogCacheStalePaths, @"%@", @"Cache is stale (search paths have changed). Rebuilding from scratch.");
        upToDate = NO;
    }
    
    // Build modification date list. (We need this regardless of whether the search paths matched.)
    
    modDates = [NSMutableArray arrayWithCapacity:[searchPaths count]];
    for (pathEnum = [searchPaths objectEnumerator]; (path = [pathEnum nextObject]); )
    {
        modDate = [[fmgr oo_fileAttributesAtPath:path traverseLink:YES] objectForKey:NSFileModificationDate];
        if (modDate != nil)
        {
            // Converts to double because I'm not sure the cache can deal with dates under GNUstep.
            modDate = [NSNumber numberWithDouble:[modDate timeIntervalSince1970]];
            [modDates addObject:modDate];
        }
    }
        
    if (upToDate && ![[cacheMgr objectForKey:kOOCacheKeyModificationDates inCache:kOOCacheSearchPathModDates] isEqual:modDates])
    {
        OOLog(kOOLogCacheStaleDates, @"%@", @"Cache is stale (modification dates have changed). Rebuilding from scratch.");
        upToDate = NO;
    }
    
    if (!upToDate)
    {
        [cacheMgr clearAllCaches];
        [cacheMgr setObject:searchPaths forKey:kOOCacheKeySearchPaths inCache:kOOCacheSearchPathModDates];
        [cacheMgr setObject:modDates forKey:kOOCacheKeyModificationDates inCache:kOOCacheSearchPathModDates];
    }
    else OOLog(kOOLogCacheUpToDate, @"%@", @"Data cache is up to date.");
 
    return upToDate;
}

References OOCacheManager::clearAllCaches, EXPECT_NOT, kOOCacheKeyModificationDates, kOOCacheSearchPathModDates, kOOLogCacheExplicitFlush, kOOLogCacheStaleDates, kOOLogCacheStalePaths, kOOLogCacheUpToDate, nil, OOCacheManager::objectForKey:inCache:, OOLog, OOCacheManager::setObject:forKey:inCache:, and OOCacheManager::sharedCache.

Referenced by pathsWithAddOns, and setUseAddOns:.

Here is the call graph for this function:

Here is the caller graph for this function:

checkOXPMessagesInPath:

+ (void) checkOXPMessagesInPath: (NSString *) path

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 583 of file ResourceManager.m.

                               :(NSString *)path
{
    NSArray *OXPMessageArray = OOArrayFromFile([path stringByAppendingPathComponent:@"OXPMessages.plist"]);
    
    if ([OXPMessageArray count] > 0)
    {
        unsigned i;
        for (i = 0; i < [OXPMessageArray count]; i++)
        {
            NSString *oxpMessage = [OXPMessageArray oo_stringAtIndex:i];
            if (oxpMessage)
            {
                OOLog(@"oxp.message", @"%@: %@", path, oxpMessage);
            }
        }
        if (sOXPsWithMessagesFound == nil)  sOXPsWithMessagesFound = [[NSMutableArray alloc] init];
        [sOXPsWithMessagesFound addObject:[path lastPathComponent]];
    }
}

References count, nil, OOArrayFromFile(), OOLog, and sOXPsWithMessagesFound.

Referenced by pathsWithAddOns.

Here is the call graph for this function:

Here is the caller graph for this function:

checkPotentialPath:path:

+ (void) checkPotentialPath: (NSString *) path: (NSMutableArray *) searchPaths

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 605 of file ResourceManager.m.

                          :(NSString *)path :(NSMutableArray *)searchPaths
{
    NSDictionary            *requirements = nil;
    NSDictionary            *manifest = nil;
    BOOL                    requirementsMet = YES;
 
    if (![[[path pathExtension] lowercaseString] isEqualToString:@"oxz"])
    {
        // OXZ format ignores requires.plist
        requirements = OODictionaryFromFile([path stringByAppendingPathComponent:@"requires.plist"]);
        requirementsMet = [self areRequirementsFulfilled:requirements forOXP:path andFile:@"requires.plist"];
    }
    if (!requirementsMet)
    {
        NSString *version = [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleVersion"];
        OOLog(@"oxp.versionMismatch", @"OXP %@ is incompatible with version %@ of Oolite.", path, version);
        [self addErrorWithKey:@"oxp-is-incompatible" param1:[path lastPathComponent] param2:version];
        return;
    }
    
    manifest = OODictionaryFromFile([path stringByAppendingPathComponent:@"manifest.plist"]);
    if (manifest == nil)
    {
        if ([[[path pathExtension] lowercaseString] isEqualToString:@"oxz"])
        {
            OOLog(@"oxp.noManifest", @"OXZ %@ has no manifest.plist", path);
            [self addErrorWithKey:@"oxz-lacks-manifest" param1:[path lastPathComponent] param2:nil];
            return;
        }
        else
        {
            if ([[[path pathExtension] lowercaseString] isEqualToString:@"oxp"])
            {
                OOStandardsError([NSString stringWithFormat:@"OXP %@ has no manifest.plist", path]);
                if (OOEnforceStandards())
                {
                    [self addErrorWithKey:@"oxp-lacks-manifest" param1:[path lastPathComponent] param2:nil];
                    return;
                }
            }
            // make up a basic manifest in relaxed mode or for base folders
            manifest = [NSDictionary dictionaryWithObjectsAndKeys:[NSString stringWithFormat:@"__oolite.tmp.%@",path],kOOManifestIdentifier,@"1",kOOManifestVersion,@"OXP without manifest",kOOManifestTitle,@"1",kOOManifestRequiredOoliteVersion,nil];
        }
    }
    
    requirementsMet = [self validateManifest:manifest forOXP:path];
 
 
    if (requirementsMet) 
    {
        [searchPaths addObject:path];
    }
}

References addErrorWithKey:param1:param2:, areRequirementsFulfilled:forOXP:andFile:, nil, OODictionaryFromFile(), OOEnforceStandards(), OOLog, OOStandardsError(), and validateManifest:forOXP:.

Referenced by pathsWithAddOns.

Here is the call graph for this function:

Here is the caller graph for this function:

checkVersionCompatibility:forOXP:

+ (BOOL) checkVersionCompatibility:		(NSDictionary *)	manifest
forOXP:		(NSString *)	title

Definition at line 726 of file ResourceManager.m.

                                  :(NSDictionary *)manifest forOXP:(NSString *)title
{
    NSString    *required = [manifest oo_stringForKey:kOOManifestRequiredOoliteVersion defaultValue:nil];
    NSString *maxRequired = [manifest oo_stringForKey:kOOManifestMaximumOoliteVersion defaultValue:nil];
    // ignore empty max version string rather than treating as "version 0"
    if (maxRequired == nil || [maxRequired length] == 0)
    {
        return [self areRequirementsFulfilled:[NSDictionary dictionaryWithObjectsAndKeys:required, @"version", nil] forOXP:title andFile:@"manifest.plist"];
    }
    else
    {
        return [self areRequirementsFulfilled:[NSDictionary dictionaryWithObjectsAndKeys:required, @"version", maxRequired, @"max_version", nil] forOXP:title andFile:@"manifest.plist"];
    }
}

References areRequirementsFulfilled:forOXP:andFile:, and nil.

Referenced by validateManifest:forOXP:.

Here is the call graph for this function:

Here is the caller graph for this function:

clearCaches

+ (void) clearCaches

Definition at line 2268 of file ResourceManager.m.

{
    [sSoundCache release];
    sSoundCache = nil;
    [sStringCache release];
    sStringCache = nil;
}

References clearCaches, nil, sSoundCache, and sStringCache.

Referenced by clearCaches, OOOXZManager::gui, and setUseAddOns:.

Here is the call graph for this function:

Here is the caller graph for this function:

corePlist:excludedAt:

+ (BOOL) corePlist:		(NSString *)	fileName
excludedAt:		(NSString *)	path

Definition at line 1219 of file ResourceManager.m.

                  :(NSString *)fileName excludedAt:(NSString *)path
{
    if (![path isEqualToString:[self builtInPath]])
    {
        // non-core paths always okay
        return NO;
    }
    NSString *uaoBit = nil;
    foreach (uaoBit, sUseAddOnsParts)
    {
        if ([uaoBit hasPrefix:SCENARIO_OXP_DEFINITION_NOPLIST])
        {
            NSString *plist = [uaoBit substringFromIndex:[SCENARIO_OXP_DEFINITION_NOPLIST length]];
            if ([plist isEqualToString:fileName])
            {
                // this core plist file should not be loaded at all
                return YES;
            }
        }
    }
    // then not excluded
    return NO;
}

References builtInPath, nil, SCENARIO_OXP_DEFINITION_NOPLIST, and sUseAddOnsParts.

Here is the call graph for this function:

diagnosticFileLocation

+ (NSString *) diagnosticFileLocation

Definition at line 2244 of file ResourceManager.m.

{
    return OOLogHandlerGetLogBasePath();
}

References diagnosticFileLocation, and OOLogHandlerGetLogBasePath().

Referenced by diagnosticFileLocation, and writeDiagnosticData:toFileNamed:.

Here is the call graph for this function:

Here is the caller graph for this function:

dictionaryFromFilesNamed:inFolder:andMerge:

+ (NSDictionary *) dictionaryFromFilesNamed:		(NSString *)	fileName
inFolder:		(NSString *)	folderName
andMerge:		(BOOL)	mergeFiles

Definition at line 1244 of file ResourceManager.m.

                                          :(NSString *)fileName
                                  inFolder:(NSString *)folderName
                                  andMerge:(BOOL) mergeFiles
{
    return [ResourceManager dictionaryFromFilesNamed:fileName inFolder:folderName mergeMode:mergeFiles ? MERGE_BASIC : MERGE_NONE cache:YES];
}

Referenced by CompileSystemDescriptions(), HeadUpDisplay(Private)::crosshairDefinitionForWeaponType:, ExportSystemDescriptions(), GlobalAutoAIForRole(), GuiDisplayGen::init, OODebugMonitor::init, HeadUpDisplay::InitTextEngine(void), Universe::initWithGameView:, Universe(OOPrivate)::loadDescriptions, OOOpenGLExtensionManager(OOPrivate)::lookUpPerGPUSettingsWithVersionString:extensionsString:, materialDefaults, Universe::reinitAndShowDemo:, ReportJSError(), HeadUpDisplay::resetGuiPositions, OOCheckShipDataPListVerifierStage::run, HeadUpDisplay::setCrosshairDefinition:, ShipEntity(Private)::setUpOneEscort:inGroup:withRole:atPosition:andCount:, Universe::setUpSettings, and PlayerEntity::switchHudTo:.

Here is the caller graph for this function:

dictionaryFromFilesNamed:inFolder:mergeMode:cache:

+ (NSDictionary *) dictionaryFromFilesNamed:		(NSString *)	fileName
inFolder:		(NSString *)	folderName
mergeMode:		(OOResourceMergeMode)	mergeMode
cache:		(BOOL)	useCache

Definition at line 1252 of file ResourceManager.m.

                                          :(NSString *)fileName
                                  inFolder:(NSString *)folderName
                                 mergeMode:(OOResourceMergeMode)mergeMode
                                     cache:(BOOL)cache
{
    id              result = nil;
    NSMutableArray  *results = nil;
    NSString        *cacheKey = nil;
    NSString        *mergeType = nil;
    OOCacheManager  *cacheMgr = [OOCacheManager sharedCache];
    NSEnumerator    *enumerator = nil;
    NSString        *path = nil;
    NSString        *dictPath = nil;
    NSDictionary    *dict = nil;
    
    if (fileName == nil)  return nil;
    
    switch (mergeMode)
    {
        case MERGE_NONE:
            mergeType = @"none";
            break;
        
        case MERGE_BASIC:
            mergeType = @"basic";
            break;
        
        case MERGE_SMART:
            mergeType = @"smart";
            break;
    }
    if (mergeType == nil)
    {
        OOLog(kOOLogParameterError, @"Unknown dictionary merge mode %u for %@. (This is an internal programming error, please report it.)", mergeMode, fileName);
        return nil;
    }
    
    if (cache)
    {
    
        if (folderName != nil)
        {
            cacheKey = [NSString stringWithFormat:@"%@/%@ merge:%@", folderName, fileName, mergeType];
        }
        else
        {
            cacheKey = [NSString stringWithFormat:@"%@ merge:%@", fileName, mergeType];
        }
        result = [cacheMgr objectForKey:cacheKey inCache:@"dictionaries"];
        if (result != nil)  return result;
    }
    
    if (mergeMode == MERGE_NONE)
    {
        // Find "last" matching dictionary
        for (enumerator = [ResourceManager reversePathEnumerator]; (path = [enumerator nextObject]); )
        {
            if (folderName != nil)
            {
                dictPath = [[path stringByAppendingPathComponent:folderName] stringByAppendingPathComponent:fileName];
                dict = OODictionaryFromFile(dictPath);
                if (dict != nil)  break;
            }
            dictPath = [path stringByAppendingPathComponent:fileName];
            dict = OODictionaryFromFile(dictPath);
            if (dict != nil)  break;
        }
        result = dict;
    }
    else
    {
        // Find all matching dictionaries
        results = [NSMutableArray array];
        for (enumerator = [ResourceManager pathEnumerator]; (path = [enumerator nextObject]); )
        {
            if ([ResourceManager corePlist:fileName excludedAt:path])
            {
                continue;
            }
            dictPath = [path stringByAppendingPathComponent:fileName];
            dict = OODictionaryFromFile(dictPath);
            if (dict != nil)  [results addObject:dict];
            if (folderName != nil)
            {
                dictPath = [[path stringByAppendingPathComponent:folderName] stringByAppendingPathComponent:fileName];
                dict = OODictionaryFromFile(dictPath);
                if (dict != nil)  [results addObject:dict];
            }
        }
        
        if ([results count] == 0)  return nil;
        
        // Merge result
        result = [NSMutableDictionary dictionary];
        
        for (enumerator = [results objectEnumerator]; (dict = [enumerator nextObject]); )
        {
            if (mergeMode == MERGE_SMART)  [result mergeEntriesFromDictionary:dict];
            else  [result addEntriesFromDictionary:dict];
        }
        result = [[result copy] autorelease];   // Make immutable
    }
    
    if (cache && result != nil)  [cacheMgr setObject:result forKey:cacheKey inCache:@"dictionaries"];
    
    return result;
}

References count, kOOLogParameterError, MERGE_BASIC, MERGE_NONE, MERGE_SMART, nil, OOCacheManager::objectForKey:inCache:, OODictionaryFromFile(), OOLog, pathEnumerator, reversePathEnumerator, OOCacheManager::setObject:forKey:inCache:, and OOCacheManager::sharedCache.

Referenced by handleEquipmentOverrides:, OOCommodities::init, PlayerEntity(KeyMapper)::initCheckingDictionary, PlayerEntity(Controls)::initKeyConfigSettings, MyOpenGLView::initKeyMappingData, PlayerEntity(KeyMapperInternal)::keyboardDescription:, PlayerEntity(KeyMapper)::keyboardLayoutList, OOShipRegistry(OODataLoader)::loadAndApplyShipDataOverrides:, OOShipRegistry(OODataLoader)::loadAndMergeShipyard:, OOShipRegistry(OODataLoader)::loadShipData, OOInitDebugSupport(), and Universe::setUpSettings.

Here is the call graph for this function:

Here is the caller graph for this function:

directoryExists:create:

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

implementation

Definition at line 2218 of file ResourceManager.m.

                       :(NSString *)inPath create:(BOOL)inCreate
{
    BOOL                exists, directory;
    NSFileManager       *fmgr =  [NSFileManager defaultManager];
    
    exists = [fmgr fileExistsAtPath:inPath isDirectory:&directory];
    
    if (exists && !directory)
    {
        OOLog(@"resourceManager.write.buildPath.failed", @"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(@"resourceManager.write.buildPath.failed", @"Could not create folder %@.", inPath);
            return NO;
        }
    }
    
    return YES;
}

References nil, and OOLog.

errors

+ (NSString *) errors

Definition at line 133 of file ResourceManager.m.

{
    NSArray                 *error = nil;
    NSUInteger              i, count;
    NSMutableArray          *result = nil;
    NSString                *errStr = nil;
    
    count = [sErrors count];
    if (count == 0)  return nil;
    
    // Expand error messages. This is deferred for localizability.
    result = [NSMutableArray arrayWithCapacity:count];
    for (i = 0; i != count; ++i)
    {
        error = [sErrors objectAtIndex:i];
        errStr = [UNIVERSE descriptionForKey:[error oo_stringAtIndex:0]];
        if (errStr != nil)
        {
            errStr = [NSString stringWithFormat:errStr, [error objectAtIndex:1], [error objectAtIndex:2]];
            [result addObject:errStr];
        }
    }
    
    [sErrors release];
    sErrors = nil;
    
    return [result componentsJoinedByString:@"\n"];
}

References count, errors, nil, and sErrors.

Referenced by errors, and PlayerEntity::setGuiToIntroFirstGo:.

Here is the call graph for this function:

Here is the caller graph for this function:

filterSearchPathsByScenario:

+ (void) filterSearchPathsByScenario: (NSMutableArray *) searchPaths

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 1023 of file ResourceManager.m.

                                    :(NSMutableArray *)searchPaths
{
    NSDictionary    *manifest = nil;
    NSString        *identifier = nil;
    NSArray         *identifiers = [sOXPManifests allKeys];
 
    // take a copy because we'll mutate the original
    // foreach identified add-on
    foreach (identifier, identifiers)
    {
        manifest = [sOXPManifests objectForKey:identifier];
        if (manifest != nil)
        {
            if (![ResourceManager manifestAllowedByScenario:manifest])
            {
                // then we don't need this one
                [searchPaths removeObject:[manifest oo_stringForKey:kOOManifestFilePath]];
                [sOXPManifests removeObjectForKey:identifier];
            }
        }
    }
}

References nil.

Referenced by pathsWithAddOns.

Here is the caller graph for this function:

filterSearchPathsForConflicts:

+ (void) filterSearchPathsForConflicts: (NSMutableArray *) searchPaths

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 848 of file ResourceManager.m.

                                      :(NSMutableArray *)searchPaths
{
    NSDictionary    *manifest = nil;
    NSString        *identifier = nil;
    NSArray         *identifiers = [sOXPManifests allKeys];
 
    // take a copy because we'll mutate the original
    // foreach identified add-on
    foreach (identifier, identifiers)
    {
        manifest = [sOXPManifests objectForKey:identifier];
        if (manifest != nil)
        {
            if ([self manifestHasConflicts:manifest logErrors:YES])
            {
                // then we have a conflict, so remove this path
                [searchPaths removeObject:[manifest oo_stringForKey:kOOManifestFilePath]];
                [sOXPManifests removeObjectForKey:identifier];
            }
        }
    }
}

References nil.

Referenced by pathsWithAddOns.

Here is the caller graph for this function:

filterSearchPathsForRequirements:

+ (BOOL) filterSearchPathsForRequirements: (NSMutableArray *) searchPaths

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 941 of file ResourceManager.m.

                                         :(NSMutableArray *)searchPaths
{
    NSDictionary    *manifest = nil;
    NSString        *identifier = nil;
    NSArray         *identifiers = [sOXPManifests allKeys];
 
    sAllMet = YES;
 
    // take a copy because we'll mutate the original
    // foreach identified add-on
    foreach (identifier, identifiers)
    {
        manifest = [sOXPManifests objectForKey:identifier];
        if (manifest != nil)
        {
            if ([self manifestHasMissingDependencies:manifest logErrors:YES])
            {
                // then we have a missing requirement, so remove this path
                [searchPaths removeObject:[manifest oo_stringForKey:kOOManifestFilePath]];
                [sOXPManifests removeObjectForKey:identifier];
                sAllMet = NO;
            }
        }
    }
 
    return sAllMet;
}

References nil, and sAllMet.

filterSearchPathsToExcludeScenarioOnlyPaths:

+ (void) filterSearchPathsToExcludeScenarioOnlyPaths: (NSMutableArray *) searchPaths

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 999 of file ResourceManager.m.

                                                    :(NSMutableArray *)searchPaths
{
    NSDictionary    *manifest = nil;
    NSString        *identifier = nil;
    NSArray         *identifiers = [sOXPManifests allKeys];
 
    // take a copy because we'll mutate the original
    // foreach identified add-on
    foreach (identifier, identifiers)
    {
        manifest = [sOXPManifests objectForKey:identifier];
        if (manifest != nil)
        {
            if ([[manifest oo_arrayForKey:kOOManifestTags] containsObject:kOOManifestTagScenarioOnly])
            {
                [searchPaths removeObject:[manifest oo_stringForKey:kOOManifestFilePath]];
                [sOXPManifests removeObjectForKey:identifier];
            }
        }
    }
}

References kOOManifestTags, kOOManifestTagScenarioOnly, and nil.

Referenced by pathsWithAddOns.

Here is the caller graph for this function:

handleEquipmentListMerging:forLookupIndex:

+ (void) handleEquipmentListMerging:		(NSMutableArray *)	arrayToProcess
forLookupIndex:		(unsigned)	lookupIndex

Definition at line 1479 of file ResourceManager.m.

                                   : (NSMutableArray *)arrayToProcess forLookupIndex:(unsigned)lookupIndex
{
    NSUInteger i,j,k;
    NSMutableArray *refArray = [arrayToProcess objectAtIndex:[arrayToProcess count] - 1];
    
    // Any change to refArray will directly modify arrayToProcess.
    
    for (i = 0; i < [refArray count]; i++)
    {
        for (j = 0; j < [arrayToProcess count] - 1; j++)
        {
            NSUInteger count = [[arrayToProcess oo_arrayAtIndex:j] count];
            if (count == 0)  continue;
            
            for (k=0; k < count; k++)
            {
                id processValue = [[[arrayToProcess oo_arrayAtIndex:j] oo_arrayAtIndex:k] oo_objectAtIndex:lookupIndex defaultValue:nil];
                id refValue = [[refArray oo_arrayAtIndex:i] oo_objectAtIndex:lookupIndex defaultValue:nil];
                
                if ([processValue isEqual:refValue])
                {
                    [[arrayToProcess objectAtIndex:j] replaceObjectAtIndex:k withObject:[refArray objectAtIndex:i]];
                    [refArray removeObjectAtIndex:i];
                }
            }
        }
    }
    // arrayToProcess has been processed at this point. Any necessary merging has been done.
}

References count.

Referenced by arrayFromFilesNamed:inFolder:andMerge:cache:.

Here is the caller graph for this function:

handleEquipmentOverrides:

+ (void) handleEquipmentOverrides:

(NSMutableArray *)

arrayToProcess

Definition at line 1514 of file ResourceManager.m.

                                 : (NSMutableArray *)arrayToProcess
{
    NSEnumerator            *equipKeyEnum = nil;
    NSString                *equipKey = nil;
    NSDictionary            *overrides = nil;
    NSDictionary            *overridesEntry = nil;
    int                     i;
 
    overrides = [ResourceManager dictionaryFromFilesNamed:@"equipment-overrides.plist"
                                                 inFolder:@"Config"
                                                mergeMode:MERGE_SMART
                                                    cache:NO];
 
    // cycle through all the equipment keys found in override files
    for (equipKeyEnum = [overrides keyEnumerator]; (equipKey = [equipKeyEnum nextObject]); )
    {
        overridesEntry = [overrides objectForKey:equipKey];
        // loop through our data array to find a match
        for (i = 0; i < [arrayToProcess count]; i++)
        {
            NSMutableArray  *equipArray = [[[arrayToProcess objectAtIndex:i] mutableCopy] autorelease];
            id refValue = [equipArray oo_objectAtIndex:EQUIPMENT_KEY_INDEX defaultValue:nil];
            // does the overridden equipment item exist in the equipment array? if so, get working
            if ([equipKey isEqual:refValue])
            {
                NSEnumerator            *infoKeyEnum = nil;
                NSString                *infoKey;
                // cycle through all the properties found for this equipment key in the overrides file
                for (infoKeyEnum = [overridesEntry keyEnumerator]; (infoKey = [infoKeyEnum nextObject]); )
                {
                    // special cases for the array items that don't have a direct keyname
                    if ([infoKey isEqualToString:@"techlevel"]) 
                        [equipArray replaceObjectAtIndex:EQUIPMENT_TECH_LEVEL_INDEX withObject:[overridesEntry objectForKey:infoKey]];
                    else if ([infoKey isEqualToString:@"price"]) 
                        [equipArray replaceObjectAtIndex:EQUIPMENT_PRICE_INDEX withObject:[overridesEntry objectForKey:infoKey]];
                    else if ([infoKey isEqualToString:@"short_description"]) 
                        [equipArray replaceObjectAtIndex:EQUIPMENT_SHORT_DESC_INDEX withObject:[overridesEntry objectForKey:infoKey]];
                    else if ([infoKey isEqualToString:@"name"]) 
                        [equipArray replaceObjectAtIndex:EQUIPMENT_SHORT_DESC_INDEX withObject:[overridesEntry objectForKey:infoKey]];
                    else if ([infoKey isEqualToString:@"long_description"]) 
                        [equipArray replaceObjectAtIndex:EQUIPMENT_LONG_DESC_INDEX withObject:[overridesEntry objectForKey:infoKey]];
                    else if ([infoKey isEqualToString:@"description"]) 
                        [equipArray replaceObjectAtIndex:EQUIPMENT_LONG_DESC_INDEX withObject:[overridesEntry objectForKey:infoKey]];
                    else 
                    {
                        NSMutableDictionary     *extra = nil;
                        // for everything else
                        // do we actually have an extras dictionary?
                        if (![equipArray oo_dictionaryAtIndex:EQUIPMENT_EXTRA_INFO_INDEX]) 
                        {
                            // if not, create a blank one we can add to
                            extra = [NSMutableDictionary dictionary];
                        }
                        else
                        {
                            extra = [[equipArray oo_dictionaryAtIndex:EQUIPMENT_EXTRA_INFO_INDEX] mutableCopy];
                        }
                        // special case for weapon_info && script_info, which are child dictionaries
                        if ([infoKey isEqualToString:@"weapon_info"] || [infoKey isEqualToString:@"script_info"])
                        {
                            NSEnumerator            *subEnum = nil;
                            NSString                *subKey;
                            NSMutableDictionary     *subInfo = nil;
                            NSDictionary            *subOverrides = nil;
                            // do we actually have a weapon_info/script_info dictionary?
                            if (![extra oo_dictionaryForKey:infoKey]) 
                            {
                                // if not, create a blank dictionary we can add to
                                subInfo = [NSMutableDictionary dictionary];
                            } 
                            else 
                            {
                                subInfo = [[extra oo_dictionaryForKey:infoKey] mutableCopy];
                            }
                            subOverrides = [overridesEntry oo_dictionaryForKey:infoKey];
                            // cycle through all the sub keys found in the overrides file for this equipment key item
                            for (subEnum = [subOverrides keyEnumerator]; (subKey = [subEnum nextObject]); )
                            {
                                [subInfo setObject:[subOverrides objectForKey:subKey] forKey:subKey];
                            }
                            [extra setObject:[[subInfo copy] autorelease] forKey:infoKey];
                        }
                        else
                        {
                            // for all other keys in the extras dictionary
                            [extra setObject:[overridesEntry objectForKey:infoKey] forKey:infoKey];
                        }
                        [equipArray replaceObjectAtIndex:EQUIPMENT_EXTRA_INFO_INDEX withObject:[[extra copy] autorelease]];
                    }
                }
                [arrayToProcess replaceObjectAtIndex:i withObject:equipArray];
            }
        }
    }
}

References dictionaryFromFilesNamed:inFolder:mergeMode:cache:, EQUIPMENT_EXTRA_INFO_INDEX, and nil.

Referenced by arrayFromFilesNamed:inFolder:andMerge:cache:.

Here is the call graph for this function:

Here is the caller graph for this function:

handleStarNebulaListMerging:

+ (void) handleStarNebulaListMerging:

(NSMutableArray *)

arrayToProcess

Definition at line 1613 of file ResourceManager.m.

                                    : (NSMutableArray *)arrayToProcess
{
    NSUInteger i,j,k;
    NSMutableArray *refArray = [arrayToProcess objectAtIndex:[arrayToProcess count] - 1];
 
    // Any change to refArray will directly modify arrayToProcess.  
    for (i = 0; i < [refArray count]; i++)
    {
        for (j = 0; j < [arrayToProcess count] - 1; j++)
        {
            NSUInteger count = [[arrayToProcess oo_arrayAtIndex:j] count];
            if (count == 0)  continue;
 
            for (k = 0; k < count; k++) 
            {
                id processValue = [[arrayToProcess oo_arrayAtIndex:j] oo_objectAtIndex:k defaultValue:nil];
                id refValue = [refArray oo_objectAtIndex:i defaultValue:nil];
                NSString *key1 = nil;
                NSString *key2 = nil;
 
                if ([processValue isKindOfClass:[NSString class]]) 
                {
                    key1 = processValue;
                }
                else if ([processValue isKindOfClass:[NSDictionary class]])
                {
                    if (![processValue objectForKey:@"key"]) 
                    {
                        key1 = [processValue objectForKey:@"texture"];
                    }
                    else
                    {
                        key1 = [processValue objectForKey:@"key"];
                    }
                }
                if (!key1) continue;
 
                if ([refValue isKindOfClass:[NSString class]]) 
                {
                    key2 = refValue;
                }
                else if ([refValue isKindOfClass:[NSDictionary class]])
                {
                    if (![refValue objectForKey:@"key"])
                    {
                        key2 = [refValue objectForKey:@"texture"];
                    }
                    else
                    {
                        key2 = [refValue objectForKey:@"key"];
                    }
                }
                if (!key2) continue;
 
                if ([key1 isEqual:key2])
                {
                    [[arrayToProcess objectAtIndex:j] replaceObjectAtIndex:k withObject:[refArray objectAtIndex:i]];
                    [refArray removeObjectAtIndex:i];
                }
 
            }
        }
    }
    // arrayToProcess has been processed at this point. Any necessary merging has been done.
}

References count, and nil.

Referenced by arrayFromFilesNamed:inFolder:andMerge:cache:.

Here is the caller graph for this function:

loadScripts

+ (NSDictionary *) loadScripts

Definition at line 2088 of file ResourceManager.m.

{
    NSMutableDictionary         *loadedScripts = nil;
    NSArray                     *results = nil;
    NSArray                     *paths = nil;
    NSEnumerator                *pathEnum = nil;
    NSString                    *path = nil;
    NSEnumerator                *scriptEnum = nil;
    OOScript                    *script = nil;
    NSString                    *name = nil;
    NSAutoreleasePool           *pool = nil;
    
    OOLog(@"script.load.world.begin", @"%@", @"Loading world scripts...");
    
    loadedScripts = [NSMutableDictionary dictionary];
    paths = [ResourceManager paths];
    for (pathEnum = [paths objectEnumerator]; (path = [pathEnum nextObject]); )
    {
        // excluding world-scripts.plist also excludes script.js / script.plist
        // though as those core files don't and won't exist this is not
        // a problem.
        if (![ResourceManager corePlist:@"world-scripts.plist" excludedAt:path])
        {
            pool = [[NSAutoreleasePool alloc] init];
        
            @try
            {
                results = [OOScript worldScriptsAtPath:[path stringByAppendingPathComponent:@"Config"]];
                if (results == nil) results = [OOScript worldScriptsAtPath:path];
                if (results != nil)
                {
                    for (scriptEnum = [results objectEnumerator]; (script = [scriptEnum nextObject]); )
                    {
                        name = [script name];
                        if (name != nil)  [loadedScripts setObject:script forKey:name];
                        else  OOLog(@"script.load.unnamed", @"Discarding anonymous script %@", script);
                    }
                }
            }
            @catch (NSException *exception)
            {
                OOLog(@"script.load.exception", @"***** %s encountered exception %@ (%@) while trying to load script from %@ -- ignoring this location.", __PRETTY_FUNCTION__, [exception name], [exception reason], path);
                // Ignore exception and keep loading other scripts.
            }
        
            [pool release];
        }
    }
    
    if (OOLogWillDisplayMessagesInClass(@"script.load.world.listAll"))
    {
        NSUInteger count = [loadedScripts count];
        if (count != 0)
        {
            NSMutableArray      *displayNames = nil;
            NSEnumerator        *scriptEnum = nil;
            OOScript            *script = nil;
            NSString            *displayString = nil;
            
            displayNames = [NSMutableArray arrayWithCapacity:count];
            
            for (scriptEnum = [loadedScripts objectEnumerator]; (script = [scriptEnum nextObject]); )
            {
                [displayNames addObject:[script displayName]];
            }
            
            displayString = [[displayNames sortedArrayUsingSelector:@selector(caseInsensitiveCompare:)] componentsJoinedByString:@"\n    "];
            OOLog(@"script.load.world.listAll", @"Loaded %llu world scripts:\n    %@", count, displayString);
        }
        else
        {
            OOLog(@"script.load.world.listAll", @"%@", @"*** No world scripts loaded.");
        }
    }
    
    return loadedScripts;
}

References count, OOScript::displayName, loadScripts, OOScript::name, nil, OOLog, OOLogWillDisplayMessagesInClass(), paths, and OOScript::worldScriptsAtPath:.

Referenced by loadScripts, and PlayerEntity::setUpAndConfirmOK:saveGame:.

Here is the call graph for this function:

Here is the caller graph for this function:

LogClassKeyRoot

+ (NSString *) LogClassKeyRoot (NSString *) key

implementation

Definition at line 1698 of file ResourceManager.m.

{
    NSRange dot = [key rangeOfString:@"."];
    if (dot.location != NSNotFound)
    {
        return [key substringToIndex:dot.location];
    }
    else
    {
        return key;
    }
}

Referenced by logControlDictionary.

Here is the caller graph for this function:

logControlDictionary

+ (NSDictionary *) logControlDictionary

Definition at line 1712 of file ResourceManager.m.

{
    // Load built-in copy of logcontrol.plist.
    NSString *path = [[[ResourceManager builtInPath] stringByAppendingPathComponent:@"Config"]
                      stringByAppendingPathComponent:@"logcontrol.plist"];
    NSMutableDictionary *logControl = [NSMutableDictionary dictionaryWithDictionary:OODictionaryFromFile(path)];
    if (logControl == nil)  logControl = [NSMutableDictionary dictionary];
    
    // Build list of root log message classes that appear in the built-in list.
    NSMutableSet *coreRoots = [NSMutableSet set];
    NSString *key = nil;
    foreachkey(key, logControl)
    {
        [coreRoots addObject:LogClassKeyRoot(key)];
    }
    
    NSArray *rootPaths = [self rootPaths];
    NSString *configPath = nil;
    NSDictionary *dict = nil;
    
    // Look for logcontrol.plists inside OXPs (but not in root paths). These are not allowed to define keys in hierarchies used by the build-in one.
    NSEnumerator *pathEnum = [self pathEnumerator];
    while ((path = [pathEnum nextObject]))
    {
        if ([rootPaths containsObject:path])  continue;
        
        configPath = [[path stringByAppendingPathComponent:@"Config"]
                      stringByAppendingPathComponent:@"logcontrol.plist"];
        dict = OODictionaryFromFile(configPath);
        if (dict == nil)
        {
            configPath = [path stringByAppendingPathComponent:@"logcontrol.plist"];
            dict = OODictionaryFromFile(configPath);
        }
        foreachkey (key, dict)
        {
            if (![coreRoots containsObject:LogClassKeyRoot(key)])
            {
                [logControl setObject:[dict objectForKey:key] forKey:key];
            }
        }
    }
    
    // Now, look for logcontrol.plists in root paths, i.e. not within OXPs. These are allowed to override the built-in copy.
    pathEnum = [rootPaths objectEnumerator];
    while ((path = [pathEnum nextObject]))
    {
        configPath = [[path stringByAppendingPathComponent:@"Config"]
                      stringByAppendingPathComponent:@"logcontrol.plist"];
        dict = OODictionaryFromFile(configPath);
        if (dict == nil)
        {
            configPath = [path stringByAppendingPathComponent:@"logcontrol.plist"];
            dict = OODictionaryFromFile(configPath);
        }
        foreachkey (key, dict)
        {
            [logControl setObject:[dict objectForKey:key] forKey:key];
        }
    }
    
    // Finally, look in preferences, which can override all of the above.
    dict = [[NSUserDefaults standardUserDefaults] dictionaryForKey:@"logging-enable"];
    if (dict != nil)  [logControl addEntriesFromDictionary:dict];
    
    return logControl;
}

References builtInPath, foreachkey, LogClassKeyRoot, logControlDictionary, nil, OODictionaryFromFile(), pathEnumerator, and rootPaths.

Referenced by LoadExplicitSettings(), and logControlDictionary.

Here is the call graph for this function:

Here is the caller graph for this function:

logPaths

+ (void) logPaths

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 2250 of file ResourceManager.m.

{
    NSMutableArray          *displayPaths = nil;
    NSEnumerator            *pathEnum = nil;
    NSString                *path = nil;
 
    // Prettify paths for logging.
    displayPaths = [NSMutableArray arrayWithCapacity:[sSearchPaths count]];
    for (pathEnum = [sSearchPaths objectEnumerator]; (path = [pathEnum nextObject]); )
    {
        [displayPaths addObject:[[path stringByStandardizingPath] stringByAbbreviatingWithTildeInPath]];
    }
    
    OOLog(@"searchPaths.dumpAll", @"Resource paths: %@\n    %@", sUseAddOns, [displayPaths componentsJoinedByString:@"\n    "]);
 
}

References logPaths, nil, OOLog, sSearchPaths, and sUseAddOns.

Referenced by logPaths, and setUseAddOns:.

Here is the call graph for this function:

Here is the caller graph for this function:

manifest:HasUnmetDependency:logErrors:

+ (BOOL) manifest:		(NSDictionary *)	manifest
HasUnmetDependency:		(NSDictionary *)	required
logErrors:		(BOOL)	logErrors

Definition at line 894 of file ResourceManager.m.

                 :(NSDictionary *)manifest HasUnmetDependency:(NSDictionary *)required logErrors:(BOOL)logErrors
{
    NSString        *requiredID = [required oo_stringForKey:kOOManifestRelationIdentifier];
    NSMutableDictionary *requiredManifest = [sOXPManifests objectForKey:requiredID];
    // if the other OXP is in the list
    BOOL requirementsMet = NO;
    if (requiredManifest != nil)
    {
        // then check versions
        if ([self matchVersions:required withVersion:[requiredManifest oo_stringForKey:kOOManifestVersion]])
        {
            requirementsMet = YES;
            /* Mark the requiredManifest as a dependency of the
             * requiring manifest */
            NSSet *reqby = [requiredManifest oo_setForKey:kOOManifestRequiredBy defaultValue:[NSSet set]];
            NSUInteger reqbycount = [reqby count];
            /* then add this manifest to its required set. This is
             * done without checking if it's already there, because
             * the list of nested requirements may have changed. */
            reqby = [reqby setByAddingObject:[manifest oo_stringForKey:kOOManifestIdentifier]];
            // *and* anything that requires this OXP to be installed
            reqby = [reqby setByAddingObjectsFromSet:[manifest oo_setForKey:kOOManifestRequiredBy]];
            if (reqbycount < [reqby count])
            {
                /* Then the set has increased in size. To handle
                 * potential cases with nested dependencies, need to
                 * re-run the requirement filter until all the sets
                 * stabilise. */
                sAllMet = NO;
            }
            // and push back into the requiring manifest
            [requiredManifest setObject:reqby forKey:kOOManifestRequiredBy];
        }
    }
    if (!requirementsMet)
    {
        if (logErrors)
        {
            [self addErrorWithKey:@"oxp-required" param1:[manifest oo_stringForKey:kOOManifestTitle] param2:[required oo_stringForKey:kOOManifestRelationDescription defaultValue:[required oo_stringForKey:kOOManifestRelationIdentifier]]];
            OOLog(@"oxp.requirementMissing",@"OXP %@ had unmet requirements and was removed from the loading list",[[manifest oo_stringForKey:kOOManifestFilePath] lastPathComponent]);
        }
        return YES;
    }
    return NO;
}

References addErrorWithKey:param1:param2:, count, kOOManifestFilePath, kOOManifestVersion, nil, OOLog, and sAllMet.

Here is the call graph for this function:

manifestAllowedByScenario:

+ (BOOL) manifestAllowedByScenario: (NSDictionary *) manifest

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 1047 of file ResourceManager.m.

                                  :(NSDictionary *)manifest
{
    /* Checks for a couple of "never happens" cases */
#ifndef NDEBUG
    // test string
    if ([sUseAddOns isEqualToString:SCENARIO_OXP_DEFINITION_ALL])
    {
        OOLog(@"scenario.check", @"%@", @"Checked scenario allowances in all state - this is an internal error; please report this");
        return YES;
    }
    if ([sUseAddOns isEqualToString:SCENARIO_OXP_DEFINITION_NONE])
    {
        OOLog(@"scenario.check", @"%@", @"Checked scenario allowances in none state - this is an internal error; please report this");
        return NO;
    }
#endif
    if ([[manifest oo_stringForKey:kOOManifestIdentifier] isEqualToString:@"org.oolite.oolite"])
    {
        // the core data is always allowed!
        return YES;
    }
 
    NSString *uaoBit = nil;
    BOOL result = NO;
    foreach (uaoBit, sUseAddOnsParts)
    {
        if ([uaoBit hasPrefix:SCENARIO_OXP_DEFINITION_BYID])
        {
            result |= [ResourceManager manifestAllowedByScenario:manifest withIdentifier:[uaoBit substringFromIndex:[SCENARIO_OXP_DEFINITION_BYID length]]];
        }
        else if ([uaoBit hasPrefix:SCENARIO_OXP_DEFINITION_BYTAG])
        {
            result |= [ResourceManager manifestAllowedByScenario:manifest withTag:[uaoBit substringFromIndex:[SCENARIO_OXP_DEFINITION_BYTAG length]]];
        }
    }
    return result;
}

References kOOManifestIdentifier, manifestAllowedByScenario:withIdentifier:, manifestAllowedByScenario:withTag:, nil, OOLog, SCENARIO_OXP_DEFINITION_ALL, SCENARIO_OXP_DEFINITION_BYID, SCENARIO_OXP_DEFINITION_BYTAG, SCENARIO_OXP_DEFINITION_NONE, sUseAddOns, and sUseAddOnsParts.

Here is the call graph for this function:

manifestAllowedByScenario:withIdentifier:

+ (BOOL) manifestAllowedByScenario: (NSDictionary *) manifest withIdentifier: (NSString *) identifier

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 1086 of file ResourceManager.m.

                                  :(NSDictionary *)manifest withIdentifier:(NSString *)identifier
{
    if ([[manifest oo_stringForKey:kOOManifestIdentifier] isEqualToString:identifier])
    {
        // manifest has the identifier - easy
        return YES;
    }
    // manifest is also allowed if a manifest with that identifier
    // requires it to be installed
    if ([[manifest oo_setForKey:kOOManifestRequiredBy] containsObject:identifier])
    {
        return YES;
    }
    // otherwise, no
    return NO;
}

References kOOManifestIdentifier, and kOOManifestRequiredBy.

Referenced by manifestAllowedByScenario:.

Here is the caller graph for this function:

manifestAllowedByScenario:withTag:

+ (BOOL) manifestAllowedByScenario: (NSDictionary *) manifest withTag: (NSString *) tag

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 1104 of file ResourceManager.m.

                                  :(NSDictionary *)manifest withTag:(NSString *)tag
{
    if ([[manifest oo_arrayForKey:kOOManifestTags] containsObject:tag])
    {
        // manifest has the tag - easy
        return YES;
    }
    // manifest is also allowed if a manifest with that tag
    // requires it to be installed
    NSSet *reqby = [manifest oo_setForKey:kOOManifestRequiredBy];
    if (reqby != nil)
    {
        NSString *identifier = nil;
        foreach (identifier, reqby)
        {
            NSDictionary *reqManifest = [sOXPManifests oo_dictionaryForKey:identifier defaultValue:nil];
            // need to check for nil as this one may already have been ruled out
            if (reqManifest != nil && [[reqManifest oo_arrayForKey:kOOManifestTags] containsObject:tag])
            {
                return YES;
            }
        }
    }
    // otherwise, no
    return NO;
}

References kOOManifestTags, and nil.

Referenced by manifestAllowedByScenario:.

Here is the caller graph for this function:

manifestForIdentifier:

+ (NSDictionary *) manifestForIdentifier:

(NSString *)

identifier

Definition at line 577 of file ResourceManager.m.

                                       :(NSString *)identifier
{
    return [sOXPManifests objectForKey:identifier];
}

Referenced by OOOXZManager(NSURLConnectionDataDelegate)::installableState:, and OOOXZManager::showInstallOptions.

Here is the caller graph for this function:

manifestHasConflicts:logErrors:

+ (BOOL) manifestHasConflicts:		(NSDictionary *)	manifest
logErrors:		(BOOL)	logErrors

Definition at line 812 of file ResourceManager.m.

                             :(NSDictionary *)manifest logErrors:(BOOL)logErrors
{
    NSDictionary    *conflicting = nil;
    NSDictionary    *conflictManifest = nil;
    NSString        *conflictID = nil;
    NSArray         *conflicts = nil;
    
    conflicts = [manifest oo_arrayForKey:kOOManifestConflictOXPs defaultValue:nil];
    // if it has a non-empty conflict_oxps list 
    if (conflicts != nil && [conflicts count] > 0)
    {
        // iterate over that list
        foreach (conflicting, conflicts)
        {
            conflictID = [conflicting oo_stringForKey:kOOManifestRelationIdentifier];
            conflictManifest = [sOXPManifests objectForKey:conflictID];
            // if the other OXP is in the list
            if (conflictManifest != nil)
            {
                // then check versions
                if ([self matchVersions:conflicting withVersion:[conflictManifest oo_stringForKey:kOOManifestVersion]])
                {
                    if (logErrors)
                    {
                        [self addErrorWithKey:@"oxp-conflict" param1:[manifest oo_stringForKey:kOOManifestTitle] param2:[conflictManifest oo_stringForKey:kOOManifestTitle]];
                        OOLog(@"oxp.conflict",@"OXP %@ conflicts with %@ and was removed from the loading list",[[manifest oo_stringForKey:kOOManifestFilePath] lastPathComponent],[[conflictManifest oo_stringForKey:kOOManifestFilePath] lastPathComponent]);
                    }
                    return YES;
                }
            }
        }
    }
    return NO;
}

References addErrorWithKey:param1:param2:, count, kOOManifestFilePath, kOOManifestVersion, nil, and OOLog.

Here is the call graph for this function:

manifestHasMissingDependencies:logErrors:

+ (BOOL) manifestHasMissingDependencies:		(NSDictionary *)	manifest
logErrors:		(BOOL)	logErrors

Definition at line 872 of file ResourceManager.m.

                                       :(NSDictionary *)manifest logErrors:(BOOL)logErrors
{
    NSDictionary    *required = nil;
    NSArray         *requireds = nil;
 
    requireds = [manifest oo_arrayForKey:kOOManifestRequiresOXPs defaultValue:nil];
    // if it has a non-empty required_oxps list 
    if (requireds != nil && [requireds count] > 0)
    {
        // iterate over that list
        foreach (required, requireds)
        {
            if ([ResourceManager manifest:manifest HasUnmetDependency:required logErrors:logErrors])
            {
                return YES;
            }
        }
    }
    return NO;
}

References count, and nil.

maskUserName:inPath:

+ (NSString *) maskUserName:		(NSString *)	name
inPath:		(NSString *)	path

Definition at line 489 of file ResourceManager.m.

                          :(NSString *)name inPath:(NSString *)path
{
    NSMutableString *result = [NSMutableString stringWithString:path];
    if (result && name)  [result replaceOccurrencesOfString:name withString:@"*"
                            options:NSLiteralSearch
                            range:NSMakeRange(0, [result length])
                         ];
    return [NSString stringWithString:result];
}

Referenced by maskUserNameInPathArray:.

Here is the caller graph for this function:

maskUserNameInPathArray:

+ (NSArray *) maskUserNameInPathArray:

(NSArray *)

inputPathArray

Definition at line 469 of file ResourceManager.m.

                                    :(NSArray *)inputPathArray
{
    NSString *path = nil;
    NSMutableArray *maskedArray = [NSMutableArray arrayWithCapacity:[inputPathArray count]];
    char *userNamePathEnvVar = 
#if OOLITE_WINDOWS
        SDL_getenv("USERPROFILE");
#else
        SDL_getenv("HOME");
#endif
    NSString *userName = [[NSString stringWithFormat:@"%s", userNamePathEnvVar] lastPathComponent];
    foreach (path, inputPathArray)
    {
        path = [self maskUserName:userName inPath:path];
        [maskedArray addObject:path];
    }
    return maskedArray;
}

References maskUserName:inPath:, and nil.

Referenced by OoliteGetProperty().

Here is the call graph for this function:

Here is the caller graph for this function:

matchVersions:withVersion:

+ (BOOL) matchVersions:		(NSDictionary *)	rangeDict
withVersion:		(NSString *)	version

Definition at line 970 of file ResourceManager.m.

                      :(NSDictionary *)rangeDict withVersion:(NSString *)version
{
    NSString    *minimum = [rangeDict oo_stringForKey:kOOManifestRelationVersion defaultValue:nil];
    NSString    *maximum = [rangeDict oo_stringForKey:kOOManifestRelationMaxVersion defaultValue:nil];
    NSArray     *isVersionComponents = ComponentsFromVersionString(version);
    NSArray     *reqVersionComponents = nil;
    if (minimum != nil)
    {
        reqVersionComponents = ComponentsFromVersionString(minimum);
        if (NSOrderedAscending == CompareVersions(isVersionComponents, reqVersionComponents))
        {
            // earlier than minimum version
            return NO;
        }
    }
    if (maximum != nil)
    {
        reqVersionComponents = ComponentsFromVersionString(maximum);
        if (NSOrderedDescending == CompareVersions(isVersionComponents, reqVersionComponents))
        {
            // later than maximum version
            return NO;
        }
    }
    // either version was okay, or no version info so an unconditional match
    return YES;
}

References CompareVersions(), ComponentsFromVersionString(), and nil.

Here is the call graph for this function:

materialDefaults

+ (NSDictionary *) materialDefaults

Definition at line 2212 of file ResourceManager.m.

{
    return [self dictionaryFromFilesNamed:@"material-defaults.plist" inFolder:@"Config" andMerge:YES];
}

References dictionaryFromFilesNamed:inFolder:andMerge:, and materialDefaults.

Referenced by materialDefaults, OODefaultShipShaderMacros(), OOMesh::placeholderMaterial, ShipSetMaterialsInternal(), and VisualEffectSetMaterialsInternal().

Here is the call graph for this function:

Here is the caller graph for this function:

mergeRoleCategories:intoDictionary:

+ (void) mergeRoleCategories: (NSDictionary *) catData intoDictionary: (NSMutableDictionary *) categories

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 1818 of file ResourceManager.m.

                            :(NSDictionary *)catData intoDictionary:(NSMutableDictionary *)categories
{
    NSMutableSet *contents = nil;
    NSArray *catDataEntry = nil;
    NSString *key;
    foreachkey(key, catData)
    {
        contents = [categories objectForKey:key];
        if (contents == nil)
        {
            contents = [NSMutableSet setWithCapacity:16];
            [categories setObject:contents forKey:key];
        }
        catDataEntry = [catData oo_arrayForKey:key];
        OOLog(@"shipData.load.roleCategories", @"Adding %ld entries for category %@", (unsigned long)[catDataEntry count], key);
        [contents addObjectsFromArray:catDataEntry];
    }
}

References count, foreachkey, nil, and OOLog.

Referenced by roleCategoriesDictionary.

Here is the caller graph for this function:

ooMusicNamed:inFolder:

+ (OOMusic *) ooMusicNamed:		(NSString *)	fileName
inFolder:		(NSString *)	folderName

Definition at line 2030 of file ResourceManager.m.

                          :(NSString *)fileName inFolder:(NSString *)folderName
{
    return [self retrieveFileNamed:fileName
                          inFolder:folderName
                             cache:NULL // Don't cache music objects; minimizing latency isn't really important.
                               key:[NSString stringWithFormat:@"OOMusic:%@:%@", folderName, fileName]
                             class:[OOMusic class]
                      usePathCache:YES];
}

References retrieveFileNamed:inFolder:cache:key:class:usePathCache:.

Referenced by OOMusicController::playMusicNamed:loop:gain:.

Here is the call graph for this function:

Here is the caller graph for this function:

ooSoundNamed:inFolder:

+ (OOSound *) ooSoundNamed:		(NSString *)	fileName
inFolder:		(NSString *)	folderName

Definition at line 2041 of file ResourceManager.m.

                          :(NSString *)fileName inFolder:(NSString *)folderName
{
    return [self retrieveFileNamed:fileName
                          inFolder:folderName
                             cache:&sSoundCache
                               key:[NSString stringWithFormat:@"OOSound:%@:%@", folderName, fileName]
                             class:[OOSound class]
                      usePathCache:YES];
}

References retrieveFileNamed:inFolder:cache:key:class:usePathCache:.

Referenced by GetNamedSound(), Universe::PreloadOneSound, PlayerEntity(Sound)::setUpSound, and OOSound(OOCustomSounds)::soundWithCustomSoundKey:.

Here is the call graph for this function:

Here is the caller graph for this function:

OXPsWithMessagesFound

+ (NSArray *) OXPsWithMessagesFound

Definition at line 571 of file ResourceManager.m.

{
    return [[sOXPsWithMessagesFound copy] autorelease];
}

References OXPsWithMessagesFound.

Referenced by OXPsWithMessagesFound, and PlayerEntity::setGuiToIntroFirstGo:.

Here is the call graph for this function:

Here is the caller graph for this function:

pathEnumerator

+ (NSEnumerator *) pathEnumerator

Definition at line 559 of file ResourceManager.m.

{
    return [[self paths] objectEnumerator];
}

References pathEnumerator, and paths.

Referenced by arrayFromFilesNamed:inFolder:andMerge:cache:, dictionaryFromFilesNamed:inFolder:mergeMode:cache:, logControlDictionary, pathEnumerator, roleCategoriesDictionary, and systemDescriptionManager.

Here is the call graph for this function:

Here is the caller graph for this function:

pathForFileNamed:inFolder:

+ (NSString *) pathForFileNamed:		(NSString *)	fileName
inFolder:		(NSString *)	folderName

Definition at line 1935 of file ResourceManager.m.

                               :(NSString *)fileName inFolder:(NSString *)folderName
{
    return [self pathForFileNamed:fileName inFolder:folderName cache:YES];
}

References pathForFileNamed:inFolder:cache:.

Referenced by OOScript::jsAIScriptFromFileNamed:properties:, OOScript::jsScriptFromFileNamed:properties:, OOTextureLoader::loaderWithTextureSpecifier:extraOptions:folder:, AI(OOPrivate)::loadStateMachine:jsName:, OOInitDebugSupport(), OOFileScannerVerifierStage::pathForFile:inFolder:referencedFrom:checkBuiltIn:, OOScript::scriptsFromFileNamed:, ShipEntity(AI)::setAITo:, OODebugMonitor(Private)::setUpDebugConsoleScript, PlayerEntity(LoadSave)::startScenario, and OOTexture::textureWithName:inFolder:options:anisotropy:lodBias:.

Here is the call graph for this function:

Here is the caller graph for this function:

pathForFileNamed:inFolder:cache:

+ (NSString *) pathForFileNamed:		(NSString *)	fileName
inFolder:		(NSString *)	folderName
cache:		(BOOL)	useCache

Definition at line 1942 of file ResourceManager.m.

                               :(NSString *)fileName inFolder:(NSString *)folderName cache:(BOOL)useCache
{
    NSString        *result = nil;
    NSString        *cacheKey = nil;
    OOCacheManager  *cache = [OOCacheManager sharedCache];
    NSEnumerator    *pathEnum = nil;
    NSString        *path = nil;
    NSString        *filePath = nil;
    NSFileManager   *fmgr = nil;
    
    if (fileName == nil)  return nil;
    
    if (cache)
    {
        if (folderName != nil)  cacheKey = [NSString stringWithFormat:@"%@/%@", folderName, fileName];
        else  cacheKey = fileName;
        result = [cache objectForKey:cacheKey inCache:@"resolved paths"];
        if (result != nil)  return result;
    }
    
    // Search for file
    fmgr = [NSFileManager defaultManager];
    // reverse object enumerator allows OXPs to override core
    for (pathEnum = [[ResourceManager paths] reverseObjectEnumerator]; (path = [pathEnum nextObject]); )
    {
        filePath = [[path stringByAppendingPathComponent:folderName] stringByAppendingPathComponent:fileName];
        if ([fmgr oo_oxzFileExistsAtPath:filePath])
        {
            result = filePath;
            break;
        }
        
        filePath = [path stringByAppendingPathComponent:fileName];
        if ([fmgr oo_oxzFileExistsAtPath:filePath])
        {
            result = filePath;
            break;
        }
    }
    
    if (result != nil)
    {
        OOLog(@"resourceManager.foundFile", @"Found %@/%@ at %@", folderName, fileName, filePath);
        if (useCache)
        {
            [cache setObject:result forKey:cacheKey inCache:@"resolved paths"];
        }
    }
    return result;
}

References nil, OOCacheManager::objectForKey:inCache:, OOLog, paths, OOCacheManager::setObject:forKey:inCache:, and OOCacheManager::sharedCache.

Referenced by pathForFileNamed:inFolder:, retrieveFileNamed:inFolder:cache:key:class:usePathCache:, and stringFromFilesNamed:inFolder:cache:.

Here is the call graph for this function:

Here is the caller graph for this function:

paths

+ (NSArray *) paths

Definition at line 459 of file ResourceManager.m.

{
    if (EXPECT_NOT(sSearchPaths == nil))
    {
        sSearchPaths = [[NSMutableArray alloc] init];
    }
    return [self pathsWithAddOns];
}

References EXPECT_NOT, nil, paths, pathsWithAddOns, and sSearchPaths.

Referenced by loadScripts, OoliteGetProperty(), pathEnumerator, pathForFileNamed:inFolder:cache:, paths, preloadFileLists, OOOpenGLExtensionManager::reset, reversePathEnumerator, and setUseAddOns:.

Here is the call graph for this function:

Here is the caller graph for this function:

pathsWithAddOns

+ (NSArray *) pathsWithAddOns

Definition at line 218 of file ResourceManager.m.

{
    if ([sSearchPaths count] > 0)  return sSearchPaths;
 
    if (sUseAddOns == nil)
    {
        sUseAddOns = [[NSString alloc] initWithString:SCENARIO_OXP_DEFINITION_ALL];
        sUseAddOnsParts = [[sUseAddOns componentsSeparatedByString:@";"] retain];
    }
    
    /* Handle special case of 'strict mode' efficiently */
    // testing actual string
    if ([sUseAddOns isEqualToString:SCENARIO_OXP_DEFINITION_NONE])
    {
        return (NSArray *)[NSArray arrayWithObject:[self builtInPath]];
    }
 
    [sErrors release];
    sErrors = nil;
    
    NSFileManager           *fmgr = [NSFileManager defaultManager];
    NSArray                 *rootPaths = nil;
    NSMutableArray          *existingRootPaths = nil;
    NSEnumerator            *pathEnum = nil;
    NSString                *root = nil;
    NSDirectoryEnumerator   *dirEnum = nil;
    NSString                *subPath = nil;
    NSString                *path = nil;
    BOOL                    isDirectory;
    
    // Copy those root paths that actually exist to search paths.
    rootPaths = [self rootPaths];
    existingRootPaths = [NSMutableArray arrayWithCapacity:[rootPaths count]];
    for (pathEnum = [rootPaths objectEnumerator]; (root = [pathEnum nextObject]); )
    {
        if ([fmgr fileExistsAtPath:root isDirectory:&isDirectory] && isDirectory)
        {
            [existingRootPaths addObject:root];
        }
    }
    
    // validate default search paths
    DESTROY(sSearchPaths);
    sSearchPaths = [NSMutableArray new];
    foreach(path, existingRootPaths)
    {
        [self checkPotentialPath:path :sSearchPaths];
    }
    
    // Iterate over root paths.
    for (pathEnum = [existingRootPaths objectEnumerator]; (root = [pathEnum nextObject]); )
    {
        // Iterate over each root path's contents.
        if ([fmgr fileExistsAtPath:root isDirectory:&isDirectory] && isDirectory)
        {
            for (dirEnum = [fmgr enumeratorAtPath:root]; (subPath = [dirEnum nextObject]); )
            {
                // Check if it's a directory.
                path = [root stringByAppendingPathComponent:subPath];
                if ([fmgr fileExistsAtPath:path isDirectory:&isDirectory])
                {
                    if (isDirectory)
                    {
                        // If it is, is it an OXP?.
                        if ([[[path pathExtension] lowercaseString] isEqualToString:@"oxp"])
                        {
                            [self checkPotentialPath:path :sSearchPaths];
                            if ([sSearchPaths containsObject:path])  [self checkOXPMessagesInPath:path];
                        }
                        else
                        {
                            // If not, don't search subdirectories.
                            [dirEnum skipDescendents];
                        }
                    }
                    else
                    {
                        // If not a directory, is it an OXZ?
                        if ([[[path pathExtension] lowercaseString] isEqualToString:@"oxz"])
                        {
                            [self checkPotentialPath:path :sSearchPaths];
                            if ([sSearchPaths containsObject:path])  [self checkOXPMessagesInPath:path];
                        }
                    }
                }
            }
        }
    }
    
    for (pathEnum = [sExternalPaths objectEnumerator]; (path = [pathEnum nextObject]); )
    {
        [self checkPotentialPath:path :sSearchPaths];
        if ([sSearchPaths containsObject:path])  [self checkOXPMessagesInPath:path];
    }
 
    /* If a scenario restriction is *not* in place, remove
     * scenario-only OXPs. */
    // test string
    if ([sUseAddOns isEqualToString:SCENARIO_OXP_DEFINITION_ALL])
    {
        [self filterSearchPathsToExcludeScenarioOnlyPaths:sSearchPaths];
    }
 
    /* This is a conservative filter. It probably gets rid of more
     * OXPs than it technically needs to in certain situations with
     * dependency chains, but really any conflict here needs to be
     * resolved by the user rather than Oolite. The point is to avoid
     * loading OXPs which we shouldn't; if doing so takes out other
     * OXPs which would have been safe, that's not important. */
    [self filterSearchPathsForConflicts:sSearchPaths];
 
    /* This one needs to be run repeatedly to be sure. Take the chain
     * A depends on B depends on C. A and B are installed. A is
     * checked first, and depends on B, which is thought to be
     * okay. So A is kept. Then B is checked and removed. A must then
     * be rechecked. This function therefore is run repeatedly until a
     * run of it removes no further items.
     *
     * There may well be more elegant and efficient ways to do this
     * but this is already fast enough for most purposes.
     */
    while (![self filterSearchPathsForRequirements:sSearchPaths]) {}
 
    /* If a scenario restriction is in place, restrict OXPs to the
     * ones valid for the scenario only. */
    // test string
    if (![sUseAddOns isEqualToString:SCENARIO_OXP_DEFINITION_ALL])
    {
        [self filterSearchPathsByScenario:sSearchPaths];
    }
 
    [self checkCacheUpToDateForPaths:sSearchPaths];
    
    return sSearchPaths;
}

References builtInPath, checkCacheUpToDateForPaths:, checkOXPMessagesInPath:, checkPotentialPath:path:, count, DESTROY, filterSearchPathsByScenario:, filterSearchPathsForConflicts:, filterSearchPathsToExcludeScenarioOnlyPaths:, nil, pathsWithAddOns, rootPaths, SCENARIO_OXP_DEFINITION_ALL, SCENARIO_OXP_DEFINITION_NONE, sErrors, sExternalPaths, sSearchPaths, sUseAddOns, and sUseAddOnsParts.

Referenced by paths, pathsWithAddOns, and resetManifestKnowledgeForOXZManager.

Here is the call graph for this function:

Here is the caller graph for this function:

preloadFileListFromFolder:forFolders:

+ (void) preloadFileListFromFolder: (NSString *) path forFolders: (NSArray *) folders

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 424 of file ResourceManager.m.

                                  :(NSString *)path forFolders:(NSArray *)folders
{
    NSFileManager *fmgr         = [NSFileManager defaultManager];
    NSString *subFolder         = nil;
    NSString *subFolderPath     = nil;
    NSArray *fileList           = nil;
    NSString *fileName          = nil;
 
    // search each subfolder for files
    foreach (subFolder, folders)
    {
        subFolderPath = [path stringByAppendingPathComponent:subFolder];
        fileList = [fmgr oo_directoryContentsAtPath:subFolderPath];
        foreach (fileName, fileList)
        {
            [self preloadFilePathFor:fileName inFolder:subFolder atPath:[subFolderPath stringByAppendingPathComponent:fileName]];
        }
    }
}

References nil, and preloadFilePathFor:inFolder:atPath:.

Referenced by preloadFileLists.

Here is the call graph for this function:

Here is the caller graph for this function:

preloadFileListFromOXZ:forFolders:

+ (void) preloadFileListFromOXZ: (NSString *) path forFolders: (NSArray *) folders

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 377 of file ResourceManager.m.

                               :(NSString *)path forFolders:(NSArray *)folders
{
    unzFile uf = NULL;
    const char* zipname = [path UTF8String];
    char componentName[512];
 
    if (zipname != NULL)
    {
        uf = unzOpen64(zipname);
    }
    if (uf == NULL)
    {
        OOLog(@"resourceManager.error",@"Could not open .oxz at %@ as zip file",path);
        return;
    }
    if (unzGoToFirstFile(uf) == UNZ_OK)
    {
        do 
        {
            unzGetCurrentFileInfo64(uf, NULL,
                                    componentName, 512,
                                    NULL, 0,
                                    NULL, 0);
            NSString *zipEntry = [NSString stringWithUTF8String:componentName];
            NSArray *pathBits = [zipEntry pathComponents];
            if ([pathBits count] >= 2)
            {
                NSString *folder = [pathBits oo_stringAtIndex:0];
                if ([folders containsObject:folder])
                {
                    NSRange bitRange;
                    bitRange.location = 1;
                    bitRange.length = [pathBits count]-1;
                    NSString *file = [NSString pathWithComponents:[pathBits subarrayWithRange:bitRange]];
                    NSString *fullPath = [[path stringByAppendingPathComponent:folder] stringByAppendingPathComponent:file];
                    
                    [self preloadFilePathFor:file inFolder:folder atPath:fullPath];
                }
            }
 
        } 
        while (unzGoToNextFile(uf) == UNZ_OK);
    }
    unzClose(uf);
}

References count, OOLog, preloadFilePathFor:inFolder:atPath:, UNZ_OK, unzClose(), unzGetCurrentFileInfo64(), unzGoToFirstFile(), unzGoToNextFile(), and unzOpen64().

Referenced by preloadFileLists.

Here is the call graph for this function:

Here is the caller graph for this function:

preloadFileLists

+ (void) preloadFileLists

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 355 of file ResourceManager.m.

{
    NSString         *path = nil;
    NSEnumerator *pathEnum = nil;
 
    // folders which may contain files to be cached
    NSArray *folders = [NSArray arrayWithObjects:@"AIs",@"Images",@"Models",@"Music",@"Scenarios",@"Scripts",@"Shaders",@"Sounds",@"Textures",nil];
 
    for (pathEnum = [[ResourceManager paths] reverseObjectEnumerator]; (path = [pathEnum nextObject]); )
    {
        if ([path hasSuffix:@".oxz"])
        {
            [self preloadFileListFromOXZ:path forFolders:folders];
        }
        else
        {
            [self preloadFileListFromFolder:path forFolders:folders];
        }
    }
}

References nil, paths, preloadFileListFromFolder:forFolders:, preloadFileListFromOXZ:forFolders:, and preloadFileLists.

Referenced by preloadFileLists, and setUseAddOns:.

Here is the call graph for this function:

Here is the caller graph for this function:

preloadFilePathFor:inFolder:atPath:

+ (void) preloadFilePathFor: (NSString *) fileName inFolder: (NSString *) subFolder atPath: (NSString *) path

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 445 of file ResourceManager.m.

                           :(NSString *)fileName inFolder:(NSString *)subFolder atPath:(NSString *)path
{
    OOCacheManager  *cache = [OOCacheManager sharedCache];
    NSString *cacheKey = [NSString stringWithFormat:@"%@/%@", subFolder, fileName];
    NSString *result = [cache objectForKey:cacheKey inCache:@"resolved paths"];
    // if nil, not found in another OXP already
    if (result == nil)
    {
        OOLog(@"resourceManager.foundFile.preLoad", @"Found %@/%@ at %@", subFolder, fileName, path);
        [cache setObject:path forKey:cacheKey inCache:@"resolved paths"];
    }
}

References nil, OOCacheManager::objectForKey:inCache:, OOLog, OOCacheManager::setObject:forKey:inCache:, and OOCacheManager::sharedCache.

Referenced by preloadFileListFromFolder:forFolders:, and preloadFileListFromOXZ:forFolders:.

Here is the call graph for this function:

Here is the caller graph for this function:

reset

+ (void) reset

Definition at line 110 of file ResourceManager.m.

{
    sFirstRun = YES;
    DESTROY(sUseAddOns);
    DESTROY(sUseAddOnsParts);
    DESTROY(sSearchPaths);
    DESTROY(sOXPsWithMessagesFound);
    DESTROY(sExternalPaths);
    DESTROY(sErrors);
    DESTROY(sOXPManifests);
}

References DESTROY, reset, sErrors, sExternalPaths, sFirstRun, sOXPManifests, sOXPsWithMessagesFound, sSearchPaths, sUseAddOns, and sUseAddOnsParts.

Referenced by OOOXZManager::isRestarting, reset, and setUseAddOns:.

Here is the call graph for this function:

Here is the caller graph for this function:

resetManifestKnowledgeForOXZManager

+ (void) resetManifestKnowledgeForOXZManager

Definition at line 123 of file ResourceManager.m.

{
    DESTROY(sUseAddOns);
    DESTROY(sUseAddOnsParts);
    DESTROY(sSearchPaths);
    DESTROY(sOXPManifests);
    [ResourceManager pathsWithAddOns];
}

References DESTROY, pathsWithAddOns, resetManifestKnowledgeForOXZManager, sOXPManifests, sSearchPaths, sUseAddOns, and sUseAddOnsParts.

Referenced by OOOXZManager::managedOXZs, OOOXZManager(NSURLConnectionDataDelegate)::processDownloadedOXZ, and resetManifestKnowledgeForOXZManager.

Here is the call graph for this function:

Here is the caller graph for this function:

retrieveFileNamed:inFolder:cache:key:class:usePathCache:

+ (id) retrieveFileNamed: (NSString *) fileName inFolder: (NSString *) folderName cache: (NSMutableDictionary **) ioCache key: (NSString *) key class: (Class) class usePathCache: (BOOL) useCache

implementation

Definition at line 1996 of file ResourceManager.m.

                        :(NSString *)fileName
                inFolder:(NSString *)folderName
                   cache:(NSMutableDictionary **)ioCache
                     key:(NSString *)key
                   class:(Class)class
            usePathCache:(BOOL)useCache
{
    id              result = nil;
    NSString        *path = nil;
    
    if (ioCache)
    {
        if (key == nil)  key = [NSString stringWithFormat:@"%@:%@", folderName, fileName];
        if (*ioCache != nil)
        {
            // return the cached object, if any
            result = [*ioCache objectForKey:key];
            if (result)  return result;
        }
    }
    
    path = [self pathForFileNamed:fileName inFolder:folderName cache:useCache];
    if (path != nil)  result = [[[class alloc] initWithContentsOfFile:path] autorelease];
    
    if (result != nil && ioCache != NULL)
    {
        if (*ioCache == nil)  *ioCache = [[NSMutableDictionary alloc] init];
        [*ioCache setObject:result forKey:key];
    }
    
    return result;
}

References nil, and pathForFileNamed:inFolder:cache:.

Referenced by ooMusicNamed:inFolder:, and ooSoundNamed:inFolder:.

Here is the call graph for this function:

Here is the caller graph for this function:

reversePathEnumerator

+ (NSEnumerator *) reversePathEnumerator

Definition at line 565 of file ResourceManager.m.

{
    return [[self paths] reverseObjectEnumerator];
}

References paths, and reversePathEnumerator.

Referenced by arrayFromFilesNamed:inFolder:andMerge:cache:, dictionaryFromFilesNamed:inFolder:mergeMode:cache:, and reversePathEnumerator.

Here is the call graph for this function:

Here is the caller graph for this function:

roleCategoriesDictionary

+ (NSDictionary *) roleCategoriesDictionary

Definition at line 1781 of file ResourceManager.m.

{
    NSMutableDictionary *roleCategories = [NSMutableDictionary dictionaryWithCapacity:16];
 
    NSString *path = nil;
    NSString *configPath = nil;
    NSDictionary *categories = nil;
    
    NSEnumerator *pathEnum = [self pathEnumerator];
    while ((path = [pathEnum nextObject]))
    {
        if ([ResourceManager corePlist:@"role-categories.plist" excludedAt:path])
        {
            continue;
        }
 
        configPath = [[path stringByAppendingPathComponent:@"Config"]
                      stringByAppendingPathComponent:@"role-categories.plist"];
        categories = OODictionaryFromFile(configPath);
        if (categories != nil)
        {
            [ResourceManager mergeRoleCategories:categories intoDictionary:roleCategories];
        }
    }
    
    /* If the old pirate-victim-roles files exist, merge them in */
    NSArray *pirateVictims = [ResourceManager arrayFromFilesNamed:@"pirate-victim-roles.plist" inFolder:@"Config" andMerge:YES];
    if (OOEnforceStandards() && [pirateVictims count] > 0)
    {
        OOStandardsDeprecated(@"pirate-victim-roles.plist is still being used.");
    }
    [ResourceManager mergeRoleCategories:[NSDictionary dictionaryWithObject:pirateVictims forKey:@"oolite-pirate-victim"] intoDictionary:roleCategories];
 
    return [[roleCategories copy] autorelease];
}

References arrayFromFilesNamed:inFolder:andMerge:, count, mergeRoleCategories:intoDictionary:, nil, OODictionaryFromFile(), OOEnforceStandards(), OOStandardsDeprecated(), pathEnumerator, and roleCategoriesDictionary.

Referenced by roleCategoriesDictionary, and Universe::setUpSettings.

Here is the call graph for this function:

Here is the caller graph for this function:

rootPaths

+ (NSArray *) rootPaths

Definition at line 163 of file ResourceManager.m.

{
    static NSArray *sRootPaths = nil;
    if (sRootPaths == nil) {
        /* Built-in data, then managed OXZs, then manually installed ones,
         * which may be useful for debugging/testing purposes. */
        sRootPaths = [NSArray arrayWithObjects:[self builtInPath], [[OOOXZManager sharedManager] installPath], nil];
        sRootPaths = [[sRootPaths arrayByAddingObjectsFromArray:[self userRootPaths]] retain];
    }
    return sRootPaths;
}

References builtInPath, OOOXZManager::installPath, nil, rootPaths, OOOXZManager::sharedManager, and userRootPaths.

Referenced by logControlDictionary, pathsWithAddOns, and rootPaths.

Here is the call graph for this function:

Here is the caller graph for this function:

setUseAddOns:

+ (void) setUseAddOns:

(NSString *)

useAddOns

Definition at line 506 of file ResourceManager.m.

                    :(NSString *)useAddOns
{
    if (sFirstRun || ![useAddOns isEqualToString:sUseAddOns])
    {
        [self reset];
        sFirstRun = NO;
        DESTROY(sUseAddOnsParts);
        DESTROY(sUseAddOns);
        sUseAddOns = [useAddOns retain];
        sUseAddOnsParts = [[sUseAddOns componentsSeparatedByString:@";"] retain];
 
        [ResourceManager clearCaches];
        OOHUDResetTextEngine();
 
        OOCacheManager *cmgr = [OOCacheManager sharedCache];
        /* only allow cache writes for the "all OXPs" default
         *
         * cache should be less necessary for restricted sets anyway */
        // testing the actual string here
        if ([sUseAddOns isEqualToString:SCENARIO_OXP_DEFINITION_ALL])
        {
            [cmgr reloadAllCaches];
            [cmgr setAllowCacheWrites:YES];
        }
        else
        {
            [cmgr clearAllCaches];
            [cmgr setAllowCacheWrites:NO];
        }
        
        [self checkCacheUpToDateForPaths:[self paths]];
        [self logPaths];
        /* preloading the file lists at this stage helps efficiency a
         * lot when many OXZs are installed */
        [self preloadFileLists];
 
    }
}

References checkCacheUpToDateForPaths:, OOCacheManager::clearAllCaches, clearCaches, DESTROY, logPaths, OOHUDResetTextEngine(), paths, preloadFileLists, OOCacheManager::reloadAllCaches, reset, SCENARIO_OXP_DEFINITION_ALL, OOCacheManager::setAllowCacheWrites:, sFirstRun, OOCacheManager::sharedCache, sUseAddOns, sUseAddOnsParts, and useAddOns.

Referenced by Universe::initWithGameView:, Universe::reinitAndShowDemo:, and OOOXPVerifier(OOPrivate)::run.

Here is the call graph for this function:

Here is the caller graph for this function:

shaderBindingTypesDictionary

+ (NSDictionary *) shaderBindingTypesDictionary

Definition at line 1889 of file ResourceManager.m.

{
    static id shaderBindingTypesDictionary = nil;
    
    if (shaderBindingTypesDictionary == nil)
    {
        NSAutoreleasePool *pool = [NSAutoreleasePool new];
        
        NSString *path = [[[ResourceManager builtInPath] stringByAppendingPathComponent:@"Config"] stringByAppendingPathComponent:@"shader-uniform-bindings.plist"];
        NSMutableDictionary *dict = [NSMutableDictionary dictionaryWithContentsOfFile:path];
        NSArray *keys = [dict allKeys];
        
        // Resolve all $inherit keys.
        unsigned changeCount = 0;
        do {
            changeCount = 0;
            NSString *key = nil;
            foreach (key, keys)
            {
                NSDictionary *value = [dict oo_dictionaryForKey:key];
                NSString *inheritKey = [value oo_stringForKey:@"$w2"];
                if (inheritKey != nil)
                {
                    changeCount++;
                    NSMutableDictionary *mutableValue = [[value mutableCopy] autorelease];
                    [mutableValue removeObjectForKey:@"$w3"];
                    NSDictionary *inherited = [dict oo_dictionaryForKey:inheritKey];
                    if (inherited != nil)
                    {
                        [mutableValue addEntriesFromDictionary:inherited];
                    }
                    
                    [dict setObject:[[mutableValue copy] autorelease] forKey:key];
                }
            }
        } while (changeCount != 0);
        
        shaderBindingTypesDictionary = [dict copy];
        
        [pool release];
    }
    
    return shaderBindingTypesDictionary;
}

References builtInPath, nil, and shaderBindingTypesDictionary.

Referenced by shaderBindingTypesDictionary, and OODefaultShaderSynthesizer::writeLightMaps.

Here is the call graph for this function:

Here is the caller graph for this function:

stringFromFilesNamed:inFolder:

+ (NSString *) stringFromFilesNamed:		(NSString *)	fileName
inFolder:		(NSString *)	folderName

Definition at line 2052 of file ResourceManager.m.

                                   :(NSString *)fileName inFolder:(NSString *)folderName
{
    return [self stringFromFilesNamed:fileName inFolder:folderName cache:YES];
}

References stringFromFilesNamed:inFolder:cache:.

Referenced by GetShaderSource().

Here is the call graph for this function:

Here is the caller graph for this function:

stringFromFilesNamed:inFolder:cache:

+ (NSString *) stringFromFilesNamed:		(NSString *)	fileName
inFolder:		(NSString *)	folderName
cache:		(BOOL)	useCache

Definition at line 2058 of file ResourceManager.m.

                                   :(NSString *)fileName inFolder:(NSString *)folderName cache:(BOOL)useCache
{
    id              result = nil;
    NSString        *path = nil;
    NSString        *key = nil;
    
    if (useCache)
    {
        key = [NSString stringWithFormat:@"%@:%@", folderName, fileName];
        if (sStringCache != nil)
        {
            // return the cached object, if any
            result = [sStringCache objectForKey:key];
            if (result)  return result;
        }
    }
    
    path = [self pathForFileNamed:fileName inFolder:folderName cache:YES];
    if (path != nil)  result = [NSString stringWithContentsOfUnicodeFile:path];
    
    if (result != nil && useCache)
    {
        if (sStringCache == nil)  sStringCache = [[NSMutableDictionary alloc] init];
        [sStringCache setObject:result forKey:key];
    }
    
    return result;
}

References nil, pathForFileNamed:inFolder:cache:, and sStringCache.

Referenced by OOMesh(Private)::loadData:scaleFactor:, and stringFromFilesNamed:inFolder:.

Here is the call graph for this function:

Here is the caller graph for this function:

systemDescriptionManager

+ (OOSystemDescriptionManager *) systemDescriptionManager

Definition at line 1838 of file ResourceManager.m.

{
    OOLog(@"resourceManager.planetinfo.load", @"%@", @"Initialising manager");
    OOSystemDescriptionManager *manager = [[OOSystemDescriptionManager alloc] init];
    
    NSString *path = nil;
    NSString *configPath = nil;
    NSDictionary *categories = nil;
    NSString *systemKey = nil;
 
    NSEnumerator *pathEnum = [self pathEnumerator]; 
    while ((path = [pathEnum nextObject]))
    {
        if ([ResourceManager corePlist:@"planetinfo.plist" excludedAt:path])
        {
            continue;
        }
        configPath = [[path stringByAppendingPathComponent:@"Config"]
                      stringByAppendingPathComponent:@"planetinfo.plist"];
        categories = OODictionaryFromFile(configPath);
        if (categories != nil)
        {
            foreachkey(systemKey,categories)
            {
                NSDictionary *values = [categories oo_dictionaryForKey:systemKey defaultValue:nil];
                if (values != nil)
                {
                    if ([systemKey isEqualToString:PLANETINFO_UNIVERSAL_KEY])
                    {
                        [manager setUniversalProperties:values];
                    }
                    else if ([systemKey isEqualToString:PLANETINFO_INTERSTELLAR_KEY])
                    {
                        [manager setInterstellarProperties:values];
                    }
                    else
                    {
                        [manager setProperties:values forSystemKey:systemKey];
                    }
                }
            }
        }
    }
    OOLog(@"resourceManager.planetinfo.load", @"%@", @"Caching routes");
    [manager buildRouteCache];
    OOLog(@"resourceManager.planetinfo.load", @"%@", @"Initialised manager");
    return [manager autorelease];
}

References OOSystemDescriptionManager::buildRouteCache, foreachkey, nil, OODictionaryFromFile(), OOLog, pathEnumerator, PLANETINFO_INTERSTELLAR_KEY, PLANETINFO_UNIVERSAL_KEY, OOSystemDescriptionManager::setInterstellarProperties:, OOSystemDescriptionManager::setProperties:forSystemKey:, OOSystemDescriptionManager::setUniversalProperties:, and systemDescriptionManager.

Referenced by Universe::setUpSettings, and systemDescriptionManager.

Here is the call graph for this function:

Here is the caller graph for this function:

useAddOns

+ (NSString *) useAddOns

Definition at line 500 of file ResourceManager.m.

{
    return sUseAddOns;
}

References sUseAddOns, and useAddOns.

Referenced by setUseAddOns:, useAddOns, and GameController::validateMenuItem:.

Here is the call graph for this function:

Here is the caller graph for this function:

userRootPaths

+ (NSArray *) userRootPaths

Definition at line 176 of file ResourceManager.m.

{
    static NSArray          *sUserRootPaths = nil;
    
    if (sUserRootPaths == nil)
    {
        // the paths are now in order of preference as per yesterday's talk. -- Kaks 2010-05-05
        NSArray *defaultAddOnsPaths = [NSArray arrayWithObjects:
#if OOLITE_MAC_OS_X
                      [[[[NSHomeDirectory() stringByAppendingPathComponent:@"Library"]
                         stringByAppendingPathComponent:@"Application Support"]
                         stringByAppendingPathComponent:@"Oolite"]
                        stringByAppendingPathComponent:@"AddOns"],
                      [[[[NSBundle mainBundle] bundlePath]
                         stringByDeletingLastPathComponent]
                        stringByAppendingPathComponent:@"AddOns"],
#endif
#if !OOLITE_WINDOWS
                      @"AddOns",
#endif
                      [[OOOXZManager sharedManager] extractAddOnsPath],
                      nil];
        sUserRootPaths = [[[[OOOXZManager sharedManager] additionalAddOnsPaths] arrayByAddingObjectsFromArray:defaultAddOnsPaths] retain];
    }
    OOLog(@"searchPaths.debug",@"%@",sUserRootPaths);
    return sUserRootPaths;
}

References OOOXZManager::additionalAddOnsPaths, OOOXZManager::extractAddOnsPath, nil, OOLog, OOOXZManager::sharedManager, and userRootPaths.

Referenced by OOOXZManager(NSURLConnectionDataDelegate)::extractionBasePathForIdentifier:andVersion:, rootPaths, GameController::showAddOnsAction:, and userRootPaths.

Here is the call graph for this function:

Here is the caller graph for this function:

validateManifest:forOXP:

+ (BOOL) validateManifest: (NSDictionary*) manifest forOXP: (NSString *) path

implementation

Provided by category ResourceManager(OOPrivate).

Definition at line 660 of file ResourceManager.m.

                         :(NSDictionary*)manifest forOXP:(NSString *)path
{
    if (EXPECT_NOT(sOXPManifests == nil))
    {
        sOXPManifests = [[NSMutableDictionary alloc] initWithCapacity:32];
    }
    
    BOOL        OK = YES;
    NSString    *identifier = [manifest oo_stringForKey:kOOManifestIdentifier defaultValue:nil];
    NSString    *version = [manifest oo_stringForKey:kOOManifestVersion defaultValue:nil];
    NSString    *required = [manifest oo_stringForKey:kOOManifestRequiredOoliteVersion defaultValue:nil];
    NSString    *title = [manifest oo_stringForKey:kOOManifestTitle defaultValue:nil];
 
    if (identifier == nil)
    {
        OOLog(@"oxp.noManifest", @"OXZ %@ manifest.plist has no '%@' field.", path, kOOManifestIdentifier);
        [self addErrorWithKey:@"oxp-manifest-incomplete" param1:title param2:kOOManifestIdentifier];
        OK = NO;
    }
    if (version == nil)
    {
        OOLog(@"oxp.noManifest", @"OXZ %@ manifest.plist has no '%@' field.", path, kOOManifestVersion);
        [self addErrorWithKey:@"oxp-manifest-incomplete" param1:title param2:kOOManifestVersion];
        OK = NO;
    }
    if (required == nil)
    {
        OOLog(@"oxp.noManifest", @"OXZ %@ manifest.plist has no '%@' field.", path, kOOManifestRequiredOoliteVersion);
        [self addErrorWithKey:@"oxp-manifest-incomplete" param1:title param2:kOOManifestRequiredOoliteVersion];
        OK = NO;
    }
    if (title == nil)
    {
        OOLog(@"oxp.noManifest", @"OXZ %@ manifest.plist has no '%@' field.", path, kOOManifestTitle);
        [self addErrorWithKey:@"oxp-manifest-incomplete" param1:title param2:kOOManifestTitle];
        OK = NO;
    }
    if (!OK)
    {
        return NO;
    }
    OK = [self checkVersionCompatibility:manifest forOXP:title];
 
    if (!OK)
    {
        NSString *version = [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleVersion"];
        OOLog(@"oxp.versionMismatch", @"OXP %@ is incompatible with version %@ of Oolite.", path, version);
        [self addErrorWithKey:@"oxp-is-incompatible" param1:[path lastPathComponent] param2:version];
        return NO;
    }
 
    NSDictionary *duplicate = [sOXPManifests objectForKey:identifier];
    if (duplicate != nil)
    {
        OOLog(@"oxp.duplicate", @"OXP %@ has the same identifier (%@) as %@ which has already been loaded.",path,identifier,[duplicate oo_stringForKey:kOOManifestFilePath]);
        [self addErrorWithKey:@"oxp-manifest-duplicate" param1:path param2:[duplicate oo_stringForKey:kOOManifestFilePath]];
        return NO;
    }
    NSMutableDictionary *mData = [NSMutableDictionary dictionaryWithDictionary:manifest];
    [mData setObject:path forKey:kOOManifestFilePath];
    // add an extra key
    [sOXPManifests setObject:mData forKey:identifier];
    return YES;
}

References addErrorWithKey:param1:param2:, checkVersionCompatibility:forOXP:, EXPECT_NOT, kOOManifestFilePath, kOOManifestIdentifier, kOOManifestRequiredOoliteVersion, kOOManifestTitle, kOOManifestVersion, nil, OOLog, and sOXPManifests.

Referenced by checkPotentialPath:path:.

Here is the call graph for this function:

Here is the caller graph for this function:

whitelistDictionary

+ (NSDictionary *) whitelistDictionary

Definition at line 1680 of file ResourceManager.m.

{
    static id whitelistDictionary = nil;
    
    if (whitelistDictionary == nil)
    {
        NSString *path = [[[ResourceManager builtInPath] stringByAppendingPathComponent:@"Config"] stringByAppendingPathComponent:@"whitelist.plist"];
        whitelistDictionary = [NSDictionary dictionaryWithContentsOfFile:path];
        if (whitelistDictionary == nil)  whitelistDictionary = [NSNull null];
        
        [whitelistDictionary retain];
    }
    
    if (whitelistDictionary == [NSNull null])  return nil;
    return whitelistDictionary;
}

References builtInPath, nil, and whitelistDictionary.

Referenced by HeadUpDisplay::addDial:, AI(OOPrivate)::cleanActions:forHandler:state:stateMachine:, LookUpLegacySelector(), OOUniformBindingPermitted(), OOAIStateMachineVerifierStage::run, SanitizeActionMethod(), SanitizeQueryMethod(), and whitelistDictionary.

Here is the call graph for this function:

Here is the caller graph for this function:

writeDiagnosticData:toFileNamed:

+ (BOOL) writeDiagnosticData:		(NSData *)	data
toFileNamed:		(NSString *)	name

Definition at line 2167 of file ResourceManager.m.

                            :(NSData *)data toFileNamed:(NSString *)name
{
    if (data == nil || name == nil)  return NO;
    
    NSString *directory = [self diagnosticFileLocation];
    if (directory == nil)  return NO;
    
    NSArray *nameComponents = [name componentsSeparatedByString:@"/"];
    NSUInteger count = [nameComponents count];
    if (count > 1)
    {
        name = [nameComponents lastObject];
        
        for (NSUInteger i = 0; i < count - 1; i++)
        {
            NSString *component = [nameComponents objectAtIndex:i];
            if ([component hasPrefix:@"."])
            {
                component = [@"!" stringByAppendingString:[component substringFromIndex:1]];
            }
            directory = [directory stringByAppendingPathComponent:component];
            [[NSFileManager defaultManager] oo_createDirectoryAtPath:directory attributes:nil];
        }
    }
    
    return [data writeToFile:[directory stringByAppendingPathComponent:name] atomically:YES];
}

References count, diagnosticFileLocation, and nil.

Referenced by writeDiagnosticPList:toFileNamed:, and writeDiagnosticString:toFileNamed:.

Here is the call graph for this function:

Here is the caller graph for this function:

writeDiagnosticPList:toFileNamed:

+ (BOOL) writeDiagnosticPList:		(id)	plist
toFileNamed:		(NSString *)	name

Definition at line 2202 of file ResourceManager.m.

                             :(id)plist toFileNamed:(NSString *)name
{
    NSData *data = [plist oldSchoolPListFormatWithErrorDescription:NULL];
    if (data == nil)  [NSPropertyListSerialization dataFromPropertyList:plist format:NSPropertyListXMLFormat_v1_0 errorDescription:NULL];
    if (data == nil)  return NO;
    
    return [self writeDiagnosticData:data toFileNamed:name];
}

References nil, and writeDiagnosticData:toFileNamed:.

Here is the call graph for this function:

writeDiagnosticString:toFileNamed:

+ (BOOL) writeDiagnosticString:		(NSString *)	string
toFileNamed:		(NSString *)	name

Definition at line 2196 of file ResourceManager.m.

                              :(NSString *)string toFileNamed:(NSString *)name
{
    return [self writeDiagnosticData:[string dataUsingEncoding:NSUTF8StringEncoding] toFileNamed:name];
}

References writeDiagnosticData:toFileNamed:.

Referenced by OOOXPVerifier(OOPrivate)::dumpDebugGraphviz, and SVGDumpEnd().

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• src/Core/ResourceManager.h
• src/Core/ResourceManager.m