/** {@inheritDoc} */ @Override @SuppressWarnings("unchecked") public <T extends Serializable> T loadObject(String name, Class<T> klass) throws NoSuchElementException { assertConnectionOpen(); if(!existsObject(name)) { throw new NoSuchElementException("Can't find any object with name '"+name+"'"); } DB storage = openStorage(StorageType.PRIMARY_STORAGE); Atomic.Var<T> atomicVar = storage.getAtomicVar(name); T serializableObject = klass.cast(atomicVar.get()); postDeserializer(serializableObject); return serializableObject; }
if (nodeUuid.toString().equals(rootNodeVar.get().getId())) { throw new AfsStorageException("Cannot delete root node");
try (MapDBTransaction tx = this.openTransaction()) { Var<String> variable = tx.atomicVar(VARIABLE_NAME__CHRONOS_BUILD_VERSION); String versionString = variable.get(); if (versionString == null) { variable.set(ChronosVersion.getCurrentVersion().toString()); } else { variable.set(ChronosVersion.getCurrentVersion().toString());
private void persistIndexersMap(final SetMultimap<String, Indexer<?>> indexNameToIndexers, final MapDBTransaction tx) { checkNotNull(indexNameToIndexers, "Precondition violation - argument 'indexNameToIndexers' must not be NULL!"); checkNotNull(tx, "Precondition violation - argument 'tx' must not be NULL!"); // Kryo doesn't like to convert the SetMultimap class directly, so we transform // it into a regular hash map with sets as values. Map<String, Set<Indexer<?>>> persistentMap = Maps.newHashMap(); // we need to transform the multimap into an internal representation using a normal hash map. for (Entry<String, Indexer<?>> entry : indexNameToIndexers.entries()) { Set<Indexer<?>> set = persistentMap.get(entry.getKey()); if (set == null) { set = Sets.newHashSet(); } set.add(entry.getValue()); persistentMap.put(entry.getKey(), set); } // first, serialize the indexers map to a binary format byte[] serialForm = this.serializeObject(persistentMap); // store the binary format in the database Var<byte[]> variable = this.getIndexersMapVariable(tx); variable.set(serialForm); }
private SetMultimap<String, Indexer<?>> loadIndexersMap(final MapDBTransaction tx) { checkNotNull(tx, "Precondition violation - argument 'tx' must not be NULL!"); Var<byte[]> variable = this.getIndexersMapVariable(tx); byte[] serializedForm = variable.get(); // Kryo doesn't like to convert the SetMultimap class directly, so we transform // it into a regular hash map with sets as values. Map<String, Set<Indexer<?>>> map = this.deserializeObject(serializedForm); if (map == null) { return HashMultimap.create(); } else { // we need to convert our internal map representation back into its multimap form SetMultimap<String, Indexer<?>> multiMap = HashMultimap.create(); for (Entry<String, Set<Indexer<?>>> entry : map.entrySet()) { for (Indexer<?> indexer : entry.getValue()) { multiMap.put(entry.getKey(), indexer); } } return multiMap; } }
@Override protected WriteAheadLogToken getWriteAheadLogTokenIfExists() { String varName = this.getBranchName() + "." + WRITE_AHEAD_LOG_VAR_NAME; try (MapDBTransaction tx = this.getOwningDB().openTransaction()) { if (tx.exists(varName) == false) { // variable that holds the WAL token doesn't exist -> no WAL token exists return null; } Var<byte[]> var = tx.atomicVar(varName); if (var.get() == null) { // variable exists, but contains NULL -> no WAL token exists return null; } byte[] contents = var.get(); WriteAheadLogToken token = (WriteAheadLogToken) this.getOwningDB().getSerializationManager() .deserialize(contents); return token; } }
/** * Atomically sets to the given value and returns the previous value. * * @param newValue the new value * @return the previous value */ public final E getAndSet(E newValue) { //$DELAY$ for (;;) { //$DELAY$ E current = get(); //$DELAY$ if (compareAndSet(current, newValue)) { //$DELAY$ return current; } } }
@Override public Map<String, Boolean> loadIndexStates() { try (MapDBTransaction tx = this.getOwningDB().openTransaction()) { byte[] dirtyFlagsSerialized = this.getIndexDirtyMapVariable(tx).get(); tx.commit(); Map<String, Boolean> map = this.deserializeObject(dirtyFlagsSerialized); if (map == null) { return Maps.newHashMap(); } else { return map; } } }
public java.lang.String toString() { E v = get(); return v==null? null : v.toString(); }
@Override public void updateChronosVersionTo(final ChronosVersion chronosVersion) { checkNotNull(chronosVersion, "Precondition violation - argument 'chronosVersion' must not be NULL!"); try (MapDBTransaction tx = this.openTransaction()) { Var<String> variable = tx.atomicVar(VARIABLE_NAME__CHRONOS_BUILD_VERSION); variable.set(chronosVersion.toString()); tx.commit(); } }
@Override public NodeInfo createRootNodeIfNotExists(String name, String nodePseudoClass) { NodeInfo rootNodeInfo = rootNodeVar.get(); if (rootNodeInfo == null) { rootNodeInfo = createNode(null, name, nodePseudoClass, "", 0, new NodeGenericMetadata()); rootNodeVar.set(rootNodeInfo); } return rootNodeInfo; }
@Override public void persistIndexDirtyStates(final Map<String, Boolean> indices) { try (MapDBTransaction tx = this.getOwningDB().openTransaction()) { byte[] serializedForm = this.serializeObject(indices); this.getIndexDirtyMapVariable(tx).set(serializedForm); tx.commit(); } }
@Override protected void performWriteAheadLog(final WriteAheadLogToken token) { try (MapDBTransaction tx = this.getOwningDB().openTransaction()) { Var<byte[]> var = tx.atomicVar(this.getBranchName() + "." + WRITE_AHEAD_LOG_VAR_NAME); var.set(this.getOwningDB().getSerializationManager().serialize(token)); tx.commit(); } }
@Override public T get() { return var.get(); }
@Override public void set(T var) { this.var.set(var); }
/** {@inheritDoc} */ @Override public <T extends Serializable> void saveObject(String name, T serializableObject) { assertConnectionOpen(); DB storage = openStorage(StorageType.PRIMARY_STORAGE); Atomic.Var<T> atomicVar = storage.getAtomicVar(name); Map<String, Object> objRefs = preSerializer(serializableObject); atomicVar.set(serializableObject); storage.commit(); postSerializer(serializableObject, objRefs); }