示例#1
0
        internal void WriteToken(JsonReader reader, bool writeChildren, bool writeDateConstructorAsDate)
        {
            int initialDepth;

            if (reader.TokenType == JsonToken.None)
            {
                initialDepth = -1;
            }
            else if (!JsonWriter.IsStartToken(reader.TokenType))
            {
                initialDepth = reader.Depth + 1;
            }
            else
            {
                initialDepth = reader.Depth;
            }
            this.WriteToken(reader, initialDepth, writeChildren, writeDateConstructorAsDate);
        }
示例#2
0
        private void ValidateCurrentToken()
        {
            // first time validate has been called. build model
            if (_model == null)
            {
                JsonSchemaModelBuilder builder = new JsonSchemaModelBuilder();
                _model = builder.Build(_schema);

                if (!JsonWriter.IsStartToken(_reader.TokenType))
                {
                    Push(new SchemaScope(JTokenType.None, CurrentMemberSchemas));
                }
            }

            switch (_reader.TokenType)
            {
            case JsonToken.StartObject:
                ProcessValue();
                IList <JsonSchemaModel> objectSchemas = CurrentMemberSchemas.Where(ValidateObject).ToList();
                Push(new SchemaScope(JTokenType.Object, objectSchemas));
                WriteToken(CurrentSchemas);
                break;

            case JsonToken.StartArray:
                ProcessValue();
                IList <JsonSchemaModel> arraySchemas = CurrentMemberSchemas.Where(ValidateArray).ToList();
                Push(new SchemaScope(JTokenType.Array, arraySchemas));
                WriteToken(CurrentSchemas);
                break;

            case JsonToken.StartConstructor:
                ProcessValue();
                Push(new SchemaScope(JTokenType.Constructor, null));
                WriteToken(CurrentSchemas);
                break;

            case JsonToken.PropertyName:
                WriteToken(CurrentSchemas);
                foreach (JsonSchemaModel schema in CurrentSchemas)
                {
                    ValidatePropertyName(schema);
                }
                break;

            case JsonToken.Raw:
                ProcessValue();
                break;

            case JsonToken.Integer:
                ProcessValue();
                WriteToken(CurrentMemberSchemas);
                foreach (JsonSchemaModel schema in CurrentMemberSchemas)
                {
                    ValidateInteger(schema);
                }
                break;

            case JsonToken.Float:
                ProcessValue();
                WriteToken(CurrentMemberSchemas);
                foreach (JsonSchemaModel schema in CurrentMemberSchemas)
                {
                    ValidateFloat(schema);
                }
                break;

            case JsonToken.String:
                ProcessValue();
                WriteToken(CurrentMemberSchemas);
                foreach (JsonSchemaModel schema in CurrentMemberSchemas)
                {
                    ValidateString(schema);
                }
                break;

            case JsonToken.Boolean:
                ProcessValue();
                WriteToken(CurrentMemberSchemas);
                foreach (JsonSchemaModel schema in CurrentMemberSchemas)
                {
                    ValidateBoolean(schema);
                }
                break;

            case JsonToken.Null:
                ProcessValue();
                WriteToken(CurrentMemberSchemas);
                foreach (JsonSchemaModel schema in CurrentMemberSchemas)
                {
                    ValidateNull(schema);
                }
                break;

            case JsonToken.EndObject:
                WriteToken(CurrentSchemas);
                foreach (JsonSchemaModel schema in CurrentSchemas)
                {
                    ValidateEndObject(schema);
                }
                Pop();
                break;

            case JsonToken.EndArray:
                WriteToken(CurrentSchemas);
                foreach (JsonSchemaModel schema in CurrentSchemas)
                {
                    ValidateEndArray(schema);
                }
                Pop();
                break;

            case JsonToken.EndConstructor:
                WriteToken(CurrentSchemas);
                Pop();
                break;

            case JsonToken.Undefined:
            case JsonToken.Date:
            case JsonToken.Bytes:
                // these have no equivalent in JSON schema
                WriteToken(CurrentMemberSchemas);
                break;

            case JsonToken.None:
                // no content, do nothing
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
示例#3
0
        private void ValidateCurrentToken()
        {
            if (this._model == null)
            {
                JsonSchemaModelBuilder jsonSchemaModelBuilder = new JsonSchemaModelBuilder();
                this._model = jsonSchemaModelBuilder.Build(this._schema);
                if (!JsonWriter.IsStartToken(this._reader.TokenType))
                {
                    this.Push(new JsonValidatingReader.SchemaScope(JTokenType.None, this.CurrentMemberSchemas));
                }
            }
            switch (this._reader.TokenType)
            {
            case JsonToken.None:
                return;

            case JsonToken.StartObject:
            {
                this.ProcessValue();
                IList <JsonSchemaModel> schemas = this.CurrentMemberSchemas.Where(new Func <JsonSchemaModel, bool>(this.ValidateObject)).ToList <JsonSchemaModel>();
                this.Push(new JsonValidatingReader.SchemaScope(JTokenType.Object, schemas));
                this.WriteToken(this.CurrentSchemas);
                return;
            }

            case JsonToken.StartArray:
            {
                this.ProcessValue();
                IList <JsonSchemaModel> schemas2 = this.CurrentMemberSchemas.Where(new Func <JsonSchemaModel, bool>(this.ValidateArray)).ToList <JsonSchemaModel>();
                this.Push(new JsonValidatingReader.SchemaScope(JTokenType.Array, schemas2));
                this.WriteToken(this.CurrentSchemas);
                return;
            }

            case JsonToken.StartConstructor:
                this.ProcessValue();
                this.Push(new JsonValidatingReader.SchemaScope(JTokenType.Constructor, null));
                this.WriteToken(this.CurrentSchemas);
                return;

            case JsonToken.PropertyName:
                this.WriteToken(this.CurrentSchemas);
                using (IEnumerator <JsonSchemaModel> enumerator = this.CurrentSchemas.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        JsonSchemaModel current = enumerator.Current;
                        this.ValidatePropertyName(current);
                    }
                    return;
                }
                break;

            case JsonToken.Comment:
                goto IL_3F9;

            case JsonToken.Raw:
                break;

            case JsonToken.Integer:
                this.ProcessValue();
                this.WriteToken(this.CurrentMemberSchemas);
                using (IEnumerator <JsonSchemaModel> enumerator2 = this.CurrentMemberSchemas.GetEnumerator())
                {
                    while (enumerator2.MoveNext())
                    {
                        JsonSchemaModel current2 = enumerator2.Current;
                        this.ValidateInteger(current2);
                    }
                    return;
                }
                goto IL_1E8;

            case JsonToken.Float:
                goto IL_1E8;

            case JsonToken.String:
                goto IL_23A;

            case JsonToken.Boolean:
                goto IL_28C;

            case JsonToken.Null:
                goto IL_2DE;

            case JsonToken.Undefined:
            case JsonToken.Date:
            case JsonToken.Bytes:
                this.WriteToken(this.CurrentMemberSchemas);
                return;

            case JsonToken.EndObject:
                goto IL_330;

            case JsonToken.EndArray:
                this.WriteToken(this.CurrentSchemas);
                foreach (JsonSchemaModel current3 in this.CurrentSchemas)
                {
                    this.ValidateEndArray(current3);
                }
                this.Pop();
                return;

            case JsonToken.EndConstructor:
                this.WriteToken(this.CurrentSchemas);
                this.Pop();
                return;

            default:
                goto IL_3F9;
            }
            this.ProcessValue();
            return;

IL_1E8:
            this.ProcessValue();
            this.WriteToken(this.CurrentMemberSchemas);
            using (IEnumerator <JsonSchemaModel> enumerator4 = this.CurrentMemberSchemas.GetEnumerator())
            {
                while (enumerator4.MoveNext())
                {
                    JsonSchemaModel current4 = enumerator4.Current;
                    this.ValidateFloat(current4);
                }
                return;
            }
IL_23A:
            this.ProcessValue();
            this.WriteToken(this.CurrentMemberSchemas);
            using (IEnumerator <JsonSchemaModel> enumerator5 = this.CurrentMemberSchemas.GetEnumerator())
            {
                while (enumerator5.MoveNext())
                {
                    JsonSchemaModel current5 = enumerator5.Current;
                    this.ValidateString(current5);
                }
                return;
            }
IL_28C:
            this.ProcessValue();
            this.WriteToken(this.CurrentMemberSchemas);
            using (IEnumerator <JsonSchemaModel> enumerator6 = this.CurrentMemberSchemas.GetEnumerator())
            {
                while (enumerator6.MoveNext())
                {
                    JsonSchemaModel current6 = enumerator6.Current;
                    this.ValidateBoolean(current6);
                }
                return;
            }
IL_2DE:
            this.ProcessValue();
            this.WriteToken(this.CurrentMemberSchemas);
            using (IEnumerator <JsonSchemaModel> enumerator7 = this.CurrentMemberSchemas.GetEnumerator())
            {
                while (enumerator7.MoveNext())
                {
                    JsonSchemaModel current7 = enumerator7.Current;
                    this.ValidateNull(current7);
                }
                return;
            }
IL_330:
            this.WriteToken(this.CurrentSchemas);
            foreach (JsonSchemaModel current8 in this.CurrentSchemas)
            {
                this.ValidateEndObject(current8);
            }
            this.Pop();
            return;

IL_3F9:
            throw new ArgumentOutOfRangeException();
        }