protected override IEnumerable <SyntaxNode> BuildNode(INodeModel statement, IPortModel portModel) { if (statement == null) { return(Enumerable.Empty <SyntaxNode>()); } Assert.IsTrue(portModel == null || portModel.NodeModel == statement, "If a Port is provided, it must be owned by the provided node"); // TODO : Find a better way to map [Node -> Current Archetype] if (!(context is RootContext) && statement.IsStacked) { var stencil = (EcsStencil)statement.GraphModel.Stencil; if (!stencil.ComponentDefinitions.ContainsKey(statement)) { stencil.ComponentDefinitions.Add(statement, context.GetComponentDefinitions()); } } Func <MethodInfo, bool> filterMethods = mi => mi.ReturnType == typeof(IEnumerable <SyntaxNode>) && mi.GetParameters().Length == 3 && mi.GetParameters()[2].ParameterType == typeof(IPortModel); Func <MethodInfo, Type> keySelector = mi => mi.GetParameters()[1].ParameterType; var ext = ModelUtility.ExtensionMethodCache <RoslynEcsTranslator> .GetExtensionMethod( statement.GetType(), filterMethods, keySelector) ?? ModelUtility.ExtensionMethodCache <RoslynTranslator> .GetExtensionMethod( statement.GetType(), filterMethods, keySelector); if (ext != null) { var syntaxNode = (IEnumerable <SyntaxNode>)ext.Invoke(null, new object[] { this, statement, portModel }) ?? Enumerable.Empty <SyntaxNode>(); var annotatedNodes = new List <SyntaxNode>(); foreach (var node in syntaxNode) { var annotatedNode = node?.WithAdditionalAnnotations(new SyntaxAnnotation(Annotations.AnnotationKind, statement.NodeAssetReference.GetInstanceID().ToString())); annotatedNodes.Add(annotatedNode); } return(annotatedNodes); } Debug.LogError("Roslyn ECS Translator doesn't know how to create a node of type: " + statement.GetType()); return(Enumerable.Empty <SyntaxNode>()); }
// static StatementSyntax StatementFromExitStrategy(StackExitStrategy stackExitStrategy, ExpressionSyntax returnValue) // { // StatementSyntax lastStatementSyntax; // switch (stackExitStrategy) // { // case StackExitStrategy.Return: // lastStatementSyntax = ReturnStatement(returnValue); // break; // case StackExitStrategy.Break: // lastStatementSyntax = BreakStatement(); // break; // case StackExitStrategy.None: // lastStatementSyntax = null; // break; // default: // lastStatementSyntax = ContinueStatement(); // break; // } // // return lastStatementSyntax; // } protected virtual IEnumerable <SyntaxNode> BuildNode(INodeModel statement, IPortModel portModel) { if (statement == null) { return(Enumerable.Empty <SyntaxNode>()); } Assert.IsTrue(portModel == null || portModel.NodeModel == statement, "If a Port is provided, it must be owned by the provided node"); var ext = ModelUtility.ExtensionMethodCache <RoslynTranslator> .GetExtensionMethod( statement.GetType(), FilterMethods, KeySelector); if (ext != null) { var syntaxNode = (IEnumerable <SyntaxNode>)ext.Invoke(null, new object[] { this, statement, portModel }) ?? Enumerable.Empty <SyntaxNode>(); var annotatedNodes = new List <SyntaxNode>(); foreach (var node in syntaxNode) { var annotatedNode = node?.WithAdditionalAnnotations(new SyntaxAnnotation(Annotations.AnnotationKind, statement.Guid.ToString())); annotatedNodes.Add(annotatedNode); } return(annotatedNodes); } else { Debug.LogError("Roslyn Translator doesn't know how to create a node of type: " + statement.GetType()); } return(Enumerable.Empty <SyntaxNode>()); }
void CheckNodeList(IReadOnlyList <INodeModel> nodeModels, Dictionary <GUID, int> existingGuids = null) { if (existingGuids == null) { existingGuids = new Dictionary <GUID, int>(nodeModels.Count * 4); // wild guess of total number of nodes, including stacked nodes } for (var i = 0; i < nodeModels.Count; i++) { INodeModel node = nodeModels[i]; Assert.IsTrue(node.NodeAssetReference != null, $"Node asset {i} is null"); Assert.IsNotNull(node, $"Node {i} is null"); Assert.IsTrue(AssetModel.IsSameAsset(node.AssetModel), $"Node {i} asset is not matching its actual asset"); Assert.IsFalse(node.Guid.Empty(), $"Node {i} ({node.GetType()}) has an empty Guid"); Assert.IsFalse(existingGuids.TryGetValue(node.Guid, out var oldIndex), $"duplicate GUIDs: Node {i} ({node.GetType()}) and Node {oldIndex}"); existingGuids.Add(node.Guid, i); if (node.Destroyed) { continue; } CheckNodePorts(node.InputsById); CheckNodePorts(node.OutputsById); if (node is IStackModel stackModel) { CheckNodeList(stackModel.NodeModels, existingGuids); } } }
// static StatementSyntax StatementFromExitStrategy(StackExitStrategy stackExitStrategy, ExpressionSyntax returnValue) // { // StatementSyntax lastStatementSyntax; // switch (stackExitStrategy) // { // case StackExitStrategy.Return: // lastStatementSyntax = ReturnStatement(returnValue); // break; // case StackExitStrategy.Break: // lastStatementSyntax = BreakStatement(); // break; // case StackExitStrategy.None: // lastStatementSyntax = null; // break; // default: // lastStatementSyntax = ContinueStatement(); // break; // } // // return lastStatementSyntax; // } protected virtual IEnumerable <SyntaxNode> BuildNode(INodeModel statement, IPortModel portModel) { if (statement == null) { return(Enumerable.Empty <SyntaxNode>()); } Assert.IsTrue(portModel == null || portModel.NodeModel == statement, "If a Port is provided, it must be owned by the provided node"); var ext = ModelUtility.ExtensionMethodCache <RoslynTranslator> .GetExtensionMethod( statement.GetType(), mi => mi.ReturnType == typeof(IEnumerable <SyntaxNode>) && mi.GetParameters().Length == 3 && mi.GetParameters()[2].ParameterType == typeof(IPortModel), mi => mi.GetParameters()[1].ParameterType); if (ext != null) { var syntaxNode = (IEnumerable <SyntaxNode>)ext.Invoke(null, new object[] { this, statement, portModel }) ?? Enumerable.Empty <SyntaxNode>(); var annotatedNodes = new List <SyntaxNode>(); foreach (var node in syntaxNode) { var annotatedNode = node?.WithAdditionalAnnotations(new SyntaxAnnotation(Annotations.AnnotationKind, (statement.NodeAssetReference).GetInstanceID().ToString())); annotatedNodes.Add(annotatedNode); } return(annotatedNodes); } else { Debug.LogError("Roslyn Translator doesn't know how to create a node of type: " + statement.GetType()); } return(Enumerable.Empty <SyntaxNode>()); }
public void AddStackedNodeNoUndo(INodeModel nodeModelInterface, int index) { if (!AcceptNode(nodeModelInterface.GetType())) { return; } var nodeModel = (NodeModel)nodeModelInterface; Utility.SaveAssetIntoObject(nodeModel.NodeAssetReference, (Object)AssetModel); nodeModel.GraphModel = GraphModel; nodeModel.ParentStackModel = this; if (index == -1) { m_NodeModels.Add(nodeModel.NodeAssetReference); } else { m_NodeModels.Insert(index, nodeModel.NodeAssetReference); } VSGraphModel vsGraphModel = (VSGraphModel)GraphModel; vsGraphModel.LastChanges.ChangedElements.Add(nodeModel); }
static bool TranslateNode(GraphBuilder builder, INodeModel nodeModel, out INode node, out Dictionary <string, uint> portToOffsetMapping, out uint?preAllocatedDataIndex) { Assert.IsNotNull(nodeModel); preAllocatedDataIndex = null; switch (nodeModel) { case SetVariableNodeModel setVariableNodeModel: { node = setVariableNodeModel.Node; portToOffsetMapping = setVariableNodeModel.PortToOffsetMapping; if (setVariableNodeModel.DeclarationModel == null) { return(false); } preAllocatedDataIndex = builder.GetVariableDataIndex(setVariableNodeModel.DeclarationModel).DataIndex; return(true); } case IEventNodeModel eventNodeModel: node = eventNodeModel.Node; ((IEventNode)node).EventId = TypeHash.CalculateStableTypeHash( eventNodeModel.TypeHandle.Resolve(nodeModel.GraphModel.Stencil)); portToOffsetMapping = eventNodeModel.PortToOffsetMapping; return(true); case SubgraphReferenceNodeModel subgraphReferenceNodeModel: node = subgraphReferenceNodeModel.Node; portToOffsetMapping = subgraphReferenceNodeModel.PortToOffsetMapping; return(true); case IDotsNodeModel dotsNodeModel: node = dotsNodeModel.Node; portToOffsetMapping = dotsNodeModel.PortToOffsetMapping; if (nodeModel is IReferenceComponentTypes referenceComponentTypes) { foreach (var typeReference in referenceComponentTypes.ReferencedTypes) { if (typeReference.TypeIndex != -1) { builder.AddReferencedComponent(typeReference); } } } return(true); case IConstantNodeModel constantNodeModel: HandleConstants(builder, out node, out portToOffsetMapping, constantNodeModel); return(true); case IVariableModel variableModel: return(HandleVariable(builder, out node, out portToOffsetMapping, out preAllocatedDataIndex, variableModel)); default: throw new NotImplementedException( $"Don't know how to translate a node of type {nodeModel.GetType()}: {nodeModel}"); } }
IEnumerable <StatementSyntax> ConvertNodesToSyntaxList(INodeModel node, IEnumerable <SyntaxNode> blocks, CompilationOptions options) { foreach (var block in blocks) { switch (block) { case StatementSyntax statementNode: foreach (var statementSyntax in Instrument(statementNode, node, options)) { yield return(statementSyntax); } break; case ExpressionSyntax expressionNode: foreach (var statementSyntax in Instrument(ExpressionStatement(expressionNode) .WithAdditionalAnnotations( new SyntaxAnnotation(Annotations.VSNodeMetadata, node.Guid.ToString())), node, options)) { yield return(statementSyntax); } break; default: throw new InvalidOperationException("Expected a statement or expression " + $"node, found a {node.GetType()} when building {block}"); } } }
public void AddStackedNode(INodeModel nodeModelInterface, int index) { if (!AcceptNode(nodeModelInterface.GetType())) { return; } var nodeModel = (NodeModel)nodeModelInterface; Utility.SaveAssetIntoObject(nodeModel.NodeAssetReference, (Object)AssetModel); nodeModel.GraphModel = GraphModel; nodeModel.ParentStackModel = this; if (index == -1) { m_NodeModels.Add(nodeModel.NodeAssetReference); } else { m_NodeModels.Insert(index, nodeModel.NodeAssetReference); } bool insertedLast = index == -1 || m_NodeModels.Count == 1 || index == m_NodeModels.Count; if (insertedLast && ModelDelegatesOutputs(nodeModelInterface)) { TransferConnections(GraphModel, m_OutputPorts, OutputPorts); } VSGraphModel vsGraphModel = (VSGraphModel)GraphModel; vsGraphModel.LastChanges.ChangedElements.Add(nodeModel); }
void OffsetNodeDependencies(INodeModel dependentNode, Vector2 delta) { Log($"Moving all dependencies of {dependentNode.GetType().Name} by {delta}"); m_TempMovedModels.Clear(); m_ModelsToMove.Clear(); m_ModelsToMove.Add(dependentNode); ProcessDependency(dependentNode, delta, OffsetDependency); }
void CheckNodeList(IList <INodeModel> nodeModels, Dictionary <GUID, int> existingGuids = null) { if (existingGuids == null) { existingGuids = new Dictionary <GUID, int>(nodeModels.Count * 4); // wild guess of total number of nodes, including stacked nodes } for (var i = 0; i < nodeModels.Count; i++) { INodeModel node = nodeModels[i]; Assert.IsTrue(node.GraphModel != null, $"Node {i} {node} graph is null"); Assert.IsTrue(node.SerializableAsset != null, $"Node {i} {node} asset is null"); Assert.IsNotNull(node, $"Node {i} is null"); Assert.IsTrue(AssetModel.IsSameAsset(node.AssetModel), $"Node {i} asset is not matching its actual asset"); Assert.IsFalse(node.Guid.Empty(), $"Node {i} ({node.GetType()}) has an empty Guid"); Assert.IsFalse(existingGuids.TryGetValue(node.Guid, out var oldIndex), $"duplicate GUIDs: Node {i} ({node.GetType()}) and Node {oldIndex} have the same guid {node.Guid}"); existingGuids.Add(node.Guid, i); if (node.Destroyed) { continue; } CheckNodePorts(node.InputsById); CheckNodePorts(node.OutputsById); if (node is IStackModel stackModel) { CheckNodeList(stackModel.NodeModels, existingGuids); } if (node is VariableNodeModel variableNode) { Assert.IsNotNull(variableNode.DeclarationModel, $"Variable Node {i} {variableNode.Title} has a null declaration model"); if (variableNode.DeclarationModel.VariableType == VariableType.GraphVariable) { var originalDeclarations = GraphVariableModels.Where(d => d.GetId() == variableNode.DeclarationModel.GetId()); Assert.IsTrue(originalDeclarations.Count() <= 1); var originalDeclaration = originalDeclarations.SingleOrDefault(); Assert.IsNotNull(originalDeclaration, $"Variable Node {i} {variableNode.Title} has a declaration model, but it was not present in the graph's variable declaration list"); Assert.IsTrue(ReferenceEquals(originalDeclaration, variableNode.DeclarationModel), $"Variable Node {i} {variableNode.Title} has a declaration model that was not ReferenceEquals() to the matching one in the graph"); } } } }
public virtual void AddStackedNode(INodeModel nodeModelInterface, int index) { if (!AcceptNode(nodeModelInterface.GetType())) { return; } var nodeModel = (NodeModel)nodeModelInterface; nodeModel.AssetModel = AssetModel; nodeModel.ParentStackModel = this; if (index == -1) { m_StackedNodeModels.Add(nodeModel); } else { m_StackedNodeModels.Insert(index, nodeModel); } VSGraphModel vsGraphModel = (VSGraphModel)GraphModel; // We need to register before calling TransferConnections(), as edge models rely on the guid to node mapping to resolve ports vsGraphModel.UnregisterNodeGuid(nodeModel.Guid); vsGraphModel.RegisterNodeGuid(nodeModel); bool insertedLast = index == -1 || m_StackedNodeModels.Count == 1 || index == m_StackedNodeModels.Count; if (insertedLast && ModelDelegatesOutputs(nodeModelInterface)) { TransferConnections(GraphModel, m_OutputPorts, OutputPorts); } vsGraphModel.LastChanges.ChangedElements.Add(nodeModel); // Needed to add/remove/update the return value port of the node according to the function type nodeModel.DefineNode(); }
static void CheckNodeList(this IGraphModel self) { var existingGuids = new Dictionary <SerializableGUID, int>(self.NodeModels.Count * 4); // wild guess of total number of nodes, including stacked nodes for (var i = 0; i < self.NodeModels.Count; i++) { INodeModel node = self.NodeModels[i]; Assert.IsTrue(node.GraphModel != null, $"Node {i} {node} graph is null"); Assert.IsTrue(node.AssetModel != null, $"Node {i} {node} asset is null"); Assert.IsNotNull(node, $"Node {i} is null"); Assert.IsTrue(self.AssetModel.GetHashCode() == node.AssetModel?.GetHashCode(), $"Node {i} asset is not matching its actual asset"); Assert.IsFalse(!node.Guid.Valid, $"Node {i} ({node.GetType()}) has an empty Guid"); Assert.IsFalse(existingGuids.TryGetValue(node.Guid, out var oldIndex), $"duplicate GUIDs: Node {i} ({node.GetType()}) and Node {oldIndex} have the same guid {node.Guid}"); existingGuids.Add(node.Guid, i); if (node.Destroyed) { continue; } if (node is IInputOutputPortsNodeModel portHolder) { CheckNodePorts(portHolder.InputsById); CheckNodePorts(portHolder.OutputsById); } if (node is IVariableNodeModel variableNode && variableNode.DeclarationModel != null) { var originalDeclarations = self.VariableDeclarations.Where(d => d.Guid == variableNode.DeclarationModel.Guid).ToList(); Assert.IsTrue(originalDeclarations.Count <= 1); var originalDeclaration = originalDeclarations.SingleOrDefault(); Assert.IsNotNull(originalDeclaration, $"Variable Node {i} {variableNode.Title} has a declaration model, but it was not present in the graph's variable declaration list"); Assert.IsTrue(ReferenceEquals(originalDeclaration, variableNode.DeclarationModel), $"Variable Node {i} {variableNode.Title} has a declaration model that was not ReferenceEquals() to the matching one in the graph"); } } }
public void AddStackedNode(INodeModel nodeModelInterface, int index) { if (!AcceptNode(nodeModelInterface.GetType())) { return; } var nodeModel = (NodeModel)nodeModelInterface; nodeModel.GraphModel = GraphModel; nodeModel.ParentStackModel = this; if (index == -1) { m_StackedNodeModels.Add(nodeModel); } else { m_StackedNodeModels.Insert(index, nodeModel); } bool insertedLast = index == -1 || m_StackedNodeModels.Count == 1 || index == m_StackedNodeModels.Count; if (insertedLast && ModelDelegatesOutputs(nodeModelInterface)) { TransferConnections(GraphModel, m_OutputPorts, OutputPorts); } VSGraphModel vsGraphModel = (VSGraphModel)GraphModel; // theor: why is that needed ? vsGraphModel.UnregisterNodeGuid(nodeModel.Guid); vsGraphModel.RegisterNodeGuid(nodeModel); vsGraphModel.LastChanges.ChangedElements.Add(nodeModel); // Needed to add/remove/update the return value port of the node according to the function type nodeModel.DefineNode(); }
bool AcceptNode(INodeModel nodeModel) { return(stackModel.NodeModels.Any(m => m == nodeModel) || stackModel.AcceptNode(nodeModel.GetType())); }
private void ParseNodeFirstPass(XmlTextReader reader, XMLTree parentNode, String parentTypeName) { INodeModel nodeModel = graph.Model.NodeModel; IEdgeModel edgeModel = graph.Model.EdgeModel; Dictionary <String, int> tagNameToNextIndex = new Dictionary <String, int>(); while (reader.Read()) { if (reader.NodeType == XmlNodeType.EndElement) { break; // reached end of current nesting level } if (reader.NodeType != XmlNodeType.Element) { continue; } bool emptyElem = reader.IsEmptyElement; // retard API designer String tagName = reader.Name; String id = null; if (reader.MoveToAttribute("xmi:id")) { id = reader.Value; } String elementName = null; if (reader.MoveToAttribute("name")) { elementName = reader.Value; } String typeName = null; if (reader.MoveToAttribute("xsi:type")) { typeName = reader.Value; } else if (reader.MoveToAttribute("xmi:type")) { typeName = reader.Value; } else { typeName = FindRefTypeName(parentTypeName, tagName); if (typeName == null) { // Treat it as an attribute AssignAttribute(parentNode.elementNode, tagName, reader.ReadInnerXml()); XMLTree attributeChild = new XMLTree(); attributeChild.elementNode = null; attributeChild.elementName = elementName; attributeChild.element = tagName; attributeChild.children = null; parentNode.children.Add(attributeChild); continue; } } INode gnode = graph.AddNode(nodeModel.GetType(GrGenTypeNameFromXmi(typeName))); XMLTree child = new XMLTree(); child.elementNode = gnode; child.elementName = elementName; child.element = tagName; child.children = new List <XMLTree>(); parentNode.children.Add(child); if (id != null) { nodeMap[id] = gnode; } String edgeTypeName = FindContainingTypeName(parentTypeName, tagName); String grgenEdgeTypeName = GrGenTypeNameFromXmi(edgeTypeName) + "_" + tagName; IEdge parentEdge = graph.AddEdge(edgeModel.GetType(grgenEdgeTypeName), parentNode.elementNode, gnode); if (IsRefOrdered(parentTypeName, tagName)) { int nextIndex = 0; tagNameToNextIndex.TryGetValue(tagName, out nextIndex); parentEdge.SetAttribute("ordering", nextIndex); tagNameToNextIndex[tagName] = nextIndex + 1; } if (!emptyElem) { ParseNodeFirstPass(reader, child, typeName); } } }