go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/projects/nodes/pkg/incrutil/cutoff2.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"
)

// Cutoff returns a new wrapping cutoff incremental.
//
// The goal of the cutoff incremental is to stop recomputation at a given
// node if the difference between the previous and latest values are not
// significant enough to warrant a full recomputation of the children of this node.
func Cutoff2[A, B any](scope incr.Scope, fn Cutoff2Func[A, B]) Cutoff2Incr[A, B] {
	return Cutoff2Context[A, B](scope, func(_ context.Context, input A, oldv, newv B) (bool, error) {
		return fn(input, oldv, newv), nil
	})
}

// CutoffContext returns a new wrapping cutoff incremental.
//
// The goal of the cutoff incremental is to stop recomputation at a given
// node if the difference between the previous and latest values are not
// significant enough to warrant a full recomputation of the children of this node.
func Cutoff2Context[A, B any](scope incr.Scope, fn Cutoff2ContextFunc[A, B]) Cutoff2Incr[A, B] {
	return incr.WithinScope(scope, &cutoff2Incr[A, B]{
		n:  incr.NewNode("cutoff2"),
		fn: fn,
	})
}

// Cutoff2Func is a function that implements cutoff checking.
type Cutoff2Func[A, B any] func(A, B, B) bool

// Cutoff2ContextFunc is a function that implements cutoff checking
// and takes a context.
type Cutoff2ContextFunc[A, B any] func(context.Context, A, B, B) (bool, error)

// CutoffIncr is an incremental node that implements the ICutoff interface.
type Cutoff2Incr[A, B any] interface {
	incr.Incr[B]
	incr.IStabilize
	incr.ICutoff
	ISetInput
	IRemoveInput
	IInputs
	IRawValue
	ISetRawValue
	IRawFunction
	ISetRawFunction
}

var (
	_ incr.Incr[string]        = (*cutoff2Incr[int, string])(nil)
	_ Cutoff2Incr[int, string] = (*cutoff2Incr[int, string])(nil)
	_ incr.IStabilize          = (*cutoff2Incr[int, string])(nil)
	_ incr.ICutoff             = (*cutoff2Incr[int, string])(nil)
	_ fmt.Stringer             = (*cutoff2Incr[int, string])(nil)
)

// cutoffIncr is a concrete implementation of Incr for
// the cutoff operator.
type cutoff2Incr[A, B any] struct {
	n       *incr.Node
	epsilon incr.Incr[A]
	input   incr.Incr[B]
	value   B
	fn      Cutoff2ContextFunc[A, B]
}

func (c *cutoff2Incr[A, B]) Parents() (out []incr.INode) {
	if c.input != nil {
		out = append(out, c.input)
	}
	if c.epsilon != nil {
		out = append(out, c.epsilon)
	}
	return
}

func (c *cutoff2Incr[A, B]) Value() B {
	return c.value
}

func (c *cutoff2Incr[A, B]) Stabilize(ctx context.Context) error {
	c.value = c.input.Value()
	return nil
}

func (c *cutoff2Incr[A, B]) Cutoff(ctx context.Context) (bool, error) {
	cutoff, err := c.fn(ctx, c.epsilon.Value(), c.value, c.input.Value())
	if err != nil {
		return cutoff, fmt.Errorf("%v; %w", c, err)
	}
	return cutoff, err
}

func (c *cutoff2Incr[A, B]) Node() *incr.Node {
	return c.n
}

func (c *cutoff2Incr[A, B]) String() string { return c.n.String() }

func (c *cutoff2Incr[A, B]) Inputs() map[string]incr.INode {
	output := make(map[string]incr.INode)
	if c.epsilon != nil {
		output["epsilon"] = c.epsilon
	}
	if c.input != nil {
		output["input"] = c.input
	}
	return output
}

func (c *cutoff2Incr[A, B]) SetInput(name string, input incr.INode, _ bool) error {
	if name == "epsilon" {
		typed, ok := input.(incr.Incr[A])
		if !ok {
			return fmt.Errorf("invalid input type for input 0: %T", input)
		}
		c.epsilon = typed
		LinkNodes(c, c.epsilon)
		return nil
	}
	if name == "input" {
		typed, ok := input.(incr.Incr[B])
		if !ok {
			return fmt.Errorf("invalid input type for input 0: %T", input)
		}
		c.input = typed
		LinkNodes(c, c.input)
		return nil
	}
	return fmt.Errorf("invalid input name: %v", name)
}

func (c *cutoff2Incr[A, B]) RemoveInput(name string) error {
	if name == "epsilon" {
		if c.epsilon != nil {
			UnlinkNodes(c, c.epsilon)
			c.epsilon = nil
			return nil
		}
		return fmt.Errorf("remove input; epsilon is unset")
	}
	if name == "input" {
		if c.input != nil {
			UnlinkNodes(c, c.input)
			c.input = nil
			return nil
		}
		return fmt.Errorf("remove input; input is unset")
	}
	return fmt.Errorf("invalid input name: %v", name)
}

func (c *cutoff2Incr[A, B]) RawFunction() any {
	return c.fn
}

func (c *cutoff2Incr[A, B]) SetRawFunction(fn any) error {
	switch typed := fn.(type) {
	case Cutoff2ContextFunc[A, B]:
		c.fn = typed
		return nil
	case Cutoff2Func[A, B]:
		c.fn = func(_ context.Context, i A, old, new B) (bool, error) {
			return typed(i, old, new), nil
		}
		return nil
	default:
		return fmt.Errorf("invalid function type for node: %T", fn)
	}
}

func (c *cutoff2Incr[A, B]) RawValue() (output any) {
	return c.value
}

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