public void Initialize(ContextBase context, SchemaScope parent, int initialDepth, ScopeType type) { base.Initialize(context, parent, initialDepth, type); ParentSchemaScope = parent; ConditionalContext = ConditionalContext.Create(context); }
public void ValidateCurrentToken(JsonToken token, object?value, int depth) { if (depth == 0) { // Handle validating multiple content RemoveCompletedScopes(); } if (_scopes.Count == 0) { if (Schema == null) { throw new JSchemaException("No schema has been set for the validator."); } if (!_hasValidatedLicense) { LicenseHelpers.IncrementAndCheckValidationCount(); _hasValidatedLicense = true; } SchemaScope.CreateTokenScope(token, Schema, _context, null, depth); } if (TokenWriter != null) { // JTokenReader can return JsonToken.String with a null value which WriteToken doesn't like. // Hacky - change token to JsonToken.Null. Can be removed when fixed Newtonsoft.Json is public. JsonToken fixedToken = (token == JsonToken.String && value == null) ? JsonToken.Null : token; TokenWriter.WriteToken(fixedToken, value); } for (int i = _scopes.Count - 1; i >= 0; i--) { Scope scope = _scopes[i]; if (scope.Complete != CompleteState.Completed) { scope.EvaluateToken(token, value, depth); } else { _scopes.RemoveAt(i); _scopesCache.Add(scope); } } if (TokenWriter != null && (TokenWriter.WriteState == WriteState.Start || TokenWriter.WriteState == WriteState.Closed)) { TokenWriter = null; } }
internal static void EnsureValid(SchemaScope scope, JSchema schema, object value) { if (schema.Reference != null) { throw new JSchemaException("Schema has unresolved reference '{0}'. All references must be resolved before a schema can be validated.".FormatWith(CultureInfo.InvariantCulture, schema.Reference.OriginalString)); } if (schema.Valid != null && !schema.Valid.Value) { scope.RaiseError($"Schema always fails validation.", ErrorType.Valid, schema, value, null); } }
public virtual void Initialize(ContextBase context, SchemaScope parent, int initialDepth, ScopeType type) { Context = context; Parent = parent; InitialDepth = initialDepth; Type = type; Complete = false; #if DEBUG Interlocked.Increment(ref LastDebugId); DebugId = LastDebugId; #endif }
protected SchemaScope GetSchemaScopeBySchema(JSchema schema) { for (int i = 0; i < ChildScopes.Count; i++) { SchemaScope schemaScope = ChildScopes[i]; if (schemaScope.Schema == schema) { return(schemaScope); } } return(null); }
protected bool GetChildrenAllValid() { for (int i = 0; i < ChildScopes.Count; i++) { SchemaScope schemaScope = ChildScopes[i]; if (!schemaScope.IsValid) { return(false); } } return(true); }
public void InitializeScopes(JsonToken token) { if (!Schema._dependencies.IsNullOrEmpty()) { foreach (KeyValuePair <string, object> dependency in Schema._dependencies.GetInnerDictionary()) { if (dependency.Value is JSchema dependencySchema) { SchemaScope scope = CreateTokenScope(token, dependencySchema, ConditionalContext.Create(Context), null, InitialDepth); _dependencyScopes.Add(dependency.Key, scope); } } } }
protected IEnumerable <SchemaScope> GetChildren() { foreach (Scope scope in Context.Scopes) { SchemaScope schemaScope = scope as SchemaScope; if (schemaScope != null) { if (schemaScope.Parent == this) { yield return(schemaScope); } } } }
public void Initialize(ContextBase context, SchemaScope parent, int initialDepth, JSchema schema) { Initialize(context, parent, initialDepth, ScopeType.Object); InitializeSchema(schema); _propertyCount = 0; _currentPropertyName = null; if (!schema._required.IsNullOrEmpty()) { if (_requiredProperties != null) { _requiredProperties.Clear(); } else { _requiredProperties = new List <string>(schema._required.Count); } foreach (string required in schema._required) { _requiredProperties.Add(required); } } if (!schema._dependencies.IsNullOrEmpty()) { if (_readProperties != null) { _readProperties.Clear(); } else { _readProperties = new List <string>(); } if (schema._dependencies.HasSchemas) { if (_dependencyScopes != null) { _dependencyScopes.Clear(); } else { _dependencyScopes = new Dictionary <string, SchemaScope>(StringComparer.Ordinal); } } } }
public void InitializeScopes(JsonToken token) { if (_dependencyScopes != null) { foreach (KeyValuePair <string, object> dependency in Schema._dependencies) { JSchema dependencySchema = dependency.Value as JSchema; if (dependencySchema != null) { SchemaScope scope = CreateTokenScope(token, dependencySchema, ConditionalContext.Create(Context), null, InitialDepth); _dependencyScopes.Add(dependency.Key, scope); } } } }
public void InitializeScopes(JsonToken token, List <JSchema> schemas) { foreach (JSchema schema in schemas) { // check to see whether a scope with the same schema exists SchemaScope childScope = GetExistingSchemaScope(schema); if (childScope == null) { childScope = SchemaScope.CreateTokenScope(token, schema, ConditionalContext, null, InitialDepth); } ChildScopes.Add(childScope); } }
protected bool GetChildrenAllValid(JsonToken token, object value, int depth) { for (int i = 0; i < ChildScopes.Count; i++) { SchemaScope schemaScope = ChildScopes[i]; AssertScopeComplete(schemaScope, token, value, depth); if (!schemaScope.IsValid) { return(false); } } return(true); }
protected SchemaScope GetSchemaScopeBySchema(JSchema schema, JsonToken token, object value, int depth) { for (int i = 0; i < ChildScopes.Count; i++) { SchemaScope schemaScope = ChildScopes[i]; if (schemaScope.Schema == schema) { AssertScopeComplete(schemaScope, token, value, depth); return(schemaScope); } } return(null); }
protected int GetChildrenValidCount() { int count = 0; for (int i = 0; i < ChildScopes.Count; i++) { SchemaScope schemaScope = ChildScopes[i]; if (schemaScope.IsValid) { count++; } } return(count); }
private void AssertScopeComplete(SchemaScope schemaScope, JsonToken token, object value, int depth) { // the schema scope that the conditional scope depends on may not be complete because it has be re-ordered // schema scope will be at the same depth at the conditional so evaluate it immediately if (!schemaScope.Complete) { schemaScope.EvaluateToken(token, value, depth); #if DEBUG if (!schemaScope.Complete) { throw new Exception("Schema scope {0} is not complete.".FormatWith(CultureInfo.InvariantCulture, schemaScope.DebugId)); } #endif } }
private static bool DependentSchemaAlreadyCreated(SchemaScope scope, string dependencyKey) { if (scope.ConditionalChildren != null) { for (int i = 0; i < scope.ConditionalChildren.Count; i++) { if (scope.ConditionalChildren[i] is DependentSchemaScope dependentSchemaScope && dependentSchemaScope.PropertyName == dependencyKey) { return(true); } } } return(false); }
public void ValidateCurrentToken(JsonToken token, object value, int depth) { if (depth == 0) { // Handle validating multiple content RemoveCompletedScopes(); } if (_scopes.Count == 0) { if (Schema == null) { throw new JSchemaException("No schema has been set for the validator."); } if (!_hasValidatedLicense) { LicenseHelpers.IncrementAndCheckValidationCount(); _hasValidatedLicense = true; } SchemaScope.CreateTokenScope(token, Schema, _context, null, depth); } TokenWriter?.WriteToken(token, value); for (int i = _scopes.Count - 1; i >= 0; i--) { Scope scope = _scopes[i]; if (!scope.Complete) { scope.EvaluateToken(token, value, depth); } else { _scopes.RemoveAt(i); _scopesCache.Add(scope); } } if (TokenWriter != null && TokenWriter.Top == 0) { TokenWriter = null; } }
protected int GetChildrenValidCount(JsonToken token, object value, int depth) { int count = 0; for (int i = 0; i < ChildScopes.Count; i++) { SchemaScope schemaScope = ChildScopes[i]; AssertScopeComplete(schemaScope, token, value, depth); if (schemaScope.IsValid) { count++; } } return(count); }
protected SchemaScope CreateScopesAndEvaluateToken(JsonToken token, object?value, int depth, JSchema schema, SchemaScope?parent, ContextBase context) { int startCount = Context.Scopes.Count; SchemaScope createdScope = CreateTokenScope(token, schema, context, parent, depth); int start = Context.Scopes.Count - 1; int end = startCount; for (int i = start; i >= end; i--) { Scope newScope = Context.Scopes[i]; newScope.EvaluateToken(token, value, depth); } return(createdScope); }
public void InitializeScopes(JsonToken token, List <JSchema> schemas, int scopeIndex) { foreach (JSchema schema in schemas) { // cache this for performance int scopeCurrentIndex = scopeIndex; // check to see whether a scope with the same schema exists SchemaScope childScope = GetExistingSchemaScope(schema, ref scopeCurrentIndex); if (childScope == null) { childScope = SchemaScope.CreateTokenScope(token, schema, ConditionalContext, null, InitialDepth); } ChildScopes.Add(childScope); } }
public void Initialize(ContextBase context, SchemaScope parent, int initialDepth, JSchema schema) { Initialize(context, parent, initialDepth, ScopeType.Array); InitializeSchema(schema); _index = -1; _matchCount = 0; if (schema.Contains != null) { if (_containsContexts != null) { _containsContexts.Clear(); } else { _containsContexts = new List <ConditionalContext>(); } } if (schema.UniqueItems) { if (_uniqueArrayItems != null) { _uniqueArrayItems.Clear(); } else { _uniqueArrayItems = new List <JToken>(); } } if (ShouldValidateUnevaluated()) { if (_unevaluatedScopes != null) { _unevaluatedScopes.Clear(); } else { _unevaluatedScopes = new Dictionary <int, UnevaluatedContext>(); } } }
internal static bool ValidateString(SchemaScope scope, JSchema schema, string value) { if (!TestType(scope, schema, JSchemaType.String, value)) { return(false); } if (schema.MaximumLength != null || schema.MinimumLength != null) { // want to test the character length and ignore unicode surrogates StringInfo stringInfo = new StringInfo(value); int textLength = stringInfo.LengthInTextElements; if (schema.MaximumLength != null && textLength > schema.MaximumLength) { scope.RaiseError($"String '{value}' exceeds maximum length of {schema.MaximumLength}.", ErrorType.MaximumLength, schema, value, null); } if (schema.MinimumLength != null && textLength < schema.MinimumLength) { scope.RaiseError($"String '{value}' is less than minimum length of {schema.MinimumLength}.", ErrorType.MinimumLength, schema, value, null); } } if (schema.Pattern != null) { if (schema.TryGetPatternRegex( #if !(NET35 || NET40) scope.Context.Validator.RegexMatchTimeout, #endif out Regex regex, out string errorMessage)) { if (!RegexHelpers.IsMatch(regex, schema.Pattern, value)) { scope.RaiseError($"String '{value}' does not match regex pattern '{schema.Pattern}'.", ErrorType.Pattern, schema, value, null); } } else { scope.RaiseError($"Could not validate string with regex pattern '{schema.Pattern}'. There was an error parsing the regex: {errorMessage}", ErrorType.Pattern, schema, value, null); } }
public void InitializeScope(JsonToken token, int scopeIndex, JSchema schema, ContextBase context) { // cache this for performance int scopeCurrentIndex = scopeIndex; // check to see whether a scope with the same schema exists SchemaScope?childScope = GetExistingSchemaScope(schema, ref scopeCurrentIndex); if (childScope == null) { childScope = SchemaScope.CreateTokenScope(token, schema, context, null, InitialDepth); } else { if (childScope.Context != context) { // The schema scope needs to be part of a different conditional contexts. // We need to create a composite so that errors are raised to both. CompositeContext?compositeContext = childScope.Context as CompositeContext; if (compositeContext == null) { compositeContext = new CompositeContext(context.Validator); compositeContext.Contexts.Add(childScope.Context); compositeContext.Contexts.Add(context); childScope.Context = compositeContext; } else { if (!compositeContext.Contexts.Contains(context)) { compositeContext.Contexts.Add(context); } } } } #if DEBUG childScope.ConditionalParents.Add(this); #endif ChildScopes.Add(childScope); }
public void Initialize(ContextBase context, SchemaScope parent, int initialDepth, JSchema schema) { Initialize(context, parent, initialDepth, ScopeType.Array); InitializeSchema(schema); _index = -1; if (schema.UniqueItems) { if (_uniqueArrayItems != null) { _uniqueArrayItems.Clear(); } else { _uniqueArrayItems = new List <JToken>(); } } }
protected override bool EvaluateTokenCore(JsonToken token, object value, int depth) { SchemaScope ifScope = GetSchemaScopeBySchema(If, token, value, depth); if (ifScope.IsValid) { ConditionalContext.TrackEvaluatedSchema(ifScope.Schema); if (Then != null) { SchemaScope thenScope = GetSchemaScopeBySchema(Then, token, value, depth); if (!thenScope.IsValid) { ConditionalContext context = (ConditionalContext)thenScope.Context; RaiseError($"JSON does not match schema from 'then'.", ErrorType.Then, Then, null, context.Errors); } else { ConditionalContext.TrackEvaluatedSchema(thenScope.Schema); } } } else { if (Else != null) { SchemaScope elseScope = GetSchemaScopeBySchema(Else, token, value, depth); if (!elseScope.IsValid) { ConditionalContext context = (ConditionalContext)elseScope.Context; RaiseError($"JSON does not match schema from 'else'.", ErrorType.Else, Else, null, context.Errors); } else { ConditionalContext.TrackEvaluatedSchema(elseScope.Schema); } } } return(true); }
protected bool TryGetChildrenValidCount(JsonToken token, object?value, int depth, out int validCount) { validCount = 0; for (int i = 0; i < ChildScopes.Count; i++) { SchemaScope schemaScope = ChildScopes[i]; if (!AssertScopeComplete(schemaScope, token, value, depth)) { return(false); } if (schemaScope.IsValid) { validCount++; } } return(true); }
private void InitializeScope(JsonToken token, int scopeIndex, JSchema schema, ConditionalContext context) { // cache this for performance int scopeCurrentIndex = scopeIndex; // check to see whether a scope with the same schema exists SchemaScope childScope = GetExistingSchemaScope(schema, ref scopeCurrentIndex); if (childScope == null) { childScope = SchemaScope.CreateTokenScope(token, schema, context, null, InitialDepth); } #if DEBUG childScope.ConditionalParents.Add(this); #endif ChildScopes.Add(childScope); }
protected bool TryGetChildrenAllValid(JsonToken token, object?value, int depth, out bool allValid) { for (int i = 0; i < ChildScopes.Count; i++) { SchemaScope schemaScope = ChildScopes[i]; if (!AssertScopeComplete(schemaScope, token, value, depth)) { allValid = default; return(false); } if (!schemaScope.IsValid) { allValid = false; return(true); } } allValid = true; return(true); }
private void ValidateDependantSchema(string readProperty) { SchemaScope dependencyScope = _dependencyScopes[readProperty]; if (dependencyScope.Context.HasErrors) { IFormattable message = $"Dependencies for property '{readProperty}' failed."; RaiseError(message, ErrorType.Dependencies, Schema, readProperty, dependencyScope.GetValidationErrors()); } else { if (!_unevaluatedScopes.IsNullOrEmpty()) { foreach (KeyValuePair <string, UnevaluatedContext> item in _unevaluatedScopes) { if (!item.Value.Evaluated && IsPropertyDefined(dependencyScope.Schema, item.Key)) { item.Value.Evaluated = true; } } } } }
public void ValidateCurrentToken(JsonToken token, object value, int depth) { if (_scopes.Count == 0) { if (Schema == null) { throw new JsonException("No schema has been set for the validator."); } LicenseHelpers.IncrementAndCheckValidationCount(); SchemaScope.CreateTokenScope(token, Schema, _context, null, depth); } if (TokenWriter != null) { TokenWriter.WriteToken(token, value); } for (int i = _scopes.Count - 1; i >= 0; i--) { Scope scope = _scopes[i]; if (!scope.Complete) { scope.EvaluateToken(token, value, depth); } else { _scopes.RemoveAt(i); } } if (TokenWriter != null && TokenWriter.Top == 0) { TokenWriter = null; } }
private SchemaScope GetExistingSchemaScope(JSchema schema) { for (int i = Context.Scopes.Count - 1; i >= 0; i--) { SchemaScope scope = Context.Scopes[i] as SchemaScope; if (scope != null) { if (scope.InitialDepth == InitialDepth) { if (!scope.Complete && scope.Schema == schema) { return(scope); } } else if (scope.InitialDepth < InitialDepth) { break; } } } return(null); }
public OneOfScope(SchemaScope parent, ContextBase context, int depth) : base(context, parent, depth) { }
protected ConditionalScope(ContextBase context, SchemaScope parent, int initialDepth) : base(context, parent, initialDepth) { ParentSchemaScope = parent; ConditionalContext = ConditionalContext.Create(context); }
protected static bool IsValidPredicateInternal(SchemaScope s) { return s.IsValid; }