Refine search
@Override protected boolean doEquivalent(Statement a, Statement b) { if(a == b) return true; if(!Objects.equal(a.getSubject(), b.getSubject())) return false; if(!Objects.equal(a.getPredicate(), b.getPredicate())) return false; if(!Objects.equal(a.getObject(), b.getObject())) return false; return true; }
public static void printStatements(final Iterable<Statement> statements) { System.out.println("=================================================="); System.out.println("Statements: "); System.out.println(); for(final Statement nextStatement : statements) { System.out.println(" {" + nextStatement.getSubject() + "} <" + nextStatement.getPredicate() + "> {" + nextStatement.getObject() + "}"); } System.out.println("=================================================="); }
public void cacheStatement(Statement stmt) { Map<Resource, List<Statement>> cache = _statements.get(); if (cache == null) return; Resource subj = stmt.getSubject(); Value obj = stmt.getObject(); Resource key = getCarriedOverResource(subj, obj); List<Statement> list = cache.get(key); if (list == null) cache.put(key, list = new ArrayList<Statement>()); list.add(stmt); }
/** * Checks whether a Statement matches a pattern of subject, predicate * and object that has been specified for removal of the concerning * statements. The pattern can contain null values to indicate wild cards. **/ protected boolean _matchesForRemoval(Statement st, Resource subj, URI pred, Value obj) { return (subj == null || subj.equals(st.getSubject())) && (pred == null || pred.equals(st.getPredicate())) && ( obj == null || obj.equals(st.getObject())); }
@Override public Vertex getVertex(final Direction dir) throws IllegalArgumentException { if (log.isInfoEnabled()) log.info("("+dir+")"); if (dir == Direction.BOTH) { throw new IllegalArgumentException(); } final URI uri = (URI) (dir == Direction.OUT ? stmt.getSubject() : stmt.getObject()); final String id = graph.factory.fromURI(uri); return graph.getVertex(id); }
/** * Convert a unit of RDF data to an atomic unit of PG data. */ protected BigdataGraphAtom toGraphAtom(final Statement stmt) { final URI s = (URI) stmt.getSubject(); final URI p = (URI) stmt.getPredicate(); final Value o = stmt.getObject(); return toGraphAtom(s, p, o); }
@Override public boolean hasStatement(final Statement s, final boolean includeInferred, final Resource... c) throws RepositoryException { return hasStatement(s.getSubject(), s.getPredicate(), s.getObject(), includeInferred, c); }
public boolean hasStatement(Statement st, boolean inf, Resource... contexts) throws RepositoryException { return hasStatement(st.getSubject(), st.getPredicate(), st.getObject(), inf, contexts); }
@Override public int compare(Statement o1, Statement o2) { if (!o1.getSubject().equals(o2.getSubject())) { return compare(o1.getSubject(), o2.getSubject()); } else if (!o1.getPredicate().equals(o2.getPredicate())) { return compare(o1.getPredicate(), o2.getPredicate()); } else { return compare(o1.getObject(), o2.getObject()); } }
@Override public int compare(Statement o1, Statement o2) { if (!o1.getSubject().equals(o2.getSubject())){ return compare(o1.getSubject(), o2.getSubject()); }else if (!o1.getPredicate().equals(o2.getPredicate())){ return compare(o1.getPredicate(), o2.getPredicate()); }else{ return compare(o1.getObject(), o2.getObject()); } }
@Override public final boolean contains(@Nullable final Object object) { if (object instanceof Statement) { final Statement stmt = (Statement) object; return doIterator(stmt.getSubject(), stmt.getPredicate(), stmt.getObject(), new Resource[] { stmt.getContext() }).hasNext(); } return false; }
void remove(ContextAwareConnection conn, Statement stmt) throws RepositoryException { assert stmt.getPredicate().equals(getURI()); remove(conn, stmt.getSubject(), stmt.getObject()); }
private void setDatatype(ValueFactory vf, URI pred, URI datatype) { for (Statement stmt : ds.match(null, pred, null)) { String label = ((Literal) stmt.getObject()).getLabel(); Literal literal = vf.createLiteral(label, datatype); ds.remove(stmt.getSubject(), pred, stmt.getObject()); ds.add(stmt.getSubject(), pred, literal); } }
public boolean equals(Object otherStmt) { if(this==otherStmt) { return true; }else if(otherStmt instanceof Statement) { Statement other=(Statement)otherStmt; return this.getSubject().equals(other.getSubject())&& this.getPredicate().equals(other.getPredicate())&& this.getObject().equals(other.getObject()); }else { return false; } }
void remove(ObjectConnection conn, Statement stmt) throws RepositoryException { assert stmt.getPredicate().equals(getURI()); remove(conn, stmt.getSubject(), stmt.getObject()); }
@Override public final boolean remove(@Nullable final Object object) { if (object instanceof Statement) { final Statement stmt = (Statement) object; return doRemove(stmt.getSubject(), stmt.getPredicate(), stmt.getObject(), new Resource[] { stmt.getContext() }); } return false; }
@Override public boolean remove(Object o) { if (o instanceof Statement) { Statement st = (Statement)o; return remove(st.getSubject(), st.getPredicate(), st.getObject(), st.getContext()); } return false; }
private Iterator find(Statement st) { Resource subj = st.getSubject(); IRI pred = st.getPredicate(); Value obj = st.getObject(); Resource ctx = st.getContext(); return matchPattern(subj, pred, obj, ctx); }
@Override public boolean remove(Object o) { if (o instanceof Statement) { Statement st = (Statement) o; return remove(st.getSubject(), st.getPredicate(), st.getObject(), st.getContext()); } return false; }
public static void printRepository(SailRepository nr) throws RepositoryException{ RepositoryResult<Statement> rr = nr.getConnection().getStatements((Resource)null, null, null, false, (Resource)null); List<Statement> rl = rr.asList(); for(Statement s : rl){ System.out.println( s.getSubject().toString()+" ----( "+ s.getPredicate().toString()+" )---> "+ s.getObject().toString()); } } }