public fclsGraphBrowser()
{
InitializeComponent();
//Connect to Virtuoso
this._manager = new VirtuosoManager(Properties.Settings.Default.Server, Properties.Settings.Default.Port, VirtuosoQuadStoreDB, Properties.Settings.Default.Username, Properties.Settings.Default.Password);
//Add some fake test data
DataTable data = new DataTable();
data.Columns.Add("Subject");
data.Columns.Add("Predicate");
data.Columns.Add("Object");
data.Columns["Subject"].DataType = typeof(INode);
data.Columns["Predicate"].DataType = typeof(INode);
data.Columns["Object"].DataType = typeof(INode);
Graph g = new Graph();
DataRow row = data.NewRow();
row["Subject"] = g.CreateUriNode(new Uri("http://example.org/subject"));
row["Predicate"] = g.CreateUriNode(new Uri("http://example.org/predicate"));
row["Object"] = g.CreateUriNode(new Uri("http://example.org/object"));
data.Rows.Add(row);
this.BindGraph(data);
}
public static void Main(String[] args)
{
//Fill in the code shown on this page here to build your hello world application
Graph g = new Graph();
IUriNode dotNetRDF = g.CreateUriNode(new Uri("http://www.dotnetrdf.org"));
IUriNode says = g.CreateUriNode(new Uri("http://example.org/says"));
ILiteralNode helloWorld = g.CreateLiteralNode("Hello World");
ILiteralNode bonjourMonde = g.CreateLiteralNode("Bonjour tout le Monde", "fr");
g.Assert(new Triple(dotNetRDF, says, helloWorld));
g.Assert(new Triple(dotNetRDF, says, bonjourMonde));
foreach (Triple t in g.Triples)
{
Console.WriteLine(t.ToString());
}
NTriplesWriter ntwriter = new NTriplesWriter();
ntwriter.Save(g, "HelloWorld.nt");
RdfXmlWriter rdfxmlwriter = new RdfXmlWriter();
rdfxmlwriter.Save(g, "HelloWorld.rdf");
}
public static IGraph ReplaceResourceUris(IGraph original, IDictionary<string, Uri> replacements)
{
IGraph modified = new Graph();
foreach (Triple triple in original.Triples)
{
Uri subjectUri;
if (!replacements.TryGetValue(triple.Subject.ToString(), out subjectUri))
{
subjectUri = ((IUriNode)triple.Subject).Uri;
}
INode subjectNode = modified.CreateUriNode(subjectUri);
INode predicateNode = triple.Predicate.CopyNode(modified);
INode objectNode;
if (triple.Object is IUriNode)
{
Uri objectUri;
if (!replacements.TryGetValue(triple.Object.ToString(), out objectUri))
{
objectUri = ((IUriNode)triple.Object).Uri;
}
objectNode = modified.CreateUriNode(objectUri);
}
else
{
objectNode = triple.Object.CopyNode(modified);
}
modified.Assert(subjectNode, predicateNode, objectNode);
}
return modified;
}
public void TestCreateEntryFeedForSingleItem()
{
var testGraph = new Graph {BaseUri = new Uri("http://dbpedia.org/resource/")};
var film = testGraph.CreateUriNode(UriFactory.Create("http://dbpedia.org/resource/Un_Chien_Andalou"));
testGraph.Assert(film,
testGraph.CreateUriNode(UriFactory.Create("http://www.w3.org/1999/02/22-rdf-syntax-ns#type")),
testGraph.CreateUriNode(UriFactory.Create("http://dbpedia.org/ontology/Film")));
testGraph.Assert(film,
testGraph.CreateUriNode(UriFactory.Create("http://xmlns.com/foaf/0.1/name")),
testGraph.CreateLiteralNode("Un Chien Andalou"));
var mockRequest = new Mock<IODataRequestMessage>();
mockRequest.Setup(m => m.Url).Returns(new Uri("http://example.org/odata/Films('Un_Chien_Andalou')"));
var mock = new Mock<IODataResponseMessage>();
var mockStream = new MemoryStream();
//mock.Setup(m => m.Url).Returns(new Uri("http://example.org/odata/Films('Un_Chien_Andalou')"));
//mock.Setup(m => m.Method).Returns("GET");
mock.Setup(m => m.GetStream()).Returns(mockStream);
var generator = new ODataFeedGenerator(mockRequest.Object, mock.Object, _dbpediaMap, "http://example.org/odata/", new ODataMessageWriterSettings{Indent = true});
generator.CreateEntryFromGraph(testGraph, film.Uri.ToString(), "DBPedia.Film");
mockStream.Seek(0, SeekOrigin.Begin);
var streamXml = XDocument.Load(mockStream);
Assert.IsNotNull(streamXml);
Assert.IsNotNull(streamXml.Root);
Assert.AreEqual(XName.Get("entry", "http://www.w3.org/2005/Atom"), streamXml.Root.Name);
Console.WriteLine(streamXml.ToString());
XNamespace atom = "http://www.w3.org/2005/Atom";
Assert.AreEqual("http://example.org/odata/Films('Un_Chien_Andalou')",
(string)streamXml.Root.Element(atom+"id"));
}
public void WritingBlankNodeOutput()
{
//Create a Graph and add a couple of Triples which when serialized have
//potentially colliding IDs
Graph g = new Graph();
g.NamespaceMap.AddNamespace("ex", new Uri("http://example.org"));
IUriNode subj = g.CreateUriNode("ex:subject");
IUriNode pred = g.CreateUriNode("ex:predicate");
IUriNode name = g.CreateUriNode("ex:name");
IBlankNode b1 = g.CreateBlankNode("autos1");
IBlankNode b2 = g.CreateBlankNode("1");
g.Assert(subj, pred, b1);
g.Assert(b1, name, g.CreateLiteralNode("First Triple"));
g.Assert(subj, pred, b2);
g.Assert(b2, name, g.CreateLiteralNode("Second Triple"));
TurtleWriter ttlwriter = new TurtleWriter();
ttlwriter.Save(g, "bnode-output-test.ttl");
TestTools.ShowGraph(g);
TurtleParser ttlparser = new TurtleParser();
Graph h = new Graph();
ttlparser.Load(h, "bnode-output-test.ttl");
TestTools.ShowGraph(h);
Assert.AreEqual(g.Triples.Count, h.Triples.Count, "Expected same number of Triples after serialization and reparsing");
}
public override bool Execute(PipelinePackage package, PackagePipelineContext context)
{
DateTime? commitTimeStamp = PackagePipelineHelpers.GetCommitTimeStamp(context);
Guid? commitId = PackagePipelineHelpers.GetCommitId(context);
IGraph graph = new Graph();
INode resource = graph.CreateUriNode(context.Uri);
if (commitTimeStamp != null)
{
graph.Assert(
resource,
graph.CreateUriNode(Schema.Predicates.CatalogTimeStamp),
graph.CreateLiteralNode(commitTimeStamp.Value.ToString("O"), Schema.DataTypes.DateTime));
}
if (commitId != null)
{
graph.Assert(
resource,
graph.CreateUriNode(Schema.Predicates.CatalogCommitId),
graph.CreateLiteralNode(commitId.Value.ToString()));
}
context.StageResults.Add(new GraphPackageMetadata(graph));
return true;
}
public void WritingRdfXmlLiteralsWithLanguageTags()
{
Graph g = new Graph();
INode s = g.CreateUriNode(new Uri("http://example.org/subject"));
INode p = g.CreateUriNode(new Uri("http://example.org/predicate"));
INode o = g.CreateLiteralNode("string", "en");
g.Assert(s, p, o);
this.CheckRoundTrip(g);
}
/// <summary>
///
/// </summary>
/// <param name="g"></param>
/// <param name="LO"></param>
public void insertLearningObject(ref Graph g, LearningObjectContextModel LO)
{
g.NamespaceMap.AddNamespace("onto", new Uri("http://www.owl-ontologies.com/OntoAdapt2.owl#"));
IUriNode sujeito = g.CreateUriNode("onto:" + LO.LearningObject_ID);
INode rdfType = g.CreateUriNode("rdf:type");
INode objeto = g.CreateUriNode("onto:LearningObject");
Triple triple = new Triple(sujeito, rdfType, objeto);
g.Assert(triple);
}
public string CreateContent(CatalogContext context)
{
IGraph graph = new Graph();
graph.NamespaceMap.AddNamespace("rdf", new Uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#"));
graph.NamespaceMap.AddNamespace("catalog", new Uri("http://nuget.org/catalog#"));
INode rdfTypePredicate = graph.CreateUriNode("rdf:type");
INode timeStampPredicate = graph.CreateUriNode("catalog:timeStamp");
Uri dateTimeDatatype = new Uri("http://www.w3.org/2001/XMLSchema#dateTime");
INode container = graph.CreateUriNode(_resourceUri);
graph.Assert(container, rdfTypePredicate, graph.CreateUriNode(GetContainerType()));
graph.Assert(container, timeStampPredicate, graph.CreateLiteralNode(_timeStamp.ToString(), dateTimeDatatype));
if (_parent != null)
{
graph.Assert(container, graph.CreateUriNode("catalog:parent"), graph.CreateUriNode(_parent));
}
AddCustomContent(container, graph);
INode itemPredicate = graph.CreateUriNode("catalog:item");
INode countPredicate = graph.CreateUriNode("catalog:count");
foreach (KeyValuePair<Uri, Tuple<Uri, IGraph, DateTime, int?>> item in GetItems())
{
INode itemNode = graph.CreateUriNode(item.Key);
graph.Assert(container, itemPredicate, itemNode);
graph.Assert(itemNode, rdfTypePredicate, graph.CreateUriNode(item.Value.Item1));
if (item.Value.Item2 != null)
{
graph.Merge(item.Value.Item2);
}
graph.Assert(itemNode, timeStampPredicate, graph.CreateLiteralNode(item.Value.Item3.ToString(), dateTimeDatatype));
if (item.Value.Item4 != null)
{
Uri integerDatatype = new Uri("http://www.w3.org/2001/XMLSchema#integer");
graph.Assert(itemNode, countPredicate, graph.CreateLiteralNode(item.Value.Item4.ToString(), integerDatatype));
}
}
JObject frame = context.GetJsonLdContext("context.Container.json", GetContainerType());
string content = Utils.CreateJson(graph, frame);
return content;
}
/// <summary>
///
/// </summary>
/// <param name="g"></param>
public void insertComunidadeMoodle(ref Graph g)
{
g = new Graph();
g.NamespaceMap.AddNamespace("onto", new Uri("http://www.owl-ontologies.com/OntoAdapt2.owl#"));
IUriNode sujeito = g.CreateUriNode("onto:" + student.Matricula);
INode rdfType = g.CreateUriNode("onto:ComunidadeMoodle");
ILiteralNode literal = g.CreateLiteralNode(student.ComunidadeMoodle);
Triple triple = new Triple(sujeito, rdfType, literal);
g.Assert(triple);
}
/// <summary>
/// Insere LO a comunidade
/// </summary>
/// <param name="g"></param>
/// <param name="LO"></param>
public void insertLearningObjectComunidade(ref Graph g, LearningObjectContextModel LO)
{
g = new Graph();
g.NamespaceMap.AddNamespace("onto", new Uri("http://www.owl-ontologies.com/OntoAdapt2.owl#"));
IUriNode sujeito = g.CreateUriNode("onto:" + LO.LearningObject_ID);
INode rdfType = g.CreateUriNode("onto:LO_MoodleCommunity");
ILiteralNode objeto = g.CreateLiteralNode(LO.MoodleCommunity);
Triple triple = new Triple(sujeito, rdfType, objeto);
g.Assert(triple);
}
/// <summary>
///
/// </summary>
/// <param name="g"></param>
public void InsertDeviceBrand(ref Graph g)
{
g = new Graph();
g.NamespaceMap.AddNamespace("onto", new Uri("http://www.owl-ontologies.com/OntoAdapt2.owl#"));
IUriNode sujeito = g.CreateUriNode("onto:" + Device.model_name);
INode rdfType = g.CreateUriNode("onto:Brand");
ILiteralNode literal = g.CreateLiteralNode(Device.Brand_Name);
Triple triple = new Triple(sujeito, rdfType, literal);
g.Assert(triple);
}
/// <summary>
///
/// </summary>
/// <param name="g"></param>
/// <param name="strLearningStyle"></param>
public void insertDeviceMediaPreference(ref Graph g)
{
g = new Graph();
g.NamespaceMap.AddNamespace("onto", new Uri("http://www.owl-ontologies.com/OntoAdapt2.owl#"));
IUriNode sujeito = g.CreateUriNode("onto:" + Device.model_name);
INode rdfType = g.CreateUriNode("onto:hasDeviceMediaPreference");
IUriNode objeto = g.CreateUriNode(new Uri("http://www.owl-ontologies.com/OntoAdapt2.owl#" + Device.MediaPreference));
Triple triple = new Triple(sujeito, rdfType, objeto);
g.Assert(triple);
}
/// <summary>
/// Adds the literal triple to a graph.
/// </summary>
/// <param name="graph">The graph.</param>
/// <param name="subject">The subject.</param>
/// <param name="predicate">The predicate.</param>
/// <param name="obj">The object (resource).</param>
/// <remarks></remarks>
public static void AddTripleLiteral(Graph graph, string subject, string predicate, string obj, string datatype)
{
string xmlSchemaDatatype;
switch (datatype)
{
case "Url":
xmlSchemaDatatype = XmlSpecsHelper.XmlSchemaDataTypeAnyUri;
break;
case "Date":
xmlSchemaDatatype = XmlSpecsHelper.XmlSchemaDataTypeDateTime;
break;
case "Integer":
xmlSchemaDatatype = XmlSpecsHelper.XmlSchemaDataTypeInteger;
break;
case "Ntext":
xmlSchemaDatatype = XmlSpecsHelper.XmlSchemaDataTypeString;
break;
case "Nvarchar":
xmlSchemaDatatype = XmlSpecsHelper.XmlSchemaDataTypeString;
break;
default:
xmlSchemaDatatype = XmlSpecsHelper.XmlSchemaDataTypeString;
break;
}
Triple triple = null;
if (subject.StartsWith("http") && predicate.StartsWith("http"))
{
triple = new Triple(
graph.CreateUriNode(new Uri(subject)),
graph.CreateUriNode(new Uri(predicate)),
graph.CreateLiteralNode(obj, new Uri(xmlSchemaDatatype))
);
}
else if (!subject.StartsWith("http") && predicate.StartsWith("http"))
{
triple = new Triple(
graph.CreateUriNode(subject),
graph.CreateUriNode(new Uri(predicate)),
graph.CreateLiteralNode(obj, new Uri(xmlSchemaDatatype))
);
}
else if (subject.StartsWith("http") && !predicate.StartsWith("http"))
{
triple = new Triple(
graph.CreateUriNode(new Uri(subject)),
graph.CreateUriNode(predicate),
graph.CreateLiteralNode(obj, new Uri(xmlSchemaDatatype))
);
}
else if (!subject.StartsWith("http") && !predicate.StartsWith("http"))
{
triple = new Triple(
graph.CreateUriNode(subject),
graph.CreateUriNode(predicate),
graph.CreateLiteralNode(obj, new Uri(xmlSchemaDatatype))
);
}
graph.Assert(triple);
}
public override bool Execute(PipelinePackage package, PackagePipelineContext context)
{
string hash = GetHash(package.Stream);
long size = GetSize(package.Stream);
IGraph graph = new Graph();
INode subject = graph.CreateUriNode(context.Uri);
graph.Assert(subject, graph.CreateUriNode(Schema.Predicates.PackageHashAlgorithm), graph.CreateLiteralNode("SHA512"));
graph.Assert(subject, graph.CreateUriNode(Schema.Predicates.PackageHash), graph.CreateLiteralNode(hash));
graph.Assert(subject, graph.CreateUriNode(Schema.Predicates.PackageSize), graph.CreateLiteralNode(size.ToString(), Schema.DataTypes.Integer));
context.StageResults.Add(new GraphPackageMetadata(graph));
return true;
}
public static IGraph CreateCommitMetadata(Uri indexUri, DateTime? lastCreated, DateTime? lastEdited)
{
IGraph graph = new Graph();
if (lastCreated != null)
{
graph.Assert(graph.CreateUriNode(indexUri), graph.CreateUriNode(Schema.Predicates.LastCreated), graph.CreateLiteralNode(lastCreated.Value.ToString("O"), Schema.DataTypes.DateTime));
}
if (lastEdited != null)
{
graph.Assert(graph.CreateUriNode(indexUri), graph.CreateUriNode(Schema.Predicates.LastEdited), graph.CreateLiteralNode(lastEdited.Value.ToString("O"), Schema.DataTypes.DateTime));
}
return graph;
}
public Graph CreateExampleGraph(string uri)
{
Graph newGraph = new Graph();
newGraph.BaseUri = UriFactory.Create(uri);
Triple triple = new Triple(
newGraph.CreateUriNode(UriFactory.Create("http://example/book1")),
newGraph.CreateUriNode(UriFactory.Create("http://example.org/ns#price")),
newGraph.CreateLiteralNode("42", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger))
);
newGraph.Assert(triple);
connector.SaveGraph(newGraph);
return newGraph;
}
public override IGraph CreatePageContent(CatalogContext context)
{
Uri resourceUri = new Uri(GetBaseAddress() + GetRelativeAddress());
Graph graph = new Graph();
INode subject = graph.CreateUriNode(resourceUri);
INode galleryKeyPredicate = graph.CreateUriNode(new Uri("http://nuget.org/gallery#key"));
string key = _export.Package["Key"].ToString();
Uri integerDatatype = new Uri("http://www.w3.org/2001/XMLSchema#integer");
graph.Assert(subject, galleryKeyPredicate, graph.CreateLiteralNode(key, integerDatatype));
return graph;
}
public void TestWriteSimpleRdf()
{
var g = new Graph();
g.Assert(g.CreateUriNode(new Uri("http://example.org/s")),
g.CreateUriNode(new Uri("http://example.org/p")),
g.CreateLiteralNode("o"));
//g.Assert(g.CreateUriNode(new Uri("http://example.org/s")),
// g.CreateUriNode(new Uri("http://example.org/ns2/p")),
// g.CreateLiteralNode("Another o"));
using (var stringWriter = new System.IO.StringWriter())
{
var writer = new RdfXmlWriter();
writer.Save(g, stringWriter);
var buff = stringWriter.ToString();
XDocument doc = XDocument.Parse(buff); // Fails
}
}
public override string CreateContent(CatalogContext context)
{
IGraph graph = new Graph();
graph.NamespaceMap.AddNamespace("rdf", new Uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#"));
graph.NamespaceMap.AddNamespace("nuget", new Uri("http://nuget.org/schema#"));
INode subject = graph.CreateUriNode(new Uri(GetBaseAddress() + GetItemIdentity()));
graph.Assert(subject, graph.CreateUriNode("rdf:type"), graph.CreateUriNode("nuget:DeleteRegistration"));
graph.Assert(subject, graph.CreateUriNode("nuget:id"), graph.CreateLiteralNode(_id));
JObject frame = context.GetJsonLdContext("context.DeletePackage.json", GetItemType());
string content = Utils.CreateJson(graph, frame);
return content;
}
public override IGraph CreatePageContent(CatalogContext context)
{
Uri resourceUri = new Uri(GetBaseAddress() + GetRelativeAddress());
Graph graph = new Graph();
INode subject = graph.CreateUriNode(resourceUri);
INode count = graph.CreateUriNode(new Uri("http://nuget.org/schema#count"));
INode itemGUID = graph.CreateUriNode(new Uri("http://nuget.org/schema#itemGUID"));
INode minDownloadTimestamp = graph.CreateUriNode(new Uri("http://nuget.org/schema#minDownloadTimestamp"));
INode maxDownloadTimestamp = graph.CreateUriNode(new Uri("http://nuget.org/schema#maxDownloadTimestamp"));
graph.Assert(subject, count, graph.CreateLiteralNode(_data.Count.ToString(), Schema.DataTypes.Integer));
graph.Assert(subject, itemGUID, graph.CreateLiteralNode(_itemGUID.ToString()));
graph.Assert(subject, minDownloadTimestamp, graph.CreateLiteralNode(_minDownloadTimestamp.ToString("O"), Schema.DataTypes.DateTime));
graph.Assert(subject, maxDownloadTimestamp, graph.CreateLiteralNode(_maxDownloadTimestamp.ToString("O"), Schema.DataTypes.DateTime));
return graph;
}
/// <summary>
/// Constructor creates new comparison element.
/// </summary>
/// <param name="uri">URI of the element</param>
/// <param name="node">Graph node of the element</param>
/// <param name="graph">Graph of the element</param>
public ComparisonElement(string uri, INode node, Graph graph)
{
elementURI = uri;
elementNode = node;
elementGraph = graph;
INode label = graph.CreateUriNode(new Uri("http://www.w3.org/2000/01/rdf-schema#label"));
List<Triple> t = new List<Triple>();
t.AddRange(graph.GetTriplesWithSubjectPredicate(node,label));
elementLabel = t[0].Object.ToString();
}
public void WritingSerializeOwnOneOfVeryLarge()
{
try
{
//Create the Graph for the Test and Generate a List of URIs
Graph g = new Graph();
List<IUriNode> nodes = new List<IUriNode>();
for (int i = 1; i <= 10000; i++)
{
nodes.Add(g.CreateUriNode(new Uri("http://example.org/Class" + i)));
}
//Use the thingOneOf to generate the Triples
thingOneOf(g, nodes.ToArray());
//Dump as NTriples to the Console
NTriplesFormatter formatter = new NTriplesFormatter();
foreach (Triple t in g.Triples)
{
Console.WriteLine(t.ToString(formatter));
}
Console.WriteLine();
//Now try to save as RDF/XML
IRdfWriter writer = new RdfXmlWriter();
writer.Save(g, "owl-one-of.rdf");
Console.WriteLine("Saved OK using RdfXmlWriter");
Console.WriteLine();
writer = new FastRdfXmlWriter();
((ICompressingWriter)writer).CompressionLevel = WriterCompressionLevel.Medium;
writer.Save(g, "owl-one-of-fast.rdf");
Console.WriteLine("Saved OK using FastRdfXmlWriter");
Console.WriteLine();
//Now check that the Graphs are all equivalent
Graph h = new Graph();
FileLoader.Load(h, "owl-one-of.rdf");
Assert.AreEqual(g, h, "Graphs should be equal (RdfXmlWriter)");
Console.WriteLine("RdfXmlWriter serialization was OK");
Console.WriteLine();
Graph j = new Graph();
FileLoader.Load(j, "owl-one-of-fast.rdf");
Assert.AreEqual(g, j, "Graphs should be equal (FastRdfXmlWriter)");
Console.WriteLine("FastRdfXmlWriter serialization was OK");
}
catch (StackOverflowException ex)
{
TestTools.ReportError("Stack Overflow", ex, true);
}
}
public override IGraph CreatePageContent(CatalogContext context)
{
var resourceUri = new Uri(GetBaseAddress() + GetRelativeAddress());
var graph = new Graph();
var subject = graph.CreateUriNode(resourceUri);
var idPredicate = graph.CreateUriNode(Schema.Predicates.Id);
var versionPredicate = graph.CreateUriNode(Schema.Predicates.Version);
if (_id != null)
{
graph.Assert(subject, idPredicate, graph.CreateLiteralNode(_id));
}
if (_version != null)
{
graph.Assert(subject, versionPredicate, graph.CreateLiteralNode(_version));
}
return graph;
}
public override bool Execute(PipelinePackage package, PackagePipelineContext context)
{
IGraph graph = new Graph();
INode subject = graph.CreateUriNode(context.Uri);
graph.Assert(
subject,
graph.CreateUriNode(Schema.Predicates.Published),
graph.CreateLiteralNode(package.Published.ToString("O"), Schema.DataTypes.DateTime));
if (package.Owner != null)
{
graph.Assert(
subject,
graph.CreateUriNode(Schema.Predicates.Owner),
graph.CreateLiteralNode(package.Owner));
}
context.StageResults.Add(new GraphPackageMetadata(graph));
return true;
}
private Graph CreateGraph(IEnumerable<RDFTriple> triples)
{
var g = new Graph();
foreach (var triple in triples)
{
if(triple.Subject.IsNull() || triple.Predicate.IsNull() || triple.Object.IsNull()) continue;
IUriNode subject = g.CreateUriNode(UriFactory.Create(triple.Subject));
IUriNode predicate = g.CreateUriNode(UriFactory.Create(triple.Predicate));
switch (triple.Object.DataType)
{
case Constants.UriDataType:
IUriNode objectUri = g.CreateUriNode(UriFactory.Create(triple.Object.Uri));
g.Assert(new Triple(subject, predicate, objectUri));
break;
case Constants.LiteralDataType:
ILiteralNode objecto = g.CreateLiteralNode(triple.Object.Literal);
g.Assert(new Triple(subject, predicate, objecto));
break;
}
}
return g;
}
public override bool Execute(PipelinePackage package, PackagePipelineContext context)
{
ZipArchive zipArchive = PackagePipelineHelpers.GetZipArchive(package, context);
IEnumerable<PackageEntry> entries = GetEntries(zipArchive);
IGraph graph = new Graph();
if (entries != null)
{
INode packageEntryPredicate = graph.CreateUriNode(Schema.Predicates.PackageEntry);
INode packageEntryType = graph.CreateUriNode(Schema.DataTypes.PackageEntry);
INode fullNamePredicate = graph.CreateUriNode(Schema.Predicates.FullName);
INode namePredicate = graph.CreateUriNode(Schema.Predicates.Name);
INode lengthPredicate = graph.CreateUriNode(Schema.Predicates.Length);
INode compressedLengthPredicate = graph.CreateUriNode(Schema.Predicates.CompressedLength);
INode rdfTypePredicate = graph.CreateUriNode(Schema.Predicates.Type);
INode resource = graph.CreateUriNode(context.Uri);
foreach (PackageEntry entry in entries)
{
Uri entryUri = new Uri(context.Uri.AbsoluteUri + "#" + entry.FullName);
INode entryNode = graph.CreateUriNode(entryUri);
graph.Assert(resource, packageEntryPredicate, entryNode);
graph.Assert(entryNode, rdfTypePredicate, packageEntryType);
graph.Assert(entryNode, fullNamePredicate, graph.CreateLiteralNode(entry.FullName));
graph.Assert(entryNode, namePredicate, graph.CreateLiteralNode(entry.Name));
graph.Assert(entryNode, lengthPredicate, graph.CreateLiteralNode(entry.Length.ToString(), Schema.DataTypes.Integer));
graph.Assert(entryNode, compressedLengthPredicate, graph.CreateLiteralNode(entry.CompressedLength.ToString(), Schema.DataTypes.Integer));
}
}
context.StageResults.Add(new GraphPackageMetadata(graph));
return true;
}
public static void Main(string[] args)
{
//Create a new Empty Graph
Graph g = new Graph();
//Define Namespaces
g.NamespaceMap.AddNamespace("pets", new Uri("http://example.org/pets"));
//Create Uri Nodes
IUriNode dog, fido, rob, owner, name, species, breed, lab;
dog = g.CreateUriNode("pets:Dog");
fido = g.CreateUriNode("pets:abc123");
rob = g.CreateUriNode("pets:def456");
owner = g.CreateUriNode("pets:hasOwner");
name = g.CreateUriNode("pets:hasName");
species = g.CreateUriNode("pets:isAnimal");
breed = g.CreateUriNode("pets:isBreed");
lab = g.CreateUriNode("pets:Labrador");
//Assert Triples
g.Assert(new Triple(fido, species, dog));
g.Assert(new Triple(fido, owner, rob));
g.Assert(new Triple(fido, name, g.CreateLiteralNode("Fido")));
g.Assert(new Triple(rob, name, g.CreateLiteralNode("Rob")));
g.Assert(new Triple(fido, breed, lab));
//Attempt to output GraphViz
try
{
Console.WriteLine("Writing GraphViz DOT file graph_building_example2.dot");
GraphVizWriter gvzwriter = new GraphVizWriter();
gvzwriter.Save(g, "graph_building_example2.dot");
Console.WriteLine("Creating a PNG got this Graph called graph_building_example2.png");
GraphVizGenerator gvzgen = new GraphVizGenerator("svg", "C:\\Program Files (x86)\\Graphviz2.20\\bin");
gvzgen.Format = "png";
gvzgen.Generate(g, "graph_building_example2.png", false);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
}
public string AsString(SparqlResultsFormat format)
{
var g = new VDS.RDF.Graph();
var results = new List<SparqlResult>();
foreach (var graphUri in Graphs)
{
var s = new Set();
s.Add(SparqlResultVariableName, g.CreateUriNode(new Uri(graphUri)));
results.Add(new SparqlResult(s));
}
var rs = new SparqlResultSet(results);
var writer = GetWriter(format);
var sw = new StringWriter();
writer.Save(rs, sw);
sw.Flush();
return sw.ToString();
}
public string AsString(SparqlResultsFormat format)
{
var g = new VDS.RDF.Graph();
var results = new List <SparqlResult>();
foreach (var graphUri in Graphs)
{
var s = new Set();
s.Add(SparqlResultVariableName, g.CreateUriNode(new Uri(graphUri)));
results.Add(new SparqlResult(s));
}
var rs = new SparqlResultSet(results);
var writer = GetWriter(format);
var sw = new StringWriter();
writer.Save(rs, sw);
sw.Flush();
return(sw.ToString());
}
static KeyValuePair<string, IGraph> CreateTestCatalogEntry(string id, string version, bool isDelete = false)
{
Uri packageContentUri = new Uri(string.Format("https://content/{0}.zip", Guid.NewGuid()));
IGraph graph = new Graph();
Uri subjectUri = new Uri(string.Format("https://catalog/{0}", Guid.NewGuid()));
INode subject = graph.CreateUriNode(subjectUri);
graph.Assert(subject, graph.CreateUriNode(Schema.Predicates.Id), graph.CreateLiteralNode(id));
graph.Assert(subject, graph.CreateUriNode(Schema.Predicates.Version), graph.CreateLiteralNode(version));
if (isDelete)
{
graph.Assert(subject, graph.CreateUriNode(Schema.Predicates.Type), graph.CreateUriNode(Schema.DataTypes.CatalogDelete));
}
else
{
graph.Assert(subject, graph.CreateUriNode(Schema.Predicates.Published), graph.CreateLiteralNode(DateTime.UtcNow.ToString("O"), Schema.DataTypes.DateTime));
graph.Assert(subject, graph.CreateUriNode(Schema.Predicates.PackageContent), graph.CreateUriNode(packageContentUri));
}
Console.WriteLine(subjectUri);
return new KeyValuePair<string, IGraph>(subjectUri.AbsoluteUri, graph);
}
public void NodesHashCodes()
{
Console.WriteLine("Tests that Literal and URI Nodes produce different Hashes");
Console.WriteLine();
//Create the Nodes
Graph g = new Graph();
IUriNode u = g.CreateUriNode(new Uri("http://www.google.com"));
ILiteralNode l = g.CreateLiteralNode("http://www.google.com/");
Console.WriteLine("Created a URI and Literal Node both referring to 'http://www.google.com'");
Console.WriteLine("String form of URI Node is:");
Console.WriteLine(u.ToString());
Console.WriteLine("String form of Literal Node is:");
Console.WriteLine(l.ToString());
Console.WriteLine("Hash Code of URI Node is " + u.GetHashCode());
Console.WriteLine("Hash Code of Literal Node is " + l.GetHashCode());
Console.WriteLine("Hash Codes are Equal? " + u.GetHashCode().Equals(l.GetHashCode()));
Console.WriteLine("Nodes are equal? " + u.Equals(l));
Assert.NotEqual(u.GetHashCode(), l.GetHashCode());
Assert.NotSame(u, l);
//Assert.NotEqual(u, l);
//Create some plain and typed literals which may have colliding Hash Codes
ILiteralNode plain = g.CreateLiteralNode("test^^http://example.org/type");
ILiteralNode typed = g.CreateLiteralNode("test", new Uri("http://example.org/type"));
Console.WriteLine();
Console.WriteLine("Created a Plain and Typed Literal where the String representations are identical");
Console.WriteLine("Plain Literal String form is:");
Console.WriteLine(plain.ToString());
Console.WriteLine("Typed Literal String from is:");
Console.WriteLine(typed.ToString());
Console.WriteLine("Hash Code of Plain Literal is " + plain.GetHashCode());
Console.WriteLine("Hash Code of Typed Literal is " + typed.GetHashCode());
Console.WriteLine("Hash Codes are Equal? " + plain.GetHashCode().Equals(typed.GetHashCode()));
Console.WriteLine("Nodes are equal? " + plain.Equals(typed));
Assert.NotEqual(plain.GetHashCode(), typed.GetHashCode());
Assert.NotEqual(plain, typed);
//Create Triples
IBlankNode b = g.CreateBlankNode();
IUriNode type = g.CreateUriNode("rdf:type");
Triple t1, t2;
t1 = new Triple(b, type, u);
t2 = new Triple(b, type, l);
Console.WriteLine();
Console.WriteLine("Created two Triples stating a Blank Node has rdf:type of the URI Nodes created earlier");
Console.WriteLine("String form of Triple 1 (using URI Node) is:");
Console.WriteLine(t1.ToString());
Console.WriteLine("String form of Triple 2 (using Literal Node) is:");
Console.WriteLine(t2.ToString());
Console.WriteLine("Hash Code of Triple 1 is " + t1.GetHashCode());
Console.WriteLine("Hash Code of Triple 2 is " + t2.GetHashCode());
Console.WriteLine("Hash Codes are Equal? " + t1.GetHashCode().Equals(t2.GetHashCode()));
Console.WriteLine("Triples are Equal? " + t1.Equals(t2));
Assert.NotEqual(t1.GetHashCode(), t2.GetHashCode());
Assert.NotEqual(t1, t2);
//Create Triples from the earlier Literal Nodes
t1 = new Triple(b, type, plain);
t2 = new Triple(b, type, typed);
Console.WriteLine();
Console.WriteLine("Created two Triples stating a Blank Node has rdf:type of the Literal Nodes created earlier");
Console.WriteLine("String form of Triple 1 (using Plain Literal) is:");
Console.WriteLine(t1.ToString());
Console.WriteLine("String form of Triple 2 (using Typed Literal) is:");
Console.WriteLine(t2.ToString());
Console.WriteLine("Hash Code of Triple 1 is " + t1.GetHashCode());
Console.WriteLine("Hash Code of Triple 2 is " + t2.GetHashCode());
Console.WriteLine("Hash Codes are Equal? " + t1.GetHashCode().Equals(t2.GetHashCode()));
Console.WriteLine("Triples are Equal? " + t1.Equals(t2));
Assert.NotEqual(t1.GetHashCode(), t2.GetHashCode());
Assert.NotEqual(t1, t2);
}
public void NodesUriNodeEquality()
{
//Create the Nodes
Graph g = new Graph();
Console.WriteLine("Creating two URIs referring to google - one lowercase, one uppercase - which should be equivalent");
IUriNode a = g.CreateUriNode(new Uri("http://www.google.com"));
IUriNode b = g.CreateUriNode(new Uri("http://www.GOOGLE.com/"));
TestTools.CompareNodes(a, b, true);
Console.WriteLine("Creating two URIs with the same Fragment ID but differing in case and thus are different since Fragment IDs are case sensitive => not equals");
IUriNode c = g.CreateUriNode(new Uri("http://www.google.com/#Test"));
IUriNode d = g.CreateUriNode(new Uri("http://www.GOOGLE.com/#test"));
TestTools.CompareNodes(c, d, false);
Console.WriteLine("Creating two identical URIs with unusual characters in them");
IUriNode e = g.CreateUriNode(new Uri("http://www.google.com/random,_@characters"));
IUriNode f = g.CreateUriNode(new Uri("http://www.google.com/random,_@characters"));
TestTools.CompareNodes(e, f, true);
Console.WriteLine("Creating two URIs with similar paths that differ in case");
IUriNode h = g.CreateUriNode(new Uri("http://www.google.com/path/test/case"));
IUriNode i = g.CreateUriNode(new Uri("http://www.google.com/path/Test/case"));
TestTools.CompareNodes(h, i, false);
Console.WriteLine("Creating three URIs with equivalent relative paths");
IUriNode j = g.CreateUriNode(new Uri("http://www.google.com/relative/test/../example.html"));
IUriNode k = g.CreateUriNode(new Uri("http://www.google.com/relative/test/monkey/../../example.html"));
IUriNode l = g.CreateUriNode(new Uri("http://www.google.com/relative/./example.html"));
TestTools.CompareNodes(j, k, true);
TestTools.CompareNodes(k, l, true);
}
public void NodesSortingSparqlOrder()
{
SparqlOrderingComparer comparer = new SparqlOrderingComparer();
//Stream for Output
Console.WriteLine("## Sorting Test");
Console.WriteLine("NULLs < Blank Nodes < URI Nodes < Untyped Literals < Typed Literals");
Console.WriteLine();
//Create a Graph
Graph g = new Graph();
g.BaseUri = new Uri("http://example.org/");
g.NamespaceMap.AddNamespace("", new Uri("http://example.org/"));
//Create a list of various Nodes
List <INode> nodes = new List <INode>();
nodes.Add(g.CreateUriNode(":someUri"));
nodes.Add(g.CreateBlankNode());
nodes.Add(null);
nodes.Add(g.CreateBlankNode());
nodes.Add(g.CreateLiteralNode("cheese"));
nodes.Add(g.CreateLiteralNode("aardvark"));
nodes.Add(g.CreateLiteralNode(DateTime.Now.AddDays(-25).ToString(XmlSpecsHelper.XmlSchemaDateTimeFormat), new Uri(XmlSpecsHelper.XmlSchemaDataTypeDateTime)));
nodes.Add(g.CreateLiteralNode("duck"));
nodes.Add(g.CreateUriNode(":otherUri"));
nodes.Add(g.CreateLiteralNode("1.5", new Uri(XmlSpecsHelper.XmlSchemaDataTypeDouble)));
nodes.Add(g.CreateUriNode(new Uri("http://www.google.com")));
nodes.Add(g.CreateLiteralNode(DateTime.Now.AddYears(3).ToString(XmlSpecsHelper.XmlSchemaDateTimeFormat), new Uri(XmlSpecsHelper.XmlSchemaDataTypeDateTime)));
nodes.Add(g.CreateLiteralNode("23", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Add(g.CreateLiteralNode("M43d", new Uri(XmlSpecsHelper.XmlSchemaDataTypeBase64Binary)));
nodes.Add(g.CreateUriNode(new Uri("http://www.dotnetrdf.org")));
nodes.Add(g.CreateLiteralNode("12", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Add(g.CreateBlankNode("monkey"));
nodes.Add(g.CreateBlankNode());
nodes.Add(g.CreateLiteralNode("chaese"));
nodes.Add(g.CreateLiteralNode("1.0456345", new Uri(XmlSpecsHelper.XmlSchemaDataTypeDouble)));
nodes.Add(g.CreateLiteralNode("cheese"));
nodes.Add(g.CreateLiteralNode(Convert.ToBase64String(new byte[] { Byte.Parse("32") }), new Uri(XmlSpecsHelper.XmlSchemaDataTypeBase64Binary)));
nodes.Add(g.CreateLiteralNode("TA==", new Uri(XmlSpecsHelper.XmlSchemaDataTypeBase64Binary)));
nodes.Add(g.CreateLiteralNode("-45454", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Add(g.CreateLiteralNode(DateTime.Now.ToString(XmlSpecsHelper.XmlSchemaDateTimeFormat), new Uri(XmlSpecsHelper.XmlSchemaDataTypeDateTime)));
nodes.Add(g.CreateLiteralNode("-3", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Add(g.CreateLiteralNode("242344.3456435", new Uri(XmlSpecsHelper.XmlSchemaDataTypeDouble)));
nodes.Add(g.CreateLiteralNode("true", new Uri(XmlSpecsHelper.XmlSchemaDataTypeBoolean)));
nodes.Add(g.CreateUriNode(":what"));
nodes.Add(null);
nodes.Add(g.CreateLiteralNode("false", new Uri(XmlSpecsHelper.XmlSchemaDataTypeBoolean)));
nodes.Add(g.CreateLiteralNode("invalid-value", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Sort(comparer);
//Output the Results
foreach (INode n in nodes)
{
if (n == null)
{
Console.WriteLine("NULL");
}
else
{
Console.WriteLine(n.ToString());
}
}
Console.WriteLine();
Console.WriteLine("Now in reverse...");
Console.WriteLine();
nodes.Reverse();
//Output the Results
foreach (INode n in nodes)
{
if (n == null)
{
Console.WriteLine("NULL");
}
else
{
Console.WriteLine(n.ToString());
}
}
}
public void NodeCompareToMixedNodes3()
{
Graph g = new Graph();
Graph h = new Graph();
IBlankNode b = g.CreateBlankNode();
ILiteralNode plain = g.CreateLiteralNode("plain");
IUriNode u = g.CreateUriNode("rdf:type");
List <INode> nodes = new List <INode>()
{
b,
g.CreateBlankNode(),
g.CreateBlankNode("id"),
g.CreateLiteralNode("1.2e3", new Uri(XmlSpecsHelper.XmlSchemaDataTypeFloat)),
g.CreateLiteralNode("1.2", new Uri(XmlSpecsHelper.XmlSchemaDataTypeFloat)),
g.CreateLiteralNode("1.2e1", new Uri(XmlSpecsHelper.XmlSchemaDataTypeFloat)),
g.CreateLiteralNode("10", new Uri(XmlSpecsHelper.XmlSchemaDataTypeShort)),
g.CreateLiteralNode("-3", new Uri(XmlSpecsHelper.XmlSchemaDataTypeShort)),
g.CreateLiteralNode("1.2E4", new Uri(XmlSpecsHelper.XmlSchemaDataTypeFloat)),
g.CreateLiteralNode("http://example.org:8080", new Uri(XmlSpecsHelper.XmlSchemaDataTypeAnyUri)),
g.CreateLiteralNode("http://example.org/path", new Uri(XmlSpecsHelper.XmlSchemaDataTypeAnyUri)),
g.CreateLiteralNode("ftp://ftp.example.org", new Uri(XmlSpecsHelper.XmlSchemaDataTypeAnyUri)),
g.CreateLiteralNode("1.2e0", new Uri(XmlSpecsHelper.XmlSchemaDataTypeFloat)),
DateTime.Now.ToLiteral(g),
DateTime.Now.AddYears(3).AddDays(1).ToLiteral(g),
DateTime.Now.AddYears(-25).AddMinutes(-17).ToLiteral(g),
g.CreateLiteralNode("1.2e-1", new Uri(XmlSpecsHelper.XmlSchemaDataTypeFloat)),
g.CreateLiteralNode("10", new Uri(XmlSpecsHelper.XmlSchemaDataTypeFloat)),
g.CreateLiteralNode("10e14", new Uri(XmlSpecsHelper.XmlSchemaDataTypeFloat)),
h.CreateBlankNode(),
h.CreateBlankNode("id"),
b,
plain,
g.CreateLiteralNode("plain english", "en"),
g.CreateLiteralNode("1", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)),
g.CreateLiteralNode("10", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)),
g.CreateLiteralNode("plain french", "fr"),
g.CreateLiteralNode("typed", new Uri(XmlSpecsHelper.XmlSchemaDataTypeString)),
(1234).ToLiteral(g),
(12.34m).ToLiteral(g),
(12.34d).ToLiteral(g),
(false).ToLiteral(g),
g.CreateLiteralNode((1).ToString("X2"), new Uri(XmlSpecsHelper.XmlSchemaDataTypeHexBinary)),
g.CreateLiteralNode((10).ToString("X2"), new Uri(XmlSpecsHelper.XmlSchemaDataTypeHexBinary)),
(true).ToLiteral(g),
plain,
u,
g.CreateUriNode(new Uri("http://example.org")),
g.CreateUriNode(new Uri("http://example.org:8080")),
g.CreateLiteralNode("1", new Uri(XmlSpecsHelper.XmlSchemaDataTypeByte)),
g.CreateLiteralNode("10", new Uri(XmlSpecsHelper.XmlSchemaDataTypeByte)),
g.CreateLiteralNode("-3", new Uri(XmlSpecsHelper.XmlSchemaDataTypeByte)),
g.CreateUriNode(new Uri("http://www.dotnetrdf.org")),
g.CreateUriNode(new Uri("http://www.dotnetrdf.org/configuration#")),
g.CreateUriNode(new Uri("http://www.dotnetrdf.org/Configuration#")),
g.CreateUriNode(new Uri("mailto:[email protected]")),
u
};
this.ShowOrdering(nodes);
this.CheckCombinations(nodes);
}
public void NodeCompareToUriNodes()
{
Graph g = new Graph();
IUriNode u = g.CreateUriNode("rdf:type");
List <INode> nodes = new List <INode>()
{
u,
g.CreateUriNode(new Uri("http://example.org")),
g.CreateUriNode(new Uri("http://example.org:80")),
g.CreateUriNode(new Uri("http://example.org:8080")),
g.CreateUriNode(new Uri("http://www.dotnetrdf.org")),
g.CreateUriNode(new Uri("http://www.dotnetrdf.org/configuration#")),
g.CreateUriNode(new Uri("http://www.dotnetrdf.org/Configuration#")),
g.CreateUriNode(new Uri("mailto:[email protected]")),
u,
g.CreateUriNode(new Uri("ftp://ftp.example.org")),
g.CreateUriNode(new Uri("ftp://[email protected]")),
g.CreateUriNode(new Uri("ftp://*****:*****@ftp.example.org"))
};
this.ShowOrdering(nodes);
this.CheckCombinations(nodes);
this.CheckCombinations <IUriNode>(nodes.OfType <IUriNode>().ToList());
this.CheckCombinations <UriNode>(nodes.OfType <UriNode>().ToList());
}
public void GraphCreation1()
{
//Create a new Empty Graph
Graph g = new Graph();
Assert.NotNull(g);
//Define Namespaces
g.NamespaceMap.AddNamespace("vds", new Uri("http://www.vdesign-studios.com/dotNetRDF#"));
g.NamespaceMap.AddNamespace("ecs", new Uri("http://id.ecs.soton.ac.uk/person/"));
//Check we set the Namespace OK
Assert.True(g.NamespaceMap.HasNamespace("vds"), "Failed to set a Namespace");
//Set Base Uri
g.BaseUri = g.NamespaceMap.GetNamespaceUri("vds");
Assert.NotNull(g.BaseUri);
Assert.Equal(g.NamespaceMap.GetNamespaceUri("vds"), g.BaseUri);
//Create Uri Nodes
IUriNode rav08r, wh, lac, hcd;
rav08r = g.CreateUriNode("ecs:11471");
wh = g.CreateUriNode("ecs:1650");
hcd = g.CreateUriNode("ecs:46");
lac = g.CreateUriNode("ecs:60");
//Create Uri Nodes for some Predicates
IUriNode supervises, collaborates, advises, has;
supervises = g.CreateUriNode("vds:supervises");
collaborates = g.CreateUriNode("vds:collaborates");
advises = g.CreateUriNode("vds:advises");
has = g.CreateUriNode("vds:has");
//Create some Literal Nodes
ILiteralNode singleLine = g.CreateLiteralNode("Some string");
ILiteralNode multiLine = g.CreateLiteralNode("This goes over\n\nseveral\n\nlines");
ILiteralNode french = g.CreateLiteralNode("Bonjour", "fr");
ILiteralNode number = g.CreateLiteralNode("12", new Uri(g.NamespaceMap.GetNamespaceUri("xsd") + "integer"));
g.Assert(new Triple(wh, supervises, rav08r));
g.Assert(new Triple(lac, supervises, rav08r));
g.Assert(new Triple(hcd, advises, rav08r));
g.Assert(new Triple(wh, collaborates, lac));
g.Assert(new Triple(wh, collaborates, hcd));
g.Assert(new Triple(lac, collaborates, hcd));
g.Assert(new Triple(rav08r, has, singleLine));
g.Assert(new Triple(rav08r, has, multiLine));
g.Assert(new Triple(rav08r, has, french));
g.Assert(new Triple(rav08r, has, number));
//Now print all the Statements
Console.WriteLine("All Statements");
foreach (Triple t in g.Triples)
{
Console.WriteLine(t.ToString());
}
//Get statements about Rob Vesse
Console.WriteLine();
Console.WriteLine("Statements about Rob Vesse");
foreach (Triple t in g.GetTriples(rav08r))
{
Console.WriteLine(t.ToString());
}
//Get Statements about Collaboration
Console.WriteLine();
Console.WriteLine("Statements about Collaboration");
foreach (Triple t in g.GetTriples(collaborates))
{
Console.WriteLine(t.ToString());
}
//Attempt to output Turtle for this Graph
try
{
Console.WriteLine("Writing Turtle file graph_building_example.ttl");
var ttlwriter = new CompressingTurtleWriter();
ttlwriter.Save(g, "graph_building_example.ttl");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
}
