@SuppressWarnings("unchecked") public CloseableIterator<STMT> findStatements(@Nullable ID subject, @Nullable UID predicate, @Nullable NODE object, @Nullable UID context, boolean includeInferred) { Iterator<STMT> iterator = null; if (subject != null) { iterator = getIndexed(subject, predicate, subjects); } else if (objects != null && object != null && object.isResource()) { iterator = getIndexed(object.asResource(), predicate, objects); } else { List<Iterator<STMT>> iterators = Lists.newArrayList(); for (PredicateCache stmtCache : subjects.values()) { iterators.add(stmtCache.iterator(predicate)); } iterator = Iterators.concat(iterators.toArray(new Iterator[iterators.size()])); } return new ResultIterator(iterator, subject, predicate, object, context, includeInferred); }
public void remove(@Nullable ID subject, @Nullable UID predicate, @Nullable NODE object, @Nullable UID context) { // remove all if (subject == null && predicate == null && object == null && context == null) { subjects.clear(); if (objects != null) { objects.clear(); } // subject given } else if (subject != null) { PredicateCache cache = subjects.get(subject); if (cache != null) { Iterator<STMT> stmts = cache.iterator(predicate); removeStatements(IteratorAdapter.asList(stmts)); } // object given } else if (object != null && object.isResource() && objects != null) { PredicateCache cache = objects.get(object.asResource()); if (cache != null) { Iterator<STMT> stmts = cache.iterator(predicate); removeStatements(IteratorAdapter.asList(stmts)); } // predicate or context given } else { for (Map.Entry<ID, PredicateCache> entry : subjects.entrySet()) { PredicateCache cache = entry.getValue(); Iterator<STMT> stmts = cache.iterator(predicate); removeStatements(IteratorAdapter.asList(stmts)); } } }
public void removeStatements(Collection<STMT> stmts) { for (STMT stmt : stmts) { if (removeIndexed(stmt.getSubject(), stmt, subjects)) { if (objects != null && stmt.getObject().isResource()) { removeIndexed((ID) stmt.getObject(), stmt, objects); } } } }
public void add(STMT... stmts) { for (STMT stmt : stmts) { index(stmt.getSubject(), stmt, subjects); if (objects != null && stmt.getObject().isResource()) { index((ID) stmt.getObject(), stmt, objects); } } }
if (stmt.getObject().isResource() && directToType.containsKey(stmt.getPredicate())) { if (!instanceCache.containsKey(stmt.getObject()) && !handled.contains(stmt.getObject())) { Class<?> cl = directToType.get(stmt.getPredicate());
@SuppressWarnings("unchecked") private <RT> RT getAsProjectionValue(NODE node, Class<RT> type) { if (node.isResource()) { if (type.equals(String.class)) { // TODO : always return LID ? return (RT) session.getLID(node.asResource()).getId(); } else { return session.get(type, node.asResource()); } } else { return converterRegistry.fromString(node.getValue(), type); } }
private void deleteResource(ID subject, @Nullable UID context) { // Delete own properties for (STMT statement : findStatements(subject, null, null, context, false)) { recordRemoveStatement(statement); NODE object = statement.getObject(); if (object.isResource() && !statement.getPredicate().equals(RDF.type)) { removeList((ID) object, context); removeContainer((ID) object, context); } } // Delete references for (STMT statement : findStatements(null, null, subject, context, false)) { recordRemoveStatement(statement); } // Remove from primary cache Collection<Object> instances = instanceCache.removeAll(subject); if (instances != null) { for (Object obj : instances) { resourceCache.remove(obj); } } }
private void removeListInternal(ID node, UID context) { for (STMT statement : findStatements(node, null, null, context, false)) { recordRemoveStatement(statement); NODE object = statement.getObject(); // Remove rdf:rest if (RDF.rest.equals(statement.getPredicate()) && object.isResource()) { removeListInternal((ID) object, context); } } }
else if (MappedPath.isWildcard(targetClass) && value.isResource()) { convertedValue = convertMappedObject((ID) value, Object.class, true, mappedProperty.isInjection());
recordRemoveStatement(statement); NODE object = statement.getObject(); if (object.isResource()) { if (property.isList()) { removeList((ID) object, context);
if (stmt.getObject().isResource()) { if (!ID.class.isAssignableFrom(componentType)) { List<STMT> typeStmts = findStatements(stmt.getObject().asResource(), RDF.type, null, null, false);
private Set<NODE> findPathValues(ID resource, MappedPath path, int index, PropertiesMap properties, UID context) { MappedPredicate predicate = path.get(index); if (predicate.getContext() != null) { context = predicate.getContext(); } Set<NODE> values; if (!predicate.inv() && properties.getDirect() != null) { values = findValues(predicate.getUID(), properties.getDirect(), context, predicate.inv()); } else if (predicate.inv() && properties.getInverse() != null) { values = findValues(predicate.getUID(), properties.getInverse(), null, predicate.inv()); } else { values = findValues(resource, predicate.getUID(), predicate.inv(), predicate.includeInferred(), context); } if (path.size() > index + 1) { Set<NODE> nestedValues = new LinkedHashSet<NODE>(); for (NODE value : values) { if (value.isResource()) { nestedValues.addAll(findPathValues((ID) value, path, index + 1, new PropertiesMap(null, null), context)); } } return nestedValues; } return values; }
return (lhs.isResource()) ? new LIT(lhs.getValue()) : lhs;