X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.utils.datastructures%2Fsrc%2Forg%2Fsimantics%2Futils%2Fdatastructures%2Fcontext%2FContext.java;fp=bundles%2Forg.simantics.utils.datastructures%2Fsrc%2Forg%2Fsimantics%2Futils%2Fdatastructures%2Fcontext%2FContext.java;h=a195d5fb4c3d3959d6ef30cc323d9f79212eca19;hb=969bd23cab98a79ca9101af33334000879fb60c5;hp=0000000000000000000000000000000000000000;hpb=866dba5cd5a3929bbeae85991796acb212338a08;p=simantics%2Fplatform.git

diff --git a/bundles/org.simantics.utils.datastructures/src/org/simantics/utils/datastructures/context/Context.java b/bundles/org.simantics.utils.datastructures/src/org/simantics/utils/datastructures/context/Context.java
new file mode 100644
index 000000000..a195d5fb4
--- /dev/null
+++ b/bundles/org.simantics.utils.datastructures/src/org/simantics/utils/datastructures/context/Context.java
@@ -0,0 +1,251 @@
+/*******************************************************************************
+ * Copyright (c) 2007, 2010 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
+ *******************************************************************************/
+/*
+ *
+ * @author Toni Kalajainen
+ */
+package org.simantics.utils.datastructures.context;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+import org.simantics.utils.datastructures.disposable.AbstractDisposable;
+import org.simantics.utils.strings.EString;
+import org.simantics.utils.threads.Executable;
+import org.simantics.utils.threads.IThreadWorkQueue;
+import org.simantics.utils.threads.SyncListenerList;
+import org.simantics.utils.threads.ThreadUtils;
+
+/**
+ * 
+ * TODO Optimize getItemsByClass queries (Create optimizing structures after 1st query)
+ * TODO Optimize getSingleItem query
+ *
+ * @param <E>
+ */
+public class Context<E> extends AbstractDisposable implements IContext<E> {
+
+	protected Set<E> set = new HashSet<E>();
+	@SuppressWarnings({ "rawtypes" })
+    protected SyncListenerList<IContextListener> listeners =
+		new SyncListenerList<IContextListener>(IContextListener.class);
+	
+	final Class<E> clazz;
+	
+	private E[] snapshotArray;
+	private Map<Class<? extends E>, Collection<? extends E>> classQueryResultCache = 
+		new HashMap<Class<? extends E>, Collection<? extends E>>();
+	
+	public Context(Class<E> clazz) {
+		this.clazz = clazz;
+		snapshotArray = createArray(clazz, 0);
+	}
+	
+	@Override
+	public void add(E item) {
+	    assertNotDisposed();
+		Executable executables[];
+		synchronized(this) {
+			if (set.contains(item))
+				throw new IllegalArgumentException("Context already contains item "+item);
+		
+			set.add(item);
+			snapshotArray = createSnapshot(set);
+			
+			executables = listeners.getExecutables(itemAdded, this, item);
+			
+			Iterator<Class<? extends E>> i = classQueryResultCache.keySet().iterator();
+			while (i.hasNext()) {
+				Class<? extends E> c = i.next();
+				if (c.isInstance(item))
+					i.remove();				
+			}
+		}
+		ThreadUtils.multiSyncExec(executables);
+	}
+
+	@Override
+	public boolean remove(E item) {
+        assertNotDisposed();
+		Executable executables[];		
+		synchronized(this) {
+			if (!set.remove(item))			
+				return false;
+			snapshotArray = createSnapshot(set);
+			executables = listeners.getExecutables(itemRemoved, this, item);
+			
+			Iterator<Class<? extends E>> i = classQueryResultCache.keySet().iterator();
+			while (i.hasNext()) {
+				Class<? extends E> c = i.next();
+				if (c.isInstance(item))
+					i.remove();				
+			}			
+		}
+		ThreadUtils.multiSyncExec(executables);
+		return true;
+	}
+	
+	@Override
+	public synchronized boolean contains(E item) {
+        assertNotDisposed();
+		return set.contains(item);
+	}
+
+    @Override
+    public void clear() {
+        assertNotDisposed();
+        classQueryResultCache.clear();
+    	ArrayList<Executable> executables = new ArrayList<Executable>();
+    	synchronized(this) {
+    		if (set.isEmpty())
+    			return;
+
+    		for (E item : snapshotArray)
+    			listeners.addExecutables(executables, itemRemoved, this, item);
+    		
+    		set.clear();
+    		this.snapshotArray = createSnapshot(set);
+    	}
+    	ThreadUtils.multiSyncExec(executables);
+    }
+
+	@SuppressWarnings("unchecked")
+    @Override
+	public synchronized <R extends E> Collection<R> getItemsByClass(Class<R> clazz) {
+        assertNotDisposed();        
+		Collection<R> result = (Collection<R>) classQueryResultCache.get(clazz);
+		if (result!=null)
+			return result;
+		result = new ArrayList<R>();
+		for (E i : set)
+			if (clazz.isAssignableFrom(i.getClass()))
+				result.add((R)i);
+		classQueryResultCache.put(clazz, result);
+		return result;
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public synchronized <R> boolean containsItemByClass(Class<R> clazz) {
+        assertNotDisposed();
+		Collection<R> result = (Collection<R>) classQueryResultCache.get(clazz);
+		if (result!=null) return !result.isEmpty();
+		for (E i : set)
+			if (clazz.isAssignableFrom(i.getClass()))
+				return true;
+		return false;
+	}
+	
+    @SuppressWarnings({ "unchecked" })
+    private <R extends E> R[] createArray(Class<R> clazz, int length)
+    {
+        return (R[]) Array.newInstance(clazz, length);
+    }    
+	
+	E[] createSnapshot(Set<E> set) {
+		E[] result = createArray(clazz, set.size());
+		int index = 0;
+		for (E i : set)
+			result[index++] = i; 
+		return result;
+	}	
+	
+	public synchronized <R extends E> R getSingleItem(Class<R> clazz)
+	{
+        assertNotDisposed();
+		Collection<R> result = getItemsByClass(clazz);
+		if (result.size()==1)
+			return result.iterator().next();
+		throw new RuntimeException("one "+clazz.getName()+" expected in Context, got "+result.size());			
+	}
+
+	@Override
+	public E[] toArray() {
+        assertNotDisposed();
+		return snapshotArray;
+	}
+	
+	@Override
+	public void addContextListener(IContextListener<E> listener) {
+        assertNotDisposed();
+		listeners.add(listener);
+	}
+
+	@Override
+	public void removeContextListener(IContextListener<E> listener) {
+        assertNotDisposed();
+		listeners.remove(listener);
+	}	
+	
+	@Override
+	public void addContextListener(IThreadWorkQueue thread,
+			IContextListener<E> listener) {
+        assertNotDisposed();
+		listeners.add(thread, listener);
+	}
+
+	@Override
+	public void removeContextListener(IThreadWorkQueue thread,
+			IContextListener<E> listener) {
+        assertNotDisposed();
+		listeners.remove(thread, listener);
+	}		
+
+	private static Method itemAdded = SyncListenerList.getMethod(IContextListener.class, "itemAdded");
+	private static Method itemRemoved = SyncListenerList.getMethod(IContextListener.class, "itemRemoved");
+
+//	private void fireItemAdded(E item)
+//	{
+//		listeners.fireEventSync(itemAdded, this, item);
+//	}
+//	
+//	private void fireItemRemoved(E item)
+//	{
+//		listeners.fireEventSync(itemRemoved, this, item);
+//	}
+
+	@SuppressWarnings("unchecked")
+    @Override
+	public <R extends E> R getAtMostOneItemOfClass(Class<R> clazz) {
+        assertNotDisposed();
+	    int count = 0;
+	    R r = null;
+        for (E i : set) {
+            if (clazz.isAssignableFrom(i.getClass())) {
+                ++count;
+                r = (R) i;
+            }
+        }
+        if (count==0) return null;
+        if (count>1)
+			throw new RuntimeException("one "+clazz.getName()+" expected in Context, got "+count);
+		return r;
+	}
+	
+	@Override
+	protected void doDispose() {
+	}
+
+	@Override
+	public String toString() {
+	    String s = EString.implode(snapshotArray, "\n");
+	    return s != null ? s : "";
+	}
+
+}