public static void SaveGraph(PocGraph graph, string filename)
{
using (XmlWriter writer = XmlWriter.Create(filename))
{
var serializer = new GraphMLSerializer<PocVertex, PocEdge, PocGraph>();
serializer.Serialize(writer, graph, v => v.ID, e => e.ID);
}
}
public static void SaveGraph(PocGraph graph, string filename)
{
using (XmlWriter writer = XmlWriter.Create(filename))
{
var serializer = new GraphMLSerializer <PocVertex, PocEdge, PocGraph>();
serializer.Serialize(writer, graph, v => v.ID, e => e.ID);
}
}
public static void Serialize(SoftMutableBidirectionalGraph <CFGNode, CFGEdge> graph, string path)
{
var ser = new GraphMLSerializer <CFGNode, CFGEdge, SoftMutableBidirectionalGraph <CFGNode, CFGEdge> >();
using (var writer = XmlWriter.Create(path + "temp.graphml", new XmlWriterSettings {
Indent = true, WriteEndDocumentOnClose = false
}))
{
ser.Serialize(writer, graph, v => v.Id.ToString(), e => e.Id.ToString());
}
}
/// <summary>
/// Saves a graph to file.
/// </summary>
public static void SaveGraph([NotNull] PocGraph graph, [NotNull] string filePath)
{
// Create the xml writer
using (var writer = XmlWriter.Create(filePath))
{
var serializer = new GraphMLSerializer <PocVertex, PocEdge, PocGraph>();
// Serialize the graph
serializer.Serialize(writer, graph, v => v.ID, e => e.ID);
}
}
public static void Serialize(SEGraph graph, string path)
{
ReplaceLineBreaks(graph, true);
var ser = new GraphMLSerializer <SENode, SEEdge, SEGraph>();
using (var writer = XmlWriter.Create(path + "temp.graphml", new XmlWriterSettings {
Indent = true, WriteEndDocumentOnClose = false
}))
{
ser.Serialize(writer, graph, v => v.Id.ToString(), e => e.Id.ToString());
}
}
/// <summary>
/// Saves the graph.
/// </summary>
/// <param name="graph">The graph.</param>
/// <param name="filename">The filename.</param>
public static void SaveGraph(CustomGraph graph, string filename)
{
////create the xml writer
if (!string.IsNullOrEmpty(filename))
{
using (var writer = XmlWriter.Create(filename))
{
var serializer = new GraphMLSerializer <CustomVertex, CustomEdge, CustomGraph>();
////serialize the graph
serializer.Serialize(writer, graph, v => v.Text + ";" + v.BackgroundColor.ToString() + ";" + v.X.ToString() + ";" + v.Y.ToString() + ";" + v.Highlight.ToString() + ";", e => e.EdgeColor.ToString() + ";" + e.Trigger);
}
}
}
/// <summary>
/// Saves the graph.
/// </summary>
/// <param name="graph">The graph.</param>
/// <param name="filename">The filename.</param>
public static void SaveGraph(CustomGraph graph, string filename)
{
////create the xml writer
if (!string.IsNullOrEmpty(filename))
{
using (var writer = XmlWriter.Create(filename))
{
var serializer = new GraphMLSerializer<CustomVertex, CustomEdge, CustomGraph>();
////serialize the graph
serializer.Serialize(writer, graph, v => v.Text + ";" + v.BackgroundColor.ToString() + ";" + v.X.ToString() + ";" + v.Y.ToString() + ";" + v.Highlight.ToString() + ";", e => e.EdgeColor.ToString() + ";" + e.Trigger);
}
}
}
public static void SaveGraph( PocGraph graph, string filename )
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
//create the xml writer
using ( var writer = XmlWriter.Create( filename, settings ) )
{
var serializer = new GraphMLSerializer<PocVertex, PocEdge, PocGraph>();
//serialize the graph
serializer.Serialize( writer, graph, v => v.ID, e => e.ID );
}
}
public static void SaveGraph(PocGraph graph, string filename)
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
//create the xml writer
using (var writer = XmlWriter.Create(filename, settings))
{
var serializer = new GraphMLSerializer <PocVertex, PocEdge, PocGraph>();
//serialize the graph
serializer.Serialize(writer, graph, v => v.ID, e => e.ID);
}
}
public static void SaveGraph(PocGraph graph, string filename)
{
// graph.SerializeToBinary()
using (XmlWriter writer = XmlWriter.Create(filename))
{
var serializer = new GraphMLSerializer <PocVertex, PocEdge, PocGraph>();
serializer.Serialize(writer, graph, v => v.ID, e => e.ID);
}
// using (var stream = File.OpenWrite(filename))
// {
// graph.SerializeToBinary(stream);
// }
}
public static string Serialize <TVertex, TEdge>(this IBidirectionalGraph <TVertex, TEdge> graph)
where TEdge : IEdge <TVertex>
{
using (var memoryStream = new MemoryStream())
{
var xmlWriterSettings = new XmlWriterSettings {
Encoding = Encoding.UTF8
};
using (var xmlWriter = XmlWriter.Create(memoryStream, xmlWriterSettings))
{
var serializer = new GraphMLSerializer <TVertex, TEdge, IEdgeListGraph <TVertex, TEdge> >();
serializer.Serialize(xmlWriter, graph, v => v.ToString(), e => e.ToString());
xmlWriter.Flush();
}
return(Encoding.UTF8.GetString(memoryStream.ToArray()));
}
}
public void RoundTripGraph([PexAssumeNotNull]IMutableVertexAndEdgeListGraph<NamedVertex, NamedEdge> g)
{
GraphMLSerializer<NamedVertex, NamedEdge> serializer = new GraphMLSerializer<NamedVertex, NamedEdge>();
AdjacencyGraph<NamedVertex, NamedEdge> gd = new AdjacencyGraph<NamedVertex, NamedEdge>();
string baseLine;
string output;
using (StringWriter writer = new StringWriter())
{
serializer.Serialize(writer, g);
baseLine = writer.ToString();
TestConsole.WriteLineBold("Original graph:");
Console.WriteLine(writer.ToString());
TestConsole.WriteLineBold("---");
using (XmlTextReader reader = new XmlTextReader(new StringReader(writer.ToString())))
{
serializer.Deserialize(
reader,
gd,
new NamedVertex.Factory(),
new NamedEdge.Factory()
);
}
}
TestConsole.WriteLineBold("Roundtripped graph:");
using (StringWriter sw = new StringWriter())
{
serializer.Serialize(sw, gd);
output = sw.ToString();
Console.WriteLine(sw.ToString());
}
Assert.AreEqual(g.VertexCount, gd.VertexCount);
Assert.AreEqual(g.EdgeCount, gd.EdgeCount);
StringAssert.AreEqual(
baseLine,
output,
StringComparison.InvariantCulture
);
}
public void GraphMLSerialization_HeaderCheck(bool emitDeclarationOnSerialize, bool emitDeclarationOnDeserialize)
{
var graph = new EquatableTestGraph
{
String = "graph",
Int = 42
};
var vertex1 = new EquatableTestVertex("v1")
{
StringDefault = "foo",
String = "string",
Int = 10,
Long = 20,
Float = 25.0F,
Double = 30.0,
Bool = true
};
var vertex2 = new EquatableTestVertex("v2")
{
StringDefault = "bar",
String = "string2",
Int = 110,
Long = 120,
Float = 125.0F,
Double = 130.0,
Bool = true
};
graph.AddVertex(vertex1);
graph.AddVertex(vertex2);
var edge1 = new EquatableTestEdge(vertex1, vertex2, "e_1")
{
String = "edge",
Int = 90,
Long = 100,
Float = 25.0F,
Double = 110.0,
Bool = true
};
graph.AddEdge(edge1);
EquatableTestGraph serializedGraph = VerifySerialization(
graph,
g =>
{
using (var writer = new StringWriter())
{
var settings = new XmlWriterSettings {
Indent = true
};
using (XmlWriter xmlWriter = XmlWriter.Create(writer, settings))
{
var serializer = new GraphMLSerializer <EquatableTestVertex, EquatableTestEdge, EquatableTestGraph>
{
EmitDocumentDeclaration = emitDeclarationOnDeserialize
};
serializer.Serialize(
xmlWriter,
g,
vertex => vertex.ID,
edge => edge.ID);
}
return(writer.ToString());
}
},
xml =>
{
using (var reader = new StringReader(xml))
{
var serializer = new GraphMLDeserializer <EquatableTestVertex, EquatableTestEdge, EquatableTestGraph>
{
EmitDocumentDeclaration = emitDeclarationOnDeserialize
};
#if SUPPORTS_XML_DTD_PROCESSING
var settings = new XmlReaderSettings
{
ValidationFlags = XmlSchemaValidationFlags.ReportValidationWarnings,
XmlResolver = new GraphMLXmlResolver(),
DtdProcessing = DtdProcessing.Ignore
};
using (XmlReader xmlReader = XmlReader.Create(reader, settings))
{
#else
var xmlReader = new XmlTextReader(reader);
{
xmlReader.ProhibitDtd = false;
xmlReader.XmlResolver = null;
#endif
var g = new EquatableTestGraph();
serializer.Deserialize(
xmlReader,
g,
id => new EquatableTestVertex(id),
(source, target, id) => new EquatableTestEdge(source, target, id));
return(g);
}
}
});
Assert.IsTrue(
EquateGraphs.Equate(
graph,
serializedGraph));
}
static void Main(string[] args)
{
int nodesPerSide = 12;
var graph = new BidirectionalGraph <int, Edge <int> >();
// add start
graph.AddVertex(0);
// add odd vertices
for (int i = 0; i < nodesPerSide; i++)
{
graph.AddVertex(i * 2 + 1);
}
// add even vertices
for (int i = 1; i < nodesPerSide + 1; i++)
{
graph.AddVertex(i * 2);
}
// add end
graph.AddVertex(nodesPerSide * 2 + 1);
// conditionally connect odd side
for (int i = 0; i < nodesPerSide; i++)
{
graph.AddEdge(new Edge <int>(0, i * 2 + 1));
for (int j = i + 1; j < nodesPerSide; j++)
{
graph.AddEdge(new Edge <int>(i * 2 + 1, j * 2 + 1));
}
// add edge to final
graph.AddEdge(new Edge <int>(i * 2 + 1, nodesPerSide * 2 + 1));
}
// conditionally connect even side
for (int i = 1; i < nodesPerSide + 1; i++)
{
graph.AddEdge(new Edge <int>(0, i * 2));
for (int j = i + 1; j < nodesPerSide + 1; j++)
{
graph.AddEdge(new Edge <int>(i * 2, j * 2));
}
// add edge to final
graph.AddEdge(new Edge <int>(i * 2, nodesPerSide * 2 + 1));
}
// save graph
var graphSerializer = new GraphMLSerializer <int, Edge <int>, BidirectionalGraph <int, Edge <int> > >();
using (var xmlWriter = XmlWriter.Create("graph.xml"))
{
graphSerializer.Serialize(xmlWriter, graph, x => x.ToString(), x => x.ToString());
}
// generate odd result set
var datuh = GetForwardConnectedPresenceVectors(nodesPerSide);
var expectedPaths = new List <List <int> >();
foreach (var vector in datuh)
{
var path = new List <int>();
var pathEven = new List <int>();
path.Add(0);
pathEven.Add(0);
var index2 = 0;
foreach (var shouldAdd in vector)
{
if (shouldAdd)
{
path.Add(index2 * 2 + 1);
pathEven.Add((index2 + 1) * 2);
}
index2++;
}
path.Add(nodesPerSide * 2 + 1);
pathEven.Add(nodesPerSide * 2 + 1);
expectedPaths.Add(path);
if (pathEven.Count > 2)
{
expectedPaths.Add(pathEven);
}
}
var search = new GraphSearchResult()
{
Start = 0,
End = nodesPerSide * 2 + 1,
CodePaths = new GraphCodePathResult[expectedPaths.Count]
};
var index = 0;
foreach (var path in expectedPaths)
{
var codePathResult = new GraphCodePathResult();
var ids = string.Join(",", path);
codePathResult.Ids = ids;
search.CodePaths[index] = codePathResult;
index++;
}
var model = new GraphResultsModel()
{
Searches = new GraphSearchResult[] { search }
};
var serializer = new XmlSerializer(typeof(GraphResultsModel));
using (var fs = new FileStream("results.xml", FileMode.Create, FileAccess.ReadWrite))
{
serializer.Serialize(fs, model);
}
Console.ReadKey();
}
