public async Task SaveEdgesAndNodesToCsv(int parallelLevel = 10, CsvFormat csvFormat = CsvFormat.AutoTrainer)
{
var tasks = new List <Task>();
foreach (var batch in NodeTypes.Batch(parallelLevel))
{
foreach (var nodeType in batch)
{
var method = GetType().GetMethod("SaveNodesAsCsv");
var generic = method.MakeGenericMethod(nodeType.NType, nodeType.SourceType);
tasks.Add(Task.Run(() => (Task)generic.Invoke(this, new object[] { nodeType, csvFormat })));
}
await Task.WhenAll(tasks);
}
foreach (var batch in EdgeTypes.Batch(parallelLevel))
{
foreach (var edgeType in batch)
{
var method = GetType().GetMethod("SaveEdgesAsCsv");
var generic = method.MakeGenericMethod(edgeType.FromType, edgeType.ToType, edgeType.SourceType);
tasks.Add(Task.Run(() => (Task)generic.Invoke(this, new object[] { edgeType, csvFormat })));
}
await Task.WhenAll(tasks);
}
}
public EdgeType GetEdgeType(dynamic name)
{
var n = (string)name;
EdgeType type;
if (!EdgeTypes.TryGetValue(n, out type))
{
throw new MappingException(String.Format("No edge type named '{0}' could be found.", n));
}
return(type);
}
public static int FindValueInEnumEdgeTypes(string val)
{
var values = EdgeTypes.GetValues(typeof(EdgeTypes));
for (int x = 0; x < values.Length; x++)
{
if (values.GetValue(x).ToString().ToLower() == val.ToLower())
{
return(x);
}
}
return(-1);
}
public void AddEdgeType <TFrom, TTo, TSource>(
Expression <Func <TSource, dynamic> > fromKey,
Expression <Func <TSource, dynamic> > toKey,
Func <TSource, bool> predicate = null,
params Expression <Func <TSource, dynamic> >[] properties)
where TFrom : class where TTo : class
{
var edgeType = new EdgeType <TFrom, TTo, TSource>(fromKey, toKey, predicate, properties);
if (EdgeTypes.Any(e => e.Label == edgeType.Label))
{
throw new Exception($"EdgeType already added: {edgeType.Label}");
}
EdgeTypes.Add(edgeType);
}
public void ClassificateEdges(ControlFlowGraph cfg)
{
DSTree = new DepthSpanningTree(cfg);
foreach (var edge in cfg.Edges)
{
if (DSTree.Edges.Any(e => e.Target.Equals(edge.Target) && e.Source.Equals(edge.Source)))
{
EdgeTypes.Add(edge, EdgeType.Coming);
}
else if (FindBackwardPath(edge.Source, edge.Target))
{
EdgeTypes.Add(edge, EdgeType.Retreating);
}
else
{
EdgeTypes.Add(edge, EdgeType.Cross);
}
}
}
public void SetNextEdgeType()
{
// Set caption to next edge type.
// Cirulates at last element and jumps over index 0
int index = FindValueInEnumEdgeTypes(label);
if (index != -1)
{
index++;
index %= EdgeTypes.GetValues(typeof(EdgeTypes)).Length;
index = index == 0 ? index + 1 : index;
EdgeTypes newEdgeType = (EdgeTypes)index;
label = newEdgeType.ToString().ToLower();
}
else
{
// If caption could not be found in types set to first
int firstInEdgeTypes = 1;
label = ((EdgeTypes)firstInEdgeTypes).ToString().ToLower();
}
}
public TypedEdge(TVertex source, TVertex target, EdgeTypes type)
: base(source, target)
{
Type = type;
}
public SugiEdge(TEdge original, SugiVertex source, SugiVertex target, EdgeTypes type)
: base(source, target, type)
{
Original = original;
}
/// <summary>
/// Initializes a new instance of the <see cref="TypedEdge{TVertex}"/> class.
/// </summary>
/// <param name="source">Source vertex.</param>
/// <param name="target">Target vertex.</param>
/// <param name="type">Edge type.</param>
public TypedEdge([NotNull] TVertex source, [NotNull] TVertex target, EdgeTypes type)
: base(source, target)
{
Type = type;
}
public override string ToString()
{
return(string.Join("\n", EdgeTypes.Select(ed => $"[{ed.Key.Source.ToString()} -> {ed.Key.Target.ToString()}]: {ed.Value}")));
}
internal Edge(Vertex source, Vertex target, EdgeTypes type) : base(source, target, type)
{
}
public static EdgeTypes Reverse(EdgeTypes edgeType)
{
if (edgeType == EdgeTypes.Left)
return EdgeTypes.Right;
else if (edgeType == EdgeTypes.Right)
return EdgeTypes.Left;
else if (edgeType == EdgeTypes.Up)
return EdgeTypes.Down;
else if (edgeType == EdgeTypes.Down)
return EdgeTypes.Up;
return EdgeTypes.None;
}
public CrossCounterPair(EdgeTypes type)
{
Type = type;
}
