private void OnStartVertex(TVertex v)
{
VertexEventHandler <TVertex> eh = this.StartVertex;
if (eh != null)
{
eh(this, new VertexEventArgs <TVertex>(v));
}
}
protected virtual void OnVertexRemoved(VertexEventArgs <TVertex> args)
{
VertexEventHandler <TVertex> eh = this.VertexRemoved;
if (eh != null)
{
eh(this, args);
}
}
/// <summary>
/// Registers the predecessors handler
/// </summary>
/// <param name="vis"></param>
public void RegisterPredecessorRecorderHandlers(IPredecessorRecorderVisitor vis)
{
if (vis == null)
{
throw new ArgumentNullException("visitor");
}
TreeEdge += new EdgeEventHandler(vis.TreeEdge);
FinishVertex += new VertexEventHandler(vis.FinishVertex);
}
private void OnInitializeVertex(TVertex v)
{
VertexEventHandler <TVertex> eh = this.InitializeVertex;
if (eh != null)
{
eh(this, new VertexEventArgs <TVertex>(v));
}
}
/// <summary>
///
/// </summary>
/// <param name="vis"></param>
public void RegisterTimeStamperHandlers(ITimeStamperVisitor vis)
{
if (vis == null)
{
throw new ArgumentNullException("visitor");
}
DiscoverVertex += new VertexEventHandler(vis.DiscoverVertex);
FinishVertex += new VertexEventHandler(vis.FinishVertex);
}
/// <summary>
///
/// </summary>
/// <param name="vis"></param>
public void RegisterVertexColorizerHandlers(IVertexColorizerVisitor vis)
{
if (vis == null)
{
throw new ArgumentNullException("visitor");
}
InitializeVertex += new VertexEventHandler(vis.InitializeVertex);
DiscoverVertex += new VertexEventHandler(vis.DiscoverVertex);
FinishVertex += new VertexEventHandler(vis.FinishVertex);
}
/// <summary>
///
/// </summary>
/// <param name="vis"></param>
public void RegisterDistanceRecorderHandlers(IDistanceRecorderVisitor vis)
{
if (vis == null)
{
throw new ArgumentNullException("visitor");
}
InitializeVertex += new VertexEventHandler(vis.InitializeVertex);
DiscoverVertex += new VertexEventHandler(vis.DiscoverVertex);
TreeEdge += new EdgeEventHandler(vis.TreeEdge);
}
public bool Remove(IVertex item)
{
bool ret = _list.Remove(item);
// Fire a VertexRemoved event if necessary
VertexEventHandler oVertexRemoved = this.VertexRemoved;
if (oVertexRemoved != null)
{
oVertexRemoved(this, new VertexEventArgs(item));
}
return(ret);
}
Add
(
IVertex vertex
)
{
AssertValid();
ArgumentChecker oArgumentChecker = this.ArgumentChecker;
const String MethodName = "Add";
const String ArgumentName = "vertex";
oArgumentChecker.CheckArgumentNotNull(
MethodName, ArgumentName, vertex);
// Check whether the vertex already belongs to a graph.
if (vertex.ParentGraph != null)
{
oArgumentChecker.ThrowArgumentException(MethodName, ArgumentName,
"The vertex already belongs to a graph. A vertex can't be"
+ " added twice."
);
}
// The vertex is valid. Add it to the collection.
m_oLinkedList.AddLast(vertex);
// Set the vertex's parent graph.
Vertex oVertex = Vertex.IVertexToVertex(
vertex, this.ClassName, MethodName);
oVertex.SetParentGraph(m_oParentGraph);
// Fire a VertexAdded event if necessary.
VertexEventHandler oVertexAdded = this.VertexAdded;
if (oVertexAdded != null)
{
oVertexAdded(this, new VertexEventArgs(vertex));
}
AssertValid();
}
public void Add(IVertex item)
{
// Check null
if (item == null)
{
return;
}
// The vertex is valid. Add it to the collection
_list.Add(item);
// Fire a VertexAdded event if necessary.
VertexEventHandler oVertexAdded = this.VertexAdded;
if (oVertexAdded != null)
{
oVertexAdded(this, new VertexEventArgs(item));
}
}
Remove
(
LinkedListNode <IVertex> oLinkedListNode
)
{
AssertValid();
Debug.Assert(oLinkedListNode != null);
const String MethodName = "Remove";
// Cast to a Vertex.
Vertex oVertex = Vertex.IVertexToVertex(
oLinkedListNode.Value, this.ClassName, MethodName);
// Remove the vertex's incident edges.
oVertex.RemoveIncidentEdges();
// Now remove the node from the list.
m_oLinkedList.Remove(oLinkedListNode);
// The vertex no longer has a parent graph.
oVertex.SetParentGraph(null);
// Fire a VertexRemoved event if necessary.
VertexEventHandler oVertexRemoved = this.VertexRemoved;
if (oVertexRemoved != null)
{
oVertexRemoved(this, new VertexEventArgs(oVertex));
}
AssertValid();
}
/// <summary>
///
/// </summary>
/// <param name="vis"></param>
public void RegisterTimeStamperHandlers(ITimeStamperVisitor vis)
{
if (vis == null)
throw new ArgumentNullException("visitor");
DiscoverVertex += new VertexEventHandler(vis.DiscoverVertex);
FinishVertex += new VertexEventHandler(vis.FinishVertex);
}
/// <summary>
///
/// </summary>
/// <param name="vis"></param>
public void RegisterVertexColorizerHandlers(IVertexColorizerVisitor vis)
{
if (vis == null)
throw new ArgumentNullException("visitor");
InitializeVertex += new VertexEventHandler(vis.InitializeVertex);
DiscoverVertex += new VertexEventHandler(vis.DiscoverVertex);
FinishVertex += new VertexEventHandler(vis.FinishVertex);
}
/// <summary>
/// Registers the predecessors handler
/// </summary>
/// <param name="vis"></param>
public void RegisterPredecessorRecorderHandlers(IPredecessorRecorderVisitor vis)
{
if (vis == null)
throw new ArgumentNullException("visitor");
TreeEdge += new EdgeEventHandler(vis.TreeEdge);
FinishVertex += new VertexEventHandler(vis.FinishVertex);
}
/// <summary>
///
/// </summary>
/// <param name="vis"></param>
public void RegisterVisitor(IGraphvizVisitor vis)
{
WriteGraph += new EventHandler(vis.WriteGraph);
WriteVertex += new VertexEventHandler(vis.WriteVertex);
WriteEdge += new EdgeEventHandler(vis.WriteEdge);
}
//*************************************************************************
// Method: FireVertexEvent()
//
/// <summary>
/// Fires an event with the signature VertexEventHandler.
/// </summary>
///
/// <param name="oVertexEventHandler">
/// Event handler, or null if the event isn't being handled.
/// </param>
///
/// <param name="oVertex">
/// Vertex associated with the event. Can't be null.
/// </param>
//*************************************************************************
protected void FireVertexEvent(
VertexEventHandler oVertexEventHandler,
IVertex oVertex
)
{
Debug.Assert(oVertex != null);
AssertValid();
if (oVertexEventHandler != null)
{
oVertexEventHandler( this, new VertexEventArgs(oVertex) );
}
}
/// <summary>
///
/// </summary>
/// <param name="vis"></param>
public void RegisterDistanceRecorderHandlers(IDistanceRecorderVisitor vis)
{
if (vis == null)
throw new ArgumentNullException("visitor");
InitializeVertex += new VertexEventHandler(vis.InitializeVertex);
DiscoverVertex += new VertexEventHandler(vis.DiscoverVertex);
TreeEdge += new EdgeEventHandler(vis.TreeEdge);
}
/// <summary>
///
/// </summary>
/// <param name="vis"></param>
public void RegisterVisitor(IGraphvizVisitor vis)
{
WriteGraph += new EventHandler(vis.WriteGraph);
WriteVertex += new VertexEventHandler(vis.WriteVertex);
WriteEdge += new EdgeEventHandler(vis.WriteEdge);
}
/// <summary>
///
/// </summary>
/// <param name="vis"></param>
public void RegisterVertexColorizerHandlers(IVertexColorizerVisitor vis)
{
InitializeVertex += new VertexEventHandler(vis.InitializeVertex);
DiscoverVertex += new VertexEventHandler(vis.DiscoverVertex);
FinishVertex += new VertexEventHandler(vis.FinishVertex);
}
/// <summary>
///
/// </summary>
/// <param name="vis"></param>
public void RegisterVertexColorizerHandlers(IVertexColorizerVisitor vis)
{
InitializeVertex += new VertexEventHandler(vis.InitializeVertex);
DiscoverVertex += new VertexEventHandler(vis.DiscoverVertex);
FinishVertex += new VertexEventHandler(vis.FinishVertex);
}
public TypeDependencyGraph TypeDepAnalysis(List <TypeReference> typesToExamine)
{
TypeDependencyGraph tdg = new TypeDependencyGraph();
StrongComponentsAlgorithm scgo = new StrongComponentsAlgorithm(this);
scgo.Compute();
Dictionary <int, List <IVertex> > sccMap = new Dictionary <int, List <IVertex> >();
foreach (System.Collections.DictionaryEntry de in scgo.Components)
{
IVertex v = (IVertex)de.Key;
int scc_id = (int)de.Value;
if (!sccMap.ContainsKey(scc_id))
{
sccMap[scc_id] = new List <IVertex>();
}
sccMap[scc_id].Add(v);
}
Stack <List <TypeVertex> > PendingEdges = new Stack <List <TypeVertex> >();
List <TypeVertex> VertexToRemove = new List <TypeVertex>();
VertexEventHandler discV = delegate(Object s, VertexEventArgs e)
{
PendingEdges.Push(new List <TypeVertex>());
TypeVertex tv = (TypeVertex)e.Vertex;
if (scgo.Components.Contains(tv) && sccMap[scgo.Components[tv]].Count > 1)
{
tv.SCCNum = scgo.Components[tv];
tdg.AddVertex(tv);
}
else if (typesToExamine.Contains(tv.TypeRef))
{
tdg.AddVertex(tv);
}
else
{
VertexToRemove.Add(tv);
}
};
VertexEventHandler finishV = delegate(Object s, VertexEventArgs e)
{
TypeVertex tv = (TypeVertex)e.Vertex;
List <TypeVertex> pes = PendingEdges.Pop();
if (tdg.ContainsVertex(tv))
{
foreach (TypeVertex target in pes)
{
if (tdg.ContainsVertex(target) && !tdg.ContainsEdge(tv, target))
{
tdg.AddEdge(tv, target);
}
}
}
};
EdgeEventHandler treeedge = delegate(Object o, EdgeEventArgs e)
{
PendingEdges.Peek().Add((TypeVertex)e.Edge.Target);
};
DepthFirstSearchAlgorithm dfs = new DepthFirstSearchAlgorithm(this);
dfs.DiscoverVertex += discV;
dfs.FinishVertex += finishV;
dfs.TreeEdge += treeedge;
dfs.Compute();
foreach (TypeVertex v in VertexToRemove)
{
this.RemoveVertex(v);
}
return(tdg);
}
