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

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

@@ -1,44 +1,113 @@
 package cz.cuni.mff.d3s.deeco.knowledge;
 
 import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Map.Entry;
 
-import cz.cuni.mff.d3s.deeco.knowledge.KnowledgeSet.KnowledgeValue;
+/**
+ * Container for a set of changes to a component's knowledge.
+ * 
+ * <p>
+ * Contains a set of deleted {@link KnowledgeReference}s and values
+ * corresponding to a set of added/updated {@link KnowledgeReference}s.
+ * </p>
+ * 
+ * <p>
+ * Implemented as a map reference->value, where a special EMPTY value indicates
+ * that the reference is to be deleted
+ * </p>
+ * 
+ * <p>
+ * TODO: maybe the class would need a separate list of references to be added
+ * (i.e., to be added, to be updated, and to be deleted) so that we can enforce
+ * some knowledge update rules (i.e., update is possible only at some places).
+ * </p>
+ * 
+ * @author Jaroslav Keznikl <keznikl@d3s.mff.cuni.cz>
+ * 
+ */
 
-// TODO: maybe the class would need a separate of references to be added (i.e., to be added, to be updated, and to be deleted)
-// so that we can enforce some knowledge update rules (i.e., update is possible only at some places)
 public class ChangeSet {
+	/**
+	 * Singleton indicating a reference to be deleted.
+	 */
+	private enum KnowledgeValue { EMPTY } 
 
-	private KnowledgeSet ks;
+	/**
+	 * The reference->value map.
+	 */
+	private Map<KnowledgeReference, Object> values = new HashMap<>();
 
-	public ChangeSet() {
-		ks = new KnowledgeSet();
-	}
 
-	ChangeSet(KnowledgeSet ks) {
-		this.ks = ks;
-	}
-
+	/**
+	 * Returns all added/updated references.
+	 */
 	public Collection<KnowledgeReference> getUpdatedReferences() {
-		return ks.getNonEmptyReferences();
+		/*
+		 * The added/updated references are those not being assigned the value
+		 * KnowledgeValue.EMPTY
+		 */
+		Collection<KnowledgeReference> ret = new HashSet<>();
+		for (Entry<KnowledgeReference, Object> e: values.entrySet()) {
+			if (e.getValue() != KnowledgeValue.EMPTY)
+				ret.add(e.getKey());
+		}
+		return ret;	
 	}
 
+	/**
+	 * Returns all deleted references.
+	 */
 	public Collection<KnowledgeReference> getDeletedReferences() {
-		return ks.getEmptyReferences();
+		/*
+		 * The deleted references are those that are assigned the value
+		 * KnowledgeValue.EMPTY
+		 */
+		Collection<KnowledgeReference> ret = new HashSet<>();
+		for (Entry<KnowledgeReference, Object> e: values.entrySet()) {
+			if (e.getValue() == KnowledgeValue.EMPTY)
+				ret.add(e.getKey());
+		}
+		return ret;
 	}
 
+	/**
+	 * Returns the value for the {@code reference}.
+	 * <p>
+	 * Returns null if the reference is not included in the {@link ChangeSet} or
+	 * if the reference is deleted. Otherwise returns the added/updated value.
+	 * </p>
+	 */
 	public Object getValue(KnowledgeReference reference) {
-		Object ret = ks.getValue(reference);
+		if (!values.containsKey(reference))
+			return null;
+
+		Object ret = values.get(reference);
 		if (ret == KnowledgeValue.EMPTY)
 			return null;
 		else 
 			return ret;
 	}
 
+	/**
+	 * Sets the {@code value} for the {@code reference}.
+	 * 
+	 * Overrides previous calls of {@link #setDeleted(KnowledgeReference)} and
+	 * {@link #setValue(KnowledgeReference, Object)}.
+	 */
 	public void setValue(KnowledgeReference reference, Object value) {
-		ks.setValue(reference, value);		
+		values.put(reference, value);		
 	}
 
+	/**
+	 * Marks the {@code reference} as deleted.
+	 * 
+	 * Overrides previous calls of {@link #setDeleted(KnowledgeReference)} and
+	 * {@link #setValue(KnowledgeReference, Object)}.
+	 */
 	public void setDeleted(KnowledgeReference reference) {
-		ks.setValue(reference, KnowledgeValue.EMPTY);		
+		values.put(reference, KnowledgeValue.EMPTY);		
 	}
 }

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

@@ -14,20 +14,18 @@
 
 public class KnowledgeManagerImpl implements KnowledgeManager {
 
-	protected KnowledgeSet ks;
+
 
 	public KnowledgeManagerImpl(){
 
-		ks = new KnowledgeSet();
+
 	}
 
-	public KnowledgeManagerImpl(KnowledgeSet ks){
-		this.ks = ks;
-	}
+
 
 	@Override
 	public ValueSet get(Collection<KnowledgeReference> knowledgeReferenceList) {
-		ValueSet vs = new ValueSet(ks);
+		ValueSet vs = new ValueSet();
 		return vs;
 	}
 

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

@@ -1,47 +1,48 @@
 package cz.cuni.mff.d3s.deeco.knowledge;
 
 import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
 
-import cz.cuni.mff.d3s.deeco.knowledge.KnowledgeSet.KnowledgeValue;
-
+/**
+ * Container for knowledge values corresponding to a set of {@link KnowledgeReference}s.
+ * 
+ * Allows storing {@code null} references.
+ *  
+ * @author Jaroslav Keznikl <keznikl@d3s.mff.cuni.cz>
+ *
+ */
 public class ValueSet {
 
-	// FIXME: Doesn't have to be a knowledge set, can be just a hashmap. Then KnowledgeSet can be merged with ChangeSet because it does not serve for any other purpose.
-	private KnowledgeSet ks;
-
-	public ValueSet() {
-		ks = new KnowledgeSet();
-	}
 
-	ValueSet(KnowledgeSet ks) {
-		this.ks = ks;
-	}
-
-	// FIXME: Better would be getReferences
-	public Collection<KnowledgeReference> getFoundReferences() {
-		return ks.getNonEmptyReferences();
-	}
+	private Map<KnowledgeReference, Object> values = new HashMap<>();
 
-	// FIXME: We actually don't need this. When it's not there, it is just not there.
-	public Collection<KnowledgeReference> getNotFoundReferences() {
-		return ks.getEmptyReferences();
+	/**
+	 * Returns the list of {@link KnowledgeReference}s for which the container contains a value.
+	 */
+	public Collection<KnowledgeReference> getReferences() {
+		return values.keySet();
 	}
 
-	public Object getValue(KnowledgeReference reference) {
-		Object ret = ks.getValue(reference);
-		// FIXME: Should not get to a value set, assert would be better
-		if (ret == KnowledgeValue.EMPTY)
+	/**
+	 * Returns the value for the {@code reference}.
+	 * 
+	 * If there is no value for the reference, returns {@code null}. Note that
+	 * the value for a reference can also be {@code null}, thus it is necessary
+	 * to check {@link #getReferences()} to distinguish between references
+	 * with/without a value.
+	 */
+	public Object getValue(KnowledgeReference reference) {	
+		if (values.containsKey(reference))
+			return values.get(reference);
+		else
 			return null;
-		else 
-			return ret;
-	}
-
-	public void setValue(KnowledgeReference reference, Object value) {
-		ks.setValue(reference, value);		
 	}
 
-	// FIXME: We actually don't need this. When it's not there, it is just not there.
-	public void setNotFound(KnowledgeReference reference) {
-		ks.setValue(reference, KnowledgeValue.EMPTY);		
-	}
+	/**
+	 * Sets the {@code value} for the {@code reference}.
+	 */
+	public void setValue(KnowledgeReference reference, Object value) {		
+		values.put(reference, value);		
+	}	
 }