final J2ME updates

Author: dghgit

buildj2me

@@ -170,12 +170,27 @@ then
         rm -r src/org/bouncycastle/apache
         rm -r src/org/bouncycastle/voms
         rm -r src/org/bouncycastle/math/ec/tools
+        rm src/org/bouncycastle/cert/test/ExternalKeyTest.java
         rm src/org/bouncycastle/mozilla/SignedPublicKeyAndChallenge.java
 
+        for i in src/org/bouncycastle/pqc/crypto/*/*.java
+        do
+            ed $i <<%%
+g/ .Override/d
+w
+q
+%%
+        done
+
         ed src/org/bouncycastle/cms/CMSSignedDataGenerator.java <<%
 g/LinkedHashSet/s//HashSet/g
 w
 q
+%
+        ed src/org/bouncycastle/openpgp/PGPEncryptedData.java <<%
+g/new UnsupportedOperationException/s//new RuntimeException/g
+w
+q
 %
         ed src/org/bouncycastle/openpgp/operator/bc/BcPGPDataEncryptorBuilder.java <<%
 g/public BcPGPDataEncryptorBuilder setWi/s//public PGPDataEncryptorBuilder setWi/g

core/src/main/j2me/java/util/Collections.java

@@ -2,14 +2,22 @@
 
 public class Collections
 {
-    public static List EMPTY_LIST = new UnmodifiableList(new ArrayList());
-
-    public static Set EMPTY_SET = new UnmodifiableSet(new HashSet());
+    public static final List EMPTY_LIST = unmodifiableList(new ArrayList());
+    public static final Set EMPTY_SET = unmodifiableSet(new HashSet());
 
     private Collections()
     {
     }
 
+    public static Set singleton(Object o)
+    {
+        Set rv = new HashSet();
+
+        rv.add(o);
+
+        return rv;
+    }
+
     public static Collection unmodifiableCollection(Collection c)
     {
         return new UnmodifiableCollection(c);
@@ -119,15 +127,6 @@ public static Set unmodifiableSet(Set s)
         return new UnmodifiableSet(s);
     }
 
-    public static Set singleton(Object o)
-    {
-        Set rv = new HashSet();
-
-        rv.add(o);
-
-        return rv;
-    }
-
     static class UnmodifiableSet
         extends UnmodifiableCollection
         implements Set
@@ -148,88 +147,6 @@ public int hashCode()
         }
     }
 
-    public static Map unmodifiableMap(Map map)
-    {
-        return new UnmodifiableMap(map);
-    }
-
-    static class UnmodifiableMap
-        implements Map
-    {
-        private Map map;
-
-        UnmodifiableMap(Map map)
-        {
-            this.map = map;
-        }
-
-        public int size()
-        {
-            return map.size();
-        }
-
-        public boolean isEmpty()
-        {
-            return map.isEmpty();
-        }
-
-        public boolean containsKey(Object key)
-            throws ClassCastException, NullPointerException
-        {
-            return map.containsKey(key);
-        }
-
-        public boolean containsValue(Object value)
-        {
-            return map.containsValue(value);
-        }
-
-        public Object get(Object key)
-            throws ClassCastException, NullPointerException
-        {
-            return map.get(key);
-        }
-
-        public Object put(Object key, Object value)
-            throws RuntimeException, ClassCastException, IllegalArgumentException, NullPointerException
-        {
-            throw new RuntimeException("unsupported operation - map unmodifiable");
-        }
-
-        public Object remove(Object key)
-            throws RuntimeException
-        {
-            throw new RuntimeException("unsupported operation - map unmodifiable");
-        }
-
-        public void putAll(Map t)
-            throws RuntimeException, ClassCastException, IllegalArgumentException, NullPointerException
-        {
-            throw new RuntimeException("unsupported operation - map unmodifiable");
-        }
-
-        public void clear()
-            throws RuntimeException
-        {
-            throw new RuntimeException("unsupported operation - map unmodifiable");
-        }
-
-        public Set keySet()
-        {
-            return map.keySet();
-        }
-
-        public Collection values()
-        {
-            return map.values();
-        }
-
-        public Set entrySet()
-        {
-            return map.entrySet();
-        }
-    }
-
     public static List unmodifiableList(List list)
     {
         return new UnmodifiableList(list);
@@ -373,4 +290,214 @@ public Object nextElement()
             }
         };
     }
+
+    public static Map unmodifiableMap(Map s)
+    {
+        return new UnmodifiableMap(s);
+    }
+
+    static class UnmodifiableMap
+        implements Map
+    {
+        private Map c;
+
+        UnmodifiableMap(Map map)
+        {
+            this.c = map;
+        }
+
+        public int size()
+        {
+            return c.size();
+        }
+
+        public boolean isEmpty()
+        {
+            return c.isEmpty();
+        }
+
+        public boolean containsKey(Object o)
+        {
+            return c.containsKey(o);
+        }
+
+        public boolean containsValue(Object o)
+        {
+            return c.containsValue(o);
+        }
+
+        public Object get(Object o)
+        {
+            return c.get(o);
+        }
+
+        public Object put(Object o, Object o2)
+        {
+            throw new RuntimeException();
+        }
+
+        public Object remove(Object o)
+        {
+            throw new RuntimeException();
+        }
+
+        public void putAll(Map map)
+        {
+            throw new RuntimeException();
+        }
+
+        public void clear()
+        {
+            throw new RuntimeException();
+        }
+
+        public Set keySet()
+        {
+            return Collections.unmodifiableSet(c.keySet());
+        }
+
+        public Collection values()
+        {
+            return new UnmodifiableCollection(c.values());
+        }
+
+        public Set entrySet()
+        {
+            return Collections.unmodifiableSet(c.entrySet());
+        }
+
+        public boolean equals(Object o)
+        {
+            return c.equals(o);
+        }
+
+        public int hashCode()
+        {
+            return c.hashCode();
+        }
+
+        public String toString()
+        {
+            return c.toString();
+        }
+    }
+
+    public static Set synchronizedSet(Set set)
+    {
+        return new SyncSet(set);
+    }
+
+    static class SyncSet implements Set
+    {
+        private Set base;
+
+        SyncSet(Set base)
+        {
+            this.base = base;
+        }
+
+        public int size()
+        {
+            synchronized (base)
+            {
+                return base.size();
+            }
+        }
+
+        public boolean isEmpty()
+        {
+            synchronized (base)
+            {
+                return base.isEmpty();
+            }
+        }
+
+        public boolean contains(Object o)
+        {
+            synchronized (base)
+            {
+                return base.contains(o);
+            }
+        }
+
+        public Iterator iterator()
+        {
+            synchronized (base)
+            {
+                return new ArrayList(base).iterator();
+            }
+        }
+
+        public Object[] toArray()
+        {
+            synchronized (base)
+            {
+                return base.toArray();
+            }
+        }
+
+        public boolean add(Object o)
+        {
+            synchronized (base)
+            {
+                return base.add(o);
+            }
+        }
+
+        public boolean remove(Object o)
+        {
+            synchronized (base)
+            {
+                return base.remove(o);
+            }
+        }
+
+        public boolean addAll(Collection collection)
+        {
+            synchronized (base)
+            {
+                return base.addAll(collection);
+            }
+        }
+
+        public void clear()
+        {
+            synchronized (base)
+            {
+                base.clear();
+            }
+        }
+
+        public boolean removeAll(Collection collection)
+        {
+            synchronized (base)
+            {
+                return base.removeAll(collection);
+            }
+        }
+
+        public boolean retainAll(Collection collection)
+        {
+            synchronized (base)
+            {
+                return base.retainAll(collection);
+            }
+        }
+
+        public boolean containsAll(Collection collection)
+        {
+            synchronized (base)
+            {
+                return base.containsAll(collection);
+            }
+        }
+
+        public Object[] toArray(Object[] objects)
+        {
+            synchronized (base)
+            {
+                return base.toArray(objects);
+            }
+        }
+    }
 }

core/src/main/j2me/org/bouncycastle/crypto/SecretWithEncapsulation.java

@@ -0,0 +1,25 @@
+package org.bouncycastle.crypto;
+
+/**
+ * Interface describing secret with encapsulation details.
+ */
+public interface SecretWithEncapsulation
+{
+// Destroyable methods
+    void destroy();
+    boolean isDestroyed();
+
+    /**
+     * Return the secret associated with the encapsulation.
+     *
+     * @return the secret the encapsulation is for.
+     */
+    byte[] getSecret();
+
+    /**
+     * Return the data that carries the secret in its encapsulated form.
+     *
+     * @return the encapsulation of the secret.
+     */
+    byte[] getEncapsulation();
+}