private void AddPortalsForLevel(BidirectionalGraph <Point, Edge <Point> > graph, HashSet <Portal> portals, int level)
{
foreach (var portalPair in portals.GroupBy(p => p.Name).Where(g => g.Count() == 2))
{
var pair = portalPair.ToArray();
var outerPortal = portalPair.First(p => p.IsOuter);
var innerPortal = portalPair.First(p => !p.IsOuter);
// Connect the inner portal to the next level and the outer portal to to previous level.
// Connect the inner portal at the level above this level to the outer portal at this level.
var innerPortalSource = GetPointForLevel(innerPortal.MapLocation, level - 1);
var innerPortalTarget = GetPointForLevel(outerPortal.MapLocation, level);
if (graph.ContainsVertex(innerPortalSource) && graph.ContainsVertex(innerPortalTarget))
{
var edge = new Edge <Point>(innerPortalSource, innerPortalTarget);
graph.AddEdge(edge);
graph.AddEdge(edge.Reverse);
}
// Connect the outer portal at this level to the inner portal at the level below this.
var outerPortalSource = GetPointForLevel(outerPortal.MapLocation, level);
var outerPortalTarget = GetPointForLevel(innerPortal.MapLocation, level + 1);
if (graph.ContainsVertex(outerPortalSource) && graph.ContainsVertex(outerPortalTarget))
{
var edge = new Edge <Point>(outerPortalSource, outerPortalTarget);
graph.AddEdge(edge);
graph.AddEdge(edge.Reverse);
}
}
}
public BidirectionalGraph <Point, Edge <Point> > BuildDoorGraph(Point location)
{
var graph = new BidirectionalGraph <Point, Edge <Point> >();
var keysUnlocked = new Dictionary <char, List <char> >();
var reachablePoints = ReachablePoints(location).ToArray();
var doorsReachable = reachablePoints.Where(p => _doors.ContainsKey(p)).ToArray();
foreach (var source in doorsReachable)
{
// Connect them together.
foreach (var target in doorsReachable)
{
if (source != target)
{
if (!graph.ContainsVertex(source))
{
graph.AddVertex(source);
}
if (!graph.ContainsVertex(target))
{
graph.AddVertex(target);
}
graph.AddEdge(new Edge <Point>(source, target));
}
}
}
return(graph);
}
/// <summary>
/// Retourne True si une sortie d'un component1 à une sortie d'un component2 ont été reliées, et si c'est le cas mettre à jour les input/output
/// </summary>
/// <param name="component1">Le composant qui comporte le input/output sortie</param>
/// <param name="component2">Le composant qui comporte le input/output entree</param>
/// <param name="sortie">La sortie à relier</param>
/// <param name="entree">L'entrée à relier</param>
/// <returns></returns>
public bool Relate(Outils component1, Outils component2, Sortie sortie, ClasseEntree entree)
{
component1.circuit = this;
component2.circuit = this;
//On vérifie si l'entrée entree n'est pas déjà reliée,
//et si sortie et entree ont le meme état booléen,
//et si sortie est contenue dans la liste_sorties de component1,
//et si entree est contenue dans la liste_sentrees de component2,
//et si component1 et component2 sont contenus dans le circuit
if (!entree.getRelated() && entree.getEtat() == sortie.getEtat() && component1.getListesorties().Contains(sortie) && component2.getListeentrees().Contains(entree) && Circuit.ContainsVertex(component2) && Circuit.ContainsVertex(component1)) //Si l'entrée de component2 n'est pas reliée
{
OutStruct outstruct = new OutStruct(entree, component2); //Mise à jour des liaison
if (!sortie.getSortie().Contains(outstruct))
{
sortie.getSortie().Add(outstruct);
entree.setRelated(true);//Mise à jour de related
}
if (!Circuit.ContainsEdge(component1, component2)) //Si il n'y a pas un edge déja présent liant component1 et component2
{
Edge <Outils> edge = new Edge <Outils>(component1, component2);
Circuit.AddEdge(edge); //Ajouter edge entre component1 et component2
}
entree.setEtat(sortie.getEtat()); //Mise à jour de l'état d'entree de component2
return(true); // component1 et component2 liées avec succès
}
else
{
return(false);
}
}
public void AddEdge(string Source, string Target)
{
if (!graph.ContainsVertex(Source))
{
AddNode(Source);
}
if (!graph.ContainsVertex(Target))
{
AddNode(Target);
}
graph.AddEdge(new Edge <string>(Source, Target));
}
public void removeIsolatedVertices()
{
var graph = new BidirectionalGraph <int, IEdge <int> >();
graph.AddVertex(1);
var edge = new EquatableEdge <int>(2, 3);
graph.AddVerticesAndEdge(edge);
var predicate = new IsolatedVertexPredicate <int, IEdge <int> >(graph);
graph.RemoveVertexIf(predicate.Test);
Assert.IsTrue(graph.ContainsVertex(2));
Assert.IsTrue(graph.ContainsEdge(edge));
Assert.IsFalse(graph.ContainsVertex(1));
}
private BidirectionalGraph <Point, Edge <Point> > BuildGraph(HashSet <Point> map, char[] keys, Dictionary <Point, char> doors, Point startingLocation)
{
var graph = new BidirectionalGraph <Point, Edge <Point> >();
graph.AddVertex(startingLocation);
var pointsToCheck = new Queue <Point>();
pointsToCheck.Enqueue(startingLocation);
while (pointsToCheck.Count > 0)
{
var source = pointsToCheck.Dequeue();
foreach (var dir in _allDirections)
{
// Is there a location on the map in this direction?
var target = source.GetPoint(dir);
if (map.Contains(target) && !graph.ContainsVertex(target))
{
// Valid point that we can move to.
graph.AddVertex(target);
graph.AddEdge(new Edge <Point>(source, target));
graph.AddEdge(new Edge <Point>(target, source));
// Can we continue past this location?
if (!doors.ContainsKey(target) || keys.Contains(doors[target]))
{
pointsToCheck.Enqueue(target);
}
}
}
}
return(graph);
}
private void AddVertex_Click(object sender, RoutedEventArgs e)
{
if (graph == null || graph.VertexCount >= 100)
{
return;
}
var rnd = new Random(DateTime.Now.Millisecond);
int verticesToAdd = Math.Max(graph.VertexCount / 4, 1);
var parents = new string[verticesToAdd];
for (int j = 0; j < verticesToAdd; j++)
{
parents[j] = graph.Vertices.ElementAt(rnd.Next(graph.VertexCount));
}
for (int i = 0; i < verticesToAdd; i++)
{
string newVertex = string.Empty;
do
{
newVertex = rnd.Next(0, graph.VertexCount + 20) + "_new";
} while (graph.ContainsVertex(newVertex));
graph.AddVertex(newVertex);
if (graph.VertexCount < 2)
{
return;
}
//string vo1 = graph.Vertices.ElementAt(rnd.Next(Math.Max(9 * graph.VertexCount / 10, graph.VertexCount - 1)));
graph.AddEdge(new Edge <string>(parents[i], newVertex));
}
}
public void Add(Node node, bool isOutput = false, bool isInput = false)
{
if (isOutput && !Outputs.Contains(node))
{
Outputs.Add(node);
}
if (isInput && !Inputs.Contains(node))
{
Inputs.Add(node);
}
if (graph.ContainsVertex(node))
{
return;
}
if (!NodeIndex.ContainsKey(node.Value))
{
NodeIndex[node.Value] = node;
}
else if (NodeIndex[node.Value] != node)
{
NodeIndex[node.Value] = node; //TODO: this could be really bad!!!
//throw new InvalidOperationException($"a node with the value '{node.Value}' already exists!");
}
graph.AddVertex(node);
node.OnAdd(this);
}
public static IEnumerable <string> Get_Branch_Points_Backwards(string vertex, BidirectionalGraph <string, TaggedEdge <string, ITag> > graph)
{
var visited = new HashSet <string>();
return(Get_Branch_Points_Backwards_LOCAL(vertex));
#region Local Method
IEnumerable <string> Get_Branch_Points_Backwards_LOCAL(string v1)
{
if (visited.Contains(v1))
{
yield break;
}
if (!graph.ContainsVertex(v1))
{
yield break;
}
if (graph.OutDegree(v1) > 1)
{
visited.Add(v1);
yield return(v1);
}
foreach (var edge in graph.InEdges(v1))
{
foreach (var v in Get_Branch_Points_Backwards_LOCAL(edge.Source))
{
yield return(v);
}
}
}
#endregion
}
/// <summary>
/// Removes the group that is related to the specified ID.
/// </summary>
/// <param name="group">The ID of the group that should be removed.</param>
/// <returns>A task that indicates when the removal has taken place.</returns>
public Task Remove(GroupCompositionId group)
{
{
Debug.Assert(group != null, "The ID that should be removed should not be a null reference.");
Debug.Assert(m_Groups.ContainsKey(group), "The ID should be known.");
}
m_Diagnostics.Log(
LevelToLog.Trace,
HostConstants.LogPrefix,
string.Format(
CultureInfo.InvariantCulture,
Resources.ProxyCompositionLayer_LogMessage_RemovingGroup_WithId,
group));
var remoteTask = m_Commands.Remove(group);
return(remoteTask.ContinueWith(
t =>
{
lock (m_Lock)
{
if (m_GroupConnections.ContainsVertex(group))
{
m_GroupConnections.RemoveVertex(group);
}
if (m_Groups.ContainsKey(group))
{
m_Groups.Remove(group);
}
}
}));
}
private void OnAddVertexClick(object sender, RoutedEventArgs args)
{
if (_graph is null || _graph.VertexCount >= 100)
{
return;
}
var random = new Random(DateTime.Now.Millisecond);
int verticesToAdd = Math.Max(_graph.VertexCount / 4, 1);
var parents = new string[verticesToAdd];
for (int j = 0; j < verticesToAdd; ++j)
{
int index = random.Next(_graph.VertexCount);
parents[j] = _graph.Vertices.ElementAt(index);
}
for (int i = 0; i < verticesToAdd; ++i)
{
string newVertex;
do
{
newVertex = $"{random.Next(0, _graph.VertexCount + 20)}_new";
} while (_graph.ContainsVertex(newVertex));
_graph.AddVertex(newVertex);
if (_graph.VertexCount < 2)
{
return;
}
_graph.AddEdge(new Edge <string>(parents[i], newVertex));
}
}
/// <summary>
/// Traverses the schedule and applies an action to each vertex visited.
/// </summary>
/// <param name="start">The vertex where the traverse should be started.</param>
/// <param name="vertexAction">
/// The action taken for each vertex that is encountered. The action is provided with the current vertex and
/// a collection of all outbound, if <paramref name="traverseViaOutBoundVertices"/> is <see langword="true" />,
/// or inbound vertices and the ID of the traversing condition. The function should return <see langword="false" />
/// to terminate the traverse.
/// </param>
/// <param name="traverseViaOutBoundVertices">
/// A flag indicating if the schedule should be traversed via the outbound edges of the vertices, or the inbound ones.
/// </param>
public void TraverseAllScheduleVertices(
IScheduleVertex start,
Func <IScheduleVertex, IEnumerable <Tuple <ScheduleElementId, IScheduleVertex> >, bool> vertexAction,
bool traverseViaOutBoundVertices = true)
{
{
Lokad.Enforce.Argument(() => start);
Lokad.Enforce.With <UnknownScheduleVertexException>(
m_Graph.ContainsVertex(start),
Resources.Exceptions_Messages_UnknownScheduleVertex);
Lokad.Enforce.Argument(() => vertexAction);
}
var nodeCounter = new List <IScheduleVertex>();
var uncheckedVertices = new Queue <IScheduleVertex>();
uncheckedVertices.Enqueue(start);
while (uncheckedVertices.Count > 0)
{
var source = uncheckedVertices.Dequeue();
if (nodeCounter.Contains(source))
{
continue;
}
nodeCounter.Add(source);
var outEdges = traverseViaOutBoundVertices ? m_Graph.OutEdges(source) : m_Graph.InEdges(source);
var traverseMap = from edge in outEdges
select new Tuple <ScheduleElementId, IScheduleVertex>(
edge.TraversingCondition,
traverseViaOutBoundVertices ? edge.Target : edge.Source);
var result = vertexAction(source, traverseMap);
if (!result)
{
return;
}
foreach (var outEdge in outEdges)
{
uncheckedVertices.Enqueue(traverseViaOutBoundVertices ? outEdge.Target : outEdge.Source);
}
}
}
/// <summary>
/// Returns a possible implicit cast chain.
/// </summary>
/// <param name="original"></param>
/// <param name="destinationType"></param>
/// <returns></returns>
public IEnumerable <CoercionRule> GetImplicitlyCastChain(System.Type original, System.Type destinationType)
{
if (implicitCoercionRules.ContainsVertex(original) && implicitCoercionRules.ShortestPathsDijkstra(t => 1, original)(destinationType, out IEnumerable <TaggedEdge <Type, CoercionRule> > result))
{
return(result.Select(e => e.Tag).ToArray());
}
return(Enumerable.Empty <CoercionRule>());
}
public BidirectionalGraph <object, IEdge <object> > toGraphSharp()
{
BidirectionalGraph <object, IEdge <object> > gr = new BidirectionalGraph <object, IEdge <object> >();
foreach (var v in a)
{
if (!gr.ContainsVertex(v.Origem))
{
gr.AddVertex(v.Origem);
}
if (!gr.ContainsVertex(v.vertice))
{
gr.AddVertex(v.vertice);
}
gr.AddEdge(new TaggedEdge <object, object>(v.Origem, v.vertice, v.peso));
}
return(gr);
}
public IReadOnlyList <TVertex> GetConnectedVertices(TVertex vertex, Func <TVertex, TEdge, bool> edgePredicate, bool recursive = false)
{
lock (SyncRoot)
{
if (!Graph.ContainsVertex(vertex))
{
return(new TVertex[0]);
}
return(GetConnectedVerticesRecursive(vertex, edgePredicate, recursive).ToArray());
}
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
protected void AddNode(NodeVertex node)
{
// Skip if it it already been added
if (graph.ContainsVertex(node))
{
return;
}
// Add the vertex to the logic graph
graph.AddVertex(node);
// Create the vertex control
var control = AssociatedObject.ControlFactory.CreateVertexControl(node);
control.DataContext = node;
//control.Visibility = Visibility.Hidden; // make them invisible (there is no layout positions yet calculated)
// Create data binding for input slots and output slots
var binding = new Binding();
binding.Path = new PropertyPath("InputSlots");
binding.Mode = BindingMode.TwoWay;
binding.Source = node;
binding.UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged;
BindingOperations.SetBinding(control, NodeVertexControl.InputSlotsProperty, binding);
binding = new Binding();
binding.Path = new PropertyPath("OutputSlots");
binding.Mode = BindingMode.TwoWay;
binding.Source = node;
binding.UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged;
BindingOperations.SetBinding(control, NodeVertexControl.OutputSlotsProperty, binding);
// Add vertex and control to the graph area
AssociatedObject.AddVertex(node, control);
AssociatedObject.RelayoutGraph();
// Connect control
node.ConnectControl(control);
}
/// <summary>
/// Initializes a new instance of the <see cref="Schedule"/> class.
/// </summary>
/// <param name="graph">The graph that describes the current schedule.</param>
/// <param name="start">The start node for the schedule.</param>
/// <param name="end">The end node for the schedule.</param>
public Schedule(
BidirectionalGraph <IScheduleVertex, ScheduleEdge> graph,
IScheduleVertex start,
IScheduleVertex end)
{
{
Debug.Assert(graph != null, "The graph should not be a null reference.");
Debug.Assert(start != null, "The start vertex should not be a null reference.");
Debug.Assert(start is StartVertex, "The start vertex should be an editable start vertex.");
Debug.Assert(graph.ContainsVertex(start), "The start vertex should be part of the graph.");
Debug.Assert(end != null, "The end vertex should not be a null reference.");
Debug.Assert(end is EndVertex, "The end vertex should be an editable end vertex.");
Debug.Assert(graph.ContainsVertex(end), "The end vertex should be part of the graph.");
}
m_Start = start;
m_End = end;
m_Graph = graph;
}
public void ReadFromString(string metroNetworkGraphStr)
{
if(String.IsNullOrWhiteSpace(metroNetworkGraphStr))
throw new ArgumentException("Metro network string either null, empty or consists only of whitespaces", "metroNetworkGraphStr");
try
{
var edges = metroNetworkGraphStr.Split(',').Select(s => s.Trim());
foreach (var edgeStr in edges)
{
var stationPairAndDistance = edgeStr.Split(':');
var stationPair = stationPairAndDistance[0].Split('-');
var station1 = stationPair[0];
var station2 = stationPair[1];
var distance = Int32.Parse(stationPairAndDistance[1]);
if (!_graph.ContainsVertex(station1))
{
_graph.AddVertex(station1);
}
if (!_graph.ContainsVertex(station2))
{
_graph.AddVertex(station2);
}
var edge = new Edge<string>(station1, station2);
if (!_graph.ContainsEdge(edge))
{
_graph.AddEdge(edge);
_costs.Add(edge, distance);
}
}
}
catch (Exception exc)
{
throw new FormatException("Can't read a metro networkgraph - string is in incorrect format", exc);
}
}
private void AddTypeToGraph(TypeDefinition type)
{
var derivedTypes = m_Types
.Where(
p =>
{
return(p.Value.BaseInterfaces.Contains(type.Identity) ||
((p.Value.BaseType != null) && p.Value.BaseType.Equals(type.Identity)) ||
((p.Value.GenericTypeDefinition != null) && p.Value.GenericTypeDefinition.Equals(type.Identity)));
})
.Select(p => p.Key)
.ToList();
m_TypeGraph.AddVertex(type.Identity);
if ((type.BaseType != null) && m_TypeGraph.ContainsVertex(type.BaseType))
{
m_TypeGraph.AddEdge(new Edge <TypeIdentity>(type.Identity, type.BaseType));
}
if ((type.GenericTypeDefinition != null) && m_TypeGraph.ContainsVertex(type.GenericTypeDefinition))
{
m_TypeGraph.AddEdge(new Edge <TypeIdentity>(type.Identity, type.GenericTypeDefinition));
}
foreach (var baseInterface in type.BaseInterfaces)
{
if ((baseInterface != null) && m_TypeGraph.ContainsVertex(baseInterface))
{
m_TypeGraph.AddEdge(new Edge <TypeIdentity>(type.Identity, baseInterface));
}
}
foreach (var derivedType in derivedTypes)
{
m_TypeGraph.AddEdge(new Edge <TypeIdentity>(derivedType, type.Identity));
}
}
public static IEnumerable <string> Get_First_Mutual_Branch_Point_Backwards(string vertex, BidirectionalGraph <string, TaggedEdge <string, Tag> > graph)
{
Contract.Requires(graph != null);
if (!graph.ContainsVertex(vertex))
{
yield break;
}
int inDegree = graph.InDegree(vertex);
if (inDegree < 2)
{
yield break; // the provided vertex is not a mergePoint
}
if (inDegree == 2)
{
string s1 = graph.InEdge(vertex, 0).Source;
string s2 = graph.InEdge(vertex, 1).Source;
if (s1 != s2)
{
HashSet <string> branchPoints1 = new HashSet <string>();
HashSet <string> branchPoints2 = new HashSet <string>();
foreach (string v in Get_First_Branch_Point_Backwards(s1, graph))
{
branchPoints1.Add(v);
}
foreach (string v in Get_First_Branch_Point_Backwards(s2, graph))
{
branchPoints2.Add(v);
}
foreach (string mutual in branchPoints1.Intersect(branchPoints2))
{
yield return(mutual);
}
}
}
else
{
Console.WriteLine("WARNING: Get_First_Mutual_Branch_Point_Backwards: multiple merge points at this the provided vertex " + vertex);
}
}
/// <summary>
/// Adds a vertex that indicates the end of a synchronization block.
/// </summary>
/// <param name="startPoint">The vertex that forms the start point of the block.</param>
/// <returns>The vertex that indicates the end of a synchronization block.</returns>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="startPoint"/> is <see langword="null" />.
/// </exception>
/// <exception cref="UnknownScheduleVertexException">
/// Thrown if <paramref name="startPoint"/> is not part of the current schedule.
/// </exception>
public SynchronizationEndVertex AddSynchronizationEnd(SynchronizationStartVertex startPoint)
{
{
Lokad.Enforce.Argument(() => startPoint);
Lokad.Enforce.With <UnknownScheduleVertexException>(
m_Schedule.ContainsVertex(startPoint),
Resources.Exceptions_Messages_UnknownScheduleVertex);
}
var result = new SynchronizationEndVertex(m_Schedule.VertexCount);
m_Schedule.AddVertex(result);
return(result);
}
public static BidirectionalGraph<object, IEdge<object>> ToBidirectionalGraph(this AssemblyDependencyGraph graph)
{
// convert schedule graph into generic bidirectional graph that is bindable to the WPF control
var g = new BidirectionalGraph<object, IEdge<object>>();
foreach (Assembly assembly in graph.GetAssemblies())
{
string fromAssemblyName = assembly.GetName().Name;
g.AddVertex(fromAssemblyName);
foreach (Assembly dependantAssembly in graph.GetDependantAssemblies(assembly))
{
string toAssemblyName = dependantAssembly.GetName().Name;
if (!g.ContainsVertex(toAssemblyName))
{
g.AddVertex(toAssemblyName);
}
g.AddEdge(new Edge<object>(fromAssemblyName, toAssemblyName));
}
}
return g;
}
public static BidirectionalGraph <object, IEdge <object> > ToBidirectionalGraph(this AssemblyDependencyGraph graph)
{
// convert schedule graph into generic bidirectional graph that is bindable to the WPF control
var g = new BidirectionalGraph <object, IEdge <object> >();
foreach (Assembly assembly in graph.GetAssemblies())
{
string fromAssemblyName = assembly.GetName().Name;
g.AddVertex(fromAssemblyName);
foreach (Assembly dependantAssembly in graph.GetDependantAssemblies(assembly))
{
string toAssemblyName = dependantAssembly.GetName().Name;
if (!g.ContainsVertex(toAssemblyName))
{
g.AddVertex(toAssemblyName);
}
g.AddEdge(new Edge <object>(fromAssemblyName, toAssemblyName));
}
}
return(g);
}
private void FloodFill(IntCode vm, ref Point currentPos, Dictionary <Point, Status> map, BidirectionalGraph <Point, Edge <Point> > g)
{
// Check all directions from this point.
var pointsToCheck = new Stack <Point>();
pointsToCheck.Push(currentPos);
var pointStatus = new Dictionary <Direction, Status>();
while (pointsToCheck.Count > 0)
{
var pointToCheck = pointsToCheck.Pop();
Log(string.Empty);
Log($"Checking new point {pointToCheck}");
MoveTo(pointToCheck, ref currentPos, g, vm, $"new point to check {pointToCheck}");
var dirsToCheck = Enum.GetValues(typeof(Direction)).Cast <Direction>();
pointStatus.Clear();
foreach (var dir in dirsToCheck)
{
var targetPos = currentPos.GetLocation(dir);
if (map.ContainsKey(targetPos))
{
continue;
}
var currentStatus = Move(ref currentPos, dir, vm, $"checking out unknown position.");
pointStatus.Add(dir, currentStatus);
map[targetPos] = currentStatus;
switch (currentStatus)
{
case Status.Wall:
// The robot did not move, but it hit a wall.
break;
case Status.Empty:
// We moved, and are now at the target position
if (!g.ContainsVertex(targetPos))
{
g.AddVertex(targetPos);
}
g.AddEdge(new Edge <Point>(pointToCheck, targetPos));
g.AddEdge(new Edge <Point>(targetPos, pointToCheck));
// Add it as a point to check.
pointsToCheck.Push(targetPos);
// Then go back to the pointToCheck.
MoveTo(pointToCheck, ref currentPos, g, vm, $"point checked. Moving back to {pointToCheck}");
break;
case Status.System:
// We moved, and are now at the target position
if (!g.ContainsVertex(targetPos))
{
g.AddVertex(targetPos);
}
// We found the oxygen system. No need to check any further in this path. (No other way will be shorter than this).
// We just go back to the current position.
g.AddEdge(new Edge <Point>(pointToCheck, targetPos));
g.AddEdge(new Edge <Point>(targetPos, pointToCheck));
MoveTo(pointToCheck, ref currentPos, g, vm, $"point checked (System found). Moving back to {pointToCheck}");
break;
}
}
Log($"Finished with {pointToCheck}:");
foreach (var kvp in pointStatus)
{
Log($" {kvp.Key}: {kvp.Value}");
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Schedule"/> class.
/// </summary>
/// <param name="graph">The graph that describes the current schedule.</param>
/// <param name="start">The start node for the schedule.</param>
/// <param name="end">The end node for the schedule.</param>
public Schedule(
BidirectionalGraph<IScheduleVertex, ScheduleEdge> graph,
IScheduleVertex start,
IScheduleVertex end)
{
{
Debug.Assert(graph != null, "The graph should not be a null reference.");
Debug.Assert(start != null, "The start vertex should not be a null reference.");
Debug.Assert(start is StartVertex, "The start vertex should be an editable start vertex.");
Debug.Assert(graph.ContainsVertex(start), "The start vertex should be part of the graph.");
Debug.Assert(end != null, "The end vertex should not be a null reference.");
Debug.Assert(end is EndVertex, "The end vertex should be an editable end vertex.");
Debug.Assert(graph.ContainsVertex(end), "The end vertex should be part of the graph.");
}
m_Start = start;
m_End = end;
m_Graph = graph;
}
public bool ContainsVertex(TVertexId vertexId) => _graph.ContainsVertex(vertexId);
void setElement(InfoWrapper W, int parent, int children)
{
BidirectionalGraph<object, IEdge<object>> L = new BidirectionalGraph<object, IEdge<object>>();
L.AddVertex(W);
if (parent != 0)
{
InfoWrapper c = W;
while (c.Parent.pString != "")
{
InfoWrapper p = m_pData[W.Parent.pString];
if (!L.ContainsVertex(p))
L.AddVertex(p);
L.AddEdge(new Edge<object>(p, c));
if (parent == 1 || p.Name.pString == c.Name.pString)
break;
c = p;
}
}
if (children != 0)
{
Action<InfoWrapper> T = null;
T = (p) =>
{
foreach (InfoWrapper a in m_pData.Values)
if (a.Parent.pString == p.Name.pString)
{
if (!L.AddVertex(a))
L.AddVertex(a);
L.AddEdge(new Edge<object>(p, a));
if (children != 1)
T(a);
}
};
T(W);
}
graphLayout1.Graph = L;
foreach (var v in graphLayout1.Children)
{
if (v is VertexControl)
(v as VertexControl).PreviewMouseDoubleClick += graphLayout1_MouseDown;
}
(windowsFormsHost2.Child as System.Windows.Forms.PropertyGrid).SelectedObject = W;
addWrapper(W);
}
public bool ContainsVertex(TVertex vertex) => _graph.ContainsVertex(vertex);
public bool ContainsAssembly(Assembly assembly)
{
return(_dependencyGraph.ContainsVertex(new AssemblyNode(assembly)));
}
private void FindDependencies(IDomainObject currentObject, IDomainObject child, bool halt = false)
{
if (abort || currentObject == null)
{
return;
}
if (graph.ContainsVertex(currentObject))
{
if (child != null)
{
graph.AddEdge(new Edge <IDomainObject>(currentObject, child));
}
return;
}
statusLabel.Invoke(new System.Action(() =>
{
statusLabel.Text = string.Format("Analyzing {0}...", currentObject.ToString());
}));
NHibernateUtil.Initialize(currentObject);
graph.AddVertex(currentObject);
if (child != null)
{
graph.AddEdge(new Edge <IDomainObject>(currentObject, child));
}
if (currentObject is Cdc.MetaManager.DataAccess.Domain.Application || halt)
{
return;
}
List <IDomainObject> list = modelService.GetReferencingObjects(currentObject) as List <IDomainObject>;
if (currentObject is ServiceMethod || (currentObject is Dialog && ((Dialog)currentObject).Type == DialogType.Find))
{
statusLabel.Invoke(new System.Action(() =>
{
statusLabel.Text = string.Format("Finding XML references for {0}...", currentObject.ToString());
}));
string query = "select v from View v where v.VisualTreeXml like '%" + currentObject.Id + "%'";
IList <IDomainObject> xmlReferences = modelService.GetDomainObjectsByQuery <IDomainObject>(query);
list.AddRange(xmlReferences);
}
IList <IVersionControlled> vcParents = new List <IVersionControlled>();
foreach (IDomainObject domainObject in list)
{
halt = false;
ViewAction vc = domainObject as ViewAction;
if (vc != null && vc.Type == ViewActionType.JumpTo)
{
halt = true;
}
IVersionControlled vcObject = domainObject as IVersionControlled;
if (vcObject == null)
{
List <IDomainObject> allParents;
vcObject = modelService.GetVersionControlledParent(domainObject, out allParents).LastOrDefault();
}
if (!vcParents.Contains(vcObject))
{
vcParents.Add(vcObject);
FindDependencies(vcObject, currentObject, halt);
}
}
}
