public void Constructor()
{
var vertex = new TestVertex("1");
var args = new VertexEventArgs <TestVertex>(vertex);
Assert.AreSame(vertex, args.Vertex);
}
void dfs_DiscoverVertex(object sender, VertexEventArgs e)
{
TypeVertex v = (TypeVertex)e.Vertex;
Trace.WriteLine("S: " + v.Name);
Trace.Indent();
PendingEdges.Push(new List <TypeVertex>());
if (!destcg.ContainsVertex(v))
{
CondensedVertex nv;
TypeReference tref = v.TypeRef;
string trefNamespace = v.Namespace;
if (!NamespaceVertexMap.ContainsKey(trefNamespace))
{
nv = (CondensedVertex)destcg.AddVertex();
nv.NameSpaces[trefNamespace] = 0;
NamespaceVertexMap[trefNamespace] = new List <CondensedVertex>();
NamespaceVertexMap[trefNamespace].Add(nv);
}
else
{
nv = NamespaceVertexMap[trefNamespace][0];
}
nv.NameSpaces[trefNamespace]++;
nv.ContainedTypes.Add(tref);
VertexReassignmentMap[v] = nv;
return;
}
}
public void StartVertex(Object sender, VertexEventArgs args)
{
Assert.IsTrue(sender is DepthFirstSearchAlgorithm);
DepthFirstSearchAlgorithm algo = (DepthFirstSearchAlgorithm)sender;
Assert.AreEqual(algo.Colors[args.Vertex], GraphColor.White);
}
/// <summary>
/// Used internally
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
public void FinishVertex(Object sender, VertexEventArgs args)
{
IVertex v = args.Vertex;
foreach (IEdge e in VisitedGraph.OutEdges(v))
{
IVertex w = e.Target;
if (Components[w] == int.MaxValue)
{
Roots[v] = MinDiscoverTime(Roots[v], Roots[w]);
}
}
if (Roots[v] == v)
{
IVertex w = null;
do
{
w = (IVertex)m_Stack.Peek();
m_Stack.Pop();
Components[w] = m_Count;
}while (w != v);
++m_Count;
}
}
public void WriteVertex(Object sender, VertexEventArgs args)
{
GraphvizWriterAlgorithm algo = (GraphvizWriterAlgorithm)sender;
m_Vertex.Label = m_Names[args.Vertex];
algo.Output.Write(m_Vertex.ToDot());
}
private void ExamineVertex(Object sender, VertexEventArgs<int> args)
{
int u = args.Vertex;
// Ensure that the distances monotonically increase.
Assert.IsTrue(distances[u] == currentDistance
|| distances[u] == currentDistance + 1);
}
public void FinishVertex(object sender, VertexEventArgs args)
{
if (this.VisitedGraph.OutEdgesEmpty(args.Vertex))
{
this.sinks.Add(args.Vertex);
}
}
private void DiscoverVertex(Object sender, VertexEventArgs<string> args)
{
Assert.AreEqual(dfs.VertexColors[args.Vertex], GraphColor.Gray);
Assert.AreEqual(dfs.VertexColors[parents[args.Vertex]], GraphColor.Gray);
discoverTimes[args.Vertex] = time++;
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
protected void OutputGraph(Object sender, VertexEventArgs args)
{
IVertexColorizerAlgorithm algo = (IVertexColorizerAlgorithm)sender;
m_Colors = algo.Colors;
m_Algo.Write();
}
/// <summary>
/// Used internally
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private void FinishVertex(Object sender, VertexEventArgs args)
{
IVertex v = args.Vertex;
foreach (IEdge e in VisitedGraph.OutEdges(v))
{
IVertex w = e.Target;
if (this.Components[w] == int.MaxValue)
{
this.Roots[v] = MinDiscoverTime(this.Roots[v], this.Roots[w]);
}
}
if (Roots[v] == v)
{
IVertex w = null;
do
{
w = (IVertex)this.stack.Peek();
this.stack.Pop();
this.Components[w] = count;
}while (w != v);
++count;
}
}
public void FinishVertex(Object sender, VertexEventArgs args)
{
Assert.IsTrue(sender is BreadthFirstSearchAlgorithm);
BreadthFirstSearchAlgorithm algo = (BreadthFirstSearchAlgorithm)sender;
Assert.AreEqual(algo.Colors[args.Vertex], GraphColor.Black);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
public void WriteVertex(Object sender, VertexEventArgs args)
{
if (m_Colors != null && m_Colors.Contains(args.Vertex))
{
GraphColor c = (GraphColor)m_Colors[args.Vertex];
VertexFormatter.FillColor = GraphColorConverter.Convert(c);
if (c == GraphColor.Black)
{
VertexFormatter.FontColor = Color.White;
}
else
{
VertexFormatter.FontColor = Color.Black;
}
}
else
{
VertexFormatter.StrokeColor = Color.White;
}
if (m_VertexLabels != null)
{
VertexFormatter.Label = m_VertexLabels[args.Vertex].ToString();
}
((GraphvizAlgorithm)sender).Output.Write(VertexFormatter.ToDot());
}
private void DiscoverVertex(Object sender, VertexEventArgs <string> args)
{
Assert.AreEqual(dfs.VertexColors[args.Vertex], GraphColor.Gray);
Assert.AreEqual(dfs.VertexColors[parents[args.Vertex]], GraphColor.Gray);
discoverTimes[args.Vertex] = time++;
}
public void FinishVertex(Object sender, VertexEventArgs args)
{
Assert.IsTrue(sender is DepthFirstSearchAlgorithm);
DepthFirstSearchAlgorithm algo = (DepthFirstSearchAlgorithm)sender;
Assert.AreEqual(algo.Colors[args.Vertex], GraphColor.Black);
FinishTimes[args.Vertex] = m_Time++;
}
m_oNodeXLControl_VertexMouseHover
(
object sender,
VertexEventArgs vertexEventArgs
)
{
AddToStatus("VertexMouseHover: " + vertexEventArgs.Vertex);
}
private void ExamineVertex(Object sender, VertexEventArgs <int> args)
{
int u = args.Vertex;
// Ensure that the distances monotonically increase.
Assert.IsTrue(distances[u] == currentDistance ||
distances[u] == currentDistance + 1);
}
public void WriteVertex(Object sender, VertexEventArgs args)
{
GraphvizWriterAlgorithm algo = (GraphvizWriterAlgorithm)sender;
m_Vertex.Label = m_Names[args.Vertex];
algo.Output.Write(m_Vertex.ToDot());
}
m_oNodeXLControl_VertexDoubleClick
(
object sender,
VertexEventArgs vertexEventArgs
)
{
AddToStatus("VertexDoubleClick: " + vertexEventArgs.Vertex);
}
void dfs_StartVertex(object sender, VertexEventArgs <TVertex> e)
{
// we are looking on a new tree
this.currentComponent = this.componentEquivalences.Count;
this.componentEquivalences.Add(this.currentComponent, this.currentComponent);
this.componentCount++;
this.components.Add(e.Vertex, this.currentComponent);
}
private void DiscoverVertex(Object sender, VertexEventArgs <TVertex> args)
{
TVertex v = args.Vertex;
this.Roots[v] = v;
this.Components[v] = int.MaxValue;
this.DiscoverTimes[v] = dfsTime++;
this.stack.Push(v);
}
private void RaiseNewVertexInRepo(Repo.INode node)
{
var args = new VertexEventArgs
{
Node = node
};
this.NewVertexInRepo?.Invoke(this, args);
}
/// <summary>
/// Used internally
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
public void DiscoverVertex(Object sender, VertexEventArgs args)
{
IVertex v = args.Vertex;
Roots[v] = v;
Components[v] = int.MaxValue;
DiscoverTimes[v] = m_DfsTime++;
m_Stack.Push(v);
}
public void WriteVertex(Object sender, VertexEventArgs args)
{
// setting the vertex name
Vertex.Label = Names[args.Vertex];
// outputting to dot
// sender is the graphviz writer algorithm
((GraphvizAlgorithm)sender).Output.Write(Vertex.ToDot());
}
void udfs_StartVertex(Object sender, VertexEventArgs e)
{
if (this.startVertex == null)
{
this.startVertex = (DataTableJoinVertex)e.Vertex;
return;
}
throw new InvalidOperationException("The Join graph is not connected");
}
public void DiscoverVertex(Object sender, VertexEventArgs args)
{
Assert.IsTrue(sender is DepthFirstSearchAlgorithm);
DepthFirstSearchAlgorithm algo = (DepthFirstSearchAlgorithm)sender;
Assert.AreEqual(algo.Colors[args.Vertex], GraphColor.Gray);
Assert.AreEqual(algo.Colors[Parents[args.Vertex]], GraphColor.Gray);
DiscoverTimes[args.Vertex] = m_Time++;
}
/// <summary>
/// Does a depth first search on the vertex u
/// </summary>
/// <param name="u">vertex to explore</param>
/// <exception cref="ArgumentNullException">u cannot be null</exception>
public void Visit(IVertex u)
{
if (u == null)
{
throw new ArgumentNullException("u");
}
IVertex v = null;
Colors[u] = GraphColor.Gray;
VertexEventArgs uArgs = new VertexEventArgs(u);
if (this.DiscoverVertex != null)
{
DiscoverVertex(this, uArgs);
}
foreach (IEdge e in VisitedGraph.OutEdges(u))
{
EdgeEventArgs eArgs = new EdgeEventArgs(e);
if (this.ExamineEdge != null)
{
ExamineEdge(this, eArgs);
}
v = e.Target;
if (Colors[v] == GraphColor.White)
{
if (this.TreeEdge != null)
{
TreeEdge(this, eArgs);
}
Visit(v);
}
else if (Colors[v] == GraphColor.Gray)
{
if (this.BackEdge != null)
{
BackEdge(this, eArgs);
}
}
else
{
if (this.ForwardOrCrossEdge != null)
{
ForwardOrCrossEdge(this, eArgs);
}
}
}
Colors[u] = GraphColor.Black;
if (this.FinishVertex != null)
{
FinishVertex(this, uArgs);
}
}
private void DiscoverVertex(Object sender, VertexEventArgs <int> args)
{
int u = args.Vertex;
Assert.AreEqual(algo.GetVertexColor(u), GraphColor.Gray);
if (u != sourceVertex)
{
Assert.AreEqual(distances[u], currentDistance + 1);
Assert.AreEqual(distances[u], distances[parents[u]] + 1);
}
}
/// <summary>
/// Used internally
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
public void StartVertex(Object sender, VertexEventArgs args)
{
if (m_Count == int.MaxValue)
{
m_Count = 0; // start counting components at zero
}
else
{
++m_Count;
}
}
private void DiscoverVertex(Object sender, VertexEventArgs<int> args)
{
int u = args.Vertex;
Assert.AreEqual(algo.GetVertexColor(u), GraphColor.Gray);
if (u != sourceVertex)
{
Assert.AreEqual(distances[u], currentDistance + 1);
Assert.AreEqual(distances[u], distances[parents[u]] + 1);
}
}
private void ExamineVertex(Object sender, VertexEventArgs<string> args)
{
string u = args.Vertex;
currentVertex = u;
// Ensure that the distances monotonically increase.
Assert.IsTrue(
distances[u] == currentDistance
|| distances[u] == currentDistance + 1
);
if (distances[u] == currentDistance + 1) // new level
++currentDistance;
}
/// <summary>
/// Records end of path vertex
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
public void FinishVertex(Object sender, VertexEventArgs args)
{
foreach (DictionaryEntry de in Predecessors)
{
IEdge e = (IEdge)de.Value;
if (e.Source == args.Vertex)
{
return;
}
}
// if (!Predecessors.Contains(args.Vertex))
EndPathVertices.Add(args.Vertex);
}
void FinishVertex(Object sender, VertexEventArgs <TVertex> e)
{
if (this.RecordEndPath)
{
foreach (TEdge edge in this.VertexPredecessors.Values)
{
if (edge.Source.Equals(e.Vertex))
{
return;
}
}
this.endPathVertices.Add(e.Vertex);
}
}
private void DiscoverVertex(Object sender, VertexEventArgs<string> args)
{
string u = args.Vertex;
Assert.AreEqual(algo.VertexColors[u], GraphColor.Gray);
if (u == sourceVertex)
currentVertex = sourceVertex;
else
{
Assert.AreEqual(parents[u], currentVertex);
Assert.AreEqual(distances[u], currentDistance + 1);
Assert.AreEqual(distances[u], distances[parents[u]] + 1);
}
}
private void DiscoverVertex(Object sender, VertexEventArgs <string> args)
{
string u = args.Vertex;
Assert.AreEqual(algo.VertexColors[u], GraphColor.Gray);
if (u == sourceVertex)
{
currentVertex = sourceVertex;
}
else
{
Assert.AreEqual(parents[u], currentVertex);
Assert.AreEqual(distances[u], currentDistance + 1);
Assert.AreEqual(distances[u], distances[parents[u]] + 1);
}
}
private void ExamineVertex(Object sender, VertexEventArgs <string> args)
{
string u = args.Vertex;
currentVertex = u;
// Ensure that the distances monotonically increase.
Assert.IsTrue(
distances[u] == currentDistance ||
distances[u] == currentDistance + 1
);
if (distances[u] == currentDistance + 1) // new level
{
++currentDistance;
}
}
VertexCollection_VertexAdded
(
Object oSender,
VertexEventArgs oVertexEventArgs
)
{
if (oSender == null || !(oSender is IVertexCollection))
{
throw new ApplicationException(
"VertexAdded event provided incorrect oSender argument."
);
}
m_bVertexAdded = true;
m_oAddedVertex = oVertexEventArgs.Vertex;
}
private void FinishVertex(Object sender, VertexEventArgs<int> args)
{
Assert.AreEqual(algo.GetVertexColor(args.Vertex), GraphColor.Gray);
}
private void FinishVertex(Object sender, VertexEventArgs<string> args)
{
Assert.AreEqual(algo.VertexColors[args.Vertex], GraphColor.Black);
}
private void StartVertex(Object sender, VertexEventArgs<string> args)
{
Assert.AreEqual(dfs.VertexColors[args.Vertex], GraphColor.White);
}
private void InitializeVertex(Object sender, VertexEventArgs<string> args)
{
Assert.AreEqual(algo.VertexColors[args.Vertex], GraphColor.White);
}
private void FinishVertex(Object sender, VertexEventArgs<string> args)
{
Assert.AreEqual(dfs.VertexColors[args.Vertex], GraphColor.Black);
finishTimes[args.Vertex] = time++;
}
private void InitializeVertex(Object sender, VertexEventArgs<int> args)
{
Assert.AreEqual(algo.GetVertexColor(args.Vertex), GraphColor.White);
}
