X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.db.common%2Fsrc%2Forg%2Fsimantics%2Fdb%2Fcommon%2FIndexing.java;fp=bundles%2Forg.simantics.db.common%2Fsrc%2Forg%2Fsimantics%2Fdb%2Fcommon%2FIndexing.java;h=f9106636bd930d71011b96c8d19f39beca1eb4b6;hb=969bd23cab98a79ca9101af33334000879fb60c5;hp=0000000000000000000000000000000000000000;hpb=866dba5cd5a3929bbeae85991796acb212338a08;p=simantics%2Fplatform.git

diff --git a/bundles/org.simantics.db.common/src/org/simantics/db/common/Indexing.java b/bundles/org.simantics.db.common/src/org/simantics/db/common/Indexing.java
new file mode 100644
index 000000000..f9106636b
--- /dev/null
+++ b/bundles/org.simantics.db.common/src/org/simantics/db/common/Indexing.java
@@ -0,0 +1,154 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Association for Decentralized Information Management in
+ * Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     VTT Technical Research Centre of Finland - initial API and implementation
+ *******************************************************************************/
+package org.simantics.db.common;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.simantics.db.Resource;
+import org.simantics.db.WriteOnlyGraph;
+import org.simantics.db.common.utils.Logger;
+
+/**
+ * A internal temporary store for database indexing-related low-level utilities
+ * and static data.
+ * 
+ * This will be moved to more a more logical location at some point.
+ * 
+ * @author Antti Villberg
+ * @author Tuukka Lehtonen
+ * @since 1.8
+ */
+public class Indexing {
+
+    private static final boolean PROFILE                      = false;
+
+    private static Set<UUID>     indexPendings                = new HashSet<UUID>();
+
+    private static AtomicBoolean dependenciesIndexingDisabled = new AtomicBoolean();
+
+    private static int indexPendingCounter = 0;
+
+    private static Map<Resource, Map<Class<?>, Object>> caches = new HashMap<Resource, Map<Class<?>, Object>>(); 
+    
+    private static boolean useIndexing = true;
+    
+    @SuppressWarnings("unchecked")
+	public static <T> T getCache(Resource root, Class<T> clazz) {
+    	Map<Class<?>,Object> cache = caches.get(root);
+    	if(cache == null) return null;
+    	return (T)cache.get(clazz);
+    }
+    
+    public static <T> T createCache(Resource root, T object) {
+    	Map<Class<?>,Object> cache = caches.get(root);
+    	if(cache == null) {
+    		cache = new HashMap<Class<?>,Object>();
+    		caches.put(root, cache);
+    	}
+    	cache.put(object.getClass(), object);
+    	return object;
+    }
+    
+    public static void clearCaches(Resource root) {
+    	caches.remove(root);
+    }
+    
+    public static UUID makeIndexPending() {
+        synchronized (indexPendings) {
+            UUID guid = UUID.randomUUID();
+            indexPendings.add(guid);
+            return guid;
+        }
+    }
+
+    public static void releaseIndexPending(UUID guid) {
+        synchronized (indexPendings) {
+            indexPendings.remove(guid);
+            if (indexPendings.isEmpty()) {
+                indexPendings.notifyAll();
+                indexPendingCounter++;
+            }
+        }
+    }
+
+    public static int getIndexPendingCounter() {
+        synchronized (indexPendings) {
+            return indexPendingCounter;
+        }
+    }
+    
+    public static boolean isIndexPending() {
+        synchronized (indexPendings) {
+            return !indexPendings.isEmpty();
+        }
+    }
+
+    private static long totalWaitTime = 0;
+
+    public static void waitIndexPending() {
+        long startTime = PROFILE ? System.nanoTime() : 0;
+        boolean waited = false;
+        int time = 1;
+        synchronized (indexPendings) {
+            while (isIndexPending()) {
+                try {
+                    waited = true;
+                    indexPendings.wait(time++);
+                    if (time > 10) time = 10;
+                } catch (InterruptedException e) {
+                    Logger.defaultLogError(e);
+                }
+            }
+        }
+        if (PROFILE) {
+            if (waited) {
+                long endTime = System.nanoTime();
+                long waitTime = endTime - startTime;
+                totalWaitTime += waitTime;
+                System.out.println("Indexing wait time " + (waitTime*1e-6) + " ms (total " + (totalWaitTime*1e-6) + " ms)");
+            }
+        }
+    }
+
+    /**
+     * @param graph an active database write handle to prove one is in a write
+     *        transaction and wants to disable dependencies indexing for this
+     *        transaction only.
+     * @return previous value
+     */
+    public static boolean setDependenciesIndexingDisabled(WriteOnlyGraph graph, boolean disabled) {
+        if (graph == null)
+            throw new NullPointerException("null write graph");
+        // TODO: check that graph is valid once made possible
+        return dependenciesIndexingDisabled.getAndSet(disabled);
+    }
+
+    public static boolean resetDependenciesIndexingDisabled() {
+    	return dependenciesIndexingDisabled.compareAndSet(true, false);
+    }
+
+    public static boolean isDependenciesIndexingDisabled() {
+    	if (!useIndexing)
+    		return true;
+        return dependenciesIndexingDisabled.get();
+    }
+    
+    public static void setDefaultDependenciesIndexingEnabled(boolean b) {
+    	useIndexing = b;
+    }
+
+}