public PortAssigned(NodeIdentifier nodeId, PortDirection port, LinkIdentifier linkId, ConnectionDirection direction) { NodeId = nodeId ?? throw new System.ArgumentNullException(nameof(nodeId)); Port = port; LinkId = linkId ?? throw new System.ArgumentNullException(nameof(linkId)); Direction = direction; }
public PortDescription(NodeEditor owner, string memberName, string displayName, PortDirection portDirection) { Owner = owner; _memberName = memberName; _displayName = displayName; _portDirection = portDirection; }
public Port(string name, PortDirection portDirection, PortType portType, float initialValue = 0f) { Name = name; Direction = portDirection; Type = portType; Value = initialValue; }
public void RemovePort(PortOrientation orientation, PortDirection direction) { if (orientation == PortOrientation.Horizontal) { if (direction == PortDirection.Input) { m_InputCount--; } else { m_OutputCount--; } } else { if (direction == PortDirection.Input) { m_VerticalInputCount--; } else { m_VerticalOutputCount--; } } DefineNode(); }
/* Initialize port's properties from loaded template */ public void InitializeFromTemplate(Node parent, PortDirection direction, api.PortTemplate template) { ParentNode = parent; Direction = direction; // Note: This Id should be obtained from backend on save Id = Guid.NewGuid().ToString(); name = Id; Name = template.name; // Few steps to set Type var type = Utils.DataTypeFromString(template.kind); Type = type; iconField.color = Utils.GetDataTypeColor(type); if (valueField && null == template.defaultValue) { valueField.enabled = false; } else if (valueField) { valueField.enabled = true; Value = template.defaultValue; } }
public NodePort this[PortDirection direction] { get { return(_ports[(int)direction]); } }
public LinkNodes(NodeIdentifier source, PortDirection sourcePort, NodeIdentifier sink, PortDirection sinkPort, LinkAttributes attributes) { Source = source ?? throw new System.ArgumentNullException(nameof(source)); SourcePort = sourcePort; Sink = sink ?? throw new System.ArgumentNullException(nameof(sink)); SinkPort = sinkPort; Attributes = attributes; }
public void Reload(NodePort port) { fieldName = port.fieldName; direction = port.direction; capacity = port.capacity; typeConstraint = port.typeConstraint; DataType = port.DataType; }
public NodePort(NodePort _port) { fieldName = _port.fieldName; direction = _port.direction; multiple = _port.multiple; typeConstraint = _port.typeConstraint; typeQualifiedName = _port.typeQualifiedName; }
public void Reload(NodePort port) { fieldName = port.fieldName; direction = port.direction; multiple = port.multiple; typeConstraint = port.typeConstraint; typeQualifiedName = port.typeQualifiedName; }
/// <summary> /// Creates a new <see cref="VerticalPortContainerPart"/>. /// </summary> /// <param name="name">The name of the part to create.</param> /// <param name="portDirection">The direction of the ports the container will hold.</param> /// <param name="model">The model which the part represents.</param> /// <param name="ownerUI">The owner of the part to create.</param> /// <param name="parentClassName">The class name of the parent UI.</param> /// <returns>A new instance of <see cref="VerticalPortContainerPart"/>.</returns> public static VerticalPortContainerPart Create(string name, PortDirection portDirection, IGraphElementModel model, IModelUI ownerUI, string parentClassName) { if (model is IPortNodeModel) { return(new VerticalPortContainerPart(name, portDirection, model, ownerUI, parentClassName)); } return(null); }
public NodePort(NodePort port, NodeData node) { fieldName = port.fieldName; direction = port.direction; capacity = port.capacity; typeConstraint = port.typeConstraint; DataType = port.DataType; this.node = node; }
public Port(FlowNode node, string fieldName, Type fieldType, PortCapacity capacity, PortDirection direction) { m_Connections = new List <Edge>(); this.node = node; this.fieldName = fieldName; this.capacity = capacity; this.direction = direction; this.m_FieldTypeName = fieldType.FullName; }
public PortData(string nodeDataId, string fieldName, Type type, Type overrideConnectionType, PortDirection direction) { _portId = Guid.NewGuid().ToString(); _overrideConnectionTypeName = overrideConnectionType != null ? overrideConnectionType.FullName : null; _nodeDataId = nodeDataId; _fieldName = fieldName; _typeName = type.Name; _direction = direction; }
public My_Port(Schematix.FSM.Constructor_Core core, PortDirection Direction) : base(core) { Color = Color.Aqua; this.Direction = Direction; this.Port_Type = PortType.Registered; base.name = ("Port" + core.Graph.Ports.Count.ToString()); base.label_name.Text = name; }
/***************************************************************************/ public PortElement( PortDirection _portKind , string _name , int _id , ILibraryElementType _type ) : base(_id, _type, 0) { m_port = new Port(_name); PortKind = _portKind; }
public void Display(PacketType packetType, PortDirection direction) { switch (packetType) { case PacketType.Red: RedInputDetector.UpdateDirectionToFace(direction); break; case PacketType.Green: GreenInputDetector.UpdateDirectionToFace(direction); break; case PacketType.Blue: BlueInputDetector.UpdateDirectionToFace(direction); break; } }
public void CreateNode_Should_Create_Port(string id, Type type, PortDirection direction, PortCapacity capacity) { var nodeType = new NodeWithPorts(); var node = nodeType.CreateNode(); var port = node.Ports.FirstOrDefault(p => p.Id == id); Assert.That(port, Is.Not.Null); Assert.That(port.Type, Is.EqualTo(type)); Assert.That(port.Direction, Is.EqualTo(direction)); Assert.That(port.Capacity, Is.EqualTo(capacity)); }
// Инверсия направления порта public static PortDirection Invert(PortDirection dir) { switch (dir) { case PortDirection.In: return PortDirection.Out; case PortDirection.Out: return PortDirection.In; default: throw new System.Exception("Unknown port direction"); } }
/// <summary> /// Initializes a new instance of the <see cref="CreateEdgeCommand" /> class. /// </summary> /// <param name="toPortModel">Destination port.</param> /// <param name="fromPortModel">Origin port.</param> /// <param name="edgeModelsToDelete">List of edges to delete (sometimes the new edge replaces previous connections).</param> /// <param name="portAlignment">Which port's node should be aligned to the other port.</param> public CreateEdgeCommand(IPortModel toPortModel, IPortModel fromPortModel, IReadOnlyList <IEdgeModel> edgeModelsToDelete = null, PortDirection portAlignment = PortDirection.None) : this() { Assert.IsTrue(toPortModel == null || toPortModel.Direction == PortDirection.Input); Assert.IsTrue(fromPortModel == null || fromPortModel.Direction == PortDirection.Output); ToPortModel = toPortModel; FromPortModel = fromPortModel; EdgeModelsToDelete = edgeModelsToDelete; PortAlignment = portAlignment; }
public override IPortModel CreatePort(PortDirection direction, PortOrientation orientation, string portName, PortType portType, TypeHandle dataType, string portId, PortModelOptions options) { return(new FakePortModel(GraphModel) { Direction = direction, Orientation = orientation, Title = portName, PortType = portType, DataTypeHandle = dataType, NodeModel = this }); }
public IPort SetupPort(INode node, FieldInfo fieldInfo, out PortDirection direction, out PortType type, out string name) { var portIndex = LastPortIndex + 1; name = fieldInfo.Name; var port = (IPort)fieldInfo.GetValue(node); LastPortIndex += (uint)port.GetDataCount(); var internalPort = port.GetPort(); internalPort.Index = portIndex; if (port is IInputDataPort inputDataPort) { direction = PortDirection.Input; type = PortType.Data; inputDataPort.SetPort(internalPort); port = inputDataPort; } else if (port is IOutputDataPort outputDataPort) { direction = PortDirection.Output; type = PortType.Data; outputDataPort.SetPort(internalPort); port = outputDataPort; } else if (port is IInputTriggerPort inputTriggerPort) { direction = PortDirection.Input; type = PortType.Trigger; inputTriggerPort.SetPort(internalPort); port = inputTriggerPort; } else if (port is IOutputTriggerPort outputTriggerPort) { direction = PortDirection.Output; type = PortType.Trigger; outputTriggerPort.SetPort(internalPort); port = outputTriggerPort; } else { throw new NotImplementedException(); } fieldInfo.SetValue(node, port); return(port); }
public void UpdateDirectionToFace(PortDirection direction) { switch (direction) { case PortDirection.Right: _desiredDirection = RightDirection; break; case PortDirection.Top: _desiredDirection = TopDirection; break; case PortDirection.Left: _desiredDirection = LeftDirection; break; default: case PortDirection.Bottom: _desiredDirection = BottomDirection; break; } }
public static string GetBothName(string fieldName, PortDirection direction) { switch (direction) { case PortDirection.Input: return(fieldName + " Iutput"); case PortDirection.Output: return(fieldName + " Onput"); default: return(fieldName); } }
/// <summary> /// Instantiates a new <see cref="PortInfo"/> object. /// </summary> /// <param name="name">Name of the port.</param> /// <param name="description">Description of the port.</param> /// <param name="direction">Direction of the port.</param> /// <param name="type">Type of the port.</param> /// <param name="defaultValue">Default value of the port. Can be null or empty.</param> /// <exception cref="ArgumentNullException"><paramref name="name"/>, <paramref name="type"/>, or <paramref name="description"/> is a null reference.</exception> /// <exception cref="ArgumentException"><paramref name="name"/>, <paramref name="type"/>, or <paramref name="description"/> is an empty string.</exception> public PortInfo(string name, string description, PortDirection direction, string type, string defaultValue = null) : base(name, direction, type, defaultValue) { if (description == null) { throw new ArgumentNullException("description"); } if (description.Length == 0) { throw new ArgumentException("description is an empty string"); } Description = description; }
public override IPortModel CreatePort(PortDirection direction, PortOrientation orientation, string portName, PortType portType, TypeHandle dataType, string portId, PortModelOptions options) { return(new MathExpressionPortModel { Direction = direction, Orientation = orientation, PortType = portType, DataTypeHandle = dataType, Title = portName ?? "", UniqueName = portId, Options = options, NodeModel = this, AssetModel = AssetModel }); }
public NodePort(FieldInfo _fieldInfo, PortAttribute _portAttribute) { fieldName = _fieldInfo.Name; multiple = _portAttribute.IsMulti; direction = _portAttribute.Direction; typeConstraint = _portAttribute.TypeConstraint; if (Utility_Attribute.TryGetFieldAttribute(_fieldInfo.DeclaringType, _fieldInfo.Name, out PortTypeAttribute typeAttribute)) { typeQualifiedName = typeAttribute.portType.AssemblyQualifiedName; } else { typeQualifiedName = _fieldInfo.FieldType.AssemblyQualifiedName; } }
/***************************************************************************/ public PortElement createPortElement(PortDirection _kind, string _name) { if (_name.Length == 0) { throw new ArgumentException( Resoursers.Exceptions.Messages.emptyPortName ); } return (new PortElement( _kind , _name , ms_currentID++ , ms_portElementTypes[_kind] )); }
public override IPortModel CreatePort(PortDirection direction, PortOrientation orientation, string portName, PortType portType, TypeHandle dataType, string portId, PortModelOptions options) { var port = new PortModel { Direction = direction, Orientation = orientation, PortType = portType, DataTypeHandle = dataType, Title = portName, UniqueName = portId, Options = options, NodeModel = this }; port.SetGraphModel(GraphModel); return(port); }
public IBaseMessage Execute(IPipelineContext pContext, IBaseMessage pInMsg) { string stageID = pContext.StageID.ToString("D"); m_portDirection = PortDirection.send; if (stageID == CategoryTypes.CATID_Decoder || stageID == CategoryTypes.CATID_Validate || stageID == CategoryTypes.CATID_PartyResolver) { m_portDirection = PortDirection.receive; } if (!string.IsNullOrEmpty(_mapName)) { MarkableForwardOnlyEventingReadStream stream = new MarkableForwardOnlyEventingReadStream( pInMsg.BodyPart.GetOriginalDataStream()); string messageType = (string)pInMsg.Context.Read("MessageType", _systemPropertiesNamespace); if (messageType == String.Empty) { stream.MarkPosition(); //Thanks to http://maximelabelle.wordpress.com/2010/07/08/determining-the-type-of-an-xml-message-in-a-custom-pipeline-component/ messageType = Microsoft.BizTalk.Streaming.Utils.GetDocType(stream); stream.ResetPosition(); } TransformMetaData _map = FindFirstMapMatch(messageType); if (_map == null) { System.Diagnostics.Debug.WriteLine("No match for map could be made for message type: " + messageType); } else { pInMsg.BodyPart.Data = TransformMessage(stream, _map, pInMsg); pContext.ResourceTracker.AddResource(stream); } } return(pInMsg); }
private void SetAvailablePorts() { signalControl.AvailableIns.Clear(); signalControl.AvailableOuts.Clear(); foreach (ListViewItem lvi in interfaceListControl.Items) { var port = lvi.Tag as Port; if (port != null) { PortDirection direction = port.direction; if (direction == PortDirection.Input || direction == PortDirection.BiDirectional) signalControl.AvailableIns.Add(port); if (direction == PortDirection.Output || direction == PortDirection.BiDirectional) signalControl.AvailableOuts.Add(port); } } }
// Составление имени контакта, в соответствии с его направлением // и порядком public static string BuildName(PortDirection dir, int idx = -1) { switch (dir) { case Model.PortDirection.In: return (idx < 0) ? "I" : "I_" + idx.ToString(); case Model.PortDirection.Out: return (idx < 0) ? "O" : "O_" + idx.ToString(); default: throw new System.Exception("Unknown port direction"); } }
public void pinMode(ArduinoPort port, PortDirection direction) { }
protected Connection(string name, PortDirection direction) : base(name) { Direction = direction; }
public Pin(string name, PortDirection direction, ILogic owner) : base(name, direction) { Owner = owner; }