public void Invoke(ControlOutput output) { Ensure.That(nameof(output)).IsNotNull(output); var connection = output.connection; if (connection == null) { return; } var input = connection.destination; var recursionNode = new RecursionNode(output, stack); BeforeInvoke(output, recursionNode); var nextPort = InvokeDelegate(input); if (nextPort != null) { Invoke(nextPort); } AfterInvoke(output, recursionNode); }
protected override void Definition() { base.Definition(); finished = ControlOutput("finished"); Succession(enter, finished); }
protected override void Definition() { enter = ControlInput(nameof(enter), Enter); selector = ValueInput <T>(nameof(selector)); Requirement(selector, enter); branches = new List <KeyValuePair <T, ControlOutput> >(); foreach (var option in options) { var key = "%" + option; if (!controlOutputs.Contains(key)) { var branch = ControlOutput(key); branches.Add(new KeyValuePair <T, ControlOutput>(option, branch)); Succession(enter, branch); } } @default = ControlOutput(nameof(@default)); Succession(enter, @default); }
private RecursionNode BeforeInvoke(ControlOutput output, RecursionNode recursionNode) { try { recursion?.Enter(recursionNode); } catch (StackOverflowException ex) { output.unit.HandleException(stack, ex); throw; } var connection = output.connection; var input = connection.destination; if (enableDebug) { var connectionEditorData = stack.GetElementDebugData <IUnitConnectionDebugData>(connection); var inputUnitEditorData = stack.GetElementDebugData <IUnitDebugData>(input.unit); connectionEditorData.lastInvokeFrame = EditorTimeBinding.frame; connectionEditorData.lastInvokeTime = EditorTimeBinding.time; inputUnitEditorData.lastInvokeFrame = EditorTimeBinding.frame; inputUnitEditorData.lastInvokeTime = EditorTimeBinding.time; } return(recursionNode); }
protected override void Definition() { enter = ControlInput("enter", ProcessInternal); exit = ControlOutput("exit"); Succession(enter, exit); }
private IEnumerator Coroutine(ControlOutput startPort) { try { foreach (var instruction in InvokeCoroutine(startPort)) { if (coroutineStopRequested) { yield break; } yield return(instruction); if (coroutineStopRequested) { yield break; } } } finally { // Manual disposal might have already occurred from StopCoroutine, // so we have to avoid double disposal, which would throw. if (!disposed) { Dispose(); } } }
protected override void Definition() { enter = ControlInput(nameof(enter), Enter); exit = ControlOutput(nameof(exit)); Succession(enter, exit); }
protected ControlOutput ControlOutput(string key) { EnsureUniqueOutput(key); var port = new ControlOutput(key); controlOutputs.Add(port); return(port); }
protected override void Definition() { enter = ControlInputCoroutine(nameof(enter), Loop, LoopCoroutine); exit = ControlOutput(nameof(exit)); body = ControlOutput(nameof(body)); Succession(enter, body); Succession(enter, exit); }
protected override void Definition() { enter = ControlInput(nameof(enter), Enter); reset = ControlInput(nameof(reset), Reset); once = ControlOutput(nameof(once)); after = ControlOutput(nameof(after)); Succession(enter, once); Succession(enter, after); }
protected override void Definition() { start = ControlInput(nameof(start), Start); stop = ControlInput(nameof(stop), Stop); started = ControlOutput(nameof(started)); stopped = ControlOutput(nameof(stopped)); Succession(start, started); Succession(stop, stopped); }
protected override void Definition() { enter = ControlInput(nameof(enter), Enter); input = ValueInput <object>(nameof(input)).AllowsNull(); ifNotNull = ControlOutput(nameof(ifNotNull)); ifNull = ControlOutput(nameof(ifNull)); Requirement(input, enter); Succession(enter, ifNotNull); Succession(enter, ifNull); }
protected override void Definition() { enter = ControlInput(nameof(enter), Store); input = ValueInput <object>(nameof(input)); output = ValueOutput <object>(nameof(output)); exit = ControlOutput(nameof(exit)); Requirement(input, enter); Assignment(enter, output); Succession(enter, exit); }
protected override void Definition() { enterTrue = ControlInput("true", ProcessTrue); enterFalse = ControlInput("false", ProcessFalse); exit = ControlOutput("exit"); valueOut = ValueOutput("value", (flow) => m_value); Succession(enterTrue, exit); Succession(enterFalse, exit); }
protected override void Definition() { enter = ControlInput(nameof(enter), Clear); dictionaryInput = ValueInput <IDictionary>(nameof(dictionaryInput)); dictionaryOutput = ValueOutput <IDictionary>(nameof(dictionaryOutput)); exit = ControlOutput(nameof(exit)); Requirement(dictionaryInput, enter); Assignment(enter, dictionaryOutput); Succession(enter, exit); }
protected override void Definition() { enter = ControlInput(nameof(enter), Enter); condition = ValueInput <bool>(nameof(condition)); ifTrue = ControlOutput(nameof(ifTrue)); ifFalse = ControlOutput(nameof(ifFalse)); Requirement(condition, enter); Succession(enter, ifTrue); Succession(enter, ifFalse); }
protected override void Definition() { enter = ControlInput(nameof(enter), Clear); listInput = ValueInput <IList>(nameof(listInput)); listOutput = ValueOutput <IList>(nameof(listOutput)); exit = ControlOutput(nameof(exit)); Requirement(listInput, enter); Assignment(enter, listOutput); Succession(enter, exit); }
protected override void Definition() { enter = ControlInput("enter", Enter); condition = ValueInput <bool>("condition"); ifTrue = ControlOutput("ifTrue"); ifFalse = ControlOutput("ifFalse"); onNext = ControlOutput("onNext"); Relation(enter, ifTrue); Relation(enter, ifFalse); Relation(enter, onNext); Relation(condition, enter); }
protected override void Definition() { enter = ControlInput(nameof(enter), Set); list = ValueInput <IList>(nameof(list)); index = ValueInput(nameof(index), 0); item = ValueInput <object>(nameof(item)); exit = ControlOutput(nameof(exit)); Requirement(list, enter); Requirement(index, enter); Requirement(item, enter); Succession(enter, exit); }
protected override void Definition() { enter = ControlInput(nameof(enter), Set); dictionary = ValueInput <IDictionary>(nameof(dictionary)); key = ValueInput <object>(nameof(key)); value = ValueInput <object>(nameof(value)); exit = ControlOutput(nameof(exit)); Requirement(dictionary, enter); Requirement(key, enter); Requirement(value, enter); Succession(enter, exit); }
private IEnumerable InvokeCoroutine(ControlOutput output) { var connection = output.connection; if (connection == null) { yield break; } var input = connection.destination; var recursionNode = new RecursionNode(output, stack); BeforeInvoke(output, recursionNode); if (input.supportsCoroutine) { foreach (var instruction in InvokeCoroutineDelegate(input)) { if (instruction is ControlOutput) { foreach (var unwrappedInstruction in InvokeCoroutine((ControlOutput)instruction)) { yield return(unwrappedInstruction); } } else { yield return(instruction); } } } else { ControlOutput nextPort = InvokeDelegate(input); if (nextPort != null) { foreach (var instruction in InvokeCoroutine(nextPort)) { yield return(instruction); } } } AfterInvoke(output, recursionNode); }
public void StartCoroutine(ControlOutput port, ICollection <Flow> registry = null) { isCoroutine = true; coroutineRunner = stack.component; if (coroutineRunner == null) { coroutineRunner = CoroutineRunner.instance; } activeCoroutinesRegistry = registry; activeCoroutinesRegistry?.Add(this); // We have to store the enumerator because Coroutine itself // can't be cast to IDisposable, which we'll need when stopping. coroutineEnumerator = Coroutine(port); coroutineRunner.StartCoroutine(coroutineEnumerator); }
protected override void Definition() { enter = ControlInput(nameof(enter), Trigger); exit = ControlOutput(nameof(exit)); name = ValueInput(nameof(name), string.Empty); target = ValueInput <FlowMachine>(nameof(target), flowmachine); arguments = new List <ValueInput>(); for (var i = 0; i < argumentCount; i++) { var argument = ValueInput <object>("argument_" + i); arguments.Add(argument); Relation(argument, enter); } Relation(enter, exit); Relation(name, enter); Relation(target, enter); }
/// <summary> /// Triggering the source may trigger the destination. /// </summary> protected void Succession(ControlInput source, ControlOutput destination) { Relation(source, destination); }
protected void InvokeControlOutput(ControlOutput output) { Flow.New(graphReference)?.Invoke(output); }
private void AfterInvoke(ControlOutput output, RecursionNode recursionNode) { recursion?.Exit(recursionNode); }
public void Run(ControlOutput port) { Invoke(port); Dispose(); }
protected override void Definition() { base.Definition(); inputParameters = new Dictionary <int, ValueInput>(); outputParameters = new Dictionary <int, ValueOutput>(); useExpandedParameters = true; enter = ControlInput(nameof(enter), Enter); exit = ControlOutput(nameof(exit)); Succession(enter, exit); if (member.requiresTarget) { Requirement(target, enter); } if (supportsChaining && chainable) { targetOutput = ValueOutput(member.targetType, nameof(targetOutput)); Assignment(enter, targetOutput); } if (member.isGettable) { result = ValueOutput(member.type, nameof(result), Result); if (member.requiresTarget) { Requirement(target, result); } } var parameterInfos = member.GetParameterInfos().ToArray(); parameterCount = parameterInfos.Length; for (int parameterIndex = 0; parameterIndex < parameterCount; parameterIndex++) { var parameterInfo = parameterInfos[parameterIndex]; var parameterType = parameterInfo.UnderlyingParameterType(); if (!parameterInfo.HasOutModifier()) { var inputParameterKey = "%" + parameterInfo.Name; var inputParameter = ValueInput(parameterType, inputParameterKey); inputParameters.Add(parameterIndex, inputParameter); inputParameter.SetDefaultValue(parameterInfo.PseudoDefaultValue()); if (parameterInfo.AllowsNull()) { inputParameter.AllowsNull(); } Requirement(inputParameter, enter); if (member.isGettable) { Requirement(inputParameter, result); } } if (parameterInfo.ParameterType.IsByRef || parameterInfo.IsOut) { var outputParameterKey = "&" + parameterInfo.Name; var outputParameter = ValueOutput(parameterType, outputParameterKey); outputParameters.Add(parameterIndex, outputParameter); Assignment(enter, outputParameter); useExpandedParameters = false; } } if (inputParameters.Count > 5) { useExpandedParameters = false; } }