[MOD] Minor refactorings and forgot to stage most changes in the last

commit.

bundles/sirix-core/src/main/java/org/sirix/access/ResourceStore.java

@@ -0,0 +1,112 @@
+package org.sirix.access;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.io.File;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.Semaphore;
+
+import javax.annotation.Nonnull;
+
+import org.sirix.access.conf.ResourceConfiguration;
+import org.sirix.access.conf.ResourceManagerConfiguration;
+import org.sirix.api.ResourceManager;
+import org.sirix.cache.BufferManager;
+import org.sirix.io.Reader;
+import org.sirix.io.Storage;
+import org.sirix.io.StorageType;
+import org.sirix.page.PageReference;
+import org.sirix.page.UberPage;
+
+/**
+ * Manages all resource stuff.
+ *
+ * @author Johannes Lichtenberger
+ */
+public final class ResourceStore implements AutoCloseable {
+	/** Central repository of all open resource managers. */
+	private final ConcurrentMap<File, ResourceManager> mResourceManagers;
+
+	/** Makes sure there is at maximum a specific number of readers per resource. */
+	private final Semaphore mReadSemaphore;
+
+	/** Makes sure there is at maximum one writer per resource. */
+	private final Semaphore mWriteSempahore;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param readSempahore makes sure there is at maximum a specific number of readers per resource
+	 * @param writeSempahore makes sure there is at maximum one writer per resource.
+	 */
+	public ResourceStore(final Semaphore readSempahore, final Semaphore writeSemaphore) {
+		mResourceManagers = new ConcurrentHashMap<>();
+		mReadSemaphore = checkNotNull(readSempahore);
+		mWriteSempahore = checkNotNull(writeSemaphore);
+	}
+
+	/**
+	 * Open a resource, that is get an instance of a {@link ResourceManager} in order to read/write
+	 * from the resource.
+	 *
+	 * @param database The database.
+	 * @param resourceConfig The resource configuration.
+	 * @param resourceManagerConfig The resource manager configuration.
+	 * @param bufferManager The buffer manager.
+	 * @param resourceFile The resource to open.
+	 * @return A resource manager.
+	 */
+	public ResourceManager openResource(final @Nonnull DatabaseImpl database,
+			final @Nonnull ResourceConfiguration resourceConfig,
+			final @Nonnull ResourceManagerConfiguration resourceManagerConfig,
+			final @Nonnull BufferManager bufferManager, final @Nonnull File resourceFile) {
+		checkNotNull(database);
+		checkNotNull(resourceConfig);
+		return mResourceManagers.computeIfAbsent(resourceFile, k -> {
+			final Storage storage = StorageType.getStorage(resourceConfig);
+			final UberPage uberPage;
+
+			if (storage.exists()) {
+				try (final Reader reader = storage.createReader()) {
+					final PageReference firstRef = reader.readUberPageReference();
+					if (firstRef.getPage() == null) {
+						uberPage = (UberPage) reader.read(firstRef.getKey(), null);
+					} else {
+						uberPage = (UberPage) firstRef.getPage();
+					}
+				}
+			} else {
+				// Bootstrap uber page and make sure there already is a root node.
+				uberPage = new UberPage();
+			}
+
+			final ResourceManager resourceManager = new XdmResourceManager(database, this, resourceConfig,
+					resourceManagerConfig, bufferManager, resourceFile,
+					StorageType.getStorage(resourceConfig), uberPage, mReadSemaphore, mWriteSempahore);
+			Databases.putResourceManager(resourceFile, resourceManager);
+			return resourceManager;
+		});
+	}
+
+	public boolean hasOpenResourceManager(File resourceFile) {
+		checkNotNull(resourceFile);
+		return mResourceManagers.containsKey(resourceFile);
+	}
+
+	public ResourceManager getOpenResourceManager(File resourceFile) {
+		checkNotNull(resourceFile);
+		return mResourceManagers.get(resourceFile);
+	}
+
+	@Override
+	public void close() {
+		mResourceManagers.forEach((resourceName, resourceMgr) -> resourceMgr.close());
+	}
+
+	public boolean closeResource(File resourceFile) {
+		final ResourceManager manager = mResourceManagers.remove(resourceFile);
+		Databases.removeResourceManager(resourceFile, manager);
+		return manager != null;
+	}
+}

bundles/sirix-core/src/main/java/org/sirix/access/TransactionImpl.java

@@ -0,0 +1,76 @@
+package org.sirix.access;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.sirix.api.Transaction;
+import org.sirix.api.TransactionManager;
+import org.sirix.api.XdmNodeWriteTrx;
+
+public final class TransactionImpl implements Transaction {
+
+	private final List<XdmNodeWriteTrx> resourceTrxs;
+	private final TransactionManager trxMgr;
+
+	public TransactionImpl(TransactionManager trxMgr) {
+		resourceTrxs = new ArrayList<>();
+		this.trxMgr = checkNotNull(trxMgr);
+	}
+
+	@Override
+	public Transaction commit() {
+		int i = 0;
+		for (boolean failure = false; i < resourceTrxs.size() && !failure; i++) {
+			final XdmNodeWriteTrx trx = resourceTrxs.get(i);
+
+			try {
+				trx.commit();
+			} catch (final Exception e) {
+				trx.rollback();
+				failure = true;
+			}
+		}
+
+		if (i < resourceTrxs.size()) {
+			for (int j = 0; j < i; j++) {
+				final XdmNodeWriteTrx trx = resourceTrxs.get(i);
+				trx.truncateTo(trx.getRevisionNumber() - 1);
+			}
+
+			for (; i < resourceTrxs.size(); i++) {
+				final XdmNodeWriteTrx trx = resourceTrxs.get(i);
+				trx.rollback();
+			}
+		}
+
+		resourceTrxs.clear();
+		trxMgr.closeTransaction(this);
+		return this;
+	}
+
+	@Override
+	public Transaction rollback() {
+		resourceTrxs.forEach(XdmNodeWriteTrx::rollback);
+		resourceTrxs.clear();
+		trxMgr.closeTransaction(this);
+		return this;
+	}
+
+	@Override
+	public void close() {
+		rollback();
+	}
+
+	@Override
+	public Transaction add(XdmNodeWriteTrx writer) {
+		resourceTrxs.add(checkNotNull(writer));
+		return this;
+	}
+
+	@Override
+	public long getId() {
+		return 0;
+	}
+}

bundles/sirix-core/src/main/java/org/sirix/access/TransactionManagerImpl.java

@@ -0,0 +1,37 @@
+package org.sirix.access;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.sirix.api.Transaction;
+import org.sirix.api.TransactionManager;
+
+public final class TransactionManagerImpl implements TransactionManager {
+
+	private final Set<Transaction> mTransactions;
+
+	public TransactionManagerImpl() {
+		mTransactions = new HashSet<>();
+	}
+
+	@Override
+	public Transaction beginTransaction() {
+		final Transaction trx = new TransactionImpl(this);
+		mTransactions.add(trx);
+		return trx;
+	}
+
+	@Override
+	public TransactionManager closeTransaction(final Transaction trx) {
+		mTransactions.remove(checkNotNull(trx));
+		return this;
+	}
+
+	@Override
+	public void close() {
+		mTransactions.forEach(Transaction::commit);
+	}
+
+}

bundles/sirix-core/src/main/java/org/sirix/api/Transaction.java

@@ -0,0 +1,14 @@
+package org.sirix.api;
+
+public interface Transaction extends AutoCloseable {
+	Transaction commit();
+
+	Transaction rollback();
+
+	long getId();
+
+	@Override
+	void close();
+
+	Transaction add(XdmNodeWriteTrx nodeWriter);
+}

bundles/sirix-core/src/main/java/org/sirix/api/TransactionManager.java

@@ -0,0 +1,10 @@
+package org.sirix.api;
+
+public interface TransactionManager extends AutoCloseable {
+	Transaction beginTransaction();
+
+	TransactionManager closeTransaction(Transaction trx);
+
+	@Override
+	void close();
+}