1 files changed, 304 insertions, 0 deletions
diff --git a/libraries/spongycastle/core/src/main/j2me/java/util/AbstractList.java b/libraries/spongycastle/core/src/main/j2me/java/util/AbstractList.java
new file mode 100644
index 000000000..dbb1dffc4
--- /dev/null
+++ b/libraries/spongycastle/core/src/main/j2me/java/util/AbstractList.java
@@ -0,0 +1,304 @@
+package java.util;
+
+public abstract class AbstractList
+    extends AbstractCollection
+    implements List
+{
+    protected AbstractList al = this;
+
+
+    protected AbstractList()
+    {
+    }
+
+    public boolean add(Object o)
+        throws RuntimeException, ClassCastException, IllegalArgumentException
+    {
+        try
+        {
+            add(size(), o);
+            return true;
+        }
+        catch (RuntimeException ue)
+        {
+            throw ue;
+        }
+    }
+
+    public abstract Object get(int index)
+        throws IndexOutOfBoundsException;
+
+    public Object set(int index, Object element)
+        throws RuntimeException, ClassCastException, IllegalArgumentException, IndexOutOfBoundsException
+    {
+        throw new RuntimeException();
+    }
+
+    public void add(int index, Object element)
+        throws RuntimeException, ClassCastException, IllegalArgumentException, IndexOutOfBoundsException
+    {
+        throw new RuntimeException();
+    }
+
+    public Object remove(int index)
+        throws RuntimeException, IndexOutOfBoundsException
+    {
+        Object o = get(index);
+
+        removeRange(index, index + 1);
+        return o;
+    }
+
+    public int indexOf(Object o)
+    {
+        ListIterator li = listIterator();
+        Object e;
+        while (li.hasNext())
+        {
+            int index = li.nextIndex();
+            e = li.next();
+
+            if (o == null)
+            {
+                if (e == null)
+                {
+                    return index;
+                }
+            }
+            else
+            {
+                if (o.equals(e))
+                {
+                    return index;
+                }
+            }
+        }
+        return -1;
+    }
+
+    public int lastIndexOf(Object o)
+    {
+        ListIterator li = listIterator(size());
+        while (li.hasPrevious())
+        {
+            int index = li.previousIndex();
+            Object e = li.previous();
+            if (o == null)
+            {
+                if (e == null)
+                {
+                    return index;
+                }
+            }
+            else
+            {
+                if (o.equals(e))
+                {
+                    return index;
+                }
+            }
+        }
+        return -1;
+    }
+
+    public void clear()
+        throws RuntimeException
+    {
+        try
+        {
+            removeRange(0, size());
+        }
+        catch (RuntimeException ue)
+        {
+            throw ue;
+        }
+    }
+
+    public boolean addAll(int index, Collection c)
+        throws RuntimeException, ClassCastException, IllegalArgumentException, IndexOutOfBoundsException
+    {
+        Iterator it = c.iterator();
+        boolean ret = false;
+        while (it.hasNext())
+        {
+            try
+            {
+                add(index++, it.next());
+                ret = true;
+            }
+            catch (RuntimeException ue)
+            {
+                throw ue;
+            }
+        }
+        return ret;
+    }
+
+    public Iterator iterator()
+    {
+        return new AbstractListIterator(this, 0);
+    }
+
+    public ListIterator listIterator()
+    {
+        return listIterator(0);
+    }
+
+    public ListIterator listIterator(int index)
+        throws IndexOutOfBoundsException
+    {
+        if (index < 0 || index > size())
+        {
+            throw new IndexOutOfBoundsException();
+        }
+        return new AbstractListListIterator(this, index);
+    }
+
+    public List subList(int fromIndex, int toIndex)
+        throws IndexOutOfBoundsException, IllegalArgumentException
+    {
+        if (fromIndex < 0 || toIndex > size())
+        {
+            throw new IndexOutOfBoundsException();
+        }
+        if (fromIndex > toIndex)
+        {
+            throw new IllegalArgumentException();
+        }
+        return (List)new Sublist(this, fromIndex, toIndex);
+    }
+
+    public boolean equals(Object o)
+    {
+        if (o == this)
+        {
+            return true;
+        }
+        if (!(o instanceof List))
+        {
+            return false;
+        }
+        Iterator it1 = iterator();
+        Iterator it2 = ((List)o).iterator();
+        while (it1.hasNext())
+        {
+            if (!it2.hasNext())
+            {
+                return false;
+            }
+            Object e1 = it1.next();
+            Object e2 = it2.next();
+            if (e1 == null)
+            {
+                if (e2 != null)
+                {
+                    return false;
+                }
+            }
+            if (!e1.equals(e2))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public int hashCode()
+    {
+        int hashCode = 1;
+        Iterator it = iterator();
+        while (it.hasNext())
+        {
+            Object o = it.next();
+            hashCode = 31 * hashCode + (o == null ? 0 : o.hashCode());
+        }
+        return hashCode;
+    }
+
+    protected void removeRange(int fromIndex, int toIndex)
+    {
+        if (fromIndex == toIndex)
+        {
+            return;
+        }
+
+        ListIterator li = listIterator(fromIndex);
+
+        int i = fromIndex;
+        do
+        {
+            li.next();
+            li.remove();
+            i++;
+        }
+        while (li.hasNext() && i < toIndex);
+    }
+
+    private class AbstractListIterator
+        implements Iterator
+    {
+        AbstractList m_al = null;
+        int m_nextIndex = 0;
+
+        public AbstractListIterator(AbstractList al, int index)
+        {
+            m_al = al;
+            m_nextIndex = index;
+        }
+
+        public boolean hasNext()
+        {
+            return m_nextIndex < m_al.size();
+        }
+
+        public Object next()
+        {
+            return m_al.get(m_nextIndex++);
+        }
+
+        public void remove()
+        {
+            m_al.remove(m_nextIndex - 1);
+        }
+    }
+
+    private class AbstractListListIterator
+        extends AbstractListIterator
+        implements ListIterator
+    {
+        public AbstractListListIterator(AbstractList al, int index)
+        {
+            super(al, index);
+        }
+
+        public boolean hasPrevious()
+        {
+            return m_nextIndex > 0;
+        }
+
+        public Object previous()// throws NoSuchElementException;
+        {
+            return m_al.get(--m_nextIndex);
+        }
+
+        public int nextIndex()
+        {
+            return m_nextIndex;
+        }
+
+        public int previousIndex()
+        {
+            return m_nextIndex - 1;
+        }
+
+        public void set(Object o) //throws RuntimeException, ClassCastException, IllegalArgumentException,IllegalStateException;
+        {
+            m_al.set(m_nextIndex - 1, o);
+        }
+
+        public void add(Object o)// throws RuntimeException, ClassCastException, IllegalArgumentException;
+        {
+            m_al.add(m_nextIndex - 1, o);
+        }
+    }
+}