private SearchRequest BuildUnionRequest(SearchExpressionNode ex) { if (ex.variables == null) { return(null); } if (ex.variables == null) { return(null); } var unionItems = new HashSet <SearchItem>(); var unionRequest = new SearchRequest(ex.type); foreach (var v in ex.variables) { if (v.source != null) { var sourceRequest = BuildRequest(v.source); unionRequest.DependsOn(sourceRequest); sourceRequest.Resolve(results => unionItems.UnionWith(results), null); } } unionRequest.resolved += exs => unionRequest.ProcessItems(exs.context, unionItems); return(unionRequest); }
private SearchRequest BuildValueRequest(SearchExpressionNode ex) { var valueRequest = new SearchRequest(ex.type); valueRequest.resolved += exs => valueRequest.ProcessItems(null, new [] { new SearchItem(ex.value.ToString()) }); return(valueRequest); }
private SearchExpressionNode LoadNodeData(SearchExpressionNode node, IDictionary info) { if (SJSON.TryGetValue(info, ExpressionField.name, out var name)) { node.name = Convert.ToString(name); } if (SJSON.TryGetValue(info, ExpressionField.value, out var value)) { node.value = value; } if (node.type == ExpressionType.Expression) { var nestedExpression = new SearchExpression(m_SearchOptions); if (node.value is string expressionPath && File.Exists(expressionPath)) { nestedExpression.Load(expressionPath); } else if (SJSON.TryGetValue(info, ExpressionField.source, out var source) && source is IDictionary sourceData) { nestedExpression.Load(sourceData); } if (nestedExpression.m_EvalNode != null && nestedExpression.m_EvalNode.source != null) { node.source = nestedExpression.m_EvalNode.source; } }
private SearchRequest BuildFromSearchQuery(SearchExpressionNode node, string searchQuery) { var providers = new List <SearchProvider>(); if (node.source?.type == ExpressionType.Provider) { var selectedProviderName = Convert.ToString(node.source.value); if (!m_AdditionalProviders.TryGetValue(selectedProviderName, out var selectedProvider)) { selectedProvider = SearchService.GetProvider(selectedProviderName); } if (selectedProvider != null) { providers.Add(selectedProvider); } } else if (node.source == null) { providers.AddRange(SearchService.Providers.Where(p => p.active)); } else { throw new NotSupportedException($"Evaluation of source node {node.source.id} of type {node.source.type} is not supported."); } requestCount++; return(new SearchRequest(node.type, SearchService.CreateContext(providers, searchQuery, m_SearchOptions))); }
public void SetSelection(SearchExpressionNode node) { if (node == m_Selection) { return; } m_Selection = node; if (m_Selection == null) { return; } m_VariablesList.Clear(); if (m_Selection.type == ExpressionType.Search) { if (m_Selection.variables != null) { m_VariablesList.AddRange(m_Selection.variables.Select(v => v.name)); } } resetHeight = true; MarkDirtyRepaint(); }
private SearchRequest BuildRequest(SearchExpressionNode node) { switch (node.type) { case ExpressionType.Results: return(EvaluateNode(m_EvalNode.source)); case ExpressionType.Search: return(BuildSearchRequest(node)); case ExpressionType.Select: return(BuildSelectRequest(node)); case ExpressionType.Union: return(BuildUnionRequest(node)); case ExpressionType.Intersect: return(BuildIntersectRequest(node)); case ExpressionType.Except: return(BuildExceptRequest(node)); case ExpressionType.Value: return(BuildValueRequest(node)); case ExpressionType.Expression: if (node.source != null) { return(BuildRequest(node.source)); } return(SearchRequest.empty); default: throw new ExpressionException($"Cannot evaluate {node.id} of type {node.type}"); } }
public SearchExpressionNode(ExpressionType type, SearchExpressionNode source, object value, List <ExpressionVariable> variables) : this(NewId(), type) { this.source = source; this.value = value; this.variables = variables; }
public void SetSelection(SearchExpressionNode node) { if (node == m_Node) { return; } m_Node = node; if (m_Node == null) { return; } m_VariablesList.Clear(); if (m_Node.type == ExpressionType.Search) { if (m_Node.variables != null) { m_VariablesList.AddRange(m_Node.variables.Select(v => v.name)); } } m_ExpressionPaths = AssetDatabase.FindAssets($"t:{nameof(SearchExpressionAsset)}").Select(AssetDatabase.GUIDToAssetPath).ToArray(); resetHeight = true; MarkDirtyRepaint(); }
public void ClearSelection() { resetHeight = true; m_Node = null; m_VariablesList.Clear(); MarkDirtyRepaint(); }
public void UpdateNode(SearchExpressionNode ex) { if (!TryGetNode(ex, out var node)) { return; } node.title = FormatTitle(ex); // Update result port if (ex.type == ExpressionType.Value || ex.type == ExpressionType.Provider) { var outputPort = FindPort(node, "output"); if (outputPort != null) { outputPort.portName = Convert.ToString(ex.value); } } else if (ex.type == ExpressionType.Union) { UpdateUnionVariables(node); } else if (ex.type == ExpressionType.Select) { var outputPort = FindPort(node, "output"); if (outputPort != null) { outputPort.portName = ex.GetProperty("field", "Results"); } } NotifyGraphChanged(); }
public SearchExpressionNode AddNode(ExpressionType type) { var node = new SearchExpressionNode(type); m_Nodes.Add(node.id, node); return(node); }
internal static IEnumerable <SearchItem> Object(SearchRequest selectRequest, SearchExpressionNode node, IEnumerable <SearchItem> items) { var objectType = node.GetProperty <string>("type", null); var propertyName = node.GetProperty <string>("field", null); var mapped = node.GetProperty(ExpressionKeyName.Mapped, false); var overrides = node.GetProperty(ExpressionKeyName.Overrides, true); return(items.SelectMany(item => selectRequest.SelectObject(item, objectType, propertyName, mapped, overrides))); }
private void AddPorts(Node node, SearchExpressionNode ex) { switch (ex.type) { case ExpressionType.Search: AddInputPort(node, $"source-{ex.id}", "Source", typeof(ExpressionSource)); AddVariablePorts(node, ex); AddOutputPort(node, $"output-{ex.id}", "Results", typeof(ExpressionSet)); break; case ExpressionType.Map: AddInputPort(node, $"var-{ex.id}-{ExpressionKeyName.X}", ExpressionKeyName.X, typeof(ExpressionVariable)); AddInputPort(node, $"var-{ex.id}-{ExpressionKeyName.Y}", ExpressionKeyName.Y, typeof(ExpressionVariable)); AddOutputPort(node, $"output-{ex.id}", "Results", typeof(ExpressionSet)); break; case ExpressionType.Expression: AddOutputPort(node, $"output-{ex.id}", "Results", typeof(ExpressionSet)); break; case ExpressionType.Select: AddInputPort(node, $"source-{ex.id}", "Source", typeof(ExpressionResults)); AddOutputPort(node, $"output-{ex.id}", GetSelectNodeOutputPortName(ex), typeof(ExpressionSet)); break; case ExpressionType.Results: AddInputPort(node, $"source-{ex.id}", "Source", typeof(ExpressionResults)); break; case ExpressionType.Provider: AddOutputPort(node, $"output-{ex.id}", Convert.ToString(ex.value), typeof(ExpressionProvider)); break; case ExpressionType.Value: AddOutputPort(node, $"output-{ex.id}", Convert.ToString(ex.value), typeof(ExpressionSet)); break; case ExpressionType.Union: AddVariablePorts(node, ex); UpdateUnionVariables(node); AddOutputPort(node, $"output-{ex.id}", "Results", typeof(ExpressionSet)); break; case ExpressionType.Intersect: case ExpressionType.Except: AddInputPort(node, $"source-{ex.id}", "Source", typeof(ExpressionResults)); AddInputPort(node, $"var-{ex.id}-With", "With", typeof(ExpressionVariable)); AddOutputPort(node, $"output-{ex.id}", "Results", typeof(ExpressionSet)); break; default: throw new NotSupportedException($"Expression {ex.type} {ex.id} has no support ports"); } node.RefreshPorts(); }
private static string GetSelectNodeOutputPortName(SearchExpressionNode ex) { var propertyName = ex.GetProperty("field", "Results"); if (propertyName.StartsWith("m_", StringComparison.Ordinal)) { propertyName = propertyName.Substring(2); } return(propertyName); }
public void Reset() { m_Items = new HashSet <SearchItem>(); m_EvalNode = new SearchExpressionNode(ExpressionType.Results); m_Nodes = new Dictionary <string, SearchExpressionNode>() { { m_EvalNode.id, m_EvalNode } }; requestCount = 0; }
public SearchExpressionNode FromSource(SearchExpressionNode ex) { foreach (var n in nodes) { if (n.HasSource(ex)) { return(n); } } return(null); }
private void AddVariablePorts(Node node, SearchExpressionNode ex) { if (ex.variables == null) { return; } foreach (var v in ex.variables) { AddInputPort(node, $"var-{ex.id}-{v.name}", v.name, typeof(ExpressionVariable)); } }
internal void AddNodeVariable(SearchExpressionNode ex, string varName) { if (!TryGetNode(ex, out var node)) { return; } AddInputPort(node, $"var-{ex.id}-{varName}", varName, typeof(ExpressionVariable)); node.RefreshPorts(); NotifyGraphChanged(); }
public void UpdateNode(SearchExpressionNode ex) { if (!TryGetNode(ex, out var node)) { return; } node.title = FormatTitle(ex); if (ex.color != Color.clear) { node.titleContainer.style.backgroundColor = ex.color; } // Update result port if (ex.type == ExpressionType.Value || ex.type == ExpressionType.Provider) { var outputPort = FindPort(node, "output"); if (outputPort != null) { outputPort.portName = Convert.ToString(ex.value); } } else if (ex.type == ExpressionType.Union) { UpdateUnionVariables(node); } else if (ex.type == ExpressionType.Select) { var outputPort = FindPort(node, "output"); if (outputPort != null) { outputPort.portName = GetSelectNodeOutputPortName(ex); } } else if (ex.type == ExpressionType.Map) { if (ex.TryGetVariableSource(ExpressionKeyName.X, out var xSource)) { if (!ex.TryGetProperty(ExpressionKeyName.GroupBy, out string groupBy) || string.IsNullOrEmpty(groupBy)) { ex.SetProperty(ExpressionKeyName.GroupBy, GetSelectNodeOutputPortName(xSource).ToLowerInvariant()); } } if (ex.TryGetVariableSource(ExpressionKeyName.Y, out var ySource) && xSource == ySource) { ex.SetProperty(nameof(Mapping), (int)Mapping.Table); } } NotifyGraphChanged(); }
private void AddConnections(SearchExpressionNode ex) { switch (ex.type) { case ExpressionType.Search: case ExpressionType.Select: case ExpressionType.Union: case ExpressionType.Intersect: case ExpressionType.Except: case ExpressionType.Results: case ExpressionType.Expression: case ExpressionType.Map: { if (ex.source != null) { var sourcePort = this.Query <Port>($"source-{ex.id}").First(); var outputPort = this.Query <Port>($"output-{ex.source.id}").First(); if (sourcePort != null && outputPort != null) { AddConnection(outputPort, sourcePort); } } if (ex.variables != null) { foreach (var v in ex.variables) { if (v.source == null) { continue; } var sourcePort = this.Query <Port>($"var-{ex.id}-{v.name}").First(); var outputPort = this.Query <Port>($"output-{v.source.id}").First(); if (sourcePort != null && outputPort != null) { AddConnection(outputPort, sourcePort); } } } break; } case ExpressionType.Value: case ExpressionType.Provider: // No source to connect for these nodes. break; default: throw new NotSupportedException($"Do not know how to connect ports for {ex.type} {ex.id}"); } }
private void AddPorts(Node node, SearchExpressionNode ex) { switch (ex.type) { case ExpressionType.Search: AddInputPort(node, $"source-{ex.id}", "Source", typeof(ExpressionSource)); AddVariablePorts(node, ex); AddOutputPort(node, $"output-{ex.id}", "Results", typeof(ExpressionSet)); break; case ExpressionType.Expression: AddOutputPort(node, $"output-{ex.id}", "Results", typeof(ExpressionSet)); break; case ExpressionType.Select: AddInputPort(node, $"source-{ex.id}", "Source", typeof(ExpressionResults)); AddOutputPort(node, $"output-{ex.id}", ex.GetProperty("field", "Results"), typeof(ExpressionSet)); break; case ExpressionType.Results: AddInputPort(node, $"source-{ex.id}", "Source", typeof(ExpressionResults)); break; case ExpressionType.Provider: AddOutputPort(node, $"output-{ex.id}", Convert.ToString(ex.value), typeof(ExpressionProvider)); break; case ExpressionType.Value: AddOutputPort(node, $"output-{ex.id}", Convert.ToString(ex.value), typeof(ExpressionConstant)); break; case ExpressionType.Union: var nextMergeInputPortName = (ex.GetVariableCount() + 1).ToString(); AddVariablePorts(node, ex); AddInputPort(node, $"var-{ex.id}-{nextMergeInputPortName}", nextMergeInputPortName, typeof(ExpressionVariable)); AddOutputPort(node, $"output-{ex.id}", "Results", typeof(ExpressionSet)); break; case ExpressionType.Intersect: case ExpressionType.Except: AddInputPort(node, $"source-{ex.id}", "Source", typeof(ExpressionResults)); AddInputPort(node, $"var-{ex.id}-With", "With", typeof(ExpressionVariable)); AddOutputPort(node, $"output-{ex.id}", "Results", typeof(ExpressionSet)); break; default: throw new NotSupportedException($"Expression {ex.type} {ex.id} has no support ports"); } node.RefreshPorts(); }
public bool TryGetVariableSource(string name, out SearchExpressionNode source) { source = null; foreach (var v in variables) { if (v.name == name) { source = v.source; return(true); } } return(false); }
private SearchRequest BuildSelectRequest(SearchExpressionNode node) { if (node.source == null) { return(SearchRequest.empty); } var sourceRequest = BuildRequest(node.source); var selectField = node.selectField; var objectType = node.GetProperty <string>("type", null); var propertyName = node.GetProperty <string>("field", null); return(sourceRequest.Select(selectField, objectType, propertyName)); }
private string FormatTitle(SearchExpressionNode ex) { switch (ex.type) { case ExpressionType.Value: return(ex.name ?? ex.type.ToString()); case ExpressionType.Search: return(Convert.ToString(ex.value)); case ExpressionType.Select: return($"{ex.type} {ex.GetProperty("type", Convert.ToString(ex.value))}"); } return(ex.type.ToString()); }
private Node AddNode(SearchExpressionNode ex) { var node = new Node() { title = FormatTitle(ex), name = ex.id, expanded = true, userData = ex }; node.SetPosition(new Rect(ex.position, Vector2.zero)); node.RegisterCallback <GeometryChangedEvent>(OnNodeGeometryChanged); AddPorts(node, ex); AddElement(node); return(node); }
public void SetVariableSource(string name, SearchExpressionNode source) { InitializeVariables(); foreach (var v in variables) { if (v.name == name) { v.source = source; return; } } if (source != null) { AddVariable(name, source); } }
public ExpressionVariable AddVariable(string name, SearchExpressionNode source = null) { InitializeVariables(); foreach (var v in variables) { if (v.name == name) { v.source = source; return(v); } } var newVar = new ExpressionVariable(name, source); variables.Add(newVar); return(newVar); }
public SearchRequest EvaluateNode(SearchExpressionNode node) { if (node == null) { throw new ExpressionException(m_EvalNode, $"Nothing to evaluate, node has no source"); } m_Items.Clear(); m_Timer.Restart(); requestCount = 0; m_CurrentRequest = BuildRequest(node); if (m_CurrentRequest != null) { m_CurrentRequest.Resolve(OnSearchItemsReceived, OnEvaluationEnded); } return(m_CurrentRequest); }
internal bool RenameNodeVariable(SearchExpressionNode ex, string oldVariableName, string newVariableName) { if (!TryGetNode(ex, out var node)) { return(false); } var port = FindPort(node, "var", oldVariableName); if (port == null) { return(false); } port.name = $"var-{ex.id}-{newVariableName}"; port.portName = newVariableName; node.RefreshPorts(); NotifyGraphChanged(); return(true); }
public void Load(IDictionary data) { m_Nodes.Clear(); foreach (var kvp in data) { var id = (string)((DictionaryEntry)kvp).Key; var info = (IDictionary)((DictionaryEntry)kvp).Value; m_Nodes.Add(id, CreateNode(id, info)); } foreach (var kvp in m_Nodes) { var node = kvp.Value; var info = (IDictionary)data[node.id]; LoadNodeData(node, info); if (node.type == ExpressionType.Results) { m_EvalNode = node; } } }