/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//sh:closed
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.CLOSED, new RDFTypedLiteral(this.Closed.ToString(), RDFModelEnums.RDFDatatypes.XSD_BOOLEAN)));
//Get collection from ignored properties
RDFCollection ignoredProperties = new RDFCollection(RDFModelEnums.RDFItemTypes.Resource)
{
InternalReificationSubject = this
};
foreach (RDFResource ignoredProperty in this.IgnoredProperties.Values)
{
ignoredProperties.AddItem(ignoredProperty);
}
result.AddCollection(ignoredProperties);
//sh:ignoredProperties
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.IGNORED_PROPERTIES, ignoredProperties.ReificationSubject));
}
return(result);
}
/// <summary>
/// Gets a graph representation of this shape
/// </summary>
public virtual RDFGraph ToRDFGraph()
{
var result = new RDFGraph();
//Severity
switch (this.Severity)
{
case RDFValidationEnums.RDFShapeSeverity.Info:
result.AddTriple(new RDFTriple(this, RDFVocabulary.SHACL.SEVERITY_PROPERTY, RDFVocabulary.SHACL.INFO));
break;
case RDFValidationEnums.RDFShapeSeverity.Warning:
result.AddTriple(new RDFTriple(this, RDFVocabulary.SHACL.SEVERITY_PROPERTY, RDFVocabulary.SHACL.WARNING));
break;
case RDFValidationEnums.RDFShapeSeverity.Violation:
result.AddTriple(new RDFTriple(this, RDFVocabulary.SHACL.SEVERITY_PROPERTY, RDFVocabulary.SHACL.VIOLATION));
break;
}
//Deactivated
result.AddTriple(new RDFTriple(this, RDFVocabulary.SHACL.DEACTIVATED, this.Deactivated ? RDFTypedLiteral.True : RDFTypedLiteral.False));
//Messages
this.Messages.ForEach(message => result.AddTriple(new RDFTriple(this, RDFVocabulary.SHACL.MESSAGE, message)));
//Targets
this.Targets.ForEach(target => result = result.UnionWith(target.ToRDFGraph(this)));
//Constraints
this.Constraints.ForEach(constraint => result = result.UnionWith(constraint.ToRDFGraph(this)));
result.SetContext(this.URI);
return(result);
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//sh:pattern
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.PATTERN, new RDFTypedLiteral(this.RegEx.ToString(), RDFModelEnums.RDFDatatypes.XSD_STRING)));
//sh:flags
StringBuilder regexFlags = new StringBuilder();
if (this.RegEx.Options.HasFlag(RegexOptions.IgnoreCase))
{
regexFlags.Append("i");
}
if (this.RegEx.Options.HasFlag(RegexOptions.Singleline))
{
regexFlags.Append("s");
}
if (this.RegEx.Options.HasFlag(RegexOptions.Multiline))
{
regexFlags.Append("m");
}
if (this.RegEx.Options.HasFlag(RegexOptions.IgnorePatternWhitespace))
{
regexFlags.Append("x");
}
if (regexFlags.ToString() != string.Empty)
{
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.FLAGS, new RDFTypedLiteral(regexFlags.ToString(), RDFModelEnums.RDFDatatypes.XSD_STRING)));
}
}
return(result);
}
/// <summary>
/// Gets a graph representation of this validation report
/// </summary>
public RDFGraph ToRDFGraph()
{
var result = new RDFGraph();
//ValidationReport
result.AddTriple(new RDFTriple(this, RDFVocabulary.RDF.TYPE, RDFVocabulary.SHACL.VALIDATION_REPORT));
//Conforms
if (this.Conforms)
{
result.AddTriple(new RDFTriple(this, RDFVocabulary.SHACL.CONFORMS, new RDFTypedLiteral("true", RDFModelEnums.RDFDatatypes.XSD_BOOLEAN)));
}
else
{
result.AddTriple(new RDFTriple(this, RDFVocabulary.SHACL.CONFORMS, new RDFTypedLiteral("false", RDFModelEnums.RDFDatatypes.XSD_BOOLEAN)));
}
//Results
this.Results.ForEach(res => {
result.AddTriple(new RDFTriple(this, RDFVocabulary.SHACL.RESULT, res));
result = result.UnionWith(res.ToRDFGraph());
});
result.SetContext(this.URI);
return(result);
}
/// <summary>
/// Gets a graph representation of this validation report
/// </summary>
public RDFGraph ToRDFGraph()
{
RDFGraph result = new RDFGraph();
//ValidationReport
result.AddTriple(new RDFTriple(this, RDFVocabulary.RDF.TYPE, RDFVocabulary.SHACL.VALIDATION_REPORT));
//Conforms
if (this.Conforms)
{
result.AddTriple(new RDFTriple(this, RDFVocabulary.SHACL.CONFORMS, RDFTypedLiteral.True));
}
else
{
result.AddTriple(new RDFTriple(this, RDFVocabulary.SHACL.CONFORMS, RDFTypedLiteral.False));
}
//Results
this.Results.ForEach(res =>
{
result.AddTriple(new RDFTriple(this, RDFVocabulary.SHACL.RESULT, res));
result = result.UnionWith(res.ToRDFGraph());
});
result.SetContext(this.URI);
return(result);
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null) {
//sh:hasValue
if (this.Value is RDFResource)
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.HAS_VALUE, (RDFResource)this.Value));
else
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.HAS_VALUE, (RDFLiteral)this.Value));
}
return result;
}
/// <summary>
/// Given an attribute representing a RDF collection, iterates on its constituent elements
/// to build its standard reification triples.
/// </summary>
internal static void ParseCollectionElements(Uri xmlBase, XmlNode predNode, RDFResource subj,
RDFResource pred, RDFGraph result)
{
//Attach the collection as the blank object of the current pred
RDFResource obj = new RDFResource();
result.AddTriple(new RDFTriple(subj, pred, obj));
//Iterate on the collection items to reify it
if (predNode.HasChildNodes)
{
IEnumerator elems = predNode.ChildNodes.GetEnumerator();
while (elems != null && elems.MoveNext())
{
XmlNode elem = (XmlNode)elems.Current;
//Try to get items as "rdf:about" attributes, or as "rdf:resource"
XmlAttribute elemUri =
(GetRdfAboutAttribute(elem) ??
GetRdfResourceAttribute(elem));
if (elemUri != null)
{
//Sanitize eventual blank node or relative value, depending on attribute found
elemUri.Value = ResolveRelativeNode(elemUri, xmlBase);
// obj -> rdf:type -> rdf:list
result.AddTriple(new RDFTriple(obj, RDFVocabulary.RDF.TYPE, RDFVocabulary.RDF.LIST));
// obj -> rdf:first -> res
result.AddTriple(new RDFTriple(obj, RDFVocabulary.RDF.FIRST, new RDFResource(elemUri.Value)));
//Last element of a collection must give a triple to a "rdf:nil" object
RDFResource newObj;
if (elem != predNode.ChildNodes.Item(predNode.ChildNodes.Count - 1))
{
// obj -> rdf:rest -> newObj
newObj = new RDFResource();
}
else
{
// obj -> rdf:rest -> rdf:nil
newObj = RDFVocabulary.RDF.NIL;
}
result.AddTriple(new RDFTriple(obj, RDFVocabulary.RDF.REST, newObj));
obj = newObj;
}
}
}
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//Get collection from inValues
RDFCollection inValues = new RDFCollection(this.ItemType)
{
InternalReificationSubject = this
};
foreach (RDFPatternMember inValue in this.InValues.Values)
{
if (this.ItemType == RDFModelEnums.RDFItemTypes.Literal)
{
inValues.AddItem((RDFLiteral)inValue);
}
else
{
inValues.AddItem((RDFResource)inValue);
}
}
result.AddCollection(inValues);
//sh:in
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.IN, inValues.ReificationSubject));
}
return(result);
}
/// <summary>
/// Builds the reification graph of the collection
/// </summary>
public RDFGraph ReifyCollection()
{
RDFGraph reifColl = new RDFGraph();
RDFResource reifSubj = this.ReificationSubject;
Int32 itemCount = 0;
//Manage the empty collection
if (this.ItemsCount == 0)
{
// Subject -> rdf:type -> rdf:List
reifColl.AddTriple(new RDFTriple(reifSubj, RDFVocabulary.RDF.TYPE, RDFVocabulary.RDF.LIST));
// Subject -> rdf:first -> rdf:nil
reifColl.AddTriple(new RDFTriple(reifSubj, RDFVocabulary.RDF.FIRST, RDFVocabulary.RDF.NIL));
// Subject -> rdf:rest -> rdf:nil
reifColl.AddTriple(new RDFTriple(reifSubj, RDFVocabulary.RDF.REST, RDFVocabulary.RDF.NIL));
}
//Manage the non-empty collection
else
{
foreach (Object listEnum in this)
{
//Count the items to keep track of the last one, which will be connected to rdf:nil
itemCount++;
// Subject -> rdf:type -> rdf:List
reifColl.AddTriple(new RDFTriple(reifSubj, RDFVocabulary.RDF.TYPE, RDFVocabulary.RDF.LIST));
// Subject -> rdf:first -> RDFCollection.ITEM[i]
if (this.ItemType == RDFModelEnums.RDFItemTypes.Resource)
{
reifColl.AddTriple(new RDFTriple(reifSubj, RDFVocabulary.RDF.FIRST, (RDFResource)listEnum));
}
else
{
reifColl.AddTriple(new RDFTriple(reifSubj, RDFVocabulary.RDF.FIRST, (RDFLiteral)listEnum));
}
//Not the last one: Subject -> rdf:rest -> NEWBLANK
if (itemCount < this.ItemsCount)
{
RDFResource newSub = new RDFResource();
reifColl.AddTriple(new RDFTriple(reifSubj, RDFVocabulary.RDF.REST, newSub));
reifSubj = newSub;
}
//The last one: Subject -> rdf:rest -> rdf:nil
else
{
reifColl.AddTriple(new RDFTriple(reifSubj, RDFVocabulary.RDF.REST, RDFVocabulary.RDF.NIL));
}
}
}
return(reifColl);
}
/// <summary>
/// Builds the reification graph of the triple
/// </summary>
public RDFGraph ReifyTriple()
{
RDFGraph reifGraph = new RDFGraph();
reifGraph.AddTriple(new RDFTriple(this.ReificationSubject, RDFVocabulary.RDF.TYPE, RDFVocabulary.RDF.STATEMENT));
reifGraph.AddTriple(new RDFTriple(this.ReificationSubject, RDFVocabulary.RDF.SUBJECT, (RDFResource)this.Subject));
reifGraph.AddTriple(new RDFTriple(this.ReificationSubject, RDFVocabulary.RDF.PREDICATE, (RDFResource)this.Predicate));
if (this.TripleFlavor == RDFModelEnums.RDFTripleFlavor.SPO)
{
reifGraph.AddTriple(new RDFTriple(this.ReificationSubject, RDFVocabulary.RDF.OBJECT, (RDFResource)this.Object));
}
else
{
reifGraph.AddTriple(new RDFTriple(this.ReificationSubject, RDFVocabulary.RDF.OBJECT, (RDFLiteral)this.Object));
}
return(reifGraph);
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//sh:maxExclusive
if (this.Value is RDFResource)
{
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.MAX_EXCLUSIVE, (RDFResource)this.Value));
}
else
{
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.MAX_EXCLUSIVE, (RDFLiteral)this.Value));
}
}
return(result);
}
/// <summary>
/// Builds the reification graph of the container:
/// Subject -> rdf:type -> [rdf:Bag|rdf:Seq|rdf:Alt]
/// Subject -> rdf:_N -> RDFContainer.ITEM(N)
/// </summary>
public RDFGraph ReifyContainer()
{
RDFGraph reifCont = new RDFGraph();
// Subject -> rdf:type -> [rdf:Bag|rdf:Seq|rdf:Alt]
switch (this.ContainerType)
{
case RDFModelEnums.RDFContainerTypes.Bag:
reifCont.AddTriple(new RDFTriple(this.ReificationSubject, RDFVocabulary.RDF.TYPE, RDFVocabulary.RDF.BAG));
break;
case RDFModelEnums.RDFContainerTypes.Seq:
reifCont.AddTriple(new RDFTriple(this.ReificationSubject, RDFVocabulary.RDF.TYPE, RDFVocabulary.RDF.SEQ));
break;
case RDFModelEnums.RDFContainerTypes.Alt:
reifCont.AddTriple(new RDFTriple(this.ReificationSubject, RDFVocabulary.RDF.TYPE, RDFVocabulary.RDF.ALT));
break;
default:
throw new NotImplementedException();
break;
}
// Subject -> rdf:_N -> RDFContainer.ITEM(N)
Int32 index = 0;
foreach (Object item in this)
{
RDFResource ordPred = new RDFResource(RDFVocabulary.RDF.BASE_URI + "_" + (++index));
if (this.ItemType == RDFModelEnums.RDFItemTypes.Resource)
{
reifCont.AddTriple(new RDFTriple(this.ReificationSubject, ordPred, (RDFResource)item));
}
else
{
reifCont.AddTriple(new RDFTriple(this.ReificationSubject, ordPred, (RDFLiteral)item));
}
}
return(reifCont);
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//sh:equals
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.EQUALS, this.EqualsPredicate));
}
return(result);
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//sh:property
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.PROPERTY, this.PropertyShapeUri));
}
return(result);
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//sh:uniqueLang
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.UNIQUE_LANG, this.UniqueLang ? RDFTypedLiteral.True : RDFTypedLiteral.False));
}
return(result);
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//sh:maxCount
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.MAX_COUNT, new RDFTypedLiteral(this.MaxCount.ToString(), RDFModelEnums.RDFDatatypes.XSD_INTEGER)));
}
return(result);
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//sh:lessThan
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.LESS_THAN, this.LessThanPredicate));
}
return(result);
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//sh:class
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.CLASS, this.ClassType));
}
return(result);
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//sh:node
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.NODE, this.NodeShapeUri));
}
return(result);
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//sh:disjoint
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.DISJOINT, this.DisjointPredicate));
}
return(result);
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//sh:uniqueLang
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.UNIQUE_LANG, new RDFTypedLiteral(this.UniqueLang.ToString(), RDFModelEnums.RDFDatatypes.XSD_BOOLEAN)));
}
return(result);
}
/// <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);
}
/// <summary>
/// Builds the reification graph of the container:
/// Subject -> rdf:type -> [rdf:Bag|rdf:Seq|rdf:Alt]
/// Subject -> rdf:_N -> RDFContainer.ITEM(N)
/// </summary>
public RDFGraph ReifyContainer()
{
RDFGraph reifCont = new RDFGraph();
// Subject -> rdf:type -> [rdf:Bag|rdf:Seq|rdf:Alt]
switch (this.ContainerType)
{
case RDFModelEnums.RDFContainerTypes.Bag:
reifCont.AddTriple(new RDFTriple(this.ReificationSubject, RDFVocabulary.RDF.TYPE, RDFVocabulary.RDF.BAG));
break;
case RDFModelEnums.RDFContainerTypes.Seq:
reifCont.AddTriple(new RDFTriple(this.ReificationSubject, RDFVocabulary.RDF.TYPE, RDFVocabulary.RDF.SEQ));
break;
case RDFModelEnums.RDFContainerTypes.Alt:
reifCont.AddTriple(new RDFTriple(this.ReificationSubject, RDFVocabulary.RDF.TYPE, RDFVocabulary.RDF.ALT));
break;
}
// Subject -> rdf:_N -> RDFContainer.ITEM(N)
int index = 0;
foreach (object item in this)
{
RDFResource ordPred = new RDFResource(string.Concat(RDFVocabulary.RDF.BASE_URI, "_", (++index).ToString()));
if (this.ItemType == RDFModelEnums.RDFItemTypes.Resource)
{
reifCont.AddTriple(new RDFTriple(this.ReificationSubject, ordPred, (RDFResource)item));
}
else
{
reifCont.AddTriple(new RDFTriple(this.ReificationSubject, ordPred, (RDFLiteral)item));
}
}
return(reifCont);
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//sh:qualifiedValueShape
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.QUALIFIED_VALUE_SHAPE, this.QualifiedValueShapeUri));
//sh:qualifiedMinCount
if (this.QualifiedValueMinCount.HasValue)
{
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.QUALIFIED_MIN_COUNT, new RDFTypedLiteral(this.QualifiedValueMinCount.ToString(), RDFModelEnums.RDFDatatypes.XSD_INTEGER)));
}
//sh:qualifiedMaxCount
if (this.QualifiedValueMaxCount.HasValue)
{
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.QUALIFIED_MAX_COUNT, new RDFTypedLiteral(this.QualifiedValueMaxCount.ToString(), RDFModelEnums.RDFDatatypes.XSD_INTEGER)));
}
}
return(result);
}
/// <summary>
/// Gives the subj node extracted from the attribute list of the current element
/// </summary>
internal static RDFResource GetSubjectNode(XmlNode subjNode, Uri xmlBase, RDFGraph result)
{
RDFResource subj = null;
//If there are attributes, search them for the one representing the subj
if (subjNode.Attributes != null && subjNode.Attributes.Count > 0)
{
//We are interested in finding the "rdf:about" node for the subj
XmlAttribute rdfAbout = GetRdfAboutAttribute(subjNode);
if (rdfAbout != null)
{
//Attribute found, but we must check if it is "rdf:ID", "rdf:nodeID" or a relative Uri:
//in this case it must be resolved against the xmlBase namespace, or else it remains the same
String rdfAboutValue = ResolveRelativeNode(rdfAbout, xmlBase);
subj = new RDFResource(rdfAboutValue);
}
//If "rdf:about" attribute has been found for the subj, we must
//check if the node is not a standard "rdf:Description": this is
//the case we can directly build a triple with "rdf:type" pred
if (subj != null && !CheckIfRdfDescriptionNode(subjNode))
{
RDFResource obj = null;
if (subjNode.NamespaceURI == String.Empty)
{
obj = new RDFResource(xmlBase + subjNode.LocalName);
}
else
{
obj = new RDFResource(subjNode.NamespaceURI + subjNode.LocalName);
}
result.AddTriple(new RDFTriple(subj, RDFVocabulary.RDF.TYPE, obj));
}
}
//There are no attributes, so there's only one way we can handle this element:
//if it is a standard rdf:Description, it is a blank Subject
else
{
if (CheckIfRdfDescriptionNode(subjNode))
{
subj = new RDFResource();
}
}
return(subj);
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//Get collection from language tags
RDFCollection languageTags = new RDFCollection(RDFModelEnums.RDFItemTypes.Literal)
{
InternalReificationSubject = this
};
foreach (string languageTag in this.LanguageTags)
{
languageTags.AddItem(new RDFPlainLiteral(languageTag));
}
result.AddCollection(languageTags);
//sh:languageIn
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.LANGUAGE_IN, languageTags.ReificationSubject));
}
return(result);
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//Get collection from xoneShapes
RDFCollection xoneShapes = new RDFCollection(RDFModelEnums.RDFItemTypes.Resource)
{
InternalReificationSubject = this
};
foreach (RDFResource xoneShape in this.XoneShapes.Values)
{
xoneShapes.AddItem(xoneShape);
}
result.AddCollection(xoneShapes);
//sh:xone
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.XONE, xoneShapes.ReificationSubject));
}
return(result);
}
/// <summary>
/// Gets a graph representation of this constraint
/// </summary>
internal override RDFGraph ToRDFGraph(RDFShape shape)
{
RDFGraph result = new RDFGraph();
if (shape != null)
{
//sh:nodeKind
switch (this.NodeKind)
{
case RDFValidationEnums.RDFNodeKinds.BlankNode:
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.NODE_KIND, RDFVocabulary.SHACL.BLANK_NODE));
break;
case RDFValidationEnums.RDFNodeKinds.BlankNodeOrIRI:
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.NODE_KIND, RDFVocabulary.SHACL.BLANK_NODE_OR_IRI));
break;
case RDFValidationEnums.RDFNodeKinds.BlankNodeOrLiteral:
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.NODE_KIND, RDFVocabulary.SHACL.BLANK_NODE_OR_LITERAL));
break;
case RDFValidationEnums.RDFNodeKinds.IRI:
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.NODE_KIND, RDFVocabulary.SHACL.IRI));
break;
case RDFValidationEnums.RDFNodeKinds.IRIOrLiteral:
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.NODE_KIND, RDFVocabulary.SHACL.IRI_OR_LITERAL));
break;
case RDFValidationEnums.RDFNodeKinds.Literal:
result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.NODE_KIND, RDFVocabulary.SHACL.LITERAL));
break;
}
}
return(result);
}
/// <summary>
/// Deserializes the given N-Triples stream to a graph.
/// </summary>
internal static RDFGraph Deserialize(Stream inputStream)
{
Int64 ntripleIndex = 0;
try
{
#region deserialize
using (StreamReader sr = new StreamReader(inputStream, Encoding.ASCII))
{
RDFGraph result = new RDFGraph();
String ntriple = String.Empty;
String[] tokens = new String[3];
RDFResource S = null;
RDFResource P = null;
RDFResource O = null;
RDFLiteral L = null;
while ((ntriple = sr.ReadLine()) != null)
{
ntripleIndex++;
#region sanitize & tokenize
//Cleanup previous data
S = null;
tokens[0] = String.Empty;
P = null;
tokens[1] = String.Empty;
O = null;
L = null;
tokens[2] = String.Empty;
//Preliminary sanitizations: clean trailing space-like chars
ntriple = ntriple.Trim(new Char[] { ' ', '\t', '\r', '\n' });
//Skip empty or comment lines
if (ntriple == String.Empty || ntriple.StartsWith("#"))
{
continue;
}
//Tokenizes the sanitized triple
tokens = TokenizeNTriple(ntriple);
#endregion
#region subj
String subj = tokens[0].TrimStart(new Char[] { '<' })
.TrimEnd(new Char[] { '>' })
.Replace("_:", "bnode:");
S = new RDFResource(RDFModelUtilities.ASCII_To_Unicode(subj));
#endregion
#region pred
String pred = tokens[1].TrimStart(new Char[] { '<' })
.TrimEnd(new Char[] { '>' });
P = new RDFResource(RDFModelUtilities.ASCII_To_Unicode(pred));
#endregion
#region object
if (tokens[2].StartsWith("<") ||
tokens[2].StartsWith("bnode:") ||
tokens[2].StartsWith("_:"))
{
String obj = tokens[2].TrimStart(new Char[] { '<' })
.TrimEnd(new Char[] { '>' })
.Replace("_:", "bnode:")
.Trim(new Char[] { ' ', '\n', '\t', '\r' });
O = new RDFResource(RDFModelUtilities.ASCII_To_Unicode(obj));
}
#endregion
#region literal
else
{
#region sanitize
tokens[2] = regexSqt.Replace(tokens[2], String.Empty);
tokens[2] = regexEqt.Replace(tokens[2], String.Empty);
tokens[2] = tokens[2].Replace("\\\\", "\\")
.Replace("\\\"", "\"")
.Replace("\\n", "\n")
.Replace("\\t", "\t")
.Replace("\\r", "\r");
tokens[2] = RDFModelUtilities.ASCII_To_Unicode(tokens[2]);
#endregion
#region plain literal
if (!tokens[2].Contains("^^") ||
tokens[2].EndsWith("^^") ||
tokens[2].Substring(tokens[2].LastIndexOf("^^", StringComparison.Ordinal) + 2, 1) != "<")
{
if (regexLPL.Match(tokens[2]).Success)
{
tokens[2] = tokens[2].Replace("\"@", "@");
String pLitValue = tokens[2].Substring(0, tokens[2].LastIndexOf("@", StringComparison.Ordinal));
String pLitLang = tokens[2].Substring(tokens[2].LastIndexOf("@", StringComparison.Ordinal) + 1);
L = new RDFPlainLiteral(HttpUtility.HtmlDecode(pLitValue), pLitLang);
}
else
{
L = new RDFPlainLiteral(HttpUtility.HtmlDecode(tokens[2]));
}
}
#endregion
#region typed literal
else
{
tokens[2] = tokens[2].Replace("\"^^", "^^");
String tLitValue = tokens[2].Substring(0, tokens[2].LastIndexOf("^^", StringComparison.Ordinal));
String tLitDatatype = tokens[2].Substring(tokens[2].LastIndexOf("^^", StringComparison.Ordinal) + 2)
.TrimStart(new Char[] { '<' })
.TrimEnd(new Char[] { '>' });
RDFModelEnums.RDFDatatypes dt = RDFModelUtilities.GetDatatypeFromString(tLitDatatype);
L = new RDFTypedLiteral(HttpUtility.HtmlDecode(tLitValue), dt);
}
#endregion
}
#endregion
#region addtriple
if (O != null)
{
result.AddTriple(new RDFTriple(S, P, O));
}
else
{
result.AddTriple(new RDFTriple(S, P, L));
}
#endregion
}
return(result);
}
#endregion
}
catch (Exception ex)
{
throw new RDFModelException("Cannot deserialize N-Triples (line " + ntripleIndex + ") because: " + ex.Message, ex);
}
}
/// <summary>
/// Deserializes the given TriX stream to a graph.
/// </summary>
internal static RDFGraph Deserialize(Stream inputStream, Uri graphContext)
{
try
{
#region deserialize
RDFGraph result = new RDFGraph().SetContext(graphContext);
using (StreamReader streamReader = new StreamReader(inputStream, Encoding.UTF8))
{
using (XmlTextReader trixReader = new XmlTextReader(streamReader))
{
trixReader.DtdProcessing = DtdProcessing.Parse;
trixReader.Normalization = false;
#region document
XmlDocument trixDoc = new XmlDocument();
trixDoc.Load(trixReader);
#endregion
#region graph
if (trixDoc.DocumentElement != null)
{
if (trixDoc.DocumentElement.ChildNodes.Count > 1)
{
throw new Exception(" given TriX file seems to encode more than one graph.");
}
var graphEnum = trixDoc.DocumentElement.ChildNodes.GetEnumerator();
while (graphEnum != null && graphEnum.MoveNext())
{
XmlNode graph = (XmlNode)graphEnum.Current;
if (!graph.Name.Equals("graph", StringComparison.Ordinal))
{
throw new Exception(" a \"<graph>\" element was expected, instead of unrecognized \"<" + graph.Name + ">\".");
}
#region triple
var encodedUris = 0;
var tripleEnum = graph.ChildNodes.GetEnumerator();
while (tripleEnum != null && tripleEnum.MoveNext())
{
XmlNode triple = (XmlNode)tripleEnum.Current;
#region uri
if (triple.Name.Equals("uri", StringComparison.Ordinal))
{
encodedUris++;
if (encodedUris > 1)
{
throw new Exception(" given file encodes a graph with more than one \"<uri>\" element.");
}
result.SetContext(RDFModelUtilities.GetUriFromString(triple.ChildNodes[0].InnerText));
}
#endregion
#region triple
else if (triple.Name.Equals("triple", StringComparison.Ordinal) && triple.ChildNodes.Count == 3)
{
#region subj
//Subject is a resource ("<uri>") or a blank node ("<id>")
if (triple.ChildNodes[0].Name.Equals("uri", StringComparison.Ordinal) ||
triple.ChildNodes[0].Name.Equals("id", StringComparison.Ordinal))
{
//Sanitize eventual blank node value
if (triple.ChildNodes[0].Name.Equals("id", StringComparison.Ordinal))
{
if (!triple.ChildNodes[0].InnerText.StartsWith("bnode:"))
{
triple.ChildNodes[0].InnerText = string.Concat("bnode:", triple.ChildNodes[0].InnerText.Replace("_:", string.Empty));
}
}
}
//Subject is not valid: exception must be raised
else
{
throw new Exception("subject (" + triple.ChildNodes[0].Name + ") of \"<triple>\" element is neither \"<uri>\" or \"<id>\".");
}
#endregion
#region pred
//Predicate is not valid: exception must be raised
if (!triple.ChildNodes[1].Name.Equals("uri", StringComparison.Ordinal))
{
throw new Exception("predicate (" + triple.ChildNodes[1].Name + ") of \"<triple>\" element must be \"<uri>\".");
}
#endregion
#region object
//Object is a resource ("<uri>") or a blank node ("<id>")
if (triple.ChildNodes[2].Name.Equals("uri", StringComparison.Ordinal) ||
triple.ChildNodes[2].Name.Equals("id", StringComparison.Ordinal))
{
//Sanitize eventual blank node value
if (triple.ChildNodes[2].Name.Equals("id", StringComparison.Ordinal))
{
if (!triple.ChildNodes[2].InnerText.StartsWith("bnode:"))
{
triple.ChildNodes[2].InnerText = string.Concat("bnode:", triple.ChildNodes[2].InnerText.Replace("_:", string.Empty));
}
}
result.AddTriple(new RDFTriple(new RDFResource(triple.ChildNodes[0].InnerText),
new RDFResource(triple.ChildNodes[1].InnerText),
new RDFResource(triple.ChildNodes[2].InnerText)));
}
#endregion
#region literal
#region plain literal
else if (triple.ChildNodes[2].Name.Equals("plainLiteral"))
{
if (triple.ChildNodes[2].Attributes != null && triple.ChildNodes[2].Attributes.Count > 0)
{
XmlAttribute xmlLang = triple.ChildNodes[2].Attributes[string.Concat(RDFVocabulary.XML.PREFIX, ":lang")];
if (xmlLang != null)
{
//Plain literal with language
result.AddTriple(new RDFTriple(new RDFResource(triple.ChildNodes[0].InnerText),
new RDFResource(triple.ChildNodes[1].InnerText),
new RDFPlainLiteral(RDFModelUtilities.ASCII_To_Unicode(HttpUtility.HtmlDecode(triple.ChildNodes[2].InnerText)), xmlLang.Value)));
}
else
{
//Plain literal without language
result.AddTriple(new RDFTriple(new RDFResource(triple.ChildNodes[0].InnerText),
new RDFResource(triple.ChildNodes[1].InnerText),
new RDFPlainLiteral(RDFModelUtilities.ASCII_To_Unicode(HttpUtility.HtmlDecode(triple.ChildNodes[2].InnerText)))));
}
}
else
{
//Plain literal without language
result.AddTriple(new RDFTriple(new RDFResource(triple.ChildNodes[0].InnerText),
new RDFResource(triple.ChildNodes[1].InnerText),
new RDFPlainLiteral(RDFModelUtilities.ASCII_To_Unicode(HttpUtility.HtmlDecode(triple.ChildNodes[2].InnerText)))));
}
}
#endregion
#region typed literal
else if (triple.ChildNodes[2].Name.Equals("typedLiteral", StringComparison.Ordinal))
{
if (triple.ChildNodes[2].Attributes != null && triple.ChildNodes[2].Attributes.Count > 0)
{
XmlAttribute rdfDtype = triple.ChildNodes[2].Attributes["datatype"];
if (rdfDtype != null)
{
result.AddTriple(new RDFTriple(new RDFResource(triple.ChildNodes[0].InnerText),
new RDFResource(triple.ChildNodes[1].InnerText),
new RDFTypedLiteral(RDFModelUtilities.ASCII_To_Unicode(HttpUtility.HtmlDecode(triple.ChildNodes[2].InnerText)), RDFModelUtilities.GetDatatypeFromString(rdfDtype.Value))));
}
else
{
throw new Exception(" found typed literal without required \"datatype\" attribute.");
}
}
else
{
throw new Exception(" found typed literal without required \"datatype\" attribute.");
}
}
#endregion
#endregion
#region exception
//Object is not valid: exception must be raised
else
{
throw new Exception("object (" + triple.ChildNodes[2].Name + ") of \"<triple>\" element is neither \"<uri>\" or \"<id>\" or \"<plainLiteral>\" or \"<typedLiteral>\".");
}
#endregion
}
#endregion
#region exception
else
{
throw new Exception("found a TriX element (" + triple.Name + ") which is neither \"<uri>\" or \"<triple>\", or is a \"<triple>\" without the required 3 childs.");
}
#endregion
}
#endregion
}
}
#endregion
}
}
return(result);
#endregion
}
catch (Exception ex)
{
throw new RDFModelException("Cannot deserialize TriX because: " + ex.Message, ex);
}
}
