bind/scalar.go

package bind

import "reflect"

func bindScalar(receiver reflect.Value, values []any) bool {
	if len(values) == 0 {
		return false
	}

	if !acceptsScalar(receiver.Type()) {
		return false
	}

	if len(values) == 1 {
		receiver = unpackValue(receiver, pointer|iface|slice)
		r := reflect.ValueOf(values[0])
		r = unpackValue(r, pointer|iface|slice)
		v, ok := scan(receiver.Type(), r.Interface())
		if !ok {
			return false
		}

		if !receiver.CanSet() {
			return false
		}

		receiver.Set(reflect.ValueOf(v))
		return true
	}

	receiver = unpackValue(receiver, pointer|iface|anytype)
	if receiver.Kind() != reflect.Slice || receiver.Len() < len(values) {
		return false
	}

	for i := range values {
		if !bindScalar(receiver.Index(i), []any{values[i]}) {
			return false
		}
	}

	return true
}

func bindScalarCreate(t reflect.Type, values []any) (reflect.Value, bool) {
	if len(values) == 0 {
		return reflect.Zero(t), false
	}

	if !acceptsScalar(t) {
		return reflect.Zero(t), false
	}

	receiver, ok := allocate(t, len(values))
	if !ok {
		return reflect.Zero(t), false
	}

	if !bindScalar(receiver, values) {
		return reflect.Zero(t), false
	}

	return receiver, true
}

func bindScalarReflect(receiver any, values []any) bool {
	v := reflect.ValueOf(receiver)
	if hasCircularReference(v) {
		return false
	}

	for _, vi := range values {
		if hasCircularReference(reflect.ValueOf(vi)) {
			return false
		}
	}

	return bindScalar(v, values)
}

func bindScalarCreateReflect[T any](values []any) (T, bool) {
	t := reflect.TypeFor[T]()
	if hasCircularType(t) {
		var tt T
		return tt, false
	}

	for _, vi := range values {
		if hasCircularReference(reflect.ValueOf(vi)) {
			var tt T
			return tt, false
		}
	}

	v, ok := bindScalarCreate(t, values)
	if !ok {
		var tt T
		return tt, false
	}

	return v.Interface().(T), true
}