Implementato HashCode Dictionary via LinearProbing (Open Adress) e Chaining.

dictionary/Logfile.java

@@ -0,0 +1,131 @@
+package dictionary;
+
+import exceptions.InvalidEntryException;
+import position.NodePositionList;
+import position.Position;
+import priorityqueue.Entry;
+import priorityqueue.MyEntry;
+
+import java.security.InvalidKeyException;
+
+/**
+ * Created with MONSTER.
+ * User: xgiovio
+ * Date: 11/05/2014
+ * Time: 19:04
+ */
+public class Logfile<K,V> implements Dictionary<K,V> {
+
+      NodePositionList<Entry<K,V>> list = new NodePositionList<Entry<K,V>>();
+
+    @Override
+    public int size() {
+        return list.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return list.isEmpty();
+    }
+
+    @Override
+    public Entry<K, V> find(K key) throws InvalidKeyException {
+        checkKey(key);
+        for(Position<Entry<K,V>> p: list.positions()){
+            Entry<K,V> e= p.element();
+            if(e.getKey().equals(key)){
+                return e;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public Iterable<Entry<K, V>> findAll(K key) throws InvalidKeyException {
+        checkKey(key);
+        NodePositionList<Entry<K,V>> to_return = new NodePositionList<Entry<K,V>>();
+        for(Position<Entry<K,V>> p: list.positions()){
+            Entry<K,V> e= p.element();
+            if(e.getKey().equals(key)){
+                to_return.addLast(e);
+            }
+        }
+        return to_return;
+    }
+
+    @Override
+    public Entry<K, V> insert(K key, V value) throws InvalidKeyException {
+        checkKey(key);
+        LocationAwareEntry<K,V> t = new LocationAwareEntry<K, V>(key,value);
+        list.addLast(t);
+        t.setLocation(list.last());
+        return  t;
+    }
+
+    @Override
+    public Entry<K, V> remove(Entry<K, V> e) throws InvalidEntryException {
+        LocationAwareEntry<K,V> t = checkEntry(e);
+        list.remove(t.location());
+        t.setLocation(null);
+        return t;
+    }
+
+    @Override
+    public Iterable<Entry<K, V>> entries() {
+        return list;
+    }
+
+    //aux
+    protected void checkKey(K key) throws InvalidKeyException {
+        if (key == null )
+            throw new InvalidKeyException("Invalid key");
+    }
+
+    // inner class
+    protected static class LocationAwareEntry<K,V> extends MyEntry<K,V> {
+        protected Position<Entry<K, V>> loc = null;
+
+        public LocationAwareEntry(K k, V v) {
+            super(k, v);
+        }
+
+        public LocationAwareEntry(K k, V v, Position pos) {
+            super(k, v);
+            loc = pos;
+        }
+
+
+
+        protected Position < Entry<K,V>> location() {
+            return loc;
+        }
+        protected Position < Entry<K,V> >setLocation(Position< Entry<K,V>> pos) {
+            Position <Entry<K,V>> oldPosition = location();
+            loc = pos;
+            return oldPosition;
+        }
+        protected K setKey(K k) {
+            K oldKey = getKey();
+            key = k;
+            return oldKey;
+        }
+        protected V setValue(V v) {
+            V oldValue = getValue();
+            value = v;
+            return oldValue;
+        }
+
+        public String toString() { return "(" + key  + "," + value + ")"; }
+
+
+
+    }
+
+
+    protected LocationAwareEntry<K,V>   checkEntry(Entry<K,V> e) throws InvalidEntryException
+    {
+        if(e == null || !(e instanceof LocationAwareEntry) || isEmpty()  )
+            throw new InvalidEntryException("entrata non valida");
+        return (LocationAwareEntry) e;
+    }
+}