Merge remote-tracking branch 'origin/newgen' into newgen-iliasg

jdeeco-core/src/cz/cuni/mff/d3s/deeco/knowledge/CloningKnowledgeManager.java

@@ -19,8 +19,12 @@ public class CloningKnowledgeManager extends BaseKnowledgeManager {
 
 	private final Cloner cloner;
 
-	public CloningKnowledgeManager(Object knowledge) {
+	public CloningKnowledgeManager() {
 		cloner = new Cloner();
+	}
+
+	public CloningKnowledgeManager(Object knowledge) {
+		this();
 		setBaseKnowledge(cloner.deepClone(knowledge));
 	}
 
@@ -32,7 +36,7 @@ public CloningKnowledgeManager(Object knowledge) {
 	 * )
 	 */
 	@Override
-	public ValueSet get(Collection<KnowledgePath> knowledgePaths)
+	public synchronized ValueSet get(Collection<KnowledgePath> knowledgePaths)
 			throws KnowledgeNotFoundException {
 		return cloner.deepClone(super.get(knowledgePaths));
 	}

jdeeco-core/src/cz/cuni/mff/d3s/deeco/knowledge/CloningKnowledgeManagerContainer.java

@@ -0,0 +1,29 @@
+package cz.cuni.mff.d3s.deeco.knowledge;
+
+import com.rits.cloning.Cloner;
+
+/**
+ * @author Michal Kit <kit@d3s.mff.cuni.cz>
+ *
+ */
+public class CloningKnowledgeManagerContainer extends KnowledgeManagerContainer {
+
+	private final Cloner cloner;
+
+	public CloningKnowledgeManagerContainer() {
+		this.cloner = new Cloner();
+	}
+
+	@Override
+	public synchronized KnowledgeManager createReplicaFor(KnowledgeManager km) {
+		if (!replicas.contains(km)) {
+			KnowledgeManager result = cloner.deepClone(km);
+			replicas.add(result);
+			for (ReplicaListener listener : replicaListeners)
+				listener.replicaCreated(result);
+			return result;
+		}
+		return null;
+	}
+
+}

jdeeco-core/src/cz/cuni/mff/d3s/deeco/knowledge/KnowledgeManagerContainer.java

@@ -1,60 +1,78 @@
 package cz.cuni.mff.d3s.deeco.knowledge;
 
+import java.util.LinkedList;
 import java.util.List;
 
 /**
  * @author Michal Kit <kit@d3s.mff.cuni.cz>
  *
  */
-public class KnowledgeManagerContainer implements
+public abstract class KnowledgeManagerContainer implements
 		ReplicaKnowledgeManagerContainer, LocalKnowledgeManagerContainer {
 
-	@Override
-	public KnowledgeManager createLocal() {
-		// TODO Auto-generated method stub
-		return null;
+	protected final List<KnowledgeManager> locals;
+	protected final List<KnowledgeManager> replicas;
+	protected final List<LocalListener> localListeners;
+	protected final List<ReplicaListener> replicaListeners;
+
+	public KnowledgeManagerContainer() {
+		this.locals = new LinkedList<>();
+		this.replicas = new LinkedList<>();
+		this.localListeners = new LinkedList<>();
+		this.replicaListeners = new LinkedList<>();
 	}
-
+	
 	@Override
-	public KnowledgeManager removeLocal(KnowledgeManager km) {
-		// TODO Auto-generated method stub
-		return null;
+	public synchronized KnowledgeManager createLocal() {
+		KnowledgeManager result = new CloningKnowledgeManager();
+		locals.add(result);
+		for (LocalListener listener : localListeners)
+			listener.localCreated(result);
+		return result;
 	}
 
 	@Override
-	public List<KnowledgeManager> getLocals() {
-		// TODO Auto-generated method stub
+	public synchronized KnowledgeManager removeLocal(KnowledgeManager km) {
+		if (locals.contains(km)) {
+			locals.remove(km);
+			for (LocalListener listener : localListeners)
+				listener.localRemoved(km);
+			return km;
+		}
 		return null;
 	}
 
 	@Override
-	public void registerListener(LocalListener listener) {
-		// TODO Auto-generated method stub
-
+	public synchronized List<KnowledgeManager> getLocals() {
+		return new LinkedList<>(locals);
 	}
 
 	@Override
-	public KnowledgeManager createReplicaFor(KnowledgeManager km) {
-		// TODO Auto-generated method stub
-		return null;
+	public synchronized void registerLocalListener(LocalListener listener) {
+		if (!localListeners.contains(listener))
+			localListeners.add(listener);
 	}
 
 	@Override
-	public KnowledgeManager removeReplicaFor(KnowledgeManager km) {
-		// TODO Auto-generated method stub
+	public synchronized KnowledgeManager removeReplica(KnowledgeManager km) {
+		if (replicas.contains(km)) {
+			replicas.remove(km);
+			for (ReplicaListener listener : replicaListeners)
+				listener.replicaRemoved(km);
+			return km;
+		}
 		return null;
 	}
 
 	@Override
-	public List<KnowledgeManager> getReplicas() {
-		// TODO Auto-generated method stub
-		return null;
+	public synchronized List<KnowledgeManager> getReplicas() {
+		return new LinkedList<>(replicas);
 	}
 
 	@Override
-	public void registerListener(ReplicaListener listener) {
-		// TODO Auto-generated method stub
-
+	public synchronized void registerReplicaListener(ReplicaListener listener) {
+		if (!replicaListeners.contains(listener))
+			replicaListeners.add(listener);
 	}
 
 }

jdeeco-core/src/cz/cuni/mff/d3s/deeco/knowledge/KnowledgeManagerViewImpl.java

@@ -27,6 +27,9 @@ public KnowledgeManagerViewImpl(KnowledgeManager knowledgeManager,
 		this.container = container;
 		this.triggerListeners = new HashMap<>();
 		listenerToTriggerListeners = new HashMap<>();
+
+		this.container.registerLocalListener(this);
+		this.container.registerReplicaListener(this);
 	}
 
 	/*
@@ -82,8 +85,10 @@ public synchronized void replicaRemoved(KnowledgeManager km) {
 				.values()) {
 			toRemove.clear();
 			for (KnowledgeManagerTriggerListener tListener : tListeners)
-				if (tListener.getKnowledgeManager().equals(km))
+				if (tListener.getKnowledgeManager().equals(km)) {
+					km.unregister(tListener.getTrigger(), tListener);
 					toRemove.add(tListener);
+				}
 			tListeners.removeAll(toRemove);
 		}
 	}
@@ -161,7 +166,7 @@ private void registerTriggerAtKnowledgeManager(KnowledgeManager km,
 			Trigger trigger, ShadowsTriggerListener triggerListener) {
 		List<KnowledgeManagerTriggerListener> tListeners;
 		KnowledgeManagerTriggerListener tListener = new KnowledgeManagerTriggerListener(
-				km, triggerListener);
+				km, triggerListener, trigger);
 		// Update map of listenerToTriggerListeners
 		if (listenerToTriggerListeners.containsKey(triggerListener))
 			tListeners = listenerToTriggerListeners.get(triggerListener);
@@ -179,12 +184,14 @@ private class KnowledgeManagerTriggerListener implements TriggerListener {
 
 		private final KnowledgeManager knowledgeManager;
 		private final ShadowsTriggerListener listener;
+		private final Trigger trigger;
 
 		public KnowledgeManagerTriggerListener(
 				KnowledgeManager knowledgeManager,
-				ShadowsTriggerListener listener) {
+				ShadowsTriggerListener listener, Trigger trigger) {
 			this.knowledgeManager = knowledgeManager;
 			this.listener = listener;
+			this.trigger = trigger;
 		}
 
 		@Override
@@ -195,6 +202,10 @@ public void triggered(Trigger trigger) {
 		public KnowledgeManager getKnowledgeManager() {
 			return knowledgeManager;
 		}
+
+		public Trigger getTrigger() {
+			return trigger;
+		}
 	}
 
 }

jdeeco-core/src/cz/cuni/mff/d3s/deeco/knowledge/LocalKnowledgeManagerContainer.java

@@ -10,5 +10,5 @@ public interface LocalKnowledgeManagerContainer {
 	public KnowledgeManager createLocal();
 	public KnowledgeManager removeLocal(KnowledgeManager km);
 	public List<KnowledgeManager> getLocals();
-	public void registerListener(LocalListener listener);
+	public void registerLocalListener(LocalListener listener);
 }

jdeeco-core/src/cz/cuni/mff/d3s/deeco/knowledge/ReplicaKnowledgeManagerContainer.java

@@ -8,7 +8,7 @@
  */
 public interface ReplicaKnowledgeManagerContainer {
 	public KnowledgeManager createReplicaFor(KnowledgeManager km);
-	public KnowledgeManager removeReplicaFor(KnowledgeManager km);
+	public KnowledgeManager removeReplica(KnowledgeManager km);
 	public List<KnowledgeManager> getReplicas();
-	public void registerListener(ReplicaListener listener);
+	public void registerReplicaListener(ReplicaListener listener);
 }

jdeeco-core/src/cz/cuni/mff/d3s/deeco/runtime/RuntimeFrameworkBuilder.java

@@ -2,6 +2,7 @@
 
 import cz.cuni.mff.d3s.deeco.executor.Executor;
 import cz.cuni.mff.d3s.deeco.executor.SameThreadExecutor;
+import cz.cuni.mff.d3s.deeco.knowledge.CloningKnowledgeManagerContainer;
 import cz.cuni.mff.d3s.deeco.knowledge.KnowledgeManagerContainer;
 import cz.cuni.mff.d3s.deeco.logging.Log;
 import cz.cuni.mff.d3s.deeco.model.runtime.api.RuntimeMetadata;
@@ -68,7 +69,7 @@ protected void buildExecutor() {
 	}
 
 	protected void buildKnowledgeManagerRegistry() {		
-		kmContainer = new KnowledgeManagerContainer();
+		kmContainer = new CloningKnowledgeManagerContainer();
 	}
 
 	protected void connect() {

jdeeco-core/src/cz/cuni/mff/d3s/deeco/runtime/RuntimeFrameworkImpl.java

@@ -57,12 +57,27 @@ public class RuntimeFrameworkImpl implements RuntimeFramework {
 	 */
 	public RuntimeFrameworkImpl(RuntimeMetadata model, Scheduler scheduler,
 			Executor executor, KnowledgeManagerContainer kmContainer) {
+		this(model, scheduler, executor, kmContainer, true);
+	}
+
+	RuntimeFrameworkImpl(RuntimeMetadata model, Scheduler scheduler,
+			Executor executor, KnowledgeManagerContainer kmContainer, boolean autoInit) {
+		if (model == null)
+			throw new IllegalArgumentException("Model cannot be null");
+		if (scheduler == null)
+			throw new IllegalArgumentException("Scheduler cannot be null");
+		if (executor == null)
+			throw new IllegalArgumentException("Executor cannot be null");
+		if (kmContainer == null)
+			throw new IllegalArgumentException("KnowledgeManagerContainer cannot be null");
+
 		this.scheduler = scheduler;
 		this.model = model;
 		this.executor = executor;
 		this.kmContainer = kmContainer;
 
-		init();
+		if (autoInit)
+			init();
 	}
 
 	/**
@@ -184,8 +199,9 @@ void componentInstanceRemoved(ComponentInstance instance) {
 
 		ComponentInstanceRecord ciRecord = componentRecords.get(instance);
 
-		for (ComponentProcess p: ciRecord.getProcessTasks().keySet()) {
-			componentProcessRemoved(instance, p);
+		while (!ciRecord.getProcessTasks().isEmpty()) {
+			ComponentProcess p = ciRecord.getProcessTasks().keySet().iterator().next();
+			componentProcessRemoved(instance, p);			
 		}	
 
 		for (Task t: ciRecord.getEnsembleTasks().values()) {