PNG  IHDR pHYs   OiCCPPhotoshop ICC profilexڝSgTS=BKKoR RB&*! J!QEEȠQ, !{kּ> H3Q5 B.@ $pd!s#~<<+"x M0B\t8K@zB@F&S`cbP-`'{[! eDh;VEX0fK9-0IWfH  0Q){`##xFW<+*x<$9E[-qWW.(I+6aa@.y24x6_-"bbϫp@t~,/;m%h^ uf@Wp~<5j>{-]cK'Xto(hw?G%fIq^D$.Tʳ?D*A, `6B$BB dr`)B(Ͱ*`/@4Qhp.U=pa( Aa!ڈbX#!H$ ɈQ"K5H1RT UH=r9\F;2G1Q= C7F dt1r=6Ыhڏ>C03l0.B8, c˱" VcϱwE 6wB aAHXLXNH $4 7 Q'"K&b21XH,#/{C7$C2'ITFnR#,4H#dk9, +ȅ3![ b@qS(RjJ4e2AURݨT5ZBRQ4u9̓IKhhitݕNWGw Ljg(gwLӋT071oUX**| J&*/Tު UUT^S}FU3S ԖUPSSg;goT?~YYLOCQ_ cx,!k u5&|v*=9C3J3WRf?qtN (~))4L1e\kXHQG6EYAJ'\'GgSSݧ M=:.kDwn^Loy}/TmG X $ <5qo</QC]@Caaᄑ.ȽJtq]zۯ6iܟ4)Y3sCQ? 0k߬~OCOg#/c/Wװwa>>r><72Y_7ȷOo_C#dz%gA[z|!?:eAAA!h쐭!ΑiP~aa~ 'W?pX15wCsDDDޛg1O9-J5*>.j<74?.fYXXIlK9.*6nl {/]py.,:@LN8A*%w% yg"/6шC\*NH*Mz쑼5y$3,幄'L Lݛ:v m2=:1qB!Mggfvˬen/kY- BTZ(*geWf͉9+̳ې7ᒶKW-X潬j9(xoʿܔĹdff-[n ڴ VE/(ۻCɾUUMfeI?m]Nmq#׹=TR+Gw- 6 U#pDy  :v{vg/jBFS[b[O>zG499?rCd&ˮ/~јѡ򗓿m|x31^VwwO| (hSЧc3- cHRMz%u0`:o_F@8N ' p @8N@8}' p '#@8N@8N pQ9p!i~}|6-ӪG` VP.@*j>[ K^<֐Z]@8N'KQ<Q(`s" 'hgpKB`R@Dqj '  'P$a ( `D$Na L?u80e J,K˷NI'0eݷ(NI'؀ 2ipIIKp`:O'`ʤxB8Ѥx Ѥx $ $P6 :vRNb 'p,>NB 'P]-->P T+*^h& p '‰a ‰ (ĵt#u33;Nt̵'ޯ; [3W ~]0KH1q@8]O2]3*̧7# *p>us p _6]/}-4|t'|Smx= DoʾM×M_8!)6lq':l7!|4} '\ne t!=hnLn (~Dn\+‰_4k)0e@OhZ`F `.m1} 'vp{F`ON7Srx 'D˸nV`><;yMx!IS钦OM)Ե٥x 'DSD6bS8!" ODz#R >S8!7ّxEh0m$MIPHi$IvS8IN$I p$O8I,sk&I)$IN$Hi$I^Ah.p$MIN$IR8I·N "IF9Ah0m$MIN$IR8IN$I 3jIU;kO$ɳN$+ q.x* tEXtComment

Viewing File: /opt/go/pkg/mod/github.com/go-openapi/validate@v0.24.0/schema.go

// Copyright 2015 go-swagger maintainers
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package validate

import (
	"encoding/json"
	"reflect"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/spec"
	"github.com/go-openapi/strfmt"
	"github.com/go-openapi/swag"
)

// SchemaValidator validates data against a JSON schema
type SchemaValidator struct {
	Path         string
	in           string
	Schema       *spec.Schema
	validators   [8]valueValidator
	Root         interface{}
	KnownFormats strfmt.Registry
	Options      *SchemaValidatorOptions
}

// AgainstSchema validates the specified data against the provided schema, using a registry of supported formats.
//
// When no pre-parsed *spec.Schema structure is provided, it uses a JSON schema as default. See example.
func AgainstSchema(schema *spec.Schema, data interface{}, formats strfmt.Registry, options ...Option) error {
	res := NewSchemaValidator(schema, nil, "", formats,
		append(options, WithRecycleValidators(true), withRecycleResults(true))...,
	).Validate(data)
	defer func() {
		pools.poolOfResults.RedeemResult(res)
	}()

	if res.HasErrors() {
		return errors.CompositeValidationError(res.Errors...)
	}

	return nil
}

// NewSchemaValidator creates a new schema validator.
//
// Panics if the provided schema is invalid.
func NewSchemaValidator(schema *spec.Schema, rootSchema interface{}, root string, formats strfmt.Registry, options ...Option) *SchemaValidator {
	opts := new(SchemaValidatorOptions)
	for _, o := range options {
		o(opts)
	}

	return newSchemaValidator(schema, rootSchema, root, formats, opts)
}

func newSchemaValidator(schema *spec.Schema, rootSchema interface{}, root string, formats strfmt.Registry, opts *SchemaValidatorOptions) *SchemaValidator {
	if schema == nil {
		return nil
	}

	if rootSchema == nil {
		rootSchema = schema
	}

	if schema.ID != "" || schema.Ref.String() != "" || schema.Ref.IsRoot() {
		err := spec.ExpandSchema(schema, rootSchema, nil)
		if err != nil {
			msg := invalidSchemaProvidedMsg(err).Error()
			panic(msg)
		}
	}

	if opts == nil {
		opts = new(SchemaValidatorOptions)
	}

	var s *SchemaValidator
	if opts.recycleValidators {
		s = pools.poolOfSchemaValidators.BorrowValidator()
	} else {
		s = new(SchemaValidator)
	}

	s.Path = root
	s.in = "body"
	s.Schema = schema
	s.Root = rootSchema
	s.Options = opts
	s.KnownFormats = formats

	s.validators = [8]valueValidator{
		s.typeValidator(),
		s.schemaPropsValidator(),
		s.stringValidator(),
		s.formatValidator(),
		s.numberValidator(),
		s.sliceValidator(),
		s.commonValidator(),
		s.objectValidator(),
	}

	return s
}

// SetPath sets the path for this schema valdiator
func (s *SchemaValidator) SetPath(path string) {
	s.Path = path
}

// Applies returns true when this schema validator applies
func (s *SchemaValidator) Applies(source interface{}, _ reflect.Kind) bool {
	_, ok := source.(*spec.Schema)
	return ok
}

// Validate validates the data against the schema
func (s *SchemaValidator) Validate(data interface{}) *Result {
	if s == nil {
		return emptyResult
	}

	if s.Options.recycleValidators {
		defer func() {
			s.redeemChildren()
			s.redeem() // one-time use validator
		}()
	}

	var result *Result
	if s.Options.recycleResult {
		result = pools.poolOfResults.BorrowResult()
		result.data = data
	} else {
		result = &Result{data: data}
	}

	if s.Schema != nil && !s.Options.skipSchemataResult {
		result.addRootObjectSchemata(s.Schema)
	}

	if data == nil {
		// early exit with minimal validation
		result.Merge(s.validators[0].Validate(data)) // type validator
		result.Merge(s.validators[6].Validate(data)) // common validator

		if s.Options.recycleValidators {
			s.validators[0] = nil
			s.validators[6] = nil
		}

		return result
	}

	tpe := reflect.TypeOf(data)
	kind := tpe.Kind()
	for kind == reflect.Ptr {
		tpe = tpe.Elem()
		kind = tpe.Kind()
	}
	d := data

	if kind == reflect.Struct {
		// NOTE: since reflect retrieves the true nature of types
		// this means that all strfmt types passed here (e.g. strfmt.Datetime, etc..)
		// are converted here to strings, and structs are systematically converted
		// to map[string]interface{}.
		d = swag.ToDynamicJSON(data)
	}

	// TODO: this part should be handed over to type validator
	// Handle special case of json.Number data (number marshalled as string)
	isnumber := s.Schema.Type.Contains(numberType) || s.Schema.Type.Contains(integerType)
	if num, ok := data.(json.Number); ok && isnumber {
		if s.Schema.Type.Contains(integerType) { // avoid lossy conversion
			in, erri := num.Int64()
			if erri != nil {
				result.AddErrors(invalidTypeConversionMsg(s.Path, erri))
				result.Inc()

				return result
			}
			d = in
		} else {
			nf, errf := num.Float64()
			if errf != nil {
				result.AddErrors(invalidTypeConversionMsg(s.Path, errf))
				result.Inc()

				return result
			}
			d = nf
		}

		tpe = reflect.TypeOf(d)
		kind = tpe.Kind()
	}

	for idx, v := range s.validators {
		if !v.Applies(s.Schema, kind) {
			if s.Options.recycleValidators {
				// Validate won't be called, so relinquish this validator
				if redeemableChildren, ok := v.(interface{ redeemChildren() }); ok {
					redeemableChildren.redeemChildren()
				}
				if redeemable, ok := v.(interface{ redeem() }); ok {
					redeemable.redeem()
				}
				s.validators[idx] = nil // prevents further (unsafe) usage
			}

			continue
		}

		result.Merge(v.Validate(d))
		if s.Options.recycleValidators {
			s.validators[idx] = nil // prevents further (unsafe) usage
		}
		result.Inc()
	}
	result.Inc()

	return result
}

func (s *SchemaValidator) typeValidator() valueValidator {
	return newTypeValidator(
		s.Path,
		s.in,
		s.Schema.Type,
		s.Schema.Nullable,
		s.Schema.Format,
		s.Options,
	)
}

func (s *SchemaValidator) commonValidator() valueValidator {
	return newBasicCommonValidator(
		s.Path,
		s.in,
		s.Schema.Default,
		s.Schema.Enum,
		s.Options,
	)
}

func (s *SchemaValidator) sliceValidator() valueValidator {
	return newSliceValidator(
		s.Path,
		s.in,
		s.Schema.MaxItems,
		s.Schema.MinItems,
		s.Schema.UniqueItems,
		s.Schema.AdditionalItems,
		s.Schema.Items,
		s.Root,
		s.KnownFormats,
		s.Options,
	)
}

func (s *SchemaValidator) numberValidator() valueValidator {
	return newNumberValidator(
		s.Path,
		s.in,
		s.Schema.Default,
		s.Schema.MultipleOf,
		s.Schema.Maximum,
		s.Schema.ExclusiveMaximum,
		s.Schema.Minimum,
		s.Schema.ExclusiveMinimum,
		"",
		"",
		s.Options,
	)
}

func (s *SchemaValidator) stringValidator() valueValidator {
	return newStringValidator(
		s.Path,
		s.in,
		nil,
		false,
		false,
		s.Schema.MaxLength,
		s.Schema.MinLength,
		s.Schema.Pattern,
		s.Options,
	)
}

func (s *SchemaValidator) formatValidator() valueValidator {
	return newFormatValidator(
		s.Path,
		s.in,
		s.Schema.Format,
		s.KnownFormats,
		s.Options,
	)
}

func (s *SchemaValidator) schemaPropsValidator() valueValidator {
	sch := s.Schema
	return newSchemaPropsValidator(
		s.Path, s.in, sch.AllOf, sch.OneOf, sch.AnyOf, sch.Not, sch.Dependencies, s.Root, s.KnownFormats,
		s.Options,
	)
}

func (s *SchemaValidator) objectValidator() valueValidator {
	return newObjectValidator(
		s.Path,
		s.in,
		s.Schema.MaxProperties,
		s.Schema.MinProperties,
		s.Schema.Required,
		s.Schema.Properties,
		s.Schema.AdditionalProperties,
		s.Schema.PatternProperties,
		s.Root,
		s.KnownFormats,
		s.Options,
	)
}

func (s *SchemaValidator) redeem() {
	pools.poolOfSchemaValidators.RedeemValidator(s)
}

func (s *SchemaValidator) redeemChildren() {
	for i, validator := range s.validators {
		if validator == nil {
			continue
		}
		if redeemableChildren, ok := validator.(interface{ redeemChildren() }); ok {
			redeemableChildren.redeemChildren()
		}
		if redeemable, ok := validator.(interface{ redeem() }); ok {
			redeemable.redeem()
		}
		s.validators[i] = nil // free up allocated children if not in pool
	}
}
Back to Directory=ceiIENDB`