OOOXPVerifier Class Reference

#include <OOOXPVerifier.h>

Inheritance diagram for OOOXPVerifier:

Collaboration diagram for OOOXPVerifier:

Instance Methods
(void)	- registerStage:
(NSString *)	- oxpPath
(NSString *)	- oxpDisplayName
(id)	- stageWithName:
(id)	- configurationValueForKey:
(NSArray *)	- configurationArrayForKey:
(NSDictionary *)	- configurationDictionaryForKey:
(NSString *)	- configurationStringForKey:
(NSSet *)	- configurationSetForKey:
(void)	- dealloc [implementation]
(OOFileScannerVerifierStage *)	- fileScannerStage
(OOModelVerifierStage *)	- modelVerifierStage
(id)	- initWithPath: [implementation]
(void)	- run [implementation]
(void)	- setUpLogOverrides [implementation]
(void)	- registerBaseStages [implementation]
(void)	- buildDependencyGraph [implementation]
(void)	- runStages [implementation]
(BOOL)	- setUpDependencies:forStage: [implementation]
(void)	- setUpDependents:forStage: [implementation]
(void)	- dumpDebugGraphviz [implementation]
(OOTextureVerifierStage *)	- textureVerifierStage

Class Methods
(BOOL)	+ runVerificationIfRequested

Private Attributes
NSDictionary *	_verifierPList
NSString *	_basePath
NSString *	_displayName
NSMutableDictionary *	_stagesByName
NSMutableSet *	_waitingStages
BOOL	_openForRegistration

Detailed Description

Definition at line 47 of file OOOXPVerifier.h.

Method Documentation

buildDependencyGraph

- (void) buildDependencyGraph

implementation

Provided by category OOOXPVerifier(OOPrivate).

Definition at line 736 of file OOOXPVerifier.m.

{
    NSAutoreleasePool       *pool = nil;
    NSArray                 *stageKeys = nil;
    NSString                *stageKey = nil;
    OOOXPVerifierStage      *stage = nil;
    NSString                *name = nil;
    NSMutableDictionary     *dependenciesByStage = nil,
                            *dependentsByStage = nil;
    NSSet                   *dependencies = nil,
                            *dependents = nil;
    NSValue                 *key = nil;
    
    pool = [[NSAutoreleasePool alloc] init];
    
    /*  Iterate over all stages, getting dependency and dependent sets.
        This is done in advance so that -dependencies and -dependents may
        register stages.
    */
    dependenciesByStage = [NSMutableDictionary dictionary];
    dependentsByStage = [NSMutableDictionary dictionary];
    
    for (;;)
    {
        /*  Loop while there are stages whose dependency lists haven't been
            checked. This is an indeterminate loop since new ones can be
            added.
        */
        stage = [_waitingStages anyObject];
        if (stage == nil)  break;
        [_waitingStages removeObject:stage];
        
        key = [NSValue valueWithNonretainedObject:stage];
        
        dependencies = [stage dependencies];
        if (dependencies != nil)
        {
            [dependenciesByStage setObject:dependencies
                                    forKey:key];
        }
        
        dependents = [stage dependents];
        if (dependents != nil)
        {
            [dependentsByStage setObject:dependents
                                  forKey:key];
        }
    }
    [_waitingStages release];
    _waitingStages = nil;
    _openForRegistration = NO;
    
    // Iterate over all stages, resolving dependencies.
    stageKeys = [_stagesByName allKeys];    // Get the keys up front because we may need to remove entries from dictionary.
    
    foreach (stageKey, stageKeys)
    {
        stage = [_stagesByName objectForKey:stageKey];
        if (stage == nil)  continue;
        
        // Sanity check
        name = [stage name];
        if (![stageKey isEqualToString:name])
        {
            OOLog(@"verifyOXP.buildDependencyGraph.badName", @"***** Stage name appears to have changed from \"%@\" to \"%@\" for verifier stage %@, removing.", stageKey, name, stage);
            [_stagesByName removeObjectForKey:stageKey];
            continue;
        }
        
        // Get dependency set
        key = [NSValue valueWithNonretainedObject:stage];
        dependencies = [dependenciesByStage objectForKey:key];
        
        if (dependencies != nil && ![self setUpDependencies:dependencies forStage:stage])
        {
            [_stagesByName removeObjectForKey:stageKey];
        }
    }
    
    /*  Iterate over all stages again, resolving reverse dependencies.
        This is done in a separate pass because reverse dependencies are "weak"
        while forward dependencies are "strong". 
    */
    stageKeys = [_stagesByName allKeys];
    
    foreach (stageKey, stageKeys)
    {
        stage = [_stagesByName objectForKey:stageKey];
        if (stage == nil)  continue;
        
        // Get dependent set
        key = [NSValue valueWithNonretainedObject:stage];
        dependents = [dependentsByStage objectForKey:key];
        
        if (dependents != nil)
        {
            [self setUpDependents:dependents forStage:stage];
        }
    }
    
    _waitingStages = [[NSMutableSet alloc] initWithArray:[_stagesByName allValues]];
    [_waitingStages makeObjectsPerformSelector:@selector(dependencyRegistrationComplete)];
    
    if ([[NSUserDefaults standardUserDefaults] boolForKey:@"oxp-verifier-dump-debug-graphviz"])
    {
        [self dumpDebugGraphviz];
    }
    
    [pool release];
}

configurationArrayForKey:

- (NSArray *) configurationArrayForKey:

(NSString *)

key

Definition at line 736 of file OOOXPVerifier.m.

                                     :(NSString *)key
{
    return [_verifierPList oo_arrayForKey:key];
}

configurationDictionaryForKey:

- (NSDictionary *) configurationDictionaryForKey:

(NSString *)

key

Definition at line 736 of file OOOXPVerifier.m.

                                               :(NSString *)key
{
    return [_verifierPList oo_dictionaryForKey:key];
}

configurationSetForKey:

- (NSSet *) configurationSetForKey:

(NSString *)

key

Definition at line 736 of file OOOXPVerifier.m.

                                 :(NSString *)key
{
    NSArray *array = [_verifierPList oo_arrayForKey:key];
    return array != nil ? [NSSet setWithArray:array] : nil;
}

configurationStringForKey:

- (NSString *) configurationStringForKey:

(NSString *)

key

Definition at line 736 of file OOOXPVerifier.m.

                                       :(NSString *)key
{
    return [_verifierPList oo_stringForKey:key];
}

configurationValueForKey:

- (id) configurationValueForKey:

(NSString *)

key

Definition at line 736 of file OOOXPVerifier.m.

                              :(NSString *)key
{
    return [_verifierPList objectForKey:key];
}

dealloc

- (void) dealloc

implementation

Definition at line 736 of file OOOXPVerifier.m.

{
    [_verifierPList release];
    [_basePath release];
    [_displayName release];
    [_stagesByName release];
    [_waitingStages release];
    
    [super dealloc];
}

dumpDebugGraphviz

- (void) dumpDebugGraphviz

implementation

Provided by category OOOXPVerifier(OOPrivate).

Definition at line 736 of file OOOXPVerifier.m.

{
    NSMutableString             *graphViz = nil;
    NSDictionary                *graphVizTemplate = nil;
    NSString                    *template = nil,
                                *startTemplate = nil,
                                *endTemplate = nil;
    OOOXPVerifierStage          *stage = nil;
    NSSet                       *deps = nil;
    OOOXPVerifierStage          *dep = nil;
    
    graphVizTemplate = [self configurationDictionaryForKey:@"debugGraphvizTempate"];
    graphViz = [NSMutableString stringWithFormat:[graphVizTemplate oo_stringForKey:@"preamble"], [NSDate date]];
    
    /*  Pass 1: enumerate over graph setting node attributes for each stage.
        We use pointers as node names for simplicity of generation.
    */
    template = [graphVizTemplate oo_stringForKey:@"node"];
    foreach (stage, [_stagesByName allValues])
    {
        [graphViz appendFormat:template, stage, [stage class], [stage name]];
    }
    
    [graphViz appendString:[graphVizTemplate oo_stringForKey:@"forwardPreamble"]];
    
    /*  Pass 2: enumerate over graph setting forward arcs for each dependency.
    */
    template = [graphVizTemplate oo_stringForKey:@"forwardArc"];
    startTemplate = [graphVizTemplate oo_stringForKey:@"startArc"];
    foreach (stage, [_stagesByName allValues])
    {
        deps = [stage resolvedDependencies];
        if ([deps count] != 0)
        {
            foreach (dep, deps)
            {
                [graphViz appendFormat:template, dep, stage];
            }
        }
        else
        {
            [graphViz appendFormat:startTemplate, stage];
        }
    }
    
    [graphViz appendString:[graphVizTemplate oo_stringForKey:@"backwardPreamble"]];
    
    /*  Pass 3: enumerate over graph setting backward arcs for each dependent.
    */
    template = [graphVizTemplate oo_stringForKey:@"backwardArc"];
    endTemplate = [graphVizTemplate oo_stringForKey:@"endArc"];
    foreach (stage, [_stagesByName allValues])
    {
        deps = [stage resolvedDependents];
        if ([deps count] != 0)
        {
            foreach (dep, deps)
            {
                [graphViz appendFormat:template, dep, stage];
            }
        }
        else
        {
            [graphViz appendFormat:endTemplate, stage];
        }
    }
    
    [graphViz appendString:[graphVizTemplate oo_stringForKey:@"postamble"]];
    
    // Write file
    [ResourceManager writeDiagnosticString:graphViz toFileNamed:@"OXPVerifierStageDependencies.dot"];
}

fileScannerStage

- (OOFileScannerVerifierStage *) fileScannerStage

Provided by category OOOXPVerifier(OOFileScannerVerifierStage).

Definition at line 756 of file OOFileScannerVerifierStage.m.

{
    return [self stageWithName:kFileScannerStageName];
}

initWithPath:

- (id) initWithPath: (NSString *)  path

implementation

Provided by category OOOXPVerifier(OOPrivate).

Definition at line 736 of file OOOXPVerifier.m.

                  :(NSString *)path
{
    self = [super init];
 
    OOSetStandardsForOXPVerifierMode();
 
    NSString *verifierPListPath = [[[ResourceManager builtInPath] stringByAppendingPathComponent:@"Config"] stringByAppendingPathComponent:@"verifyOXP.plist"];
    _verifierPList = [[NSDictionary dictionaryWithContentsOfFile:verifierPListPath] retain];
    
    _basePath = [path copy];
    _displayName = [[NSFileManager defaultManager] displayNameAtPath:_basePath];
    if (_displayName == nil)  _displayName = [_basePath lastPathComponent];
    [_displayName retain];
    
    _stagesByName = [[NSMutableDictionary alloc] init];
    _waitingStages = [[NSMutableSet alloc] init];
    
    if (_verifierPList == nil ||
        _basePath == nil)
    {
        OOLog(@"verifyOXP.setup.failed", @"%@", @"***** ERROR: failed to set up OXP verifier.");
        [self release];
        return nil;
    }
    
    _openForRegistration = YES;
    
    return self;
}

modelVerifierStage

- (OOModelVerifierStage *) modelVerifierStage

Provided by category OOOXPVerifier(OOModelVerifierStage).

Definition at line 34 of file OOModelVerifierStage.m.

{
    return [self stageWithName:kStageName];
}

oxpDisplayName

- (NSString *) oxpDisplayName

Definition at line 736 of file OOOXPVerifier.m.

{
    return [[_displayName retain] autorelease];
}

oxpPath

- (NSString *) oxpPath

Definition at line 736 of file OOOXPVerifier.m.

{
    return [[_basePath retain] autorelease];
}

registerBaseStages

- (void) registerBaseStages

implementation

Provided by category OOOXPVerifier(OOPrivate).

Definition at line 736 of file OOOXPVerifier.m.

{
    NSAutoreleasePool       *pool = nil;
    NSSet                   *stages = nil;
    NSSet                   *excludeStages = nil;
    NSString                *stageName = nil;
    Class                   stageClass = Nil;
    OOOXPVerifierStage      *stage = nil;
    
    pool = [[NSAutoreleasePool alloc] init];
    
    // Load stages specified as array of class names in verifyOXP.plist
    stages = [self configurationSetForKey:@"stages"];
    excludeStages = [self configurationSetForKey:@"excludeStages"];
    if ([excludeStages count] != 0)
    {
        stages = [[stages mutableCopy] autorelease];
        [(NSMutableSet *)stages minusSet:excludeStages];
    }
    foreach (stageName, stages)
    {
        if ([stageName isKindOfClass:[NSString class]])
        {
            stageClass = NSClassFromString(stageName);
            if (stageClass == Nil)
            {
                OOLog(@"verifyOXP.registration.failed", @"Attempt to register unknown class %@ as a verifier stage, ignoring.", stageName);
                continue;
            }
            stage = [[stageClass alloc] init];
            [self registerStage:stage];
            [stage release];
        }
    }
    
    [pool release];
}

registerStage:

- (void) registerStage:

(OOOXPVerifierStage *)

stage

Definition at line 736 of file OOOXPVerifier.m.

                     :(OOOXPVerifierStage *)stage
{
    NSString                *name = nil;
    OOOXPVerifierStage      *existing = nil;
    
    // Sanity checking
    if (stage == nil)  return;
    
    if (![stage isKindOfClass:[OOOXPVerifierStage class]])
    {
        OOLog(@"verifyOXP.registration.failed", @"Attempt to register class %@ as a verifier stage, but it is not a subclass of OOOXPVerifierStage; ignoring.", [stage class]);
        return;
    }
    
    if (!_openForRegistration)
    {
        OOLog(@"verifyOXP.registration.failed", @"Attempt to register verifier stage %@ after registration closed, ignoring.", stage);
        return;
    }
    
    name = [stage name];
    if (name == nil)
    {
        OOLog(@"verifyOXP.registration.failed", @"Attempt to register verifier stage %@ with nil name, ignoring.", stage);
        return;
    }
        
    // We can only have one stage with a given name. Registering the same stage twice is OK, though.
    existing = [_stagesByName objectForKey:name];
    if (existing == stage)  return;
    if (existing != nil)
    {
        OOLog(@"verifyOXP.registration.failed", @"Attempt to register verifier stage %@ with same name as stage %@, ignoring.", stage, existing);
        return;
    }
    
    // Checks passed, store state.
    [stage setVerifier:self];
    [_stagesByName setObject:stage forKey:name];
    [_waitingStages addObject:stage];
}

run

- (void) run

implementation

Provided by category OOOXPVerifier(OOPrivate).

Definition at line 736 of file OOOXPVerifier.m.

{
    NoteVerificationStage(_displayName, @"");
    
    [self setUpLogOverrides];
    
    /*  We need to be able to look up internal files, but not other OXP files.
        To do this without clobbering the disk cache, we disable cache writes.
    */
    [[OOCacheManager sharedCache] flush];
    [[OOCacheManager sharedCache] setAllowCacheWrites:NO];
    /* FIXME: the OXP verifier should load files from OXPs which have
     * been explicitly listed as required_oxps in the
     * manifest. Reading the manifest from the OXP being verified and
     * setting 'id:<its identifier>' below will do this. */
    [ResourceManager setUseAddOns:SCENARIO_OXP_DEFINITION_NONE];
    
    SwitchLogFile(_displayName);
    OOLog(@"verifyOXP.start", @"Running OXP verifier for %@", _basePath);//_displayName);
    
    [self registerBaseStages];
    [self buildDependencyGraph];
    [self runStages];
    
    NoteVerificationStage(_displayName, @"");
    OOLog(@"verifyOXP.done", @"%@", @"OXP verification complete.");
    
    OpenLogFile(_displayName);
}

runStages

- (void) runStages

implementation

Provided by category OOOXPVerifier(OOPrivate).

Definition at line 736 of file OOOXPVerifier.m.

{
    NSAutoreleasePool       *pool = nil;
    OOOXPVerifierStage      *candidateStage = nil,
                            *stageToRun = nil;
    NSString                *stageName = nil;
    
    // Loop while there are still stages to run.
    for (;;)
    {
        pool = [[NSAutoreleasePool alloc] init];
        
        // Look through queue for a stage that's ready
        stageToRun = nil;
        foreach (candidateStage, _waitingStages)
        {
            if ([candidateStage canRun])
            {
                stageToRun = candidateStage;
                break;
            }
        }
        if (stageToRun == nil)
        {
            // No more runnable stages
            [pool release];
            break;
        }
        
        stageName = nil;
        OOLogPushIndent();
        @try
        {
            stageName = [stageToRun name];
            if ([stageToRun shouldRun])
            {
                NoteVerificationStage(_displayName, stageName);
                OOLog(@"verifyOXP.runStage", @"%@", stageName);
                OOLogIndent();
                [stageToRun performRun];
            }
            else
            {
                OOLog(@"verifyOXP.verbose.skipStage", @"- Skipping stage: %@ (nothing to do).", stageName);
                [stageToRun noteSkipped];
            }
        }
        @catch (NSException *exception)
        {
            if (stageName == nil)  stageName = [[stageToRun class] description];
            OOLog(@"verifyOXP.exception", @"***** Exception occurred when running OXP verifier stage \"%@\": %@: %@", stageName, [exception name], [exception reason]);
        }
        OOLogPopIndent();
        
        [_waitingStages removeObject:stageToRun];
        [pool release];
    }
    
    pool = [[NSAutoreleasePool alloc] init];
    
    if ([_waitingStages count] != 0)
    {
        OOLog(@"verifyOXP.incomplete", @"%@", @"Some verifier stages could not be run:");
        OOLogIndent();
        foreach (candidateStage, _waitingStages)
        {
            OOLog(@"verifyOXP.incomplete.item", @"%@", candidateStage);
        }
        OOLogOutdent();
    }
    [_waitingStages release];
    _waitingStages = nil;
    
    [pool release];
}

setUpDependencies:forStage:

- (BOOL) setUpDependencies: (NSSet *)  dependencies forStage: (OOOXPVerifierStage *)  stage

implementation

Provided by category OOOXPVerifier(OOPrivate).

Definition at line 736 of file OOOXPVerifier.m.

                         :(NSSet *)dependencies
                 forStage:(OOOXPVerifierStage *)stage
{
    NSString                *depName = nil;
    OOOXPVerifierStage      *depStage = nil;
    
    // Iterate over dependencies, connecting them up.
    foreach (depName, dependencies)
    {
        depStage = [_stagesByName objectForKey:depName];
        if (depStage == nil)
        {
            OOLog(@"verifyOXP.buildDependencyGraph.unresolved", @"Verifier stage %@ has unresolved dependency \"%@\", skipping.", stage, depName);
            return NO;
        }
        
        if ([depStage isDependentOf:stage])
        {
            OOLog(@"verifyOXP.buildDependencyGraph.circularReference", @"Verifier stages %@ and %@ have a dependency loop, skipping.", stage, depStage);
            [_stagesByName removeObjectForKey:depName];
            return NO;
        }
        
        [stage registerDependency:depStage];
    }
    
    return YES;
}

setUpDependents:forStage:

- (void) setUpDependents: (NSSet *)  dependents forStage: (OOOXPVerifierStage *)  stage

implementation

Provided by category OOOXPVerifier(OOPrivate).

Definition at line 736 of file OOOXPVerifier.m.

                       :(NSSet *)dependents
               forStage:(OOOXPVerifierStage *)stage
{
    NSString                *depName = nil;
    OOOXPVerifierStage      *depStage = nil;
    
    // Iterate over dependents, connecting them up.
    foreach (depName, dependents)
    {
        depStage = [_stagesByName objectForKey:depName];
        if (depStage == nil)
        {
            OOLog(@"verifyOXP.buildDependencyGraph.unresolved", @"Verifier stage %@ has unresolved dependent \"%@\".", stage, depName);
            continue;   // Unresolved/conflicting dependents are non-fatal
        }
        
        if ([stage isDependentOf:depStage])
        {
            OOLog(@"verifyOXP.buildDependencyGraph.circularReference", @"Verifier stage %@ lists %@ as both dependent and dependency (possibly indirectly); will execute %@ after %@.", stage, depStage, stage, depStage);
            continue;
        }
        
        [depStage registerDependency:stage];
    }
}

setUpLogOverrides

- (void) setUpLogOverrides

implementation

Provided by category OOOXPVerifier(OOPrivate).

Definition at line 736 of file OOOXPVerifier.m.

{
    NSDictionary            *overrides = nil;
    NSString                *messageClass = nil;
    id                      verbose = nil;
    
    OOLogSetShowMessageClassTemporary([_verifierPList oo_boolForKey:@"logShowMessageClassOverride" defaultValue:NO]);
    
    overrides = [_verifierPList oo_dictionaryForKey:@"logControlOverride"];
    foreachkey (messageClass, overrides)
    {
        OOLogSetDisplayMessagesInClass(messageClass, [overrides oo_boolForKey:messageClass defaultValue:NO]);
    }
    
    /*  Since actually editing logControlOverride is a pain, we also allow
        overriding verifyOXP.verbose through user defaults. This is at least
        as much a pain under GNUstep, but very convenient under OS X.
    */
    verbose = [[NSUserDefaults standardUserDefaults] objectForKey:@"oxp-verifier-verbose-logging"];
    if (verbose != nil)  OOLogSetDisplayMessagesInClass(@"verifyOXP.verbose", OOBooleanFromObject(verbose, NO));
}

stageWithName:

- (id) stageWithName:

(NSString *)

name

Definition at line 736 of file OOOXPVerifier.m.

                   :(NSString *)name
{
    if (name == nil)  return nil;
    
    return [_stagesByName objectForKey:name];
}

textureVerifierStage

- (OOTextureVerifierStage *) textureVerifierStage

Provided by category OOOXPVerifier(OOTextureVerifierStage).

Definition at line 34 of file OOTextureVerifierStage.m.

{
    return [self stageWithName:kStageName];
}

Member Data Documentation

_basePath

- (NSString*) _basePath

private

Definition at line 52 of file OOOXPVerifier.h.

_displayName

- (NSString*) _displayName

private

Definition at line 53 of file OOOXPVerifier.h.

_openForRegistration

- (BOOL) _openForRegistration

private

Definition at line 58 of file OOOXPVerifier.h.

_stagesByName

- (NSMutableDictionary*) _stagesByName

private

Definition at line 55 of file OOOXPVerifier.h.

_verifierPList

- (NSDictionary*) _verifierPList

private

Definition at line 50 of file OOOXPVerifier.h.

_waitingStages

- (NSMutableSet*) _waitingStages

private

Definition at line 56 of file OOOXPVerifier.h.

---

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

• src/Core/OXPVerifier/OOOXPVerifier.h
• src/Core/OXPVerifier/OOOXPVerifier.m