/// <summary>
/// Adds the "ontologyFact -> rdf:type -> ontologyClass" relation to the data.
/// </summary>
public RDFOntologyData AddClassTypeRelation(RDFOntologyFact ontologyFact,
RDFOntologyClass ontologyClass)
{
if (ontologyFact != null && ontologyClass != null)
{
//Enforce preliminary check on usage of BASE classes
if (!RDFOntologyChecker.CheckReservedClass(ontologyClass))
{
//Enforce taxonomy checks before adding the ClassType relation
if (RDFOntologyChecker.CheckClassTypeCompatibility(ontologyClass))
{
this.Relations.ClassType.AddEntry(new RDFOntologyTaxonomyEntry(ontologyFact, RDFVocabulary.RDF.TYPE.ToRDFOntologyObjectProperty(), ontologyClass));
}
else
{
//Raise warning event to inform the user: ClassType relation cannot be added to the data because only plain classes can be explicitly assigned as class types of facts
RDFSemanticsEvents.RaiseSemanticsWarning(String.Format("ClassType relation between fact '{0}' and class '{1}' cannot be added to the data because only plain classes can be explicitly assigned as class types of facts.", ontologyFact, ontologyClass));
}
}
else
{
//Raise warning event to inform the user: ClassType relation cannot be added to the data because usage of BASE reserved classes compromises the taxonomy consistency
RDFSemanticsEvents.RaiseSemanticsWarning(String.Format("ClassType relation between fact '{0}' and class '{1}' cannot be added to the data because because usage of BASE reserved classes compromises the taxonomy consistency.", ontologyFact, ontologyClass));
}
}
return(this);
}
/// <summary>
/// Adds the "aFact -> objectProperty -> bFact" relation to the data
/// </summary>
public RDFOntologyData AddAssertionRelation(RDFOntologyFact aFact,
RDFOntologyObjectProperty objectProperty,
RDFOntologyFact bFact)
{
if (aFact != null && objectProperty != null && bFact != null)
{
//Enforce preliminary check on usage of BASE properties
if (!RDFOntologyChecker.CheckReservedProperty(objectProperty))
{
//Enforce taxonomy checks before adding the assertion
//Creation of transitive cycles is not allowed (OWL-DL)
if (RDFOntologyChecker.CheckTransitiveAssertionCompatibility(this, aFact, objectProperty, bFact))
{
this.Relations.Assertions.AddEntry(new RDFOntologyTaxonomyEntry(aFact, objectProperty, bFact));
}
else
{
//Raise warning event to inform the user: Assertion relation cannot be added to the data because it violates the taxonomy transitive consistency
RDFSemanticsEvents.RaiseSemanticsWarning(String.Format("Assertion relation between fact '{0}' and fact '{1}' with transitive property '{2}' cannot be added to the data because it would violate the taxonomy consistency (transitive cycle detected).", aFact, bFact, objectProperty));
}
}
else
{
//Raise warning event to inform the user: Assertion relation cannot be added to the data because usage of BASE reserved properties compromises the taxonomy consistency
RDFSemanticsEvents.RaiseSemanticsWarning(String.Format("Assertion relation between fact '{0}' and fact '{1}' cannot be added to the data because usage of BASE reserved properties compromises the taxonomy consistency.", aFact, bFact));
}
}
return(this);
}
/// <summary>
/// Adds the "aFact -> owl:differentFrom -> bFact" relation to the data
/// </summary>
public RDFOntologyData AddDifferentFromRelation(RDFOntologyFact aFact,
RDFOntologyFact bFact)
{
if (aFact != null && bFact != null && !aFact.Equals(bFact))
{
//Enforce taxonomy checks before adding the DifferentFrom relation
if (RDFOntologyChecker.CheckDifferentFromCompatibility(this, aFact, bFact))
{
this.Relations.DifferentFrom.AddEntry(new RDFOntologyTaxonomyEntry(aFact, RDFVocabulary.OWL.DIFFERENT_FROM.ToRDFOntologyObjectProperty(), bFact));
this.Relations.DifferentFrom.AddEntry(new RDFOntologyTaxonomyEntry(bFact, RDFVocabulary.OWL.DIFFERENT_FROM.ToRDFOntologyObjectProperty(), aFact).SetInference(RDFSemanticsEnums.RDFOntologyInferenceType.API));
}
else
{
//Raise warning event to inform the user: DifferentFrom relation cannot be added to the data because it violates the taxonomy consistency
RDFSemanticsEvents.RaiseSemanticsWarning(String.Format("DifferentFrom relation between fact '{0}' and fact '{1}' cannot be added to the data because it violates the taxonomy consistency.", aFact, bFact));
}
}
return(this);
}
/// <summary>
/// Adds the "aFact -> owl:differentFrom -> bFact" relation to the data
/// </summary>
public RDFOntologyData AddDifferentFromRelation(RDFOntologyFact aFact,
RDFOntologyFact bFact)
{
if (aFact != null && bFact != null && !aFact.Equals(bFact))
{
//Enforce taxonomy checks before adding the differentFrom relation
if (!RDFBASEOntologyReasoningHelper.IsSameFactAs(aFact, bFact, this))
{
this.Relations.DifferentFrom.AddEntry(new RDFOntologyTaxonomyEntry(aFact, RDFBASEOntology.Instance.Model.PropertyModel.SelectProperty(RDFVocabulary.OWL.DIFFERENT_FROM.ToString()), bFact));
this.Relations.DifferentFrom.AddEntry(new RDFOntologyTaxonomyEntry(bFact, RDFBASEOntology.Instance.Model.PropertyModel.SelectProperty(RDFVocabulary.OWL.DIFFERENT_FROM.ToString()), aFact).SetInference(RDFSemanticsEnums.RDFOntologyInferenceType.API));
}
else
{
//Raise warning event to inform the user: DifferentFrom relation cannot be added to the data because it violates the taxonomy consistency
RDFSemanticsEvents.RaiseSemanticsWarning(String.Format("DifferentFrom relation between fact '{0}' and fact '{1}' cannot be added to the data because it violates the taxonomy consistency.", aFact, bFact));
}
}
return(this);
}
/// <summary>
/// Adds the "ontologyFact -> datatypeProperty -> ontologyLiteral" relation to the data
/// </summary>
public RDFOntologyData AddAssertionRelation(RDFOntologyFact ontologyFact,
RDFOntologyDatatypeProperty datatypeProperty,
RDFOntologyLiteral ontologyLiteral)
{
if (ontologyFact != null && datatypeProperty != null && ontologyLiteral != null)
{
//Enforce preliminary check on usage of BASE properties
if (!RDFOntologyChecker.CheckReservedProperty(datatypeProperty))
{
this.Relations.Assertions.AddEntry(new RDFOntologyTaxonomyEntry(ontologyFact, datatypeProperty, ontologyLiteral));
this.AddLiteral(ontologyLiteral);
}
else
{
//Raise warning event to inform the user: Assertion relation cannot be added to the data because usage of BASE reserved properties compromises the taxonomy consistency
RDFSemanticsEvents.RaiseSemanticsWarning(String.Format("Assertion relation between fact '{0}' and literal '{1}' cannot be added to the data because usage of BASE reserved properties compromises the taxonomy consistency.", ontologyFact, ontologyLiteral));
}
}
return(this);
}
/// <summary>
/// Adds the "aFact -> objectProperty -> bFact" relation to the data
/// </summary>
public RDFOntologyData AddAssertionRelation(RDFOntologyFact aFact,
RDFOntologyObjectProperty objectProperty,
RDFOntologyFact bFact)
{
if (aFact != null && objectProperty != null && bFact != null)
{
//Enforce taxonomy checks before adding the assertion
//Even if legal, we don't permit creation of transitive cycles!!
if (!RDFBASEOntologyReasoningHelper.IsTransitiveAssertionOf(bFact, objectProperty, aFact, this))
{
this.Relations.Assertions.AddEntry(new RDFOntologyTaxonomyEntry(aFact, objectProperty, bFact));
}
else
{
//Raise warning event to inform the user: Assertion relation cannot be added to the data because it violates the taxonomy transitive consistency
RDFSemanticsEvents.RaiseSemanticsWarning(String.Format("Assertion relation between fact '{0}' and fact '{1}' with transitive property '{2}' cannot be added to the data because it would violate the taxonomy consistency (transitive cycle detected).", aFact, bFact, objectProperty));
}
}
return(this);
}
/// <summary>
/// Adds the "ontologyFact -> rdf:type -> ontologyClass" relation to the data.
/// </summary>
public RDFOntologyData AddClassTypeRelation(RDFOntologyFact ontologyFact,
RDFOntologyClass ontologyClass)
{
if (ontologyFact != null && ontologyClass != null)
{
//Enforce taxonomy checks before adding the classType relation
//Only plain classes can be explicitly assigned as classtypes of facts
if (!ontologyClass.IsRestrictionClass() &&
!ontologyClass.IsCompositeClass() &&
!ontologyClass.IsEnumerateClass() &&
!ontologyClass.IsDataRangeClass() &&
//owl:Nothing cannot be assigned as classtype of facts
!ontologyClass.Equals(RDFBASEOntology.Instance.Model.ClassModel.SelectClass(RDFVocabulary.OWL.NOTHING.ToString())))
{
this.Relations.ClassType.AddEntry(new RDFOntologyTaxonomyEntry(ontologyFact, RDFBASEOntology.Instance.Model.PropertyModel.SelectProperty(RDFVocabulary.RDF.TYPE.ToString()), ontologyClass));
}
else
{
//Raise warning event to inform the user: ClassType relation cannot be added to the data because only plain classes can be explicitly assigned as class types of facts
RDFSemanticsEvents.RaiseSemanticsWarning(String.Format("ClassType relation between fact '{0}' and class '{1}' cannot be added to the data because only plain classes can be explicitly assigned as class types of facts.", ontologyFact, ontologyClass));
}
}
return(this);
}
/// <summary>
/// Adds the "ontologyFact -> ontologyAnnotationProperty -> ontologyResource" annotation to the data
/// </summary>
public RDFOntologyData AddCustomAnnotation(RDFOntologyFact ontologyFact,
RDFOntologyAnnotationProperty ontologyAnnotationProperty,
RDFOntologyResource ontologyResource)
{
if (ontologyFact != null && ontologyAnnotationProperty != null && ontologyResource != null)
{
//owl:versionInfo
if (ontologyAnnotationProperty.Equals(RDFBASEOntology.Instance.Model.PropertyModel.SelectProperty(RDFVocabulary.OWL.VERSION_INFO.ToString())))
{
if (ontologyResource.IsLiteral())
{
this.AddVersionInfoAnnotation(ontologyFact, (RDFOntologyLiteral)ontologyResource);
}
}
//vs:term_status
else if (ontologyAnnotationProperty.Equals(RDFBASEOntology.Instance.Model.PropertyModel.SelectProperty(RDFVocabulary.VS.TERM_STATUS.ToString())))
{
//Raise warning event to inform the user: vs:term_status annotation property cannot be used for facts
RDFSemanticsEvents.RaiseSemanticsWarning("vs:term_status annotation property cannot be used for facts.");
}
//rdfs:comment
else if (ontologyAnnotationProperty.Equals(RDFBASEOntology.Instance.Model.PropertyModel.SelectProperty(RDFVocabulary.RDFS.COMMENT.ToString())))
{
if (ontologyResource.IsLiteral())
{
this.AddCommentAnnotation(ontologyFact, (RDFOntologyLiteral)ontologyResource);
}
}
//rdfs:label
else if (ontologyAnnotationProperty.Equals(RDFBASEOntology.Instance.Model.PropertyModel.SelectProperty(RDFVocabulary.RDFS.LABEL.ToString())))
{
if (ontologyResource.IsLiteral())
{
this.AddLabelAnnotation(ontologyFact, (RDFOntologyLiteral)ontologyResource);
}
}
//rdfs:seeAlso
else if (ontologyAnnotationProperty.Equals(RDFBASEOntology.Instance.Model.PropertyModel.SelectProperty(RDFVocabulary.RDFS.SEE_ALSO.ToString())))
{
this.AddSeeAlsoAnnotation(ontologyFact, ontologyResource);
}
//rdfs:isDefinedBy
else if (ontologyAnnotationProperty.Equals(RDFBASEOntology.Instance.Model.PropertyModel.SelectProperty(RDFVocabulary.RDFS.IS_DEFINED_BY.ToString())))
{
this.AddIsDefinedByAnnotation(ontologyFact, ontologyResource);
}
//ontology-specific
else if (ontologyAnnotationProperty.Equals(RDFBASEOntology.Instance.Model.PropertyModel.SelectProperty(RDFVocabulary.OWL.VERSION_IRI.ToString())) ||
ontologyAnnotationProperty.Equals(RDFBASEOntology.Instance.Model.PropertyModel.SelectProperty(RDFVocabulary.OWL.IMPORTS.ToString())) ||
ontologyAnnotationProperty.Equals(RDFBASEOntology.Instance.Model.PropertyModel.SelectProperty(RDFVocabulary.OWL.BACKWARD_COMPATIBLE_WITH.ToString())) ||
ontologyAnnotationProperty.Equals(RDFBASEOntology.Instance.Model.PropertyModel.SelectProperty(RDFVocabulary.OWL.INCOMPATIBLE_WITH.ToString())) ||
ontologyAnnotationProperty.Equals(RDFBASEOntology.Instance.Model.PropertyModel.SelectProperty(RDFVocabulary.OWL.PRIOR_VERSION.ToString())))
{
//Raise warning event to inform the user: Ontology-specific annotation properties cannot be used for facts
RDFSemanticsEvents.RaiseSemanticsWarning("Ontology-specific annotation properties cannot be used for facts.");
}
//custom
else
{
this.Annotations.CustomAnnotations.AddEntry(new RDFOntologyTaxonomyEntry(ontologyFact, ontologyAnnotationProperty, ontologyResource));
if (ontologyResource.IsLiteral())
{
this.AddLiteral((RDFOntologyLiteral)ontologyResource);
}
}
}
return(this);
}