public static BaseGraph parser(string url)
{
BaseGraph graph = new NonDirectedGraph();
XmlTextReader reader = new XmlTextReader(url);
SortedList<int,Node> nodesList = new SortedList<int,Node>();
SortedList<string,Line> linesList = new SortedList<string,Line>();
Node graphNode;
Line graphLine;
int kindOfGraph =0;
while (reader.Read())
{
#region Switch-Case XMLNodes
switch (reader.NodeType)
{
case XmlNodeType.Element:
{
switch (reader.Name.ToLower())
{
#region NodeCase
//case "nodes":
case "node":
{
graphNode = new Node(Convert.ToInt32(reader.ReadString()));
reader.ReadEndElement();
nodesList.Add(graphNode.NodeNumber, graphNode);
}
break;
#endregion
#region LineCase
case "line":
{
graphLine = new Line();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
if ((reader.Name.ToLower() == "name") || (reader.Name.ToLower() == "linename"))
{
graphLine.LineName = reader.ReadString();
reader.ReadEndElement();
}
else if ((reader.Name.ToLower() == "firstnode") || (reader.Name.ToLower() == "source" || reader.Name.ToLower() == "from"))
{
graphLine.FirstNode = new Node(Convert.ToInt32(reader.ReadString()));
reader.ReadEndElement();
}
else if (reader.Name.ToLower() == "weight")
{
graphLine.Weight = Convert.ToInt32(reader.ReadString());
reader.ReadEndElement();
}
else if ((reader.Name.ToLower() == "secondnode") || (reader.Name.ToLower() == "destination" || reader.Name.ToLower() == "to"))
{
graphLine.SecondNode = new Node(Convert.ToInt32(reader.ReadString()));
reader.ReadEndElement();
}
}
else if (reader.Name == "line")
break;
}
linesList.Add(graphLine.LineName, graphLine);
//while (reader.Name.ToLower() != "name" && reader.Name.ToLower()!="linename" && reader.Read() == true) ;
//if ((reader.Name.ToLower() == "name") || (reader.Name.ToLower() == "linename"))
//{
// graphLine.LineName = reader.ReadString();
// reader.ReadEndElement();
//}
//while (reader.Name.ToLower() != "firstnode" && reader.Name.ToLower() != "source" && reader.Read() == true) ;
//if ((reader.Name.ToLower().ToLower() == "firstnode") || (reader.Name.ToLower() =="source"))
//{
// graphLine.FirstNode = new Node(Convert.ToInt32(reader.ReadString()));
// reader.ReadEndElement();
//}
//while (reader.Name.ToLower() != "weight" && reader.Read() == true) ;
//if (reader.Name.ToLower() == "weight")
//{
// graphLine.Weight = Convert.ToInt32(reader.ReadString());
// reader.ReadEndElement();
//}
//while (reader.Name.ToLower() != "secondnode" && reader.Name.ToLower() != "destination" && reader.Read() == true) ;
//if ((reader.Name.ToLower() == "secondnode") || (reader.Name.ToLower() == "destination"))
//{
// graphLine.SecondNode = new Node(Convert.ToInt32(reader.ReadString()));
// reader.ReadEndElement();
//}
//linesList.Add(graphLine.LineName, graphLine);
}
break;
#endregion
case "nondirectedgraph":
kindOfGraph = 0;
break;
case "graph":
case "directedgraph":
kindOfGraph = 1;
break;
default:
break;
}// end inner switch (reader.Name.ToLower())
}// end inner case NodeType.Element
break;
default:
break;
}//end outer switch(reader.NodeType)
}//end While(reader.Read())
#endregion
if (kindOfGraph == 0)
{
graph = new NonDirectedGraph(nodesList, linesList);
}
if (kindOfGraph == 1)
{
graph = new DirectedGraph(nodesList, linesList);
}
return graph;
}//end method
//validated
public bool ContainCircularWay(Node firstNode, ref List<int> circlenodes)
{
Stack<int> stack = new Stack<int>();
SortedList<int, bool> marked = new SortedList<int, bool>();
for (int markedCounter = 0; markedCounter < NodesCount; markedCounter++)
{
marked.Add(NodesList.Keys[markedCounter], false);
}
// this statment is add in the last time modifiy the code
marked[firstNode.NodeNumber] = true;
stack.Push(firstNode.NodeNumber);
while (stack.Count != 0)
{
int father = stack.Peek();
SortedList<int, Node> successor = OuterNodes(father);
bool successorFinish = false;
int indexOfSuccessor = 0;
if (successor == null)
{
successorFinish = true;
}
while (!successorFinish)
{
if (marked[successor.Values[indexOfSuccessor].NodeNumber])
{
if (stack.Contains(successor.Values[indexOfSuccessor].NodeNumber))
{
//return true;
int tempn = successor.Values[indexOfSuccessor].NodeNumber;
circlenodes = new List<int>();
circlenodes.Add(tempn);
while (stack.Peek() != tempn)
{
int stacknode;
stacknode = stack.Pop();
circlenodes.Add(stacknode);
}
circlenodes.Add(tempn);
return true;
}
else
{
int counter = 0;
for (counter = 0; counter < successor.Count; counter++)
{
if (!(marked[successor.Values[counter].NodeNumber]))
{
break;
}
}
if (counter == successor.Count)
{
successorFinish = true;
}
else
{
indexOfSuccessor = counter;
}
}
}
else
{
marked[successor.Values[indexOfSuccessor].NodeNumber] = true;
stack.Push(successor.Values[indexOfSuccessor].NodeNumber);
break;
}
}
if (successorFinish)
{
stack.Pop();
}
}
return false;
}
/// <summary>
/// Initialzie a new instance of the line class.
/// </summary>
/// <param name="nameOfLine">Represent the name of the line.</param>
/// <param name="first">Represent the first node that connnect to the line.</param>
/// <param name="second">Represent the second node that connect to the line.</param>
public Line(string nameOfLine, Node first, Node second)
{
LineName = nameOfLine;
FirstNode = first;
SecondNode = second;
}
public bool isWell(Node node)
{
if (OuterDegree(node) == 0)
{
return true;
}
return false;
}
public bool isSpring(Node node)
{
if (InnerDegree(node) == 0)
{
return true;
}
return false;
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public SortedList<int, Node> InnerNodes(Node node)
{
return InnerNodes(node.NodeNumber);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public SortedList<int, Node> OuterNodes(Node node)
{
return OuterNodes(node.NodeNumber);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public int OuterDegree(Node node)
{
return OuterDegree(node.NodeNumber);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public int InnerDegree(Node node)
{
return InnerDegree(node.NodeNumber);
}
/// <summary>
///
/// </summary>
/// <param name="startNode"></param>
/// <param name="way"></param>
/// <returns></returns>
private List<int> SearchTheGraph(Node startNode, WayOfSearch way)
{
if (startNode == null)
{
throw new ArgumentNullException();
}
if (ContainsNode(startNode) == false)
{
throw new KeyNotFoundException();
}
int nodeNumber = startNode.NodeNumber;
List<int> closed = new List<int>();
List<int> open = new List<int>();
open.Insert(0, nodeNumber);
while (open.Count > 0)
{
int temp = open[0];
open.RemoveAt(0);
closed.Add(temp);
SortedList<int, Node> neighbor = this.NearOfNodeDirected(new Node(temp));//verify
foreach (int number in neighbor.Keys)
{
if ((!closed.Contains(number)) && (!open.Contains(number)))
{
switch (way)
{
case WayOfSearch.BreadthFirst:
open.Add(number);
break;
case WayOfSearch.DepthFirst:
open.Insert(0, number); // add at the front of the open List
break;
}
}
}
}
return closed;
}
/// <summary>
///
/// </summary>
/// <param name="startNode"></param>
/// <returns></returns>
public List<int> DepthFirstSearch(Node startNode)
{
return SearchTheGraph(startNode, WayOfSearch.DepthFirst);
}
//brings near of node case it's the start of the line
public SortedList<int, Node> NearOfNodeDirected(Node node)
{
SortedList<int, Node> NearNodeList = new SortedList<int, Node>();
foreach (Line line in this)
{
try
{
if (line.FirstNode.NodeNumber == node.NodeNumber)
{
if (node.NodeNumber != line.SecondNode.NodeNumber)
{
NearNodeList.Add(line.SecondNode.NodeNumber, new Node(line.SecondNode.NodeNumber));
}
}
}
catch (ArgumentException)
{
// the best handling here is to do nothing
// this exception will thrown by Add Method of SortedList Class if the key value that we
// trying to enter is duplicated (for more information see ObjectBrowser)
}
}
return NearNodeList;
}
