example_validators.go

// Code generated by gencheck
// DO NOT EDIT!

package example

import (
	"errors"
	"fmt"
	"net"
	"net/url"
	"strings"
	"time"

	"github.com/abice/gencheck"
)

// Validate is an automatically generated validation method provided by
// gencheck.
// See https://github.com/abice/gencheck for more details.
func (s Embedded) Validate() error {

	vErrors := make(gencheck.ValidationErrors, 0, 1)

	// BEGIN FieldString Validations
	// required
	if s.FieldString == "" {
		vErrors = append(vErrors, gencheck.NewFieldError("Embedded", "FieldString", "required", errors.New("is required")))
	}
	// END FieldString Validations

	if len(vErrors) > 0 {
		return vErrors
	}

	return nil
}

// Validate is an automatically generated validation method provided by
// gencheck.
// See https://github.com/abice/gencheck for more details.
func (s Example) Validate() error {

	vErrors := make(gencheck.ValidationErrors, 0, 1)

	// BEGIN MapOfInterfaces Validations
	// notnil
	if s.MapOfInterfaces == nil {
		vErrors = append(vErrors, gencheck.NewFieldError("Example", "MapOfInterfaces", "notnil", errors.New("is Nil")))
	}
	// END MapOfInterfaces Validations

	if len(vErrors) > 0 {
		return vErrors
	}

	return nil
}

// Validate is an automatically generated validation method provided by
// gencheck.
// See https://github.com/abice/gencheck for more details.
func (s Inner) Validate() error {

	vErrors := make(gencheck.ValidationErrors, 0, 1)

	// BEGIN EqCSFieldString Validations
	// required
	if s.EqCSFieldString == "" {
		vErrors = append(vErrors, gencheck.NewFieldError("Inner", "EqCSFieldString", "required", errors.New("is required")))
	}
	// END EqCSFieldString Validations

	if len(vErrors) > 0 {
		return vErrors
	}

	return nil
}

// Validate is an automatically generated validation method provided by
// gencheck.
// See https://github.com/abice/gencheck for more details.
func (s Test) Validate() error {

	vErrors := make(gencheck.ValidationErrors, 0, 67)

	// BEGIN FieldString Validations
	// required
	if s.FieldString == "" {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "FieldString", "required", errors.New("is required")))
	}
	// END FieldString Validations

	// BEGIN EmbeddedString Validations
	// required
	if s.EmbeddedString == "" {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "EmbeddedString", "required", errors.New("is required")))
	}
	// END EmbeddedString Validations

	// BEGIN RequiredString Validations
	// required
	if s.RequiredString == "" {
		return append(vErrors, gencheck.NewFieldError("Test", "RequiredString", "required", errors.New("is required")))
	}
	// END RequiredString Validations

	// BEGIN RequiredMultiple Validations
	// required
	if s.RequiredMultiple == nil {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "RequiredMultiple", "required", errors.New("is required")))
	}
	// END RequiredMultiple Validations

	// BEGIN LenString Validations
	// len
	if !(len(s.LenString) == 1) {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "LenString", "len", errors.New("length mismatch")))
	}
	// END LenString Validations

	// BEGIN LenNumber Validations
	// len
	if !(s.LenNumber == 1113.00) {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "LenNumber", "len", errors.New("length mismatch")))
	}
	// END LenNumber Validations

	// BEGIN LenMultiple Validations
	// len
	if !(len(s.LenMultiple) == 7) {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "LenMultiple", "len", errors.New("length mismatch")))
	}
	// END LenMultiple Validations

	// BEGIN MinString Validations
	// min
	if len(s.MinString) < 1 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "MinString", "min", errors.New("length failed check for min=1")))
	}
	// END MinString Validations

	// BEGIN MinNumber Validations
	// min
	if s.MinNumber < 1113.00 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "MinNumber", "min", errors.New("failed check for min=1113.00")))
	}
	// END MinNumber Validations

	// BEGIN MinMultiple Validations
	// min
	if len(s.MinMultiple) < 7 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "MinMultiple", "min", errors.New("length failed check for min=7")))
	}
	// END MinMultiple Validations

	// BEGIN MaxString Validations
	// max
	if len(s.MaxString) > 3 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "MaxString", "max", errors.New("length failed check for max=3")))
	}
	// END MaxString Validations

	// BEGIN MaxNumber Validations
	// max
	if s.MaxNumber > 1113.00 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "MaxNumber", "max", errors.New("failed check for max=1113.00")))
	}
	// END MaxNumber Validations

	// BEGIN MaxMultiple Validations
	// max
	if len(s.MaxMultiple) > 7 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "MaxMultiple", "max", errors.New("length failed check for max=7")))
	}
	// END MaxMultiple Validations

	// BEGIN EqString Validations
	// eq
	if s.EqString != "3" {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "EqString", "eq", errors.New("EqString did not equal 3")))
	}
	// END EqString Validations

	// BEGIN EqNumber Validations
	// eq
	if s.EqNumber != 2.33 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "EqNumber", "eq", errors.New("EqNumber did not equal 2.33")))
	}
	// END EqNumber Validations

	// BEGIN EqMultiple Validations
	// eq
	if len(s.EqMultiple) != 7 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "EqMultiple", "eq", errors.New("Length of EqMultiple did not equal 7")))
	}
	// END EqMultiple Validations

	// BEGIN NeString Validations
	// ne
	if s.NeString == "" {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "NeString", "ne", errors.New("NeString equaled ")))
	}
	// END NeString Validations

	// BEGIN NeNumber Validations
	// ne
	if s.NeNumber == 0.00 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "NeNumber", "ne", errors.New("NeNumber equaled 0.00")))
	}
	// END NeNumber Validations

	// BEGIN NeMultiple Validations
	// ne
	if len(s.NeMultiple) == 0 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "NeMultiple", "ne", errors.New("Length of NeMultiple equaled 0")))
	}
	// END NeMultiple Validations

	// BEGIN LtString Validations
	// lt
	if len(s.LtString) >= 3 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "LtString", "lt", errors.New("length failed check for lt=3")))
	}
	// END LtString Validations

	// BEGIN LtNumber Validations
	// lt
	if s.LtNumber >= 5.56 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "LtNumber", "lt", errors.New("failed check for lt=5.56")))
	}
	// END LtNumber Validations

	// BEGIN LtMultiple Validations
	// lt
	if len(s.LtMultiple) >= 2 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "LtMultiple", "lt", errors.New("length failed check for lt=2")))
	}
	// END LtMultiple Validations

	// BEGIN LtTime Validations
	// lt
	tLtTime := time.Now().UTC()
	if !s.LtTime.Before(tLtTime) {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "LtTime", "lt", errors.New("is after now")))
	}
	// END LtTime Validations

	// BEGIN LteString Validations
	// lte
	if len(s.LteString) > 3 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "LteString", "lte", errors.New("length failed check for lte=3")))
	}
	// END LteString Validations

	// BEGIN LteNumber Validations
	// lte
	if s.LteNumber > 5.56 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "LteNumber", "lte", errors.New("failed check for lte=5.56")))
	}
	// END LteNumber Validations

	// BEGIN LteMultiple Validations
	// lte
	if len(s.LteMultiple) > 2 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "LteMultiple", "lte", errors.New("length failed check for lte=2")))
	}
	// END LteMultiple Validations

	// BEGIN LteTime Validations
	// lte
	tLteTime := time.Now().UTC()
	if s.LteTime.After(tLteTime) {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "LteTime", "lte", errors.New("is after now")))
	}
	// END LteTime Validations

	// BEGIN GtString Validations
	// gt
	if len(s.GtString) <= 3 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "GtString", "gt", errors.New("length failed check for gt=3")))
	}
	// END GtString Validations

	// BEGIN GtNumber Validations
	// gt
	if s.GtNumber <= 5.56 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "GtNumber", "gt", errors.New("failed check for gt=5.56")))
	}
	// END GtNumber Validations

	// BEGIN GtMultiple Validations
	// gt
	if len(s.GtMultiple) <= 2 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "GtMultiple", "gt", errors.New("length failed check for gt=2")))
	}
	// END GtMultiple Validations

	// BEGIN GtTime Validations
	// gt
	tGtTime := time.Now().UTC()
	if !s.GtTime.After(tGtTime) {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "GtTime", "gt", errors.New("is before now")))
	}
	// END GtTime Validations

	// BEGIN GteString Validations
	// gte
	if len(s.GteString) < 3 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "GteString", "gte", errors.New("length failed check for gte=3")))
	}
	// END GteString Validations

	// BEGIN GteNumber Validations
	// gte
	if s.GteNumber < 5.56 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "GteNumber", "gte", errors.New("failed check for gte=5.56")))
	}
	// END GteNumber Validations

	// BEGIN GteMultiple Validations
	// gte
	if len(s.GteMultiple) < 2 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "GteMultiple", "gte", errors.New("length failed check for gte=2")))
	}
	// END GteMultiple Validations

	// BEGIN GteTime Validations
	// gte
	tGteTime := time.Now().UTC()
	if s.GteTime.Before(tGteTime) {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "GteTime", "gte", errors.New("is before now")))
	}
	// END GteTime Validations

	// BEGIN GteTimeVal Validations
	// gte
	tGteTimeVal := time.Now().UTC().Add(1 * time.Second)
	if s.GteTimeVal.Before(tGteTimeVal) {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "GteTimeVal", "gte", fmt.Errorf("is before %s", tGteTimeVal)))
	}
	// END GteTimeVal Validations

	// BEGIN GteTimePtr Validations
	// gte
	if s.GteTimePtr != nil {
		tGteTimePtr := time.Now().UTC()
		if (*s.GteTimePtr).Before(tGteTimePtr) {
			vErrors = append(vErrors, gencheck.NewFieldError("Test", "GteTimePtr", "gte", errors.New("is before now")))
		}
	}
	// END GteTimePtr Validations

	// BEGIN HexadecimalString Validations
	// hexadecimal
	if err := gencheck.IsHex(&s.HexadecimalString); err != nil {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "HexadecimalString", "hexadecimal", err))
	}
	// END HexadecimalString Validations

	// BEGIN URL Validations
	// url
	if s.URL != "" {
		URLURL, URLurlerr := url.ParseRequestURI(s.URL)
		if URLurlerr != nil {
			vErrors = append(vErrors, gencheck.NewFieldError("Test", "URL", "url", URLurlerr))
		} else if URLURL.Scheme == "" {
			vErrors = append(vErrors, gencheck.NewFieldError("Test", "URL", "url", errors.New("URL is missing a scheme")))
		}
	}
	// END URL Validations

	// BEGIN URI Validations
	// uri
	if s.URI != "" {
		_, URIurierr := url.ParseRequestURI(s.URI)
		if URIurierr != nil {
			vErrors = append(vErrors, gencheck.NewFieldError("Test", "URI", "uri", URIurierr))
		}
	}
	// END URI Validations

	// BEGIN Contains Validations
	// contains
	if !strings.Contains(s.Contains, "purpose") {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "Contains", "contains", errors.New("Contains did not contain purpose")))
	}
	// END Contains Validations

	// BEGIN ContainsPtr Validations
	// contains
	if s.ContainsPtr != nil {
		if !strings.Contains(*s.ContainsPtr, "purpose") {
			vErrors = append(vErrors, gencheck.NewFieldError("Test", "ContainsPtr", "contains", errors.New("ContainsPtr did not contain purpose")))
		}
	}
	// END ContainsPtr Validations

	// BEGIN ContainsArray Validations
	// contains
	foundContainsArray := false
	for _, singleContainsArray := range s.ContainsArray {
		if "nonsense" == singleContainsArray {
			foundContainsArray = true
			break
		}
	}
	if !foundContainsArray {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "ContainsArray", "contains", errors.New("ContainsArray did not contain nonsense")))
	}
	// END ContainsArray Validations

	// BEGIN ContainsAny Validations
	// containsany
	if !strings.ContainsAny(s.ContainsAny, "!@#$") {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "ContainsAny", "containsany", errors.New("ContainsAny did not contain any of !@#$")))
	}
	// END ContainsAny Validations

	// BEGIN UUID Validations
	// uuid
	if err := gencheck.IsUUID(&s.UUID); err != nil {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "UUID", "uuid", err))
	}
	// END UUID Validations

	// BEGIN UUID3 Validations
	// uuid3
	if err := gencheck.IsUUIDv3(&s.UUID3); err != nil {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "UUID3", "uuid3", err))
	}
	// END UUID3 Validations

	// BEGIN UUID4 Validations
	// uuid4
	if err := gencheck.IsUUIDv4(&s.UUID4); err != nil {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "UUID4", "uuid4", err))
	}
	// END UUID4 Validations

	// BEGIN UUID5 Validations
	// uuid5
	if err := gencheck.IsUUIDv5(&s.UUID5); err != nil {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "UUID5", "uuid5", err))
	}
	// END UUID5 Validations

	// BEGIN CIDR Validations
	// cidr
	_, _, CIDRerr := net.ParseCIDR(s.CIDR)
	if CIDRerr != nil {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "CIDR", "cidr", CIDRerr))
	}
	// END CIDR Validations

	// BEGIN CIDRv4 Validations
	// cidrv4
	ip, _, CIDRv4err := net.ParseCIDR(s.CIDRv4)
	if CIDRv4err != nil || ip.To4() == nil {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "CIDRv4", "cidrv4", CIDRv4err))
	}
	// END CIDRv4 Validations

	// BEGIN CIDRv6 Validations
	// cidrv6
	ip, _, CIDRv6err := net.ParseCIDR(s.CIDRv6)
	if CIDRv6err != nil || ip.To4() != nil {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "CIDRv6", "cidrv6", CIDRv6err))
	}

	// END CIDRv6 Validations

	// BEGIN MinIntPtr Validations
	// required
	if s.MinIntPtr == nil {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "MinIntPtr", "required", errors.New("is required")))
	}

	// min
	if s.MinIntPtr != nil && *s.MinIntPtr < 1234 {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "MinIntPtr", "min", errors.New("failed check for min=1234")))
	}
	// END MinIntPtr Validations

	// BEGIN InnerDive Validations
	// dive
	if err := gencheck.Validate(s.InnerDive); err != nil {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "InnerDive", "dive", err))
	}
	// END InnerDive Validations

	// BEGIN InnerDivePtr Validations
	// dive
	if s.InnerDivePtr != nil {
		if err := gencheck.Validate(s.InnerDivePtr); err != nil {
			vErrors = append(vErrors, gencheck.NewFieldError("Test", "InnerDivePtr", "dive", err))
		}
	}
	// END InnerDivePtr Validations

	// BEGIN InnerDiveSlice Validations
	// dive
	for i, e := range s.InnerDiveSlice {
		if err := gencheck.Validate(e); err != nil {
			vErrors = append(vErrors, gencheck.NewFieldError("Test", fmt.Sprintf("InnerDiveSlice[%v]", i), "dive", err))
		}
	}
	// END InnerDiveSlice Validations

	// BEGIN InnerDiveSlicePtr Validations
	// dive
	for i, e := range s.InnerDiveSlicePtr {
		if err := gencheck.Validate(e); err != nil {
			vErrors = append(vErrors, gencheck.NewFieldError("Test", fmt.Sprintf("InnerDiveSlicePtr[%v]", i), "dive", err))
		}
	}
	// END InnerDiveSlicePtr Validations

	// BEGIN InnerDiveMap Validations
	// dive
	for i, e := range s.InnerDiveMap {
		if err := gencheck.Validate(e); err != nil {
			vErrors = append(vErrors, gencheck.NewFieldError("Test", fmt.Sprintf("InnerDiveMap[%v]", i), "dive", err))
		}
	}
	// END InnerDiveMap Validations

	// BEGIN InnerDiveMapPtr Validations
	// dive
	for i, e := range s.InnerDiveMapPtr {
		if err := gencheck.Validate(e); err != nil {
			vErrors = append(vErrors, gencheck.NewFieldError("Test", fmt.Sprintf("InnerDiveMapPtr[%v]", i), "dive", err))
		}
	}
	// END InnerDiveMapPtr Validations

	// BEGIN OtherFileDive Validations
	// dive
	if err := gencheck.Validate(s.OtherFileDive); err != nil {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "OtherFileDive", "dive", err))
	}
	// END OtherFileDive Validations

	// BEGIN OtherFileDivePtr Validations
	// dive
	if s.OtherFileDivePtr != nil {
		if err := gencheck.Validate(s.OtherFileDivePtr); err != nil {
			vErrors = append(vErrors, gencheck.NewFieldError("Test", "OtherFileDivePtr", "dive", err))
		}
	}
	// END OtherFileDivePtr Validations

	// BEGIN OtherFileDiveSlice Validations
	// dive
	for i, e := range s.OtherFileDiveSlice {
		if err := gencheck.Validate(e); err != nil {
			vErrors = append(vErrors, gencheck.NewFieldError("Test", fmt.Sprintf("OtherFileDiveSlice[%v]", i), "dive", err))
		}
	}
	// END OtherFileDiveSlice Validations

	// BEGIN OtherFileDiveSlicePtr Validations
	// dive
	for i, e := range s.OtherFileDiveSlicePtr {
		if err := gencheck.Validate(e); err != nil {
			vErrors = append(vErrors, gencheck.NewFieldError("Test", fmt.Sprintf("OtherFileDiveSlicePtr[%v]", i), "dive", err))
		}
	}
	// END OtherFileDiveSlicePtr Validations

	// BEGIN OtherFileDiveMap Validations
	// dive
	for i, e := range s.OtherFileDiveMap {
		if err := gencheck.Validate(e); err != nil {
			vErrors = append(vErrors, gencheck.NewFieldError("Test", fmt.Sprintf("OtherFileDiveMap[%v]", i), "dive", err))
		}
	}
	// END OtherFileDiveMap Validations

	// BEGIN OtherFileDiveMapPtr Validations
	// dive
	for i, e := range s.OtherFileDiveMapPtr {
		if err := gencheck.Validate(e); err != nil {
			vErrors = append(vErrors, gencheck.NewFieldError("Test", fmt.Sprintf("OtherFileDiveMapPtr[%v]", i), "dive", err))
		}
	}
	// END OtherFileDiveMapPtr Validations

	// BEGIN MapContains Validations
	// contains
	if _, foundMapContains := s.MapContains["key"]; !foundMapContains {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "MapContains", "contains", errors.New("MapContains did not contain key")))
	}
	// END MapContains Validations

	// BEGIN TestString Validations
	// dive
	if err := gencheck.Validate(s.TestString); err != nil {
		vErrors = append(vErrors, gencheck.NewFieldError("Test", "TestString", "dive", err))
	}
	// END TestString Validations

	// BEGIN TestStringPtr Validations
	// dive
	if s.TestStringPtr != nil {
		if err := gencheck.Validate(s.TestStringPtr); err != nil {
			vErrors = append(vErrors, gencheck.NewFieldError("Test", "TestStringPtr", "dive", err))
		}
	}
	// END TestStringPtr Validations

	if len(vErrors) > 0 {
		return vErrors
	}

	return nil
}