/// <summary>
/// Gets an ontology data representation of this collection
/// </summary>
public RDFOntologyData ToRDFOntologyData()
{
RDFOntologyData result = new RDFOntologyData();
//Collection
result.AddFact(this);
result.AddClassTypeRelation(this, RDFVocabulary.SKOS.COLLECTION.ToRDFOntologyClass());
//Concepts
foreach (RDFSKOSConcept cn in this.Concepts.Values)
{
result.AddFact(cn);
result.AddClassTypeRelation(cn, RDFVocabulary.SKOS.CONCEPT.ToRDFOntologyClass());
result.AddMemberRelation(this, cn);
}
//Collections
foreach (RDFSKOSCollection cl in this.Collections.Values)
{
result.AddMemberRelation(this, cl);
//Recursively add linked SKOS collection
result = result.UnionWith(cl.ToRDFOntologyData());
}
return(result);
}
/// <summary>
/// Gets an ontology data representation of this collection
/// </summary>
public RDFOntologyData ToRDFOntologyData()
{
var result = new RDFOntologyData();
//Collection
result.AddFact(this);
result.AddClassTypeRelation(this, RDFVocabulary.SKOS.COLLECTION.ToRDFOntologyClass());
//Concepts
foreach (var cn in this.Concepts.Values)
{
result.AddFact(cn);
result.AddClassTypeRelation(cn, RDFVocabulary.SKOS.CONCEPT.ToRDFOntologyClass());
result.AddAssertionRelation(this, RDFVocabulary.SKOS.MEMBER.ToRDFOntologyObjectProperty(), cn);
}
//Collections
foreach (var cl in this.Collections.Values)
{
result.AddAssertionRelation(this, RDFVocabulary.SKOS.MEMBER.ToRDFOntologyObjectProperty(), cl);
result = result.UnionWith(cl.ToRDFOntologyData());
}
return(result);
}
/// <summary>
/// Gets an ontology data containing the facts which are members of this class
/// </summary>
public override RDFOntologyData EnlistMembers(RDFOntology ontology) {
var facts = new RDFOntologyData();
if (ontology != null) {
//Iterate the classes belonging to the union class
var compClassEnum = this.CompositingClassesEnumerator();
while (compClassEnum.MoveNext()) {
//Compose them with a union logic
facts = facts.UnionWith(compClassEnum.Current.EnlistMembers(ontology));
}
}
return facts;
}
/// <summary>
/// Gets an ontology data representation of this scheme
/// </summary>
public RDFOntologyData ToRDFOntologyData()
{
var result = new RDFOntologyData();
//ConceptScheme
result.AddFact(this);
result.AddClassTypeRelation(this, RDFVocabulary.SKOS.CONCEPT_SCHEME.ToRDFOntologyClass());
//Concepts
foreach (var c in this)
{
result.AddFact(c);
result.AddClassTypeRelation(c, RDFVocabulary.SKOS.CONCEPT.ToRDFOntologyClass());
result.AddAssertionRelation(c, RDFVocabulary.SKOS.IN_SCHEME.ToRDFOntologyObjectProperty(), this);
}
//Collections
foreach (var c in this.Collections.Values)
{
result.AddAssertionRelation(c, RDFVocabulary.SKOS.IN_SCHEME.ToRDFOntologyObjectProperty(), this);
result = result.UnionWith(c.ToRDFOntologyData());
}
//OrderedCollections
foreach (var o in this.OrderedCollections.Values)
{
result.AddAssertionRelation(o, RDFVocabulary.SKOS.IN_SCHEME.ToRDFOntologyObjectProperty(), this);
result = result.UnionWith(o.ToRDFOntologyData());
}
//Labels
foreach (var l in this.Labels.Values)
{
result.AddFact(l);
result.AddClassTypeRelation(l, RDFVocabulary.SKOS.SKOSXL.LABEL.ToRDFOntologyClass());
result.AddAssertionRelation(l, RDFVocabulary.SKOS.IN_SCHEME.ToRDFOntologyObjectProperty(), this);
}
//Assertions
result.Relations.Assertions = result.Relations.Assertions.UnionWith(this.Relations.TopConcept)
.UnionWith(this.Relations.Broader)
.UnionWith(this.Relations.BroaderTransitive)
.UnionWith(this.Relations.BroadMatch)
.UnionWith(this.Relations.Narrower)
.UnionWith(this.Relations.NarrowerTransitive)
.UnionWith(this.Relations.NarrowMatch)
.UnionWith(this.Relations.Related)
.UnionWith(this.Relations.RelatedMatch)
.UnionWith(this.Relations.SemanticRelation)
.UnionWith(this.Relations.MappingRelation)
.UnionWith(this.Relations.CloseMatch)
.UnionWith(this.Relations.ExactMatch)
.UnionWith(this.Relations.Notation)
.UnionWith(this.Relations.PrefLabel)
.UnionWith(this.Relations.AltLabel)
.UnionWith(this.Relations.HiddenLabel)
.UnionWith(this.Relations.LiteralForm)
.UnionWith(this.Relations.LabelRelation);
//Annotations
result.Annotations.CustomAnnotations = result.Annotations.CustomAnnotations.UnionWith(this.Annotations.PrefLabel)
.UnionWith(this.Annotations.AltLabel)
.UnionWith(this.Annotations.HiddenLabel)
.UnionWith(this.Annotations.Note)
.UnionWith(this.Annotations.ChangeNote)
.UnionWith(this.Annotations.EditorialNote)
.UnionWith(this.Annotations.HistoryNote)
.UnionWith(this.Annotations.ScopeNote)
.UnionWith(this.Annotations.Definition)
.UnionWith(this.Annotations.Example);
return(result);
}
/// <summary>
/// Enlists the facts which are members of the given class within the given ontology
/// </summary>
internal static RDFOntologyData EnlistMembersOfClass(RDFOntologyClass ontClass, RDFOntology ontology) {
var result = new RDFOntologyData();
//DataRange / Literal
if (ontClass.IsDataRangeClass()
|| ontClass.Equals(RDFOntologyVocabulary.Classes.LITERAL)
|| RDFOntologyReasoningHelper.IsSubClassOf(ontClass, RDFOntologyVocabulary.Classes.LITERAL, ontology.Model.ClassModel)
|| RDFOntologyReasoningHelper.IsEquivalentClassOf(ontClass, RDFOntologyVocabulary.Classes.LITERAL, ontology.Model.ClassModel)) {
//DataRange
if (ontClass.IsDataRangeClass()) {
result = RDFSemanticsUtilities.EnlistMembersOfDataRange((RDFOntologyDataRangeClass)ontClass, ontology);
}
//Literal
else {
//Pure Literal
if (ontClass.Equals(RDFOntologyVocabulary.Classes.LITERAL) ||
RDFOntologyReasoningHelper.IsEquivalentClassOf(ontClass, RDFOntologyVocabulary.Classes.LITERAL, ontology.Model.ClassModel)) {
foreach (var ontLit in ontology.Data.Literals.Values) {
result.AddLiteral(ontLit);
}
}
//Derived Literal
else {
//String-Literals
var xsdStringClass = ontology.Model.ClassModel.SelectClass(RDFVocabulary.XSD.STRING.ToString());
if (ontClass.Equals(xsdStringClass) ||
RDFOntologyReasoningHelper.IsEquivalentClassOf(ontClass, xsdStringClass, ontology.Model.ClassModel)) {
foreach (var ontLit in ontology.Data.Literals.Values) {
if (ontLit.Value is RDFPlainLiteral) {
result.AddLiteral(ontLit);
}
else {
var dTypeClass = ontology.Model.ClassModel.SelectClass(((RDFTypedLiteral)ontLit.Value).Datatype.ToString());
if (dTypeClass != null) {
if (dTypeClass.Equals(ontClass) ||
RDFOntologyReasoningHelper.IsSubClassOf(dTypeClass, ontClass, ontology.Model.ClassModel) ||
RDFOntologyReasoningHelper.IsEquivalentClassOf(dTypeClass, ontClass, ontology.Model.ClassModel)) {
result.AddLiteral(ontLit);
}
}
else {
if (dTypeClass.Equals(ontClass)) {
result.AddLiteral(ontLit);
}
}
}
}
}
//Other Literals
else {
foreach (var ontLit in ontology.Data.Literals.Values.Where(l => l.Value is RDFTypedLiteral)) {
var dTypeClass = ontology.Model.ClassModel.SelectClass(((RDFTypedLiteral)ontLit.Value).Datatype.ToString());
if (dTypeClass != null) {
if (dTypeClass.Equals(ontClass) ||
RDFOntologyReasoningHelper.IsSubClassOf(dTypeClass, ontClass, ontology.Model.ClassModel) ||
RDFOntologyReasoningHelper.IsEquivalentClassOf(dTypeClass, ontClass, ontology.Model.ClassModel)) {
result.AddLiteral(ontLit);
}
}
else {
if (dTypeClass.Equals(ontClass)) {
result.AddLiteral(ontLit);
}
}
}
}
}
}
}
//Composite
else if (ontClass.IsCompositeClass()) {
result = RDFSemanticsUtilities.EnlistMembersOfComposite(ontClass, ontology);
}
//Enumerate
else if (ontClass.IsEnumerateClass()) {
result = RDFSemanticsUtilities.EnlistMembersOfEnumerate((RDFOntologyEnumerateClass)ontClass, ontology);
}
//Class
else {
//Get the compatible classes
var compCls = RDFOntologyReasoningHelper.EnlistSubClassesOf(ontClass, ontology.Model.ClassModel)
.UnionWith(RDFOntologyReasoningHelper.EnlistEquivalentClassesOf(ontClass, ontology.Model.ClassModel))
.AddClass(ontClass);
//Filter "classType" relations made with compatible classes
var fTaxonomy = new RDFOntologyTaxonomy();
foreach (var c in compCls) {
fTaxonomy = fTaxonomy.UnionWith(ontology.Data.Relations.ClassType.SelectEntriesByObject(c));
}
foreach (var tEntry in fTaxonomy) {
//Add the fact and its synonyms
if (tEntry.TaxonomySubject.IsFact()) {
result = result.UnionWith(RDFOntologyReasoningHelper.EnlistSameFactsAs((RDFOntologyFact)tEntry.TaxonomySubject, ontology.Data))
.AddFact((RDFOntologyFact)tEntry.TaxonomySubject);
}
}
}
return result;
}
/// <summary>
/// Enlists the facts which are members of the given composition within the given ontology
/// </summary>
internal static RDFOntologyData EnlistMembersOfComposite(RDFOntologyClass ontCompClass, RDFOntology ontology) {
var result = new RDFOntologyData();
//Intersection
if (ontCompClass is RDFOntologyIntersectionClass) {
//Filter "intersectionOf" relations made with the given intersection class
var firstIter = true;
var iTaxonomy = ontology.Model.ClassModel.Relations.IntersectionOf.SelectEntriesBySubject(ontCompClass);
foreach (var tEntry in iTaxonomy) {
if (firstIter) {
result = RDFOntologyReasoningHelper.EnlistMembersOf((RDFOntologyClass)tEntry.TaxonomyObject, ontology);
firstIter = false;
}
else {
result = result.IntersectWith(RDFOntologyReasoningHelper.EnlistMembersOf((RDFOntologyClass)tEntry.TaxonomyObject, ontology));
}
}
}
//Union
else if (ontCompClass is RDFOntologyUnionClass) {
//Filter "unionOf" relations made with the given union class
var uTaxonomy = ontology.Model.ClassModel.Relations.UnionOf.SelectEntriesBySubject(ontCompClass);
foreach (var tEntry in uTaxonomy) {
result = result.UnionWith(RDFOntologyReasoningHelper.EnlistMembersOf((RDFOntologyClass)tEntry.TaxonomyObject, ontology));
}
}
//Complement
else if (ontCompClass is RDFOntologyComplementClass) {
result = ontology.Data.DifferenceWith(RDFOntologyReasoningHelper.EnlistMembersOf(ontCompClass, ontology));
}
return result;
}
/// <summary>
/// Enlists the facts which are members of the given enumeration within the given ontology
/// </summary>
internal static RDFOntologyData EnlistMembersOfEnumerate(RDFOntologyEnumerateClass ontEnumClass, RDFOntology ontology) {
var result = new RDFOntologyData();
//Filter "oneOf" relations made with the given enumerate class
var enTaxonomy = ontology.Model.ClassModel.Relations.OneOf.SelectEntriesBySubject(ontEnumClass);
foreach (var tEntry in enTaxonomy) {
//Add the fact and its synonyms
if (tEntry.TaxonomyObject.IsFact()) {
result= result.UnionWith(RDFOntologyReasoningHelper.EnlistSameFactsAs((RDFOntologyFact)tEntry.TaxonomyObject, ontology.Data))
.AddFact((RDFOntologyFact)tEntry.TaxonomyObject);
}
}
return result;
}
/// <summary>
/// Subsumes the "owl:differentFrom" taxonomy to discover direct and indirect differentFacts of the given facts
/// </summary>
internal static RDFOntologyData EnlistDifferentFactsFrom_Core(RDFOntologyFact ontFact,
RDFOntologyData data,
Dictionary<Int64, RDFOntologyFact> visitContext) {
var result = new RDFOntologyData();
#region visitContext
if (visitContext == null) {
visitContext = new Dictionary<Int64, RDFOntologyFact>() { { ontFact.PatternMemberID, ontFact } };
}
else {
if (!visitContext.ContainsKey(ontFact.PatternMemberID)) {
visitContext.Add(ontFact.PatternMemberID, ontFact);
}
else {
return result;
}
}
#endregion
// Inference: (A DIFFERENTFROM B && B SAMEAS C => A DIFFERENTFROM C)
foreach (var df in data.Relations.DifferentFrom.SelectEntriesBySubject(ontFact)) {
result.AddFact((RDFOntologyFact)df.TaxonomyObject);
result = result.UnionWith(RDFSemanticsUtilities.EnlistSameFactsAs_Core((RDFOntologyFact)df.TaxonomyObject, data, visitContext));
}
// Inference: (A SAMEAS B && B DIFFERENTFROM C => A DIFFERENTFROM C)
foreach (var sa in RDFOntologyReasoningHelper.EnlistSameFactsAs(ontFact, data)) {
result = result.UnionWith(RDFSemanticsUtilities.EnlistDifferentFactsFrom_Core(sa, data, visitContext));
}
return result;
}
/// <summary>
/// Subsumes the "owl:sameAs" taxonomy to discover direct and indirect samefacts of the given facts
/// </summary>
internal static RDFOntologyData EnlistSameFactsAs_Core(RDFOntologyFact ontFact,
RDFOntologyData data,
Dictionary<Int64, RDFOntologyFact> visitContext) {
var result = new RDFOntologyData();
#region visitContext
if (visitContext == null) {
visitContext = new Dictionary<Int64, RDFOntologyFact>() { { ontFact.PatternMemberID, ontFact } };
}
else {
if (!visitContext.ContainsKey(ontFact.PatternMemberID)) {
visitContext.Add(ontFact.PatternMemberID, ontFact);
}
else {
return result;
}
}
#endregion
// Transitivity of "owl:sameAs" taxonomy: ((A SAMEAS B) && (B SAMEAS C)) => (A SAMEAS C)
foreach (var sf in data.Relations.SameAs.SelectEntriesBySubject(ontFact)) {
result.AddFact((RDFOntologyFact)sf.TaxonomyObject);
result = result.UnionWith(RDFSemanticsUtilities.EnlistSameFactsAs_Core((RDFOntologyFact)sf.TaxonomyObject, data, visitContext));
}
return result;
}
