/// <summary>
/// Ensures a minimum number of self loops exist in the network.
/// </summary>
public static void EnsureMinSelfLoopCount(IBasicAdjList network, int n)
{
int ctr = 0;
foreach (IEdge edge in network.Edges)
{
if (edge.IsSelfLoop)
ctr++;
}
// if that many self loops exist, return
if (ctr>=n)
return;
// else create the needed number of self loops
int needed = n;
if (n<ctr)
needed = ctr-n;
ctr=0; // re-use ctr variable
do
{
foreach (INode node in network.Nodes)
{
network.CreateEdge(node, node);
ctr++;
if (ctr>=needed)
break;
}
} while (needed>ctr);
}
public VnaBasicAdjListWriterFixture()
{
_testNetA = GetTestNetA();
_testDir = Properties.Resources.TestDumpPath;
if (!Directory.Exists(_testDir))
Directory.CreateDirectory(_testDir);
_bacisAdjListWriter = new VNABasicAdjListWriter();
}
/// <summary>
/// Removes the <see cref="INode"/> at the specified <paramref name="index"/>
/// </summary>
/// <param name="network">The INetworkAdjList from which the node is to be removed.</param>
/// <param name="index">The index of the node to be removed.</param>
/// <returns>The number of nodes removed.</returns>
public int RemoveNode(IBasicAdjList network, int index)
{
int removed = 0;
if (network is BasicAdjList)
{
BasicAdjList adj = network as BasicAdjList;
INode node = adj.Nodes[index];
adj.RemoveNode(node);
removed++;
}
return removed;
}
internal BasicEdge(IBasicAdjList network, INode sourceNode, INode destNode)
{
// You Must Set Index Manually!!!
if (!(sourceNode is IBasicNode))
throw new ArgumentException(string.Format("SourceNode must be of type {0}.", typeof(IBasicNode)), "sourceNode");
if (!(destNode is IBasicNode))
throw new ArgumentException(string.Format("DestinatinNode must be of type {0}.", typeof(IBasicNode)), "destNode");
Network = network;
if (Network != sourceNode.Network)
throw new ArgumentException("The parent network must be the same as the sourceNode.ParentNetwork.", "sourceNode");
if (Network != destNode.Network)
throw new ArgumentException("The parent network must be the same as the destNode.ParentNetwork.", "destNode");
SourceNode = sourceNode;
DestinationNode = destNode;
}
/// <summary>
/// Removes the <see cref="INode"/> at the specified <paramref name="index"/>.
/// </summary>
/// <param name="network">The INetworkAdjList from which the node is to be removed.</param>
/// <param name="indices">The list of indices of nodes to be removed.</param>
/// <returns>The number of nodes removed.</returns>
public int RemoveNodes(IBasicAdjList network, List<int> indices)
{
int removed = 0;
if (network is BasicAdjList)
{
BasicAdjList adj = network as BasicAdjList;
// sort before removing, and remove highest first
indices.Sort();
INode node;
for (int i = (indices.Count-1); i >=0; i--)
{
node = adj.Nodes[indices[i]];
adj.RemoveNode(node);
removed++;
}
}
return removed;
}
/// <summary>
/// Reads in <paramref name="dataFields"/>, which are the fields parsed from a data line in the *Node properties section
/// of the file. Each field is assigned to a cell in the node attributes table of <paramref name="network"/>
/// according to which attribute each field is mapped to. Field values are converted depending on what the corresponding node
/// data attribute column data type indicates.
/// </summary>
/// <param name="dataFields">An array of strings read in from the *Node data section</param>
/// <param name="network">An IBasicAdjList network with nodes initialize, and node data attribs</param>
/// <param name="index">The index of the node to which the data will be assigned as node data attributes</param>
/// <param name="headerFields">The list of *Node properties HeaderField mapping the dataField index to its data attrib column</param>
internal void ReadNodePropertyFields(string[] dataFields, IBasicAdjList network, int index, IList<HeaderField> headerFields)
{
// Assume dataFields are Trimmed!!!
// state must be VnaReadingState.NodeProperties
if (State != VnaFileSection.NodeProperties)
throw new InvalidOperationException(string.Format("{0} is not the correct reading state at this point.", State));
INode node = network.Nodes[index];
int nodeAttribIndex = -1;
int sourceFieldIndex = -1;
for (int i = 0; i < headerFields.Count; i++)
{
sourceFieldIndex = headerFields[i].SourceFieldIndex;
nodeAttribIndex = headerFields[i].AttribColumnIndex;
// map the field value to the node at the attribute column with index nodeAttribIndex
if (network.NodeDataAttributeTypes[nodeAttribIndex] == typeof(string))
network.NodeData.SetValue<string>(node, nodeAttribIndex, dataFields[sourceFieldIndex]);
else if (network.NodeDataAttributeTypes[nodeAttribIndex] == typeof(int))
network.NodeData.SetValue<int>(node, nodeAttribIndex, Convert.ToInt32(dataFields[sourceFieldIndex]));
else if (network.NodeDataAttributeTypes[nodeAttribIndex] == typeof(double))
network.NodeData.SetValue<double>(node, nodeAttribIndex, Convert.ToDouble(dataFields[sourceFieldIndex]));
else if (network.NodeDataAttributeTypes[nodeAttribIndex] == typeof(float))
network.NodeData.SetValue<float>(node, nodeAttribIndex, Convert.ToSingle(dataFields[sourceFieldIndex]));
else if (network.NodeDataAttributeTypes[nodeAttribIndex] == typeof(bool))
network.NodeData.SetValue<bool>(node, nodeAttribIndex, ConvertToBool(dataFields[sourceFieldIndex]));
else
{
// we only convert fields read in from a VNA file to strings, ints, floats, or doubles so
// so we can do this
throw new InvalidOperationException("Conversion not supported");
}
}
}
internal BasicEdge(IBasicAdjList network, INode sourceNode, INode destNode, int index)
: this(network, sourceNode, destNode)
{
_Index = index;
}
/// <summary>
/// Reads in <paramref name="dataFields"/>, which are the fields parsed from a data line in the '*Edge data' section
/// of the file, fields 0, 1 are assumed to be the from and to node keys. This method creates an edge with those nodes.
/// Each field is assigned to a cell in the edge attributes table of <paramref name="network"/>
/// according to which attribute each field is mapped to. Field values are converted depending on what the corresponding node
/// data attribute column data type indicates.
/// </summary>
/// <param name="dataFields">An array of strings read in from the *Edge data section</param>
/// <param name="network">An IBasicAdjList network with nodes initialize</param>
/// <param name="headerFields">The list of *Edge data HeaderField classes mapping the dataField index to its data attrib column</param>
internal void ReadEdgeDataFields(string[] dataFields, IBasicAdjList network, IList<HeaderField> headerFields)
{
// Assume line is Trimmed!!!
// state must be VnaReadingState.EdgeData
if (State != VnaFileSection.EdgeData)
throw new InvalidOperationException(string.Format("{0} is not the correct reading state at this point.", State));
// 3) create the edge in the network
// 4) Add an entry to EdgeKeyToEdgeIndexMap
var fromNode = NodeKeyToNodeIndexMap[dataFields[0]];
var toNode = NodeKeyToNodeIndexMap[dataFields[1]];
IEdge edge = network.CreateEdge(fromNode, toNode);
// do not read in datafields 0 and 1 - those are now 'with the nodes'
int edgeAttribIndex = -1;
int sourceFieldIndex = -1;
for (int i = 2; i < headerFields.Count; i++)
{
sourceFieldIndex = headerFields[i].SourceFieldIndex;
edgeAttribIndex = headerFields[i].AttribColumnIndex;
// map the field value to the edge at the attribute column with index nodeAttribIndex
if (network.EdgeDataAttributeTypes[edgeAttribIndex] == typeof(string))
network.EdgeData.SetValue<string>(edge, edgeAttribIndex, dataFields[sourceFieldIndex]);
else if (network.EdgeDataAttributeTypes[edgeAttribIndex] == typeof(int))
network.EdgeData.SetValue<int>(edge, edgeAttribIndex, Convert.ToInt32(dataFields[sourceFieldIndex]));
else if (network.EdgeDataAttributeTypes[edgeAttribIndex] == typeof(double))
network.EdgeData.SetValue<double>(edge, edgeAttribIndex, Convert.ToDouble(dataFields[sourceFieldIndex]));
else if (network.EdgeDataAttributeTypes[edgeAttribIndex] == typeof(float))
network.EdgeData.SetValue<float>(edge, edgeAttribIndex, Convert.ToSingle(dataFields[sourceFieldIndex]));
else if (network.EdgeDataAttributeTypes[edgeAttribIndex] == typeof(bool))
network.EdgeData.SetValue<bool>(edge, edgeAttribIndex, ConvertToBool(dataFields[sourceFieldIndex]));
else
{
// we only convert fields read in from a VNA file to strings, ints, floats, or doubles so
// so we can do this
throw new InvalidOperationException("Conversion not supported");
}
}
}
/// <summary>
/// Reads in <paramref name="dataFields"/>, which are the fields parsed from a data line in the *Edge properties section
/// of the file. Each field is assigned to a cell in the edge attributes table of <paramref name="network"/>
/// according to which attribute each field is mapped to. Field values are converted depending on what the corresponding node
/// data attribute column data type indicates.
/// </summary>
/// <param name="dataFields">An array of strings read in from the *Node data section</param>
/// <param name="network">An IBasicAdjList network with nodes and edges initialized</param>
/// <param name="index">The index of the edge to which the data will be assigned as node data attributes</param>
/// <param name="headerFields">The list of *Edge properties HeaderField mapping the dataField index to its data attrib column</param>
internal void ReadEdgePropertyFields(string[] dataFields, IBasicAdjList network, int index, IList<HeaderField> headerFields)
{
// Assume line is Trimmed!!!
// state must be VnaReadingState.EdgeProperties
if (State != VnaFileSection.EdgeProperties)
throw new InvalidOperationException(string.Format("{0} is not the correct reading state at this point.", State));
// assumes the edges populated in network are populated in the order in which each line is read from
// the *Edge data section. And, the assumption is made the order of data lines in the *Edge properties
// section is the same.
IEdge edge = network.Edges[index];
int edgeAttribIndex = -1;
int sourceFieldIndex = -1;
for (int i = 0; i < headerFields.Count; i++)
{
sourceFieldIndex = headerFields[i].SourceFieldIndex;
edgeAttribIndex = headerFields[i].AttribColumnIndex;
// map the field value to the edge at the attribute column with index edgeAttribIndex
if (network.EdgeDataAttributeTypes[edgeAttribIndex] == typeof(string))
network.EdgeData.SetValue<string>(edge, edgeAttribIndex, dataFields[sourceFieldIndex]);
else if (network.EdgeDataAttributeTypes[edgeAttribIndex] == typeof(int))
network.EdgeData.SetValue<int>(edge, edgeAttribIndex, Convert.ToInt32(dataFields[sourceFieldIndex]));
else if (network.EdgeDataAttributeTypes[edgeAttribIndex] == typeof(double))
network.EdgeData.SetValue<double>(edge, edgeAttribIndex, Convert.ToDouble(dataFields[sourceFieldIndex]));
else if (network.EdgeDataAttributeTypes[edgeAttribIndex] == typeof(float))
network.EdgeData.SetValue<float>(edge, edgeAttribIndex, Convert.ToSingle(dataFields[sourceFieldIndex]));
else if (network.EdgeDataAttributeTypes[edgeAttribIndex] == typeof(bool))
network.EdgeData.SetValue<bool>(edge, edgeAttribIndex, ConvertToBool(dataFields[sourceFieldIndex]));
else
{
// we only convert fields read in from a VNA file to strings, ints, floats, or doubles so
// so we can do this
throw new InvalidOperationException("Conversion not supported");
}
}
}
internal void WriteNodePropertySection(TextWriter writer, IBasicAdjList network, IDictionary<int, string> nodePropertyHeaders)
{
WriteNodeSectionHeader(writer, "*Node properties", nodePropertyHeaders);
IDataAttributes<INode> nodeData = null;
if (ExportNodeAttributes)
nodeData = network.NodeData;
bool exportAttribs = ExportNodeAttributes;
if (exportAttribs)
exportAttribs = !DisablePropertyExport;
foreach (INode node in network.Nodes)
{
WriteNodeLine(writer, node, nodeData, nodePropertyHeaders, exportAttribs);
}
}
public static void GarunteeEdgeCount(IBasicAdjList network, int desiredEdgeCount)
{
if (network.EdgeCount != desiredEdgeCount)
{
var rand = new Random();
int indexA = -1;
int indexB = -1;
while (network.EdgeCount != desiredEdgeCount)
{
indexA = rand.Next(network.NodeCount);
indexB = rand.Next(network.NodeCount);
network.CreateEdge(network.Nodes[indexA], network.Nodes[indexB]);
}
}
}
internal void WriteNodes(TextWriter writer, IBasicAdjList network)
{
writer.WriteLine(FormatVerticesHeader(network));
if (ExportNodeAttributes)
{
var nodeData = network.NodeData;
var dataType = nodeData.DataTypes[NodeIdentifierAttributeIndex];
if (BlueSpider.Base.Utilities.TypeTools.IsIntegral(dataType))
{
foreach (INode node in network.Nodes)
{
writer.WriteLine(FormatNodeWithIntegralAttrib(node, nodeData[node, NodeIdentifierAttributeIndex]));
}
}
else if (BlueSpider.Base.Utilities.TypeTools.IsFloatingPoint(dataType))
{
foreach (INode node in network.Nodes)
{
// float implicitly cast to double
writer.WriteLine(FormatNodeWithRealNumberAttrib(node, nodeData.GetValue<double>(node, NodeIdentifierAttributeIndex)));
}
}
else if (dataType == typeof(decimal))
{
foreach (INode node in network.Nodes)
{
// float implicitly cast to double
writer.WriteLine(FormatNodeWithRealNumberAttrib(node, nodeData.GetValue<decimal>(node, NodeIdentifierAttributeIndex)));
}
}
else if (dataType == typeof(string))
{
foreach (INode node in network.Nodes)
{
writer.WriteLine(FormatNodeWithStringAttrib(node, nodeData.GetValue<string>(node, NodeIdentifierAttributeIndex)));
}
}
else if (dataType == typeof(DateTime))
{
foreach (INode node in network.Nodes)
{
writer.WriteLine(FormatNodeWithObjectAttrib(node, nodeData[node, NodeIdentifierAttributeIndex], true));
}
}
else
{
foreach (INode node in network.Nodes)
{
writer.WriteLine(FormatNodeWithObjectAttrib(node, nodeData[node, NodeIdentifierAttributeIndex], false));
}
}
}
else
{
foreach (INode node in network.Nodes)
{
writer.WriteLine(FormatNode(node));
}
}
}
internal void WriteEdgePropertySection(TextWriter writer, IBasicAdjList network, IDictionary<int, string> edgePropertyHeaders)
{
WriteEdgeSectionHeader(writer, "*Tie properties", edgePropertyHeaders);
IDataAttributes<IEdge> edgeData = null;
if (ExportEdgeAttributes)
edgeData = network.EdgeData;
bool exportAttribs = ExportEdgeAttributes;
if (exportAttribs)
exportAttribs = !DisablePropertyExport;
foreach (IEdge edge in network.Edges)
{
WriteEdgePropertySectionLine(writer, edge, edgeData, edgePropertyHeaders, exportAttribs);
}
}
internal void GenerateSparseGraph(IBasicAdjList network)
{
int n = NodeCount;
int m = Math.Min(MaxAllowableEdges, EdgeCount);
INode[] V = new INode[n];
for (int i = 0; i < n; i++)
{
V[i] = network.CreateNode();
}
int count = m;
while (count > 0)
{
int vi = _rand.Next(n);
INode v = V[vi];
INode w = V[_rand.Next(n)];
if (v.IsEdge(w) || (v == w && (!AllowSelfLoops || !AllowCycles)))
{
continue;
}
network.CreateEdge(v, w);
count--;
}
if (!AllowCycles)
{
List<IEdge> edgesToReverse = new List<IEdge>();
foreach (IEdge edge in network.Edges)
{
if (edge.SourceNode.Index > edge.DestinationNode.Index)
{
edgesToReverse.Add(edge);
}
}
for (int k = 0; k < edgesToReverse.Count; k++)
{
network.ReverseEdge(edgesToReverse[k]);
edgesToReverse[k] = null;
}
}
}
internal void WriteEdges(TextWriter writer, IBasicAdjList network)
{
if (network.IsDirected)
writer.WriteLine(FormatArcsHeader(network));
else
writer.WriteLine(FormatEdgesHeader(network));
if (ExportEdgeAttributes)
{
var edgeData = network.EdgeData;
var dataType = edgeData.DataTypes[EdgeIdentifierAttributeIndex];
if (BlueSpider.Base.Utilities.TypeTools.IsIntegral(dataType))
{
foreach (IEdge edge in network.Edges)
{
writer.WriteLine(FormatEdgeWithIntegralAttrib(edge, edgeData[edge, EdgeIdentifierAttributeIndex]));
}
}
else if (BlueSpider.Base.Utilities.TypeTools.IsFloatingPoint(dataType))
{
foreach (IEdge edge in network.Edges)
{
// float implicitly cast to double
writer.WriteLine(FormatEdgeWithRealNumberAttrib(edge, edgeData.GetValue<double>(edge, EdgeIdentifierAttributeIndex)));
}
}
else if (dataType == typeof(decimal))
{
foreach (IEdge edge in network.Edges)
{
// float implicitly cast to double
writer.WriteLine(FormatEdgeWithRealNumberAttrib(edge, edgeData.GetValue<decimal>(edge, EdgeIdentifierAttributeIndex)));
}
}
else if (dataType == typeof(string))
{
foreach (IEdge edge in network.Edges)
{
writer.WriteLine(FormatEdgeWithStringAttrib(edge, edgeData.GetValue<string>(edge, EdgeIdentifierAttributeIndex)));
}
}
else if (dataType == typeof(DateTime))
{
foreach (IEdge edge in network.Edges)
{
writer.WriteLine(FormatEdgeWithObjectAttrib(edge, edgeData[edge, EdgeIdentifierAttributeIndex], true));
}
}
else
{
foreach (IEdge edge in network.Edges)
{
writer.WriteLine(FormatEdgeWithObjectAttrib(edge, edgeData[edge, EdgeIdentifierAttributeIndex], false));
}
}
}
else
{
foreach (IEdge edge in network.Edges)
{
writer.WriteLine(FormatEdge(edge));
}
}
}
internal void GenerateMultipleGraph(IBasicAdjList network)
{
int n = NodeCount;
int m = EdgeCount;
int[] deg = new int[n];
INode[] V = new INode[n];
for (int i = 0; i < n; i++)
V[i] = network.CreateNode();
for (int i = 0; i < m; i++)
deg[_rand.Next(n)]++;
for (int i = 0; i < n; i++)
{
INode v = V[i];
int d = deg[i];
while (d > 0)
{
int j = _rand.Next(n);
if (j == i && (!AllowCycles || !AllowSelfLoops))
continue;
network.CreateEdge(v, V[j]);
d--;
}
}
if (!AllowCycles)
{
List<IEdge> edgesToReverse = new List<IEdge>();
foreach (IEdge edge in network.Edges)
{
if (edge.SourceNode.Index > edge.DestinationNode.Index)
{
edgesToReverse.Add(edge);
}
}
for (int k = 0; k < edgesToReverse.Count; k++)
{
network.ReverseEdge(edgesToReverse[k]);
edgesToReverse[k] = null;
}
}
}
internal void GenerateDenseGraph(IBasicAdjList network)
{
for (int i = 0; i < NodeCount; i++)
{
network.CreateNode();
}
if (EdgeCount < MaxAllowableEdges)
EdgeCount = MaxAllowableEdges;
IList<Point> nodePairs = GetNodePairs(EdgeCount);
foreach (Point p in nodePairs)
{
network.CreateEdge(network.Nodes[p.X], network.Nodes[p.Y]);
}
}
public DummyBasicNode(IBasicAdjList network)
{
}
public void SetNodeData(IBasicAdjList network)
{
var dataTypes = new Type[panel1.Controls.Count];
for (int i = 0; i < panel1.Controls.Count; i++)
{
dataTypes[i] = ((MappedDataTypeCtrl)panel1.Controls[i]).DataType;
}
if(dataTypes.Length>0)
{
var builder = new DataAttributesBuilder();
builder.RandMaxIntValue = network.NodeCount;
builder.AddColumns((INodeAttributes)network, dataTypes);
}
}
internal virtual void WriteEdges(IBasicAdjList network, XmlWriter writer)
{
int ctr = 0;
foreach (IEdge edge in network.Edges)
{
WriteEdge(edge, ctr++, network.EdgeData, writer);
}
}
internal void WriteEdgeDataSection(TextWriter writer, IBasicAdjList network, IDictionary<int, string> edgeDataHeaders)
{
WriteEdgeSectionHeader(writer, "*Tie data", edgeDataHeaders);
IDataAttributes<IEdge> edgeData = null;
if (ExportEdgeAttributes)
edgeData = network.EdgeData;
foreach (IEdge edge in network.Edges)
{
WriteEdgeDataSectionLine(writer, edge, edgeData, edgeDataHeaders, ExportEdgeAttributes);
}
}
/*
internal void WriteKey(string keyId, INodeIntMap map, KeyWriter keyWriter, XmlWriter writer)
{
keyWriter.Write(keyId, Domain.node, map.Name, LayerDataTypeConverter.ToType(map.DataType), map.DefaultValue, writer);
}
internal void WriteKey(string keyId, INodeDoubleMap map, KeyWriter keyWriter, XmlWriter writer)
{
keyWriter.Write(keyId, Domain.node, map.Name, LayerDataTypeConverter.ToType(map.DataType), map.DefaultValue, writer);
}
internal void WriteKey(string keyId, INodeBoolMap map, KeyWriter keyWriter, XmlWriter writer)
{
keyWriter.Write(keyId, Domain.node, map.Name, LayerDataTypeConverter.ToType(map.DataType), map.DefaultValue, writer);
}
internal void WriteKey(string keyId, INodeStringMap map, KeyWriter keyWriter, XmlWriter writer)
{
keyWriter.Write(keyId, Domain.node, map.Name, LayerDataTypeConverter.ToType(map.DataType), map.DefaultValue, writer);
}
internal void WriteKey(string keyId, IEdgeIntMap map, KeyWriter keyWriter, XmlWriter writer)
{
keyWriter.Write(keyId, Domain.edge, map.Name, LayerDataTypeConverter.ToType(map.DataType), map.DefaultValue, writer);
}
internal void WriteKey(string keyId, IEdgeDoubleMap map, KeyWriter keyWriter, XmlWriter writer)
{
keyWriter.Write(keyId, Domain.edge, map.Name, LayerDataTypeConverter.ToType(map.DataType), map.DefaultValue, writer);
}
internal void WriteKey(string keyId, IEdgeBoolMap map, KeyWriter keyWriter, XmlWriter writer)
{
keyWriter.Write(keyId, Domain.edge, map.Name, LayerDataTypeConverter.ToType(map.DataType), map.DefaultValue, writer);
}
internal void WriteKey(string keyId, IEdgeStringMap map, KeyWriter keyWriter, XmlWriter writer)
{
keyWriter.Write(keyId, Domain.edge, map.Name, LayerDataTypeConverter.ToType(map.DataType), map.DefaultValue, writer);
}
*/
internal virtual void WriteNetwork(IBasicAdjList network, XmlWriter writer)
{
writer.WriteStartElement("graph");
writer.WriteStartAttribute("id");
writer.WriteValue(XmlConvert.ToString(network.Id));
writer.WriteEndAttribute();
writer.WriteStartAttribute("edgedefault");
if (network.IsDirected)
writer.WriteValue("directed");
else
writer.WriteValue("undirected");
writer.WriteEndAttribute();
if (!string.IsNullOrEmpty(network.Name))
{
WriteGraphDataElement(_KeyId_ForNetworkName, network.Name, writer);
}
WriteNodes(network, writer);
WriteEdges(network, writer);
writer.WriteEndElement();
}
internal void WriteNodeDataSection(TextWriter writer, IBasicAdjList network, IDictionary<int, string> nodeDataHeaders)
{
WriteNodeSectionHeader(writer, "*Node data", nodeDataHeaders);
IDataAttributes<INode> nodeData = null;
if (ExportNodeAttributes)
nodeData = network.NodeData;
foreach (INode node in network.Nodes)
{
WriteNodeLine(writer, node, nodeData, nodeDataHeaders, ExportNodeAttributes);
}
}
public DummyBasicEdge(IBasicAdjList network, INode sourceNode, INode destNode, int index)
{
}
internal virtual void Write(IBasicAdjList network, XmlWriter writer)
{
writer.WriteStartElement("graphml", "http://graphml.graphdrawing.org/xmlns");
writer.WriteAttributeString("xmlns", "xsi", null, "http://www.w3.org/2001/XMLSchema-instance");
writer.WriteAttributeString("xsi", "schemaLocation", null, "http://graphml.graphdrawing.org/xmlns http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd");
WriteKeys(network, writer);
WriteNetwork(network, writer);
writer.WriteEndElement();
}
public DummyBasicNode(IBasicAdjList network, int index)
{
}
internal virtual void WriteKeys(IBasicAdjList network, XmlWriter writer)
{
KeyWriter kw = new KeyWriter();
if (!string.IsNullOrEmpty(network.Name))
{
WriteNetworkNameKey(_KeyId_ForNetworkName, BlueSpider.GraphML.XMLConstants._KeyId_ForNetworkName, kw, writer);
}
string nodeKeyFormat = "nd{0}";
string key = null;
string colName = null;
Type colType = null;
object defaultVal = null;
for (int i = 0; i < network.NodeDataAttributeCount; i++)
{
key = string.Format(nodeKeyFormat, i);
colName = network.NodeData.ColumnNames[i];
colType = network.NodeData.DataTypes[i];
defaultVal = network.NodeData.ColumnDefaultValues[i];
WriteKey(key, colName, colType, defaultVal, kw, writer);
NodeDataKeys.Add(key);
}
string edgeKeyFormat = "ed{0}";
for (int i = 0; i < network.EdgeDataAttributeCount; i++)
{
key = string.Format(edgeKeyFormat, i);
colName = network.EdgeData.ColumnNames[i];
colType = network.EdgeData.DataTypes[i];
defaultVal = network.EdgeData.ColumnDefaultValues[i];
WriteKey(key, colName, colType, defaultVal, kw, writer);
EdgeDataKeys.Add(key);
}
}
internal void DoSecondPass(StreamReader reader, Microsoft.VisualBasic.FileIO.TextFieldParser parser, IBasicAdjList network)
{
// now, the network had been created based on the headers of each section, the list of
// header fields has been populated for each section, nodes have been created.
// so populate the node data, create the edges, and populate edge data
// 1) read line
// 2) if line is a '*' line
// read line and set state, skip next line
// 3) read items based on state
int index = 0;
string line = null;
string[] fields = null;
try
{
while (!parser.EndOfData)
{
if (parser.PeekChars(1) == "*")
{
line = parser.ReadLine();
State = ReadStarLine(line);
// skip the header line
parser.ReadLine();
// reset the index at each * section
index = 0;
continue;
}
// if here, then it is not a header line or star line
fields = Clean(parser.ReadFields());
switch (State)
{
case VnaFileSection.NodeData:
ReadNodeDataFields(fields, network, index++, NodeDataHeaders);
break;
case VnaFileSection.NodeProperties:
ReadNodePropertyFields(fields, network, index++, NodePropertyHeaders);
break;
case VnaFileSection.EdgeData:
ReadEdgeDataFields(fields, network, EdgeDataHeaders);
break;
case VnaFileSection.EdgeProperties:
ReadEdgePropertyFields(fields, network, index++, EdgePropertyHeaders);
break;
default:
throw new InvalidOperationException(string.Format("{0} is an invalid state", State));
}
}
}
catch (FormatException ex)
{
var sb = new StringBuilder();
sb.AppendFormat("A format error occured while reading the line {0}.{1}", parser.LineNumber, Environment.NewLine);
sb.Append(ex.Message);
ErrorMessages.Add(sb.ToString());
}
catch(NullReferenceException ex)
{
var sb = new StringBuilder();
sb.AppendFormat("A null value occured while reading the line {0}.{1}", parser.LineNumber, Environment.NewLine);
sb.Append(ex.Message);
ErrorMessages.Add(sb.ToString());
}
catch (Exception ex)
{
var sb = new StringBuilder();
sb.AppendFormat("An error occurred while reading the line {0}.{1}", parser.LineNumber, Environment.NewLine);
sb.Append(ex.Message);
ErrorMessages.Add(sb.ToString());
}
}
internal virtual void WriteNodes(IBasicAdjList network, XmlWriter writer)
{
foreach (INode node in network.Nodes)
{
WriteNode(node, network.NodeData, writer);
}
}
internal BasicNode(IBasicAdjList network, int index)
: this(network)
{
_Index = index;
}
