@Override public VariableOnlyDataAtom getVariableOnlyDataAtom(AtomPredicate predicate, ImmutableList<Variable> arguments) { if (areVariablesDistinct(arguments)) { return new DistinctVariableOnlyDataAtomImpl(predicate, arguments); } else { return new VariableOnlyDataAtomImpl(predicate, arguments); } }
@Override public DataAtom<AtomPredicate> getIntensionalTripleAtom(VariableOrGroundTerm subject, IRI classIRI) { // TODO: in the future, constants will be for IRIs in intensional data atoms return getIntensionalTripleAtom(subject, RDF.TYPE, convertIRIIntoGroundFunctionalTerm(classIRI)); }
@Override public DataAtom<AtomPredicate> getIntensionalTripleAtom(VariableOrGroundTerm subject, VariableOrGroundTerm property, VariableOrGroundTerm object) { return getDataAtom(triplePredicate, subject, property, object); }
@Override public DataAtom getDataAtom(AtomPredicate predicate, ImmutableList<? extends VariableOrGroundTerm> arguments) { /** * NB: A GroundDataAtom is a DistinctVariableDataAtom */ if(areVariablesDistinct(arguments)) { return getDistinctVariableDataAtom(predicate, arguments); } else if (isVariableOnly(arguments)) { return new VariableOnlyDataAtomImpl(predicate, (ImmutableList<Variable>)(ImmutableList<?>)arguments); } else { return new DataAtomImpl(predicate, arguments); } }
@Override public DistinctVariableDataAtom getDistinctVariableDataAtom(AtomPredicate predicate, ImmutableList<? extends VariableOrGroundTerm> arguments) { if (isVariableOnly(arguments)) { return new DistinctVariableOnlyDataAtomImpl(predicate, (ImmutableList<Variable>)(ImmutableList<?>)arguments); } else if (GroundTermTools.areGroundTerms(arguments)) { return new GroundDataAtomImpl(predicate, (ImmutableList<GroundTerm>)(ImmutableList<?>)arguments); } else { return new NonGroundDistinctVariableDataAtomImpl(predicate, arguments); } }
@Override public Function getMutableTripleHeadAtom(Term subject, IRI propertyIRI, Term object) { return getMutableTripleAtom( subject, convertIRIIntoFunction(propertyIRI), object); }
@Override public TargetAtom getTripleTargetAtom(ImmutableTerm subjectTerm, IRI classIRI) { return getTripleTargetAtom(subjectTerm, createGroundFunctionalTerm(RDF.TYPE), createGroundFunctionalTerm(classIRI)); }
@Override public Function getMutableTripleBodyAtom(Term subject, IRI classIRI) { // At the moment, no distinction between body and head atoms (this will change) return getMutableTripleHeadAtom(subject, classIRI); }
@Override public DistinctVariableOnlyDataAtom getDistinctQuadAtom(Variable subject, Variable property, Variable object, Variable namedGraph) { return getDistinctVariableOnlyDataAtom(quadPredicate, subject, property, object, namedGraph); } }
@Override public ImmutableList<Variable> getArguments() { return (ImmutableList<Variable>)super.getArguments(); } }
@Override public TargetAtom getTargetAtom(DistinctVariableOnlyDataAtom projectionAtom, ImmutableSubstitution<ImmutableTerm> substitution) { return new TargetAtomImpl(projectionAtom, substitution); }
@Override public DistinctVariableOnlyDataAtom getDistinctVariableOnlyDataAtom(AtomPredicate predicate, ImmutableList<Variable> arguments) { return new DistinctVariableOnlyDataAtomImpl(predicate, arguments); }
@Override public Variable getTerm(int index) { return (Variable) super.getTerm(index); }
@Override public DataAtom<AtomPredicate> getIntensionalTripleAtom(VariableOrGroundTerm subject, IRI propertyIRI, VariableOrGroundTerm object) { // TODO: in the future, constants will be for IRIs in intensional data atoms return getIntensionalTripleAtom(subject, convertIRIIntoGroundFunctionalTerm(propertyIRI), object); }
@Override public Function getMutableTripleHeadAtom(Term subject, IRI classIRI) { return getMutableTripleAtom( subject, convertIRIIntoFunction(RDF.TYPE), convertIRIIntoFunction(classIRI)); }
@Override public Function getMutableTripleBodyAtom(Term subject, IRI propertyIRI, Term object) { // At the moment, no distinction between body and head atoms (this will change) return getMutableTripleHeadAtom(subject, propertyIRI, object); }
@Override public DistinctVariableOnlyDataAtom getDistinctTripleAtom(Variable subject, Variable property, Variable object) { return getDistinctVariableOnlyDataAtom(triplePredicate, subject, property, object); }
@Override public ImmutableList<? extends GroundTerm> getArguments() { return (ImmutableList<? extends GroundTerm>)super.getArguments(); } }
@Override public TargetAtom changeSubstitution(ImmutableSubstitution<ImmutableTerm> newSubstitution) { return new TargetAtomImpl(atom, newSubstitution); }
@Override public DistinctVariableOnlyDataAtom getDistinctVariableOnlyDataAtom(AtomPredicate predicate, ImmutableList<Variable> arguments) { return new DistinctVariableOnlyDataAtomImpl(predicate, arguments); }