mirror of
https://github.com/moby/moby.git
synced 2026-07-13 02:52:20 +00:00
b453aa65fa
commit a0807e7cfe configured golangci-lint
to use go1.23 semantics, which alowed linters like `copyloopvar` to lint
using thee correct semantics.
go1.22 now creates a copy of variables when assigned in a loop; make sure we
don't have files that may downgrade semantics to go1.21 in case that also means
disabling that feature; https://go.dev/ref/spec#Go_1.22
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
87 lines
2.7 KiB
Go
87 lines
2.7 KiB
Go
// FIXME(thaJeztah): remove once we are a module; the go:build directive prevents go from downgrading language version to go1.16:
|
|
//go:build go1.22
|
|
|
|
// Package options provides a way to pass unstructured sets of options to a
|
|
// component expecting a strongly-typed configuration structure.
|
|
package options
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
)
|
|
|
|
// NoSuchFieldError is the error returned when the generic parameters hold a
|
|
// value for a field absent from the destination structure.
|
|
type NoSuchFieldError struct {
|
|
Field string
|
|
Type string
|
|
}
|
|
|
|
func (e NoSuchFieldError) Error() string {
|
|
return fmt.Sprintf("no field %q in type %q", e.Field, e.Type)
|
|
}
|
|
|
|
// CannotSetFieldError is the error returned when the generic parameters hold a
|
|
// value for a field that cannot be set in the destination structure.
|
|
type CannotSetFieldError struct {
|
|
Field string
|
|
Type string
|
|
}
|
|
|
|
func (e CannotSetFieldError) Error() string {
|
|
return fmt.Sprintf("cannot set field %q of type %q", e.Field, e.Type)
|
|
}
|
|
|
|
// TypeMismatchError is the error returned when the type of the generic value
|
|
// for a field mismatches the type of the destination structure.
|
|
type TypeMismatchError struct {
|
|
Field string
|
|
ExpectType string
|
|
ActualType string
|
|
}
|
|
|
|
func (e TypeMismatchError) Error() string {
|
|
return fmt.Sprintf("type mismatch, field %s require type %v, actual type %v", e.Field, e.ExpectType, e.ActualType)
|
|
}
|
|
|
|
// Generic is a basic type to store arbitrary settings.
|
|
type Generic map[string]any
|
|
|
|
// GenerateFromModel takes the generic options, and tries to build a new
|
|
// instance of the model's type by matching keys from the generic options to
|
|
// fields in the model.
|
|
//
|
|
// The return value is of the same type than the model (including a potential
|
|
// pointer qualifier).
|
|
func GenerateFromModel(options Generic, model interface{}) (interface{}, error) {
|
|
modType := reflect.TypeOf(model)
|
|
|
|
// If the model is of pointer type, we need to dereference for New.
|
|
resType := reflect.TypeOf(model)
|
|
if modType.Kind() == reflect.Ptr {
|
|
resType = resType.Elem()
|
|
}
|
|
|
|
// Populate the result structure with the generic layout content.
|
|
res := reflect.New(resType)
|
|
for name, value := range options {
|
|
field := res.Elem().FieldByName(name)
|
|
if !field.IsValid() {
|
|
return nil, NoSuchFieldError{name, resType.String()}
|
|
}
|
|
if !field.CanSet() {
|
|
return nil, CannotSetFieldError{name, resType.String()}
|
|
}
|
|
if reflect.TypeOf(value) != field.Type() {
|
|
return nil, TypeMismatchError{name, field.Type().String(), reflect.TypeOf(value).String()}
|
|
}
|
|
field.Set(reflect.ValueOf(value))
|
|
}
|
|
|
|
// If the model is not of pointer type, return content of the result.
|
|
if modType.Kind() == reflect.Ptr {
|
|
return res.Interface(), nil
|
|
}
|
|
return res.Elem().Interface(), nil
|
|
}
|