/// <summary>
/// Gets an ontology data containing the facts which are members of this restriction
/// </summary>
public override RDFOntologyData EnlistMembers(RDFOntology ontology) {
var resultFacts = new RDFOntologyData();
if (ontology != null) {
//Retrieve ontology data facts having the restricted property in their attributes
var facts = base.EnlistMembers(ontology);
//Iterate the ontology data facts
foreach(var f in facts) {
//Iterate the ontology attributes of the current ontology fact
var factOntAttributesEnum = f.OntologyAttributesEnumerator();
while (factOntAttributesEnum.MoveNext()) {
if (factOntAttributesEnum.Current.AttributeProperty.Equals(this.OnProperty)) {
if (factOntAttributesEnum.Current.AttributeValue.Equals(this.RequiredFact)) {
resultFacts.AddFact(f);
}
}
}
}
}
return resultFacts;
}
/// <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) {
//Get the facts belonging to the complemented class
facts = this.ComplementClass.EnlistMembers(ontology);
//Complement the ontology data with the retrieved facts
facts = ontology.Data.DifferenceWith(facts);
}
return facts;
}
/// <summary>
/// Gets an ontology data containing the facts which are direct members of this restrictions
/// </summary>
public override RDFOntologyData EnlistMembers(RDFOntology ontology) {
var facts = new RDFOntologyData();
if (ontology != null) {
//Iterate the ontology data facts
foreach(RDFOntologyFact f in ontology.Data) {
//Iterate the ontology attributes of the current ontology fact
var factOntAttributesEnum = f.OntologyAttributesEnumerator();
while (factOntAttributesEnum.MoveNext()) {
if (factOntAttributesEnum.Current.AttributeProperty.Equals(this.OnProperty)) {
facts.AddFact(f);
}
}
}
}
return facts;
}
/// <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 intersection class
Boolean firstIter = true;
var compClassEnum = this.CompositingClassesEnumerator();
while (compClassEnum.MoveNext()) {
//The first iteration must give the facts belonging to the first class
if (firstIter) {
facts = compClassEnum.Current.EnlistMembers(ontology);
firstIter = false;
}
//The other iterations must compose them with an intersection logic
else {
facts = facts.IntersectWith(compClassEnum.Current.EnlistMembers(ontology));
}
}
}
return facts;
}
/// <summary>
/// Gets an ontology data representation of this scheme
/// </summary>
public RDFOntologyData ToRDFOntologyData()
{
RDFOntologyData result = new RDFOntologyData();
//ConceptScheme
result.AddFact(this);
result.AddClassTypeRelation(this, RDFVocabulary.SKOS.CONCEPT_SCHEME.ToRDFOntologyClass());
//Concepts
foreach (RDFSKOSConcept c in this)
{
result.AddFact(c);
result.AddClassTypeRelation(c, RDFVocabulary.SKOS.CONCEPT.ToRDFOntologyClass());
result.AddAssertionRelation(c, RDFVocabulary.SKOS.IN_SCHEME.ToRDFOntologyObjectProperty(), this);
}
//Collections
foreach (RDFSKOSCollection c in this.Collections.Values)
{
result.AddAssertionRelation(c, RDFVocabulary.SKOS.IN_SCHEME.ToRDFOntologyObjectProperty(), this);
result = result.UnionWith(c.ToRDFOntologyData());
}
//OrderedCollections
foreach (RDFSKOSOrderedCollection o in this.OrderedCollections.Values)
{
result.AddAssertionRelation(o, RDFVocabulary.SKOS.IN_SCHEME.ToRDFOntologyObjectProperty(), this);
result = result.UnionWith(o.ToRDFOntologyData());
}
//Labels
foreach (RDFSKOSLabel 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>
/// 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 enumerate members and check if they are contained in the ontology data
var enumMembers = this.EnumerateMembersEnumerator();
while (enumMembers.MoveNext()) {
var ontFact = ontology.Data.SelectFact(enumMembers.Current.ToString());
if (ontFact != null) {
facts.AddFact(ontFact);
}
}
}
return facts;
}
/// <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>
/// Gets an ontology data containing the facts which are members of this restriction
/// </summary>
public override RDFOntologyData EnlistMembers(RDFOntology ontology) {
var resultFacts = new RDFOntologyData();
if (ontology != null) {
//Retrieve ontology data facts having the restricted property in their attributes
var facts = base.EnlistMembers(ontology);
//Item2 is a counter for occurrences of the restricted property with a range fact of the restricted "FromClass"
//Item3 is a counter for occurrences of the restricted property with a range fact not of the restricted "FromClass"
var factsRegister = new Dictionary<Int64, Tuple<RDFOntologyFact, Int64, Int64>>();
//Iterate the ontology data facts
foreach(var f in facts) {
//Iterate the ontology attributes of the current ontology fact
var factOntAttributesEnum = f.OntologyAttributesEnumerator();
while (factOntAttributesEnum.MoveNext()) {
if (factOntAttributesEnum.Current.AttributeProperty.Equals(this.OnProperty)) {
if (!factsRegister.ContainsKey(f.PatternMemberID)) {
factsRegister.Add(f.PatternMemberID, new Tuple<RDFOntologyFact, Int64, Int64>(f, 0, 0));
}
//Iterate the class types of the candidate ontology fact and check presence of the restriction "FromClass"
Boolean fromClassFound = false;
var factClassTypesEnum = factOntAttributesEnum.Current.AttributeValue.ClassTypesEnumerator();
while (!fromClassFound && factClassTypesEnum.MoveNext()) {
if (factClassTypesEnum.Current.Equals(this.FromClass)) {
fromClassFound = true;
}
}
//Update the occurrence counters of the candidate fact
Int64 actualEqCounter = factsRegister[f.PatternMemberID].Item2;
Int64 actualDiffCounter = factsRegister[f.PatternMemberID].Item3;
if (fromClassFound) {
factsRegister[f.PatternMemberID] = new Tuple<RDFOntologyFact, Int64, Int64>(f, actualEqCounter + 1, actualDiffCounter);
}
else {
factsRegister[f.PatternMemberID] = new Tuple<RDFOntologyFact, Int64, Int64>(f, actualEqCounter, actualDiffCounter + 1);
}
}
}
}
//Apply the value restrictions on the candidate ontology facts
var factsRegEnum = factsRegister.Values.GetEnumerator();
while (factsRegEnum.MoveNext()) {
switch (this.Category) {
case RDFSemanticsEnums.RDFOntologyValuesFromRestrictionCategory.AllValuesFrom:
if (factsRegEnum.Current.Item2 >= 1 && factsRegEnum.Current.Item3 == 0) {
resultFacts.AddFact(factsRegEnum.Current.Item1);
}
break;
case RDFSemanticsEnums.RDFOntologyValuesFromRestrictionCategory.SomeValuesFrom:
if (factsRegEnum.Current.Item2 >= 1) {
resultFacts.AddFact(factsRegEnum.Current.Item1);
}
break;
}
}
}
return resultFacts;
}
/// <summary>
/// Checks if the given aFact is differentFrom the given bFact within the given data
/// </summary>
public static Boolean IsDifferentFactFrom(RDFOntologyFact aFact, RDFOntologyFact bFact, RDFOntologyData data) {
return (aFact != null && bFact != null && data != null ? RDFOntologyReasoningHelper.EnlistDifferentFactsFrom(aFact, data).Facts.ContainsKey(bFact.PatternMemberID) : false);
}
/// <summary>
/// Checks if the given aFact is sameAs the given bFact within the given data
/// </summary>
public static Boolean IsSameFactAs(RDFOntologyFact aFact, RDFOntologyFact bFact, RDFOntologyData data) {
return (aFact != null && bFact != null && data != null ? RDFOntologyReasoningHelper.EnlistSameFactsAs(aFact, data).Facts.ContainsKey(bFact.PatternMemberID) : false);
}
/// <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 literals which are members of the given datarange within the given ontology
/// </summary>
internal static RDFOntologyData EnlistMembersOfDataRange(RDFOntologyDataRangeClass ontDataRangeClass, RDFOntology ontology) {
var result = new RDFOntologyData();
//Filter "oneOf" relations made with the given datarange class
var drTaxonomy = ontology.Model.ClassModel.Relations.OneOf.SelectEntriesBySubject(ontDataRangeClass);
foreach (var tEntry in drTaxonomy) {
//Add the literal
if (tEntry.TaxonomyObject.IsLiteral()) {
result.AddLiteral((RDFOntologyLiteral)tEntry.TaxonomyObject);
}
}
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>
/// Enlists the facts which are members of the given restriction within the given ontology
/// </summary>
internal static RDFOntologyData EnlistMembersOfRestriction(RDFOntologyRestriction ontRestriction, RDFOntology ontology) {
var result = new RDFOntologyData();
//Enlist the properties which are compatible with the restriction's "OnProperty"
var compProps = RDFOntologyReasoningHelper.EnlistSubPropertiesOf(ontRestriction.OnProperty, ontology.Model.PropertyModel)
.UnionWith(RDFOntologyReasoningHelper.EnlistEquivalentPropertiesOf(ontRestriction.OnProperty, ontology.Model.PropertyModel))
.AddProperty(ontRestriction.OnProperty);
//Filter assertions made with enlisted compatible properties
var fTaxonomy = new RDFOntologyTaxonomy();
foreach (var p in compProps) {
fTaxonomy = fTaxonomy.UnionWith(ontology.Data.Relations.Assertions.SelectEntriesByPredicate(p));
}
#region Cardinality
if (ontRestriction is RDFOntologyCardinalityRestriction) {
//Item2 is a counter for occurrences of the restricted property within the subject fact
var fCount = new Dictionary<Int64, Tuple<RDFOntologyFact, Int64>>();
//Iterate the compatible assertions
foreach (var tEntry in fTaxonomy) {
if (!fCount.ContainsKey(tEntry.TaxonomySubject.PatternMemberID)) {
fCount.Add(tEntry.TaxonomySubject.PatternMemberID, new Tuple<RDFOntologyFact, Int64>((RDFOntologyFact)tEntry.TaxonomySubject, 1));
}
else {
var occurrencyCounter = fCount[tEntry.TaxonomySubject.PatternMemberID].Item2;
fCount[tEntry.TaxonomySubject.PatternMemberID] = new Tuple<RDFOntologyFact, Int64>((RDFOntologyFact)tEntry.TaxonomySubject, occurrencyCounter + 1);
}
}
//Apply the cardinality restriction on the tracked facts
var fCountEnum = fCount.Values.GetEnumerator();
while (fCountEnum.MoveNext()) {
var passesMinCardinality = true;
var passesMaxCardinality = true;
//MinCardinality: signal tracked facts having "#occurrences < MinCardinality"
if (((RDFOntologyCardinalityRestriction)ontRestriction).MinCardinality > 0) {
if (fCountEnum.Current.Item2 < ((RDFOntologyCardinalityRestriction)ontRestriction).MinCardinality) {
passesMinCardinality = false;
}
}
//MaxCardinality: signal tracked facts having "#occurrences > MaxCardinality"
if (((RDFOntologyCardinalityRestriction)ontRestriction).MaxCardinality > 0) {
if (fCountEnum.Current.Item2 > ((RDFOntologyCardinalityRestriction)ontRestriction).MaxCardinality) {
passesMaxCardinality = false;
}
}
//Save the candidate fact if it passes cardinality restrictions
if (passesMinCardinality && passesMaxCardinality) {
result.AddFact(fCountEnum.Current.Item1);
}
}
}
#endregion
#region AllValuesFrom
else if (ontRestriction is RDFOntologyAllValuesFromRestriction) {
//Item2 is a counter for occurrences of the restricted property with a range member of the restricted "FromClass"
//Item3 is a counter for occurrences of the restricted property with a range member not of the restricted "FromClass"
var fCount = new Dictionary<Int64, Tuple<RDFOntologyFact, Int64, Int64>>();
//Enlist the classes which are compatible with the restricted "FromClass"
var compClasses = RDFOntologyReasoningHelper.EnlistSubClassesOf(((RDFOntologyAllValuesFromRestriction)ontRestriction).FromClass, ontology.Model.ClassModel)
.UnionWith(RDFOntologyReasoningHelper.EnlistEquivalentClassesOf(((RDFOntologyAllValuesFromRestriction)ontRestriction).FromClass, ontology.Model.ClassModel))
.AddClass(((RDFOntologyAllValuesFromRestriction)ontRestriction).FromClass);
//Iterate the compatible assertions
foreach (var tEntry in fTaxonomy) {
//Initialize the occurrence counters of the subject fact
if (!fCount.ContainsKey(tEntry.TaxonomySubject.PatternMemberID)) {
fCount.Add(tEntry.TaxonomySubject.PatternMemberID, new Tuple<RDFOntologyFact, Int64, Int64>((RDFOntologyFact)tEntry.TaxonomySubject, 0, 0));
}
//Iterate the class types of the object fact, checking presence of the restricted "FromClass"
var fromClassFound = false;
var objFactClassTypes = ontology.Data.Relations.ClassType.SelectEntriesBySubject(tEntry.TaxonomyObject);
foreach (var objFactClassType in objFactClassTypes) {
var compObjFactClassTypes = RDFOntologyReasoningHelper.EnlistSubClassesOf((RDFOntologyClass)objFactClassType.TaxonomyObject, ontology.Model.ClassModel)
.UnionWith(RDFOntologyReasoningHelper.EnlistEquivalentClassesOf((RDFOntologyClass)objFactClassType.TaxonomyObject, ontology.Model.ClassModel))
.AddClass((RDFOntologyClass)objFactClassType.TaxonomyObject);
if (compObjFactClassTypes.IntersectWith(compClasses).ClassesCount > 0) {
fromClassFound = true;
break;
}
}
//Update the occurrence counters of the subject fact
var equalityCounter = fCount[tEntry.TaxonomySubject.PatternMemberID].Item2;
var differenceCounter = fCount[tEntry.TaxonomySubject.PatternMemberID].Item3;
if (fromClassFound) {
fCount[tEntry.TaxonomySubject.PatternMemberID] = new Tuple<RDFOntologyFact, Int64, Int64>((RDFOntologyFact)tEntry.TaxonomySubject, equalityCounter + 1, differenceCounter);
}
else {
fCount[tEntry.TaxonomySubject.PatternMemberID] = new Tuple<RDFOntologyFact, Int64, Int64>((RDFOntologyFact)tEntry.TaxonomySubject, equalityCounter, differenceCounter + 1);
}
}
//Apply the restriction on the subject facts
var fCountEnum = fCount.Values.GetEnumerator();
while (fCountEnum.MoveNext()) {
if (fCountEnum.Current.Item2 >= 1 && fCountEnum.Current.Item3 == 0) {
result.AddFact(fCountEnum.Current.Item1);
}
}
}
#endregion
#region SomeValuesFrom
else if (ontRestriction is RDFOntologySomeValuesFromRestriction) {
//Item2 is a counter for occurrences of the restricted property with a range member of the restricted "FromClass"
//Item3 is a counter for occurrences of the restricted property with a range member not of the restricted "FromClass"
var fCount = new Dictionary<Int64, Tuple<RDFOntologyFact, Int64, Int64>>();
//Enlist the classes which are compatible with the restricted "FromClass"
var compClasses = RDFOntologyReasoningHelper.EnlistSubClassesOf(((RDFOntologySomeValuesFromRestriction)ontRestriction).FromClass, ontology.Model.ClassModel)
.UnionWith(RDFOntologyReasoningHelper.EnlistEquivalentClassesOf(((RDFOntologySomeValuesFromRestriction)ontRestriction).FromClass, ontology.Model.ClassModel))
.AddClass(((RDFOntologySomeValuesFromRestriction)ontRestriction).FromClass);
//Iterate the compatible assertions
foreach (var tEntry in fTaxonomy) {
//Initialize the occurrence counters of the subject fact
if (!fCount.ContainsKey(tEntry.TaxonomySubject.PatternMemberID)) {
fCount.Add(tEntry.TaxonomySubject.PatternMemberID, new Tuple<RDFOntologyFact, Int64, Int64>((RDFOntologyFact)tEntry.TaxonomySubject, 0, 0));
}
//Iterate the class types of the object fact, checking presence of the restricted "FromClass"
var fromClassFound = false;
var objFactClassTypes = ontology.Data.Relations.ClassType.SelectEntriesBySubject(tEntry.TaxonomyObject);
foreach (var objFactClassType in objFactClassTypes) {
var compObjFactClassTypes = RDFOntologyReasoningHelper.EnlistSubClassesOf((RDFOntologyClass)objFactClassType.TaxonomyObject, ontology.Model.ClassModel)
.UnionWith(RDFOntologyReasoningHelper.EnlistEquivalentClassesOf((RDFOntologyClass)objFactClassType.TaxonomyObject, ontology.Model.ClassModel))
.AddClass((RDFOntologyClass)objFactClassType.TaxonomyObject);
if (compObjFactClassTypes.IntersectWith(compClasses).ClassesCount > 0) {
fromClassFound = true;
break;
}
}
//Update the occurrence counters of the subject fact
var equalityCounter = fCount[tEntry.TaxonomySubject.PatternMemberID].Item2;
var differenceCounter = fCount[tEntry.TaxonomySubject.PatternMemberID].Item3;
if (fromClassFound) {
fCount[tEntry.TaxonomySubject.PatternMemberID] = new Tuple<RDFOntologyFact, Int64, Int64>((RDFOntologyFact)tEntry.TaxonomySubject, equalityCounter + 1, differenceCounter);
}
else {
fCount[tEntry.TaxonomySubject.PatternMemberID] = new Tuple<RDFOntologyFact, Int64, Int64>((RDFOntologyFact)tEntry.TaxonomySubject, equalityCounter, differenceCounter + 1);
}
}
//Apply the restriction on the subject facts
var fCountEnum = fCount.Values.GetEnumerator();
while (fCountEnum.MoveNext()) {
if (fCountEnum.Current.Item2 >= 1) {
result.AddFact(fCountEnum.Current.Item1);
}
}
}
#endregion
#region HasValue
else if (ontRestriction is RDFOntologyHasValueRestriction) {
if (((RDFOntologyHasValueRestriction)ontRestriction).RequiredValue.IsFact()) {
//Enlist the same facts of the restriction's "RequiredValue"
var compFacts = RDFOntologyReasoningHelper.EnlistSameFactsAs((RDFOntologyFact)((RDFOntologyHasValueRestriction)ontRestriction).RequiredValue, ontology.Data)
.AddFact((RDFOntologyFact)((RDFOntologyHasValueRestriction)ontRestriction).RequiredValue);
//Iterate the compatible assertions
foreach (var tEntry in fTaxonomy) {
if (tEntry.TaxonomyObject.IsFact()) {
if (compFacts.SelectFact(tEntry.TaxonomyObject.ToString()) != null) {
result.AddFact((RDFOntologyFact)tEntry.TaxonomyObject);
}
}
}
}
else if (((RDFOntologyHasValueRestriction)ontRestriction).RequiredValue.IsLiteral()) {
//Iterate the compatible assertions and track the occurrence informations
foreach (var tEntry in fTaxonomy) {
if (tEntry.TaxonomyObject.IsLiteral()) {
try {
var semanticLiteralsCompare = RDFQueryUtilities.CompareRDFPatternMembers(((RDFOntologyHasValueRestriction)ontRestriction).RequiredValue.Value, tEntry.TaxonomyObject.Value);
if (semanticLiteralsCompare == 0) {
result.AddFact((RDFOntologyFact)tEntry.TaxonomySubject);
}
}
finally { }
}
}
}
}
#endregion
return result;
}
/// <summary>
/// Gets an ontology data containing the facts which are members of this restriction
/// </summary>
public override RDFOntologyData EnlistMembers(RDFOntology ontology) {
var resultFacts = new RDFOntologyData();
if (ontology != null) {
//Retrieve ontology data facts having the restricted property in their attributes
var facts = base.EnlistMembers(ontology);
//Item2 is a counter for occurrences of the restricted property within the key fact
var factsRegister = new Dictionary<Int64, Tuple<RDFOntologyFact, Int64>>();
//Iterate the retrieved ontology data facts
foreach(var f in facts) {
//Iterate the ontology attributes of the current ontology fact
var factOntAttributesEnum = f.OntologyAttributesEnumerator();
while (factOntAttributesEnum.MoveNext()) {
if (factOntAttributesEnum.Current.AttributeProperty.Equals(this.OnProperty)) {
//Register the ontology data fact or update its property occurrence counter
if (!factsRegister.ContainsKey(f.PatternMemberID)) {
factsRegister.Add(f.PatternMemberID, new Tuple<RDFOntologyFact, Int64>(f, 1));
}
else {
Int64 actualCounter = factsRegister[f.PatternMemberID].Item2;
factsRegister[f.PatternMemberID] = new Tuple<RDFOntologyFact, Int64>(f, actualCounter + 1);
}
}
}
}
//Apply the cardinality restrictions on the candidate ontology facts
var factsRegEnum = factsRegister.Values.GetEnumerator();
while (factsRegEnum.MoveNext()) {
Boolean passesMinCardinality = true;
Boolean passesMaxCardinality = true;
//MinCardinality: signal candidate facts having "#occurrences < MinCardinality"
if (this.MinCardinality > 0) {
if (factsRegEnum.Current.Item2 < this.MinCardinality) {
passesMinCardinality = false;
}
}
//MaxCardinality: signal candidate facts having "#occurrences > MaxCardinality"
if (this.MaxCardinality > 0) {
if (factsRegEnum.Current.Item2 > this.MaxCardinality) {
passesMaxCardinality = false;
}
}
//Save the candidate fact if it passes cardinality restrictions
if (passesMinCardinality && passesMaxCardinality) {
resultFacts.AddFact(factsRegEnum.Current.Item1);
}
}
}
return resultFacts;
}
/// <summary>
/// Enlists the different facts of the given fact within the given data
/// </summary>
public static RDFOntologyData EnlistDifferentFactsFrom(RDFOntologyFact ontFact, RDFOntologyData data) {
var result = new RDFOntologyData();
if (ontFact != null && data != null) {
result = RDFSemanticsUtilities.EnlistDifferentFactsFrom_Core(ontFact, data, null).RemoveFact(ontFact);
}
return result;
}
/// <summary>
/// Enlists the facts which are members of the given class within the given ontology
/// </summary>
public static RDFOntologyData EnlistMembersOf(RDFOntologyClass ontClass, RDFOntology ontology) {
var result = new RDFOntologyData();
if (ontClass != null && ontology != null) {
//Restriction
if (ontClass.IsRestrictionClass()) {
result = RDFSemanticsUtilities.EnlistMembersOfRestriction((RDFOntologyRestriction)ontClass, ontology);
}
//Enumeration
else if (ontClass.IsEnumerateClass()) {
result = RDFSemanticsUtilities.EnlistMembersOfEnumerate((RDFOntologyEnumerateClass)ontClass, ontology);
}
//DataRange
else if (ontClass.IsDataRangeClass()) {
result = RDFSemanticsUtilities.EnlistMembersOfDataRange((RDFOntologyDataRangeClass)ontClass, ontology);
}
//Composite
else if (ontClass.IsCompositeClass()) {
result = RDFSemanticsUtilities.EnlistMembersOfComposite(ontClass, ontology);
}
//SimpleClass
else {
result = RDFSemanticsUtilities.EnlistMembersOfClass(ontClass, ontology);
}
}
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>
/// 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;
}
