public Take(IGraphRuntime runtime) : base(runtime) { this.inputPin = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never); this.countPin = AddInputPin("Count", PinDataTypeFactory.CreateInt32(5), PropertyMode.Default); this.outputPin = AddOutputPin("Output", PinDataTypeFactory.FromType(typeof(ISequence <>))); this.inputPin.WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType => { var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault(); if (genericType != null) { genericDelegate = new GenericDelegate <Func <object, object, object> >(this, EvaluateInternalAttribute.GetMethod(GetType()).MakeGenericMethod(genericType)); } else { genericDelegate = null; } outputPin.ChangeType(pinDataType); }); }); }
public Where(IGraphRuntime runtime) : base(runtime, false, PinDataTypeFactory.Create <bool>(), SUBGRAPH_SOURCE_PIN_ID) { this.inputPin = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never); this.outputPin = AddOutputPin("Output", PinDataTypeFactory.Create <ISequence <object> >()); this.subGraphSource = ((GenericOutputPin)this.subGraphInputModule.Outputs[SUBGRAPH_SOURCE_PIN_ID]); this.subGraphResult = this.SubGraph.OutputModule.DefaultInputPin; this.inputPin.WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType => { var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault() ?? typeof(object); subGraphSource.ChangeType(PinDataTypeFactory.FromType(genericType)); var outputType = PinDataTypeFactory.FromType(typeof(ISequence <>).MakeGenericType(genericType)); if (outputPin.DataType.UnderlyingType != outputType.UnderlyingType) { outputPin.ChangeType(outputType); } genericDelegate = new GenericDelegate <Func <object, object, object> >(this, EvaluateInternalAttribute.GetMethod(GetType()).MakeGenericMethod(genericType)); }); }); }
public ViewCurrent(IGraphRuntime runtime) : base(runtime, ModuleKind.ViewModule) { this.inputPin = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(ISequence <string>), string.Empty, WellKnownEditors.Hidden, null, null), PropertyMode.Never); this.data = AddInputPin("data", PinDataTypeFactory.CreateString(), PropertyMode.Always); EnableVirtualOutputPin(); }
private static IPinDataType CreateTargetPinDataType(ConvertTypeCode typeCode) { switch (typeCode) { case ConvertTypeCode.Any: return(PinDataTypeFactory.CreateAny());; case ConvertTypeCode.Boolean: return(PinDataTypeFactory.CreateBoolean()); case ConvertTypeCode.Byte: return(PinDataTypeFactory.FromType(typeof(byte))); case ConvertTypeCode.Int16: return(PinDataTypeFactory.FromType(typeof(short))); case ConvertTypeCode.Int32: return(PinDataTypeFactory.CreateInt32()); case ConvertTypeCode.Int64: return(PinDataTypeFactory.FromType(typeof(long))); case ConvertTypeCode.Float32: return(PinDataTypeFactory.FromType(typeof(float))); case ConvertTypeCode.Float64: return(PinDataTypeFactory.FromType(typeof(double))); case ConvertTypeCode.String: return(PinDataTypeFactory.CreateString()); } return(PinDataTypeFactory.Create <object>()); }
public SequenceToArray(IGraphRuntime runtime) : base(runtime, ModuleKind.Module, DisplayMode.Collapsed) { this.inputPin = AddInputPin("Sequence", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Allow); this.outputPin = AddOutputPin("Array", PinDataTypeFactory.FromType(typeof(object[]))); this.inputPin.WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType => { var method = EvaluateInternalAttribute.GetMethod(GetType()).MakeGenericMethod(pinDataType.UnderlyingType); var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault() ?? pinDataType.UnderlyingType; if (genericType != null) { genericDelegate = new GenericDelegate <Func <object, object> >(this, EvaluateInternalAttribute.GetMethod(GetType()).MakeGenericMethod(genericType)); } else { genericDelegate = null; } outputPin.ChangeType(PinDataTypeFactory.FromType(genericType.MakeArrayType())); }); }); }
public Cast(IGraphRuntime runtime) : base(runtime) { this.inputPin = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never); this.targetTypePin = AddInputPin("TargetType", PinDataTypeFactory.CreateEnum <ConvertTypeCode>(ConvertTypeCode.Float64), PropertyMode.Always); this.outputPin = AddOutputPin("Output", PinDataTypeFactory.FromType(typeof(ISequence <>))); this.outputPin.ChangeType(CreateTargetPinDataType(ConvertTypeCode.Float64)); this.inputPin.WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType => { var genericInputType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault(); var genericOutputType = outputPin.DataType.UnderlyingType.GenericTypeArguments.FirstOrDefault(); BuildGenericDelegate(genericInputType, genericOutputType); }); }); this.properties[targetTypePin.Id].WhenNodeEvent.OfType <PropertyChangedEvent>().Subscribe(x => { var targetTypeCode = (ConvertTypeCode)x.Value.Value; IPinDataType targetPinDataType = CreateTargetPinDataType(targetTypeCode); var errors = outputPin.ChangeType(targetPinDataType); if (errors.Any()) { throw new AggregateException("One or more connections could not be reestablished after a data type change.", errors); } var genericInputType = inputPin.DataType.UnderlyingType.GenericTypeArguments.FirstOrDefault(); var genericOutputType = outputPin.DataType.UnderlyingType.GenericTypeArguments.FirstOrDefault(); BuildGenericDelegate(genericInputType, genericOutputType); }); }
public Aggregate(IGraphRuntime runtime) : base(runtime, false, SUBGRAPH_SOURCE_PIN_ID, SUBGRAPH_ACCUMULATE_PIN_ID) { this.sourceInput = AddInputPin("Source", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never); this.seedInput = AddInputPin("Seed", PinDataTypeFactory.CreateAny(), PropertyMode.Allow); this.output = AddOutputPin("Output", PinDataTypeFactory.CreateAny()); this.subGraphInput = ((GenericOutputPin)this.subGraphInputModule.Outputs[SUBGRAPH_SOURCE_PIN_ID]); this.subGraphAccumulate = (GenericOutputPin)this.subGraphInputModule.Outputs[SUBGRAPH_ACCUMULATE_PIN_ID]; this.subGraphOutput = subGraph.OutputModule.DefaultInputPin; this.sourceInput.WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType => { var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault() ?? typeof(object); subGraphInput.ChangeType(PinDataTypeFactory.FromType(genericType)); BuildGenericDelegate(); }); }); this.seedInput.WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.CreateAny(), false, pinDataType => { subGraphAccumulate.ChangeType(pinDataType); output.ChangeType(pinDataType); subGraphOutput.ChangeType(pinDataType); BuildGenericDelegate(); }); }); }
private bool OnDynamicInputAdd(string id) { dynamicInputPin.Pin(id).WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType => { var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault() ?? typeof(object); var pinEvent = (PinConnectionChangeEvent)evt; // subgraph input var pin = SubGraph.InputModule.Outputs.Where(x => x.Id == pinEvent.Source.Id).OfType <IDataTypeChangeable>().FirstOrDefault(); pin.ChangeType(PinDataTypeFactory.FromType(genericType)); }); }); try { addingSubGraphPin = true; return(SubGraph.InputModule.AddModulePin(id, true, PinDataTypeFactory.CreateAny()) != null); } finally { addingSubGraphPin = false; } }
private bool OnDynamicInputAdd(string id) { return(dynamicInputPin.Pin(id).WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType => { var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault(); if (genericType != null) { genericDelegate = new GenericDelegate <Func <object, object> >(this, EvaluateInternalAttribute.GetMethod(GetType()).MakeGenericMethod(genericType)); } else { genericDelegate = null; } var pinsToChange = dynamicInputPin.Pins.Where(x => x.Id != id && x.DataType.UnderlyingType != pinDataType.UnderlyingType).OfType <IDataTypeChangeable>(); foreach (var pin in pinsToChange) { pin.ChangeType(pinDataType); } if (!pinsToChange.Any()) { outputPin.ChangeType(pinDataType); } }); }) != null); }
public SelectMany(IGraphRuntime runtime) : base(runtime, false, PinDataTypeFactory.FromType(typeof(ISequence <>)), SUBGRAPH_SOURCE_PIN_ID) { this.inputPin = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never); this.sequentialPin = AddInputPin("Sequential", PinDataTypeFactory.Create <bool>(true), PropertyMode.Default); this.outputPin = AddOutputPin("Output", PinDataTypeFactory.Create <ISequence <object> >()); this.maxConcurrencyPin = AddInputPin("MaxConcurrency", PinDataTypeFactory.Create <int>(8), PropertyMode.Default); this.subGraphSource = ((GenericOutputPin)this.subGraphInputModule.Outputs[SUBGRAPH_SOURCE_PIN_ID]); this.subGraphResult = this.SubGraph.OutputModule.DefaultInputPin; this.inputPin.WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType => { var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault() ?? typeof(object); subGraphSource.ChangeType(PinDataTypeFactory.FromType(genericType)); BuildGenericDelegate(); }); }); this.subGraphResult.WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType => { outputPin.ChangeType(pinDataType); BuildGenericDelegate(); }); }); }
public Broadcast(IGraphRuntime runtime) : base(runtime) { this.inputPin = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never); this.dynamicOutputPin = new DynamicOutputPin(runtime, outputs, "Output", PinDataTypeFactory.FromType(typeof(ISequence <>))); this.inputPin.WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType => { var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault(); if (genericType != null) { genericDelegate = new GenericDelegate <Func <object, object[]> >(this, EvaluateInternalAttribute.GetMethod(GetType()).MakeGenericMethod(genericType)); } else { genericDelegate = null; } foreach (var pin in dynamicOutputPin.Pins.OfType <IDataTypeChangeable>()) { pin.ChangeType(pinDataType); } }); }); }
public CreateArray(IGraphRuntime runtime) : base(runtime) { this.dynamicInputPin = new DynamicInputPin(runtime, inputs, "Input", PinDataTypeFactory.CreateAny(), OnDynamicInputAdd) { ForceAutoId = true }; this.output = AddOutputPin("Output", PinDataTypeFactory.FromType(typeof(Array))); }
public Merge(IGraphRuntime runtime) : base(runtime) { this.dynamicInputPin = new DynamicInputPin(runtime, inputs, "Input", PinDataTypeFactory.FromType(typeof(ISequence <>)), OnDynamicInputAdd) { Renameable = true }; this.outputPin = AddOutputPin("Output", PinDataTypeFactory.FromType(typeof(ISequence <>))); }
public SequenceEqual(IGraphRuntime runtime) : base(runtime) { this.firstInputPin = AddInputPin("First", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never); this.secondInputPin = AddInputPin("Second", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never); this.outputPin = AddOutputPin("Result", PinDataTypeFactory.CreateBoolean()); this.firstInputPin.WhenNodeEvent.Subscribe(HandleInputPinEvent); this.secondInputPin.WhenNodeEvent.Subscribe(HandleInputPinEvent); }
public void BuildOutputPins(Type itemType) { if (itemType == this.itemType) { return; } // do not fall back to object when we have build pins for another type before // (most likely the drop back to object is due to a disconnect and we do not want to loose all existing connections) if (itemType == typeof(object) && itemPropertyPins.Count > 0) { return; } var oldConnections = new Dictionary <string, IPin[]>(); // remove all outputs foreach (var itemPropertiesPin in itemPropertyPins) { oldConnections.Add(itemPropertiesPin.Id, itemPropertiesPin.Connections.Select(x => x.Remote).ToArray()); itemPropertiesPin.DisconnectAll(); outputs.Remove(itemPropertiesPin); } itemPropertyPins.Clear(); var itemProperties = itemType.GetProperties(BINDING_FLAGS).Where(p => p.GetIndexParameters().Length == 0); if (itemProperties.Any()) { // add one output pin for every property foreach (var property in itemProperties) { if (this.itemPropertyPins.Any(p => p.Id == property.Name)) { continue; } var pin = AddOutputPin(property.Name, PinDataTypeFactory.FromType(property.PropertyType)); this.itemPropertyPins.Add(pin); // try to reestablish exsting connections RestorePinConnection(pin, oldConnections); } } else { // add a single pin for items without properties this.itemPropertyPins.Add(AddOutputPin(itemType.Name, PinDataTypeFactory.FromType(itemType))); } // store current type in property this.ItemTypeName = itemType.AssemblyQualifiedName; this.itemType = itemType; }
public Count(IGraphRuntime runtime) : base(runtime) { this.inputPin = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never); this.outputPin = AddOutputPin("Output", PinDataTypeFactory.CreateInt32()); this.inputPin.WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true); }); }
public GetValuesFromArray(IGraphRuntime runtime) : base(runtime) { this.AddInputPin(COUNT_PIN_NAME, PinDataTypeFactory.FromType(typeof(int)), PropertyMode.Always); this.AddInputPin("array", PinDataTypeFactory.FromType(typeof(Array)), PropertyMode.Never); this.AddOutputPin("OutputRemainings", PinDataTypeFactory.FromType(typeof(Array))); this.dynamicOutputPin = new DynamicOutputPin(runtime, outputs, "Output", PinDataTypeFactory.Create <object>()); this.properties[COUNT_PIN_NAME] .WhenNodeEvent .OfType <PropertyChangedEvent>() .Subscribe(x => UpdateOutputs((int)x.Value.Value)); }
public ToSequence(IGraphRuntime runtime) : base(runtime) { this.inputPin = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(IEnumerable <>)), PropertyMode.Never); this.outputPin = AddOutputPin("Output", PinDataTypeFactory.FromType(typeof(ISequence <>))); this.inputPin.WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(IEnumerable <>)), false, pinDataType => { var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault() ?? typeof(object); outputPin.ChangeType(PinDataTypeFactory.FromType(typeof(ISequence <>).MakeGenericType(genericType))); }); }); }
public ForEach(IGraphRuntime runtime) : base(runtime, false, (IPinDataType)null, SUBGRAPH_SOURCE_PIN_ID) { this.inputPin = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never); this.subGraphSource = ((GenericOutputPin)this.subGraphInputModule.Outputs[SUBGRAPH_SOURCE_PIN_ID]); this.inputPin.WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType => { var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault() ?? typeof(object); subGraphSource.ChangeType(PinDataTypeFactory.FromType(genericType)); }); }); }
public Return(IGraphRuntime runtime) : base(runtime) { this.inputPin = AddInputPin("Value", PinDataTypeFactory.CreateAny(), PropertyMode.Allow); this.outputPin = AddOutputPin("Sequence", PinDataTypeFactory.Create <ISequence <object> >()); this.inputPin.WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.CreateAny(), false, pinDataType => { var method = EvaluateInternalAttribute.GetMethod(GetType()).MakeGenericMethod(pinDataType.UnderlyingType); genericDelegate = new GenericDelegate <Func <object, object> >(this, method); outputPin.ChangeType(PinDataTypeFactory.FromType(typeof(ISequence <>).MakeGenericType(pinDataType.UnderlyingType))); }); }); }
public ForceType(IGraphRuntime runtime) : base(runtime) { this.input = AddInputPin("Input", PinDataTypeFactory.CreateAny(), PropertyMode.Never); this.output = AddOutputPin("Output", PinDataTypeFactory.CreateAny()); this.type = AddInputPin("Type", PinDataTypeFactory.CreateString("System.Object"), PropertyMode.Always); this.properties[this.type.Id].WhenNodeEvent.OfType <PropertyChangedEvent>().Subscribe(x => { var genericInputType = Type.GetType((string)x.Value.Value, false, true) ?? typeof(object); var dataType = PinDataTypeFactory.FromType(genericInputType); var errors = input.ChangeType(dataType).Concat(output.ChangeType(dataType)); if (errors.Any()) { throw new AggregateException("One or more connections could not be reestablished after a data type change.", errors); } }); }
public ConverterModule(IGraphRuntime runtime) : base(runtime) { converterByName.Add("None", null); foreach (var c in runtime.TypeConverters) { string sourceTypeName = GetShortTypeName(c.SourceType); string destinationTypeName = GetShortTypeName(c.DestinationType); var converterName = string.Concat(sourceTypeName, " -> ", destinationTypeName); if (!converterByName.ContainsKey(converterName)) { converterByName.Add(converterName, c); } } this.inputPin = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(object)), PropertyMode.Never); this.converterPin = AddInputPin("Converter", PinDataTypeFactory.CreateDynamicEnum(converterByName.Keys.ToArray(), "None"), PropertyMode.Always); this.outputPin = AddOutputPin("Output", PinDataTypeFactory.FromType(typeof(object))); this.properties[converterPin.Id].WhenNodeEvent.OfType <PropertyChangedEvent>().Subscribe(x => { var converterName = (string)x.Value.Value; converterByName.TryGetValue(converterName, out typeConverter); IPinDataType sourceType, destinationType; if (typeConverter == null) { sourceType = PinDataTypeFactory.CreateAny(); destinationType = PinDataTypeFactory.CreateAny(); } else { sourceType = typeConverter.SourceType != null ? PinDataTypeFactory.FromType(typeConverter.SourceType) : PinDataTypeFactory.CreateAny(); destinationType = typeConverter.DestinationType != null ? PinDataTypeFactory.FromType(typeConverter.DestinationType) : PinDataTypeFactory.CreateAny(); } var errors = inputPin.ChangeType(sourceType).Concat(outputPin.ChangeType(destinationType)); if (errors.Any()) { throw new AggregateException("One or more connections could not be reestablished after a data type change.", errors); } }); }
public Any(IGraphRuntime runtime) : base(runtime, false, PinDataTypeFactory.Create <bool>(), SUBGRAPH_SOURCE_PIN_ID) { this.input = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never); this.output = AddOutputPin("Output", PinDataTypeFactory.CreateBoolean()); this.subGraphInput = ((GenericOutputPin)this.subGraphInputModule.Outputs[SUBGRAPH_SOURCE_PIN_ID]); this.input.WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType => { var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault() ?? typeof(object); subGraphInput.ChangeType(PinDataTypeFactory.FromType(genericType)); BuildGenericDelegate(); }); }); }
private bool OnDynamicInputAdd(string id) { return(dynamicInputPin.Pin(id).WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.CreateAny(), false, pinDataType => { var dataType = pinDataType.UnderlyingType; this.outputType = dataType; var count = this.dynamicInputPin.Count; var outputType = Array.CreateInstance(dataType, count).GetType(); this.output.ChangeType(PinDataTypeFactory.FromType(outputType)); if (dataType != null) { genericDelegate = new GenericDelegate <Func <object, object> >(this, EvaluateInternalAttribute.GetMethod(GetType()).MakeGenericMethod(dataType)); } else { genericDelegate = null; } }); }) != null); }
public ReadableToV(IGraphRuntime runtime) : base(runtime) { this.targetTypePin = AddInputPin("TargetType", PinDataTypeFactory.CreateEnum <ConvertTypeCode>(ConvertTypeCode.Float64), PropertyMode.Always); this.outputPin = AddOutputPin("Output", PinDataTypeFactory.FromType(typeof(V <>))); this.outputPin.ChangeType(CreateTargetPinDataType(ConvertTypeCode.Float64)); this.data = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(IReadable)), PropertyMode.Allow); this.delimiter = AddInputPin("Delimiter", PinDataTypeFactory.FromType(typeof(char), ','), PropertyMode.Default); this.properties[targetTypePin.Id].WhenNodeEvent.OfType <PropertyChangedEvent>().Subscribe(x => { var targetTypeCode = (ConvertTypeCode)x.Value.Value; IPinDataType targetPinDataType = CreateTargetPinDataType(targetTypeCode); var errors = outputPin.ChangeType(targetPinDataType); if (errors.Any()) { throw new AggregateException("One or more connections could not be reestablished after a data type change.", errors); } }); var del = (char)this.Properties.GetValue("Delimiter"); }
public Zip(IGraphRuntime runtime) : base(runtime, true) { this.dynamicInputPin = new DynamicInputPin( runtime, inputs, "Input", PinDataTypeFactory.FromType(typeof(ISequence <>)), OnDynamicInputAdd, id => SubGraph.InputModule.RemoveModulePin(id) ); this.outputPin = AddOutputPin("Output", PinDataTypeFactory.FromType(typeof(ISequence <object>))); this.subGraphResult = this.SubGraph.OutputModule.DefaultInputPin; this.subGraphResult.WhenNodeEvent.Subscribe(evt => { PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.CreateAny(), false, pinDataType => { this.genericDelegate = new GenericDelegate <Func <object, object, object> >(this, EvaluateInternalAttribute.GetMethod(GetType()).MakeGenericMethod(pinDataType.UnderlyingType)); this.outputPin.ChangeType(PinDataTypeFactory.FromType(typeof(ISequence <>).MakeGenericType(pinDataType.UnderlyingType))); }); }); }
protected virtual void UpdateSignature() { if (this.Graph == null) // file path resolving only possible when module is attached to graph { return; } logger.LogInformation("UpdateSignature"); lock (gate) { PySignature signature = null; // when there is no script available var src = this.GetScript(); if (string.IsNullOrEmpty(src)) { // there are no arguments signature = new PySignature(); this.Script = null; SetParserError(null); } else { mainThread.RunSync(() => { using (PyScope ps = Py.CreateScope()) { PyObject script = PythonEngine.Compile(src, filename ?? "", mode); ps.Execute(script); signature = PySignature.GetSignature(ps, this.FunctionName); this.Script = script; } }); this.SetParserError(null); } try { this.signature = signature; // remove all argument pins that no longer exist var unusedPins = argumentPins.Where(pin => !signature.HasArgument(pin.Id)).ToArray(); foreach (var unusedPin in unusedPins) { unusedPin.DisconnectAll(); argumentPins.Remove(unusedPin); logger.LogInformation($"Removing input pin: {unusedPin.Id}"); inputs.Remove(unusedPin); } foreach (var arg in signature.Arguments) { var existingPin = argumentPins.FirstOrDefault(x => x.Id == arg.Name); if (existingPin == null) { var newPin = this.AddInputPin(arg.Name, PinDataTypeFactory.FromType(arg.Type), PropertyMode.Allow); argumentPins.Add(newPin); } else { // check type if (existingPin.DataType.UnderlyingType != arg.Type) { existingPin.ChangeType(PinDataTypeFactory.FromType(arg.Type)); } } } // get all pin ids which are not member of this dynamic pin collection var nonDynamicPinIds = this.inputs.Where(x => !argumentPins.Contains(x)).Select(x => x.ObjectId); // reorder module input pins var orderedArgumentPinObjectIds = signature.Arguments.Select(x => argumentPins.First(y => y.Id == x.Name).ObjectId); var newOrder = nonDynamicPinIds.Concat(orderedArgumentPinObjectIds).ToArray(); this.inputs.Reorder(newOrder); // analyse return type of script Type[] returnTypes; if (signature.ReturnType == null) { returnTypes = new Type[0]; } else if (TypeHelpers.IsTuple(signature.ReturnType)) { returnTypes = TypeHelpers.GetTupleTypes(signature.ReturnType); } else { returnTypes = new Type[] { signature.ReturnType }; } // remove pins that are not needed anymore while (resultPins.Count > returnTypes.Length) { var last = resultPins[resultPins.Count - 1]; logger.LogInformation($"Removing output pin: {last.Id}"); last.DisconnectAll(); outputs.Remove(last); resultPins.RemoveAt(resultPins.Count - 1); } for (int i = 0; i < returnTypes.Length; i++) { if (i < resultPins.Count) { var existingPin = resultPins[i]; if (existingPin.DataType.UnderlyingType != returnTypes[i]) { existingPin.ChangeType(PinDataTypeFactory.FromType(returnTypes[i])); } } else { var newPin = this.AddOutputPin($"output{i}", PinDataTypeFactory.FromType(returnTypes[i])); resultPins.Add(newPin); } } } catch (Exception e) { throw; } } }
private void HandleInputPinEvent(NodeEvent evt) { if (inHandleInputPinEvent) { return; } try { inHandleInputPinEvent = true; var pin = evt.Source as GenericInputPin; var pinDataTypeA = PinDataTypeFactory.FromType(typeof(ISequence <>)); var pinDataTypeB = PinDataTypeFactory.FromType(typeof(ISequence <>)); // determine common type IPinDataType pinDataType; if (firstInputPin.Connections.Any() && secondInputPin.Connections.Any()) { // check if both data types are compatible var firstType = firstInputPin.Connections[0].DataType; var secondType = secondInputPin.Connections[0].DataType; if (firstType.IsAssignableFrom(secondType)) { pinDataType = PinDataTypeFactory.FromType(firstType); } else if (secondType.IsAssignableFrom(firstType)) { pinDataType = PinDataTypeFactory.FromType(secondType); } else { throw new Exception("Connected sequence pin data types are not compatible."); } } else { if (firstInputPin.Connections.Any()) { pinDataType = PinDataTypeFactory.FromType(firstInputPin.Connections[0].DataType); } else if (secondInputPin.Connections.Any()) { pinDataType = PinDataTypeFactory.FromType(secondInputPin.Connections[0].DataType); } else { pinDataType = PinDataTypeFactory.FromType(typeof(ISequence <>)); } } var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault() ?? typeof(object); if (genericType != null) { genericDelegate = new GenericDelegate <Func <object, object, object, Task <bool> > >(this, EvaluateInternalAttribute.GetMethod(GetType()).MakeGenericMethod(genericType)); } else { genericDelegate = null; } pin.SetType(pinDataType); if (pin == firstInputPin) { secondInputPin.ChangeType(pinDataType); } else { firstInputPin.ChangeType(pinDataType); } } finally { inHandleInputPinEvent = false; } }