OOPListSchemaVerifier.m File Reference

import "OOPListSchemaVerifier.h"
import "OOLoggingExtended.h"
import "OOCollectionExtractors.h"
import "OOMaths.h"
#include <limits.h>

Include dependency graph for OOPListSchemaVerifier.m:

Go to the source code of this file.

Classes
struct	BackLinkChain
category	OOPListSchemaVerifier(OOPrivate)
category	NSString(OOPListSchemaVerifierHelpers)

Macros
#define	PLIST_VERIFIER_DEBUG_DUMP_ENABLED   1
#define	DebugDumpIndent()   do { if (sDebugDump) OOLogIndent(); } while (0)
#define	DebugDumpOutdent()   do { if (sDebugDump) OOLogOutdent(); } while (0)
#define	DebugDumpPushIndent()   do { if (sDebugDump) OOLogPushIndent(); } while (0)
#define	DebugDumpPopIndent()   do { if (sDebugDump) OOLogPopIndent(); } while (0)
#define	DebugDump(...)   do { if (sDebugDump) OOLog(@"verifyOXP.verbose.plistDebugDump", __VA_ARGS__); } while (0)
#define	VERIFY_PROTO(T)   static NSError *Verify_##T(OOPListSchemaVerifier *verifier, id value, NSDictionary *params, id rootPList, NSString *name, BackLinkChain keyPath, BOOL tentative, BOOL *outStop)
#define	VERIFY_CASE(T)   case kType##T: error = Verify_##T(self, subProperty, resolvedSpecifier, rootPList, name, keyPath, tentative, outStop); break;
#define	REQUIRE_TYPE(CLASSNAME, NAMESTRING)

Typedefs
typedef struct BackLinkChain	BackLinkChain

Enumerations
enum	{ kMaximumLengthForStringInErrorMessage = 100 }
enum	{ kStartOfPrivateErrorCodes = kPListErrorLastErrorCode , kPListErrorFailedAndErrorHasBeenReported }
enum	SchemaType {   kTypeUnknown , kTypeString , kTypeArray , kTypeDictionary ,   kTypeInteger , kTypePositiveInteger , kTypeFloat , kTypePositiveFloat ,   kTypeOneOf , kTypeEnumeration , kTypeBoolean , kTypeFuzzyBoolean ,   kTypeVector , kTypeQuaternion , kTypeDelegatedType }

Functions
OOINLINE BackLinkChain	BackLink (BackLinkChain *link, id element)
OOINLINE BackLinkChain	BackLinkIndex (BackLinkChain *link, NSUInteger index)
OOINLINE BackLinkChain	BackLinkRoot (void)
static SchemaType	StringToSchemaType (NSString *string, NSError **outError)
static NSString *	ApplyStringFilter (NSString *string, id filterSpec, BackLinkChain keyPath, NSError **outError)
static BOOL	ApplyStringTest (NSString *string, id test, SEL testSelector, NSString *testDescription, BackLinkChain keyPath, NSError **outError)
static NSArray *	KeyPathToArray (BackLinkChain keyPath)
static NSString *	KeyPathToString (BackLinkChain keyPath)
static NSString *	StringForErrorReport (NSString *string)
static NSString *	ArrayForErrorReport (NSArray *array)
static NSString *	SetForErrorReport (NSSet *set)
static NSString *	StringOrArrayForErrorReport (id value, NSString *arrayPrefix)
static NSError *	Error (OOPListSchemaVerifierErrorCode errorCode, BackLinkChain *keyPath, NSString *format,...)
static NSError *	ErrorWithProperty (OOPListSchemaVerifierErrorCode errorCode, BackLinkChain *keyPath, NSString *propKey, id propValue, NSString *format,...)
static NSError *	ErrorWithDictionary (OOPListSchemaVerifierErrorCode errorCode, BackLinkChain *keyPath, NSDictionary *dict, NSString *format,...)
static NSError *	ErrorWithDictionaryAndArguments (OOPListSchemaVerifierErrorCode errorCode, BackLinkChain *keyPath, NSDictionary *dict, NSString *format, va_list arguments)
static NSError *	ErrorTypeMismatch (Class expectedClass, NSString *expectedClassName, id actualObject, BackLinkChain keyPath)
static NSError *	ErrorFailureAlreadyReported (void)
static BOOL	IsFailureAlreadyReportedError (NSError *error)
	VERIFY_PROTO (String)
	VERIFY_PROTO (Array)
	VERIFY_PROTO (Dictionary)
	VERIFY_PROTO (Integer)
	VERIFY_PROTO (PositiveInteger)
	VERIFY_PROTO (Float)
	VERIFY_PROTO (PositiveFloat)
	VERIFY_PROTO (OneOf)
	VERIFY_PROTO (Enumeration)
	VERIFY_PROTO (Boolean)
	VERIFY_PROTO (FuzzyBoolean)
	VERIFY_PROTO (Vector)
	VERIFY_PROTO (Quaternion)
	VERIFY_PROTO (DelegatedType)
static NSError *	Verify_String (OOPListSchemaVerifier *verifier, id value, NSDictionary *params, id rootPList, NSString *name, BackLinkChain keyPath, BOOL tentative, BOOL *outStop)
static NSError *	Verify_Array (OOPListSchemaVerifier *verifier, id value, NSDictionary *params, id rootPList, NSString *name, BackLinkChain keyPath, BOOL tentative, BOOL *outStop)
static NSError *	Verify_Dictionary (OOPListSchemaVerifier *verifier, id value, NSDictionary *params, id rootPList, NSString *name, BackLinkChain keyPath, BOOL tentative, BOOL *outStop)
static NSError *	Verify_Integer (OOPListSchemaVerifier *verifier, id value, NSDictionary *params, id rootPList, NSString *name, BackLinkChain keyPath, BOOL tentative, BOOL *outStop)
static NSError *	Verify_PositiveInteger (OOPListSchemaVerifier *verifier, id value, NSDictionary *params, id rootPList, NSString *name, BackLinkChain keyPath, BOOL tentative, BOOL *outStop)
static NSError *	Verify_Float (OOPListSchemaVerifier *verifier, id value, NSDictionary *params, id rootPList, NSString *name, BackLinkChain keyPath, BOOL tentative, BOOL *outStop)
static NSError *	Verify_PositiveFloat (OOPListSchemaVerifier *verifier, id value, NSDictionary *params, id rootPList, NSString *name, BackLinkChain keyPath, BOOL tentative, BOOL *outStop)
static NSError *	Verify_OneOf (OOPListSchemaVerifier *verifier, id value, NSDictionary *params, id rootPList, NSString *name, BackLinkChain keyPath, BOOL tentative, BOOL *outStop)
static NSError *	Verify_Enumeration (OOPListSchemaVerifier *verifier, id value, NSDictionary *params, id rootPList, NSString *name, BackLinkChain keyPath, BOOL tentative, BOOL *outStop)
static NSError *	Verify_Boolean (OOPListSchemaVerifier *verifier, id value, NSDictionary *params, id rootPList, NSString *name, BackLinkChain keyPath, BOOL tentative, BOOL *outStop)
static NSError *	Verify_FuzzyBoolean (OOPListSchemaVerifier *verifier, id value, NSDictionary *params, id rootPList, NSString *name, BackLinkChain keyPath, BOOL tentative, BOOL *outStop)
static NSError *	Verify_Vector (OOPListSchemaVerifier *verifier, id value, NSDictionary *params, id rootPList, NSString *name, BackLinkChain keyPath, BOOL tentative, BOOL *outStop)
static NSError *	Verify_Quaternion (OOPListSchemaVerifier *verifier, id value, NSDictionary *params, id rootPList, NSString *name, BackLinkChain keyPath, BOOL tentative, BOOL *outStop)
static NSError *	Verify_DelegatedType (OOPListSchemaVerifier *verifier, id value, NSDictionary *params, id rootPList, NSString *name, BackLinkChain keyPath, BOOL tentative, BOOL *outStop)

Variables
static BOOL	sDebugDump = NO
NSString *const	kOOPListSchemaVerifierErrorDomain = @"org.aegidian.oolite.OOPListSchemaVerifier.ErrorDomain"
NSString *const	kPListKeyPathErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier plist key path"
NSString *const	kSchemaKeyPathErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier schema key path"
NSString *const	kExpectedClassErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier expected class"
NSString *const	kExpectedClassNameErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier expected class name"
NSString *const	kUnknownKeyErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier unknown key"
NSString *const	kMissingRequiredKeysErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier missing required keys"
NSString *const	kMissingSubStringErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier missing substring"
NSString *const	kUnnownFilterErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier unknown filter"
NSString *const	kErrorsByOptionErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier errors by option"
NSString *const	kUnknownTypeErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier unknown type"
NSString *const	kUndefinedMacroErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier undefined macro"

Macro Definition Documentation

DebugDump

#define DebugDump

(

...

)

do { if (sDebugDump) OOLog(@"verifyOXP.verbose.plistDebugDump", __VA_ARGS__); } while (0)

Definition at line 64 of file OOPListSchemaVerifier.m.

DebugDumpIndent

#define DebugDumpIndent

(

)

do { if (sDebugDump) OOLogIndent(); } while (0)

Definition at line 60 of file OOPListSchemaVerifier.m.

DebugDumpOutdent

#define DebugDumpOutdent

(

)

do { if (sDebugDump) OOLogOutdent(); } while (0)

Definition at line 61 of file OOPListSchemaVerifier.m.

DebugDumpPopIndent

#define DebugDumpPopIndent

(

)

do { if (sDebugDump) OOLogPopIndent(); } while (0)

Definition at line 63 of file OOPListSchemaVerifier.m.

DebugDumpPushIndent

#define DebugDumpPushIndent

(

)

do { if (sDebugDump) OOLogPushIndent(); } while (0)

Definition at line 62 of file OOPListSchemaVerifier.m.

PLIST_VERIFIER_DEBUG_DUMP_ENABLED

#define PLIST_VERIFIER_DEBUG_DUMP_ENABLED   1

Definition at line 38 of file OOPListSchemaVerifier.m.

REQUIRE_TYPE

#define REQUIRE_TYPE	(		CLASSNAME,
			NAMESTRING
	)

Value:

        do { \
        if (![value isKindOfClass:[CLASSNAME class]]) \
        { \
            return ErrorTypeMismatch([CLASSNAME class], NAMESTRING, value, keyPath); \
        } \
    } while (0)

Definition at line 830 of file OOPListSchemaVerifier.m.

                                                { \
        if (![value isKindOfClass:[CLASSNAME class]]) \
        { \
            return ErrorTypeMismatch([CLASSNAME class], NAMESTRING, value, keyPath); \
        } \
    } while (0)

VERIFY_CASE

#define VERIFY_CASE

(

T

)

case kType##T: error = Verify_##T(self, subProperty, resolvedSpecifier, rootPList, name, keyPath, tentative, outStop); break;

VERIFY_PROTO

#define VERIFY_PROTO

(

T

)

static NSError *Verify_##T(OOPListSchemaVerifier *verifier, id value, NSDictionary *params, id rootPList, NSString *name, BackLinkChain keyPath, BOOL tentative, BOOL *outStop)

Definition at line 196 of file OOPListSchemaVerifier.m.

Typedef Documentation

BackLinkChain

typedef struct BackLinkChain BackLinkChain

Definition at line 111 of file OOPListSchemaVerifier.m.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
kMaximumLengthForStringInErrorMessage

Definition at line 41 of file OOPListSchemaVerifier.m.

{
    // Largest allowable number of characters for string included in error message.
    kMaximumLengthForStringInErrorMessage       = 100
};

anonymous enum

anonymous enum

Enumerator
kStartOfPrivateErrorCodes
kPListErrorFailedAndErrorHasBeenReported

Definition at line 49 of file OOPListSchemaVerifier.m.

{
    kStartOfPrivateErrorCodes = kPListErrorLastErrorCode,
    
    kPListErrorFailedAndErrorHasBeenReported
};

SchemaType

enum SchemaType

Enumerator
kTypeUnknown
kTypeString
kTypeArray
kTypeDictionary
kTypeInteger
kTypePositiveInteger
kTypeFloat
kTypePositiveFloat
kTypeOneOf
kTypeEnumeration
kTypeBoolean
kTypeFuzzyBoolean
kTypeVector
kTypeQuaternion
kTypeDelegatedType

Definition at line 91 of file OOPListSchemaVerifier.m.

{
    kTypeUnknown,
    kTypeString,
    kTypeArray,
    kTypeDictionary,
    kTypeInteger,
    kTypePositiveInteger,
    kTypeFloat,
    kTypePositiveFloat,
    kTypeOneOf,
    kTypeEnumeration,
    kTypeBoolean,
    kTypeFuzzyBoolean,
    kTypeVector,
    kTypeQuaternion,
    kTypeDelegatedType
} SchemaType;

Function Documentation

ApplyStringFilter()

static NSString * ApplyStringFilter ( NSString *  string, id  filterSpec, BackLinkChain  keyPath, NSError **  outError  )

static

Definition at line 595 of file OOPListSchemaVerifier.m.

{
    NSEnumerator            *filterEnum = nil;
    id                      filter = nil;
    NSRange                 range;
    
    assert(outError != NULL);
    
    if (filterSpec == nil)  return string;
    
    if ([filterSpec isKindOfClass:[NSString class]])
    {
        filterSpec = [NSArray arrayWithObject:filterSpec];
    }
    if ([filterSpec isKindOfClass:[NSArray class]])
    {
        for (filterEnum = [filterSpec objectEnumerator]; (filter = [filterEnum nextObject]); )
        {
            if ([filter isKindOfClass:[NSString class]])
            {
                if ([filter isEqual:@"lowerCase"])  string = [string lowercaseString];
                else if ([filter isEqual:@"upperCase"])  string = [string uppercaseString];
                else if ([filter isEqual:@"capitalized"])  string = [string capitalizedString];
                else if ([filter hasPrefix:@"truncFront:"])
                {
                    string = [string substringToIndex:[[filter substringFromIndex:11] intValue]];
                }
                else if ([filter hasPrefix:@"truncBack:"])
                {
                    string = [string substringToIndex:[[filter substringFromIndex:10] intValue]];
                }
                else if ([filter hasPrefix:@"subStringTo:"])
                {
                    range = [string rangeOfString:[filter substringFromIndex:12]];
                    if (range.location != NSNotFound)
                    {
                        string = [string substringToIndex:range.location];
                    }
                }
                else if ([filter hasPrefix:@"subStringFrom:"])
                {
                    range = [string rangeOfString:[filter substringFromIndex:14]];
                    if (range.location != NSNotFound)
                    {
                        string = [string substringFromIndex:range.location + range.length];
                    }
                }
                else if ([filter hasPrefix:@"subStringToInclusive:"])
                {
                    range = [string rangeOfString:[filter substringFromIndex:21]];
                    if (range.location != NSNotFound)
                    {
                        string = [string substringToIndex:range.location + range.length];
                    }
                }
                else if ([filter hasPrefix:@"subStringFromInclusive:"])
                {
                    range = [string rangeOfString:[filter substringFromIndex:23]];
                    if (range.location != NSNotFound)
                    {
                        string = [string substringFromIndex:range.location];
                    }
                }
                else
                {
                    *outError = ErrorWithProperty(kPListErrorSchemaUnknownFilter, &keyPath, kUnnownFilterErrorKey, filter, @"Bad schema: unknown string filter specifier \"%@\".", filter);
                }
            }
            else
            {
                *outError = Error(kPListErrorSchemaUnknownFilter, &keyPath, @"Bad schema: filter specifier is not a string.");
            }
        }
    }
    else
    {
        *outError = Error(kPListErrorSchemaUnknownFilter, &keyPath, @"Bad schema: \"filter\" must be a string or an array.");
    }
    
    return string;
}

References Error(), ErrorWithProperty(), kPListErrorSchemaUnknownFilter, kUnnownFilterErrorKey, and nil.

Referenced by Verify_Enumeration(), and Verify_String().

Here is the call graph for this function:

Here is the caller graph for this function:

ApplyStringTest()

static BOOL ApplyStringTest ( NSString *  string, id  test, SEL  testSelector, NSString *  testDescription, BackLinkChain  keyPath, NSError **  outError  )

static

Definition at line 678 of file OOPListSchemaVerifier.m.

{
    BOOL                    (*testIMP)(id, SEL, NSString *);
    NSEnumerator            *testEnum = nil;
    id                      subTest = nil;
    
    assert(outError != NULL);
    
    if (test == nil)  return YES;
    
    testIMP = (BOOL(*)(id, SEL, NSString *))[string methodForSelector:testSelector];
    if (testIMP == NULL)
    {
        *outError = Error(kPListErrorInternal, &keyPath, @"OOPListSchemaVerifier internal error: NSString does not respond to test selector %@.", NSStringFromSelector(testSelector));
        return NO;
    }
    
    if ([test isKindOfClass:[NSString class]])
    {
        test = [NSArray arrayWithObject:test];
    }
    
    if ([test isKindOfClass:[NSArray class]])
    {
        for (testEnum = [test objectEnumerator]; (subTest = [testEnum nextObject]); )
        {
            if ([subTest isKindOfClass:[NSString class]])
            {
                if (testIMP(string, testSelector, subTest))  return YES;
            }
            else
            {
                *outError = Error(kPListErrorSchemaBadComparator, &keyPath, @"Bad schema: required %@ is not a string.", testDescription);
                return NO;
            }
        }
    }
    else
    {
        *outError = Error(kPListErrorSchemaBadComparator, &keyPath, @"Bad schema: %@ requirement specification is not a string or array.", testDescription);
    }
    return NO;
}

References Error(), kPListErrorInternal, kPListErrorSchemaBadComparator, and nil.

Referenced by Verify_String().

Here is the call graph for this function:

Here is the caller graph for this function:

ArrayForErrorReport()

static NSString * ArrayForErrorReport ( NSArray *  array )

static

Definition at line 768 of file OOPListSchemaVerifier.m.

{
    NSString                *result = nil;
    NSString                *string = nil;
    NSUInteger              i, count;
    NSAutoreleasePool       *pool = nil;
    
    count = [array count];
    if (count == 0)  return @"( )";
    
    pool = [[NSAutoreleasePool alloc] init];
    
    result = [NSString stringWithFormat:@"(%@", [array objectAtIndex:0]];
    
    for (i = 1; i != count; ++i)
    {
        string = [result stringByAppendingFormat:@", %@", [array objectAtIndex:i]];
        if (kMaximumLengthForStringInErrorMessage < [string length])
        {
            result = [result stringByAppendingString:@", ..."];
            break;
        }
        result = string;
    }
    
    result = [result stringByAppendingString:@")"];
    
    [result retain];
    [pool release];
    return [result autorelease];
}

References count, kMaximumLengthForStringInErrorMessage, and nil.

Referenced by SetForErrorReport(), and Verify_Enumeration().

Here is the caller graph for this function:

BackLink()

OOINLINE BackLinkChain BackLink	(	BackLinkChain *	link,
		id	element
	)

Definition at line 118 of file OOPListSchemaVerifier.m.

{
    BackLinkChain result = { link, element };
    return result;
}

References BackLinkChain::element, and BackLinkChain::link.

Referenced by Verify_Dictionary().

Here is the caller graph for this function:

BackLinkIndex()

OOINLINE BackLinkChain BackLinkIndex	(	BackLinkChain *	link,
		NSUInteger	index
	)

Definition at line 124 of file OOPListSchemaVerifier.m.

{
    BackLinkChain result = { link, [NSNumber numberWithInteger:index] };
    return result;
}

References BackLinkChain::link.

Referenced by Verify_Array().

Here is the caller graph for this function:

BackLinkRoot()

OOINLINE BackLinkChain BackLinkRoot

(

void

)

Definition at line 130 of file OOPListSchemaVerifier.m.

{
    BackLinkChain result = { NULL, NULL };
    return result;
}

Error()

static NSError * Error ( OOPListSchemaVerifierErrorCode  errorCode, BackLinkChain *  keyPath, NSString *  format,   ...  )

static

Definition at line 1406 of file OOPListSchemaVerifier.m.

{
    NSError             *result = nil;
    va_list             args;
    
    va_start(args, format);
    result = ErrorWithDictionaryAndArguments(errorCode, keyPath, nil, format, args);
    va_end(args);
    
    return result;
}

References ErrorWithDictionaryAndArguments(), and nil.

Here is the call graph for this function:

ErrorFailureAlreadyReported()

static NSError * ErrorFailureAlreadyReported ( void  )

static

Definition at line 1495 of file OOPListSchemaVerifier.m.

{
    return [NSError errorWithDomain:kOOPListSchemaVerifierErrorDomain code:kPListErrorFailedAndErrorHasBeenReported userInfo:nil];
}

Referenced by Verify_Array(), and Verify_Dictionary().

Here is the caller graph for this function:

ErrorTypeMismatch()

static NSError * ErrorTypeMismatch ( Class  expectedClass, NSString *  expectedClassName, id  actualObject, BackLinkChain  keyPath  )

static

Definition at line 1470 of file OOPListSchemaVerifier.m.

{
    NSDictionary        *dict = nil;
    NSString            *className = nil;
    
    if (expectedClassName == nil)  expectedClassName = [expectedClass description];
    
    dict = [NSDictionary dictionaryWithObjectsAndKeys:
                expectedClassName, kExpectedClassNameErrorKey,
                expectedClass, kExpectedClassErrorKey,
                nil];
    
    if (actualObject == nil)  className = @"nothing";
    else if ([actualObject isKindOfClass:[NSString class]])  className = @"string";
    else if ([actualObject isKindOfClass:[NSNumber class]])  className = @"number";
    else if ([actualObject isKindOfClass:[NSArray class]])  className = @"array";
    else if ([actualObject isKindOfClass:[NSDictionary class]])  className = @"dictionary";
    else if ([actualObject isKindOfClass:[NSData class]])  className = @"data";
    else if ([actualObject isKindOfClass:[NSDate class]])  className = @"date";
    else  className = [[actualObject class] description];
    
    return ErrorWithDictionary(kPListErrorTypeMismatch, &keyPath, dict, @"Expected %@, found %@.", expectedClassName, className);
}

References ErrorWithDictionary(), kPListErrorTypeMismatch, and nil.

Referenced by Verify_Boolean(), Verify_Float(), Verify_FuzzyBoolean(), Verify_Integer(), Verify_PositiveFloat(), Verify_PositiveInteger(), Verify_Quaternion(), and Verify_Vector().

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorWithDictionary()

static NSError * ErrorWithDictionary ( OOPListSchemaVerifierErrorCode  errorCode, BackLinkChain *  keyPath, NSDictionary *  dict, NSString *  format,   ...  )

static

Definition at line 1437 of file OOPListSchemaVerifier.m.

{
    NSError             *result = nil;
    va_list             args;
    
    va_start(args, format);
    result = ErrorWithDictionaryAndArguments(errorCode, keyPath, dict, format, args);
    va_end(args);
    
    return result;
}

References ErrorWithDictionaryAndArguments(), and nil.

Referenced by ErrorTypeMismatch().

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorWithDictionaryAndArguments()

static NSError * ErrorWithDictionaryAndArguments ( OOPListSchemaVerifierErrorCode  errorCode, BackLinkChain *  keyPath, NSDictionary *  dict, NSString *  format, va_list  arguments  )

static

Definition at line 1450 of file OOPListSchemaVerifier.m.

{
    NSString            *message = nil;
    NSMutableDictionary *userInfo = nil;
    
    message = [[NSString alloc] initWithFormat:format arguments:arguments];
    
    userInfo = [NSMutableDictionary dictionaryWithDictionary:dict];
    [userInfo setObject:message forKey:NSLocalizedFailureReasonErrorKey];
    if (keyPath != NULL)
    {
        [userInfo setObject:KeyPathToArray(*keyPath) forKey:kPListKeyPathErrorKey];
    }
    
    [message release];
    
    return [NSError errorWithDomain:kOOPListSchemaVerifierErrorDomain code:errorCode userInfo:userInfo];
}

References nil.

Referenced by Error(), ErrorWithDictionary(), and ErrorWithProperty().

Here is the caller graph for this function:

ErrorWithProperty()

static NSError * ErrorWithProperty ( OOPListSchemaVerifierErrorCode  errorCode, BackLinkChain *  keyPath, NSString *  propKey, id  propValue, NSString *  format,   ...  )

static

Definition at line 1419 of file OOPListSchemaVerifier.m.

{
    NSError             *result = nil;
    va_list             args;
    NSDictionary        *dict = nil;
    
    if (propKey != nil && propValue != nil)
    {
        dict = [NSDictionary dictionaryWithObject:propValue forKey:propKey];
    }
    va_start(args, format);
    result = ErrorWithDictionaryAndArguments(errorCode, keyPath, dict, format, args);
    va_end(args);
    
    return result;
}

References ErrorWithDictionaryAndArguments(), and nil.

Referenced by ApplyStringFilter(), StringToSchemaType(), Verify_Dictionary(), Verify_OneOf(), and Verify_String().

Here is the call graph for this function:

Here is the caller graph for this function:

IsFailureAlreadyReportedError()

static BOOL IsFailureAlreadyReportedError ( NSError *  error )

static

Definition at line 1501 of file OOPListSchemaVerifier.m.

{
    return [[error domain] isEqualToString:kOOPListSchemaVerifierErrorDomain] && [error code] == kPListErrorFailedAndErrorHasBeenReported;
}

References kPListErrorFailedAndErrorHasBeenReported.

KeyPathToArray()

static NSArray * KeyPathToArray ( BackLinkChain  keyPath )

static

Definition at line 723 of file OOPListSchemaVerifier.m.

{
    NSMutableArray          *result = nil;
    BackLinkChain           *curr = NULL;
    
    result = [NSMutableArray array];
    for (curr = &keyPath; curr != NULL; curr = curr->link)
    {
        if (curr->element != nil)  [result insertObject:curr->element atIndex:0];
    }
    
    return result;
}

References BackLinkChain::element, BackLinkChain::link, and nil.

KeyPathToString()

static NSString * KeyPathToString ( BackLinkChain  keyPath )

static

Definition at line 738 of file OOPListSchemaVerifier.m.

{
    return [OOPListSchemaVerifier descriptionForKeyPath:KeyPathToArray(keyPath)];
}

References OOPListSchemaVerifier::descriptionForKeyPath:.

Here is the call graph for this function:

SetForErrorReport()

static NSString * SetForErrorReport ( NSSet *  set )

static

Definition at line 801 of file OOPListSchemaVerifier.m.

{
    return ArrayForErrorReport([[set allObjects] sortedArrayUsingSelector:@selector(caseInsensitiveCompare:)]);
}

References ArrayForErrorReport().

Referenced by Verify_Dictionary().

Here is the call graph for this function:

Here is the caller graph for this function:

StringForErrorReport()

static NSString * StringForErrorReport ( NSString *  string )

static

Definition at line 744 of file OOPListSchemaVerifier.m.

{
    id                      result = nil;
    
    if (kMaximumLengthForStringInErrorMessage < [string length])
    {
        string = [string substringToIndex:kMaximumLengthForStringInErrorMessage];
    }
    result = [NSMutableString stringWithString:string];
    [result replaceOccurrencesOfString:@"\t" withString:@"    " options:0 range:NSMakeRange(0, [string length])];
    [result replaceOccurrencesOfString:@"\r\n" withString:@" \\ " options:0 range:NSMakeRange(0, [string length])];
    [result replaceOccurrencesOfString:@"\n" withString:@" \\ " options:0 range:NSMakeRange(0, [string length])];
    [result replaceOccurrencesOfString:@"\r" withString:@" \\ " options:0 range:NSMakeRange(0, [string length])];
    
    if (kMaximumLengthForStringInErrorMessage < [result length])
    {
        result = [result substringToIndex:kMaximumLengthForStringInErrorMessage - 3];
        result = [result stringByAppendingString:@"..."];
    }
    
    return result;
}

References kMaximumLengthForStringInErrorMessage, and nil.

Referenced by Verify_Dictionary(), Verify_Enumeration(), and Verify_String().

Here is the caller graph for this function:

StringOrArrayForErrorReport()

static NSString * StringOrArrayForErrorReport ( id  value, NSString *  arrayPrefix  )

static

Definition at line 807 of file OOPListSchemaVerifier.m.

{
    if ([value isKindOfClass:[NSString class]])
    {
        return [NSString stringWithFormat:@"\"%@\"", StringForErrorReport(value)];
    }
    
    if (arrayPrefix == nil)  arrayPrefix = @"";
    if ([value isKindOfClass:[NSArray class]])
    {
        return [arrayPrefix stringByAppendingString:ArrayForErrorReport(value)];
    }
    if ([value isKindOfClass:[NSSet class]])
    {
        return [arrayPrefix stringByAppendingString:SetForErrorReport(value)];
    }
    if (value == nil)  return @"(null)";
    return @"<?>";
}

References nil.

Referenced by Verify_String().

Here is the caller graph for this function:

StringToSchemaType()

static SchemaType StringToSchemaType ( NSString *  string, NSError **  outError  )

static

Definition at line 551 of file OOPListSchemaVerifier.m.

{
    static NSDictionary         *typeMap = nil;
    SchemaType                  result;
    
    if (typeMap == nil)
    {
        typeMap =
            [[NSDictionary dictionaryWithObjectsAndKeys:
                [NSNumber numberWithUnsignedInt:kTypeString],           @"string",
                [NSNumber numberWithUnsignedInt:kTypeArray],            @"array",
                [NSNumber numberWithUnsignedInt:kTypeDictionary],       @"dictionary",
                [NSNumber numberWithUnsignedInt:kTypeInteger],          @"integer",
                [NSNumber numberWithUnsignedInt:kTypePositiveInteger],  @"positiveInteger",
                [NSNumber numberWithUnsignedInt:kTypeFloat],            @"float",
                [NSNumber numberWithUnsignedInt:kTypePositiveFloat],    @"positiveFloat",
                [NSNumber numberWithUnsignedInt:kTypeOneOf],            @"oneOf",
                [NSNumber numberWithUnsignedInt:kTypeEnumeration],      @"enumeration",
                [NSNumber numberWithUnsignedInt:kTypeBoolean],          @"boolean",
                [NSNumber numberWithUnsignedInt:kTypeFuzzyBoolean],     @"fuzzyBoolean",
                [NSNumber numberWithUnsignedInt:kTypeVector],           @"vector",
                [NSNumber numberWithUnsignedInt:kTypeQuaternion],       @"quaternion",
                [NSNumber numberWithUnsignedInt:kTypeDelegatedType],    @"delegatedType",
                nil
             ] retain];
    }
    
    result = [[typeMap objectForKey:string] unsignedIntValue];
    if (result == kTypeUnknown && outError != NULL)
    {
        if ([string hasPrefix:@"$"])
        {
            *outError = ErrorWithProperty(kPListErrorSchemaUnknownType, NULL, kUnknownTypeErrorKey, string, @"Bad schema: unresolved macro reference \"%@\".", string);
        }
        else
        {
            *outError = ErrorWithProperty(kPListErrorSchemaUnknownType, NULL, kUnknownTypeErrorKey, string, @"Bad schema: unknown type \"%@\".", string);
        }
    }
    
    return result;
}

References ErrorWithProperty(), kPListErrorSchemaUnknownType, kTypeUnknown, kUnknownTypeErrorKey, and nil.

Here is the call graph for this function:

Verify_Array()

static NSError * Verify_Array ( OOPListSchemaVerifier *  verifier, id  value, NSDictionary *  params, id  rootPList, NSString *  name, BackLinkChain  keyPath, BOOL  tentative, BOOL *  outStop  )

static

Definition at line 903 of file OOPListSchemaVerifier.m.

{
    id                      valueType = nil;
    BOOL                    OK = YES, stop = NO;
    NSUInteger              i, count;
    id                      subProperty = nil;
    NSUInteger              constraint;
    
    REQUIRE_TYPE(NSArray, @"array");
    
    DebugDump(@"%@", @"* array");
    
    // Apply count bounds.
    count = [value count];
    constraint = [params oo_unsignedIntegerForKey:@"minCount" defaultValue:0];
    if (count < constraint)
    {
        return  Error(kPListErrorMinimumConstraintNotMet, &keyPath, @"Array has too few members (%u, minimum is %u).", count, constraint);
    }
    
    constraint = [params oo_unsignedIntegerForKey:@"maxCount" defaultValue:NSUIntegerMax];
    if (constraint < count)
    {
        return  Error(kPListErrorMaximumConstraintNotMet, &keyPath, @"Array has too many members (%u, maximum is %u).", count, constraint);
    }
    
    // Test member objects.
    valueType = [params objectForKey:@"valueType"];
    if (valueType != nil)
    {
        for (i = 0; i != count; ++i)
        {
            subProperty = [value objectAtIndex:i];
            
            if (![verifier verifyPList:rootPList
                                 named:name
                           subProperty:subProperty
                     againstSchemaType:valueType
                                atPath:BackLinkIndex(&keyPath, i)
                             tentative:tentative
                                 error:NULL
                                  stop:&stop])
            {
                OK = NO;
            }
            
            if ((stop && !tentative) || (tentative && !OK))  break;
        }
    }
    
    *outStop = stop && !tentative;
    
    if (!OK)  return ErrorFailureAlreadyReported();
    else  return nil;
}

References BackLinkIndex(), count, DebugDump, Error(), ErrorFailureAlreadyReported(), kPListErrorMaximumConstraintNotMet, kPListErrorMinimumConstraintNotMet, nil, and REQUIRE_TYPE.

Here is the call graph for this function:

Verify_Boolean()

static NSError * Verify_Boolean ( OOPListSchemaVerifier *  verifier, id  value, NSDictionary *  params, id  rootPList, NSString *  name, BackLinkChain  keyPath, BOOL  tentative, BOOL *  outStop  )

static

Definition at line 1282 of file OOPListSchemaVerifier.m.

{
    DebugDump(@"* boolean: %@", value);
    
    // Check basic parseability. If there's inequality here, the default value is being returned.
    if (OOBooleanFromObject(value, 0) == OOBooleanFromObject(value, 1))  return nil;
    else  return ErrorTypeMismatch([NSNumber class], @"boolean", value, keyPath);
}

References DebugDump, ErrorTypeMismatch(), nil, and OOBooleanFromObject().

Here is the call graph for this function:

Verify_DelegatedType()

static NSError * Verify_DelegatedType ( OOPListSchemaVerifier *  verifier, id  value, NSDictionary *  params, id  rootPList, NSString *  name, BackLinkChain  keyPath, BOOL  tentative, BOOL *  outStop  )

static

Definition at line 1323 of file OOPListSchemaVerifier.m.

{
    id                      baseType = nil;
    NSString                *key = nil;
    BOOL                    stop = NO;
    NSError                 *error = nil;
    
    DebugDump(@"* delegated type: %@", [params objectForKey:@"key"]);
    
    baseType = [params objectForKey:@"baseType"];
    if (baseType != nil)
    {
        if (![verifier verifyPList:rootPList
                             named:name
                       subProperty:value
                 againstSchemaType:baseType
                            atPath:keyPath
                         tentative:tentative
                             error:NULL
                              stop:&stop])
        {
            *outStop = stop;
            return nil;
        }
    }
    
    key = [params objectForKey:@"key"];
    *outStop = ![verifier delegateVerifierWithPropertyList:rootPList
                                                     named:name
                                              testProperty:value
                                                    atPath:keyPath
                                               againstType:key
                                                     error:&error];
    return error;
}

References DebugDump, OOPListSchemaVerifier::delegateVerifierWithPropertyList:named:testProperty:atPath:againstType:error:, and nil.

Here is the call graph for this function:

Verify_Dictionary()

static NSError * Verify_Dictionary ( OOPListSchemaVerifier *  verifier, id  value, NSDictionary *  params, id  rootPList, NSString *  name, BackLinkChain  keyPath, BOOL  tentative, BOOL *  outStop  )

static

Definition at line 960 of file OOPListSchemaVerifier.m.

{
    NSDictionary            *schema = nil;
    id                      valueType = nil,
                            typeSpec = nil;
    NSEnumerator            *keyEnum = nil;
    NSString                *key = nil;
    id                      subProperty = nil;
    BOOL                    OK = YES, stop = NO, prematureExit = NO;
    BOOL                    allowOthers;
    NSMutableSet            *requiredKeys = nil;
    NSArray                 *requiredKeyList = nil;
    NSUInteger              count, constraint;
    
    REQUIRE_TYPE(NSDictionary, @"dictionary");
    
    DebugDump(@"%@", @"* dictionary");
    
    // Apply count bounds.
    count = [value count];
    constraint = [params oo_unsignedIntegerForKey:@"minCount" defaultValue:0];
    if (count < constraint)
    {
        return  Error(kPListErrorMinimumConstraintNotMet, &keyPath, @"Dictionary has too few pairs (%u, minimum is %u).", count, constraint);
    }
    constraint = [params oo_unsignedIntegerForKey:@"maxCount" defaultValue:NSUIntegerMax];
    if (constraint < count)
    {
        return  Error(kPListErrorMaximumConstraintNotMet, &keyPath, @"Dictionary has too manu pairs (%u, maximum is %u).", count, constraint);
    }
    
    // Get schema.
    schema = [params oo_dictionaryForKey:@"schema"];
    valueType = [params objectForKey:@"valueType"];
    allowOthers = [params oo_boolForKey:@"allowOthers" defaultValue:YES];
    requiredKeyList = [params oo_arrayForKey:@"requiredKeys"];
    
    // If these conditions are met, all members must pass:
    if (schema == nil && valueType == nil && requiredKeyList == nil && allowOthers)  return nil;
    
    if (requiredKeyList != nil)
    {
        requiredKeys = [NSMutableSet setWithArray:requiredKeyList];
    }
    
    DebugDumpIndent();
    
    // Test member objects.
    for (keyEnum = [value keyEnumerator]; (key = [keyEnum nextObject]) && !stop; )
    {
        subProperty = [(NSDictionary *)value objectForKey:key];
        typeSpec = [schema objectForKey:key];
        if (typeSpec == nil)  typeSpec = valueType;
        
        DebugDump(@"- \"%@\"", key);
        DebugDumpIndent();
        
        if (typeSpec != nil)
        {
            if (![verifier verifyPList:rootPList
                                 named:name
                           subProperty:subProperty
                     againstSchemaType:typeSpec
                                atPath:BackLink(&keyPath, key)
                             tentative:tentative
                                 error:NULL
                                  stop:&stop])
            {
                OK = NO;
            }
        }
        else if (!allowOthers && ![requiredKeys containsObject:key] && [schema objectForKey:key] == nil)
        {
            // Report error now rather than returning it, since there may be several unknown keys.
            if (!tentative)
            {
                NSError *error = ErrorWithProperty(kPListErrorDictionaryUnknownKey, &keyPath, kUnknownKeyErrorKey, key, @"Unpermitted key \"%@\" in dictionary.", StringForErrorReport(key));
                stop = ![verifier delegateVerifierWithPropertyList:rootPList
                                                             named:name
                                                 failedForProperty:value
                                                         withError:error
                                                      expectedType:params];
            }
            OK = NO;
        }
        
        DebugDumpOutdent();
        
        [requiredKeys removeObject:key];
        
        if ((stop && !tentative) || (tentative && !OK))
        {
            prematureExit = YES;
            break;
        }
    }
    
    DebugDumpOutdent();
    
    // Check that all required keys were present.
    if (!prematureExit && [requiredKeys count] != 0)
    {
        return ErrorWithProperty(kPListErrorDictionaryMissingRequiredKeys, &keyPath, kMissingRequiredKeysErrorKey, requiredKeys, @"Required keys %@ missing from dictionary.", SetForErrorReport(requiredKeys));
    }
    
    *outStop = stop && !tentative;
    
    if (!OK)  return ErrorFailureAlreadyReported();
    else  return nil;
}

References BackLink(), count, DebugDump, DebugDumpIndent, DebugDumpOutdent, OOPListSchemaVerifier::delegateVerifierWithPropertyList:named:failedForProperty:withError:expectedType:, Error(), ErrorFailureAlreadyReported(), ErrorWithProperty(), kMissingRequiredKeysErrorKey, kPListErrorDictionaryMissingRequiredKeys, kPListErrorDictionaryUnknownKey, kPListErrorMaximumConstraintNotMet, kPListErrorMinimumConstraintNotMet, kUnknownKeyErrorKey, nil, REQUIRE_TYPE, SetForErrorReport(), and StringForErrorReport().

Here is the call graph for this function:

Verify_Enumeration()

static NSError * Verify_Enumeration ( OOPListSchemaVerifier *  verifier, id  value, NSDictionary *  params, id  rootPList, NSString *  name, BackLinkChain  keyPath, BOOL  tentative, BOOL *  outStop  )

static

Definition at line 1254 of file OOPListSchemaVerifier.m.

{
    NSArray                 *values = nil;
    NSString                *filteredString = nil;
    NSError                 *error = nil;
    
    DebugDump(@"%@", @"* enumeration");
    
    REQUIRE_TYPE(NSString, @"string");
    
    values = [params oo_arrayForKey:@"values"];
    DebugDump(@"  - \"%@\" in %@", StringForErrorReport(value), ArrayForErrorReport(values));
    
    if (values == nil)
    {
        *outStop = YES;
        return Error(kPListErrorSchemaNoEnumerationValues, &keyPath, @"Bad schema: no options specified for oneOf type.");
    }
    
    filteredString = ApplyStringFilter(value, [params objectForKey:@"filter"], keyPath, &error);
    if (filteredString == nil)  return error;
    
    if ([values containsObject:filteredString])  return nil;
    
    return Error(kPListErrorEnumerationBadValue, &keyPath, @"Value \"%@\" not recognized, should be one of %@.", StringForErrorReport(value), ArrayForErrorReport(values));
}

References ApplyStringFilter(), ArrayForErrorReport(), DebugDump, Error(), kPListErrorEnumerationBadValue, kPListErrorSchemaNoEnumerationValues, nil, REQUIRE_TYPE, and StringForErrorReport().

Here is the call graph for this function:

Verify_Float()

static NSError * Verify_Float ( OOPListSchemaVerifier *  verifier, id  value, NSDictionary *  params, id  rootPList, NSString *  name, BackLinkChain  keyPath, BOOL  tentative, BOOL *  outStop  )

static

Definition at line 1136 of file OOPListSchemaVerifier.m.

{
    double                  numericValue;
    double                  constraint;
    
    numericValue = OODoubleFromObject(value, 0);
    
    DebugDump(@"* float: %g", numericValue);
    
    // Check basic parseability. If there's inequality here, the default value is being returned.
    if (numericValue != OODoubleFromObject(value, 1))
    {
        return ErrorTypeMismatch([NSNumber class], @"number", value, keyPath);
    }
    
    // Check constraints.
    constraint = [params oo_doubleForKey:@"minimum" defaultValue:-INFINITY];
    if (numericValue < constraint)
    {
        return  Error(kPListErrorMinimumConstraintNotMet, &keyPath, @"Number is too small (%g, minimum is %g).", numericValue, constraint);
    }
    
    constraint = [params oo_doubleForKey:@"maximum" defaultValue:INFINITY];
    if (constraint < numericValue)
    {
        return  Error(kPListErrorMaximumConstraintNotMet, &keyPath, @"Number is too large (%g, maximum is %g).", numericValue, constraint);
    }
    
    return nil;
}

References DebugDump, Error(), ErrorTypeMismatch(), kPListErrorMaximumConstraintNotMet, kPListErrorMinimumConstraintNotMet, nil, and OODoubleFromObject().

Here is the call graph for this function:

Verify_FuzzyBoolean()

static NSError * Verify_FuzzyBoolean ( OOPListSchemaVerifier *  verifier, id  value, NSDictionary *  params, id  rootPList, NSString *  name, BackLinkChain  keyPath, BOOL  tentative, BOOL *  outStop  )

static

Definition at line 1292 of file OOPListSchemaVerifier.m.

{
    DebugDump(@"* fuzzy boolean: %@", value);
    
    // Check basic parseability. If there's inequality here, the default value is being returned.
    if (OODoubleFromObject(value, 0) == OODoubleFromObject(value, 1))  return nil;
    else if (OOBooleanFromObject(value, 0) == OOBooleanFromObject(value, 1))  return nil;
    else  return ErrorTypeMismatch([NSNumber class], @"fuzzy boolean", value, keyPath);
}

References DebugDump, ErrorTypeMismatch(), nil, OOBooleanFromObject(), and OODoubleFromObject().

Here is the call graph for this function:

Verify_Integer()

static NSError * Verify_Integer ( OOPListSchemaVerifier *  verifier, id  value, NSDictionary *  params, id  rootPList, NSString *  name, BackLinkChain  keyPath, BOOL  tentative, BOOL *  outStop  )

static

Definition at line 1072 of file OOPListSchemaVerifier.m.

{
    long long               numericValue;
    long long               constraint;
    
    numericValue = OOLongLongFromObject(value, 0);
    
    DebugDump(@"* integer: %lli", numericValue);
    
    // Check basic parseability. If there's inequality here, the default value is being returned.
    if (numericValue != OOLongLongFromObject(value, 1))
    {
        return ErrorTypeMismatch([NSNumber class], @"integer", value, keyPath);
    }
    
    // Check constraints.
    constraint = [params oo_longLongForKey:@"minimum" defaultValue:LLONG_MIN];
    if (numericValue < constraint)
    {
        return  Error(kPListErrorMinimumConstraintNotMet, &keyPath, @"Number is too small (%lli, minimum is %lli).", numericValue, constraint);
    }
    
    constraint = [params oo_longLongForKey:@"maximum" defaultValue:LLONG_MAX];
    if (constraint < numericValue)
    {
        return  Error(kPListErrorMaximumConstraintNotMet, &keyPath, @"Number is too large (%lli, maximum is %lli).", numericValue, constraint);
    }
    
    return nil;
}

References DebugDump, Error(), ErrorTypeMismatch(), kPListErrorMaximumConstraintNotMet, kPListErrorMinimumConstraintNotMet, nil, and OOLongLongFromObject().

Here is the call graph for this function:

Verify_OneOf()

static NSError * Verify_OneOf ( OOPListSchemaVerifier *  verifier, id  value, NSDictionary *  params, id  rootPList, NSString *  name, BackLinkChain  keyPath, BOOL  tentative, BOOL *  outStop  )

static

Definition at line 1205 of file OOPListSchemaVerifier.m.

{
    NSArray                 *options = nil;
    BOOL                    OK = NO, stop = NO;
    id                      option = nil;
    NSError                 *error;
    NSMutableDictionary     *errors = nil;
    
    DebugDump(@"%@", @"* oneOf");
    
    options = [params oo_arrayForKey:@"options"];
    if (options == nil)
    {
        *outStop = YES;
        return Error(kPListErrorSchemaNoOneOfOptions, &keyPath, @"Bad schema: no options specified for oneOf type.");
    }
    
    errors = [[NSMutableDictionary alloc] initWithCapacity:[options count]];
    
    foreach (option, options)
    {
        if ([verifier verifyPList:rootPList
                            named:name
                      subProperty:value
                againstSchemaType:option
                           atPath:keyPath
                        tentative:YES
                            error:&error
                             stop:&stop])
        {
            DebugDump(@"%@", @"> Match.");
            OK = YES;
            break;
        }
        [errors setObject:error forKey:option];
    }
    
    if (!OK)
    {
        DebugDump(@"%@", @"! No match.");
        return ErrorWithProperty(kPListErrorOneOfNoMatch, &keyPath, kErrorsByOptionErrorKey, [errors autorelease], @"No matching type rule could be found.");
    }
    
    // Ignore stop in tentatives.
    [errors release];
    return nil;
}

References DebugDump, Error(), ErrorWithProperty(), kErrorsByOptionErrorKey, kPListErrorOneOfNoMatch, kPListErrorSchemaNoOneOfOptions, and nil.

Here is the call graph for this function:

Verify_PositiveFloat()

static NSError * Verify_PositiveFloat ( OOPListSchemaVerifier *  verifier, id  value, NSDictionary *  params, id  rootPList, NSString *  name, BackLinkChain  keyPath, BOOL  tentative, BOOL *  outStop  )

static

Definition at line 1168 of file OOPListSchemaVerifier.m.

{
    double                  numericValue;
    double                  constraint;
    
    numericValue = OODoubleFromObject(value, 0);
    
    DebugDump(@"* positive float: %g", numericValue);
    
    // Check basic parseability. If there's inequality here, the default value is being returned.
    if (numericValue != OODoubleFromObject(value, 1))
    {
        return ErrorTypeMismatch([NSNumber class], @"positive number", value, keyPath);
    }
    
    if (numericValue < 0)
    {
        return Error(kPListErrorNumberIsNegative, &keyPath, @"Expected non-negative number, found %g.", numericValue);
    }
    
    // Check constraints.
    constraint = [params oo_doubleForKey:@"minimum" defaultValue:0];
    if (numericValue < constraint)
    {
        return  Error(kPListErrorMinimumConstraintNotMet, &keyPath, @"Number is too small (%g, minimum is %g).", numericValue, constraint);
    }
    
    constraint = [params oo_doubleForKey:@"maximum" defaultValue:INFINITY];
    if (constraint < numericValue)
    {
        return  Error(kPListErrorMaximumConstraintNotMet, &keyPath, @"Number is too large (%g, maximum is %g).", numericValue, constraint);
    }
    
    return nil;
}

References DebugDump, Error(), ErrorTypeMismatch(), kPListErrorMaximumConstraintNotMet, kPListErrorMinimumConstraintNotMet, kPListErrorNumberIsNegative, nil, and OODoubleFromObject().

Here is the call graph for this function:

Verify_PositiveInteger()

static NSError * Verify_PositiveInteger ( OOPListSchemaVerifier *  verifier, id  value, NSDictionary *  params, id  rootPList, NSString *  name, BackLinkChain  keyPath, BOOL  tentative, BOOL *  outStop  )

static

Definition at line 1104 of file OOPListSchemaVerifier.m.

{
    unsigned long long      numericValue;
    unsigned long long      constraint;
    
    numericValue = OOUnsignedLongLongFromObject(value, 0);
    
    DebugDump(@"* positive integer: %llu", numericValue);
    
    // Check basic parseability. If there's inequality here, the default value is being returned.
    if (numericValue != OOUnsignedLongLongFromObject(value, 1))
    {
        return ErrorTypeMismatch([NSNumber class], @"positive integer", value, keyPath);
    }
    
    // Check constraints.
    constraint = [params oo_unsignedLongLongForKey:@"minimum" defaultValue:0];
    if (numericValue < constraint)
    {
        return  Error(kPListErrorMinimumConstraintNotMet, &keyPath, @"Number is too small (%llu, minimum is %llu).", numericValue, constraint);
    }
    
    constraint = [params oo_unsignedLongLongForKey:@"maximum" defaultValue:ULLONG_MAX];
    if (constraint < numericValue)
    {
        return  Error(kPListErrorMaximumConstraintNotMet, &keyPath, @"Number is too large (%llu, maximum is %llu).", numericValue, constraint);
    }
    
    return nil;
}

References DebugDump, Error(), ErrorTypeMismatch(), kPListErrorMaximumConstraintNotMet, kPListErrorMinimumConstraintNotMet, nil, and OOUnsignedLongLongFromObject().

Here is the call graph for this function:

VERIFY_PROTO() [1/14]

VERIFY_PROTO

(

Array

)

VERIFY_PROTO() [2/14]

VERIFY_PROTO

(

Boolean

)

VERIFY_PROTO() [3/14]

VERIFY_PROTO

(

DelegatedType

)

VERIFY_PROTO() [4/14]

VERIFY_PROTO

(

Dictionary

)

VERIFY_PROTO() [5/14]

VERIFY_PROTO

(

Enumeration

)

VERIFY_PROTO() [6/14]

VERIFY_PROTO

(

Float

)

VERIFY_PROTO() [7/14]

VERIFY_PROTO

(

FuzzyBoolean

)

VERIFY_PROTO() [8/14]

VERIFY_PROTO

(

Integer

)

VERIFY_PROTO() [9/14]

VERIFY_PROTO

(

OneOf

)

VERIFY_PROTO() [10/14]

VERIFY_PROTO

(

PositiveFloat

)

VERIFY_PROTO() [11/14]

VERIFY_PROTO

(

PositiveInteger

)

VERIFY_PROTO() [12/14]

VERIFY_PROTO

(

Quaternion

)

VERIFY_PROTO() [13/14]

VERIFY_PROTO

(

String

)

VERIFY_PROTO() [14/14]

VERIFY_PROTO

(

Vector

)

Verify_Quaternion()

static NSError * Verify_Quaternion ( OOPListSchemaVerifier *  verifier, id  value, NSDictionary *  params, id  rootPList, NSString *  name, BackLinkChain  keyPath, BOOL  tentative, BOOL *  outStop  )

static

Definition at line 1313 of file OOPListSchemaVerifier.m.

{
    DebugDump(@"* quaternion: %@", value);
    
    // Check basic parseability. If there's inequality here, the default value is being returned.
    if (quaternion_equal(OOQuaternionFromObject(value, kZeroQuaternion), OOQuaternionFromObject(value, kIdentityQuaternion)))  return nil;
    else  return ErrorTypeMismatch(Nil, @"quaternion", value, keyPath);
}

References DebugDump, ErrorTypeMismatch(), kIdentityQuaternion, kZeroQuaternion, nil, and OOQuaternionFromObject().

Here is the call graph for this function:

Verify_String()

static NSError * Verify_String ( OOPListSchemaVerifier *  verifier, id  value, NSDictionary *  params, id  rootPList, NSString *  name, BackLinkChain  keyPath, BOOL  tentative, BOOL *  outStop  )

static

Definition at line 837 of file OOPListSchemaVerifier.m.

{
    NSString            *filteredString = nil;
    id                  testValue = nil;
    NSUInteger          length;
    NSUInteger          lengthConstraint;
    NSError             *error = nil;
    
    REQUIRE_TYPE(NSString, @"string");
    
    DebugDump(@"* string: \"%@\"", StringForErrorReport(value));
    
    // Apply filters
    filteredString = ApplyStringFilter(value, [params objectForKey:@"filter"], keyPath, &error);
    if (filteredString == nil)  return error;
    
    // Apply substring requirements
    testValue = [params objectForKey:@"requiredPrefix"];
    if (testValue != nil)
    {
        if (!ApplyStringTest(filteredString, testValue, @selector(hasPrefix:), @"prefix", keyPath, &error))
        {
            if (error == nil)  error = ErrorWithProperty(kPListErrorStringPrefixMissing, &keyPath, kMissingSubStringErrorKey, testValue, @"String \"%@\" does not have required %@ %@.", StringForErrorReport(value), @"prefix", StringOrArrayForErrorReport(testValue, @"in "));
            return error;
        }
    }
    
    testValue = [params objectForKey:@"requiredSuffix"];
    if (testValue != nil)
    {
        if (!ApplyStringTest(filteredString, testValue, @selector(hasSuffix:), @"suffix", keyPath, &error))
        {
            if (error == nil)  error = ErrorWithProperty(kPListErrorStringSuffixMissing, &keyPath, kMissingSubStringErrorKey, testValue, @"String \"%@\" does not have required %@ %@.", StringForErrorReport(value), @"suffix", StringOrArrayForErrorReport(testValue, @"in "));
            return error;
        }
    }
    
    testValue = [params objectForKey:@"requiredSubString"];
    if (testValue != nil)
    {
        if (!ApplyStringTest(filteredString, testValue, @selector(ooPListVerifierHasSubString:), @"substring", keyPath, &error))
        {
            if (error == nil)  error = ErrorWithProperty(kPListErrorStringSubstringMissing, &keyPath, kMissingSubStringErrorKey, testValue, @"String \"%@\" does not have required %@ %@.", StringForErrorReport(value), @"substring", StringOrArrayForErrorReport(testValue, @"in "));
            return error;
        }
    }
    
    // Apply length bounds.
    length = [filteredString length];
    lengthConstraint = [params oo_unsignedIntegerForKey:@"minLength"];
    if (length < lengthConstraint)
    {
        return  Error(kPListErrorMinimumConstraintNotMet, &keyPath, @"String \"%@\" is too short (%u bytes, minimum is %u).", StringForErrorReport(filteredString), length, lengthConstraint);
    }
    
    lengthConstraint = [params oo_unsignedIntegerForKey:@"maxLength" defaultValue:NSUIntegerMax];
    if (lengthConstraint < length)
    {
        return  Error(kPListErrorMaximumConstraintNotMet, &keyPath, @"String \"%@\" is too long (%u bytes, maximum is %u).", StringForErrorReport(filteredString), length, lengthConstraint);
    }
    
    // All tests passed.
    return nil;
}

References ApplyStringFilter(), ApplyStringTest(), DebugDump, Error(), ErrorWithProperty(), kMissingSubStringErrorKey, kPListErrorMaximumConstraintNotMet, kPListErrorMinimumConstraintNotMet, kPListErrorStringPrefixMissing, kPListErrorStringSubstringMissing, kPListErrorStringSuffixMissing, nil, REQUIRE_TYPE, StringForErrorReport(), and StringOrArrayForErrorReport().

Here is the call graph for this function:

Verify_Vector()

static NSError * Verify_Vector ( OOPListSchemaVerifier *  verifier, id  value, NSDictionary *  params, id  rootPList, NSString *  name, BackLinkChain  keyPath, BOOL  tentative, BOOL *  outStop  )

static

Definition at line 1303 of file OOPListSchemaVerifier.m.

{
    DebugDump(@"* vector: %@", value);
    
    // Check basic parseability. If there's inequality here, the default value is being returned.
    if (vector_equal(OOVectorFromObject(value, kZeroVector), OOVectorFromObject(value, kBasisXVector)))  return nil;
    else  return ErrorTypeMismatch(Nil, @"vector", value, keyPath);
}

References DebugDump, ErrorTypeMismatch(), kBasisXVector, kZeroVector, nil, and OOVectorFromObject().

Here is the call graph for this function:

Variable Documentation

kErrorsByOptionErrorKey

NSString* const kErrorsByOptionErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier errors by option"

Definition at line 85 of file OOPListSchemaVerifier.m.

Referenced by Verify_OneOf().

kExpectedClassErrorKey

NSString* const kExpectedClassErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier expected class"

Definition at line 79 of file OOPListSchemaVerifier.m.

kExpectedClassNameErrorKey

NSString* const kExpectedClassNameErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier expected class name"

Definition at line 80 of file OOPListSchemaVerifier.m.

kMissingRequiredKeysErrorKey

NSString* const kMissingRequiredKeysErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier missing required keys"

Definition at line 82 of file OOPListSchemaVerifier.m.

Referenced by Verify_Dictionary().

kMissingSubStringErrorKey

NSString* const kMissingSubStringErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier missing substring"

Definition at line 83 of file OOPListSchemaVerifier.m.

Referenced by Verify_String().

kOOPListSchemaVerifierErrorDomain

NSString* const kOOPListSchemaVerifierErrorDomain = @"org.aegidian.oolite.OOPListSchemaVerifier.ErrorDomain"

Definition at line 74 of file OOPListSchemaVerifier.m.

kPListKeyPathErrorKey

NSString* const kPListKeyPathErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier plist key path"

Definition at line 76 of file OOPListSchemaVerifier.m.

kSchemaKeyPathErrorKey

NSString* const kSchemaKeyPathErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier schema key path"

Definition at line 77 of file OOPListSchemaVerifier.m.

kUndefinedMacroErrorKey

NSString* const kUndefinedMacroErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier undefined macro"

Definition at line 88 of file OOPListSchemaVerifier.m.

kUnknownKeyErrorKey

NSString* const kUnknownKeyErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier unknown key"

Definition at line 81 of file OOPListSchemaVerifier.m.

Referenced by Verify_Dictionary().

kUnknownTypeErrorKey

NSString* const kUnknownTypeErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier unknown type"

Definition at line 87 of file OOPListSchemaVerifier.m.

Referenced by StringToSchemaType().

kUnnownFilterErrorKey

NSString* const kUnnownFilterErrorKey = @"org.aegidian.oolite.OOPListSchemaVerifier unknown filter"

Definition at line 84 of file OOPListSchemaVerifier.m.

Referenced by ApplyStringFilter().

sDebugDump

BOOL sDebugDump = NO

static

Definition at line 58 of file OOPListSchemaVerifier.m.