/// <summary>
/// Default-ctor to build an "owl:HasValue" ontology restriction with the given name on the given property and the given required value
/// </summary>
public RDFOntologyHasValueRestriction(RDFResource restrictionName, RDFOntologyProperty onProperty, RDFOntologyLiteral requiredValue) : base(restrictionName, onProperty)
{
if (requiredValue != null)
{
this.RequiredValue = requiredValue;
}
else
{
throw new RDFSemanticsException("Cannot create RDFOntologyHasValueRestriction because given \"requiredValue\" parameter is null.");
}
}
/// <summary>
/// Adds the given resource to the describe terms of the query
/// </summary>
public RDFDescribeQuery AddDescribeTerm(RDFResource describeTerm)
{
if (describeTerm != null)
{
if (!this.DescribeTerms.Any(dt => dt.Equals(describeTerm)))
{
this.DescribeTerms.Add(describeTerm);
}
}
return(this);
}
/// <summary>
/// Selects the quadruples indexed by the given object
/// </summary>
internal HashSet <Int64> SelectIndexByObject(RDFResource objectResource)
{
if (objectResource != null)
{
if (this.Objects.ContainsKey(objectResource.PatternMemberID))
{
return(this.Objects[objectResource.PatternMemberID]);
}
}
return(new HashSet <Int64>());
}
/// <summary>
/// Selects the quadruples indexed by the given subject
/// </summary>
internal HashSet <long> SelectIndexBySubject(RDFResource subjectResource)
{
if (subjectResource != null)
{
if (this.Subjects.ContainsKey(subjectResource.PatternMemberID))
{
return(this.Subjects[subjectResource.PatternMemberID]);
}
}
return(new HashSet <long>());
}
/// <summary>
/// Default-ctor to build a step of a property path
/// </summary>
public RDFPropertyPathStep(RDFResource stepProperty)
{
if (stepProperty != null)
{
this.StepProperty = stepProperty;
}
else
{
throw new RDFQueryException("Cannot create RDFPropertyPathStep because given \"stepProperty\" parameter is null.");
}
}
/// <summary>
/// Selects the quadruples indexed by the given predicate
/// </summary>
internal HashSet <Int64> SelectIndexByPredicate(RDFResource predicateResource)
{
if (predicateResource != null)
{
if (this.Predicates.ContainsKey(predicateResource.PatternMemberID))
{
return(this.Predicates[predicateResource.PatternMemberID]);
}
}
return(new HashSet <Int64>());
}
public void AddQuadrupleLiteral(string contextUri, string subjUri, string predUri, string literalValue)
{
RDFContext context = new RDFContext(contextUri);
RDFResource subj = new RDFResource(subjUri);
RDFResource pred = new RDFResource(predUri);
RDFLiteral lit = new RDFPlainLiteral(literalValue);
RDFQuadruple quadruple = new RDFQuadruple(context, subj, pred, lit);
Store.AddQuadruple(quadruple);
}
/// <summary>
/// Default-ctor to build a subjectsOf target on the given property
/// </summary>
public RDFTargetSubjectsOf(RDFResource targetProperty) : base()
{
if (targetProperty != null)
{
this.TargetValue = targetProperty;
}
else
{
throw new RDFModelException("Cannot create RDFTargetSubjectsOf because given \"targetProperty\" parameter is null.");
}
}
public void AddQuadrupleObject(string contextUri, string subjUri, string predUri, string objectUri)
{
RDFContext context = new RDFContext(contextUri);
RDFResource subj = new RDFResource(subjUri);
RDFResource pred = new RDFResource(predUri);
RDFResource obj = new RDFResource(objectUri);
RDFQuadruple quadruple = new RDFQuadruple(context, subj, pred, obj);
Store.AddQuadruple(quadruple);
}
/// <summary>
/// Default-ctor to build an ontology complement class of the given class and with the given name
/// </summary>
public RDFOntologyComplementClass(RDFResource className, RDFOntologyClass complementOf) : base(className)
{
if (complementOf != null)
{
this.ComplementOf = complementOf;
}
else
{
throw new RDFSemanticsException("Cannot create RDFOntologyComplementClass because given \"complementOf\" parameter is null.");
}
}
/// <summary>
/// Default-ctor to build a node target on the given resource
/// </summary>
public RDFTargetNode(RDFResource targetResource) : base()
{
if (targetResource != null)
{
this.TargetValue = targetResource;
}
else
{
throw new RDFModelException("Cannot create RDFTargetNode because given \"targetNode\" parameter is null.");
}
}
/// <summary>
/// Default-ctor to build a class target on the given resource
/// </summary>
public RDFTargetClass(RDFResource targetClass) : base()
{
if (targetClass != null)
{
this.TargetValue = targetClass;
}
else
{
throw new RDFModelException("Cannot create RDFTargetClass because given \"targetClass\" parameter is null.");
}
}
public static void RemoveResourceItemTest()
{
var container = new RDFContainer(RDFModelEnums.RDFContainerTypes.Alt, RDFModelEnums.RDFItemTypes.Resource);
var resource = new RDFResource("https://www.index.hu");
container.AddItem(resource);
container.RemoveItem(resource);
Assert.Equal(0, container.ItemsCount);
}
/// <summary>
/// Default-ctor to build an ontology class with the given name and type=OWL
/// </summary>
public RDFOntologyClass(RDFResource className)
{
if (className != null)
{
this.Value = className;
this.PatternMemberID = className.PatternMemberID;
}
else
{
throw new RDFSemanticsException("Cannot create RDFOntologyClass because given \"className\" parameter is null.");
}
}
/// <summary>
/// Removes the quadruples with the given (non-blank) predicate
/// </summary>
public override RDFStore RemoveQuadruplesByPredicate(RDFResource predicateResource)
{
if (predicateResource != null && !predicateResource.IsBlank)
{
foreach (var quadruple in this.SelectQuadruplesByPredicate(predicateResource))
{
this.Quadruples.Remove(quadruple.QuadrupleID);
this.StoreIndex.RemoveIndex(quadruple);
}
}
return(this);
}
private void BuildGraph(RDFGraph graph, int count)
{
RDFResource tempObject1 = new RDFResource(string.Concat(RDF.BASE_URI, "example_object_1"));
RDFResource tempObject2 = new RDFResource(string.Concat(RDF.BASE_URI, "example_object_2"));
for (int i = 0; i < count; i++)
{
RDFResource newSubject = new RDFResource(string.Concat(RDF.BASE_URI, "example_subject_" + i));
RDFResource newObject = (count < 30) ? tempObject1 : tempObject2;
graph.AddTriple(new RDFTriple(newSubject, RDF.TYPE, newObject));
}
}
/// <summary>
/// Default-ctor to build an ontology fact with the given name
/// </summary>
public RDFOntologyFact(RDFResource factName)
{
if (factName != null)
{
this.Value = factName;
this.PatternMemberID = factName.PatternMemberID;
}
else
{
throw new RDFSemanticsException("Cannot create RDFOntologyFact because given \"factName\" parameter is null.");
}
}
/// <summary>
/// Removes the quadruples with the given resource as object
/// </summary>
public override RDFStore RemoveQuadruplesByObject(RDFResource objectResource)
{
if (objectResource != null)
{
foreach (var quadruple in this.SelectQuadruplesByObject(objectResource))
{
this.Quadruples.Remove(quadruple.QuadrupleID);
this.StoreIndex.RemoveIndex(quadruple);
}
}
return(this);
}
public RDFSharpBenchmark()
{
this.monaLisa = new RDFResource("http://www.wikidata.org/entity/Q12418");
this.creator = new RDFResource("http://purl.org/dc/terms/creator");
this.title = new RDFResource("http://purl.org/dc/terms/title");
this.leonardoDaVinci = new RDFResource("http://dbpedia.org/resource/Leonardo_da_Vinci");
FileStream fs = File.OpenRead(@"../../../../../../..//TestData/szepmuveszeti.n3");
this.museumGraph = RDFGraph.FromStream(RDFModelEnums.RDFFormats.Turtle, fs);
this.monaLisaCreator = new RDFTriple(this.monaLisa, this.creator, this.leonardoDaVinci);
this.monaLisaTitle = new RDFPlainLiteral("Mona Lisa");
}
/// <summary>
/// Default-ctor to build an "owl:AllValuesFrom" ontology restriction with the given name on the given property and the given fromClass
/// </summary>
public RDFOntologyAllValuesFromRestriction(RDFResource restrictionName,
RDFOntologyProperty onProperty,
RDFOntologyClass fromClass) : base(restrictionName, onProperty)
{
if (fromClass != null)
{
this.FromClass = fromClass;
}
else
{
throw new RDFSemanticsException("Cannot create RDFOntologyAllValuesFromRestriction because given \"fromClass\" parameter is null.");
}
}
/// <summary>
/// Default-ctor to build an ontology class with the given name and nature
/// </summary>
public RDFOntologyClass(RDFResource className, RDFSemanticsEnums.RDFOntologyClassNature nature = RDFSemanticsEnums.RDFOntologyClassNature.OWL)
{
if (className != null)
{
this.Value = className;
this.Nature = nature;
this.SetLazyPatternMemberID();
}
else
{
throw new RDFSemanticsException("Cannot create RDFOntologyClass because given \"className\" parameter is null.");
}
}
public static void ClearItemsTest()
{
var collection = new RDFCollection(RDFModelEnums.RDFItemTypes.Resource);
var resource1 = new RDFResource("https://www.index.hu");
var resource2 = new RDFResource("https://www.google.com");
collection.AddItem(resource1);
collection.AddItem(resource2);
collection.ClearItems();
Assert.Equal(RDFVocabulary.RDF.NIL, collection.ReificationSubject);
Assert.Equal(0, collection.ItemsCount);
}
public void CreateTriplePatternTest()
{
//Arrange
var x = new RDFVariable("x");
var y = new RDFVariable("y");
var dogOf = new RDFResource(RDFVocabulary.DC.BASE_URI + "dogOf");
//Act
var y_dogOf_x = new RDFPattern(y, dogOf, x);
//Assert
Assert.Equal(x, y_dogOf_x.Object);
}
/// <summary>
/// Selects the quadruples indexed by the given predicate
/// </summary>
internal Dictionary <Int64, Object> SelectIndexByPredicate(RDFResource predicateResource)
{
var result = new Dictionary <Int64, Object>();
if (predicateResource != null)
{
if (this.Predicates.ContainsKey(predicateResource.PatternMemberID))
{
result = this.Predicates[predicateResource.PatternMemberID];
}
}
return(result);
}
/// <summary>
/// Selects the quadruples indexed by the given object
/// </summary>
internal Dictionary <Int64, Object> SelectIndexByObject(RDFResource objectResource)
{
var result = new Dictionary <Int64, Object>();
if (objectResource != null)
{
if (this.Objects.ContainsKey(objectResource.PatternMemberID))
{
result = this.Objects[objectResource.PatternMemberID];
}
}
return(result);
}
/// <summary>
/// Removes the quadruples with the given resource as object
/// </summary>
public override RDFStore RemoveQuadruplesByObject(RDFResource objectResource)
{
if (objectResource != null)
{
foreach (RDFQuadruple quad in this.SelectQuadruplesByObject(objectResource))
{
//Remove quadruple
this.Quadruples.Remove(quad.QuadrupleID);
//Remove index
this.StoreIndex.RemoveIndex(quad);
}
}
return(this);
}
/// <summary>
/// Default-ctor to build an ontology cardinality restriction with the given name on the given property
/// </summary>
public RDFOntologyCardinalityRestriction(RDFResource restrictionName,
RDFOntologyProperty onProperty,
int minCardinality,
int maxCardinality) : base(restrictionName, onProperty)
{
//MinCardinality
if (minCardinality > 0)
{
if (maxCardinality > 0)
{
if (minCardinality <= maxCardinality)
{
this.MinCardinality = minCardinality;
}
else
{
throw new RDFSemanticsException("Cannot create RDFOntologyCardinalityRestriction because given \"minCardinality\" parameter (" + minCardinality + ") must be less or equal than given \"maxCardinality\" parameter (" + maxCardinality + ")");
}
}
else
{
this.MinCardinality = minCardinality;
}
}
//MaxCardinality
if (maxCardinality > 0)
{
if (minCardinality > 0)
{
if (maxCardinality >= minCardinality)
{
this.MaxCardinality = maxCardinality;
}
else
{
throw new RDFSemanticsException("Cannot create RDFOntologyCardinalityRestriction because given \"maxCardinality\" parameter (" + maxCardinality + ") must be greater or equal than given \"minCardinality\" parameter (" + minCardinality + ")");
}
}
else
{
this.MaxCardinality = maxCardinality;
}
}
if (this.MinCardinality == 0 && this.MaxCardinality == 0)
{
throw new RDFSemanticsException("Cannot create RDFOntologyCardinalityRestriction because at least one of the given \"minCardinality\" and \"maxCardinality\" parameters must be greater than 0.");
}
}
/// <summary>
/// Removes the quadruples with the given predicate
/// </summary>
public override RDFStore RemoveQuadruplesByPredicate(RDFResource predicateResource)
{
if (predicateResource != null)
{
foreach (var quad in this.SelectQuadruplesByPredicate(predicateResource))
{
//Remove quadruple
this.Quadruples.Remove(quad.QuadrupleID);
//Remove index
this.StoreIndex.RemoveIndex(quad);
}
}
return(this);
}
public void CreateQuadruplePatternTest()
{
//Arrange
var x = new RDFVariable("x");
var y = new RDFVariable("y");
var n = new RDFVariable("n");
var dogOf = new RDFResource(RDFVocabulary.DC.BASE_URI + "dogOf");
//Act
var n_y_dogOf_x = new RDFPattern(n, y, dogOf, x);
//Assert
Assert.Equal(y, n_y_dogOf_x.Subject);
}
public static void RemoveResourceItemTest_NotSameObject()
{
var collection = new RDFCollection(RDFModelEnums.RDFItemTypes.Resource);
var resource1 = new RDFResource("https://www.index.hu");
collection.AddItem(resource1);
// Not the same object but their are equals
var resource2 = new RDFResource("https://www.index.hu");
collection.RemoveItem(resource2);
Assert.Equal(RDFVocabulary.RDF.NIL, collection.ReificationSubject);
Assert.Equal(0, collection.ItemsCount);
}
