1 /*
2  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * This code is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 only, as
7  * published by the Free Software Foundation.  Oracle designates this
8  * particular file as subject to the "Classpath" exception as provided
9  * by Oracle in the LICENSE file that accompanied this code.
10  *
11  * This code is distributed in the hope that it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14  * version 2 for more details (a copy is included in the LICENSE file that
15  * accompanied this code).
16  *
17  * You should have received a copy of the GNU General Public License version
18  * 2 along with this work; if not, write to the Free Software Foundation,
19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20  *
21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22  * or visit www.oracle.com if you need additional information or have any
23  * questions.
24  */
25 
26 package java.util;
27 
28 import android.compat.annotation.UnsupportedAppUsage;
29 
30 @SuppressWarnings({"unchecked", "deprecation", "all"})
31 public class LinkedHashMap<K, V> extends java.util.HashMap<K, V> implements java.util.Map<K, V> {
32 
LinkedHashMap(int initialCapacity, float loadFactor)33     public LinkedHashMap(int initialCapacity, float loadFactor) {
34         throw new RuntimeException("Stub!");
35     }
36 
LinkedHashMap(int initialCapacity)37     public LinkedHashMap(int initialCapacity) {
38         throw new RuntimeException("Stub!");
39     }
40 
LinkedHashMap()41     public LinkedHashMap() {
42         throw new RuntimeException("Stub!");
43     }
44 
LinkedHashMap(java.util.Map<? extends K, ? extends V> m)45     public LinkedHashMap(java.util.Map<? extends K, ? extends V> m) {
46         throw new RuntimeException("Stub!");
47     }
48 
LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)49     public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
50         throw new RuntimeException("Stub!");
51     }
52 
linkNodeLast(java.util.LinkedHashMap.LinkedHashMapEntry<K, V> p)53     private void linkNodeLast(java.util.LinkedHashMap.LinkedHashMapEntry<K, V> p) {
54         throw new RuntimeException("Stub!");
55     }
56 
transferLinks( java.util.LinkedHashMap.LinkedHashMapEntry<K, V> src, java.util.LinkedHashMap.LinkedHashMapEntry<K, V> dst)57     private void transferLinks(
58             java.util.LinkedHashMap.LinkedHashMapEntry<K, V> src,
59             java.util.LinkedHashMap.LinkedHashMapEntry<K, V> dst) {
60         throw new RuntimeException("Stub!");
61     }
62 
reinitialize()63     void reinitialize() {
64         throw new RuntimeException("Stub!");
65     }
66 
newNode(int hash, K key, V value, java.util.HashMap.Node<K, V> e)67     java.util.HashMap.Node<K, V> newNode(int hash, K key, V value, java.util.HashMap.Node<K, V> e) {
68         throw new RuntimeException("Stub!");
69     }
70 
replacementNode( java.util.HashMap.Node<K, V> p, java.util.HashMap.Node<K, V> next)71     java.util.HashMap.Node<K, V> replacementNode(
72             java.util.HashMap.Node<K, V> p, java.util.HashMap.Node<K, V> next) {
73         throw new RuntimeException("Stub!");
74     }
75 
newTreeNode( int hash, K key, V value, java.util.HashMap.Node<K, V> next)76     java.util.HashMap.TreeNode<K, V> newTreeNode(
77             int hash, K key, V value, java.util.HashMap.Node<K, V> next) {
78         throw new RuntimeException("Stub!");
79     }
80 
replacementTreeNode( java.util.HashMap.Node<K, V> p, java.util.HashMap.Node<K, V> next)81     java.util.HashMap.TreeNode<K, V> replacementTreeNode(
82             java.util.HashMap.Node<K, V> p, java.util.HashMap.Node<K, V> next) {
83         throw new RuntimeException("Stub!");
84     }
85 
afterNodeRemoval(java.util.HashMap.Node<K, V> e)86     void afterNodeRemoval(java.util.HashMap.Node<K, V> e) {
87         throw new RuntimeException("Stub!");
88     }
89 
afterNodeInsertion(boolean evict)90     void afterNodeInsertion(boolean evict) {
91         throw new RuntimeException("Stub!");
92     }
93 
afterNodeAccess(java.util.HashMap.Node<K, V> e)94     void afterNodeAccess(java.util.HashMap.Node<K, V> e) {
95         throw new RuntimeException("Stub!");
96     }
97 
internalWriteEntries(java.io.ObjectOutputStream s)98     void internalWriteEntries(java.io.ObjectOutputStream s) throws java.io.IOException {
99         throw new RuntimeException("Stub!");
100     }
101 
containsValue(java.lang.Object value)102     public boolean containsValue(java.lang.Object value) {
103         throw new RuntimeException("Stub!");
104     }
105 
get(java.lang.Object key)106     public V get(java.lang.Object key) {
107         throw new RuntimeException("Stub!");
108     }
109 
getOrDefault(java.lang.Object key, V defaultValue)110     public V getOrDefault(java.lang.Object key, V defaultValue) {
111         throw new RuntimeException("Stub!");
112     }
113 
clear()114     public void clear() {
115         throw new RuntimeException("Stub!");
116     }
117 
118     @UnsupportedAppUsage
eldest()119     public java.util.Map.Entry<K, V> eldest() {
120         throw new RuntimeException("Stub!");
121     }
122 
removeEldestEntry(java.util.Map.Entry<K, V> eldest)123     protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
124         throw new RuntimeException("Stub!");
125     }
126 
keySet()127     public java.util.Set<K> keySet() {
128         throw new RuntimeException("Stub!");
129     }
130 
values()131     public java.util.Collection<V> values() {
132         throw new RuntimeException("Stub!");
133     }
134 
entrySet()135     public java.util.Set<java.util.Map.Entry<K, V>> entrySet() {
136         throw new RuntimeException("Stub!");
137     }
138 
forEach(java.util.function.BiConsumer<? super K, ? super V> action)139     public void forEach(java.util.function.BiConsumer<? super K, ? super V> action) {
140         throw new RuntimeException("Stub!");
141     }
142 
replaceAll( java.util.function.BiFunction<? super K, ? super V, ? extends V> function)143     public void replaceAll(
144             java.util.function.BiFunction<? super K, ? super V, ? extends V> function) {
145         throw new RuntimeException("Stub!");
146     }
147 
148     @UnsupportedAppUsage
149     final boolean accessOrder;
150 
151     {
152         accessOrder = false;
153     }
154 
155     transient java.util.LinkedHashMap.LinkedHashMapEntry<K, V> head;
156 
157     private static final long serialVersionUID = 3801124242820219131L; // 0x34c04e5c106cc0fbL
158 
159     transient java.util.LinkedHashMap.LinkedHashMapEntry<K, V> tail;
160 
161     @SuppressWarnings({"unchecked", "deprecation", "all"})
162     final class LinkedEntryIterator extends java.util.LinkedHashMap.LinkedHashIterator
163             implements java.util.Iterator<java.util.Map.Entry<K, V>> {
164 
next()165         public java.util.Map.Entry<K, V> next() {
166             throw new RuntimeException("Stub!");
167         }
168     }
169 
170     @SuppressWarnings({"unchecked", "deprecation", "all"})
171     final class LinkedEntrySet extends java.util.AbstractSet<java.util.Map.Entry<K, V>> {
172 
LinkedEntrySet()173         LinkedEntrySet() {
174             throw new RuntimeException("Stub!");
175         }
176 
size()177         public int size() {
178             throw new RuntimeException("Stub!");
179         }
180 
clear()181         public void clear() {
182             throw new RuntimeException("Stub!");
183         }
184 
iterator()185         public java.util.Iterator<java.util.Map.Entry<K, V>> iterator() {
186             throw new RuntimeException("Stub!");
187         }
188 
contains(java.lang.Object o)189         public boolean contains(java.lang.Object o) {
190             throw new RuntimeException("Stub!");
191         }
192 
remove(java.lang.Object o)193         public boolean remove(java.lang.Object o) {
194             throw new RuntimeException("Stub!");
195         }
196 
spliterator()197         public java.util.Spliterator<java.util.Map.Entry<K, V>> spliterator() {
198             throw new RuntimeException("Stub!");
199         }
200 
forEach(java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action)201         public void forEach(java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
202             throw new RuntimeException("Stub!");
203         }
204     }
205 
206     @SuppressWarnings({"unchecked", "deprecation", "all"})
207     abstract class LinkedHashIterator {
208 
LinkedHashIterator()209         LinkedHashIterator() {
210             throw new RuntimeException("Stub!");
211         }
212 
hasNext()213         public final boolean hasNext() {
214             throw new RuntimeException("Stub!");
215         }
216 
nextNode()217         final java.util.LinkedHashMap.LinkedHashMapEntry<K, V> nextNode() {
218             throw new RuntimeException("Stub!");
219         }
220 
remove()221         public final void remove() {
222             throw new RuntimeException("Stub!");
223         }
224 
225         java.util.LinkedHashMap.LinkedHashMapEntry<K, V> current;
226 
227         int expectedModCount;
228 
229         java.util.LinkedHashMap.LinkedHashMapEntry<K, V> next;
230     }
231 
232     @SuppressWarnings({"unchecked", "deprecation", "all"})
233     static class LinkedHashMapEntry<K, V> extends java.util.HashMap.Node<K, V> {
234 
LinkedHashMapEntry(int hash, K key, V value, java.util.HashMap.Node<K, V> next)235         LinkedHashMapEntry(int hash, K key, V value, java.util.HashMap.Node<K, V> next) {
236             super(0, null, null, null);
237             throw new RuntimeException("Stub!");
238         }
239 
240         java.util.LinkedHashMap.LinkedHashMapEntry<K, V> after;
241 
242         java.util.LinkedHashMap.LinkedHashMapEntry<K, V> before;
243     }
244 
245     @SuppressWarnings({"unchecked", "deprecation", "all"})
246     final class LinkedKeyIterator extends java.util.LinkedHashMap.LinkedHashIterator
247             implements java.util.Iterator<K> {
248 
next()249         public K next() {
250             throw new RuntimeException("Stub!");
251         }
252     }
253 
254     @SuppressWarnings({"unchecked", "deprecation", "all"})
255     final class LinkedKeySet extends java.util.AbstractSet<K> {
256 
LinkedKeySet()257         LinkedKeySet() {
258             throw new RuntimeException("Stub!");
259         }
260 
size()261         public int size() {
262             throw new RuntimeException("Stub!");
263         }
264 
clear()265         public void clear() {
266             throw new RuntimeException("Stub!");
267         }
268 
iterator()269         public java.util.Iterator<K> iterator() {
270             throw new RuntimeException("Stub!");
271         }
272 
contains(java.lang.Object o)273         public boolean contains(java.lang.Object o) {
274             throw new RuntimeException("Stub!");
275         }
276 
remove(java.lang.Object key)277         public boolean remove(java.lang.Object key) {
278             throw new RuntimeException("Stub!");
279         }
280 
spliterator()281         public java.util.Spliterator<K> spliterator() {
282             throw new RuntimeException("Stub!");
283         }
284 
forEach(java.util.function.Consumer<? super K> action)285         public void forEach(java.util.function.Consumer<? super K> action) {
286             throw new RuntimeException("Stub!");
287         }
288     }
289 
290     @SuppressWarnings({"unchecked", "deprecation", "all"})
291     final class LinkedValueIterator extends java.util.LinkedHashMap.LinkedHashIterator
292             implements java.util.Iterator<V> {
293 
next()294         public V next() {
295             throw new RuntimeException("Stub!");
296         }
297     }
298 
299     @SuppressWarnings({"unchecked", "deprecation", "all"})
300     final class LinkedValues extends java.util.AbstractCollection<V> {
301 
LinkedValues()302         LinkedValues() {
303             throw new RuntimeException("Stub!");
304         }
305 
size()306         public int size() {
307             throw new RuntimeException("Stub!");
308         }
309 
clear()310         public void clear() {
311             throw new RuntimeException("Stub!");
312         }
313 
iterator()314         public java.util.Iterator<V> iterator() {
315             throw new RuntimeException("Stub!");
316         }
317 
contains(java.lang.Object o)318         public boolean contains(java.lang.Object o) {
319             throw new RuntimeException("Stub!");
320         }
321 
spliterator()322         public java.util.Spliterator<V> spliterator() {
323             throw new RuntimeException("Stub!");
324         }
325 
forEach(java.util.function.Consumer<? super V> action)326         public void forEach(java.util.function.Consumer<? super V> action) {
327             throw new RuntimeException("Stub!");
328         }
329     }
330 }
331