/// <summary>
/// Collects the namespaces used by the given triple
/// </summary>
private void CollectNamespaces(RDFTriple triple)
{
RDFNamespaceRegister.Instance.Register.ForEach(ns => {
String nSpace = ns.ToString();
//Resolve subj Uri
String subj = triple.Subject.ToString();
if (subj.Contains(nSpace) || subj.StartsWith(ns.Prefix + ":"))
{
if (!this.Namespaces.Contains(ns))
{
this.Namespaces.Add(ns);
}
}
//Resolve pred Uri
String pred = triple.Predicate.ToString();
if (pred.Contains(nSpace) || pred.StartsWith(ns.Prefix + ":"))
{
if (!this.Namespaces.Contains(ns))
{
this.Namespaces.Add(ns);
}
}
//Resolve object Uri
if (triple.TripleFlavor == RDFModelEnums.RDFTripleFlavor.SPO)
{
String obj = triple.Object.ToString();
if (obj.Contains(nSpace) || obj.StartsWith(ns.Prefix + ":"))
{
if (!this.Namespaces.Contains(ns))
{
this.Namespaces.Add(ns);
}
}
}
else
{
//Resolve typed literal Uri
if (triple.Object is RDFTypedLiteral)
{
String tLit = RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)triple.Object).Datatype);
if (tLit.Contains(nSpace) || tLit.StartsWith(ns.Prefix + ":"))
{
if (!this.Namespaces.Contains(ns))
{
this.Namespaces.Add(ns);
}
}
}
}
});
}
/// <summary>
/// Enlists the facts/literals which are directly (or indirectly, if inference is requested) members of the lens class
/// </summary>
public List <(bool, RDFOntologyResource)> Members(bool enableInference)
{
List <(bool, RDFOntologyResource)> result = new List <(bool, RDFOntologyResource)>();
//First-level enlisting of members (datatype class)
if (RDFOntologyHelper.CheckIsLiteralCompatibleClass(this.Ontology.Model.ClassModel, this.OntologyClass))
{
IEnumerable <RDFOntologyLiteral> ontlits = this.Ontology.Data.Literals.Values.Where(ol => ol.Value is RDFTypedLiteral);
foreach (RDFOntologyLiteral ontlit in ontlits.Where(ol => RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)ol.Value).Datatype).Equals(this.OntologyClass.ToString())))
{
if (!result.Any(ol => ol.Equals(ontlit)))
{
result.Add((false, ontlit));
}
}
}
//First-level enlisting of members (object class)
else
{
foreach (RDFOntologyTaxonomyEntry sf in this.Ontology.Data.Relations.ClassType.SelectEntriesByObject(this.OntologyClass).Where(te => !te.IsInference()))
{
result.Add((false, sf.TaxonomySubject));
}
}
//Inference-enabled discovery of members
if (enableInference)
{
RDFOntologyData members = RDFOntologyHelper.GetMembersOf(this.Ontology, this.OntologyClass);
foreach (RDFOntologyFact fact in members)
{
if (!result.Any(f => f.Item2.Equals(fact)))
{
result.Add((true, fact));
}
}
foreach (RDFOntologyLiteral literal in members.Literals.Values)
{
if (!result.Any(f => f.Item2.Equals(literal)))
{
result.Add((true, literal));
}
}
}
return(result);
}
/// <summary>
/// Gives a formatted string representation of the given pattern member
/// </summary>
internal static String PrintRDFPatternMember(RDFPatternMember patternMember)
{
if (patternMember != null)
{
#region Variable
if (patternMember is RDFVariable)
{
return(patternMember.ToString());
}
#endregion
#region Non-Variable
#region Resource/Context
if (patternMember is RDFResource || patternMember is RDFContext)
{
if (patternMember is RDFResource && ((RDFResource)patternMember).IsBlank)
{
return(patternMember.ToString());
}
return("<" + patternMember + ">");
}
#endregion
#region Literal
if (patternMember is RDFPlainLiteral)
{
if (((RDFPlainLiteral)patternMember).Language != String.Empty)
{
return("\"" + ((RDFPlainLiteral)patternMember).Value + "\"@" + ((RDFPlainLiteral)patternMember).Language);
}
return("\"" + ((RDFPlainLiteral)patternMember).Value + "\"");
}
return("\"" + ((RDFTypedLiteral)patternMember).Value + "\"^^<" + RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)patternMember).Datatype) + ">");
#endregion
#endregion
}
throw new RDFQueryException("Cannot print pattern member because given \"patternMember\" parameter is null.");
}
/// <summary>
/// Applies the filter on the column corresponding to the variable in the given datarow
/// </summary>
internal override Boolean ApplyFilter(DataRow row, Boolean applyNegation)
{
Boolean keepRow = true;
//Check is performed only if the row contains a column named like the filter's variable
if (row.Table.Columns.Contains(this.Variable.ToString()))
{
String variableValue = row[this.Variable.ToString()].ToString();
//Successfull match if given datatype is found in the variable
keepRow = Regex.IsMatch(variableValue, "\\^\\^" + RDFModelUtilities.GetDatatypeFromEnum(this.Datatype) + "$");
//Apply the eventual negation
if (applyNegation)
{
keepRow = !keepRow;
}
}
return(keepRow);
}
/// <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);
}
}
/// <summary>
/// Writes the "SPARQL Query Results XML Format" stream corresponding to the SELECT query result
/// </summary>
public void ToSparqlXmlResult(Stream outputStream)
{
try {
#region serialize
using (XmlTextWriter sparqlWriter = new XmlTextWriter(outputStream, Encoding.UTF8)) {
XmlDocument sparqlDoc = new XmlDocument();
sparqlWriter.Formatting = Formatting.Indented;
#region xmlDecl
XmlDeclaration sparqlDecl = sparqlDoc.CreateXmlDeclaration("1.0", "UTF-8", null);
sparqlDoc.AppendChild(sparqlDecl);
#endregion
#region sparqlRoot
XmlNode sparqlRoot = sparqlDoc.CreateNode(XmlNodeType.Element, "sparql", null);
XmlAttribute sparqlRootNS = sparqlDoc.CreateAttribute("xmlns");
XmlText sparqlRootNSText = sparqlDoc.CreateTextNode("http://www.w3.org/2005/sparql-results#");
sparqlRootNS.AppendChild(sparqlRootNSText);
sparqlRoot.Attributes.Append(sparqlRootNS);
#region sparqlHead
XmlNode sparqlHeadElement = sparqlDoc.CreateNode(XmlNodeType.Element, "head", null);
IEnumerator resultColumns = this.SelectResults.Columns.GetEnumerator();
while (resultColumns.MoveNext())
{
XmlNode variableElement = sparqlDoc.CreateNode(XmlNodeType.Element, "variable", null);
XmlAttribute varElName = sparqlDoc.CreateAttribute("name");
XmlText varElNameText = sparqlDoc.CreateTextNode(resultColumns.Current.ToString());
varElName.AppendChild(varElNameText);
variableElement.Attributes.Append(varElName);
sparqlHeadElement.AppendChild(variableElement);
}
sparqlRoot.AppendChild(sparqlHeadElement);
#endregion
#region sparqlResults
XmlNode sparqlResultsElement = sparqlDoc.CreateNode(XmlNodeType.Element, "results", null);
IEnumerator resultRows = this.SelectResults.Rows.GetEnumerator();
while (resultRows.MoveNext())
{
resultColumns.Reset();
XmlNode resultElement = sparqlDoc.CreateNode(XmlNodeType.Element, "result", null);
while (resultColumns.MoveNext())
{
if (!((DataRow)resultRows.Current).IsNull(resultColumns.Current.ToString()))
{
XmlNode bindingElement = sparqlDoc.CreateNode(XmlNodeType.Element, "binding", null);
XmlAttribute bindElName = sparqlDoc.CreateAttribute("name");
XmlText bindElNameText = sparqlDoc.CreateTextNode(resultColumns.Current.ToString());
bindElName.AppendChild(bindElNameText);
bindingElement.Attributes.Append(bindElName);
#region RDFTerm
RDFPatternMember rdfTerm = RDFQueryUtilities.ParseRDFPatternMember(((DataRow)resultRows.Current)[resultColumns.Current.ToString()].ToString());
if (rdfTerm is RDFResource)
{
if (rdfTerm.ToString().StartsWith("bnode:"))
{
XmlNode bnodeElement = sparqlDoc.CreateNode(XmlNodeType.Element, "bnode", null);
XmlText bnodeElText = sparqlDoc.CreateTextNode(rdfTerm.ToString());
bnodeElement.AppendChild(bnodeElText);
bindingElement.AppendChild(bnodeElement);
}
else
{
XmlNode uriElement = sparqlDoc.CreateNode(XmlNodeType.Element, "uri", null);
XmlText uriElText = sparqlDoc.CreateTextNode(rdfTerm.ToString());
uriElement.AppendChild(uriElText);
bindingElement.AppendChild(uriElement);
}
}
else if (rdfTerm is RDFLiteral)
{
XmlNode litElement = sparqlDoc.CreateNode(XmlNodeType.Element, "literal", null);
if (rdfTerm is RDFPlainLiteral)
{
if (((RDFPlainLiteral)rdfTerm).Language != String.Empty)
{
XmlAttribute xmlLang = sparqlDoc.CreateAttribute(RDFVocabulary.XML.PREFIX + ":lang", RDFVocabulary.XML.BASE_URI);
XmlText xmlLangText = sparqlDoc.CreateTextNode(((RDFPlainLiteral)rdfTerm).Language);
xmlLang.AppendChild(xmlLangText);
litElement.Attributes.Append(xmlLang);
}
XmlText plainLiteralText = sparqlDoc.CreateTextNode(RDFModelUtilities.EscapeControlCharsForXML(HttpUtility.HtmlDecode(((RDFLiteral)rdfTerm).Value)));
litElement.AppendChild(plainLiteralText);
}
else
{
XmlAttribute datatype = sparqlDoc.CreateAttribute("datatype");
XmlText datatypeText = sparqlDoc.CreateTextNode(RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)rdfTerm).Datatype));
datatype.AppendChild(datatypeText);
litElement.Attributes.Append(datatype);
XmlText typedLiteralText = sparqlDoc.CreateTextNode(RDFModelUtilities.EscapeControlCharsForXML(HttpUtility.HtmlDecode(((RDFLiteral)rdfTerm).Value)));
litElement.AppendChild(typedLiteralText);
}
bindingElement.AppendChild(litElement);
}
#endregion
resultElement.AppendChild(bindingElement);
}
}
sparqlResultsElement.AppendChild(resultElement);
}
sparqlRoot.AppendChild(sparqlResultsElement);
#endregion
sparqlDoc.AppendChild(sparqlRoot);
#endregion
sparqlDoc.Save(sparqlWriter);
}
#endregion
}
catch (Exception ex) {
throw new RDFQueryException("Cannot serialize SPARQL XML RESULT because: " + ex.Message, ex);
}
}
/// <summary>
/// Serializes the given graph to the given stream using N-Triples data format.
/// </summary>
internal static void Serialize(RDFGraph graph, Stream outputStream)
{
try
{
#region serialize
using (StreamWriter sw = new StreamWriter(outputStream, Encoding.ASCII))
{
String tripleTemplate = String.Empty;
foreach (var t in graph)
{
#region template
if (t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO)
{
tripleTemplate = "<{SUBJ}> <{PRED}> <{OBJ}> .";
}
else
{
if (t.Object is RDFPlainLiteral)
{
tripleTemplate = "<{SUBJ}> <{PRED}> \"{VAL}\"@{LANG} .";
}
else
{
tripleTemplate = "<{SUBJ}> <{PRED}> \"{VAL}\"^^<{DTYPE}> .";
}
}
#endregion
#region subj
if (((RDFResource)t.Subject).IsBlank)
{
tripleTemplate = tripleTemplate.Replace("<{SUBJ}>", RDFModelUtilities.Unicode_To_ASCII(t.Subject.ToString()).Replace("bnode:", "_:"));
}
else
{
tripleTemplate = tripleTemplate.Replace("{SUBJ}", RDFModelUtilities.Unicode_To_ASCII(t.Subject.ToString()));
}
#endregion
#region pred
tripleTemplate = tripleTemplate.Replace("{PRED}", RDFModelUtilities.Unicode_To_ASCII(t.Predicate.ToString()));
#endregion
#region object
if (t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO)
{
if (((RDFResource)t.Object).IsBlank)
{
tripleTemplate = tripleTemplate.Replace("<{OBJ}>", RDFModelUtilities.Unicode_To_ASCII(t.Object.ToString())).Replace("bnode:", "_:");
}
else
{
tripleTemplate = tripleTemplate.Replace("{OBJ}", RDFModelUtilities.Unicode_To_ASCII(t.Object.ToString()));
}
}
#endregion
#region literal
else
{
tripleTemplate = tripleTemplate.Replace("{VAL}", RDFModelUtilities.EscapeControlCharsForXML(RDFModelUtilities.Unicode_To_ASCII(((RDFLiteral)t.Object).Value.Replace("\\", "\\\\").Replace("\"", "\\\""))));
tripleTemplate = tripleTemplate.Replace("\n", "\\n")
.Replace("\t", "\\t")
.Replace("\r", "\\r");
#region plain literal
if (t.Object is RDFPlainLiteral)
{
if (((RDFPlainLiteral)t.Object).Language != String.Empty)
{
tripleTemplate = tripleTemplate.Replace("{LANG}", ((RDFPlainLiteral)t.Object).Language);
}
else
{
tripleTemplate = tripleTemplate.Replace("@{LANG}", String.Empty);
}
}
#endregion
#region typed literal
else
{
tripleTemplate = tripleTemplate.Replace("{DTYPE}", RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)t.Object).Datatype));
}
#endregion
}
#endregion
sw.WriteLine(tripleTemplate);
}
}
#endregion
}
catch (Exception ex)
{
throw new RDFModelException("Cannot serialize N-Triples because: " + ex.Message, ex);
}
}
/// <summary>
/// Compares the given pattern members, throwing a "Type Error" whenever the comparison operator detects sematically incompatible members;
/// </summary>
internal static Int32 CompareRDFPatternMembers(RDFPatternMember left, RDFPatternMember right)
{
#region CornerCase Comparisons
if (left == null)
{
if (right == null)
{
return(0);
}
return(-1);
}
if (right == null)
{
return(1);
}
#endregion
#region Effective Comparisons
#region RESOURCE/CONTEXT
if (left is RDFResource || left is RDFContext)
{
//RESOURCE/CONTEXT VS RESOURCE/CONTEXT
if (right is RDFResource || right is RDFContext)
{
return(String.Compare(left.ToString(), right.ToString(), StringComparison.Ordinal));
}
//RESOURCE/CONTEXT VS "XSD:ANYURI" TYPED LITERAL
if (right is RDFTypedLiteral && ((RDFTypedLiteral)right).Datatype.Equals(RDFModelEnums.RDFDatatype.XSD_ANYURI))
{
return(String.Compare(left.ToString(), ((RDFTypedLiteral)right).Value, StringComparison.Ordinal));
}
//RESOURCE/CONTEXT VS LITERAL
return(-1);
}
#endregion
#region PLAINLITERAL
if (left is RDFPlainLiteral)
{
//PLAIN LITERAL VS RESOURCE/CONTEXT
if (right is RDFResource || right is RDFContext)
{
return(1);
}
//PLAIN LITERAL VS PLAIN LITERAL
if (right is RDFPlainLiteral)
{
return(String.Compare(left.ToString(), right.ToString(), StringComparison.Ordinal));
}
//PLAIN LITERAL VS "RDFS:LITERAL" OR "XSD:STRING" TYPED LITERAL
if (((RDFTypedLiteral)right).Datatype.Equals(RDFModelEnums.RDFDatatype.RDFS_LITERAL) ||
((RDFTypedLiteral)right).Datatype.Equals(RDFModelEnums.RDFDatatype.XSD_STRING))
{
return(String.Compare(left.ToString(), ((RDFTypedLiteral)right).Value, StringComparison.Ordinal));
}
//PLAIN LITERAL VS TYPED LITERAL
return(-1);
}
#endregion
#region TYPEDLITERAL
//TYPED LITERAL VS RESOURCE/CONTEXT
if (right is RDFResource || right is RDFContext)
{
//"XSD:ANYURI" TYPED LITERAL VS RESOURCE/CONTEXT
if (left is RDFTypedLiteral && ((RDFTypedLiteral)left).Datatype.Equals(RDFModelEnums.RDFDatatype.XSD_ANYURI))
{
return(String.Compare(((RDFTypedLiteral)left).Value, right.ToString(), StringComparison.Ordinal));
}
//TYPED LITERAL VS RESOURCE/CONTEXT
return(1);
}
//TYPED LITERAL VS PLAIN LITERAL
if (right is RDFPlainLiteral)
{
//"RDFS:LITERAL" OR "XSD:STRING" TYPED LITERAL VS PLAIN LITERAL
if (((RDFTypedLiteral)left).Datatype.Equals(RDFModelEnums.RDFDatatype.RDFS_LITERAL) ||
((RDFTypedLiteral)left).Datatype.Equals(RDFModelEnums.RDFDatatype.XSD_STRING))
{
return(String.Compare(((RDFTypedLiteral)left).Value, right.ToString(), StringComparison.Ordinal));
}
//TYPED LITERAL VS PLAIN LITERAL
return(1);
}
//TYPED LITERAL VS TYPED LITERAL
//Detect left typed literal's category
RDFModelEnums.RDFDatatype leftDType = ((RDFTypedLiteral)left).Datatype;
Boolean isLeftDTypeBoolean = leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_BOOLEAN);
Boolean isLeftDTypeNumeric = leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_BYTE) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_DECIMAL) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_DOUBLE) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_FLOAT) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_INT) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_INTEGER) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_LONG) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_NEGATIVEINTEGER) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_NONNEGATIVEINTEGER) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_NONPOSITIVEINTEGER) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_POSITIVEINTEGER) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_SHORT) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_UNSIGNEDBYTE) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_UNSIGNEDINT) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_UNSIGNEDLONG) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_UNSIGNEDSHORT);
Boolean isLeftDTypeDateTime = leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_DATE) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_DATETIME) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_GDAY) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_GMONTH) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_GMONTHDAY) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_GYEAR) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_GYEARMONTH) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_TIME);
Boolean isLeftDTypeTimeSpan = leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_DURATION);
Boolean isLeftDTypeString = leftDType.Equals(RDFModelEnums.RDFDatatype.RDFS_LITERAL) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.RDF_XMLLITERAL) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_ANYURI) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_BASE64BINARY) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_HEXBINARY) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_LANGUAGE) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_NAME) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_NCNAME) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_NMTOKEN) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_NORMALIZEDSTRING) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_NOTATION) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_QNAME) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_STRING) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_TOKEN);
//Detect right typed literal's category
RDFModelEnums.RDFDatatype rightDType = ((RDFTypedLiteral)right).Datatype;
Boolean isRightDTypeBoolean = rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_BOOLEAN);
Boolean isRightDTypeNumeric = rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_BYTE) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_DECIMAL) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_DOUBLE) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_FLOAT) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_INT) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_INTEGER) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_LONG) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_NEGATIVEINTEGER) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_NONNEGATIVEINTEGER) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_NONPOSITIVEINTEGER) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_POSITIVEINTEGER) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_SHORT) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_UNSIGNEDBYTE) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_UNSIGNEDINT) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_UNSIGNEDLONG) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_UNSIGNEDSHORT);
Boolean isRightDTypeDateTime = rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_DATE) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_DATETIME) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_GDAY) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_GMONTH) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_GMONTHDAY) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_GYEAR) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_GYEARMONTH) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_TIME);
Boolean isRightDTypeTimeSpan = rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_DURATION);
Boolean isRightDTypeString = rightDType.Equals(RDFModelEnums.RDFDatatype.RDFS_LITERAL) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.RDF_XMLLITERAL) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_ANYURI) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_BASE64BINARY) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_HEXBINARY) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_LANGUAGE) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_NAME) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_NCNAME) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_NMTOKEN) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_NORMALIZEDSTRING) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_NOTATION) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_QNAME) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_STRING) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_TOKEN);
//Compare typed literals, only if categories are semantically compatible
if (isLeftDTypeBoolean && isRightDTypeBoolean)
{
Boolean leftValueBoolean = Boolean.Parse(((RDFTypedLiteral)left).Value);
Boolean rightValueBoolean = Boolean.Parse(((RDFTypedLiteral)right).Value);
return(leftValueBoolean.CompareTo(rightValueBoolean));
}
else if (isLeftDTypeDateTime && isRightDTypeDateTime)
{
DateTime leftValueDateTime = DateTime.Parse(((RDFTypedLiteral)left).Value, CultureInfo.InvariantCulture);
DateTime rightValueDateTime = DateTime.Parse(((RDFTypedLiteral)right).Value, CultureInfo.InvariantCulture);
return(leftValueDateTime.CompareTo(rightValueDateTime));
}
else if (isLeftDTypeNumeric && isRightDTypeNumeric)
{
Decimal leftValueDecimal = Decimal.Parse(((RDFTypedLiteral)left).Value, CultureInfo.InvariantCulture);
Decimal rightValueDecimal = Decimal.Parse(((RDFTypedLiteral)right).Value, CultureInfo.InvariantCulture);
return(leftValueDecimal.CompareTo(rightValueDecimal));
}
else if (isLeftDTypeString && isRightDTypeString)
{
String leftValueString = ((RDFTypedLiteral)left).Value;
String rightValueString = ((RDFTypedLiteral)right).Value;
return(leftValueString.CompareTo(rightValueString));
}
else if (isLeftDTypeTimeSpan && isRightDTypeTimeSpan)
{
TimeSpan leftValueDuration = XmlConvert.ToTimeSpan(((RDFTypedLiteral)left).Value);
TimeSpan rightValueDuration = XmlConvert.ToTimeSpan(((RDFTypedLiteral)right).Value);
return(leftValueDuration.CompareTo(rightValueDuration));
}
else
{
throw new RDFQueryException("Type Error: Typed Literal of datatype (" + RDFModelUtilities.GetDatatypeFromEnum(leftDType) + ") cannot be compared to Typed Literal of datatype (" + RDFModelUtilities.GetDatatypeFromEnum(rightDType) + ")");
}
#endregion
#endregion
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//sh:datatype
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.DATATYPE, new RDFResource(RDFModelUtilities.GetDatatypeFromEnum(this.Datatype))));
}
return(result);
}
internal override String ToString(List <RDFNamespace> prefixes)
{
return("FILTER ( DATATYPE(" + this.Variable + ") = " + RDFQueryUtilities.PrintRDFPatternMember(RDFQueryUtilities.ParseRDFPatternMember(RDFModelUtilities.GetDatatypeFromEnum(this.Datatype)), prefixes) + " )");
}
/// <summary> /// Gives the string representation of the typed literal /// </summary> public override string ToString() => string.Concat(base.ToString(), "^^", RDFModelUtilities.GetDatatypeFromEnum(this.Datatype));
/// <summary>
/// Default-ctor to build a typed literal with given value and given datatype.
/// Semantic validation of given value against given datatype is performed.
/// </summary>
public RDFTypedLiteral(string value, RDFModelEnums.RDFDatatypes datatype)
{
this.Value = value ?? string.Empty;
this.Datatype = datatype;
//Validation against semantic of given datatype
if (RDFModelUtilities.ValidateTypedLiteral(this))
{
this.SetLazyPatternMemberID();
}
else
{
throw new RDFModelException("Cannot create RDFTypedLiteral because given \"value\" parameter (" + value + ") is not well-formed against given \"datatype\" parameter (" + RDFModelUtilities.GetDatatypeFromEnum(datatype) + ")");
}
}
/// <summary>
/// Gives the string representation of the typed literal
/// </summary>
public override String ToString()
{
return(base.ToString() + "^^" + RDFModelUtilities.GetDatatypeFromEnum(this.Datatype));
}
/// <summary>
/// Default-ctor to build a typed literal with given value and given datatype.
/// Semantic validation of given value against given datatype is performed.
/// </summary>
public RDFTypedLiteral(String value, RDFModelEnums.RDFDatatypes datatype)
{
this.Value = (value ?? String.Empty);
this.Datatype = datatype;
if (RDFModelUtilities.ValidateTypedLiteral(this))
{
this.PatternMemberID = RDFModelUtilities.CreateHash(this.ToString());
}
else
{
throw new RDFModelException("Cannot create RDFTypedLiteral because given \"value\" parameter (" + value + ") is not well-formed against given \"datatype\" parameter (" + RDFModelUtilities.GetDatatypeFromEnum(datatype) + ")");
}
}
/// <summary>
/// Serializes the given graph to the given stream using XML data format.
/// </summary>
internal static void Serialize(RDFGraph graph, Stream outputStream)
{
try {
#region serialize
using (XmlTextWriter rdfxmlWriter = new XmlTextWriter(outputStream, Encoding.UTF8)) {
XmlDocument rdfDoc = new XmlDocument();
rdfxmlWriter.Formatting = Formatting.Indented;
#region xmlDecl
XmlDeclaration xmlDecl = rdfDoc.CreateXmlDeclaration("1.0", "UTF-8", null);
rdfDoc.AppendChild(xmlDecl);
#endregion
#region rdfRoot
XmlNode rdfRoot = rdfDoc.CreateNode(XmlNodeType.Element, RDFVocabulary.RDF.PREFIX + ":RDF", RDFVocabulary.RDF.BASE_URI);
XmlAttribute rdfRootNS = rdfDoc.CreateAttribute("xmlns:" + RDFVocabulary.RDF.PREFIX);
XmlText rdfRootNSText = rdfDoc.CreateTextNode(RDFVocabulary.RDF.BASE_URI);
rdfRootNS.AppendChild(rdfRootNSText);
rdfRoot.Attributes.Append(rdfRootNS);
#region prefixes
//Write the graph's prefixes (except for "rdf", which has already been written)
graph.GraphMetadata.Namespaces.ForEach(p => {
if (!p.Prefix.Equals(RDFVocabulary.RDF.PREFIX, StringComparison.Ordinal) && !p.Prefix.Equals("base", StringComparison.Ordinal))
{
XmlAttribute pfRootNS = rdfDoc.CreateAttribute("xmlns:" + p.Prefix);
XmlText pfRootNSText = rdfDoc.CreateTextNode(p.ToString());
pfRootNS.AppendChild(pfRootNSText);
rdfRoot.Attributes.Append(pfRootNS);
}
});
//Write the graph's base uri to resolve eventual relative #IDs
XmlAttribute pfBaseNS = rdfDoc.CreateAttribute(RDFVocabulary.XML.PREFIX + ":base");
XmlText pfBaseNSText = rdfDoc.CreateTextNode(graph.Context.ToString());
pfBaseNS.AppendChild(pfBaseNSText);
rdfRoot.Attributes.Append(pfBaseNS);
#endregion
#region linq
//Group the graph's triples by subj
var groupedList = (from triple in graph
orderby triple.Subject.ToString()
group triple by new {
subj = triple.Subject.ToString()
});
#endregion
#region graph
//Iterate over the calculated groups
Dictionary <RDFResource, XmlNode> containers = new Dictionary <RDFResource, XmlNode>();
//Floating containers have reification subject which is never object of any graph's triple
Boolean floatingContainers = graph.GraphMetadata.Containers.Keys.Any(k =>
graph.Triples.Values.Count(v => v.Object.Equals(k)) == 0);
//Floating collections have reification subject which is never object of any graph's triple
Boolean floatingCollections = graph.GraphMetadata.Collections.Keys.Any(k =>
graph.Triples.Values.Count(v => v.Object.Equals(k)) == 0);
foreach (var group in groupedList)
{
#region subj
//Check if the current subj is a container or a collection subj: if so it must be
//serialized in the canonical RDF/XML way instead of the "rdf:Description" way
XmlNode subjNode = null;
String subj = group.Key.subj;
//It is a container subj, so add it to the containers pool
if (graph.GraphMetadata.Containers.Keys.Any(k => k.ToString().Equals(subj, StringComparison.Ordinal)) && !floatingContainers)
{
switch (graph.GraphMetadata.Containers.Single(c => c.Key.ToString().Equals(subj, StringComparison.Ordinal)).Value)
{
case RDFModelEnums.RDFContainerType.Bag:
subjNode = rdfDoc.CreateNode(XmlNodeType.Element, RDFVocabulary.RDF.PREFIX + ":Bag", RDFVocabulary.RDF.BASE_URI);
containers.Add(new RDFResource(subj), subjNode);
break;
case RDFModelEnums.RDFContainerType.Seq:
subjNode = rdfDoc.CreateNode(XmlNodeType.Element, RDFVocabulary.RDF.PREFIX + ":Seq", RDFVocabulary.RDF.BASE_URI);
containers.Add(new RDFResource(subj), subjNode);
break;
case RDFModelEnums.RDFContainerType.Alt:
subjNode = rdfDoc.CreateNode(XmlNodeType.Element, RDFVocabulary.RDF.PREFIX + ":Alt", RDFVocabulary.RDF.BASE_URI);
containers.Add(new RDFResource(subj), subjNode);
break;
}
}
//It is a subj of a collection of resources, so do not append triples having it as a subject
//because we will reconstruct the collection and append it as a whole
else if (graph.GraphMetadata.Collections.Keys.Any(k => k.ToString().Equals(subj, StringComparison.Ordinal)) &&
graph.GraphMetadata.Collections.Single(c => c.Key.ToString().Equals(subj, StringComparison.Ordinal)).Value.ItemType == RDFModelEnums.RDFItemType.Resource &&
!floatingCollections)
{
continue;
}
//It is neither a container or a collection subj
else
{
subjNode = rdfDoc.CreateNode(XmlNodeType.Element, RDFVocabulary.RDF.PREFIX + ":Description", RDFVocabulary.RDF.BASE_URI);
//<rdf:Description rdf:nodeID="blankID">
XmlAttribute subjNodeDesc = null;
XmlText subjNodeDescText = rdfDoc.CreateTextNode(group.Key.subj);
if (group.Key.subj.StartsWith("bnode:"))
{
subjNodeDescText.InnerText = subjNodeDescText.InnerText.Replace("bnode:", String.Empty);
subjNodeDesc = rdfDoc.CreateAttribute(RDFVocabulary.RDF.PREFIX + ":nodeID", RDFVocabulary.RDF.BASE_URI);
}
//<rdf:Description rdf:about="subjURI">
else
{
subjNodeDesc = rdfDoc.CreateAttribute(RDFVocabulary.RDF.PREFIX + ":about", RDFVocabulary.RDF.BASE_URI);
}
subjNodeDesc.AppendChild(subjNodeDescText);
subjNode.Attributes.Append(subjNodeDesc);
}
#endregion
#region predObjList
//Iterate over the triples of the current group
foreach (var triple in group)
{
//Do not append the triple if it is "SUBJECT rdf:type rdf:[Bag|Seq|Alt]"
if (!(triple.Predicate.Equals(RDFVocabulary.RDF.TYPE) &&
(subjNode.Name.Equals(RDFVocabulary.RDF.PREFIX + ":Bag", StringComparison.Ordinal) ||
subjNode.Name.Equals(RDFVocabulary.RDF.PREFIX + ":Seq", StringComparison.Ordinal) ||
subjNode.Name.Equals(RDFVocabulary.RDF.PREFIX + ":Alt", StringComparison.Ordinal))))
{
#region pred
String predString = triple.Predicate.ToString();
//"<predPREF:predURI"
RDFNamespace predNS =
(RDFNamespaceRegister.GetByNamespace(predString) ??
RDFModelUtilities.GenerateNamespace(predString, false));
//Refine the pred with eventually necessary sanitizations
String predUri = predString.Replace(predNS.ToString(), predNS.Prefix + ":")
.Replace(":#", ":")
.TrimEnd(new Char[] { ':', '/' });
//Sanitize eventually detected automatic namespace
if (predUri.StartsWith("autoNS:"))
{
predUri = predUri.Replace("autoNS:", string.Empty);
}
//Do not write "xmlns" attribute if the predUri is the context of the graph
XmlNode predNode = null;
if (predNS.ToString().Equals(graph.Context.ToString(), StringComparison.Ordinal))
{
predNode = rdfDoc.CreateNode(XmlNodeType.Element, predUri, null);
}
else
{
predNode = rdfDoc.CreateNode(XmlNodeType.Element, predUri, predNS.ToString());
}
#endregion
#region object
if (triple.TripleFlavor == RDFModelEnums.RDFTripleFlavor.SPO)
{
//If the object is a container subj, we must append its entire node saved in the containers dictionary
if (containers.Keys.Any(k => k.Equals(triple.Object)) && !floatingContainers)
{
predNode.AppendChild(containers.Single(c => c.Key.Equals(triple.Object)).Value);
}
//Else, if the object is a subject of a collection of resources, we must append the "rdf:parseType=Collection" attribute to the predicate node
else if (graph.GraphMetadata.Collections.Keys.Any(k => k.Equals(triple.Object)) &&
graph.GraphMetadata.Collections.Single(c => c.Key.Equals(triple.Object)).Value.ItemType == RDFModelEnums.RDFItemType.Resource &&
!floatingCollections)
{
XmlAttribute rdfParseType = rdfDoc.CreateAttribute(RDFVocabulary.RDF.PREFIX + ":parseType", RDFVocabulary.RDF.BASE_URI);
XmlText rdfParseTypeText = rdfDoc.CreateTextNode("Collection");
rdfParseType.AppendChild(rdfParseTypeText);
predNode.Attributes.Append(rdfParseType);
//Then we append sequentially the collection elements
List <XmlNode> collElements = ReconstructCollection(graph.GraphMetadata, (RDFResource)triple.Object, rdfDoc);
collElements.ForEach(c => predNode.AppendChild(c));
}
//Else, threat it as a traditional object node
else
{
String objString = triple.Object.ToString();
XmlAttribute predNodeDesc = null;
XmlText predNodeDescText = rdfDoc.CreateTextNode(objString);
// rdf:nodeID="blankID">
if (objString.StartsWith("bnode:"))
{
predNodeDescText.InnerText = predNodeDescText.InnerText.Replace("bnode:", String.Empty);
predNodeDesc = rdfDoc.CreateAttribute(RDFVocabulary.RDF.PREFIX + ":nodeID", RDFVocabulary.RDF.BASE_URI);
}
// rdf:resource="objURI">
else
{
predNodeDesc = rdfDoc.CreateAttribute(RDFVocabulary.RDF.PREFIX + ":resource", RDFVocabulary.RDF.BASE_URI);
}
predNodeDesc.AppendChild(predNodeDescText);
predNode.Attributes.Append(predNodeDesc);
}
}
#endregion
#region literal
else
{
#region plain literal
if (triple.Object is RDFPlainLiteral)
{
RDFPlainLiteral pLit = (RDFPlainLiteral)triple.Object;
// xml:lang="plitLANG">
if (pLit.Language != String.Empty)
{
XmlAttribute plainLiteralLangNodeDesc = rdfDoc.CreateAttribute(RDFVocabulary.XML.PREFIX + ":lang", RDFVocabulary.XML.BASE_URI);
XmlText plainLiteralLangNodeDescText = rdfDoc.CreateTextNode(pLit.Language);
plainLiteralLangNodeDesc.AppendChild(plainLiteralLangNodeDescText);
predNode.Attributes.Append(plainLiteralLangNodeDesc);
}
}
#endregion
#region typed literal
// rdf:datatype="tlitURI">
else
{
RDFTypedLiteral tLit = (RDFTypedLiteral)triple.Object;
XmlAttribute typedLiteralNodeDesc = rdfDoc.CreateAttribute(RDFVocabulary.RDF.PREFIX + ":datatype", RDFVocabulary.RDF.BASE_URI);
XmlText typedLiteralNodeDescText = rdfDoc.CreateTextNode(RDFModelUtilities.GetDatatypeFromEnum(tLit.Datatype));
typedLiteralNodeDesc.AppendChild(typedLiteralNodeDescText);
predNode.Attributes.Append(typedLiteralNodeDesc);
}
#endregion
//litVALUE</predPREF:predURI>"
XmlText litNodeDescText = rdfDoc.CreateTextNode(((RDFLiteral)triple.Object).Value);
predNode.AppendChild(litNodeDescText);
}
#endregion
subjNode.AppendChild(predNode);
}
}
//Raw containers must not be written as-is, instead they have to be saved
//and attached when their subj is found later as object of a triple
if (!subjNode.Name.Equals(RDFVocabulary.RDF.PREFIX + ":Bag", StringComparison.Ordinal) &&
!subjNode.Name.Equals(RDFVocabulary.RDF.PREFIX + ":Seq", StringComparison.Ordinal) &&
!subjNode.Name.Equals(RDFVocabulary.RDF.PREFIX + ":Alt", StringComparison.Ordinal))
{
rdfRoot.AppendChild(subjNode);
}
#endregion
}
#endregion
rdfDoc.AppendChild(rdfRoot);
#endregion
rdfDoc.Save(rdfxmlWriter);
}
#endregion
}
catch (Exception ex) {
throw new RDFModelException("Cannot serialize Xml because: " + ex.Message, ex);
}
}
/// <summary>
/// Prints the string representation of a pattern member
/// </summary>
internal static String PrintPatternMember(RDFPatternMember patternMember, List <RDFNamespace> prefixes)
{
if (patternMember != null)
{
#region Variable
if (patternMember is RDFVariable)
{
return(patternMember.ToString());
}
#endregion
#region Resource/Context
if (patternMember is RDFResource || patternMember is RDFContext)
{
#region Blank
if (patternMember is RDFResource && ((RDFResource)patternMember).IsBlank)
{
return(patternMember.ToString().Replace("bnode:", "_:"));
}
#endregion
#region NonBlank
var abbreviatedPM = RDFQueryUtilities.AbbreviateRDFPatternMember(patternMember, prefixes);
if (abbreviatedPM.Item1)
{
return(abbreviatedPM.Item2);
}
else
{
return("<" + abbreviatedPM.Item2 + ">");
}
#endregion
}
#endregion
#region Literal
if (patternMember is RDFLiteral)
{
#region PlainLiteral
if (patternMember is RDFPlainLiteral)
{
if (((RDFPlainLiteral)patternMember).Language != String.Empty)
{
return("\"" + ((RDFPlainLiteral)patternMember).Value + "\"@" + ((RDFPlainLiteral)patternMember).Language);
}
return("\"" + ((RDFPlainLiteral)patternMember).Value + "\"");
}
#endregion
#region TypedLiteral
else
{
var abbreviatedPM = RDFQueryUtilities.AbbreviateRDFPatternMember(RDFQueryUtilities.ParseRDFPatternMember(RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)patternMember).Datatype)), prefixes);
if (abbreviatedPM.Item1)
{
return("\"" + ((RDFTypedLiteral)patternMember).Value + "\"^^" + abbreviatedPM.Item2);
}
else
{
return("\"" + ((RDFTypedLiteral)patternMember).Value + "\"^^<" + abbreviatedPM.Item2 + ">");
}
}
#endregion
}
#endregion
}
return(null);
}
/// <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 graph to the given stream using Turtle data format.
/// </summary>
internal static void Serialize(RDFGraph graph, Stream outputStream)
{
try {
#region serialize
using (StreamWriter sw = new StreamWriter(outputStream, Encoding.UTF8)) {
#region prefixes
//Write the namespaces collected by the graph
foreach (var ns in graph.GraphMetadata.Namespaces.OrderBy(n => n.Prefix))
{
sw.WriteLine("@prefix " + ns.Prefix + ": <" + ns.Namespace + ">.");
}
sw.WriteLine("@base <" + graph.Context + ">.\n");
#endregion
#region linq
//Group the graph's triples by subj and pred
var groupedList = (from triple in graph
orderby triple.Subject.ToString(), triple.Predicate.ToString()
group triple by new {
subj = triple.Subject.ToString(),
pred = triple.Predicate.ToString()
});
var groupedListLast = groupedList.Last();
#endregion
#region triples
String actualSubj = String.Empty;
String abbreviatedSubj = String.Empty;
String actualPred = String.Empty;
String abbreviatedPred = String.Empty;
const String spaceConst = " ";
StringBuilder result = new StringBuilder();
//Iterate over the calculated groups
foreach (var group in groupedList)
{
var groupLast = group.Last();
//Reset the flag of subj printing for the new iteration
Boolean subjPrint = false;
#region subj
//New subj found: write the finished Turtle token to the file, then start collecting the new one
if (!actualSubj.Equals(group.Key.subj, StringComparison.Ordinal))
{
if (result.Length > 0)
{
result.Replace(";", ".", result.Length - 4, 1);
sw.Write(result.ToString());
result.Remove(0, result.Length - 1);
}
actualSubj = group.Key.subj;
actualPred = String.Empty;
if (!actualSubj.StartsWith("_:"))
{
abbreviatedSubj = RDFModelUtilities.AbbreviateNamespace(actualSubj);
}
else
{
abbreviatedSubj = actualSubj;
}
result.Append(abbreviatedSubj + " ");
subjPrint = true;
}
#endregion
#region predObjList
//Iterate over the triples of the current group
foreach (var triple in group)
{
#region pred
//New pred found: collect it to the actual Turtle token.
if (!actualPred.Equals(triple.Predicate.ToString(), StringComparison.Ordinal))
{
if (!subjPrint)
{
result.Append(spaceConst.PadRight(abbreviatedSubj.Length + 1)); //pretty-printing spaces to align the predList
}
actualPred = triple.Predicate.ToString();
abbreviatedPred = RDFModelUtilities.AbbreviateNamespace(actualPred);
//Turtle goody for "rdf:type" shortcutting to "a"
if (abbreviatedPred == RDFVocabulary.RDF.PREFIX + ":type")
{
abbreviatedPred = "a";
}
result.Append(abbreviatedPred + " ");
}
#endregion
#region object
//Collect the object or the literal to the Turtle token
if (triple.TripleFlavor == RDFModelEnums.RDFTripleFlavor.SPO)
{
String obj = triple.Object.ToString();
if (!obj.StartsWith("_:"))
{
result.Append(RDFModelUtilities.AbbreviateNamespace(obj));
}
else
{
result.Append(obj);
}
}
#endregion
#region literal
else
{
//Detect presence of long-literals
var litValDelim = "\"";
if (regexTTL.Match(triple.Object.ToString()).Success)
{
litValDelim = "\"\"\"";
}
if (triple.Object is RDFTypedLiteral)
{
String tLit = litValDelim + ((RDFTypedLiteral)triple.Object).Value.Replace("\"", "\\\"") + litValDelim + "^^" + RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)triple.Object).Datatype);
result.Append(RDFModelUtilities.AbbreviateNamespace(tLit));
}
else
{
String pLit = litValDelim + ((RDFPlainLiteral)triple.Object).Value.Replace("\"", "\\\"") + litValDelim;
if (((RDFPlainLiteral)triple.Object).Language != String.Empty)
{
pLit = pLit + "@" + ((RDFPlainLiteral)triple.Object).Language;
}
result.Append(pLit);
}
}
#endregion
#region continuation goody
//Then append the appropriated Turtle continuation goody ("," or ";")
if (!triple.Equals(groupLast))
{
result.Append(", ");
}
else
{
result.AppendLine("; ");
}
#endregion
}
#endregion
#region last group
//This is only for the last group, which is not written into the cycle as the others
if (group.Key.Equals(groupedListLast.Key))
{
result.Replace(";", ".", result.Length - 4, 1);
sw.Write(result.ToString());
}
#endregion
}
#endregion
}
#endregion
}
catch (Exception ex) {
throw new RDFModelException("Cannot serialize Turtle because: " + ex.Message, ex);
}
}
/// <summary>
/// Gives the string representation of the filter
/// </summary>
public override String ToString()
{
return("FILTER ( DATATYPE(" + this.Variable + ") = <" + RDFModelUtilities.GetDatatypeFromEnum(this.Datatype) + "> )");
}
internal override string ToString(List <RDFNamespace> prefixes)
=> string.Concat(
"FILTER ( DATATYPE(", this.Variable, ") = ",
RDFQueryPrinter.PrintPatternMember(RDFQueryUtilities.ParseRDFPatternMember(RDFModelUtilities.GetDatatypeFromEnum(this.Datatype)), prefixes), " )");
