OOOXZManager(NSURLConnectionDataDelegate) Category Reference

Instance Methods
(NSString *)	- manifestPath
(NSString *)	- downloadPath
(NSString *)	- extractionBasePathForIdentifier:andVersion:
(NSString *)	- dataURL
(NSString *)	- humanSize:
(BOOL)	- ensureInstallPath
(BOOL)	- beginDownload:
(BOOL)	- processDownloadedManifests
(BOOL)	- processDownloadedOXZ
(OXZInstallableState)	- installableState:
(OOColor *)	- colorForManifest:
(NSString *)	- installStatusForManifest:
(BOOL)	- validateFilter:
(void)	- setOXZList:
(void)	- setFilteredList:
(NSArray *)	- applyCurrentFilter:
(void)	- setCurrentDownload:withLabel:
(void)	- setProgressStatus:
(BOOL)	- installOXZ:
(BOOL)	- updateAllOXZ
(BOOL)	- removeOXZ:
(NSArray *)	- installOptions
(NSArray *)	- removeOptions
(NSString *)	- extractOXZ:
(void)	- connection:didFailWithError:
(void)	- connection:didReceiveResponse:
(void)	- connection:didReceiveData:
(void)	- connectionDidFinishLoading:

Detailed Description

Definition at line 126 of file OOOXZManager.m.

Method Documentation

applyCurrentFilter:

- (NSArray *) applyCurrentFilter:

(NSArray *)

list

Extends class OOOXZManager.

Definition at line 414 of file OOOXZManager.m.

                                :(NSArray *)list
{
    SEL filterSelector = @selector(applyFilterByNoFilter:);
    NSString *parameter  = nil;
    if ([_currentFilter isEqualToString:kOOOXZFilterUpdates])
    {
        filterSelector = @selector(applyFilterByUpdateRequired:);
    }
    else if ([_currentFilter isEqualToString:kOOOXZFilterInstallable])
    {
        filterSelector = @selector(applyFilterByInstallable:);
    }
    else if ([_currentFilter hasPrefix:kOOOXZFilterKeyword])
    {
        filterSelector = @selector(applyFilterByKeyword:keyword:);
        parameter = [_currentFilter substringFromIndex:[kOOOXZFilterKeyword length]];
    }
    else if ([_currentFilter hasPrefix:kOOOXZFilterAuthor])
    {
        filterSelector = @selector(applyFilterByAuthor:author:);
        parameter = [_currentFilter substringFromIndex:[kOOOXZFilterAuthor length]];
    }
    else if ([_currentFilter hasPrefix:kOOOXZFilterDays])
    {
        filterSelector = @selector(applyFilterByDays:days:);
        parameter = [_currentFilter substringFromIndex:[kOOOXZFilterDays length]];
    }
    else if ([_currentFilter hasPrefix:kOOOXZFilterTag])
    {
        filterSelector = @selector(applyFilterByTag:tag:);
        parameter = [_currentFilter substringFromIndex:[kOOOXZFilterTag length]];
    }
    else if ([_currentFilter hasPrefix:kOOOXZFilterCategory])
    {
        filterSelector = @selector(applyFilterByCategory:category:);
        parameter = [_currentFilter substringFromIndex:[kOOOXZFilterCategory length]];
    }
 
    NSMutableArray *filteredList = [NSMutableArray arrayWithCapacity:[list count]];
    NSDictionary *manifest       = nil;
    NSInvocation *invocation     = [NSInvocation invocationWithMethodSignature:[[self class] instanceMethodSignatureForSelector:filterSelector]];
    [invocation setSelector:filterSelector];
    [invocation setTarget:self];
    if (parameter != nil)
    {
        [invocation setArgument:&parameter atIndex:3];
    }
 
    foreach(manifest, list)
    {
        [invocation setArgument:&manifest atIndex:2];
        [invocation invoke];
        BOOL filterAccepted = NO;
        [invocation getReturnValue:&filterAccepted];
        if (filterAccepted)
        {
            [filteredList addObject:manifest];
        }
    }
    // any bad filter that gets this far is also treated as '*'
    // so don't need to explicitly test for '*' or ''
    return [[filteredList copy] autorelease];
}

References kOOOXZFilterAuthor, kOOOXZFilterCategory, kOOOXZFilterDays, kOOOXZFilterInstallable, kOOOXZFilterKeyword, kOOOXZFilterTag, kOOOXZFilterUpdates, and nil.

Referenced by OOOXZManager::gui, and OOOXZManager::showOptionsUpdate.

Here is the caller graph for this function:

beginDownload:

- (BOOL) beginDownload:

(NSMutableURLRequest *)

request

Extends class OOOXZManager.

Definition at line 640 of file OOOXZManager.m.

                      :(NSMutableURLRequest *)request
{
    NSString *userAgent = [NSString stringWithFormat:@"Oolite/%@", [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleVersion"]];
    [request setValue:userAgent forHTTPHeaderField:@"User-Agent"];
    NSURLConnection *download = [[NSURLConnection alloc] initWithRequest:request delegate:self];
    if (download)
    {
        _downloadProgress = 0;
        _downloadExpected = 0;
        NSString *label = DESC(@"oolite-oxzmanager-download-label-list");
        if (_interfaceState != OXZ_STATE_UPDATING)
        {
            NSDictionary *expectedManifest = nil;
            expectedManifest = [_filteredList objectAtIndex:_item];
 
            label = [expectedManifest oo_stringForKey:kOOManifestTitle defaultValue:DESC(@"oolite-oxzmanager-download-label-oxz")];
        }
 
        [self setCurrentDownload:download withLabel:label]; // retains it
        [download release];
        OOLog(kOOOXZDebugLog,@"Download request received, using %@ and downloading to %@",[request URL],[self downloadPath]);
        return YES;
    }
    else
    {
        OOLog(kOOOXZErrorLog,@"Unable to start downloading file at %@",[request URL]);
        _downloadStatus = OXZ_DOWNLOAD_ERROR;
        return NO;
    }
}

References DESC, downloadPath, kOOOXZDebugLog, kOOOXZErrorLog, nil, OOLog, OXZ_DOWNLOAD_ERROR, OXZ_STATE_UPDATING, and OOOXZManager::setCurrentDownload:withLabel:.

Referenced by installOXZ:, and OOOXZManager::updateManifests.

Here is the call graph for this function:

Here is the caller graph for this function:

colorForManifest:

- (OOColor *) colorForManifest:

(NSDictionary *)

manifest

Extends class OOOXZManager.

Definition at line 1104 of file OOOXZManager.m.

                              :(NSDictionary *)manifest 
{
    switch ([self installableState:manifest])
    {
    case OXZ_INSTALLABLE_OKAY:
        return [OOColor yellowColor];
    case OXZ_INSTALLABLE_UPDATE:
        return [OOColor cyanColor];
    case OXZ_INSTALLABLE_DEPENDENCIES:
        return [OOColor orangeColor];
    case OXZ_INSTALLABLE_CONFLICTS:
        return [OOColor brownColor];
    case OXZ_UNINSTALLABLE_ALREADY:
        return [OOColor whiteColor];
    case OXZ_UNINSTALLABLE_MANUAL:
        return [OOColor redColor];
    case OXZ_UNINSTALLABLE_VERSION:
        return [OOColor grayColor];
    case OXZ_UNINSTALLABLE_NOREMOTE:
        return [OOColor blueColor];
    }
    return [OOColor yellowColor]; // never
}

References OOColor::blueColor, OOColor::brownColor, OOColor::cyanColor, OOColor::grayColor, OOColor::orangeColor, OXZ_INSTALLABLE_CONFLICTS, OXZ_INSTALLABLE_DEPENDENCIES, OXZ_INSTALLABLE_OKAY, OXZ_INSTALLABLE_UPDATE, OXZ_UNINSTALLABLE_ALREADY, OXZ_UNINSTALLABLE_MANUAL, OXZ_UNINSTALLABLE_NOREMOTE, OXZ_UNINSTALLABLE_VERSION, OOColor::redColor, OOColor::whiteColor, and OOColor::yellowColor.

Referenced by OOOXZManager::showInstallOptions, and OOOXZManager::showRemoveOptions.

Here is the call graph for this function:

Here is the caller graph for this function:

connection:didFailWithError:

- (void) connection:		(NSURLConnection *)	connection
didFailWithError:		(NSError *)	error

Extends class OOOXZManager.

Definition at line 2389 of file OOOXZManager.m.

                  :(NSURLConnection *)connection didFailWithError:(NSError *)error
{
    _downloadStatus = OXZ_DOWNLOAD_ERROR;
    OOLog(kOOOXZErrorLog,@"Error downloading file: %@",[error description]);
    [_fileWriter closeFile];
    DESTROY(_fileWriter);
    DESTROY(_currentDownload);
}

References DESTROY, kOOOXZErrorLog, OOLog, and OXZ_DOWNLOAD_ERROR.

connection:didReceiveData:

- (void) connection:		(NSURLConnection *)	connection
didReceiveData:		(NSData *)	data

Extends class OOOXZManager.

Definition at line 2331 of file OOOXZManager.m.

                  :(NSURLConnection *)connection didReceiveData:(NSData *)data
{
    OOLog(kOOOXZDebugLog,@"Downloaded %llu bytes",[data length]);
    [_fileWriter seekToEndOfFile];
    [_fileWriter writeData:data];
    _downloadProgress += [data length];
    [self gui]; // update GUI
#if OOLITE_WINDOWS
    /* Irritating fix to issue https://github.com/OoliteProject/oolite/issues/95
     *
     * The problem is that on MINGW, GNUStep makes all socket streams
     * blocking, which causes problems with the run loop. Calling this
     * method of the run loop forces it to execute all already
     * scheduled items with a time in the past, before any more items
     * are placed on it, which means that the main game update gets a
     * chance to run.
     *
     * This stops the interface freezing - and Oolite appearing to
     * have stopped responding to the OS - when downloading large
     * (>20Mb) OXZ files.
     *
     * CIM 6 July 2014
     */
    [[NSRunLoop currentRunLoop] limitDateForMode:NSDefaultRunLoopMode];
#endif
}

References OOOXZManager::gui, kOOOXZDebugLog, and OOLog.

Here is the call graph for this function:

connection:didReceiveResponse:

- (void) connection:		(NSURLConnection *)	connection
didReceiveResponse:		(NSURLResponse *)	response

Extends class OOOXZManager.

Definition at line 2313 of file OOOXZManager.m.

                  :(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response
{
    _downloadStatus = OXZ_DOWNLOAD_RECEIVING;
    OOLog(kOOOXZDebugLog, @"%@", @"Download receiving");
    _downloadExpected = [response expectedContentLength];
    _downloadProgress = 0;
    DESTROY(_fileWriter);
    [[NSFileManager defaultManager] createFileAtPath:[self downloadPath] contents:nil attributes:nil];
    _fileWriter = [[NSFileHandle fileHandleForWritingAtPath:[self downloadPath]] retain];
    if (_fileWriter == nil)
    {
        // file system is full or read-only or something
        OOLog(kOOOXZErrorLog, @"%@", @"Unable to create download file");
        [self cancelUpdate];
    }
}

References OOOXZManager::cancelUpdate, DESTROY, OOOXZManager::downloadPath, kOOOXZDebugLog, kOOOXZErrorLog, nil, OOLog, and OXZ_DOWNLOAD_RECEIVING.

Here is the call graph for this function:

connectionDidFinishLoading:

- (void) connectionDidFinishLoading:

(NSURLConnection *)

connection

Extends class OOOXZManager.

Definition at line 2359 of file OOOXZManager.m.

                                  :(NSURLConnection *)connection
{
    _downloadStatus = OXZ_DOWNLOAD_COMPLETE;
    OOLog(kOOOXZDebugLog, @"%@", @"Download complete");
    [_fileWriter synchronizeFile];
    [_fileWriter closeFile];
    DESTROY(_fileWriter);
    DESTROY(_currentDownload);
    if (_interfaceState == OXZ_STATE_UPDATING)
    {
        if (![self processDownloadedManifests])
        {
            _downloadStatus = OXZ_DOWNLOAD_ERROR;
        }
    }
    else if (_interfaceState == OXZ_STATE_INSTALLING)
    {
        if (![self processDownloadedOXZ])
        {
            _downloadStatus = OXZ_DOWNLOAD_ERROR;
        }
    }
    else
    {
        OOLog(kOOOXZErrorLog,@"Error: download completed in unexpected state %d. This is an internal error - please report it.",_interfaceState);
        _downloadStatus = OXZ_DOWNLOAD_ERROR;
    }
}

References DESTROY, kOOOXZDebugLog, kOOOXZErrorLog, OOLog, OXZ_DOWNLOAD_COMPLETE, OXZ_DOWNLOAD_ERROR, OXZ_STATE_INSTALLING, OXZ_STATE_UPDATING, processDownloadedManifests, and processDownloadedOXZ.

Here is the call graph for this function:

dataURL

- (NSString *) dataURL

Extends class OOOXZManager.

Definition at line 355 of file OOOXZManager.m.

{
    /* Not expected to be set in general, but might be useful for some users */
    NSString *url = [[NSUserDefaults standardUserDefaults] stringForKey:kOOOXZDataConfig];
    if (url != nil)
    {
        return url;
    }
    return kOOOXZDataURL;
}

References dataURL, kOOOXZDataURL, and nil.

Referenced by dataURL, and OOOXZManager::updateManifests.

Here is the call graph for this function:

Here is the caller graph for this function:

downloadPath

- (NSString *) downloadPath

Extends class OOOXZManager.

Definition at line 342 of file OOOXZManager.m.

{
    if (_interfaceState == OXZ_STATE_UPDATING)
    {
        return [[[OOCacheManager sharedCache] cacheDirectoryPathCreatingIfNecessary:YES] stringByAppendingPathComponent:kOOOXZTmpPlistPath];
    }
    else
    {
        return [[[OOCacheManager sharedCache] cacheDirectoryPathCreatingIfNecessary:YES] stringByAppendingPathComponent:kOOOXZTmpPath];
    }
}

References OOCacheManager::cacheDirectoryPathCreatingIfNecessary:, downloadPath, OXZ_STATE_UPDATING, and OOCacheManager::sharedCache.

Referenced by beginDownload:, OOOXZManager::cancelUpdate, connection:didReceiveResponse:, downloadPath, processDownloadedManifests, and processDownloadedOXZ.

Here is the call graph for this function:

Here is the caller graph for this function:

ensureInstallPath

- (BOOL) ensureInstallPath

Extends class OOOXZManager.

Definition at line 307 of file OOOXZManager.m.

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

References ensureInstallPath, OOOXZManager::installPath, kOOOXZErrorLog, nil, and OOLog.

Referenced by ensureInstallPath, and processDownloadedOXZ.

Here is the call graph for this function:

Here is the caller graph for this function:

extractionBasePathForIdentifier:andVersion:

- (NSString *) extractionBasePathForIdentifier:		(NSString *)	identifier
andVersion:		(NSString *)	version

Extends class OOOXZManager.

Definition at line 297 of file OOOXZManager.m.

                                              :(NSString *)identifier andVersion:(NSString *)version
{
    NSString *basePath = [[ResourceManager userRootPaths] lastObject];
    NSString *rawMainDir = [NSString stringWithFormat:@"%@-%@.off",identifier,version];
    
    NSCharacterSet *blacklist = [NSCharacterSet characterSetWithCharactersInString:@"'#%^&{}[]/~|\\?<,:\" "];
    return [[[basePath stringByAppendingPathComponent:[[rawMainDir componentsSeparatedByCharactersInSet:blacklist] componentsJoinedByString:@""]] retain] autorelease];
}

References ResourceManager::userRootPaths.

Referenced by extractOXZ:, and OOOXZManager::gui.

Here is the call graph for this function:

Here is the caller graph for this function:

extractOXZ:

- (NSString *) extractOXZ:

(NSUInteger)

item

Extends class OOOXZManager.

Definition at line 2178 of file OOOXZManager.m.

                         :(NSUInteger)item
{
    NSFileManager *fmgr             = [NSFileManager defaultManager];
    NSMutableString *extractionLog  = [[NSMutableString alloc] init];
    NSDictionary *manifest          = [_filteredList oo_dictionaryAtIndex:item];
    NSString *version               = [manifest oo_stringForKey:kOOManifestVersion];
    NSString *identifier            = [manifest oo_stringForKey:kOOManifestIdentifier];
    NSString *path                  = [self extractionBasePathForIdentifier:identifier andVersion:version];
 
    // OXZ errors should really never happen unless someone is messing
    // directly with the managed folder while Oolite is running, but
    // it's possible.
 
    NSString *oxzfile = [manifest oo_stringForKey:kOOManifestFilePath];
    if (![fmgr fileExistsAtPath:oxzfile])
    {
        OOLog(kOOOXZErrorLog,@"OXZ %@ could not be found",oxzfile);
        [extractionLog appendString:DESC(@"oolite-oxzmanager-extract-log-no-original")];
        return [extractionLog autorelease];
    }
    const char* zipname = [oxzfile UTF8String];
    unzFile uf = NULL;
    uf = unzOpen64(zipname);
    if (uf == NULL)
    {
        OOLog(kOOOXZErrorLog,@"Could not open .oxz at %@ as zip file",path);
        [extractionLog appendString:DESC(@"oolite-oxzmanager-extract-log-bad-original")];
        return [extractionLog autorelease];
    }   
 
    if ([fmgr fileExistsAtPath:path])
    {
        OOLog(kOOOXZErrorLog,@"Path %@ already exists",path);
        [extractionLog appendString:DESC(@"oolite-oxzmanager-extract-log-main-exists")];
        unzClose(uf);
        return [extractionLog autorelease];
    }
    if (![fmgr oo_createDirectoryAtPath:path attributes:nil])
    {
        OOLog(kOOOXZErrorLog,@"Path %@ could not be created",path);
        [extractionLog appendString:DESC(@"oolite-oxzmanager-extract-log-main-unmakeable")];
        unzClose(uf);
        return [extractionLog autorelease];
    }
    [extractionLog appendString:DESC(@"oolite-oxzmanager-extract-log-main-created")];
    NSUInteger counter = 0;
    char rawComponentName[512];
    BOOL error = NO;
    unz_file_info64 file_info = {0};
    if (unzGoToFirstFile(uf) == UNZ_OK)
    {
        do 
        {
            unzGetCurrentFileInfo64(uf, &file_info,
                                    rawComponentName, 512,
                                    NULL, 0,
                                    NULL, 0);
            NSString *componentName = [NSString stringWithUTF8String:rawComponentName];
            if ([componentName hasSuffix:@"/"])
            {
                // folder
                if (![fmgr oo_createDirectoryAtPath:[path stringByAppendingPathComponent:componentName] attributes:nil])
                {
                    OOLog(kOOOXZErrorLog,@"Subpath %@ could not be created",componentName);
                    [extractionLog appendString:DESC(@"oolite-oxzmanager-extract-log-sub-failed")];
                    error = YES;
                    break;
                }
                else
                {
                    OOLog(kOOOXZDebugLog,@"Subpath %@ created OK",componentName);
                }
            }
            else
            {
                // file
                // usually folder must now exist, but just in case...
                NSString *folder = [[path stringByAppendingPathComponent:componentName] stringByDeletingLastPathComponent];
                if ([folder length] > 0 && ![fmgr fileExistsAtPath:folder] && ![fmgr oo_createDirectoryAtPath:folder attributes:nil])
                {
                    OOLog(kOOOXZErrorLog,@"Subpath %@ could not be created",folder);
                    [extractionLog appendString:DESC(@"oolite-oxzmanager-extract-log-sub-failed")];
                    error = YES;
                    break;
                }
                
 
                // This is less efficient in memory use than just
                // streaming out of the ZIP file onto disk
                // but it makes error handling easier
                NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
                NSData *tmp = [NSData oo_dataWithOXZFile:[oxzfile stringByAppendingPathComponent:componentName]];
                if (tmp == nil)
                {
                    OOLog(kOOOXZErrorLog,@"Sub file %@ could not be extracted from the OXZ",componentName);
                    [extractionLog appendString:DESC(@"oolite-oxzmanager-extract-log-sub-failed")];
                    error = YES;
                    [pool release];
                    break;
                }
                else
                {
                    if (![tmp writeToFile:[path stringByAppendingPathComponent:componentName] atomically:YES])
                    {
                        OOLog(kOOOXZErrorLog,@"Sub file %@ could not be created",componentName);
                        [extractionLog appendString:DESC(@"oolite-oxzmanager-extract-log-sub-failed")];
                        error = YES;
                        [pool release];
                        break;
                    }
                    else
                    {
                        ++counter;
                    }
                }
                [pool release];
 
            }
        }
        while (unzGoToNextFile(uf) == UNZ_OK);
    }
    unzClose(uf);
 
    if (!error)
    {
        [extractionLog appendFormat:DESC(@"oolite-oxzmanager-extract-log-num-u-extracted"),counter];
        [extractionLog appendFormat:DESC(@"oolite-oxzmanager-extract-log-extracted-to-@"),path];
    }
 
    return [extractionLog autorelease];
}

References OOOXZManager::extractionBasePathForIdentifier:andVersion:, kOOOXZDebugLog, kOOOXZErrorLog, nil, OOLog, UNZ_OK, unzClose(), unzGetCurrentFileInfo64(), unzGoToFirstFile(), unzGoToNextFile(), and unzOpen64().

Referenced by OOOXZManager::processSelection.

Here is the call graph for this function:

Here is the caller graph for this function:

humanSize:

- (NSString *) humanSize:

(NSUInteger)

bytes

Extends class OOOXZManager.

Definition at line 367 of file OOOXZManager.m.

                        :(NSUInteger)bytes
{
    if (bytes == 0)
    {
        return DESC(@"oolite-oxzmanager-missing-field");
    }
    else if (bytes < 1024)
    {
        return @"<1 kB";
    }
    else if (bytes < 1024*1024)
    {
        return [NSString stringWithFormat:@"%llu kB",bytes>>10];
    }
    else 
    {
        return [NSString stringWithFormat:@"%.2f MB",((float)(bytes>>10))/1024];
    }
}

References DESC.

Referenced by OOOXZManager::gui, and OOOXZManager::showInstallOptions.

Here is the caller graph for this function:

installableState:

- (OXZInstallableState) installableState:

(NSDictionary *)

manifest

Extends class OOOXZManager.

Definition at line 1037 of file OOOXZManager.m.

                                        :(NSDictionary *)manifest
{
    NSString *title = [manifest oo_stringForKey:kOOManifestTitle defaultValue:nil];
    NSString *identifier = [manifest oo_stringForKey:kOOManifestIdentifier defaultValue:nil];
    /* Check Oolite version */
    if (![ResourceManager checkVersionCompatibility:manifest forOXP:title])
    {
        return OXZ_UNINSTALLABLE_VERSION;
    }
    /* Check for current automated install */
    NSDictionary *installed = [self installedManifestForIdentifier:identifier];
    if (installed == nil)
    {
        // check for manual install
        installed = [ResourceManager manifestForIdentifier:identifier];
    }
 
    if (installed != nil)
    {
        if (![[installed oo_stringForKey:kOOManifestFilePath] hasPrefix:[self installPath]])
        {
            // installed manually
            return OXZ_UNINSTALLABLE_MANUAL;
        }
        if ([[installed oo_stringForKey:kOOManifestVersion] isEqualToString:[manifest oo_stringForKey:kOOManifestAvailableVersion defaultValue:[manifest oo_stringForKey:kOOManifestVersion]]]
            && [[NSFileManager defaultManager] fileExistsAtPath:[installed oo_stringForKey:kOOManifestFilePath]])
        {
            // installed this exact version already, and haven't
            // uninstalled it since entering the manager, and it's
            // still available
            return OXZ_UNINSTALLABLE_ALREADY;
        }
        else if ([installed oo_stringForKey:kOOManifestAvailableVersion defaultValue:nil] == nil)
        {
            // installed, but no remote copy is indexed any more
            return OXZ_UNINSTALLABLE_NOREMOTE;
        }
    }
    /* Check for dependencies being met */
    if ([ResourceManager manifestHasConflicts:manifest logErrors:NO])
    {
        return OXZ_INSTALLABLE_CONFLICTS;
    }
    if (installed != nil)
    {
        NSString *availableVersion = [manifest oo_stringForKey:kOOManifestAvailableVersion];
        if (availableVersion == nil)
        {
            availableVersion = [manifest oo_stringForKey:kOOManifestVersion];
        }
        NSString *installedVersion = [installed oo_stringForKey:kOOManifestVersion];
        OOLog(@"version.debug",@"%@ mv:%@ mav:%@",identifier,installedVersion,availableVersion);
        if (CompareVersions(ComponentsFromVersionString(installedVersion),ComponentsFromVersionString(availableVersion)) == NSOrderedDescending)
        {
            // the installed copy is more recent than the server copy
            return OXZ_UNINSTALLABLE_NOREMOTE;
        }
        return OXZ_INSTALLABLE_UPDATE;
    }
    if ([ResourceManager manifestHasMissingDependencies:manifest logErrors:NO])
    {
        return OXZ_INSTALLABLE_DEPENDENCIES;
    }
    return OXZ_INSTALLABLE_OKAY;
}

References CompareVersions(), ComponentsFromVersionString(), OOOXZManager::installedManifestForIdentifier:, kOOManifestAvailableVersion, kOOManifestFilePath, kOOManifestVersion, ResourceManager::manifestForIdentifier:, nil, OOLog, OXZ_INSTALLABLE_CONFLICTS, OXZ_INSTALLABLE_DEPENDENCIES, OXZ_INSTALLABLE_OKAY, OXZ_INSTALLABLE_UPDATE, OXZ_UNINSTALLABLE_ALREADY, OXZ_UNINSTALLABLE_MANUAL, OXZ_UNINSTALLABLE_NOREMOTE, and OXZ_UNINSTALLABLE_VERSION.

Here is the call graph for this function:

installOptions

- (NSArray *) installOptions

Extends class OOOXZManager.

Definition at line 1757 of file OOOXZManager.m.

{
    NSUInteger start = _offset;
    if (start >= [_filteredList count])
    {
        start = 0;
        _offset = 0;
    }
    NSUInteger end = start + OXZ_GUI_NUM_LISTROWS;
    if (end > [_filteredList count])
    {
        end = [_filteredList count];
    }
    return [_filteredList subarrayWithRange:NSMakeRange(start,end-start)];
}

References count, installOptions, and OXZ_GUI_NUM_LISTROWS.

Referenced by installOptions, and OOOXZManager::showInstallOptions.

Here is the call graph for this function:

Here is the caller graph for this function:

installOXZ:

- (BOOL) installOXZ:

(NSUInteger)

item

Extends class OOOXZManager.

Definition at line 1689 of file OOOXZManager.m.

                   :(NSUInteger)item 
{
    NSArray *picklist = _filteredList;
 
    if ([picklist count] <= item)
    {
        return NO;
    }
    NSDictionary *manifest = [picklist objectAtIndex:item];
    _item = item;
 
    if ([self installableState:manifest] >= OXZ_UNINSTALLABLE_ALREADY)
    {
        OOLog(kOOOXZDebugLog,@"Cannot install %@",manifest);
        // can't be installed on this version of Oolite, or already is installed
        return NO;
    }
    NSString *url = [manifest objectForKey:kOOManifestDownloadURL];
    if (url == nil)
    {
        OOLog(kOOOXZErrorLog, @"%@", @"Manifest does not have a download URL - cannot install");
        return NO;
    }
    NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:url]];
    [request setHTTPShouldHandleCookies:NO];
    if (_downloadStatus != OXZ_DOWNLOAD_NONE)
    {
        return NO;
    }
    _downloadStatus = OXZ_DOWNLOAD_STARTED;
    _interfaceState = OXZ_STATE_INSTALLING;
    
    [self setProgressStatus:@""];
    return [self beginDownload:request];
}

References OOOXZManager::beginDownload:, count, kOOOXZDebugLog, kOOOXZErrorLog, nil, OOLog, OXZ_DOWNLOAD_NONE, OXZ_DOWNLOAD_STARTED, OXZ_STATE_INSTALLING, OXZ_UNINSTALLABLE_ALREADY, and OOOXZManager::setProgressStatus:.

Referenced by OOOXZManager::processSelection, and updateAllOXZ.

Here is the call graph for this function:

Here is the caller graph for this function:

installStatusForManifest:

- (NSString *) installStatusForManifest:

(NSDictionary *)

manifest

Extends class OOOXZManager.

Definition at line 1129 of file OOOXZManager.m.

                                       :(NSDictionary *)manifest 
{
    switch ([self installableState:manifest])
    {
    case OXZ_INSTALLABLE_OKAY:
        return DESC(@"oolite-oxzmanager-installable-okay");
    case OXZ_INSTALLABLE_UPDATE:
        return DESC(@"oolite-oxzmanager-installable-update");
    case OXZ_INSTALLABLE_DEPENDENCIES:
        return DESC(@"oolite-oxzmanager-installable-depend");
    case OXZ_INSTALLABLE_CONFLICTS:
        return DESC(@"oolite-oxzmanager-installable-conflicts");
    case OXZ_UNINSTALLABLE_ALREADY:
        return DESC(@"oolite-oxzmanager-installable-already");
    case OXZ_UNINSTALLABLE_MANUAL:
        return DESC(@"oolite-oxzmanager-installable-manual");
    case OXZ_UNINSTALLABLE_VERSION:
        return DESC(@"oolite-oxzmanager-installable-version");
    case OXZ_UNINSTALLABLE_NOREMOTE:
        return DESC(@"oolite-oxzmanager-installable-noremote");
    }
    return nil; // never
}

References DESC, nil, OXZ_INSTALLABLE_CONFLICTS, OXZ_INSTALLABLE_DEPENDENCIES, OXZ_INSTALLABLE_OKAY, OXZ_INSTALLABLE_UPDATE, OXZ_UNINSTALLABLE_ALREADY, OXZ_UNINSTALLABLE_MANUAL, OXZ_UNINSTALLABLE_NOREMOTE, and OXZ_UNINSTALLABLE_VERSION.

Referenced by OOOXZManager::showInstallOptions, and OOOXZManager::showRemoveOptions.

Here is the caller graph for this function:

manifestPath

- (NSString *) manifestPath

Extends class OOOXZManager.

Definition at line 333 of file OOOXZManager.m.

{
    return [[[OOCacheManager sharedCache] cacheDirectoryPathCreatingIfNecessary:YES] stringByAppendingPathComponent:kOOOXZManifestCache];
}

References OOCacheManager::cacheDirectoryPathCreatingIfNecessary:, manifestPath, and OOCacheManager::sharedCache.

Referenced by OOOXZManager::init, manifestPath, and processDownloadedManifests.

Here is the call graph for this function:

Here is the caller graph for this function:

processDownloadedManifests

- (BOOL) processDownloadedManifests

Extends class OOOXZManager.

Definition at line 761 of file OOOXZManager.m.

{
    if (_downloadStatus != OXZ_DOWNLOAD_COMPLETE)
    {
        return NO;
    }
    [self setOXZList:OOArrayFromFile([self downloadPath])];
    if (_oxzList != nil)
    {
        [_oxzList writeToFile:[self manifestPath] atomically:YES];
        // and clean up the temp file
        [[NSFileManager defaultManager] oo_removeItemAtPath:[self downloadPath]];
        // invalidate the managed list
        DESTROY(_managedList);
        _interfaceState = OXZ_STATE_TASKDONE;
        [self gui];
        return YES;
    }
    else
    {
        _downloadStatus = OXZ_DOWNLOAD_ERROR;
        OOLog(kOOOXZErrorLog,@"Downloaded manifest was not a valid plist, has been left in %@",[self downloadPath]);
        // revert to the old one
        [self setOXZList:OOArrayFromFile([self manifestPath])];
        _interfaceState = OXZ_STATE_TASKDONE;
        [self gui];
        return NO;
    }
}

References DESTROY, OOOXZManager::downloadPath, downloadPath, OOOXZManager::gui, kOOOXZErrorLog, OOOXZManager::manifestPath, nil, OOLog, OXZ_DOWNLOAD_COMPLETE, OXZ_DOWNLOAD_ERROR, OXZ_STATE_TASKDONE, processDownloadedManifests, and OOOXZManager::setOXZList:.

Referenced by connectionDidFinishLoading:, and processDownloadedManifests.

Here is the call graph for this function:

Here is the caller graph for this function:

processDownloadedOXZ

- (BOOL) processDownloadedOXZ

If downloadedManifest is in _dependencyStack, remove it Get downloadedManifest requires_oxp list Add entries ones to _dependencyStack If _dependencyStack has contents, update _progressStatus ...and start the download of the 'first' item in _dependencyStack ...which isn't already installed (_dependencyStack is unordered ...so 'first' isn't really defined)

...if the item in _dependencyStack is not findable (e.g. wrong ...version) then stop here.

Extends class OOOXZManager.

Definition at line 792 of file OOOXZManager.m.

{
    if (_downloadStatus != OXZ_DOWNLOAD_COMPLETE)
    {
        return NO;
    }
 
    NSDictionary *downloadedManifest = OODictionaryFromFile([[self downloadPath] stringByAppendingPathComponent:@"manifest.plist"]);
    if (downloadedManifest == nil)
    {
        _downloadStatus = OXZ_DOWNLOAD_ERROR;
        OOLog(kOOOXZErrorLog,@"Downloaded OXZ does not contain a manifest.plist, has been left in %@",[self downloadPath]);
        _interfaceState = OXZ_STATE_TASKDONE;
        [self gui];
        return NO;
    }
    NSDictionary *expectedManifest = nil;
    expectedManifest = [_filteredList objectAtIndex:_item];
 
    if (expectedManifest == nil || 
        (![[downloadedManifest oo_stringForKey:kOOManifestIdentifier] isEqualToString:[expectedManifest oo_stringForKey:kOOManifestIdentifier]]) || 
        (![[downloadedManifest oo_stringForKey:kOOManifestVersion] isEqualToString:[expectedManifest oo_stringForKey:kOOManifestAvailableVersion defaultValue:[expectedManifest oo_stringForKey:kOOManifestVersion]]])
        )
    {
        _downloadStatus = OXZ_DOWNLOAD_ERROR;
        OOLog(kOOOXZErrorLog, @"%@", @"Downloaded OXZ does not have the same identifer and version as expected. This might be due to your manifests list being out of date - try updating it.");
        _interfaceState = OXZ_STATE_TASKDONE;
        [self gui];
        return NO;
    }
    // this appears to be the OXZ we expected
    // filename is going to be identifier.oxz
    NSString *filename = [[downloadedManifest oo_stringForKey:kOOManifestIdentifier] stringByAppendingString:@".oxz"];
 
    if (![self ensureInstallPath])
    {
        _downloadStatus = OXZ_DOWNLOAD_ERROR;
        OOLog(kOOOXZErrorLog, @"%@", @"Unable to create installation folder.");
        _interfaceState = OXZ_STATE_TASKDONE;
        [self gui];
        return NO;
    }
 
    // delete filename if it exists from OXZ folder
    NSString *destination = [[self installPath] stringByAppendingPathComponent:filename];
    [[NSFileManager defaultManager] oo_removeItemAtPath:destination];
 
    // move the temp file on to it
    if (![[NSFileManager defaultManager] oo_moveItemAtPath:[self downloadPath] toPath:destination])
    {
        _downloadStatus = OXZ_DOWNLOAD_ERROR;
        OOLog(kOOOXZErrorLog, @"%@", @"Downloaded OXZ could not be installed.");
        _interfaceState = OXZ_STATE_TASKDONE;
        [self gui];
        return NO;
    }
    _changesMade = YES;
    DESTROY(_managedList); // will need updating
    // do this now to cope with circular dependencies on download
    [ResourceManager resetManifestKnowledgeForOXZManager];

    NSArray *requires = [downloadedManifest oo_arrayForKey:kOOManifestRequiresOXPs defaultValue:nil];
    if (requires == nil)
    {
        // just in case the requirements are only specified in the online copy
        requires = [expectedManifest oo_arrayForKey:kOOManifestRequiresOXPs defaultValue:nil];
    }
    NSDictionary *requirement = nil;
    NSMutableString *progress = [NSMutableString stringWithCapacity:2048];
    OOLog(kOOOXZDebugLog,@"Dependency stack has %llu elements",[_dependencyStack count]);
 
    if ([_dependencyStack count] > 0)
    {
        // will remove as iterate, so create a temp copy to iterate over
        NSSet *tempStack = [NSSet setWithSet:_dependencyStack];
        foreach (requirement, tempStack)
        {
            OOLog(kOOOXZDebugLog,@"Dependency stack: checking %@",[requirement oo_stringForKey:kOOManifestRelationIdentifier]);
            if (![ResourceManager manifest:downloadedManifest HasUnmetDependency:requirement logErrors:NO]
                && requires != nil && [requires containsObject:requirement])
            {
                // it was unmet, but now it's met                   
                [progress appendFormat:DESC(@"oolite-oxzmanager-progress-now-has-@"),[requirement oo_stringForKey:kOOManifestRelationDescription defaultValue:[requirement oo_stringForKey:kOOManifestRelationIdentifier]]];
                [_dependencyStack removeObject:requirement];
                OOLog(kOOOXZDebugLog, @"%@", @"Dependency stack: requirement met");
            } else if ([[requirement oo_stringForKey:kOOManifestRelationIdentifier] isEqualToString:[downloadedManifest oo_stringForKey:kOOManifestIdentifier]]) {
                // remove the requirement for the just downloaded OXP
                [_dependencyStack removeObject:requirement];
            }
        }
    }
    if (requires != nil)
    {
        foreach (requirement, requires)
        {
            if ([ResourceManager manifest:downloadedManifest HasUnmetDependency:requirement logErrors:NO])
            {
                OOLog(kOOOXZDebugLog,@"Dependency stack: adding %@",[requirement oo_stringForKey:kOOManifestRelationIdentifier]);
                [_dependencyStack addObject:requirement];
                [progress appendFormat:DESC(@"oolite-oxzmanager-progress-requires-@"),[requirement oo_stringForKey:kOOManifestRelationDescription defaultValue:[requirement oo_stringForKey:kOOManifestRelationIdentifier]]];
            }
        }
    }
    if ([_dependencyStack count] > 0)
    {
        // get an object from the requirements list, and download it
        // if it can be found
        BOOL undownloadedRequirement = NO;
        NSDictionary *availableDownload = nil;
        BOOL foundDownload = NO;
        NSUInteger index = 0;
        NSString *needsIdentifier = nil;
 
        do
        {
            undownloadedRequirement = YES;
            requirement = [_dependencyStack anyObject];
            OOLog(kOOOXZDebugLog,@"Dependency stack: next is %@",[requirement oo_stringForKey:kOOManifestRelationIdentifier]);
 
            if (!_downloadAllDependencies)
            {
                [progress appendString:DESC(@"oolite-oxzmanager-progress-get-required")];
            }
            needsIdentifier = [requirement oo_stringForKey:kOOManifestRelationIdentifier];
        
            foreach (availableDownload, _oxzList)
            {
                if ([[availableDownload oo_stringForKey:kOOManifestIdentifier] isEqualToString:needsIdentifier])
                {
                    if ([ResourceManager matchVersions:requirement withVersion:[availableDownload oo_stringForKey:kOOManifestVersion]])
                    {
                        OOLog(kOOOXZDebugLog, @"%@", @"Dependency stack: found download for next item");
                        foundDownload = YES;
                        index = [_oxzList indexOfObject:availableDownload];
                        break;
                    }
                }
            }
            
            if (foundDownload)
            {
                if ([self installableState:[_oxzList objectAtIndex:index]] == OXZ_UNINSTALLABLE_ALREADY)
                {
                    OOLog(kOOOXZDebugLog,@"Dependency stack: %@ is downloaded but not yet loadable, removing from list.",[requirement oo_stringForKey:kOOManifestRelationIdentifier]);
                    // then this has already been downloaded, but
                    // can't be configured yet presumably because
                    // another dependency is still to be loaded
                    [_dependencyStack removeObject:requirement];
                    if ([_dependencyStack count] > 0)
                    {
                        // try again
                        undownloadedRequirement = NO;
                    }
                    else
                    {
                        // this case should probably never happen
                        // is handled below just in case
                        foundDownload = NO;
                    }
                }
            }
        }
        while (!undownloadedRequirement);
 
        if (foundDownload)
        {
            // must clear filters entirely at this point
            [self setFilteredList:_oxzList];
            // then download that item
            _downloadStatus = OXZ_DOWNLOAD_NONE;
            if (_downloadAllDependencies)
            {
                OOLog(kOOOXZDebugLog,@"Dependency stack: installing %llu from list",index);
                if (![self installOXZ:index]) {
                    // if a required dependency is somehow uninstallable
                    // e.g. required+maximum version don't match this Oolite
                    [progress appendFormat:DESC(@"oolite-oxzmanager-progress-required-@-not-found"),[requirement oo_stringForKey:kOOManifestRelationDescription defaultValue:[requirement oo_stringForKey:kOOManifestRelationIdentifier]]];
                    [self setProgressStatus:progress];
                    OOLog(kOOOXZErrorLog,@"OXZ dependency %@ could not be found for automatic download.",needsIdentifier);
                    _downloadStatus = OXZ_DOWNLOAD_ERROR;
                    OOLog(kOOOXZErrorLog, @"%@", @"Downloaded OXZ could not be installed.");
                    _interfaceState = OXZ_STATE_TASKDONE;
                    [self gui];
                    return NO;
                }
            }
            else
            {
                _interfaceState = OXZ_STATE_DEPENDENCIES;
                _item = index;
            }
            [self setProgressStatus:progress];
            [self gui];
            return YES;
        }
        // this is probably always the case, see above
        else if ([_dependencyStack count] > 0)
        {
            [progress appendFormat:DESC(@"oolite-oxzmanager-progress-required-@-not-found"),[requirement oo_stringForKey:kOOManifestRelationDescription defaultValue:[requirement oo_stringForKey:kOOManifestRelationIdentifier]]];
            [self setProgressStatus:progress];
            OOLog(kOOOXZErrorLog,@"OXZ dependency %@ could not be found for automatic download.",needsIdentifier);
            _downloadStatus = OXZ_DOWNLOAD_ERROR;
            OOLog(kOOOXZErrorLog, @"%@", @"Downloaded OXZ could not be installed.");
            _interfaceState = OXZ_STATE_TASKDONE;
            [self gui];
            return NO;
        }
    }
 
    [self setProgressStatus:@""];
    _interfaceState = OXZ_STATE_TASKDONE;
    [_dependencyStack removeAllObjects]; // just in case
    _downloadAllDependencies = NO;
    [self gui];
    return YES;
}

References count, DESTROY, downloadPath, ensureInstallPath, OOOXZManager::gui, OOOXZManager::installPath, kOOManifestAvailableVersion, kOOManifestIdentifier, kOOManifestRelationIdentifier, kOOManifestVersion, kOOOXZDebugLog, kOOOXZErrorLog, nil, OODictionaryFromFile(), OOLog, OXZ_DOWNLOAD_COMPLETE, OXZ_DOWNLOAD_ERROR, OXZ_DOWNLOAD_NONE, OXZ_STATE_DEPENDENCIES, OXZ_STATE_TASKDONE, OXZ_UNINSTALLABLE_ALREADY, processDownloadedOXZ, ResourceManager::resetManifestKnowledgeForOXZManager, OOOXZManager::setFilteredList:, and OOOXZManager::setProgressStatus:.

Referenced by connectionDidFinishLoading:, and processDownloadedOXZ.

Here is the call graph for this function:

Here is the caller graph for this function:

removeOptions

- (NSArray *) removeOptions

Extends class OOOXZManager.

Definition at line 1978 of file OOOXZManager.m.

{
    NSArray *remList = _filteredList;
    if ([remList count] == 0)
    {
        return nil;
    }
    NSUInteger start = _offset;
    if (start >= [remList count])
    {
        start = 0;
        _offset = 0;
    }
    NSUInteger end = start + OXZ_GUI_NUM_LISTROWS;
    if (end > [remList count])
    {
        end = [remList count];
    }
    return [remList subarrayWithRange:NSMakeRange(start,end-start)];
}

References count, nil, OXZ_GUI_NUM_LISTROWS, and removeOptions.

Referenced by removeOptions, and OOOXZManager::showRemoveOptions.

Here is the call graph for this function:

Here is the caller graph for this function:

removeOXZ:

- (BOOL) removeOXZ:

(NSUInteger)

item

Extends class OOOXZManager.

Definition at line 1950 of file OOOXZManager.m.

                  :(NSUInteger)item
{
    NSArray *remList = _filteredList;
    if ([remList count] <= item)
    {
        OOLog(kOOOXZDebugLog, @"Unable to remove item %lu as only %lu in list", (unsigned long)item, (unsigned long)[remList count]);
        return NO;
    }
    NSString *filename = [[remList objectAtIndex:item] oo_stringForKey:kOOManifestFilePath];
    if (filename == nil)
    {
        OOLog(kOOOXZDebugLog, @"Unable to remove item %lu as filename not found", (unsigned long)item);
        return NO;
    }
 
    if (![[NSFileManager defaultManager] oo_removeItemAtPath:filename])
    {
        OOLog(kOOOXZErrorLog, @"Unable to remove file %@", filename);
        return NO;
    }
    _changesMade = YES;
    DESTROY(_managedList); // will need updating
    _interfaceState = OXZ_STATE_REMOVING;
    [self gui];
    return YES;
}

References count, DESTROY, OOOXZManager::gui, kOOOXZDebugLog, kOOOXZErrorLog, nil, OOLog, and OXZ_STATE_REMOVING.

Referenced by OOOXZManager::processSelection.

Here is the call graph for this function:

Here is the caller graph for this function:

setCurrentDownload:withLabel:

- (void) setCurrentDownload:		(NSURLConnection *)	download
withLabel:		(NSString *)	label

Extends class OOOXZManager.

Definition at line 606 of file OOOXZManager.m.

                           :(NSURLConnection *)download withLabel:(NSString *)label
{
    if (_currentDownload != nil)
    {
        [_currentDownload cancel]; // releases via delegate
    }
    _currentDownload = [download retain];
    DESTROY(_currentDownloadName);
    _currentDownloadName = [label copy];
}

References DESTROY, and nil.

Referenced by beginDownload:, and OOOXZManager::dealloc.

Here is the caller graph for this function:

setFilteredList:

- (void) setFilteredList:

(NSArray *)

list

Extends class OOOXZManager.

Definition at line 400 of file OOOXZManager.m.

                        :(NSArray *)list
{
    DESTROY(_filteredList);
    _filteredList = [list copy]; // copy retains
}

References DESTROY.

Referenced by OOOXZManager::gui, processDownloadedOXZ, OOOXZManager::showOptionsUpdate, and updateAllOXZ.

Here is the caller graph for this function:

setOXZList:

- (void) setOXZList:

(NSArray *)

list

Extends class OOOXZManager.

Definition at line 388 of file OOOXZManager.m.

                   :(NSArray *)list
{
    DESTROY(_oxzList);
    if (list != nil)
    {
        _oxzList = [[list sortedArrayUsingFunction:oxzSort context:NULL] retain];
        // needed for update to available versions
        DESTROY(_managedList);
    }
}

References DESTROY, and nil.

Referenced by OOOXZManager::init, and processDownloadedManifests.

Here is the caller graph for this function:

setProgressStatus:

- (void) setProgressStatus:

(NSString *)

newStatus

Extends class OOOXZManager.

Definition at line 618 of file OOOXZManager.m.

                          :(NSString *)new
{
    DESTROY(_progressStatus);
    _progressStatus = [new copy];
}

References DESTROY.

Referenced by OOOXZManager::init, installOXZ:, processDownloadedOXZ, OOOXZManager::processSelection, and OOOXZManager::updateManifests.

Here is the caller graph for this function:

updateAllOXZ

- (BOOL) updateAllOXZ

Extends class OOOXZManager.

Definition at line 1726 of file OOOXZManager.m.

{
    [_dependencyStack removeAllObjects];
    _downloadAllDependencies = YES;
    [self setFilteredList:_oxzList];
    NSDictionary *manifest = nil;
 
    foreach (manifest,_oxzList)
    {
        if ([self installableState:manifest] == OXZ_INSTALLABLE_UPDATE)
        {
            OOLog(kOOOXZDebugLog, @"Queuing in for update: %@", manifest);
            [_dependencyStack addObject:manifest];
        }
    }
    NSDictionary *first = [_dependencyStack anyObject];
    NSString* identifier = [first oo_stringForKey:kOOManifestRelationIdentifier];
    NSUInteger item = NSUIntegerMax;
    NSDictionary *availableDownload = nil;
    foreach (availableDownload, _oxzList)
    {
        if ([[availableDownload oo_stringForKey:kOOManifestIdentifier] isEqualToString:identifier])
        {
            item = [_oxzList indexOfObject:availableDownload];
            break;
        }
    }
    return [self installOXZ:item];
}

References OOOXZManager::installOXZ:, kOOManifestIdentifier, kOOOXZDebugLog, nil, OOLog, OXZ_INSTALLABLE_UPDATE, OOOXZManager::setFilteredList:, and updateAllOXZ.

Referenced by OOOXZManager::processSelection, and updateAllOXZ.

Here is the call graph for this function:

Here is the caller graph for this function:

validateFilter:

- (BOOL) validateFilter:

(NSString *)

input

Extends class OOOXZManager.

Definition at line 585 of file OOOXZManager.m.

                       :(NSString *)input
{
    NSString *filter = [input lowercaseString];
    if (([filter length] == 0) // empty is valid
        || ([filter isEqualToString:kOOOXZFilterAll])
        || ([filter isEqualToString:kOOOXZFilterUpdates])
        || ([filter isEqualToString:kOOOXZFilterInstallable])
        || ([filter hasPrefix:kOOOXZFilterKeyword] && [filter length] > [kOOOXZFilterKeyword length])
        || ([filter hasPrefix:kOOOXZFilterAuthor] && [filter length] > [kOOOXZFilterAuthor length])
        || ([filter hasPrefix:kOOOXZFilterDays] && [[filter substringFromIndex:[kOOOXZFilterDays length]] intValue] > 0)
        || ([filter hasPrefix:kOOOXZFilterTag] && [filter length] > [kOOOXZFilterTag length])
        || ([filter hasPrefix:kOOOXZFilterCategory] && [filter length] > [kOOOXZFilterCategory length])
        )
    {
        return YES;
    }
 
    return NO;
}

References kOOOXZFilterAll, kOOOXZFilterAuthor, kOOOXZFilterCategory, kOOOXZFilterDays, kOOOXZFilterInstallable, kOOOXZFilterKeyword, kOOOXZFilterTag, and kOOOXZFilterUpdates.

---

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

• src/Core/OOOXZManager.m