diff --git a/cadcAccessControl/src/ca/nrc/cadc/ac/UserSet.java b/cadcAccessControl/src/ca/nrc/cadc/ac/UserSet.java
new file mode 100644
index 0000000000000000000000000000000000000000..925de85bf40414d4e8f3a4dc156f5968c84ac5b3
--- /dev/null
+++ b/cadcAccessControl/src/ca/nrc/cadc/ac/UserSet.java
@@ -0,0 +1,163 @@
+package ca.nrc.cadc.ac;
+
+import java.security.Principal;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * A custom set built on a list implementation.
+ *
+ * Ordering will not be deterministic as per the Set specification.
+ */
+public class UserSet implements Set<User>
+{
+
+    private List<User> users;
+
+    public UserSet()
+    {
+        users = new ArrayList<User>();
+    }
+
+    public User getUser(Principal identity)
+    {
+        User test = null;
+        for (User u : users)
+        {
+            test = new User();
+            test.getIdentities().add(identity);
+            if (test.isConsistent(u))
+            {
+                return u;
+            }
+        }
+        return null;
+    }
+
+    public List<User> getUserList()
+    {
+        return users;
+    }
+
+    @Override
+    public boolean add(User e)
+    {
+        if (!users.contains(e))
+        {
+            users.add(e);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean addAll(Collection<? extends User> c)
+    {
+        Iterator<? extends User> i = c.iterator();
+        boolean modified = false;
+        while (i.hasNext())
+        {
+            if (this.add(i.next()))
+            {
+                modified = true;
+            }
+        }
+        return modified;
+    }
+
+    @Override
+    public void clear()
+    {
+        users.clear();
+    }
+
+    @Override
+    public boolean contains(Object o)
+    {
+        return users.contains(o);
+    }
+
+    @Override
+    public boolean containsAll(Collection<?> c)
+    {
+        return users.containsAll(c);
+    }
+
+    @Override
+    public boolean isEmpty()
+    {
+        return users.isEmpty();
+    }
+
+    @Override
+    public Iterator<User> iterator()
+    {
+        return users.iterator();
+    }
+
+    @Override
+    public boolean remove(Object o)
+    {
+        if (users.contains(o))
+        {
+            users.remove(o);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean removeAll(Collection<?> c)
+    {
+        Iterator<?> i = c.iterator();
+        boolean modified = false;
+        while (i.hasNext())
+        {
+            if (this.remove(i.next()))
+            {
+                modified = true;
+            }
+        }
+        return modified;
+    }
+
+    @Override
+    public boolean retainAll(Collection<?> c)
+    {
+        Iterator<User> i = users.listIterator();
+        boolean modified = false;
+        User next = null;
+        while (i.hasNext())
+        {
+            next = i.next();
+            if (!c.contains(next))
+            {
+                i.remove();
+                modified = true;
+            }
+        }
+        return modified;
+    }
+
+    @Override
+    public int size()
+    {
+        return users.size();
+    }
+
+    @Override
+    public Object[] toArray()
+    {
+        return users.toArray();
+    }
+
+    @Override
+    public <T> T[] toArray(T[] a)
+    {
+        return users.toArray(a);
+    }
+
+}