/// <summary>
/// Writes the given store to the given stream in the given RDF format.
/// </summary>
public static void WriteRDF(RDFStoreEnums.RDFFormats rdfFormat, RDFStore store, Stream outputStream)
{
if (store != null)
{
if (outputStream != null)
{
switch (rdfFormat)
{
case RDFStoreEnums.RDFFormats.NQuads:
RDFNQuads.Serialize(store, outputStream);
break;
case RDFStoreEnums.RDFFormats.TriX:
RDFTriX.Serialize(store, outputStream);
break;
}
}
else
{
throw new RDFStoreException("Cannot write RDF file because given \"outputStream\" parameter is null.");
}
}
else
{
throw new RDFStoreException("Cannot write RDF file because given \"store\" parameter is null.");
}
}
/// <summary>
/// Builds a new difference store from this store and a given one
/// </summary>
public RDFMemoryStore DifferenceWith(RDFStore store)
{
RDFMemoryStore result = new RDFMemoryStore();
if (store != null)
{
//Add difference quadruples
foreach (RDFQuadruple q in this)
{
if (!store.ContainsQuadruple(q))
{
result.AddQuadruple(q);
}
}
}
else
{
//Add quadruples from this store
foreach (RDFQuadruple q in this)
{
result.AddQuadruple(q);
}
}
return(result);
}
/// <summary>
/// Removes the store from the federation
/// </summary>
public RDFFederation RemoveStore(RDFStore store)
{
if (store != null)
{
if (this.Stores.ContainsKey(store.StoreID))
{
this.Stores.Remove(store.StoreID);
}
}
return(this);
}
/// <summary>
/// Adds the store to the federation, avoiding duplicate insertions
/// </summary>
public RDFFederation AddStore(RDFStore store)
{
if (store != null)
{
if (!this.Stores.ContainsKey(store.StoreID))
{
this.Stores.Add(store.StoreID, store);
}
}
return(this);
}
/// <summary>
/// Removes the store from the federation
/// </summary>
public RDFFederation RemoveStore(RDFStore store)
{
if (store != null)
{
if (this.Stores.ContainsKey(store.StoreID))
{
this.Stores.Remove(store.StoreID);
RDFStoreEvents.RaiseOnStoreRemoved(String.Format("Store '{0}' has been removed from the Federation '{1}'.", store, this));
}
}
return(this);
}
/// <summary>
/// Adds the store to the federation, avoiding duplicate insertions
/// </summary>
public RDFFederation AddStore(RDFStore store)
{
if (store != null)
{
if (!this.Stores.ContainsKey(store.StoreID))
{
this.Stores.Add(store.StoreID, store);
RDFStoreEvents.RaiseOnStoreAdded(String.Format("Store '{0}' has been added to the Federation '{1}'.", store, this));
}
}
return(this);
}
/// <summary>
/// Builds a new intersection store from this store and a given one
/// </summary>
public RDFMemoryStore IntersectWith(RDFStore store)
{
RDFMemoryStore result = new RDFMemoryStore();
if (store != null)
{
//Add intersection quadruples
foreach (RDFQuadruple q in this)
{
if (store.ContainsQuadruple(q))
{
result.AddQuadruple(q);
}
}
}
return(result);
}
/// <summary>
/// Builds a new union store from this store and a given one
/// </summary>
public RDFMemoryStore UnionWith(RDFStore store)
{
RDFMemoryStore result = new RDFMemoryStore();
//Add quadruples from this store
foreach (RDFQuadruple q in this)
{
result.AddQuadruple(q);
}
//Manage the given store
if (store != null)
{
//Add quadruples from the given store
foreach (RDFQuadruple q in store.SelectAllQuadruples())
{
result.AddQuadruple(q);
}
}
return(result);
}
/// <summary>
/// Serializes the given store to the given filepath using N-Quads data format.
/// </summary>
internal static void Serialize(RDFStore store, Stream outputStream)
{
try {
#region serialize
using (StreamWriter sw = new StreamWriter(outputStream, Encoding.ASCII)) {
String quadrupleTemplate = String.Empty;
foreach (var q in store.SelectAllQuadruples())
{
#region template
if (q.TripleFlavor == RDFModelEnums.RDFTripleFlavor.SPO)
{
quadrupleTemplate = "<{SUBJ}> <{PRED}> <{OBJ}> <{CTX}> .";
}
else
{
if (q.Object is RDFPlainLiteral)
{
quadrupleTemplate = "<{SUBJ}> <{PRED}> \"{VAL}\"@{LANG} <{CTX}> .";
}
else
{
quadrupleTemplate = "<{SUBJ}> <{PRED}> \"{VAL}\"^^<{DTYPE}> <{CTX}> .";
}
}
#endregion
#region subj
if (((RDFResource)q.Subject).IsBlank)
{
quadrupleTemplate = quadrupleTemplate.Replace("<{SUBJ}>", RDFModelUtilities.Unicode_To_ASCII(q.Subject.ToString()).Replace("bnode:", "_:"));
}
else
{
quadrupleTemplate = quadrupleTemplate.Replace("{SUBJ}", RDFModelUtilities.Unicode_To_ASCII(q.Subject.ToString()));
}
#endregion
#region pred
quadrupleTemplate = quadrupleTemplate.Replace("{PRED}", RDFModelUtilities.Unicode_To_ASCII(q.Predicate.ToString()));
#endregion
#region object
if (q.TripleFlavor == RDFModelEnums.RDFTripleFlavor.SPO)
{
if (((RDFResource)q.Object).IsBlank)
{
quadrupleTemplate = quadrupleTemplate.Replace("<{OBJ}>", RDFModelUtilities.Unicode_To_ASCII(q.Object.ToString())).Replace("bnode:", "_:");
}
else
{
quadrupleTemplate = quadrupleTemplate.Replace("{OBJ}", RDFModelUtilities.Unicode_To_ASCII(q.Object.ToString()));
}
}
#endregion
#region literal
else
{
quadrupleTemplate = quadrupleTemplate.Replace("{VAL}", RDFModelUtilities.Unicode_To_ASCII(((RDFLiteral)q.Object).Value.Replace("\"", "\\\"")));
quadrupleTemplate = quadrupleTemplate.Replace("\n", "\\n")
.Replace("\t", "\\t")
.Replace("\r", "\\r");
#region plain literal
if (q.Object is RDFPlainLiteral)
{
if (((RDFPlainLiteral)q.Object).Language != String.Empty)
{
quadrupleTemplate = quadrupleTemplate.Replace("{LANG}", ((RDFPlainLiteral)q.Object).Language);
}
else
{
quadrupleTemplate = quadrupleTemplate.Replace("@{LANG}", String.Empty);
}
}
#endregion
#region typed literal
else
{
quadrupleTemplate = quadrupleTemplate.Replace("{DTYPE}", RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)q.Object).Datatype));
}
#endregion
}
#endregion
#region context
quadrupleTemplate = quadrupleTemplate.Replace("{CTX}", RDFModelUtilities.Unicode_To_ASCII(q.Context.ToString()));
#endregion
sw.WriteLine(quadrupleTemplate);
}
}
#endregion
}
catch (Exception ex) {
throw new RDFStoreException("Cannot serialize N-Quads because: " + ex.Message, ex);
}
}
/// <summary>
/// Serializes the given store to the given filepath using N-Quads data format.
/// </summary>
internal static void Serialize(RDFStore store, String filepath)
{
Serialize(store, new FileStream(filepath, FileMode.Create));
}
/// <summary>
/// Serializes the given store to the given stream using TriX data format.
/// </summary>
internal static void Serialize(RDFStore store, Stream outputStream)
{
try
{
#region serialize
using (XmlTextWriter trixWriter = new XmlTextWriter(outputStream, Encoding.UTF8))
{
XmlDocument trixDoc = new XmlDocument();
trixWriter.Formatting = Formatting.Indented;
#region xmlDecl
XmlDeclaration trixDecl = trixDoc.CreateXmlDeclaration("1.0", "UTF-8", null);
trixDoc.AppendChild(trixDecl);
#endregion
#region trixRoot
XmlNode trixRoot = trixDoc.CreateNode(XmlNodeType.Element, "TriX", null);
XmlAttribute trixRootNS = trixDoc.CreateAttribute("xmlns");
XmlText trixRootNSText = trixDoc.CreateTextNode("http://www.w3.org/2004/03/trix/trix-1/");
trixRootNS.AppendChild(trixRootNSText);
trixRoot.Attributes.Append(trixRootNS);
#region graphs
foreach (var graph in store.ExtractGraphs())
{
XmlNode graphElement = trixDoc.CreateNode(XmlNodeType.Element, "graph", null);
XmlNode graphUriElement = trixDoc.CreateNode(XmlNodeType.Element, "uri", null);
XmlText graphUriElementT = trixDoc.CreateTextNode(graph.ToString());
graphUriElement.AppendChild(graphUriElementT);
graphElement.AppendChild(graphUriElement);
#region triple
foreach (var t in graph)
{
XmlNode tripleElement = trixDoc.CreateNode(XmlNodeType.Element, "triple", null);
#region subj
XmlNode subjElement = (((RDFResource)t.Subject).IsBlank ? trixDoc.CreateNode(XmlNodeType.Element, "id", null) :
trixDoc.CreateNode(XmlNodeType.Element, "uri", null));
XmlText subjElementText = trixDoc.CreateTextNode(t.Subject.ToString());
subjElement.AppendChild(subjElementText);
tripleElement.AppendChild(subjElement);
#endregion
#region pred
XmlNode uriElementP = trixDoc.CreateNode(XmlNodeType.Element, "uri", null);
XmlText uriTextP = trixDoc.CreateTextNode(t.Predicate.ToString());
uriElementP.AppendChild(uriTextP);
tripleElement.AppendChild(uriElementP);
#endregion
#region object
if (t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO)
{
XmlNode objElement = (((RDFResource)t.Object).IsBlank ? trixDoc.CreateNode(XmlNodeType.Element, "id", null) :
trixDoc.CreateNode(XmlNodeType.Element, "uri", null));
XmlText objElementText = trixDoc.CreateTextNode(t.Object.ToString());
objElement.AppendChild(objElementText);
tripleElement.AppendChild(objElement);
}
#endregion
#region literal
else
{
#region plain literal
if (t.Object is RDFPlainLiteral)
{
XmlNode plainLiteralElement = trixDoc.CreateNode(XmlNodeType.Element, "plainLiteral", null);
if (((RDFPlainLiteral)t.Object).Language != String.Empty)
{
XmlAttribute xmlLang = trixDoc.CreateAttribute(RDFVocabulary.XML.PREFIX + ":lang", RDFVocabulary.XML.BASE_URI);
XmlText xmlLangText = trixDoc.CreateTextNode(((RDFPlainLiteral)t.Object).Language);
xmlLang.AppendChild(xmlLangText);
plainLiteralElement.Attributes.Append(xmlLang);
}
XmlText plainLiteralText = trixDoc.CreateTextNode(RDFModelUtilities.EscapeControlCharsForXML(HttpUtility.HtmlDecode(((RDFLiteral)t.Object).Value)));
plainLiteralElement.AppendChild(plainLiteralText);
tripleElement.AppendChild(plainLiteralElement);
}
#endregion
#region typed literal
else
{
XmlNode typedLiteralElement = trixDoc.CreateNode(XmlNodeType.Element, "typedLiteral", null);
XmlAttribute datatype = trixDoc.CreateAttribute("datatype");
XmlText datatypeText = trixDoc.CreateTextNode(RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)t.Object).Datatype));
datatype.AppendChild(datatypeText);
typedLiteralElement.Attributes.Append(datatype);
XmlText typedLiteralText = trixDoc.CreateTextNode(RDFModelUtilities.EscapeControlCharsForXML(HttpUtility.HtmlDecode(((RDFLiteral)t.Object).Value)));
typedLiteralElement.AppendChild(typedLiteralText);
tripleElement.AppendChild(typedLiteralElement);
}
#endregion
}
#endregion
graphElement.AppendChild(tripleElement);
}
#endregion
trixRoot.AppendChild(graphElement);
}
#endregion
trixDoc.AppendChild(trixRoot);
#endregion
trixDoc.Save(trixWriter);
}
#endregion
}
catch (Exception ex)
{
throw new RDFStoreException("Cannot serialize TriX because: " + ex.Message, ex);
}
}
