private Lock getUniquenessLock(final TitanVertex start, final TitanType type, final Object end) {
if (config.isSingleThreaded()) return FakeLock.INSTANCE;
if (uniqueLocks == UNINITIALIZED_LOCKS) {
Preconditions.checkArgument(!config.isSingleThreaded());
synchronized (this) {
if (uniqueLocks == UNINITIALIZED_LOCKS)
uniqueLocks = new ConcurrentHashMap<UniqueLockApplication, Lock>();
}
}
UniqueLockApplication la = new UniqueLockApplication(start, type, end);
Lock lock = new ReentrantLock();
Lock existingLock = uniqueLocks.putIfAbsent(la, lock);
if (existingLock == null) return lock;
else return existingLock;
}
public void removeRelation(InternalRelation relation) {
Preconditions.checkArgument(!relation.isRemoved());
relation = relation.it();
// Delete from Vertex
for (int i = 0; i < relation.getLen(); i++) {
relation.getVertex(i).removeRelation(relation);
}
// Update transaction data structures
if (relation.isNew()) {
addedRelations.remove(relation);
if (isVertexIndexProperty(relation)) newVertexIndexEntries.remove((TitanProperty) relation);
} else {
Preconditions.checkArgument(relation.isLoaded());
if (deletedRelations == EMPTY_DELETED_RELATIONS) {
if (config.isSingleThreaded()) {
deletedRelations = new HashMap<Long, InternalRelation>();
} else {
synchronized (this) {
if (deletedRelations == EMPTY_DELETED_RELATIONS)
deletedRelations = new ConcurrentHashMap<Long, InternalRelation>();
}
}
}
deletedRelations.put(Long.valueOf(relation.getID()), relation);
}
}
public StandardTitanTx(
StandardTitanGraph graph, TransactionConfig config, BackendTransaction txHandle) {
Preconditions.checkNotNull(graph);
Preconditions.checkArgument(graph.isOpen());
Preconditions.checkNotNull(config);
Preconditions.checkNotNull(txHandle);
this.graph = graph;
this.config = config;
this.idInspector = graph.getIDInspector();
this.txHandle = txHandle;
temporaryID = new AtomicLong(-1);
Cache<StandardElementQuery, List<Object>> indexCacheBuilder =
CacheBuilder.newBuilder()
.weigher(
new Weigher<StandardElementQuery, List<Object>>() {
@Override
public int weigh(StandardElementQuery q, List<Object> r) {
return 2 + r.size();
}
})
.maximumWeight(DEFAULT_CACHE_SIZE)
.build();
int concurrencyLevel;
if (config.isSingleThreaded()) {
vertexCache = new SimpleVertexCache();
addedRelations = new SimpleBufferAddedRelations();
concurrencyLevel = 1;
typeCache = new HashMap<String, TitanType>();
newVertexIndexEntries = new SimpleIndexCache();
} else {
vertexCache = new ConcurrentVertexCache();
addedRelations = new ConcurrentBufferAddedRelations();
concurrencyLevel = 4;
typeCache = new ConcurrentHashMap<String, TitanType>();
newVertexIndexEntries = new ConcurrentIndexCache();
}
for (SystemType st : SystemKey.values()) typeCache.put(st.getName(), st);
indexCache =
CacheBuilder.newBuilder()
.weigher(
new Weigher<StandardElementQuery, List<Object>>() {
@Override
public int weigh(StandardElementQuery q, List<Object> r) {
return 2 + r.size();
}
})
.concurrencyLevel(concurrencyLevel)
.maximumWeight(DEFAULT_CACHE_SIZE)
.build();
uniqueLocks = UNINITIALIZED_LOCKS;
deletedRelations = EMPTY_DELETED_RELATIONS;
this.isOpen = true;
}