8266571: Sequenced Collections

Reviewed-by: alanb

src/java.base/share/classes/java/util/AbstractMap.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,6 +25,11 @@
 
 package java.util;
 
+import java.util.stream.Stream;
+import java.util.function.Consumer;
+import java.util.function.IntFunction;
+import java.util.function.Predicate;
+
 /**
  * This class provides a skeletal implementation of the {@code Map}
  * interface, to minimize the effort required to implement this interface.
@@ -875,7 +880,48 @@ public abstract class AbstractMap<K,V> implements Map<K,V> {
         public String toString() {
             return key + "=" + value;
         }
-
     }
 
+    /**
+     * Delegates all Collection methods to the provided non-sequenced map view,
+     * except add() and addAll(), which throw UOE. This provides the common
+     * implementation of each of the sequenced views of the SequencedMap.
+     * Each view implementation is a subclass that provides an instance of the
+     * non-sequenced view as a delegate and an implementation of reversed().
+     * Each view also inherits the default implementations for the sequenced
+     * methods from SequencedCollection or SequencedSet.
+     * <p>
+     * Ideally this would be a private class within SequencedMap, but private
+     * classes aren't permitted within interfaces.
+     *
+     * @param <E> the view's element type
+     */
+    /* non-public */ abstract static class ViewCollection<E> implements Collection<E> {
+        UnsupportedOperationException uoe() { return new UnsupportedOperationException(); }
+        final Collection<E> view;
+
+        ViewCollection(Collection<E> view) { this.view = view; }
+
+        public boolean add(E t) { throw uoe(); }
+        public boolean addAll(Collection<? extends E> c) { throw uoe(); }
+        public void clear() { view.clear(); }
+        public boolean contains(Object o) { return view.contains(o); }
+        public boolean containsAll(Collection<?> c) { return view.containsAll(c); }
+        public boolean equals(Object o) { return view.equals(o); }
+        public void forEach(Consumer<? super E> c) { view.forEach(c); }
+        public int hashCode() { return view.hashCode(); }
+        public boolean isEmpty() { return view.isEmpty(); }
+        public Iterator<E> iterator() { return view.iterator(); }
+        public Stream<E> parallelStream() { return view.parallelStream(); }
+        public boolean remove(Object o) { return view.remove(o); }
+        public boolean removeAll(Collection<?> c) { return view.removeAll(c); }
+        public boolean removeIf(Predicate<? super E> filter) { return view.removeIf(filter); }
+        public boolean retainAll(Collection<?> c) { return view.retainAll(c); }
+        public int size() { return view.size(); }
+        public Spliterator<E> spliterator() { return view.spliterator(); }
+        public Stream<E> stream() { return view.stream(); }
+        public Object[] toArray() { return view.toArray(); }
+        public <T> T[] toArray(IntFunction<T[]> generator) { return view.toArray(generator); }
+        public <T> T[] toArray(T[] a) { return view.toArray(a); }
+    }
 }