go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/projects/nodes/pkg/incrutil/map3.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package incrutil

import (
	"context"
	"fmt"

	"github.com/wcharczuk/go-incr"
)

// MapN applies a function to given list of input incrementals and returns
// a new incremental of the output type of that function.
func Map3[A, B, C, D any](scope incr.Scope, fn Map3Func[A, B, C, D]) Map3Incr[A, B, C, D] {
	return incr.WithinScope(scope, &map3Incr[A, B, C, D]{
		n:  incr.NewNode("map3"),
		fn: fn,
	})
}

// Map3Func is the function that the ApplyN incremental applies.
type Map3Func[A, B, C, D any] func(context.Context, A, B, C) (D, error)

// MapNIncr is a type of incremental that can add inputs over time.
type Map3Incr[A, B, C, D any] interface {
	incr.Incr[D]
	ISetInput
	IRemoveInput
	IInputs
	IRawFunction
	ISetRawFunction
	IRawValue
	ISetRawValue
}

var (
	_ incr.Incr[bool]                     = (*map3Incr[int, string, string, bool])(nil)
	_ Map3Incr[int, string, string, bool] = (*map3Incr[int, string, string, bool])(nil)
	_ incr.INode                          = (*map3Incr[int, string, string, bool])(nil)
	_ incr.IStabilize                     = (*map3Incr[int, string, string, bool])(nil)
	_ fmt.Stringer                        = (*map3Incr[int, string, string, bool])(nil)
)

type map3Incr[A, B, C, D any] struct {
	n   *incr.Node
	a   incr.Incr[A]
	b   incr.Incr[B]
	c   incr.Incr[C]
	fn  Map3Func[A, B, C, D]
	val D
}

func (m *map3Incr[A, B, C, D]) Parents() (out []incr.INode) {
	if m.a != nil {
		out = append(out, m.a)
	}
	if m.b != nil {
		out = append(out, m.b)
	}
	if m.c != nil {
		out = append(out, m.c)
	}
	return
}

func (m *map3Incr[A, B, C, D]) RawValue() any {
	return m.val
}

func (m *map3Incr[A, B, C, D]) SetRawValue(value any) error {
	var typed D
	if err := CastAny(value, &typed); err != nil {
		return err
	}
	m.val = typed
	return nil
}

func (m *map3Incr[A, B, C, D]) RawFunction() any {
	return m.fn
}

func (m *map3Incr[A, B, C, D]) Inputs() map[string]incr.INode {
	output := make(map[string]incr.INode)
	if m.a != nil {
		output["a"] = m.a
	}
	if m.b != nil {
		output["b"] = m.b
	}
	if m.c != nil {
		output["c"] = m.c
	}
	return output
}

func (m *map3Incr[A, B, C, D]) SetInput(name string, input incr.INode, _ bool) error {
	if name == "0" || name == "a" {
		typed, ok := input.(incr.Incr[A])
		if !ok {
			return fmt.Errorf("set input; invalid input type for input %v: %T", name, input)
		}
		m.a = typed
		LinkNodes(m, m.a)
		return nil
	} else if name == "1" || name == "b" {
		typed, ok := input.(incr.Incr[B])
		if !ok {
			return fmt.Errorf("set input; invalid input type for input %v: %T", name, input)
		}
		m.b = typed
		LinkNodes(m, m.b)
		return nil
	} else if name == "2" || name == "c" {
		typed, ok := input.(incr.Incr[C])
		if !ok {
			return fmt.Errorf("set input; invalid input type for input %v: %T", name, input)
		}
		m.c = typed
		LinkNodes(m, m.c)
		return nil
	}
	return fmt.Errorf("set input; invalid input name: %v", name)
}

func (m *map3Incr[A, B, C, D]) RemoveInput(name string) error {
	if name == "0" || name == "a" {
		if m.a != nil {
			UnlinkNodes(m, m.a)
			m.a = nil
			return nil
		}
		return fmt.Errorf("remove input; input unset: %v", name)
	} else if name == "1" || name == "b" {
		if m.b != nil {
			UnlinkNodes(m, m.b)
			m.b = nil
			return nil
		}
		return fmt.Errorf("remove input; input unset: %v", name)
	} else if name == "2" || name == "c" {
		if m.c != nil {
			UnlinkNodes(m, m.c)
			m.c = nil
			return nil
		}
		return fmt.Errorf("remove input; input unset: %v", name)
	}
	return fmt.Errorf("remove input; invalid input name: %v", name)
}

func (m *map3Incr[A, B, C, D]) SetRawFunction(fn any) error {
	typed, ok := fn.(Map3Func[A, B, C, D])
	if !ok {
		return fmt.Errorf("invalid function type for map3node: %T", fn)
	}
	m.fn = typed
	return nil
}

func (m *map3Incr[A, B, C, D]) Node() *incr.Node { return m.n }

func (m *map3Incr[A, B, C, D]) Value() D { return m.val }

func (m *map3Incr[A, B, C, D]) Stabilize(ctx context.Context) (err error) {
	var val D

	var mva A
	var mvb B
	var mvc C
	if m.a != nil {
		mva = m.a.Value()
	}
	if m.b != nil {
		mvb = m.b.Value()
	}
	if m.c != nil {
		mvc = m.c.Value()
	}
	val, err = m.fn(ctx, mva, mvb, mvc)
	if err != nil {
		err = fmt.Errorf("%v; %w", m, err)
		return
	}
	m.val = val
	return nil
}

func (m *map3Incr[A, B, C, D]) String() string {
	return m.n.String()
}