podman

1
package validator
2

3
import (
4
	"context"
5
	"errors"
6
	"fmt"
7
	"reflect"
8
	"strings"
9
	"sync"
10
	"time"
11

12
	ut "github.com/go-playground/universal-translator"
13
)
14

15
const (
16
	defaultTagName        = "validate"
17
	utf8HexComma          = "0x2C"
18
	utf8Pipe              = "0x7C"
19
	tagSeparator          = ","
20
	orSeparator           = "|"
21
	tagKeySeparator       = "="
22
	structOnlyTag         = "structonly"
23
	noStructLevelTag      = "nostructlevel"
24
	omitempty             = "omitempty"
25
	omitnil               = "omitnil"
26
	isdefault             = "isdefault"
27
	requiredWithoutAllTag = "required_without_all"
28
	requiredWithoutTag    = "required_without"
29
	requiredWithTag       = "required_with"
30
	requiredWithAllTag    = "required_with_all"
31
	requiredIfTag         = "required_if"
32
	requiredUnlessTag     = "required_unless"
33
	skipUnlessTag         = "skip_unless"
34
	excludedWithoutAllTag = "excluded_without_all"
35
	excludedWithoutTag    = "excluded_without"
36
	excludedWithTag       = "excluded_with"
37
	excludedWithAllTag    = "excluded_with_all"
38
	excludedIfTag         = "excluded_if"
39
	excludedUnlessTag     = "excluded_unless"
40
	skipValidationTag     = "-"
41
	diveTag               = "dive"
42
	keysTag               = "keys"
43
	endKeysTag            = "endkeys"
44
	requiredTag           = "required"
45
	namespaceSeparator    = "."
46
	leftBracket           = "["
47
	rightBracket          = "]"
48
	restrictedTagChars    = ".[],|=+()`~!@#$%^&*\\\"/?<>{}"
49
	restrictedAliasErr    = "Alias '%s' either contains restricted characters or is the same as a restricted tag needed for normal operation"
50
	restrictedTagErr      = "Tag '%s' either contains restricted characters or is the same as a restricted tag needed for normal operation"
51
)
52

53
var (
54
	timeDurationType = reflect.TypeOf(time.Duration(0))
55
	timeType         = reflect.TypeOf(time.Time{})
56

57
	byteSliceType = reflect.TypeOf([]byte{})
58

59
	defaultCField = &cField{namesEqual: true}
60
)
61

62
// FilterFunc is the type used to filter fields using
63
// StructFiltered(...) function.
64
// returning true results in the field being filtered/skipped from
65
// validation
66
type FilterFunc func(ns []byte) bool
67

68
// CustomTypeFunc allows for overriding or adding custom field type handler functions
69
// field = field value of the type to return a value to be validated
70
// example Valuer from sql drive see https://golang.org/src/database/sql/driver/types.go?s=1210:1293#L29
71
type CustomTypeFunc func(field reflect.Value) interface{}
72

73
// TagNameFunc allows for adding of a custom tag name parser
74
type TagNameFunc func(field reflect.StructField) string
75

76
type internalValidationFuncWrapper struct {
77
	fn                FuncCtx
78
	runValidatinOnNil bool
79
}
80

81
// Validate contains the validator settings and cache
82
type Validate struct {
83
	tagName               string
84
	pool                  *sync.Pool
85
	tagNameFunc           TagNameFunc
86
	structLevelFuncs      map[reflect.Type]StructLevelFuncCtx
87
	customFuncs           map[reflect.Type]CustomTypeFunc
88
	aliases               map[string]string
89
	validations           map[string]internalValidationFuncWrapper
90
	transTagFunc          map[ut.Translator]map[string]TranslationFunc // map[<locale>]map[<tag>]TranslationFunc
91
	rules                 map[reflect.Type]map[string]string
92
	tagCache              *tagCache
93
	structCache           *structCache
94
	hasCustomFuncs        bool
95
	hasTagNameFunc        bool
96
	requiredStructEnabled bool
97
}
98

99
// New returns a new instance of 'validate' with sane defaults.
100
// Validate is designed to be thread-safe and used as a singleton instance.
101
// It caches information about your struct and validations,
102
// in essence only parsing your validation tags once per struct type.
103
// Using multiple instances neglects the benefit of caching.
104
func New(options ...Option) *Validate {
105

106
	tc := new(tagCache)
107
	tc.m.Store(make(map[string]*cTag))
108

109
	sc := new(structCache)
110
	sc.m.Store(make(map[reflect.Type]*cStruct))
111

112
	v := &Validate{
113
		tagName:     defaultTagName,
114
		aliases:     make(map[string]string, len(bakedInAliases)),
115
		validations: make(map[string]internalValidationFuncWrapper, len(bakedInValidators)),
116
		tagCache:    tc,
117
		structCache: sc,
118
	}
119

120
	// must copy alias validators for separate validations to be used in each validator instance
121
	for k, val := range bakedInAliases {
122
		v.RegisterAlias(k, val)
123
	}
124

125
	// must copy validators for separate validations to be used in each instance
126
	for k, val := range bakedInValidators {
127

128
		switch k {
129
		// these require that even if the value is nil that the validation should run, omitempty still overrides this behaviour
130
		case requiredIfTag, requiredUnlessTag, requiredWithTag, requiredWithAllTag, requiredWithoutTag, requiredWithoutAllTag,
131
			excludedIfTag, excludedUnlessTag, excludedWithTag, excludedWithAllTag, excludedWithoutTag, excludedWithoutAllTag,
132
			skipUnlessTag:
133
			_ = v.registerValidation(k, wrapFunc(val), true, true)
134
		default:
135
			// no need to error check here, baked in will always be valid
136
			_ = v.registerValidation(k, wrapFunc(val), true, false)
137
		}
138
	}
139

140
	v.pool = &sync.Pool{
141
		New: func() interface{} {
142
			return &validate{
143
				v:        v,
144
				ns:       make([]byte, 0, 64),
145
				actualNs: make([]byte, 0, 64),
146
				misc:     make([]byte, 32),
147
			}
148
		},
149
	}
150

151
	for _, o := range options {
152
		o(v)
153
	}
154
	return v
155
}
156

157
// SetTagName allows for changing of the default tag name of 'validate'
158
func (v *Validate) SetTagName(name string) {
159
	v.tagName = name
160
}
161

162
// ValidateMapCtx validates a map using a map of validation rules and allows passing of contextual
163
// validation information via context.Context.
164
func (v Validate) ValidateMapCtx(ctx context.Context, data map[string]interface{}, rules map[string]interface{}) map[string]interface{} {
165
	errs := make(map[string]interface{})
166
	for field, rule := range rules {
167
		if ruleObj, ok := rule.(map[string]interface{}); ok {
168
			if dataObj, ok := data[field].(map[string]interface{}); ok {
169
				err := v.ValidateMapCtx(ctx, dataObj, ruleObj)
170
				if len(err) > 0 {
171
					errs[field] = err
172
				}
173
			} else if dataObjs, ok := data[field].([]map[string]interface{}); ok {
174
				for _, obj := range dataObjs {
175
					err := v.ValidateMapCtx(ctx, obj, ruleObj)
176
					if len(err) > 0 {
177
						errs[field] = err
178
					}
179
				}
180
			} else {
181
				errs[field] = errors.New("The field: '" + field + "' is not a map to dive")
182
			}
183
		} else if ruleStr, ok := rule.(string); ok {
184
			err := v.VarCtx(ctx, data[field], ruleStr)
185
			if err != nil {
186
				errs[field] = err
187
			}
188
		}
189
	}
190
	return errs
191
}
192

193
// ValidateMap validates map data from a map of tags
194
func (v *Validate) ValidateMap(data map[string]interface{}, rules map[string]interface{}) map[string]interface{} {
195
	return v.ValidateMapCtx(context.Background(), data, rules)
196
}
197

198
// RegisterTagNameFunc registers a function to get alternate names for StructFields.
199
//
200
// eg. to use the names which have been specified for JSON representations of structs, rather than normal Go field names:
201
//
202
//	validate.RegisterTagNameFunc(func(fld reflect.StructField) string {
203
//	    name := strings.SplitN(fld.Tag.Get("json"), ",", 2)[0]
204
//	    // skip if tag key says it should be ignored
205
//	    if name == "-" {
206
//	        return ""
207
//	    }
208
//	    return name
209
//	})
210
func (v *Validate) RegisterTagNameFunc(fn TagNameFunc) {
211
	v.tagNameFunc = fn
212
	v.hasTagNameFunc = true
213
}
214

215
// RegisterValidation adds a validation with the given tag
216
//
217
// NOTES:
218
// - if the key already exists, the previous validation function will be replaced.
219
// - this method is not thread-safe it is intended that these all be registered prior to any validation
220
func (v *Validate) RegisterValidation(tag string, fn Func, callValidationEvenIfNull ...bool) error {
221
	return v.RegisterValidationCtx(tag, wrapFunc(fn), callValidationEvenIfNull...)
222
}
223

224
// RegisterValidationCtx does the same as RegisterValidation on accepts a FuncCtx validation
225
// allowing context.Context validation support.
226
func (v *Validate) RegisterValidationCtx(tag string, fn FuncCtx, callValidationEvenIfNull ...bool) error {
227
	var nilCheckable bool
228
	if len(callValidationEvenIfNull) > 0 {
229
		nilCheckable = callValidationEvenIfNull[0]
230
	}
231
	return v.registerValidation(tag, fn, false, nilCheckable)
232
}
233

234
func (v *Validate) registerValidation(tag string, fn FuncCtx, bakedIn bool, nilCheckable bool) error {
235
	if len(tag) == 0 {
236
		return errors.New("function Key cannot be empty")
237
	}
238

239
	if fn == nil {
240
		return errors.New("function cannot be empty")
241
	}
242

243
	_, ok := restrictedTags[tag]
244
	if !bakedIn && (ok || strings.ContainsAny(tag, restrictedTagChars)) {
245
		panic(fmt.Sprintf(restrictedTagErr, tag))
246
	}
247
	v.validations[tag] = internalValidationFuncWrapper{fn: fn, runValidatinOnNil: nilCheckable}
248
	return nil
249
}
250

251
// RegisterAlias registers a mapping of a single validation tag that
252
// defines a common or complex set of validation(s) to simplify adding validation
253
// to structs.
254
//
255
// NOTE: this function is not thread-safe it is intended that these all be registered prior to any validation
256
func (v *Validate) RegisterAlias(alias, tags string) {
257

258
	_, ok := restrictedTags[alias]
259

260
	if ok || strings.ContainsAny(alias, restrictedTagChars) {
261
		panic(fmt.Sprintf(restrictedAliasErr, alias))
262
	}
263

264
	v.aliases[alias] = tags
265
}
266

267
// RegisterStructValidation registers a StructLevelFunc against a number of types.
268
//
269
// NOTE:
270
// - this method is not thread-safe it is intended that these all be registered prior to any validation
271
func (v *Validate) RegisterStructValidation(fn StructLevelFunc, types ...interface{}) {
272
	v.RegisterStructValidationCtx(wrapStructLevelFunc(fn), types...)
273
}
274

275
// RegisterStructValidationCtx registers a StructLevelFuncCtx against a number of types and allows passing
276
// of contextual validation information via context.Context.
277
//
278
// NOTE:
279
// - this method is not thread-safe it is intended that these all be registered prior to any validation
280
func (v *Validate) RegisterStructValidationCtx(fn StructLevelFuncCtx, types ...interface{}) {
281

282
	if v.structLevelFuncs == nil {
283
		v.structLevelFuncs = make(map[reflect.Type]StructLevelFuncCtx)
284
	}
285

286
	for _, t := range types {
287
		tv := reflect.ValueOf(t)
288
		if tv.Kind() == reflect.Ptr {
289
			t = reflect.Indirect(tv).Interface()
290
		}
291

292
		v.structLevelFuncs[reflect.TypeOf(t)] = fn
293
	}
294
}
295

296
// RegisterStructValidationMapRules registers validate map rules.
297
// Be aware that map validation rules supersede those defined on a/the struct if present.
298
//
299
// NOTE: this method is not thread-safe it is intended that these all be registered prior to any validation
300
func (v *Validate) RegisterStructValidationMapRules(rules map[string]string, types ...interface{}) {
301
	if v.rules == nil {
302
		v.rules = make(map[reflect.Type]map[string]string)
303
	}
304

305
	deepCopyRules := make(map[string]string)
306
	for i, rule := range rules {
307
		deepCopyRules[i] = rule
308
	}
309

310
	for _, t := range types {
311
		typ := reflect.TypeOf(t)
312

313
		if typ.Kind() == reflect.Ptr {
314
			typ = typ.Elem()
315
		}
316

317
		if typ.Kind() != reflect.Struct {
318
			continue
319
		}
320
		v.rules[typ] = deepCopyRules
321
	}
322
}
323

324
// RegisterCustomTypeFunc registers a CustomTypeFunc against a number of types
325
//
326
// NOTE: this method is not thread-safe it is intended that these all be registered prior to any validation
327
func (v *Validate) RegisterCustomTypeFunc(fn CustomTypeFunc, types ...interface{}) {
328

329
	if v.customFuncs == nil {
330
		v.customFuncs = make(map[reflect.Type]CustomTypeFunc)
331
	}
332

333
	for _, t := range types {
334
		v.customFuncs[reflect.TypeOf(t)] = fn
335
	}
336

337
	v.hasCustomFuncs = true
338
}
339

340
// RegisterTranslation registers translations against the provided tag.
341
func (v *Validate) RegisterTranslation(tag string, trans ut.Translator, registerFn RegisterTranslationsFunc, translationFn TranslationFunc) (err error) {
342

343
	if v.transTagFunc == nil {
344
		v.transTagFunc = make(map[ut.Translator]map[string]TranslationFunc)
345
	}
346

347
	if err = registerFn(trans); err != nil {
348
		return
349
	}
350

351
	m, ok := v.transTagFunc[trans]
352
	if !ok {
353
		m = make(map[string]TranslationFunc)
354
		v.transTagFunc[trans] = m
355
	}
356

357
	m[tag] = translationFn
358

359
	return
360
}
361

362
// Struct validates a structs exposed fields, and automatically validates nested structs, unless otherwise specified.
363
//
364
// It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
365
// You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
366
func (v *Validate) Struct(s interface{}) error {
367
	return v.StructCtx(context.Background(), s)
368
}
369

370
// StructCtx validates a structs exposed fields, and automatically validates nested structs, unless otherwise specified
371
// and also allows passing of context.Context for contextual validation information.
372
//
373
// It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
374
// You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
375
func (v *Validate) StructCtx(ctx context.Context, s interface{}) (err error) {
376

377
	val := reflect.ValueOf(s)
378
	top := val
379

380
	if val.Kind() == reflect.Ptr && !val.IsNil() {
381
		val = val.Elem()
382
	}
383

384
	if val.Kind() != reflect.Struct || val.Type().ConvertibleTo(timeType) {
385
		return &InvalidValidationError{Type: reflect.TypeOf(s)}
386
	}
387

388
	// good to validate
389
	vd := v.pool.Get().(*validate)
390
	vd.top = top
391
	vd.isPartial = false
392
	// vd.hasExcludes = false // only need to reset in StructPartial and StructExcept
393

394
	vd.validateStruct(ctx, top, val, val.Type(), vd.ns[0:0], vd.actualNs[0:0], nil)
395

396
	if len(vd.errs) > 0 {
397
		err = vd.errs
398
		vd.errs = nil
399
	}
400

401
	v.pool.Put(vd)
402

403
	return
404
}
405

406
// StructFiltered validates a structs exposed fields, that pass the FilterFunc check and automatically validates
407
// nested structs, unless otherwise specified.
408
//
409
// It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
410
// You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
411
func (v *Validate) StructFiltered(s interface{}, fn FilterFunc) error {
412
	return v.StructFilteredCtx(context.Background(), s, fn)
413
}
414

415
// StructFilteredCtx validates a structs exposed fields, that pass the FilterFunc check and automatically validates
416
// nested structs, unless otherwise specified and also allows passing of contextual validation information via
417
// context.Context
418
//
419
// It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
420
// You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
421
func (v *Validate) StructFilteredCtx(ctx context.Context, s interface{}, fn FilterFunc) (err error) {
422
	val := reflect.ValueOf(s)
423
	top := val
424

425
	if val.Kind() == reflect.Ptr && !val.IsNil() {
426
		val = val.Elem()
427
	}
428

429
	if val.Kind() != reflect.Struct || val.Type().ConvertibleTo(timeType) {
430
		return &InvalidValidationError{Type: reflect.TypeOf(s)}
431
	}
432

433
	// good to validate
434
	vd := v.pool.Get().(*validate)
435
	vd.top = top
436
	vd.isPartial = true
437
	vd.ffn = fn
438
	// vd.hasExcludes = false // only need to reset in StructPartial and StructExcept
439

440
	vd.validateStruct(ctx, top, val, val.Type(), vd.ns[0:0], vd.actualNs[0:0], nil)
441

442
	if len(vd.errs) > 0 {
443
		err = vd.errs
444
		vd.errs = nil
445
	}
446

447
	v.pool.Put(vd)
448

449
	return
450
}
451

452
// StructPartial validates the fields passed in only, ignoring all others.
453
// Fields may be provided in a namespaced fashion relative to the  struct provided
454
// eg. NestedStruct.Field or NestedArrayField[0].Struct.Name
455
//
456
// It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
457
// You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
458
func (v *Validate) StructPartial(s interface{}, fields ...string) error {
459
	return v.StructPartialCtx(context.Background(), s, fields...)
460
}
461

462
// StructPartialCtx validates the fields passed in only, ignoring all others and allows passing of contextual
463
// validation information via context.Context
464
// Fields may be provided in a namespaced fashion relative to the  struct provided
465
// eg. NestedStruct.Field or NestedArrayField[0].Struct.Name
466
//
467
// It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
468
// You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
469
func (v *Validate) StructPartialCtx(ctx context.Context, s interface{}, fields ...string) (err error) {
470
	val := reflect.ValueOf(s)
471
	top := val
472

473
	if val.Kind() == reflect.Ptr && !val.IsNil() {
474
		val = val.Elem()
475
	}
476

477
	if val.Kind() != reflect.Struct || val.Type().ConvertibleTo(timeType) {
478
		return &InvalidValidationError{Type: reflect.TypeOf(s)}
479
	}
480

481
	// good to validate
482
	vd := v.pool.Get().(*validate)
483
	vd.top = top
484
	vd.isPartial = true
485
	vd.ffn = nil
486
	vd.hasExcludes = false
487
	vd.includeExclude = make(map[string]struct{})
488

489
	typ := val.Type()
490
	name := typ.Name()
491

492
	for _, k := range fields {
493

494
		flds := strings.Split(k, namespaceSeparator)
495
		if len(flds) > 0 {
496

497
			vd.misc = append(vd.misc[0:0], name...)
498
			// Don't append empty name for unnamed structs
499
			if len(vd.misc) != 0 {
500
				vd.misc = append(vd.misc, '.')
501
			}
502

503
			for _, s := range flds {
504

505
				idx := strings.Index(s, leftBracket)
506

507
				if idx != -1 {
508
					for idx != -1 {
509
						vd.misc = append(vd.misc, s[:idx]...)
510
						vd.includeExclude[string(vd.misc)] = struct{}{}
511

512
						idx2 := strings.Index(s, rightBracket)
513
						idx2++
514
						vd.misc = append(vd.misc, s[idx:idx2]...)
515
						vd.includeExclude[string(vd.misc)] = struct{}{}
516
						s = s[idx2:]
517
						idx = strings.Index(s, leftBracket)
518
					}
519
				} else {
520

521
					vd.misc = append(vd.misc, s...)
522
					vd.includeExclude[string(vd.misc)] = struct{}{}
523
				}
524

525
				vd.misc = append(vd.misc, '.')
526
			}
527
		}
528
	}
529

530
	vd.validateStruct(ctx, top, val, typ, vd.ns[0:0], vd.actualNs[0:0], nil)
531

532
	if len(vd.errs) > 0 {
533
		err = vd.errs
534
		vd.errs = nil
535
	}
536

537
	v.pool.Put(vd)
538

539
	return
540
}
541

542
// StructExcept validates all fields except the ones passed in.
543
// Fields may be provided in a namespaced fashion relative to the  struct provided
544
// i.e. NestedStruct.Field or NestedArrayField[0].Struct.Name
545
//
546
// It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
547
// You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
548
func (v *Validate) StructExcept(s interface{}, fields ...string) error {
549
	return v.StructExceptCtx(context.Background(), s, fields...)
550
}
551

552
// StructExceptCtx validates all fields except the ones passed in and allows passing of contextual
553
// validation information via context.Context
554
// Fields may be provided in a namespaced fashion relative to the  struct provided
555
// i.e. NestedStruct.Field or NestedArrayField[0].Struct.Name
556
//
557
// It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
558
// You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
559
func (v *Validate) StructExceptCtx(ctx context.Context, s interface{}, fields ...string) (err error) {
560
	val := reflect.ValueOf(s)
561
	top := val
562

563
	if val.Kind() == reflect.Ptr && !val.IsNil() {
564
		val = val.Elem()
565
	}
566

567
	if val.Kind() != reflect.Struct || val.Type().ConvertibleTo(timeType) {
568
		return &InvalidValidationError{Type: reflect.TypeOf(s)}
569
	}
570

571
	// good to validate
572
	vd := v.pool.Get().(*validate)
573
	vd.top = top
574
	vd.isPartial = true
575
	vd.ffn = nil
576
	vd.hasExcludes = true
577
	vd.includeExclude = make(map[string]struct{})
578

579
	typ := val.Type()
580
	name := typ.Name()
581

582
	for _, key := range fields {
583

584
		vd.misc = vd.misc[0:0]
585

586
		if len(name) > 0 {
587
			vd.misc = append(vd.misc, name...)
588
			vd.misc = append(vd.misc, '.')
589
		}
590

591
		vd.misc = append(vd.misc, key...)
592
		vd.includeExclude[string(vd.misc)] = struct{}{}
593
	}
594

595
	vd.validateStruct(ctx, top, val, typ, vd.ns[0:0], vd.actualNs[0:0], nil)
596

597
	if len(vd.errs) > 0 {
598
		err = vd.errs
599
		vd.errs = nil
600
	}
601

602
	v.pool.Put(vd)
603

604
	return
605
}
606

607
// Var validates a single variable using tag style validation.
608
// eg.
609
// var i int
610
// validate.Var(i, "gt=1,lt=10")
611
//
612
// WARNING: a struct can be passed for validation eg. time.Time is a struct or
613
// if you have a custom type and have registered a custom type handler, so must
614
// allow it; however unforeseen validations will occur if trying to validate a
615
// struct that is meant to be passed to 'validate.Struct'
616
//
617
// It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
618
// You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
619
// validate Array, Slice and maps fields which may contain more than one error
620
func (v *Validate) Var(field interface{}, tag string) error {
621
	return v.VarCtx(context.Background(), field, tag)
622
}
623

624
// VarCtx validates a single variable using tag style validation and allows passing of contextual
625
// validation information via context.Context.
626
// eg.
627
// var i int
628
// validate.Var(i, "gt=1,lt=10")
629
//
630
// WARNING: a struct can be passed for validation eg. time.Time is a struct or
631
// if you have a custom type and have registered a custom type handler, so must
632
// allow it; however unforeseen validations will occur if trying to validate a
633
// struct that is meant to be passed to 'validate.Struct'
634
//
635
// It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
636
// You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
637
// validate Array, Slice and maps fields which may contain more than one error
638
func (v *Validate) VarCtx(ctx context.Context, field interface{}, tag string) (err error) {
639
	if len(tag) == 0 || tag == skipValidationTag {
640
		return nil
641
	}
642

643
	ctag := v.fetchCacheTag(tag)
644

645
	val := reflect.ValueOf(field)
646
	vd := v.pool.Get().(*validate)
647
	vd.top = val
648
	vd.isPartial = false
649
	vd.traverseField(ctx, val, val, vd.ns[0:0], vd.actualNs[0:0], defaultCField, ctag)
650

651
	if len(vd.errs) > 0 {
652
		err = vd.errs
653
		vd.errs = nil
654
	}
655
	v.pool.Put(vd)
656
	return
657
}
658

659
// VarWithValue validates a single variable, against another variable/field's value using tag style validation
660
// eg.
661
// s1 := "abcd"
662
// s2 := "abcd"
663
// validate.VarWithValue(s1, s2, "eqcsfield") // returns true
664
//
665
// WARNING: a struct can be passed for validation eg. time.Time is a struct or
666
// if you have a custom type and have registered a custom type handler, so must
667
// allow it; however unforeseen validations will occur if trying to validate a
668
// struct that is meant to be passed to 'validate.Struct'
669
//
670
// It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
671
// You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
672
// validate Array, Slice and maps fields which may contain more than one error
673
func (v *Validate) VarWithValue(field interface{}, other interface{}, tag string) error {
674
	return v.VarWithValueCtx(context.Background(), field, other, tag)
675
}
676

677
// VarWithValueCtx validates a single variable, against another variable/field's value using tag style validation and
678
// allows passing of contextual validation validation information via context.Context.
679
// eg.
680
// s1 := "abcd"
681
// s2 := "abcd"
682
// validate.VarWithValue(s1, s2, "eqcsfield") // returns true
683
//
684
// WARNING: a struct can be passed for validation eg. time.Time is a struct or
685
// if you have a custom type and have registered a custom type handler, so must
686
// allow it; however unforeseen validations will occur if trying to validate a
687
// struct that is meant to be passed to 'validate.Struct'
688
//
689
// It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
690
// You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
691
// validate Array, Slice and maps fields which may contain more than one error
692
func (v *Validate) VarWithValueCtx(ctx context.Context, field interface{}, other interface{}, tag string) (err error) {
693
	if len(tag) == 0 || tag == skipValidationTag {
694
		return nil
695
	}
696
	ctag := v.fetchCacheTag(tag)
697
	otherVal := reflect.ValueOf(other)
698
	vd := v.pool.Get().(*validate)
699
	vd.top = otherVal
700
	vd.isPartial = false
701
	vd.traverseField(ctx, otherVal, reflect.ValueOf(field), vd.ns[0:0], vd.actualNs[0:0], defaultCField, ctag)
702

703
	if len(vd.errs) > 0 {
704
		err = vd.errs
705
		vd.errs = nil
706
	}
707
	v.pool.Put(vd)
708
	return
709
}
710