/// <summary>
/// Converts a dotNetRDF Graph to a Sesame Graph
/// </summary>
/// <param name="g">dotNetRDF Graph</param>
/// <param name="mapping">Blank Node Mapping</param>
/// <param name="target">Sesame Graph</param>
public static void ToSesame(IGraph g, SesameMapping mapping, dotSesame.Graph target)
{
foreach (Triple t in g.Triples)
{
target.add(ToSesameResource(t.Subject, mapping), ToSesameUri(t.Predicate, mapping), ToSesameValue(t.Object, mapping));
}
}
public bool add(dotSesame.Resource r, dotSesame.URI uri, dotSesame.Value v, params dotSesame.Resource[] rarr)
{
Triple t = new Triple(SesameConverter.FromSesameResource(r, this._mapping), SesameConverter.FromSesameUri(uri, this._mapping), SesameConverter.FromSesameValue(v, this._mapping));
if (this._g.ContainsTriple(t))
{
return false;
}
else
{
this._g.Assert(t);
return true;
}
}
/// <summary>
/// Converts a dotNetRDF Graph to a Sesame Graph
/// </summary>
/// <param name="g">dotNetRDF Graph</param>
/// <param name="target">Sesame Graph</param>
public static void ToSesame(IGraph g, dotSesame.Graph target)
{
SesameMapping mapping = new SesameMapping(g, target);
ToSesame(g, mapping, target);
}
/// <summary>
/// Converts a Sesame Value to a dotNetRDF Node
/// </summary>
/// <param name="value">Value</param>
/// <param name="mapping">Blank Node Mapping</param>
/// <returns></returns>
internal static INode FromSesameValue(dotSesame.Value value, SesameMapping mapping)
{
if (value is dotSesame.URI)
{
return mapping.Graph.CreateUriNode(new Uri(((dotSesame.URI)value).stringValue()));
}
else if (value is dotSesame.Literal)
{
dotSesame.Literal lit = (dotSesame.Literal)value;
if (lit.getDatatype() != null)
{
return mapping.Graph.CreateLiteralNode(lit.stringValue(), FromSesameUri(lit.getDatatype()));
}
else if (lit.getLanguage() != null)
{
return mapping.Graph.CreateLiteralNode(lit.stringValue(), lit.getLanguage());
}
else
{
return mapping.Graph.CreateLiteralNode(lit.stringValue());
}
}
else if (value is dotSesame.BNode)
{
dotSesame.BNode bnode = (dotSesame.BNode)value;
if (mapping.InputMapping.ContainsKey(bnode))
{
return mapping.InputMapping[bnode];
}
else
{
INode n = mapping.Graph.CreateBlankNode();
lock (mapping)
{
if (!mapping.InputMapping.ContainsKey(bnode))
{
mapping.InputMapping.Add(bnode, n);
}
else
{
n = mapping.InputMapping[bnode];
}
if (!mapping.OutputMapping.ContainsKey(n)) mapping.OutputMapping.Add(n, bnode);
}
return n;
}
}
else
{
throw new RdfException("Unable to convert unexpected Sesame Value Type to a dotNetRDF INode");
}
}
/// <summary>
/// Converts a Sesame URI to a URI
/// </summary>
/// <param name="uri">URI</param>
/// <returns></returns>
internal static Uri FromSesameUri(dotSesame.URI uri)
{
return new Uri(uri.stringValue());
}
/// <summary>
/// Converts a Sesame URI to a dotNetRDF Node
/// </summary>
/// <param name="uri">URI</param>
/// <param name="mapping">Blank Node Mapping</param>
/// <returns></returns>
internal static INode FromSesameUri(dotSesame.URI uri, SesameMapping mapping)
{
return mapping.Graph.CreateUriNode(new Uri(uri.stringValue()));
}
/// <summary>
/// Converts a Sesame Resource to a dotNetRDF Node
/// </summary>
/// <param name="resource">Resource</param>
/// <param name="mapping">Blank Node Mapping</param>
/// <returns></returns>
internal static INode FromSesameResource(dotSesame.Resource resource, SesameMapping mapping)
{
if (resource is dotSesame.URI)
{
return mapping.Graph.CreateUriNode(new Uri(((dotSesame.URI)resource).stringValue()));
}
else if (resource is dotSesame.BNode)
{
dotSesame.BNode bnode = (dotSesame.BNode)resource;
if (mapping.InputMapping.ContainsKey(bnode))
{
return mapping.InputMapping[bnode];
}
else
{
INode n = mapping.Graph.CreateBlankNode();
lock (mapping)
{
if (!mapping.InputMapping.ContainsKey(bnode))
{
mapping.InputMapping.Add(bnode, n);
}
else
{
n = mapping.InputMapping[bnode];
}
if (!mapping.OutputMapping.ContainsKey(n)) mapping.OutputMapping.Add(n, bnode);
}
return n;
}
}
else
{
throw new RdfException("Unable to convert unexpected Sesame Resource Type to a dotNetRDF INode");
}
}
/// <summary>
/// Converts a Sesame Statement to a dotNetRDF Triple
/// </summary>
/// <param name="statement">Sesame Statement</param>
/// <param name="mapping">Blank Node Mapping</param>
/// <returns></returns>
public static Triple FromSesame(dotSesame.Statement statement, SesameMapping mapping)
{
return new Triple(FromSesameResource(statement.getSubject(), mapping), FromSesameUri(statement.getPredicate(), mapping), FromSesameValue(statement.getObject(), mapping));
}
public SesameMapping(DotNetRdfValueFactory factory, dotSesame.Graph target)
{
this._g = factory.Graph;
this._target = target;
this._factory = factory;
}
/// <summary>
/// Converts a Sesame Graph to a dotNetRDF Graph
/// </summary>
/// <param name="source">Sesame Graph</param>
/// <param name="target">dotNetRDF Graph</param>
public static void FromSesame(dotSesame.Graph source, IGraph target)
{
SesameMapping mapping = new SesameMapping(target, source);
FromSesame(source, mapping, target);
}
public DotNetRdfValueFactory(IGraph g, dotSesame.Graph target)
: this(new SesameMapping(g, target)) { }
public dotSesame.Statement createStatement(dotSesame.Resource r, dotSesame.URI uri, dotSesame.Value v)
{
return this._mapping.ValueFactory.createStatement(r, uri, v);
}
public dotSesame.Literal createLiteral(string str, dotSesame.URI uri)
{
return this._mapping.ValueFactory.createLiteral(str, uri);
}
public java.util.Iterator match(dotSesame.Resource r, dotSesame.URI uri, dotSesame.Value v, params dotSesame.Resource[] rarr)
{
INode s = (r != null) ? SesameConverter.FromSesameResource(r, this._mapping) : null;
INode p = (uri != null) ? SesameConverter.FromSesameUri(uri, this._mapping) : null;
INode o = (v != null) ? SesameConverter.FromSesameValue(v, this._mapping) : null;
//Contexts are Ignored for matches on a single Graph
IEnumerable<Triple> ts;
if (s != null)
{
if (p != null)
{
if (o != null)
{
//Matching on Subject Predicate and Object
Triple t = new Triple(s, p, o);
if (this._g.ContainsTriple(t))
{
ts = t.AsEnumerable();
}
else
{
ts = Enumerable.Empty<Triple>();
}
}
else
{
//Just matching on Subject Predicate
ts = this._g.GetTriplesWithSubjectPredicate(s, p);
}
}
else
{
if (o != null)
{
//Matching on Subject Object
ts = this._g.GetTriplesWithSubjectObject(s, o);
}
else
{
//Just Matching on Subject
ts = this._g.GetTriplesWithSubject(s);
}
}
}
else if (p != null)
{
if (o != null)
{
//Matching on Predicate Object
ts = this._g.GetTriplesWithPredicateObject(p, o);
}
else
{
//Just Matching on Predicate
ts = this._g.GetTriplesWithPredicate(p);
}
}
else if (o != null)
{
//Matching on Object only
ts = this._g.GetTriplesWithObject(o);
}
else
{
//Matching anything
ts = this._g.Triples;
}
return new DotNetEnumerableWrapper(ts.Select(t => SesameConverter.ToSesame(t, this._mapping)));
}
public SesameTripleCollection(dotSesame.Graph g, SesameMapping mapping)
{
this._g = g;
this._mapping = mapping;
}
/// <summary>
/// Converts a Sesame Graph to a dotNetRDF Graph
/// </summary>
/// <param name="source">Sesame Graph</param>
/// <param name="mapping">Blank Node Mapping</param>
/// <param name="target">dotNetRDF Graph</param>
public static void FromSesame(dotSesame.Graph source, SesameMapping mapping, IGraph target)
{
Iterator iter = source.iterator();
while (iter.hasNext())
{
dotSesame.Statement stmt = (dotSesame.Statement)iter.next();
target.Assert(FromSesame(stmt, mapping));
}
}
public SesameGraph(dotSesame.Graph g)
{
this._g = g;
this._mapping = new SesameMapping(this, this._g);
this._triples = new SesameTripleCollection(this._g, this._mapping);
}
/// <summary>
/// Creates a new Sesame mapping
/// </summary>
/// <param name="g">Graph</param>
public SesameMapping(IGraph g, dotSesame.Graph target)
{
this._g = g;
this._target = target;
}
