github.com/alkemics/goflow@v0.2.1/wrappers/gonodes/graph/gonodes.go

// Code generated by goflow DO NOT EDIT.

//go:build !codeanalysis
// +build !codeanalysis

package main

import (
	"github.com/alkemics/goflow/example/nodes"
)

/*

 */
type GoNodes struct{ debug bool }

func NewGoNodes(debug bool) GoNodes {
	return GoNodes{
		debug: debug,
	}
}

func newGoNodes(id string, debug bool) GoNodes {
	return GoNodes{
		debug: debug,
	}
}

/*

 */
func (g *GoNodes) Run() {

	// __add_slice_list outputs
	var __add_slice_list_aggregated []int

	// __print_values outputs
	var __print_values_aggregated []interface{}

	// add_slice outputs
	var add_slice_sum int

	// make_slice outputs
	var make_slice_list []int

	// print outputs

	igniteNodeID := "ignite"
	doneNodeID := "done"

	done := make(chan string)
	defer close(done)

	steps := map[string]struct {
		deps        map[string]struct{}
		run         func()
		alreadyDone bool
	}{

		"__add_slice_list": {
			deps: map[string]struct{}{
				"make_slice": {},
				igniteNodeID: {},
			},
			run: func() {
				__add_slice_list_aggregated = make_slice_list
				done <- "__add_slice_list"
			},
			alreadyDone: false,
		},
		"__print_values": {
			deps: map[string]struct{}{
				"add_slice":  {},
				igniteNodeID: {},
			},
			run: func() {
				__print_values_aggregated = append(__print_values_aggregated, add_slice_sum)
				done <- "__print_values"
			},
			alreadyDone: false,
		},
		"add_slice": {
			deps: map[string]struct{}{
				"__add_slice_list": {},
				igniteNodeID:       {},
			},
			run: func() {
				node := nodes.NewIntReducer(g.debug)
				add_slice_sum = node.Add(__add_slice_list_aggregated)
				done <- "add_slice"
			},
			alreadyDone: false,
		},
		"make_slice": {
			deps: map[string]struct{}{
				igniteNodeID: {},
			},
			run: func() {
				make_slice_list = nodes.SliceMaker()
				done <- "make_slice"
			},
			alreadyDone: false,
		},
		"print": {
			deps: map[string]struct{}{
				"__print_values": {},
				igniteNodeID:     {},
			},
			run: func() {
				nodes.Printer(__print_values_aggregated)
				done <- "print"
			},
			alreadyDone: false,
		},
		igniteNodeID: {
			deps: map[string]struct{}{},
			run: func() {
				done <- igniteNodeID
			},
			alreadyDone: false,
		},
		doneNodeID: {
			deps: map[string]struct{}{
				"__add_slice_list": {},
				"__print_values":   {},
				"add_slice":        {},
				"make_slice":       {},
				"print":            {},
			},
			run: func() {
				done <- doneNodeID
			},
			alreadyDone: false,
		},
	}

	// Ignite
	ignite := steps[igniteNodeID]
	ignite.alreadyDone = true
	steps[igniteNodeID] = ignite
	go steps[igniteNodeID].run()

	// Resolve the graph
	for resolved := range done {
		if resolved == doneNodeID {
			// If all the graph was resolved, get out of the loop
			break
		}

		for name, step := range steps {
			delete(step.deps, resolved)
			if len(step.deps) == 0 && !step.alreadyDone {
				step.alreadyDone = true
				steps[name] = step
				go step.run()
			}
		}
	}

	return
}