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;
}
}
}
