feat: Waku v2 bridge

Issue #12610

vendor/github.com/mitchellh/pointerstructure/set.go

@@ -0,0 +1,122 @@
+package pointerstructure
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// Set writes a value v to the pointer p in structure s.
+//
+// The structures s must have non-zero values set up to this pointer.
+// For example, if setting "/bob/0/name", then "/bob/0" must be set already.
+//
+// The returned value is potentially a new value if this pointer represents
+// the root document. Otherwise, the returned value will always be s.
+func (p *Pointer) Set(s, v interface{}) (interface{}, error) {
+	// if we represent the root doc, return that
+	if len(p.Parts) == 0 {
+		return v, nil
+	}
+
+	// Save the original since this is going to be our return value
+	originalS := s
+
+	// Get the parent value
+	var err error
+	s, err = p.Parent().Get(s)
+	if err != nil {
+		return nil, err
+	}
+
+	// Map for lookup of getter to call for type
+	funcMap := map[reflect.Kind]setFunc{
+		reflect.Array: p.setSlice,
+		reflect.Map:   p.setMap,
+		reflect.Slice: p.setSlice,
+	}
+
+	val := reflect.ValueOf(s)
+	for val.Kind() == reflect.Interface {
+		val = val.Elem()
+	}
+
+	for val.Kind() == reflect.Ptr {
+		val = reflect.Indirect(val)
+	}
+
+	f, ok := funcMap[val.Kind()]
+	if !ok {
+		return nil, fmt.Errorf("set %s: %w: %s", p, ErrInvalidKind, val.Kind())
+	}
+
+	result, err := f(originalS, val, reflect.ValueOf(v))
+	if err != nil {
+		return nil, fmt.Errorf("set %s: %w", p, err)
+	}
+
+	return result, nil
+}
+
+type setFunc func(interface{}, reflect.Value, reflect.Value) (interface{}, error)
+
+func (p *Pointer) setMap(root interface{}, m, value reflect.Value) (interface{}, error) {
+	part := p.Parts[len(p.Parts)-1]
+	key, err := coerce(reflect.ValueOf(part), m.Type().Key())
+	if err != nil {
+		return root, err
+	}
+
+	elem, err := coerce(value, m.Type().Elem())
+	if err != nil {
+		return root, err
+	}
+
+	// Set the key
+	m.SetMapIndex(key, elem)
+	return root, nil
+}
+
+func (p *Pointer) setSlice(root interface{}, s, value reflect.Value) (interface{}, error) {
+	// Coerce the value, we'll need that no matter what
+	value, err := coerce(value, s.Type().Elem())
+	if err != nil {
+		return root, err
+	}
+
+	// If the part is the special "-", that means to append it (RFC6901 4.)
+	part := p.Parts[len(p.Parts)-1]
+	if part == "-" {
+		return p.setSliceAppend(root, s, value)
+	}
+
+	// Coerce the key to an int
+	idxVal, err := coerce(reflect.ValueOf(part), reflect.TypeOf(42))
+	if err != nil {
+		return root, err
+	}
+	idx := int(idxVal.Int())
+
+	// Verify we're within bounds
+	if idx < 0 || idx >= s.Len() {
+		return root, fmt.Errorf(
+			"index %d is %w (length = %d)", idx, ErrOutOfRange, s.Len())
+	}
+
+	// Set the key
+	s.Index(idx).Set(value)
+	return root, nil
+}
+
+func (p *Pointer) setSliceAppend(root interface{}, s, value reflect.Value) (interface{}, error) {
+	// Coerce the value, we'll need that no matter what. This should
+	// be a no-op since we expect it to be done already, but there is
+	// a fast-path check for that in coerce so do it anyways.
+	value, err := coerce(value, s.Type().Elem())
+	if err != nil {
+		return root, err
+	}
+
+	// We can assume "s" is the parent of pointer value. We need to actually
+	// write s back because Append can return a new slice.
+	return p.Parent().Set(root, reflect.Append(s, value).Interface())
+}