public bool Evaluate(PropertyVertexModel vertex, PropertyEdgeModel edge)
{
switch (Scope)
{
case EdgeTraversalScope.All:
return(vertex.Edges.Any(edgeIterator => Expression.Evaluate(null, edgeIterator)));
case EdgeTraversalScope.In:
return(vertex.Edges.Any(edgeIterator => edgeIterator.TargetVertex.Id == vertex.Id && Expression.Evaluate(null, edgeIterator)));
case EdgeTraversalScope.Out:
return(vertex.Edges.Any(edgeIterator => edgeIterator.SourceVertex.Id == vertex.Id && Expression.Evaluate(null, edgeIterator)));
case EdgeTraversalScope.Mutual:
return(vertex.Edges.Any(edgeIterator =>
Expression.Evaluate(null, edgeIterator) &&
vertex.Edges.Any(mutual =>
mutual.SourceVertex.Id == edgeIterator.TargetVertex.Id &&
mutual.TargetVertex.Id == edgeIterator.SourceVertex.Id &&
Expression.Evaluate(null, mutual)
)));
default:
throw new ArgumentOutOfRangeException();
}
}
public bool Evaluate(PropertyVertexModel vertex, PropertyEdgeModel edge)
{
switch (BinaryOperator)
{
case BinaryOperator.And:
return(Left.Evaluate(vertex, edge) && Right.Evaluate(vertex, edge));
case BinaryOperator.Or:
return(Left.Evaluate(vertex, edge) || Right.Evaluate(vertex, edge));
default:
throw new ArgumentOutOfRangeException();
}
}
public bool Evaluate(PropertyVertexModel vertex, PropertyEdgeModel edge)
{
var leftValue = Left.Evaluate(vertex, edge);
var rightValue = Right.Evaluate(vertex, edge);
if (leftValue is Array)
{
return(ArrayEval(leftValue as Array, rightValue));
}
if (rightValue is Array)
{
return(ArrayEval(rightValue as Array, leftValue));
}
return(SingleEval(leftValue, rightValue));
}
private SigmaEdgeModel TransformEdge(PropertyEdgeModel edge, int idx)
{
Dictionary <string, object> props = null;
if (edge.Props != null)
{
props = new Dictionary <string, object>(edge.Props);
props.Remove("size");
}
return(new SigmaEdgeModel()
{
Id = "e" + idx,
Source = "n" + edge.Source,
Target = "n" + edge.Target,
Size = (edge.Props != null && edge.Props.ContainsKey("size")) ? Convert.ToDouble(edge.Props["size"]) : (double?)null,
Props = props
});
}
public object Evaluate(PropertyVertexModel vertex, PropertyEdgeModel edge)
{
if (edge == null)
{
return(null);
}
switch (_direction)
{
case EdgeDirection.Source:
return(_propIdentifier.Evaluate(edge.SourceVertex));
case EdgeDirection.Target:
return(_propIdentifier.Evaluate(edge.TargetVertex));
default:
throw new ArgumentOutOfRangeException();
}
}
public virtual object Evaluate(PropertyVertexModel vertex, PropertyEdgeModel edge = null)
{
if (PropName.ToLower() == "null")
{
return(null);
}
if (edge != null)
{
if (PropName.ToLower() == "name")
{
return(edge.Name);
}
if (edge.Props == null)
{
return(null);
}
object result = null;
edge.Props.TryGetValue(PropName, out result);
return(result);
}
if (vertex != null)
{
if (PropName.ToLower() == "id")
{
return(vertex.Id.ToString());
}
if (vertex.Props == null)
{
return(null);
}
object result = null;
vertex.Props.TryGetValue(PropName, out result);
return(result);
}
return(null);
}
public bool Evaluate(PropertyVertexModel vertex, PropertyEdgeModel edge)
{
return(Value);
}
public object Evaluate(PropertyVertexModel vertex = null, PropertyEdgeModel edge = null)
{
return(Val);
}
public PropertyGraphModel Transform(PropertyGraphModel graph)
{
// no vertices to filter
if (graph.Vertices == null)
{
return(graph);
}
var edges = new List <PropertyEdgeModel>();
// evaluate each vertex
var vertices = graph.Vertices
.Where(vertex => Expression.Evaluate(vertex, null))
.ToList();
// index new set of vertices
var vertexIndexer = new Dictionary <Guid, int>();
for (var i = 0; i < vertices.Count; i++)
{
vertexIndexer.Add(vertices[i].Id, i);
}
// add all edges that have both ends in vertices list
foreach (var vertex in vertices)
{
if (vertex.Edges == null)
{
continue;
}
var newVertexEdges = new List <PropertyEdgeModel>();
foreach (var edge in vertex.Edges)
{
if (edge.SourceVertex.Id != vertex.Id)
{
continue;
}
int sourceIndex;
int targetIndex;
if (vertexIndexer.TryGetValue(edge.SourceVertex.Id, out sourceIndex) &&
vertexIndexer.TryGetValue(edge.TargetVertex.Id, out targetIndex))
{
var newEdge = new PropertyEdgeModel()
{
SourceVertex = edge.SourceVertex,
TargetVertex = edge.TargetVertex,
Source = sourceIndex,
Target = targetIndex,
Name = edge.Name,
Props = edge.Props
};
edges.Add(newEdge);
newVertexEdges.Add(newEdge);
}
}
vertex.Edges = newVertexEdges;
}
var result = new PropertyGraphModel()
{
Vertices = vertices,
Edges = edges,
Data = graph.Data
};
result.CreateLinks();
return(result);
}
public PropertyGraphModel Transform(PropertyGraphModel graph)
{
// calculate groups and memberships
var groupKeyToIndexSet = new Dictionary <object, HashSet <int> >(); // groupKey to vertex index set
var lpToGroupKeySet = new Dictionary <int, HashSet <object> >();
for (int index = 0; index < graph.Vertices.Count; index++)
{
var vertex = graph.Vertices[index];
var groupKeyArray = GroupKeyArray(vertex);
if (groupKeyArray == null)
{
continue;
}
foreach (var key in groupKeyArray)
{
if (key == null)
{
continue;
}
if (!groupKeyToIndexSet.ContainsKey(key))
{
groupKeyToIndexSet[key] = new HashSet <int>();
}
groupKeyToIndexSet[key].Add(index);
if (!lpToGroupKeySet.ContainsKey(index))
{
lpToGroupKeySet[index] = new HashSet <object>();
}
lpToGroupKeySet[index].Add(key);
}
}
// transform groups to vertices
var groupVertices = new List <PropertyVertexModel>();
var groupKeyToGroupIndex = new Dictionary <object, int>();
var i = 0;
foreach (var group in groupKeyToIndexSet)
{
groupVertices.Add(new PropertyVertexModel()
{
Id = new Guid(i, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
Props = new Dictionary <string, object>()
{
{ "label", group.Key },
{ "size", group.Value.Count },
{ "members", group.Value }
}
});
groupKeyToGroupIndex[group.Key] = i;
i++;
}
// transform edges
List <PropertyEdgeModel> groupEdgesList = null;
if (graph.Edges != null)
{
var groupEdges = new Dictionary <Tuple <int, int, string>, PropertyEdgeModel>();
foreach (var edge in graph.Edges)
{
if (!lpToGroupKeySet.ContainsKey(edge.Source))
{
continue;
}
if (!lpToGroupKeySet.ContainsKey(edge.Target))
{
continue;
}
var sourceGroupSet = lpToGroupKeySet[edge.Source];
var targetGroupSet = lpToGroupKeySet[edge.Target];
foreach (var sourceGroup in sourceGroupSet)
{
var source = groupKeyToGroupIndex[sourceGroup];
foreach (var targetGroup in targetGroupSet)
{
var target = groupKeyToGroupIndex[targetGroup];
var name = edge.Name;
var key = new Tuple <int, int, string>(source, target, name);
if (!groupEdges.ContainsKey(key))
{
groupEdges[key] = new PropertyEdgeModel()
{
Name = name,
Source = source,
Target = target,
SourceVertex = groupVertices[source],
TargetVertex = groupVertices[target],
Props = new Dictionary <string, object>()
{
{ "size", 0 },
{ "connectors", new Dictionary <int, HashSet <int> >() } // member index => other members set
}
};
}
groupEdges[key].Props["size"] = (int)groupEdges[key].Props["size"] + 1;
var connectors = groupEdges[key].Props["connectors"] as Dictionary <int, HashSet <int> >;
if (!connectors.ContainsKey(edge.Source))
{
connectors[edge.Source] = new HashSet <int>()
{
edge.Target
}
}
;
else
{
connectors[edge.Source].Add(edge.Target);
}
}
}
}
groupEdgesList = groupEdges.Select(kv => kv.Value).ToList();
}
var result = new PropertyGraphModel()
{
Vertices = groupVertices,
Edges = groupEdgesList
};
result.CreateLinks();
result.Data["grouped_vertices"] = graph.Vertices;
return(result);
}
