public IrisDtgWriter(Writer out) { super(out, DefaultAtomFactory.instance()); }
public DlgpWriter(Writer out) { super(out, DefaultAtomFactory.instance()); this.pm = new PrefixManager(); }
protected DefaultConjunctiveQueryFactory() { super(); BOOLEAN_BOTTOM_QUERY = this.create( DefaultAtomFactory.instance().create(Predicate.BOTTOM, DefaultTermFactory.instance().createVariable("X")), Collections.<Term>emptyList()); }
public static Atom triple2Atom(Triple triple) { Node subject = triple.getSubject(); Node object = triple.getObject(); Node predicate = triple.getPredicate(); if (predicate.getURI().equals(URIUtils.RDF_TYPE.toString())) { return DefaultAtomFactory.instance().create(node2Predicate(object, 1), node2Term(subject)); } else { return DefaultAtomFactory.instance().create(node2Predicate(predicate, 2), node2Term(subject), node2Term(object)); } }
@Override public Atom unmap(Atom atom) { return DefaultAtomFactory.instance().create(this.unmap(atom.getPredicate()), atom.getTerms()); }
@Override public Atom map(Atom atom) { return DefaultAtomFactory.instance().create(this.map(atom.getPredicate()), atom.getTerms()); }
public static boolean isNegativeConstraint(Rule r) { if (!AtomSetUtils.isSingleton(r.getHead())) return false; return r.getHead().iterator().next().equals(DefaultAtomFactory.instance().getBottom()); }
@Override public Atom next() throws IteratorException { BindingSet bs = this.it.next(); Term[] terms = new Term[atom.getTerms().size()]; int i = 0; for(Term t : atom) { if(t.isVariable()) { terms[i] = utils.valueToTerm(bs.getValue(t.getLabel())); } else { terms[i] = t; } ++i; } return DefaultAtomFactory.instance().create(atom.getPredicate(), terms); }
@Override public CloseableIterator<Atom> atomsByPredicate(Predicate p) throws AtomSetException { List<Term> terms = new LinkedList<Term>(); for (int i = 0; i < p.getArity(); ++i) { terms.add(DefaultTermFactory.instance().createVariable("X" + i)); } Atom atom = DefaultAtomFactory.instance().create(p, terms); ConjunctiveQuery query = DefaultConjunctiveQueryFactory.instance().create(new LinkedListAtomSet(atom)); SqlHomomorphism solver = SqlHomomorphism.instance(); try { return new SubstitutionIterator2AtomIterator(atom, solver.execute(query, this)); } catch (HomomorphismException e) { throw new AtomSetException(e); } }
@Override public CloseableIterator<Atom> atomsByPredicate(Predicate p) throws AtomSetException { if (!this.check(p)) { return Iterators.<Atom> emptyIterator(); } List<Term> terms = new LinkedList<Term>(); for (int i = 0; i < p.getArity(); ++i) { terms.add(DefaultTermFactory.instance().createVariable("X" + i)); } Atom atom = DefaultAtomFactory.instance().create(p, terms); ConjunctiveQuery query = DefaultConjunctiveQueryFactory.instance().create(new LinkedListAtomSet(atom)); SqlHomomorphism solver = SqlHomomorphism.instance(); try { return new SubstitutionIterator2AtomIterator(atom, solver.execute(query, this)); } catch (HomomorphismException e) { throw new AtomSetException(e); } }
/** * This method returns an atom like <Concept>(<individual>) if the specified atom is like rdf:type(<individual>, <Concept>). * Otherwise, it returns the specified atom itself. * * @param atom * any atom * @return a corresponding atom. It returns an atom like * <Concept>(<individual>) if the specfied atom is like * rdf:type(<individual>, <Concept>). Otherwise, it returns the * specified an atom like rdf:type(<individual>, <Concept>) to <Concept>(<individual>)atom itself. */ @Override public Atom map(Atom atom) { if (rdfTypePredicate.equals(atom.getPredicate())) { return DefaultAtomFactory.instance().create(new Predicate(atom.getTerm(1).getIdentifier(), 1), atom.getTerm(0)); } return atom; }
} else { Predicate predicate = new Predicate("aux_" + ++auxIndex, rule.getTerms().size()); Atom aux = DefaultAtomFactory.instance().create(predicate, rule.getTerms().toArray(new Term[rule.getTerms().size()]));
/** * This method is the reverse method of map, it returns an atom like rdf:type(<individual>, <Concept>) if the specified atom is like <Concept>(<individual>). * Otherwise, it returns the specified atom itself. * * @param atom * any atom * @return a corresponding atom. It returns an atom like * rdf:type(<individual>, <Concept>) if the specfied atom is like * <Concept>(<individual>). Otherwise, it returns the * specified an atom like rdf:type(<individual>, <Concept>) to <Concept>(<individual>)atom itself. */ @Override public Atom unmap(Atom atom) { if (atom.getPredicate().getArity() == 1) { return DefaultAtomFactory.instance().create(rdfTypePredicate, atom.getTerm(0), DefaultTermFactory.instance().createConstant(atom.getPredicate().getIdentifier())); } return atom; }