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

// Code generated by goflow DO NOT EDIT.

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

package main

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

/*

 */
type Ifs struct{}

func NewIfs() Ifs {
	return Ifs{}
}

func newIfs(id string) Ifs {
	return Ifs{}
}

/*

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

	// __print_again_values outputs
	var __print_again_values_aggregated []interface{}

	// __print_values outputs
	var __print_values_aggregated []interface{}

	// __print_void_again_values outputs
	var __print_void_again_values_aggregated []interface{}

	// __print_void_values outputs
	var __print_void_values_aggregated []interface{}

	// print outputs

	// print_again outputs

	// print_void outputs

	// print_void_again outputs

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

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

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

		"__print_again_values": {
			deps: map[string]struct{}{
				igniteNodeID: {},
			},
			run: func() {
				__print_again_values_aggregated = append(__print_again_values_aggregated, "this is printed as well")
				done <- "__print_again_values"
			},
			alreadyDone: false,
		},
		"__print_values": {
			deps: map[string]struct{}{
				igniteNodeID: {},
			},
			run: func() {
				__print_values_aggregated = append(__print_values_aggregated, "this is printed")
				done <- "__print_values"
			},
			alreadyDone: false,
		},
		"__print_void_again_values": {
			deps: map[string]struct{}{
				igniteNodeID: {},
			},
			run: func() {
				__print_void_again_values_aggregated = append(__print_void_again_values_aggregated, "never printed as well")
				done <- "__print_void_again_values"
			},
			alreadyDone: false,
		},
		"__print_void_values": {
			deps: map[string]struct{}{
				igniteNodeID: {},
			},
			run: func() {
				__print_void_values_aggregated = append(__print_void_values_aggregated, "never printed")
				done <- "__print_void_values"
			},
			alreadyDone: false,
		},
		"print": {
			deps: map[string]struct{}{
				"__print_values": {},
				igniteNodeID:     {},
			},
			run: func() {
				nodes.Printer(__print_values_aggregated)
				done <- "print"
			},
			alreadyDone: false,
		},
		"print_again": {
			deps: map[string]struct{}{
				"__print_again_values": {},
				igniteNodeID:           {},
			},
			run: func() {
				if len(numbers.EmptyIntSlice) == 0 {
					nodes.Printer(__print_again_values_aggregated)
				}

				done <- "print_again"
			},
			alreadyDone: false,
		},
		"print_void": {
			deps: map[string]struct{}{
				"__print_void_values": {},
				igniteNodeID:          {},
			},
			run: func() {
				if false {
					nodes.Printer(__print_void_values_aggregated)
				}

				done <- "print_void"
			},
			alreadyDone: false,
		},
		"print_void_again": {
			deps: map[string]struct{}{
				"__print_void_again_values": {},
				igniteNodeID:                {},
			},
			run: func() {
				if len(numbers.EmptyIntSlice) > 0 {
					nodes.Printer(__print_void_again_values_aggregated)
				}

				done <- "print_void_again"
			},
			alreadyDone: false,
		},
		igniteNodeID: {
			deps: map[string]struct{}{},
			run: func() {
				done <- igniteNodeID
			},
			alreadyDone: false,
		},
		doneNodeID: {
			deps: map[string]struct{}{
				"__print_again_values":      {},
				"__print_values":            {},
				"__print_void_again_values": {},
				"__print_void_values":       {},
				"print":                     {},
				"print_again":               {},
				"print_void":                {},
				"print_void_again":          {},
			},
			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
}