/// <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 representation of this collection
/// </summary>
public RDFOntologyData ToRDFOntologyData()
{
var result = new RDFOntologyData();
//OrderedCollection
result.AddFact(this);
result.AddClassTypeRelation(this, RDFVocabulary.SKOS.ORDERED_COLLECTION.ToRDFOntologyClass());
result.AddAssertionRelation(this, RDFVocabulary.SKOS.MEMBER_LIST.ToRDFOntologyObjectProperty(), this.Representative);
//Representative
result.AddFact(this.Representative);
//Concepts
var reifSubj = new RDFOntologyFact((RDFResource)this.Representative.Value);
if (this.ConceptsCount == 0)
{
result.Relations.ClassType.AddEntry(new RDFOntologyTaxonomyEntry(reifSubj, RDFVocabulary.RDF.TYPE.ToRDFOntologyObjectProperty(), RDFVocabulary.RDF.LIST.ToRDFOntologyClass()));
result.Relations.Assertions.AddEntry(new RDFOntologyTaxonomyEntry(reifSubj, RDFVocabulary.RDF.FIRST.ToRDFOntologyObjectProperty(), RDFVocabulary.RDF.NIL.ToRDFOntologyFact()));
result.Relations.Assertions.AddEntry(new RDFOntologyTaxonomyEntry(reifSubj, RDFVocabulary.RDF.REST.ToRDFOntologyObjectProperty(), RDFVocabulary.RDF.NIL.ToRDFOntologyFact()));
}
else
{
var itemCounter = 0;
var conceptsEnum = this.ConceptsEnumerator;
while (conceptsEnum.MoveNext())
{
result.AddFact(conceptsEnum.Current.Item2);
result.AddClassTypeRelation(conceptsEnum.Current.Item2, RDFVocabulary.SKOS.CONCEPT.ToRDFOntologyClass());
//first
result.Relations.ClassType.AddEntry(new RDFOntologyTaxonomyEntry(reifSubj, RDFVocabulary.RDF.TYPE.ToRDFOntologyObjectProperty(), RDFVocabulary.RDF.LIST.ToRDFOntologyClass()));
result.Relations.Assertions.AddEntry(new RDFOntologyTaxonomyEntry(reifSubj, RDFVocabulary.RDF.FIRST.ToRDFOntologyObjectProperty(), conceptsEnum.Current.Item2));
//rest
itemCounter++;
if (itemCounter < this.ConceptsCount)
{
var newReifSubj = new RDFOntologyFact(new RDFResource());
result.Relations.Assertions.AddEntry(new RDFOntologyTaxonomyEntry(reifSubj, RDFVocabulary.RDF.REST.ToRDFOntologyObjectProperty(), newReifSubj));
reifSubj = newReifSubj;
}
else
{
result.Relations.Assertions.AddEntry(new RDFOntologyTaxonomyEntry(reifSubj, RDFVocabulary.RDF.REST.ToRDFOntologyObjectProperty(), RDFVocabulary.RDF.NIL.ToRDFOntologyFact()));
}
}
}
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);
//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 representation of this collection
/// </summary>
public RDFOntologyData ToRDFOntologyData()
{
RDFOntologyData result = new RDFOntologyData();
//OrderedCollection
result.AddFact(this);
result.AddClassTypeRelation(this, RDFVocabulary.SKOS.ORDERED_COLLECTION.ToRDFOntologyClass());
//Concepts
foreach (RDFSKOSConcept cn in this.GetMembers())
{
result.AddFact(cn);
result.AddClassTypeRelation(cn, RDFVocabulary.SKOS.CONCEPT.ToRDFOntologyClass());
result.AddMemberListRelation(this, cn);
}
return(result);
}
/// <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 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>
/// 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>
/// 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>
/// 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>
/// 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>
/// 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;
}
