1 files changed, 242 insertions, 0 deletions
diff --git a/libraries/spongycastle/core/src/main/jdk1.1/java/util/AbstractCollection.java b/libraries/spongycastle/core/src/main/jdk1.1/java/util/AbstractCollection.java
new file mode 100644
index 000000000..0ea61b772
--- /dev/null
+++ b/libraries/spongycastle/core/src/main/jdk1.1/java/util/AbstractCollection.java
@@ -0,0 +1,242 @@
+package java.util;
+
+import java.lang.reflect.Array;
+/**
+ * Title:
+ * Description:
+ * Copyright:    Copyright (c) 2001
+ * Company:
+ * @version 1.0
+ */
+
+
+public abstract class AbstractCollection implements Collection
+    {
+        protected AbstractCollection()
+          {
+      }
+
+        public abstract Iterator iterator();
+
+        public abstract int size();
+
+        public boolean isEmpty()
+            {
+                return size()==0;
+            }
+
+        public boolean contains(Object o)
+            {
+                Iterator it=iterator();
+                while(it.hasNext())
+                    {
+                        Object e=it.next();
+                        if(o==null)
+                            {
+                              if(e==null)
+                                  return true;
+                            }
+                        else
+                            {
+                                if(o.equals(e))
+                                    return true;
+                            }
+                    }
+                return false;
+            }
+
+        public Object[] toArray()
+            {
+                Object[] arObjects=new Object[size()];
+                Iterator it=iterator();
+                int i=0;
+                while(it.hasNext())
+                    {
+                        arObjects[i++]=it.next();
+                    }
+                return arObjects;
+            }
+
+        public Object[] toArray(Object[] a) throws NullPointerException,ArrayStoreException
+        //TODO: Check if this is realy compatible to SUN!!!
+            {
+                if(a==null)
+                throw new NullPointerException();
+
+        if (isEmpty()) return a;
+                Object[] arObjects=null;
+                int size=size();
+                if(a.length<size)
+                    {
+                        Iterator it=iterator();
+                        Object o=it.next();
+                        if(o==null) //no object or object is null
+                            throw new ArrayStoreException(); //correct ?
+                        arObjects=(Object[])Array.newInstance(o.getClass(),size);
+                    }
+                else
+                    {
+                        arObjects=a;
+                         if(a.length>size)
+                          arObjects[size]=null;
+
+                    }
+
+                Iterator it=iterator();
+                int i=0;
+         while(it.hasNext())
+                    {
+                        Object o=it.next();
+            arObjects[i++]=o;
+            }
+                return arObjects;
+            }
+
+        public boolean add(Object o) throws UnsupportedOperationException,NullPointerException,ClassCastException,IllegalArgumentException
+            {
+                throw new UnsupportedOperationException();
+            }
+
+        public boolean remove(Object o) throws UnsupportedOperationException
+            {
+                Iterator it=iterator();
+                while(it.hasNext())
+                    {
+                        Object e=it.next();
+                        if(o==null)
+                            {
+                                if(e==null)
+                                    {
+                                      try
+                                            {
+                                                it.remove();
+                                            }
+                                        catch(UnsupportedOperationException ue)
+                                            {
+                                              throw ue;
+                                            }
+                                        return true;
+                                    }
+                            }
+                        else
+                          {
+                                if(o.equals(e))
+                                    {
+                                      try
+                                            {
+                                                it.remove();
+                                            }
+                                        catch(UnsupportedOperationException ue)
+                                            {
+                                              throw ue;
+                                            }
+                                        return true;
+                                    }
+                            }
+                    }
+                return false;
+            }
+
+        public boolean containsAll(Collection c)
+            {
+                Iterator it=c.iterator();
+                while(it.hasNext())
+                    {
+                        if(!contains(it.next()))
+                            return false;
+                    }
+                return true;
+            }
+
+        public boolean addAll(Collection c) throws UnsupportedOperationException
+            {
+                Iterator it=c.iterator();
+                boolean ret=false;
+                while(it.hasNext())
+                    {
+                        try
+                            {
+                                ret|=add(it.next());
+                            }
+                        catch(UnsupportedOperationException ue)
+                            {
+                                throw ue;
+                            }
+                    }
+                return ret;
+            }
+
+        public boolean removeAll(Collection c) throws UnsupportedOperationException
+            {
+                Iterator it=iterator();
+                boolean ret=false;
+                while(it.hasNext())
+                    {
+                        if(c.contains(it.next()))
+                            try
+                                {
+                                    it.remove();
+                                    ret=true;
+                                }
+                            catch(UnsupportedOperationException ue)
+                                {
+                                    throw ue;
+                                }
+                    }
+                return ret;
+            }
+
+        public boolean retainAll(Collection c) throws UnsupportedOperationException
+            {
+                Iterator it=iterator();
+                boolean ret=false;
+                while(it.hasNext())
+                    {
+                        if(!c.contains(it.next()))
+                            try
+                                {
+                                    it.remove();
+                                    ret=true;
+                                }
+                            catch(UnsupportedOperationException ue)
+                                {
+                                    throw ue;
+                                }
+                    }
+                return ret;
+            }
+
+        public void clear() throws UnsupportedOperationException
+            {
+                Iterator it=iterator();
+                while(it.hasNext())
+                    {
+                        try
+                            {
+                                it.next();
+                                it.remove();
+                            }
+                        catch(UnsupportedOperationException ue)
+                            {
+                                throw ue;
+                            }
+                    }
+            }
+
+        public String toString()
+            {
+                String ret="[";
+                Iterator it=iterator();
+                if(it.hasNext())
+                    ret+=String.valueOf(it.next());
+                while(it.hasNext())
+                    {
+                        ret+=", ";
+                        ret+=String.valueOf(it.next());
+
+                    }
+                ret+="]";
+                return ret;
+            }
+
+}