Renamed SSList -> AccessPriorityList

+ implemented clear()

Signed-off-by: bartimaeusnek <33183715+bartimaeusnek@users.noreply.github.com>

Former-commit-id: 56a7fd3f407454fb1eee55ec8e02a255267fbce8

4 files changed, 67 insertions, 56 deletions

diff --git a/src/main/java/com/github/bartimaeusnek/ASM/BWCoreStaticReplacementMethodes.java b/src/main/java/com/github/bartimaeusnek/ASM/BWCoreStaticReplacementMethodes.java
index d5d35e50a5..53a0fff182 100644
--- a/src/main/java/com/github/bartimaeusnek/ASM/BWCoreStaticReplacementMethodes.java
+++ b/src/main/java/com/github/bartimaeusnek/ASM/BWCoreStaticReplacementMethodes.java
@@ -22,7 +22,7 @@
 
 package com.github.bartimaeusnek.ASM;
 
-import com.github.bartimaeusnek.bartworks.util.selfsortinglist.SSList;
+import com.github.bartimaeusnek.bartworks.util.accessprioritylist.AccessPriorityList;
 import net.minecraft.inventory.InventoryCrafting;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
@@ -35,7 +35,7 @@ import java.util.Optional;
 
 public class BWCoreStaticReplacementMethodes {
 
-    public static final SSList<IRecipe> RECENTLYUSEDRECIPES = new SSList<>();
+    public static final AccessPriorityList<IRecipe> RECENTLYUSEDRECIPES = new AccessPriorityList<>();
 
     @SuppressWarnings("ALL")
     public static ItemStack findCachedMatchingRecipe(InventoryCrafting inventoryCrafting, World world) {
diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/util/selfsortinglist/SSList.java b/src/main/java/com/github/bartimaeusnek/bartworks/util/accessprioritylist/AccessPriorityList.java
index 769b32638d..8f0cd8dd41 100644
--- a/src/main/java/com/github/bartimaeusnek/bartworks/util/selfsortinglist/SSList.java
+++ b/src/main/java/com/github/bartimaeusnek/bartworks/util/accessprioritylist/AccessPriorityList.java
@@ -20,26 +20,26 @@
  * SOFTWARE.
  */
 
-package com.github.bartimaeusnek.bartworks.util.selfsortinglist;
+package com.github.bartimaeusnek.bartworks.util.accessprioritylist;
 
 import java.util.*;
 
-public class SSList<E> implements List<E>, Deque<E>, Set<E> {
+public class AccessPriorityList<E> implements List<E>, Deque<E>, Set<E> {
 
     transient int size = 0;
-    transient SSListNode<E> head;
-    transient SSListNode<E> tail;
+    transient AccessPriorityListNode<E> head;
+    transient AccessPriorityListNode<E> tail;
 
-    public static SSList create(){
-        return new SSList();
+    public static AccessPriorityList create(){
+        return new AccessPriorityList();
     }
 
-    public SSList() {}
+    public AccessPriorityList() {}
 
     @Override
     public void addFirst(E t) {
-        final SSListNode<E> first = head;
-        final SSListNode<E> newNode = new SSListNode<>(null, t, first);
+        final AccessPriorityListNode<E> first = head;
+        final AccessPriorityListNode<E> newNode = new AccessPriorityListNode<>(null, t, first);
         head = newNode;
         if (first == null)
             tail = newNode;
@@ -50,8 +50,8 @@ public class SSList<E> implements List<E>, Deque<E>, Set<E> {
 
     @Override
     public void addLast(E t) {
-        final SSListNode<E> last = tail;
-        final SSListNode<E> newNode = new SSListNode<>(last, t, null);
+        final AccessPriorityListNode<E> last = tail;
+        final AccessPriorityListNode<E> newNode = new AccessPriorityListNode<>(last, t, null);
         tail = newNode;
         if (last == null)
             head = newNode;
@@ -137,12 +137,12 @@ public class SSList<E> implements List<E>, Deque<E>, Set<E> {
 
     @Override
     public Iterator<E> iterator() {
-        return new SSListIterators.SSListIterator<>(head);
+        return new AccessPriorityListIterators.AccessPriorityListIterator<>(head);
     }
 
     @Override
     public Iterator<E> descendingIterator() {
-        return new SSListIterators.SSListReverseIterator<>(tail);
+        return new AccessPriorityListIterators.AccessPriorityListReverseIterator<>(tail);
     }
 
     @Override
@@ -167,12 +167,12 @@ public class SSList<E> implements List<E>, Deque<E>, Set<E> {
         return true;
     }
 
-    private void moveNodeUp(SSListNode<E> node){
+    private void moveNodeUp(AccessPriorityListNode<E> node){
         if (node == head || node.getBefore() == null)
             return;
-        final SSListNode<E> before = node.getBefore();
-        final SSListNode<E> beforeBefore = before.getBefore();
-        final SSListNode<E> next = node.getNext();
+        final AccessPriorityListNode<E> before = node.getBefore();
+        final AccessPriorityListNode<E> beforeBefore = before.getBefore();
+        final AccessPriorityListNode<E> next = node.getNext();
 
         // <0,1,2> <1,2,3> N<2,3,4> <3,4,5>
 
@@ -197,14 +197,14 @@ public class SSList<E> implements List<E>, Deque<E>, Set<E> {
         // <0,1,3> N<0,3,2> <3,2,4> <2,4,5>
     }
 
-    SSListNode<E> getNode(int index) {
+    AccessPriorityListNode<E> getNode(int index) {
         if (index <= (size / 2)) {
-            SSListNode<E> x = head;
+            AccessPriorityListNode<E> x = head;
             for (int i = 0; i < index; i++)
                 x = x.getNext();
             return x;
         } else {
-            SSListNode<E> x = tail;
+            AccessPriorityListNode<E> x = tail;
             for (int i = size - 1; i > index; i--)
                 x = x.getBefore();
             return x;
@@ -237,7 +237,7 @@ public class SSList<E> implements List<E>, Deque<E>, Set<E> {
 
     @Override
     public E peek() {
-        return null;
+        return getFirst();
     }
 
     @Override
@@ -285,13 +285,24 @@ public class SSList<E> implements List<E>, Deque<E>, Set<E> {
 
     @Override
     public void clear() {
-
+        if (tail != null) {
+            AccessPriorityListNode<E> node = tail;
+            while (node.getBefore() != null) {
+                node.setNext(null);
+                node.setPriority(0L);
+                node = node.getBefore();
+                node.getNext().setBefore(null);
+            }
+            this.size = 0;
+            this.head = null;
+            this.tail = null;
+        }
     }
 
     public void addPrioToNode(int index, long prio){
         if (!isValidIndex(index))
             return;
-        SSListNode<E> node = getNode(index);
+        AccessPriorityListNode<E> node = getNode(index);
         node.setPriority(node.getPriority()+prio);
         while (node.getBefore() != null && node.getPriority() > node.getBefore().getPriority()){
                 moveNodeUp(node);
@@ -306,7 +317,7 @@ public class SSList<E> implements List<E>, Deque<E>, Set<E> {
     public E get(int index) {
         if (!isValidIndex(index))
             return null;
-        SSListNode<E> node = getNode(index);
+        AccessPriorityListNode<E> node = getNode(index);
         return node.getELEMENT();
     }
 
@@ -337,12 +348,12 @@ public class SSList<E> implements List<E>, Deque<E>, Set<E> {
 
     @Override
     public ListIterator<E> listIterator() {
-        return new SSListIterators.SSListListIterator<>(head,tail,false);
+        return new AccessPriorityListIterators.AccessPriorityListListIterator<>(head,tail,false);
     }
 
     @Override
     public ListIterator<E> listIterator(int index) {
-        return new SSListIterators.SSListListIterator<>(this,index);
+        return new AccessPriorityListIterators.AccessPriorityListListIterator<>(this,index);
     }
 
     @Override
diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/util/selfsortinglist/SSListIterators.java b/src/main/java/com/github/bartimaeusnek/bartworks/util/accessprioritylist/AccessPriorityListIterators.java
index 83b3c66046..3b85030d1e 100644
--- a/src/main/java/com/github/bartimaeusnek/bartworks/util/selfsortinglist/SSListIterators.java
+++ b/src/main/java/com/github/bartimaeusnek/bartworks/util/accessprioritylist/AccessPriorityListIterators.java
@@ -20,30 +20,30 @@
  * SOFTWARE.
  */
 
-package com.github.bartimaeusnek.bartworks.util.selfsortinglist;
+package com.github.bartimaeusnek.bartworks.util.accessprioritylist;
 
 import org.apache.commons.lang3.NotImplementedException;
 
 import java.util.Iterator;
 import java.util.ListIterator;
 
-public class SSListIterators {
+public class AccessPriorityListIterators {
 
 
-    public static class SSListListIterator<E> implements ListIterator<E> {
-        final SSListNode<E> head;
-        final SSListNode<E> tail;
-        SSListNode<E> current;
+    public static class AccessPriorityListListIterator<E> implements ListIterator<E> {
+        final AccessPriorityListNode<E> head;
+        final AccessPriorityListNode<E> tail;
+        AccessPriorityListNode<E> current;
         int counter = 0;
         boolean reverse;
-        public SSListListIterator(SSListNode<E> head,SSListNode<E> tail, boolean reverse) {
+        public AccessPriorityListListIterator(AccessPriorityListNode<E> head, AccessPriorityListNode<E> tail, boolean reverse) {
             this.head = head;
             this.tail = tail;
             current = reverse ? tail : head;
             this.reverse = reverse;
         }
 
-        public SSListListIterator(SSList<E> list, int index) {
+        public AccessPriorityListListIterator(AccessPriorityList<E> list, int index) {
             this.head = list.head;
             this.tail = list.tail;
             current = list.getNode(index);
@@ -102,10 +102,10 @@ public class SSListIterators {
         }
     }
 
-    public static class SSListIterator<E> implements Iterator<E> {
-        final SSListNode<E> head;
-        SSListNode<E> current;
-        public SSListIterator(SSListNode<E> head) {
+    public static class AccessPriorityListIterator<E> implements Iterator<E> {
+        final AccessPriorityListNode<E> head;
+        AccessPriorityListNode<E> current;
+        public AccessPriorityListIterator(AccessPriorityListNode<E> head) {
             this.head = this.current = head;
         }
 
@@ -122,11 +122,11 @@ public class SSListIterators {
         }
     }
 
-    public static class SSListReverseIterator<E> implements Iterator<E> {
-        final SSListNode<E> tail;
-        SSListNode<E> current;
+    public static class AccessPriorityListReverseIterator<E> implements Iterator<E> {
+        final AccessPriorityListNode<E> tail;
+        AccessPriorityListNode<E> current;
 
-        public SSListReverseIterator(SSListNode<E> tail) {
+        public AccessPriorityListReverseIterator(AccessPriorityListNode<E> tail) {
             this.tail = this.current = tail;
         }
 
diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/util/selfsortinglist/SSListNode.java b/src/main/java/com/github/bartimaeusnek/bartworks/util/accessprioritylist/AccessPriorityListNode.java
index f9c509019e..b8fd357027 100644
--- a/src/main/java/com/github/bartimaeusnek/bartworks/util/selfsortinglist/SSListNode.java
+++ b/src/main/java/com/github/bartimaeusnek/bartworks/util/accessprioritylist/AccessPriorityListNode.java
@@ -20,27 +20,27 @@
  * SOFTWARE.
  */
 
-package com.github.bartimaeusnek.bartworks.util.selfsortinglist;
+package com.github.bartimaeusnek.bartworks.util.accessprioritylist;
 
-public class SSListNode<E> {
+public class AccessPriorityListNode<E> {
 
-    public final static SSListNode EMPTY_NODE = new SSListNode(null);
+    public final static AccessPriorityListNode EMPTY_NODE = new AccessPriorityListNode(null);
 
     private final E ELEMENT;
     private long priority = Long.MIN_VALUE;
-    private SSListNode<E> next;
-    private SSListNode<E> before;
+    private AccessPriorityListNode<E> next;
+    private AccessPriorityListNode<E> before;
 
-    public SSListNode(E element) {
+    public AccessPriorityListNode(E element) {
         ELEMENT = element;
     }
 
-    public SSListNode(SSListNode<E> before, E element, SSListNode<E> next) {
+    public AccessPriorityListNode(AccessPriorityListNode<E> before, E element, AccessPriorityListNode<E> next) {
         this.ELEMENT = element;
         connect(next, before);
     }
 
-    public void connect(SSListNode<E> next, SSListNode<E> before){
+    public void connect(AccessPriorityListNode<E> next, AccessPriorityListNode<E> before){
         this.setNext(next);
         this.setBefore(before);
     }
@@ -57,19 +57,19 @@ public class SSListNode<E> {
         this.priority = priority;
     }
 
-    public SSListNode<E> getNext() {
+    public AccessPriorityListNode<E> getNext() {
         return next;
     }
 
-    public void setNext(SSListNode<E> next) {
+    public void setNext(AccessPriorityListNode<E> next) {
         this.next = next;
     }
 
-    public SSListNode<E> getBefore() {
+    public AccessPriorityListNode<E> getBefore() {
         return before;
     }
 
-    public void setBefore(SSListNode<E> before) {
+    public void setBefore(AccessPriorityListNode<E> before) {
         this.before = before;
     }
 }