modificato arraysequence in fake e aggiunti una nuova versione. fidato alcuni metodi che restituivano void invece di position. sono necessari ulteriori test

2014-03-31 22:43:48 +02:00
parent 483863d410
commit eb15d53208
8 changed files with 414 additions and 76 deletions
--- a/sequence/ArraySequenceFake.java
+++ b/sequence/ArraySequenceFake.java
@@ -0,0 +1,224 @@
+package sequence;
+
+import arraylist.ArrayIndexList;
+import exceptions.BoundaryViolationException;
+import exceptions.EmptyListException;
+import exceptions.EmptySequenceException;
+import exceptions.InvalidPositionException;
+import position.Position;
+import sequence.utility.DNodeFake;
+
+/**
+ * Created with MONSTER.
+ * User: xgiovio
+ * Date: 30/03/2014
+ * Time: 17:19
+ */
+
+ // fake positions created on the fly. if the element in the array change, it doesn't change on the position retrieved before.
+
+
+public class ArraySequenceFake<E> extends ArrayIndexList<E> implements Sequence<E> {
+
+
+    public ArraySequenceFake(int in){
+        super(in);
+    }
+
+    @Override
+    public E getFirst() throws EmptySequenceException {
+        try {
+            E ele = get(0);
+            return ele;
+        }
+        catch (IndexOutOfBoundsException err){
+            throw new EmptySequenceException();
+        }
+    }
+
+    @Override
+    public E getLast() throws EmptySequenceException {
+        try {
+            E ele = get(size()-1);
+            return ele;
+        }
+        catch (IndexOutOfBoundsException err){
+            throw new EmptySequenceException();
+        }
+    }
+
+    @Override
+    public E removeFirst() throws EmptySequenceException {
+        try {
+            E ele = remove(0);
+            return ele;
+        }
+        catch (IndexOutOfBoundsException err){
+            throw new EmptySequenceException();
+        }
+    }
+
+    @Override
+    public E removeLast() throws EmptySequenceException {
+        try {
+            E ele = remove(size() - 1);
+            return ele;
+        }
+        catch (IndexOutOfBoundsException err){
+            throw new EmptySequenceException();
+        }
+    }
+
+    @Override
+    public Position<E> atIndex(int in_index) throws BoundaryViolationException {
+        try {
+            checkIndex(in_index, size());
+            return new DNodeFake<E>(get(in_index),in_index);
+        }
+        catch (IndexOutOfBoundsException err){
+            throw new BoundaryViolationException();
+        }
+    }
+
+    @Override
+    public int indexOf(Position<E> position) throws InvalidPositionException {
+        checkPosition(position);
+        return ((DNodeFake<E>) position).getIndex();
+    }
+
+    @Override
+    public Position<E> first() throws EmptyListException {
+        try{
+            return new DNodeFake<E>(get(0),0);
+        }
+        catch (IndexOutOfBoundsException err){
+            throw new EmptyListException("Empty Array");
+        }
+    }
+
+    @Override
+    public Position<E> last() throws EmptyListException {
+        try{
+            return new DNodeFake<E>(get(size() - 1),size() - 1);
+        }
+        catch (IndexOutOfBoundsException err){
+            throw new EmptyListException("Empty Array");
+        }
+    }
+
+    @Override
+    public Position<E> next(Position<E> p) throws InvalidPositionException, BoundaryViolationException {
+        DNodeFake<E> t = checkPosition(p);
+        if (t.getIndex()< size() -1){
+            return new DNodeFake<E>(get(t.getIndex() + 1),t.getIndex() + 1);
+        }else{
+            throw new BoundaryViolationException();
+        }
+    }
+
+    @Override
+    public Position<E> prev(Position<E> p) throws InvalidPositionException, BoundaryViolationException {
+        DNodeFake<E> t = checkPosition(p);
+        if (t.getIndex()> 0){
+            return new DNodeFake<E>(get(t.getIndex() - 1),t.getIndex() - 1);
+        }else{
+            throw new BoundaryViolationException();
+        }
+    }
+
+    @Override
+    public void addFirst(E e) {
+      add (0,e);
+    }
+
+    @Override
+    public void addLast(E e) {
+      add (size(),e);
+    }
+
+    @Override
+    public Position<E> addAfter(Position<E> p, E e) throws InvalidPositionException {
+        try {
+            DNodeFake<E> t = checkPosition(p);
+            add(t.getIndex() + 1, e);
+            return new DNodeFake<E>(get(t.getIndex() + 1),t.getIndex() + 1);
+        }
+        catch (IndexOutOfBoundsException err){
+            throw new InvalidPositionException();
+        }
+    }
+
+    @Override
+    public Position<E> addBefore(Position<E> p, E e) throws InvalidPositionException {
+        try {
+            DNodeFake<E> t = checkPosition(p);
+            add(t.getIndex() - 1,e);
+            return new DNodeFake<E>(get(t.getIndex() - 1),t.getIndex() - 1);
+        }
+        catch (IndexOutOfBoundsException err){
+            throw new InvalidPositionException();
+        }
+    }
+
+    @Override
+    public E remove(Position<E> p) throws InvalidPositionException {
+        try {
+        DNodeFake<E> t = checkPosition(p);
+        return remove(t.getIndex());
+        }
+        catch (IndexOutOfBoundsException err){
+            throw new InvalidPositionException();
+        }
+    }
+
+    @Override
+    public E set(Position<E> p, E e) throws InvalidPositionException {
+        try {
+            DNodeFake<E> t = checkPosition(p);
+            return set (t.getIndex(),e);
+        }
+        catch (IndexOutOfBoundsException err){
+            throw new InvalidPositionException();
+        }
+
+
+    }
+
+    @Override
+    public String toString() {
+        String to_return = "";
+        to_return = to_return + "[";
+
+        for (  int i = 0; i< size() ; i++){
+
+            if ( i== size() -1){
+                to_return+=(get(i).toString());
+            }else{
+                to_return+=(get(i).toString() + ",");
+            }
+        }
+        to_return = to_return + "]";
+
+        return to_return;
+    }
+
+    protected DNodeFake<E> checkPosition(Position<E> p)  throws InvalidPositionException {
+        if (p == null)
+            throw new InvalidPositionException
+                    ("Null position passed");
+
+        try {
+            DNodeFake<E> temp = (DNodeFake<E>) p;
+            if ( temp.getIndex() >= size() || temp.getIndex() < 0 )
+                throw new InvalidPositionException
+                        ("Position does not belong to a valid value");
+            return temp;
+        } catch (ClassCastException e) {
+            throw new InvalidPositionException
+                    ("Position is of wrong type for this array");
+        }
+    }
+
+
+
+}