public void Delete()
{
if (!isDirected) // irányított
{
for (int i = 0; i < Edges.Count;)
{
Edge temp = Edges[i];
Edges.RemoveAt(i);
temp.DeleteEdge();
EdgeAdded();
}
}
else // nem irányított
{
for (int i = 0; i < InEdges.Count;)
{
Edge temp = InEdges[i];
InEdges.RemoveAt(i);
temp.DeleteEdge();
EdgeAdded();
}
for (int i = 0; i < OutEdges.Count;)
{
Edge temp = OutEdges[i];
OutEdges.RemoveAt(i);
temp.DeleteEdge();
EdgeAdded();
}
}
this.parent.Children.Remove(this);
this.Visibility = System.Windows.Visibility.Hidden;
}
// Add an edge from this node to dest. If this is a cBranch type of node and it already
// has an edge to dest then node edge is added and the node type is changed to fall
public void AddEdgeTo(StructureNode dest)
{
if (BlockType != BlockTerminationType.Branch || !HasEdgeTo(dest))
{
OutEdges.Add(dest);
}
else
{
//reset the type to fall if no edge was added (i.e. this edge already existed)
BlockType = BlockTerminationType.FallThrough;
}
}
public ET ConnectTo <ET>(VertexT targetVertex) where ET : EdgeT
{
var ps = new[] { typeof(GraphT), typeof(VertexT), typeof(VertexT) };
var pss = new object[] { Graph, this, targetVertex };
var e = (ET)typeof(ET).GetConstructor(ps).Invoke(pss);
Graph.Edges.Add(e);
OutEdges.Add(e);
targetVertex.InEdges.Add(e);
return(e);
}
/* Menentukan level (kedalaman) tiap rumah dengan DFS.
* Dimulai dari NomorRumah = 1 dan level = 0.
*/
public static void TentukanLevel(int NomorRumah_dicari, int level, List <int> path, GraphKingdomMap graph)
{
foreach (var vert in graph.Vertices)
{
if (vert.NomorRumah == NomorRumah_dicari)
{
if (!path.Contains <int>(vert.NomorRumah))
{
path.Add(vert.NomorRumah);
}
// menentukan level
vert.Level = level;
// cari tetangga yang belum dikunjungi
graph.TryGetOutEdges(vert, out IEnumerable <DataEdge> OutEdges);
int i = 0;
bool DeadEnd = true;
while ((i < OutEdges.Count()) && (DeadEnd))
{
if (!path.Contains(OutEdges.ElementAt <DataEdge>(i).Target.NomorRumah))
{
DeadEnd = false;
TentukanLevel(OutEdges.ElementAt <DataEdge>(i).Target.NomorRumah, level + 1, path, graph);
}
else
{
i++;
}
}
// jika tidak ada tentangga yang belum dikunjungi dan belum balik ke istana
if (level > 0)
{
foreach (var edge in OutEdges)
{
if (edge.Target.Level < level)
{
level = level - 1;
TentukanLevel(edge.Target.NomorRumah, level, path, graph);
}
}
}
// jika tidak ada tentangga yang belum dikunjungi dan sudah balik ke istana, berhenti
else
{
break;
}
}
}
}
private bool AddEdgeUnchecked(
NodeId source,
NodeId target,
BufferPointer <NodeEdgeListHeader> targetInEdges,
bool isLight,
bool bulkAddingTargetIncoming)
{
BufferPointer <NodeEdgeListHeader> outEdges = OutEdges.GetBufferPointer(source.Value);
var edgeSetItem = new LinkedEdgeSetItem(source, target, isLight);
int index = 0;
if (!bulkAddingTargetIncoming)
{
ConcurrentBigSet <LinkedEdgeSetItem> .GetAddOrUpdateResult result =
m_edgeSet.GetOrAdd(edgeSetItem);
if (result.IsFound)
{
// Edge already existed
return(false);
}
index = result.Index;
}
else
{
index = m_edgeSet.ReservedNextIndex(m_edgeSetBuffer);
m_edgeSetBuffer[index] = edgeSetItem;
}
// Update head index for in edges and out edges
int inEdgesNext = Interlocked.Exchange(ref targetInEdges.Buffer[targetInEdges.Index].FirstIndex, index);
int outEdgesNext = Interlocked.Exchange(ref outEdges.Buffer[outEdges.Index].FirstIndex, index);
var linkedEdgeSetItemPtr = m_edgeSetBuffer.GetBufferPointer(index);
// Update next pointers
linkedEdgeSetItemPtr.Buffer[linkedEdgeSetItemPtr.Index].NextTargetIncomingEdgeIndex = inEdgesNext;
linkedEdgeSetItemPtr.Buffer[linkedEdgeSetItemPtr.Index].NextSourceOutgoingEdgeIndex = outEdgesNext;
Interlocked.Increment(ref m_edgeCount);
// Update edge counts
targetInEdges.Buffer[targetInEdges.Index].InterlockedIncrementCount();
outEdges.Buffer[outEdges.Index].InterlockedIncrementCount();
return(true);
}
/* Melakukan DFS dari start hingga destination ditemukan. */
public static void DFS(int startLevel, int start, int destination, List <int> route, GraphKingdomMap graph)
{
foreach (var vert in graph.Vertices)
{
// mencari NomorRumah dari daftar rumah
if (vert.NomorRumah == start)
{
// menambahkan rumah ke rute
route.Add(vert.NomorRumah);
// jika rumah = destination, method berakhir
if (vert.NomorRumah == destination)
{
break;
}
// cari tetangga rumah
graph.TryGetOutEdges(vert, out IEnumerable <DataEdge> OutEdges);
int i = 0;
bool DeadEnd = true;
while ((i < OutEdges.Count()) && (DeadEnd))
{
// mencari tujuan yang belum pernah dikunjungi dan bukan parent dari start
if ((!route.Contains(OutEdges.ElementAt <DataEdge>(i).Target.NomorRumah)) && (OutEdges.ElementAt <DataEdge>(i).Target.Level > startLevel))
{
DeadEnd = false;
}
else
{
i++;
}
}
// jika ditemukan tujuan, pindah ke tujuan
if (!DeadEnd)
{
DFS(startLevel, OutEdges.ElementAt <DataEdge>(i).Target.NomorRumah, destination, route, graph);
}
else
{
// jika tidak ditemukan tujuan dan belum kembali ke start
if (vert.Level > startLevel)
{
foreach (var edge in OutEdges)
{
// backtrack
if (edge.Target.Level < vert.Level)
{
DFS(startLevel, edge.Target.NomorRumah, destination, route, graph);
}
}
}
// jika tidak ditemukan tujuan dan sudah kembali ke start, berhenti
else
{
route.RemoveAt(route.Count() - 1);
break;
}
}
}
}
}
public IEnumerator <T> GetEnumerator()
{
return(OutEdges.Select(x => x.Value).GetEnumerator());
}
/// <summary>
/// These iterate from the end of the list because List.Remove is linear in
/// the number of items, so callers have been optimized where possible to
/// remove only the last or next-to-last edges (but in some cases such as
/// rectilinear, this optimization isn't always possible).
/// </summary>
/// <param name="edge"></param>
internal void RemoveOutEdge(VisibilityEdge edge)
{
OutEdges.Remove(edge);
}
/// <summary>
/// Does this node have an edge to dest?
/// </summary>
/// <param name="dest"></param>
/// <returns></returns>
public bool HasEdgeTo(StructureNode dest)
{
return(OutEdges.Contains(dest));
}
IEnumerator <IEdge> IEnumerable <IEdge> .GetEnumerator()
{
return(OutEdges.GetEnumerator());
}
private void AddEdge(Edge edge)
{
OutEdges.Add(edge);
edge.TargetNode.InEdges.Add(edge);
}
public ResearchNode OutResearch()
{
return(OutEdges.First().OutResearch());
}
public IEnumerable <ResearchNode> DirectChildren()
{
return(OutEdges.Select(e => e.OutResearch()));
}
public override int LayoutLowerPriority()
{
return(OutEdges.Count());
}
public override int DefaultPriority()
{
return(InEdges.Count() + OutEdges.Count());
}
