public final void verifyAccess(TitanVertex... vertices) {
verifyOpen();
for (TitanVertex v : vertices) {
Preconditions.checkArgument(v instanceof InternalVertex, "Invalid vertex: %s", v);
if (!(v instanceof SystemType) && this != ((InternalVertex) v).tx())
throw new IllegalArgumentException(
"The vertex or type is not associated with this transaction [" + v + "]");
if (v.isRemoved())
throw new IllegalArgumentException("The vertex or type has been removed [" + v + "]");
}
}
public TitanProperty setProperty(TitanVertex vertex, final TitanKey key, Object value) {
Preconditions.checkNotNull(key);
Preconditions.checkArgument(
key.isUnique(Direction.OUT), "Not an out-unique key: %s", key.getName());
Lock uniqueLock = FakeLock.INSTANCE;
try {
if (config.hasVerifyUniqueness()) {
// Acquire uniqueness lock, remove and add
uniqueLock = getUniquenessLock(vertex, key, value);
uniqueLock.lock();
vertex.removeProperty(key);
} else {
// Only delete in-memory
InternalVertex v = (InternalVertex) vertex;
for (InternalRelation r :
v.it()
.getAddedRelations(
new Predicate<InternalRelation>() {
@Override
public boolean apply(@Nullable InternalRelation p) {
return p.getType().equals(key);
}
})) {
r.remove();
}
}
return addPropertyInternal(vertex, key, value);
} finally {
uniqueLock.unlock();
}
}
@Override
public Iterator<TitanElement> getNew(final StandardElementQuery query) {
Preconditions.checkArgument(
query.getType() == StandardElementQuery.Type.VERTEX
|| query.getType() == StandardElementQuery.Type.EDGE);
if (query.getType() == StandardElementQuery.Type.VERTEX && hasModifications()) {
// Collect all keys from the query - ASSUMPTION: query is an AND of KeyAtom
final Set<TitanKey> keys = Sets.newHashSet();
KeyAtom<TitanKey> standardIndexKey = null;
for (KeyCondition<TitanKey> cond : query.getCondition().getChildren()) {
KeyAtom<TitanKey> atom = (KeyAtom<TitanKey>) cond;
if (atom.getRelation() == Cmp.EQUAL && isVertexIndexProperty(atom.getKey()))
standardIndexKey = atom;
keys.add(atom.getKey());
}
Iterator<TitanVertex> vertices;
if (standardIndexKey == null) {
Set<TitanVertex> vertexSet = Sets.newHashSet();
for (TitanRelation r :
addedRelations.getView(
new Predicate<InternalRelation>() {
@Override
public boolean apply(@Nullable InternalRelation relation) {
return keys.contains(relation.getType());
}
})) {
vertexSet.add(((TitanProperty) r).getVertex());
}
for (TitanRelation r : deletedRelations.values()) {
if (keys.contains(r.getType())) {
TitanVertex v = ((TitanProperty) r).getVertex();
if (!v.isRemoved()) vertexSet.add(v);
}
}
vertices = vertexSet.iterator();
} else {
vertices =
Iterators.transform(
newVertexIndexEntries
.get(standardIndexKey.getCondition(), standardIndexKey.getKey())
.iterator(),
new Function<TitanProperty, TitanVertex>() {
@Nullable
@Override
public TitanVertex apply(@Nullable TitanProperty o) {
return o.getVertex();
}
});
}
return (Iterator)
Iterators.filter(
vertices,
new Predicate<TitanVertex>() {
@Override
public boolean apply(@Nullable TitanVertex vertex) {
return query.matches(vertex);
}
});
} else if (query.getType() == StandardElementQuery.Type.EDGE
&& !addedRelations.isEmpty()) {
return (Iterator)
addedRelations
.getView(
new Predicate<InternalRelation>() {
@Override
public boolean apply(@Nullable InternalRelation relation) {
return (relation instanceof TitanEdge)
&& !relation.isHidden()
&& query.matches(relation);
}
})
.iterator();
} else throw new IllegalArgumentException("Unexpected type: " + query.getType());
}
