Add stubs for hiddenapi
Adds stubs for ojluni classes some of whose hidden members are used by
applications. Each such member is annotated with the UnsupportedAppUsage
annotation.
The stubs are built as part of the core-oj-hiddenapi target from which
the build will extract information about the hidden class members that
are used by applications.
This was tested by making and then manually checking that the generated
out/target/common/obj/PACKAGING/hiddenapi-light-greylist.txt was the
same (after sorting) before and after this change.
Test: see above
Bug: 117818301
Change-Id: Icfe773e00ba1f96a379b705f26ef631ec34fee5e
diff --git a/JavaLibrary.bp b/JavaLibrary.bp
index 45bfba7..3e5367a 100644
--- a/JavaLibrary.bp
+++ b/JavaLibrary.bp
@@ -255,6 +255,23 @@
],
}
+// Provided solely to contribute information about which hidden parts of the
+// core-oj API are used by apps.
+java_library {
+ name: "core-oj-hiddenapi",
+ defaults: ["libcore_java_defaults"],
+ compile_dex: true,
+
+ srcs: [":openjdk_hiddenapi_javadoc_files"],
+
+ no_standard_libs: true,
+ libs: ["core-all"],
+ system_modules: "core-all-system-modules",
+ openjdk9: {
+ javacflags: ["--patch-module=java.base=."],
+ },
+}
+
//
// Guaranteed unstripped versions of core-oj and core-libart.
//
diff --git a/ojluni/annotations/hiddenapi/java/io/Console.java b/ojluni/annotations/hiddenapi/java/io/Console.java
new file mode 100644
index 0000000..9a93310
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/io/Console.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2005, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.io;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Console implements java.io.Flushable {
+
+ private Console() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private Console(java.io.InputStream inStream, java.io.OutputStream outStream) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.PrintWriter writer() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.Reader reader() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.Console format(java.lang.String fmt, java.lang.Object... args) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.Console printf(java.lang.String format, java.lang.Object... args) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String readLine(java.lang.String fmt, java.lang.Object... args) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String readLine() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public char[] readPassword(java.lang.String fmt, java.lang.Object... args) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public char[] readPassword() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void flush() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static native java.lang.String encoding();
+
+ private static native boolean echo(boolean on) throws java.io.IOException;
+
+ private char[] readline(boolean zeroOut) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private char[] grow() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.io.Console console() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native boolean istty();
+
+ private static java.io.Console cons;
+
+ private java.nio.charset.Charset cs;
+
+ private static boolean echoOff;
+
+ private java.util.Formatter formatter;
+
+ private java.io.Writer out;
+
+ private java.io.PrintWriter pw;
+
+ private char[] rcb;
+
+ private java.lang.Object readLock;
+
+ private java.io.Reader reader;
+
+ private java.lang.Object writeLock;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ class LineReader extends java.io.Reader {
+
+ LineReader(java.io.Reader in) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void close() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean ready() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int read(char[] cbuf, int offset, int length) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private char[] cb;
+
+ private java.io.Reader in;
+
+ boolean leftoverLF;
+
+ private int nChars;
+
+ private int nextChar;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/io/File.java b/ojluni/annotations/hiddenapi/java/io/File.java
new file mode 100644
index 0000000..7b93218
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/io/File.java
@@ -0,0 +1,377 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1994, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.io;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class File implements java.io.Serializable, java.lang.Comparable<java.io.File> {
+
+ private File(java.lang.String pathname, int prefixLength) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private File(java.lang.String child, java.io.File parent) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public File(java.lang.String pathname) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public File(java.lang.String parent, java.lang.String child) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public File(java.io.File parent, java.lang.String child) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public File(java.net.URI uri) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final boolean isInvalid() {
+ throw new RuntimeException("Stub!");
+ }
+
+ int getPrefixLength() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getParent() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.File getParentFile() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getPath() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isAbsolute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getAbsolutePath() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.File getAbsoluteFile() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getCanonicalPath() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.File getCanonicalFile() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String slashify(java.lang.String path, boolean isDirectory) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public java.net.URL toURL() throws java.net.MalformedURLException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.URI toURI() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean canRead() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean canWrite() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean exists() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isDirectory() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isFile() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isHidden() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long lastModified() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long length() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean createNewFile() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean delete() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void deleteOnExit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String[] list() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String[] list(java.io.FilenameFilter filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.File[] listFiles() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.File[] listFiles(java.io.FilenameFilter filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.File[] listFiles(java.io.FileFilter filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean mkdir() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean mkdirs() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean renameTo(java.io.File dest) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean setLastModified(long time) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean setReadOnly() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean setWritable(boolean writable, boolean ownerOnly) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean setWritable(boolean writable) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean setReadable(boolean readable, boolean ownerOnly) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean setReadable(boolean readable) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean setExecutable(boolean executable, boolean ownerOnly) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean setExecutable(boolean executable) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean canExecute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.io.File[] listRoots() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getTotalSpace() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getFreeSpace() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getUsableSpace() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.io.File createTempFile(
+ java.lang.String prefix, java.lang.String suffix, java.io.File directory)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.io.File createTempFile(java.lang.String prefix, java.lang.String suffix)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compareTo(java.io.File pathname) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.file.Path toPath() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long PATH_OFFSET;
+
+ static {
+ PATH_OFFSET = 0;
+ }
+
+ private static final long PREFIX_LENGTH_OFFSET;
+
+ static {
+ PREFIX_LENGTH_OFFSET = 0;
+ }
+
+ private static final sun.misc.Unsafe UNSAFE;
+
+ static {
+ UNSAFE = null;
+ }
+
+ @UnsupportedAppUsage
+ private transient volatile java.nio.file.Path filePath;
+
+ @UnsupportedAppUsage
+ private static final java.io.FileSystem fs;
+
+ static {
+ fs = null;
+ }
+
+ @UnsupportedAppUsage
+ private final java.lang.String path;
+
+ {
+ path = null;
+ }
+
+ public static final java.lang.String pathSeparator;
+
+ static {
+ pathSeparator = null;
+ }
+
+ public static final char pathSeparatorChar;
+
+ static {
+ pathSeparatorChar = 0;
+ }
+
+ @UnsupportedAppUsage
+ private final transient int prefixLength;
+
+ {
+ prefixLength = 0;
+ }
+
+ public static final java.lang.String separator;
+
+ static {
+ separator = null;
+ }
+
+ public static final char separatorChar;
+
+ static {
+ separatorChar = 0;
+ }
+
+ private static final long serialVersionUID = 301077366599181567L; // 0x42da4450e0de4ffL
+
+ @UnsupportedAppUsage
+ private transient java.io.File.PathStatus status;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static enum PathStatus {
+ INVALID,
+ CHECKED;
+
+ private PathStatus() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class TempDirectory {
+
+ private TempDirectory() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.io.File generateFile(
+ java.lang.String prefix, java.lang.String suffix, java.io.File dir)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/io/FileDescriptor.java b/ojluni/annotations/hiddenapi/java/io/FileDescriptor.java
new file mode 100644
index 0000000..7872403
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/io/FileDescriptor.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 1995, 2011, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.io;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class FileDescriptor {
+
+ public FileDescriptor() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private FileDescriptor(int descriptor) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean valid() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public native void sync() throws java.io.SyncFailedException;
+
+ @UnsupportedAppUsage
+ public int getInt$() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public void setInt$(int fd) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getOwnerId$() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setOwnerId$(long newOwnerId) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.FileDescriptor release$() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public boolean isSocket$() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.io.FileDescriptor dupFd(int fd) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native boolean isSocket(int descriptor);
+
+ public static final long NO_OWNER = 0L; // 0x0L
+
+ @UnsupportedAppUsage
+ private int descriptor;
+
+ public static final java.io.FileDescriptor err;
+
+ static {
+ err = null;
+ }
+
+ public static final java.io.FileDescriptor in;
+
+ static {
+ in = null;
+ }
+
+ public static final java.io.FileDescriptor out;
+
+ static {
+ out = null;
+ }
+
+ private long ownerId = 0L; // 0x0L
+}
diff --git a/ojluni/annotations/hiddenapi/java/io/FileInputStream.java b/ojluni/annotations/hiddenapi/java/io/FileInputStream.java
new file mode 100644
index 0000000..3de1617
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/io/FileInputStream.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1994, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.io;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class FileInputStream extends java.io.InputStream {
+
+ public FileInputStream(java.lang.String name) throws java.io.FileNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public FileInputStream(java.io.File file) throws java.io.FileNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public FileInputStream(java.io.FileDescriptor fdObj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public FileInputStream(java.io.FileDescriptor fdObj, boolean isFdOwner) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native void open0(java.lang.String name) throws java.io.FileNotFoundException;
+
+ private void open(java.lang.String name) throws java.io.FileNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int read() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int read(byte[] b) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int read(byte[] b, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long skip(long n) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native long skip0(long n)
+ throws java.io.FileInputStream.UseManualSkipException, java.io.IOException;
+
+ public int available() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native int available0() throws java.io.IOException;
+
+ public void close() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.io.FileDescriptor getFD() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.channels.FileChannel getChannel() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void finalize() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.nio.channels.FileChannel channel;
+
+ private final java.lang.Object closeLock;
+
+ {
+ closeLock = null;
+ }
+
+ private volatile boolean closed = false;
+
+ @UnsupportedAppUsage
+ private final java.io.FileDescriptor fd;
+
+ {
+ fd = null;
+ }
+
+ private final dalvik.system.CloseGuard guard;
+
+ {
+ guard = null;
+ }
+
+ private final boolean isFdOwner;
+
+ {
+ isFdOwner = false;
+ }
+
+ private final java.lang.String path;
+
+ {
+ path = null;
+ }
+
+ private final libcore.io.IoTracker tracker;
+
+ {
+ tracker = null;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class UseManualSkipException extends java.lang.Exception {
+
+ private UseManualSkipException() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/io/FileOutputStream.java b/ojluni/annotations/hiddenapi/java/io/FileOutputStream.java
new file mode 100644
index 0000000..b918f6a
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/io/FileOutputStream.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1994, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.io;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class FileOutputStream extends java.io.OutputStream {
+
+ public FileOutputStream(java.lang.String name) throws java.io.FileNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public FileOutputStream(java.lang.String name, boolean append)
+ throws java.io.FileNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public FileOutputStream(java.io.File file) throws java.io.FileNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public FileOutputStream(java.io.File file, boolean append)
+ throws java.io.FileNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public FileOutputStream(java.io.FileDescriptor fdObj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public FileOutputStream(java.io.FileDescriptor fdObj, boolean isFdOwner) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native void open0(java.lang.String name, boolean append)
+ throws java.io.FileNotFoundException;
+
+ private void open(java.lang.String name, boolean append) throws java.io.FileNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void write(int b) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void write(byte[] b) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void write(byte[] b, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void close() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.io.FileDescriptor getFD() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.channels.FileChannel getChannel() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void finalize() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final boolean append;
+
+ {
+ append = false;
+ }
+
+ @UnsupportedAppUsage
+ private java.nio.channels.FileChannel channel;
+
+ private final java.lang.Object closeLock;
+
+ {
+ closeLock = null;
+ }
+
+ private volatile boolean closed = false;
+
+ @UnsupportedAppUsage
+ private final java.io.FileDescriptor fd;
+
+ {
+ fd = null;
+ }
+
+ private final dalvik.system.CloseGuard guard;
+
+ {
+ guard = null;
+ }
+
+ private final boolean isFdOwner;
+
+ {
+ isFdOwner = false;
+ }
+
+ private final java.lang.String path;
+
+ {
+ path = null;
+ }
+
+ private final libcore.io.IoTracker tracker;
+
+ {
+ tracker = null;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/io/FileSystem.java b/ojluni/annotations/hiddenapi/java/io/FileSystem.java
new file mode 100644
index 0000000..4999b3c
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/io/FileSystem.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1998, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.io;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+abstract class FileSystem {
+
+ FileSystem() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public abstract char getSeparator();
+
+ @UnsupportedAppUsage
+ public abstract char getPathSeparator();
+
+ @UnsupportedAppUsage
+ public abstract java.lang.String normalize(java.lang.String path);
+
+ @UnsupportedAppUsage
+ public abstract int prefixLength(java.lang.String path);
+
+ @UnsupportedAppUsage
+ public abstract java.lang.String resolve(java.lang.String parent, java.lang.String child);
+
+ @UnsupportedAppUsage
+ public abstract java.lang.String getDefaultParent();
+
+ @UnsupportedAppUsage
+ public abstract java.lang.String fromURIPath(java.lang.String path);
+
+ @UnsupportedAppUsage
+ public abstract boolean isAbsolute(java.io.File f);
+
+ @UnsupportedAppUsage
+ public abstract java.lang.String resolve(java.io.File f);
+
+ @UnsupportedAppUsage
+ public abstract java.lang.String canonicalize(java.lang.String path) throws java.io.IOException;
+
+ @UnsupportedAppUsage
+ public abstract int getBooleanAttributes(java.io.File f);
+
+ @UnsupportedAppUsage
+ public abstract boolean checkAccess(java.io.File f, int access);
+
+ @UnsupportedAppUsage
+ public abstract boolean setPermission(
+ java.io.File f, int access, boolean enable, boolean owneronly);
+
+ @UnsupportedAppUsage
+ public abstract long getLastModifiedTime(java.io.File f);
+
+ @UnsupportedAppUsage
+ public abstract long getLength(java.io.File f);
+
+ @UnsupportedAppUsage
+ public abstract boolean createFileExclusively(java.lang.String pathname)
+ throws java.io.IOException;
+
+ @UnsupportedAppUsage
+ public abstract boolean delete(java.io.File f);
+
+ @UnsupportedAppUsage
+ public abstract java.lang.String[] list(java.io.File f);
+
+ @UnsupportedAppUsage
+ public abstract boolean createDirectory(java.io.File f);
+
+ @UnsupportedAppUsage
+ public abstract boolean rename(java.io.File f1, java.io.File f2);
+
+ @UnsupportedAppUsage
+ public abstract boolean setLastModifiedTime(java.io.File f, long time);
+
+ @UnsupportedAppUsage
+ public abstract boolean setReadOnly(java.io.File f);
+
+ @UnsupportedAppUsage
+ public abstract java.io.File[] listRoots();
+
+ @UnsupportedAppUsage
+ public abstract long getSpace(java.io.File f, int t);
+
+ @UnsupportedAppUsage
+ public abstract int compare(java.io.File f1, java.io.File f2);
+
+ @UnsupportedAppUsage
+ public abstract int hashCode(java.io.File f);
+
+ private static boolean getBooleanProperty(java.lang.String prop, boolean defaultVal) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final int ACCESS_EXECUTE = 1; // 0x1
+
+ public static final int ACCESS_OK = 8; // 0x8
+
+ public static final int ACCESS_READ = 4; // 0x4
+
+ public static final int ACCESS_WRITE = 2; // 0x2
+
+ public static final int BA_DIRECTORY = 4; // 0x4
+
+ public static final int BA_EXISTS = 1; // 0x1
+
+ public static final int BA_HIDDEN = 8; // 0x8
+
+ public static final int BA_REGULAR = 2; // 0x2
+
+ public static final int SPACE_FREE = 1; // 0x1
+
+ public static final int SPACE_TOTAL = 0; // 0x0
+
+ public static final int SPACE_USABLE = 2; // 0x2
+
+ static boolean useCanonCaches = false;
+
+ static boolean useCanonPrefixCache = false;
+}
diff --git a/ojluni/annotations/hiddenapi/java/io/ObjectInputStream.java b/ojluni/annotations/hiddenapi/java/io/ObjectInputStream.java
new file mode 100644
index 0000000..90dcfea
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/io/ObjectInputStream.java
@@ -0,0 +1,895 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1996, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.io;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ObjectInputStream extends java.io.InputStream
+ implements java.io.ObjectInput, java.io.ObjectStreamConstants {
+
+ public ObjectInputStream(java.io.InputStream in) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected ObjectInputStream() throws java.io.IOException, java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.Object readObject()
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Object readObjectOverride()
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object readUnshared()
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void defaultReadObject() throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.ObjectInputStream.GetField readFields()
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void registerValidation(java.io.ObjectInputValidation obj, int prio)
+ throws java.io.InvalidObjectException, java.io.NotActiveException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Class<?> resolveClass(java.io.ObjectStreamClass desc)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Class<?> resolveProxyClass(java.lang.String[] interfaces)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Object resolveObject(java.lang.Object obj) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected boolean enableResolveObject(boolean enable) throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void readStreamHeader() throws java.io.IOException, java.io.StreamCorruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.io.ObjectStreamClass readClassDescriptor()
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int read() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int read(byte[] buf, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int available() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void close() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean readBoolean() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public byte readByte() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int readUnsignedByte() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public char readChar() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public short readShort() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int readUnsignedShort() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int readInt() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long readLong() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public float readFloat() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public double readDouble() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void readFully(byte[] buf) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void readFully(byte[] buf, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int skipBytes(int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public java.lang.String readLine() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String readUTF() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void verifySubclass() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean auditSubclass(java.lang.Class<?> subcl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readObject0(boolean unshared) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object checkResolve(java.lang.Object obj) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.String readTypeString() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readNull() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readHandle(boolean unshared) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Class<?> readClass(boolean unshared) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.io.ObjectStreamClass readClassDesc(boolean unshared) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean isCustomSubclass() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.io.ObjectStreamClass readProxyDesc(boolean unshared) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.io.ObjectStreamClass readNonProxyDesc(boolean unshared)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String readString(boolean unshared) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readArray(boolean unshared) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Enum<?> readEnum(boolean unshared) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readOrdinaryObject(boolean unshared) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readExternalData(java.io.Externalizable obj, java.io.ObjectStreamClass desc)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readSerialData(java.lang.Object obj, java.io.ObjectStreamClass desc)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void skipCustomData() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void defaultReadFields(java.lang.Object obj, java.io.ObjectStreamClass desc)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.io.IOException readFatalException() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void handleReset() throws java.io.StreamCorruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static native void bytesToFloats(
+ byte[] src, int srcpos, float[] dst, int dstpos, int nfloats);
+
+ @UnsupportedAppUsage
+ private static native void bytesToDoubles(
+ byte[] src, int srcpos, double[] dst, int dstpos, int ndoubles);
+
+ private static java.lang.ClassLoader latestUserDefinedLoader() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.Object cloneArray(java.lang.Object array) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int NULL_HANDLE = -1; // 0xffffffff
+
+ @UnsupportedAppUsage
+ private final java.io.ObjectInputStream.BlockDataInputStream bin;
+
+ {
+ bin = null;
+ }
+
+ private boolean closed;
+
+ private java.io.SerialCallbackContext curContext;
+
+ private boolean defaultDataEnd = false;
+
+ private int depth;
+
+ private final boolean enableOverride;
+
+ {
+ enableOverride = false;
+ }
+
+ private boolean enableResolve;
+
+ private final java.io.ObjectInputStream.HandleTable handles;
+
+ {
+ handles = null;
+ }
+
+ private int passHandle = -1; // 0xffffffff
+
+ private static final java.util.HashMap<java.lang.String, java.lang.Class<?>> primClasses;
+
+ static {
+ primClasses = null;
+ }
+
+ private byte[] primVals;
+
+ private static final java.lang.Object unsharedMarker;
+
+ static {
+ unsharedMarker = null;
+ }
+
+ private final java.io.ObjectInputStream.ValidationList vlist;
+
+ {
+ vlist = null;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class BlockDataInputStream extends java.io.InputStream implements java.io.DataInput {
+
+ BlockDataInputStream(java.io.InputStream in) {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean setBlockDataMode(boolean newmode) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean getBlockDataMode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void skipBlockData() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int readBlockHeader(boolean canBlock) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void refill() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ int currentBlockRemaining() {
+ throw new RuntimeException("Stub!");
+ }
+
+ int peek() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ byte peekByte() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int read() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int read(byte[] b, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long skip(long len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int available() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void close() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ int read(byte[] b, int off, int len, boolean copy) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void readFully(byte[] b) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void readFully(byte[] b, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void readFully(byte[] b, int off, int len, boolean copy) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int skipBytes(int n) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean readBoolean() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public byte readByte() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int readUnsignedByte() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public char readChar() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public short readShort() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int readUnsignedShort() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int readInt() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public float readFloat() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long readLong() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public double readDouble() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String readUTF() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String readLine() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void readBooleans(boolean[] v, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void readChars(char[] v, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void readShorts(short[] v, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void readInts(int[] v, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void readFloats(float[] v, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void readLongs(long[] v, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void readDoubles(double[] v, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.String readLongUTF() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String readUTFBody(long utflen) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private long readUTFSpan(java.lang.StringBuilder sbuf, long utflen)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int readUTFChar(java.lang.StringBuilder sbuf, long utflen)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ long getBytesRead() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int CHAR_BUF_SIZE = 256; // 0x100
+
+ private static final int HEADER_BLOCKED = -2; // 0xfffffffe
+
+ private static final int MAX_BLOCK_SIZE = 1024; // 0x400
+
+ private static final int MAX_HEADER_SIZE = 5; // 0x5
+
+ private boolean blkmode = false;
+
+ private final byte[] buf;
+
+ {
+ buf = new byte[0];
+ }
+
+ private final char[] cbuf;
+
+ {
+ cbuf = new char[0];
+ }
+
+ private final java.io.DataInputStream din;
+
+ {
+ din = null;
+ }
+
+ private int end = -1; // 0xffffffff
+
+ private final byte[] hbuf;
+
+ {
+ hbuf = new byte[0];
+ }
+
+ private final java.io.ObjectInputStream.PeekInputStream in;
+
+ {
+ in = null;
+ }
+
+ private int pos = 0; // 0x0
+
+ private int unread = 0; // 0x0
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class Caches {
+
+ private Caches() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.util.concurrent.ConcurrentMap<
+ java.io.ObjectStreamClass.WeakClassKey, java.lang.Boolean>
+ subclassAudits;
+
+ static {
+ subclassAudits = null;
+ }
+
+ static final java.lang.ref.ReferenceQueue<java.lang.Class<?>> subclassAuditsQueue;
+
+ static {
+ subclassAuditsQueue = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public abstract static class GetField {
+
+ public GetField() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.io.ObjectStreamClass getObjectStreamClass();
+
+ public abstract boolean defaulted(java.lang.String name) throws java.io.IOException;
+
+ public abstract boolean get(java.lang.String name, boolean val) throws java.io.IOException;
+
+ public abstract byte get(java.lang.String name, byte val) throws java.io.IOException;
+
+ public abstract char get(java.lang.String name, char val) throws java.io.IOException;
+
+ public abstract short get(java.lang.String name, short val) throws java.io.IOException;
+
+ public abstract int get(java.lang.String name, int val) throws java.io.IOException;
+
+ public abstract long get(java.lang.String name, long val) throws java.io.IOException;
+
+ public abstract float get(java.lang.String name, float val) throws java.io.IOException;
+
+ public abstract double get(java.lang.String name, double val) throws java.io.IOException;
+
+ public abstract java.lang.Object get(java.lang.String name, java.lang.Object val)
+ throws java.io.IOException;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class GetFieldImpl extends java.io.ObjectInputStream.GetField {
+
+ GetFieldImpl(java.io.ObjectStreamClass desc) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.ObjectStreamClass getObjectStreamClass() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean defaulted(java.lang.String name) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean get(java.lang.String name, boolean val) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public byte get(java.lang.String name, byte val) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public char get(java.lang.String name, char val) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public short get(java.lang.String name, short val) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int get(java.lang.String name, int val) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public float get(java.lang.String name, float val) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long get(java.lang.String name, long val) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public double get(java.lang.String name, double val) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object get(java.lang.String name, java.lang.Object val)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void readFields() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int getFieldOffset(java.lang.String name, java.lang.Class<?> type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.io.ObjectStreamClass desc;
+
+ {
+ desc = null;
+ }
+
+ private final int[] objHandles;
+
+ {
+ objHandles = new int[0];
+ }
+
+ private final java.lang.Object[] objVals;
+
+ {
+ objVals = new java.lang.Object[0];
+ }
+
+ private final byte[] primVals;
+
+ {
+ primVals = new byte[0];
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class HandleTable {
+
+ HandleTable(int initialCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ int assign(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void markDependency(int dependent, int target) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void markException(int handle, java.lang.ClassNotFoundException ex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void finish(int handle) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setObject(int handle, java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.Object lookupObject(int handle) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.ClassNotFoundException lookupException(int handle) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void grow() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final byte STATUS_EXCEPTION = 3; // 0x3
+
+ private static final byte STATUS_OK = 1; // 0x1
+
+ private static final byte STATUS_UNKNOWN = 2; // 0x2
+
+ java.io.ObjectInputStream.HandleTable.HandleList[] deps;
+
+ java.lang.Object[] entries;
+
+ int lowDep = -1; // 0xffffffff
+
+ int size = 0; // 0x0
+
+ byte[] status;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class HandleList {
+
+ public HandleList() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void add(int handle) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int get(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int[] list;
+
+ private int size = 0; // 0x0
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class PeekInputStream extends java.io.InputStream {
+
+ PeekInputStream(java.io.InputStream in) {
+ throw new RuntimeException("Stub!");
+ }
+
+ int peek() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int read() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int read(byte[] b, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void readFully(byte[] b, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long skip(long n) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int available() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void close() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getBytesRead() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.io.InputStream in;
+
+ {
+ in = null;
+ }
+
+ private int peekb = -1; // 0xffffffff
+
+ private long totalBytesRead = 0; // 0x0
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class ValidationList {
+
+ ValidationList() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void register(java.io.ObjectInputValidation obj, int priority)
+ throws java.io.InvalidObjectException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void doCallbacks() throws java.io.InvalidObjectException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.io.ObjectInputStream.ValidationList.Callback list;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class Callback {
+
+ Callback(
+ java.io.ObjectInputValidation obj,
+ int priority,
+ java.io.ObjectInputStream.ValidationList.Callback next,
+ java.security.AccessControlContext acc) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.security.AccessControlContext acc;
+
+ {
+ acc = null;
+ }
+
+ java.io.ObjectInputStream.ValidationList.Callback next;
+
+ final java.io.ObjectInputValidation obj;
+
+ {
+ obj = null;
+ }
+
+ final int priority;
+
+ {
+ priority = 0;
+ }
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/io/ObjectOutputStream.java b/ojluni/annotations/hiddenapi/java/io/ObjectOutputStream.java
new file mode 100644
index 0000000..f3e462d
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/io/ObjectOutputStream.java
@@ -0,0 +1,745 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1996, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.io;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ObjectOutputStream extends java.io.OutputStream
+ implements java.io.ObjectOutput, java.io.ObjectStreamConstants {
+
+ public ObjectOutputStream(java.io.OutputStream out) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected ObjectOutputStream() throws java.io.IOException, java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void useProtocolVersion(int version) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void writeObject(java.lang.Object obj) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void writeObjectOverride(java.lang.Object obj) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeUnshared(java.lang.Object obj) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void defaultWriteObject() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.ObjectOutputStream.PutField putFields() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeFields() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void reset() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void annotateClass(java.lang.Class<?> cl) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void annotateProxyClass(java.lang.Class<?> cl) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Object replaceObject(java.lang.Object obj) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected boolean enableReplaceObject(boolean enable) throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void writeStreamHeader() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void writeClassDescriptor(java.io.ObjectStreamClass desc) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void write(int val) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void write(byte[] buf) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void write(byte[] buf, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void flush() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void drain() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void close() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeBoolean(boolean val) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeByte(int val) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeShort(int val) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeChar(int val) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeInt(int val) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeLong(long val) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeFloat(float val) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeDouble(double val) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeBytes(java.lang.String str) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeChars(java.lang.String str) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeUTF(java.lang.String str) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ int getProtocolVersion() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void writeTypeString(java.lang.String str) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void verifySubclass() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean auditSubclass(java.lang.Class<?> subcl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject0(java.lang.Object obj, boolean unshared) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeNull() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeHandle(int handle) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeClass(java.lang.Class<?> cl, boolean unshared) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeClassDesc(java.io.ObjectStreamClass desc, boolean unshared)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean isCustomSubclass() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeProxyDesc(java.io.ObjectStreamClass desc, boolean unshared)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeNonProxyDesc(java.io.ObjectStreamClass desc, boolean unshared)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeString(java.lang.String str, boolean unshared) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeArray(
+ java.lang.Object array, java.io.ObjectStreamClass desc, boolean unshared)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeEnum(java.lang.Enum<?> en, java.io.ObjectStreamClass desc, boolean unshared)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeOrdinaryObject(
+ java.lang.Object obj, java.io.ObjectStreamClass desc, boolean unshared)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeExternalData(java.io.Externalizable obj) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeSerialData(java.lang.Object obj, java.io.ObjectStreamClass desc)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void defaultWriteFields(java.lang.Object obj, java.io.ObjectStreamClass desc)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeFatalException(java.io.IOException ex) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native void floatsToBytes(
+ float[] src, int srcpos, byte[] dst, int dstpos, int nfloats);
+
+ private static native void doublesToBytes(
+ double[] src, int srcpos, byte[] dst, int dstpos, int ndoubles);
+
+ private final java.io.ObjectOutputStream.BlockDataOutputStream bout;
+
+ {
+ bout = null;
+ }
+
+ private java.io.SerialCallbackContext curContext;
+
+ private java.io.ObjectOutputStream.PutFieldImpl curPut;
+
+ private final java.io.ObjectOutputStream.DebugTraceInfoStack debugInfoStack;
+
+ {
+ debugInfoStack = null;
+ }
+
+ private int depth;
+
+ private final boolean enableOverride;
+
+ {
+ enableOverride = false;
+ }
+
+ private boolean enableReplace;
+
+ private static final boolean extendedDebugInfo = false;
+
+ private final java.io.ObjectOutputStream.HandleTable handles;
+
+ {
+ handles = null;
+ }
+
+ private byte[] primVals;
+
+ @UnsupportedAppUsage
+ private int protocol = 2; // 0x2
+
+ private final java.io.ObjectOutputStream.ReplaceTable subs;
+
+ {
+ subs = null;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class BlockDataOutputStream extends java.io.OutputStream
+ implements java.io.DataOutput {
+
+ BlockDataOutputStream(java.io.OutputStream out) {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean setBlockDataMode(boolean mode) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean getBlockDataMode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void warnIfClosed() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void write(int b) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void write(byte[] b) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void write(byte[] b, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void flush() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void close() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void write(byte[] b, int off, int len, boolean copy) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void drain() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeBlockHeader(int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeBoolean(boolean v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeByte(int v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeChar(int v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeShort(int v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeInt(int v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeFloat(float v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeLong(long v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeDouble(double v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeBytes(java.lang.String s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeChars(java.lang.String s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void writeUTF(java.lang.String s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void writeBooleans(boolean[] v, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void writeChars(char[] v, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void writeShorts(short[] v, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void writeInts(int[] v, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void writeFloats(float[] v, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void writeLongs(long[] v, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void writeDoubles(double[] v, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ long getUTFLength(java.lang.String s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void writeUTF(java.lang.String s, long utflen) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void writeLongUTF(java.lang.String s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void writeLongUTF(java.lang.String s, long utflen) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeUTFBody(java.lang.String s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int CHAR_BUF_SIZE = 256; // 0x100
+
+ private static final int MAX_BLOCK_SIZE = 1024; // 0x400
+
+ private static final int MAX_HEADER_SIZE = 5; // 0x5
+
+ private boolean blkmode = false;
+
+ private final byte[] buf;
+
+ {
+ buf = new byte[0];
+ }
+
+ private final char[] cbuf;
+
+ {
+ cbuf = new char[0];
+ }
+
+ private final java.io.DataOutputStream dout;
+
+ {
+ dout = null;
+ }
+
+ private final byte[] hbuf;
+
+ {
+ hbuf = new byte[0];
+ }
+
+ private final java.io.OutputStream out;
+
+ {
+ out = null;
+ }
+
+ private int pos = 0; // 0x0
+
+ private boolean warnOnceWhenWriting;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class Caches {
+
+ private Caches() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.util.concurrent.ConcurrentMap<
+ java.io.ObjectStreamClass.WeakClassKey, java.lang.Boolean>
+ subclassAudits;
+
+ static {
+ subclassAudits = null;
+ }
+
+ static final java.lang.ref.ReferenceQueue<java.lang.Class<?>> subclassAuditsQueue;
+
+ static {
+ subclassAuditsQueue = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class DebugTraceInfoStack {
+
+ DebugTraceInfoStack() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void pop() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void push(java.lang.String entry) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.List<java.lang.String> stack;
+
+ {
+ stack = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class HandleTable {
+
+ HandleTable(int initialCapacity, float loadFactor) {
+ throw new RuntimeException("Stub!");
+ }
+
+ int assign(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ int lookup(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void insert(java.lang.Object obj, int handle) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void growSpine() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void growEntries() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int hash(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final float loadFactor;
+
+ {
+ loadFactor = 0;
+ }
+
+ private int[] next;
+
+ private java.lang.Object[] objs;
+
+ private int size;
+
+ private int[] spine;
+
+ private int threshold;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public abstract static class PutField {
+
+ public PutField() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract void put(java.lang.String name, boolean val);
+
+ public abstract void put(java.lang.String name, byte val);
+
+ public abstract void put(java.lang.String name, char val);
+
+ public abstract void put(java.lang.String name, short val);
+
+ public abstract void put(java.lang.String name, int val);
+
+ public abstract void put(java.lang.String name, long val);
+
+ public abstract void put(java.lang.String name, float val);
+
+ public abstract void put(java.lang.String name, double val);
+
+ public abstract void put(java.lang.String name, java.lang.Object val);
+
+ @Deprecated
+ public abstract void write(java.io.ObjectOutput out) throws java.io.IOException;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class PutFieldImpl extends java.io.ObjectOutputStream.PutField {
+
+ PutFieldImpl(java.io.ObjectStreamClass desc) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void put(java.lang.String name, boolean val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void put(java.lang.String name, byte val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void put(java.lang.String name, char val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void put(java.lang.String name, short val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void put(java.lang.String name, int val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void put(java.lang.String name, float val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void put(java.lang.String name, long val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void put(java.lang.String name, double val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void put(java.lang.String name, java.lang.Object val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void write(java.io.ObjectOutput out) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void writeFields() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int getFieldOffset(java.lang.String name, java.lang.Class<?> type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.io.ObjectStreamClass desc;
+
+ {
+ desc = null;
+ }
+
+ private final java.lang.Object[] objVals;
+
+ {
+ objVals = new java.lang.Object[0];
+ }
+
+ private final byte[] primVals;
+
+ {
+ primVals = new byte[0];
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class ReplaceTable {
+
+ ReplaceTable(int initialCapacity, float loadFactor) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void assign(java.lang.Object obj, java.lang.Object rep) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.Object lookup(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void grow() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.io.ObjectOutputStream.HandleTable htab;
+
+ {
+ htab = null;
+ }
+
+ private java.lang.Object[] reps;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/io/ObjectStreamClass.java b/ojluni/annotations/hiddenapi/java/io/ObjectStreamClass.java
new file mode 100644
index 0000000..d617d32
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/io/ObjectStreamClass.java
@@ -0,0 +1,733 @@
+/*
+ * Copyright (c) 1996, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.io;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ObjectStreamClass implements java.io.Serializable {
+
+ private ObjectStreamClass(java.lang.Class<?> cl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ ObjectStreamClass() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.io.ObjectStreamClass lookup(java.lang.Class<?> cl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.io.ObjectStreamClass lookupAny(java.lang.Class<?> cl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getSerialVersionUID() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Class<?> forClass() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.ObjectStreamField[] getFields() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.ObjectStreamField getField(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.io.ObjectStreamClass lookup(java.lang.Class<?> cl, boolean all) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void initProxy(
+ java.lang.Class<?> cl,
+ java.lang.ClassNotFoundException resolveEx,
+ java.io.ObjectStreamClass superDesc)
+ throws java.io.InvalidClassException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void initNonProxy(
+ java.io.ObjectStreamClass model,
+ java.lang.Class<?> cl,
+ java.lang.ClassNotFoundException resolveEx,
+ java.io.ObjectStreamClass superDesc)
+ throws java.io.InvalidClassException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void readNonProxy(java.io.ObjectInputStream in)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void writeNonProxy(java.io.ObjectOutputStream out) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.ClassNotFoundException getResolveException() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final void requireInitialized() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void checkDeserialize() throws java.io.InvalidClassException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void checkSerialize() throws java.io.InvalidClassException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void checkDefaultSerialize() throws java.io.InvalidClassException {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.io.ObjectStreamClass getSuperDesc() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ java.io.ObjectStreamClass getLocalDesc() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.io.ObjectStreamField[] getFields(boolean copy) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.io.ObjectStreamField getField(java.lang.String name, java.lang.Class<?> type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isProxy() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isEnum() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isExternalizable() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isSerializable() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean hasBlockExternalData() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ boolean hasWriteObjectData() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isInstantiable() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean hasWriteObjectMethod() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ boolean hasReadObjectMethod() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ boolean hasReadObjectNoDataMethod() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean hasWriteReplaceMethod() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean hasReadResolveMethod() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ java.lang.Object newInstance()
+ throws java.lang.InstantiationException, java.lang.reflect.InvocationTargetException,
+ java.lang.UnsupportedOperationException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void invokeWriteObject(java.lang.Object obj, java.io.ObjectOutputStream out)
+ throws java.io.IOException, java.lang.UnsupportedOperationException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void invokeReadObject(java.lang.Object obj, java.io.ObjectInputStream in)
+ throws java.lang.ClassNotFoundException, java.io.IOException,
+ java.lang.UnsupportedOperationException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void invokeReadObjectNoData(java.lang.Object obj)
+ throws java.io.IOException, java.lang.UnsupportedOperationException {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.Object invokeWriteReplace(java.lang.Object obj)
+ throws java.io.IOException, java.lang.UnsupportedOperationException {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.Object invokeReadResolve(java.lang.Object obj)
+ throws java.io.IOException, java.lang.UnsupportedOperationException {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.io.ObjectStreamClass.ClassDataSlot[] getClassDataLayout()
+ throws java.io.InvalidClassException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.io.ObjectStreamClass.ClassDataSlot[] getClassDataLayout0()
+ throws java.io.InvalidClassException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ int getPrimDataSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ int getNumObjFields() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void getPrimFieldValues(java.lang.Object obj, byte[] buf) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setPrimFieldValues(java.lang.Object obj, byte[] buf) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void getObjFieldValues(java.lang.Object obj, java.lang.Object[] vals) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setObjFieldValues(java.lang.Object obj, java.lang.Object[] vals) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private void computeFieldOffsets() throws java.io.InvalidClassException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.io.ObjectStreamClass getVariantFor(java.lang.Class<?> cl)
+ throws java.io.InvalidClassException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.reflect.Constructor<?> getExternalizableConstructor(
+ java.lang.Class<?> cl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.reflect.Constructor<?> getSerializableConstructor(
+ java.lang.Class<?> cl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.reflect.Method getInheritableMethod(
+ java.lang.Class<?> cl,
+ java.lang.String name,
+ java.lang.Class<?>[] argTypes,
+ java.lang.Class<?> returnType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.reflect.Method getPrivateMethod(
+ java.lang.Class<?> cl,
+ java.lang.String name,
+ java.lang.Class<?>[] argTypes,
+ java.lang.Class<?> returnType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean packageEquals(java.lang.Class<?> cl1, java.lang.Class<?> cl2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String getPackageName(java.lang.Class<?> cl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean classNamesEqual(java.lang.String name1, java.lang.String name2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String getClassSignature(java.lang.Class<?> cl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String getMethodSignature(
+ java.lang.Class<?>[] paramTypes, java.lang.Class<?> retType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void throwMiscException(java.lang.Throwable th) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.io.ObjectStreamField[] getSerialFields(java.lang.Class<?> cl)
+ throws java.io.InvalidClassException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.io.ObjectStreamField[] getDeclaredSerialFields(java.lang.Class<?> cl)
+ throws java.io.InvalidClassException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.io.ObjectStreamField[] getDefaultSerialFields(java.lang.Class<?> cl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.Long getDeclaredSUID(java.lang.Class<?> cl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static long computeDefaultSUID(java.lang.Class<?> cl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native boolean hasStaticInitializer(
+ java.lang.Class<?> cl, boolean checkSuperclass);
+
+ private static java.io.ObjectStreamClass.FieldReflector getReflector(
+ java.io.ObjectStreamField[] fields, java.io.ObjectStreamClass localDesc)
+ throws java.io.InvalidClassException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.io.ObjectStreamField[] matchFields(
+ java.io.ObjectStreamField[] fields, java.io.ObjectStreamClass localDesc)
+ throws java.io.InvalidClassException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static long getConstructorId(java.lang.Class<?> clazz) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static java.lang.Object newInstance(java.lang.Class<?> clazz, long constructorId) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static void processQueue(
+ java.lang.ref.ReferenceQueue<java.lang.Class<?>> queue,
+ java.util.concurrent.ConcurrentMap<
+ ? extends java.lang.ref.WeakReference<java.lang.Class<?>>, ?>
+ map) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final int MAX_SDK_TARGET_FOR_CLINIT_UIDGEN_WORKAROUND = 23; // 0x17
+
+ public static final java.io.ObjectStreamField[] NO_FIELDS;
+
+ static {
+ NO_FIELDS = new java.io.ObjectStreamField[0];
+ }
+
+ private java.lang.Class<?> cl;
+
+ private java.lang.reflect.Constructor<?> cons;
+
+ private volatile java.io.ObjectStreamClass.ClassDataSlot[] dataLayout;
+
+ private java.io.ObjectStreamClass.ExceptionInfo defaultSerializeEx;
+
+ private java.io.ObjectStreamClass.ExceptionInfo deserializeEx;
+
+ private boolean externalizable;
+
+ private java.io.ObjectStreamClass.FieldReflector fieldRefl;
+
+ @UnsupportedAppUsage
+ private java.io.ObjectStreamField[] fields;
+
+ private boolean hasBlockExternalData = true;
+
+ private boolean hasWriteObjectData;
+
+ private boolean initialized;
+
+ private boolean isEnum;
+
+ private boolean isProxy;
+
+ private java.io.ObjectStreamClass localDesc;
+
+ private java.lang.String name;
+
+ private int numObjFields;
+
+ private int primDataSize;
+
+ private java.lang.reflect.Method readObjectMethod;
+
+ private java.lang.reflect.Method readObjectNoDataMethod;
+
+ private java.lang.reflect.Method readResolveMethod;
+
+ private java.lang.ClassNotFoundException resolveEx;
+
+ private static final java.io.ObjectStreamField[] serialPersistentFields;
+
+ static {
+ serialPersistentFields = new java.io.ObjectStreamField[0];
+ }
+
+ private static final long serialVersionUID = -6120832682080437368L; // 0xab0e6f1aeefe7b88L
+
+ private boolean serializable;
+
+ private java.io.ObjectStreamClass.ExceptionInfo serializeEx;
+
+ private volatile java.lang.Long suid;
+
+ private java.io.ObjectStreamClass superDesc;
+
+ private java.lang.reflect.Method writeObjectMethod;
+
+ private java.lang.reflect.Method writeReplaceMethod;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class Caches {
+
+ private Caches() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.util.concurrent.ConcurrentMap<
+ java.io.ObjectStreamClass.WeakClassKey, java.lang.ref.Reference<?>>
+ localDescs;
+
+ static {
+ localDescs = null;
+ }
+
+ private static final java.lang.ref.ReferenceQueue<java.lang.Class<?>> localDescsQueue;
+
+ static {
+ localDescsQueue = null;
+ }
+
+ static final java.util.concurrent.ConcurrentMap<
+ java.io.ObjectStreamClass.FieldReflectorKey, java.lang.ref.Reference<?>>
+ reflectors;
+
+ static {
+ reflectors = null;
+ }
+
+ private static final java.lang.ref.ReferenceQueue<java.lang.Class<?>> reflectorsQueue;
+
+ static {
+ reflectorsQueue = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class ClassDataSlot {
+
+ ClassDataSlot(java.io.ObjectStreamClass desc, boolean hasData) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.io.ObjectStreamClass desc;
+
+ {
+ desc = null;
+ }
+
+ final boolean hasData;
+
+ {
+ hasData = false;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class EntryFuture {
+
+ private EntryFuture() {
+ throw new RuntimeException("Stub!");
+ }
+
+ synchronized boolean set(java.lang.Object entry) {
+ throw new RuntimeException("Stub!");
+ }
+
+ synchronized java.lang.Object get() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.Thread getOwner() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object entry;
+
+ private final java.lang.Thread owner;
+
+ {
+ owner = null;
+ }
+
+ private static final java.lang.Object unset;
+
+ static {
+ unset = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class ExceptionInfo {
+
+ ExceptionInfo(java.lang.String cn, java.lang.String msg) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.io.InvalidClassException newInvalidClassException() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.lang.String className;
+
+ {
+ className = null;
+ }
+
+ private final java.lang.String message;
+
+ {
+ message = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class FieldReflector {
+
+ FieldReflector(java.io.ObjectStreamField[] fields) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.io.ObjectStreamField[] getFields() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void getPrimFieldValues(java.lang.Object obj, byte[] buf) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setPrimFieldValues(java.lang.Object obj, byte[] buf) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void getObjFieldValues(java.lang.Object obj, java.lang.Object[] vals) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setObjFieldValues(java.lang.Object obj, java.lang.Object[] vals) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.io.ObjectStreamField[] fields;
+
+ {
+ fields = new java.io.ObjectStreamField[0];
+ }
+
+ private final int numPrimFields;
+
+ {
+ numPrimFields = 0;
+ }
+
+ private final int[] offsets;
+
+ {
+ offsets = new int[0];
+ }
+
+ private final long[] readKeys;
+
+ {
+ readKeys = new long[0];
+ }
+
+ private final char[] typeCodes;
+
+ {
+ typeCodes = new char[0];
+ }
+
+ private final java.lang.Class<?>[] types;
+
+ {
+ types = new java.lang.Class[0];
+ }
+
+ private static final sun.misc.Unsafe unsafe;
+
+ static {
+ unsafe = null;
+ }
+
+ private final long[] writeKeys;
+
+ {
+ writeKeys = new long[0];
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class FieldReflectorKey extends java.lang.ref.WeakReference<java.lang.Class<?>> {
+
+ FieldReflectorKey(
+ java.lang.Class<?> cl,
+ java.io.ObjectStreamField[] fields,
+ java.lang.ref.ReferenceQueue<java.lang.Class<?>> queue) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final int hash;
+
+ {
+ hash = 0;
+ }
+
+ private final boolean nullClass;
+
+ {
+ nullClass = false;
+ }
+
+ private final java.lang.String sigs;
+
+ {
+ sigs = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class MemberSignature {
+
+ public MemberSignature(java.lang.reflect.Field field) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public MemberSignature(java.lang.reflect.Constructor<?> cons) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public MemberSignature(java.lang.reflect.Method meth) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.reflect.Member member;
+
+ {
+ member = null;
+ }
+
+ public final java.lang.String name;
+
+ {
+ name = null;
+ }
+
+ public final java.lang.String signature;
+
+ {
+ signature = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class WeakClassKey extends java.lang.ref.WeakReference<java.lang.Class<?>> {
+
+ WeakClassKey(
+ java.lang.Class<?> cl, java.lang.ref.ReferenceQueue<java.lang.Class<?>> refQueue) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final int hash;
+
+ {
+ hash = 0;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/io/ObjectStreamField.java b/ojluni/annotations/hiddenapi/java/io/ObjectStreamField.java
new file mode 100644
index 0000000..b3b7c34
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/io/ObjectStreamField.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 1996, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.io;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ObjectStreamField implements java.lang.Comparable<java.lang.Object> {
+
+ public ObjectStreamField(java.lang.String name, java.lang.Class<?> type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ObjectStreamField(java.lang.String name, java.lang.Class<?> type, boolean unshared) {
+ throw new RuntimeException("Stub!");
+ }
+
+ ObjectStreamField(java.lang.String name, java.lang.String signature, boolean unshared) {
+ throw new RuntimeException("Stub!");
+ }
+
+ ObjectStreamField(java.lang.reflect.Field field, boolean unshared, boolean showType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Class<?> getType() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public char getTypeCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getTypeString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getOffset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void setOffset(int offset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isPrimitive() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isUnshared() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compareTo(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ java.lang.reflect.Field getField() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.String getSignature() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String getClassSignature(java.lang.Class<?> cl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.lang.reflect.Field field;
+
+ {
+ field = null;
+ }
+
+ private final java.lang.String name;
+
+ {
+ name = null;
+ }
+
+ private int offset = 0; // 0x0
+
+ private final java.lang.String signature;
+
+ {
+ signature = null;
+ }
+
+ private final java.lang.Class<?> type;
+
+ {
+ type = null;
+ }
+
+ private final boolean unshared;
+
+ {
+ unshared = false;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/io/RandomAccessFile.java b/ojluni/annotations/hiddenapi/java/io/RandomAccessFile.java
new file mode 100644
index 0000000..32d36ab
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/io/RandomAccessFile.java
@@ -0,0 +1,260 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1994, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.io;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class RandomAccessFile implements java.io.DataOutput, java.io.DataInput, java.io.Closeable {
+
+ public RandomAccessFile(java.lang.String name, java.lang.String mode)
+ throws java.io.FileNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public RandomAccessFile(java.io.File file, java.lang.String mode)
+ throws java.io.FileNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void maybeSync() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.io.FileDescriptor getFD() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.channels.FileChannel getChannel() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int read() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int readBytes(byte[] b, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int read(byte[] b, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int read(byte[] b) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void readFully(byte[] b) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void readFully(byte[] b, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int skipBytes(int n) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void write(int b) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeBytes(byte[] b, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void write(byte[] b) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void write(byte[] b, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getFilePointer() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void seek(long pos) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long length() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setLength(long newLength) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void close() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean readBoolean() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final byte readByte() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int readUnsignedByte() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final short readShort() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int readUnsignedShort() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final char readChar() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int readInt() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final long readLong() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final float readFloat() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final double readDouble() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String readLine() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String readUTF() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void writeBoolean(boolean v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void writeByte(int v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void writeShort(int v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void writeChar(int v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void writeInt(int v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void writeLong(long v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void writeFloat(float v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void writeDouble(double v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void writeBytes(java.lang.String s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void writeChars(java.lang.String s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void writeUTF(java.lang.String str) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void finalize() throws java.lang.Throwable {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int FLUSH_FDATASYNC = 2; // 0x2
+
+ private static final int FLUSH_FSYNC = 1; // 0x1
+
+ private static final int FLUSH_NONE = 0; // 0x0
+
+ private java.nio.channels.FileChannel channel;
+
+ private java.lang.Object closeLock;
+
+ private volatile boolean closed = false;
+
+ @UnsupportedAppUsage
+ private java.io.FileDescriptor fd;
+
+ private int flushAfterWrite = 0; // 0x0
+
+ private final dalvik.system.CloseGuard guard;
+
+ {
+ guard = null;
+ }
+
+ private final libcore.io.IoTracker ioTracker;
+
+ {
+ ioTracker = null;
+ }
+
+ private int mode;
+
+ private final java.lang.String path;
+
+ {
+ path = null;
+ }
+
+ private boolean rw;
+
+ private final byte[] scratch;
+
+ {
+ scratch = new byte[0];
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/AbstractStringBuilder.java b/ojluni/annotations/hiddenapi/java/lang/AbstractStringBuilder.java
new file mode 100644
index 0000000..42a5b55
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/AbstractStringBuilder.java
@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) 2003, 2016, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+abstract class AbstractStringBuilder implements java.lang.Appendable, java.lang.CharSequence {
+
+ AbstractStringBuilder() {
+ throw new RuntimeException("Stub!");
+ }
+
+ AbstractStringBuilder(int capacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int length() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int capacity() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void ensureCapacity(int minimumCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void ensureCapacityInternal(int minimumCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int newCapacity(int minCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int hugeCapacity(int minCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void trimToSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setLength(int newLength) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public char charAt(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int codePointAt(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int codePointBefore(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int codePointCount(int beginIndex, int endIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int offsetByCodePoints(int index, int codePointOffset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setCharAt(int index, char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder append(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder append(java.lang.String str) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder append(java.lang.StringBuffer sb) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.AbstractStringBuilder append(java.lang.AbstractStringBuilder asb) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder append(java.lang.CharSequence s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.AbstractStringBuilder appendNull() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder append(java.lang.CharSequence s, int start, int end) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder append(char[] str) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder append(char[] str, int offset, int len) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder append(boolean b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder append(char c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder append(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder append(long l) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder append(float f) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder append(double d) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder delete(int start, int end) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder appendCodePoint(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder deleteCharAt(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder replace(int start, int end, java.lang.String str) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String substring(int start) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.CharSequence subSequence(int start, int end) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String substring(int start, int end) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder insert(int index, char[] str, int offset, int len) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder insert(int offset, java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder insert(int offset, java.lang.String str) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder insert(int offset, char[] str) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder insert(int dstOffset, java.lang.CharSequence s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder insert(
+ int dstOffset, java.lang.CharSequence s, int start, int end) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder insert(int offset, boolean b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder insert(int offset, char c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder insert(int offset, int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder insert(int offset, long l) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder insert(int offset, float f) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder insert(int offset, double d) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int indexOf(java.lang.String str) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int indexOf(java.lang.String str, int fromIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int lastIndexOf(java.lang.String str) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int lastIndexOf(java.lang.String str, int fromIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.AbstractStringBuilder reverse() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void reverseAllValidSurrogatePairs() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.lang.String toString();
+
+ final char[] getValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int MAX_ARRAY_SIZE = 2147483639; // 0x7ffffff7
+
+ int count;
+
+ @UnsupportedAppUsage
+ char[] value;
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/Boolean.java b/ojluni/annotations/hiddenapi/java/lang/Boolean.java
new file mode 100644
index 0000000..43090eb
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/Boolean.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 1994, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Boolean
+ implements java.io.Serializable, java.lang.Comparable<java.lang.Boolean> {
+
+ public Boolean(boolean value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Boolean(java.lang.String s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean parseBoolean(java.lang.String s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean booleanValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Boolean valueOf(boolean b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Boolean valueOf(java.lang.String s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(boolean b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int hashCode(boolean value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean getBoolean(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compareTo(java.lang.Boolean b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int compare(boolean x, boolean y) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean logicalAnd(boolean a, boolean b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean logicalOr(boolean a, boolean b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean logicalXor(boolean a, boolean b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.lang.Boolean FALSE;
+
+ static {
+ FALSE = null;
+ }
+
+ public static final java.lang.Boolean TRUE;
+
+ static {
+ TRUE = null;
+ }
+
+ public static final java.lang.Class<java.lang.Boolean> TYPE;
+
+ static {
+ TYPE = null;
+ }
+
+ private static final long serialVersionUID = -3665804199014368530L; // 0xcd207280d59cfaeeL
+
+ @UnsupportedAppUsage
+ private final boolean value;
+
+ {
+ value = false;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/Byte.java b/ojluni/annotations/hiddenapi/java/lang/Byte.java
new file mode 100644
index 0000000..e4d15bf
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/Byte.java
@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) 1996, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Byte extends java.lang.Number implements java.lang.Comparable<java.lang.Byte> {
+
+ public Byte(byte value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Byte(java.lang.String s) throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(byte b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Byte valueOf(byte b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static byte parseByte(java.lang.String s, int radix)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static byte parseByte(java.lang.String s) throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Byte valueOf(java.lang.String s, int radix)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Byte valueOf(java.lang.String s)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Byte decode(java.lang.String nm)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public byte byteValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public short shortValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int intValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long longValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public float floatValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public double doubleValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int hashCode(byte value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compareTo(java.lang.Byte anotherByte) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int compare(byte x, byte y) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int toUnsignedInt(byte x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long toUnsignedLong(byte x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public static java.lang.String toHexString(byte b, boolean upperCase) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final int BYTES = 1; // 0x1
+
+ private static final char[] DIGITS;
+
+ static {
+ DIGITS = new char[0];
+ }
+
+ public static final byte MAX_VALUE = 127; // 0x7f
+
+ public static final byte MIN_VALUE = -128; // 0xffffff80
+
+ public static final int SIZE = 8; // 0x8
+
+ public static final java.lang.Class<java.lang.Byte> TYPE;
+
+ static {
+ TYPE = null;
+ }
+
+ private static final char[] UPPER_CASE_DIGITS;
+
+ static {
+ UPPER_CASE_DIGITS = new char[0];
+ }
+
+ private static final long serialVersionUID = -7183698231559129828L; // 0x9c4e6084ee50f51cL
+
+ @UnsupportedAppUsage
+ private final byte value;
+
+ {
+ value = 0;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class ByteCache {
+
+ private ByteCache() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.lang.Byte[] cache;
+
+ static {
+ cache = new java.lang.Byte[0];
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/Character.java b/ojluni/annotations/hiddenapi/java/lang/Character.java
new file mode 100644
index 0000000..4d7bb1f
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/Character.java
@@ -0,0 +1,2146 @@
+/*
+ * Copyright (c) 2002, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Character
+ implements java.io.Serializable, java.lang.Comparable<java.lang.Character> {
+
+ public Character(char value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Character valueOf(char c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public char charValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int hashCode(char value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(char c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isValidCodePoint(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isBmpCodePoint(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isSupplementaryCodePoint(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isHighSurrogate(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isLowSurrogate(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isSurrogate(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isSurrogatePair(char high, char low) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int charCount(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int toCodePoint(char high, char low) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int codePointAt(java.lang.CharSequence seq, int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int codePointAt(char[] a, int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int codePointAt(char[] a, int index, int limit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static int codePointAtImpl(char[] a, int index, int limit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int codePointBefore(java.lang.CharSequence seq, int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int codePointBefore(char[] a, int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int codePointBefore(char[] a, int index, int start) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static int codePointBeforeImpl(char[] a, int index, int start) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static char highSurrogate(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static char lowSurrogate(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int toChars(int codePoint, char[] dst, int dstIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static char[] toChars(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static void toSurrogates(int codePoint, char[] dst, int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int codePointCount(java.lang.CharSequence seq, int beginIndex, int endIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int codePointCount(char[] a, int offset, int count) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static int codePointCountImpl(char[] a, int offset, int count) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int offsetByCodePoints(
+ java.lang.CharSequence seq, int index, int codePointOffset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int offsetByCodePoints(
+ char[] a, int start, int count, int index, int codePointOffset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static int offsetByCodePointsImpl(
+ char[] a, int start, int count, int index, int codePointOffset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isLowerCase(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isLowerCase(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native boolean isLowerCaseImpl(int codePoint);
+
+ public static boolean isUpperCase(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isUpperCase(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native boolean isUpperCaseImpl(int codePoint);
+
+ public static boolean isTitleCase(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isTitleCase(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native boolean isTitleCaseImpl(int codePoint);
+
+ public static boolean isDigit(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isDigit(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native boolean isDigitImpl(int codePoint);
+
+ public static boolean isDefined(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isDefined(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native boolean isDefinedImpl(int codePoint);
+
+ public static boolean isLetter(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isLetter(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native boolean isLetterImpl(int codePoint);
+
+ public static boolean isLetterOrDigit(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isLetterOrDigit(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native boolean isLetterOrDigitImpl(int codePoint);
+
+ @Deprecated
+ public static boolean isJavaLetter(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public static boolean isJavaLetterOrDigit(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isAlphabetic(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native boolean isAlphabeticImpl(int codePoint);
+
+ public static boolean isIdeographic(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native boolean isIdeographicImpl(int codePoint);
+
+ public static boolean isJavaIdentifierStart(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isJavaIdentifierStart(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isJavaIdentifierPart(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isJavaIdentifierPart(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isUnicodeIdentifierStart(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isUnicodeIdentifierStart(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native boolean isUnicodeIdentifierStartImpl(int codePoint);
+
+ public static boolean isUnicodeIdentifierPart(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isUnicodeIdentifierPart(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native boolean isUnicodeIdentifierPartImpl(int codePoint);
+
+ public static boolean isIdentifierIgnorable(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isIdentifierIgnorable(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native boolean isIdentifierIgnorableImpl(int codePoint);
+
+ public static char toLowerCase(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int toLowerCase(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native int toLowerCaseImpl(int codePoint);
+
+ public static char toUpperCase(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int toUpperCase(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native int toUpperCaseImpl(int codePoint);
+
+ public static char toTitleCase(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int toTitleCase(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native int toTitleCaseImpl(int codePoint);
+
+ public static int digit(char ch, int radix) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int digit(int codePoint, int radix) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native int digitImpl(int codePoint, int radix);
+
+ public static int getNumericValue(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int getNumericValue(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native int getNumericValueImpl(int codePoint);
+
+ @Deprecated
+ public static boolean isSpace(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isSpaceChar(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isSpaceChar(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native boolean isSpaceCharImpl(int codePoint);
+
+ public static boolean isWhitespace(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isWhitespace(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native boolean isWhitespaceImpl(int codePoint);
+
+ public static boolean isISOControl(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isISOControl(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int getType(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int getType(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native int getTypeImpl(int codePoint);
+
+ public static char forDigit(int digit, int radix) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static byte getDirectionality(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static byte getDirectionality(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native byte getDirectionalityImpl(int codePoint);
+
+ public static boolean isMirrored(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isMirrored(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native boolean isMirroredImpl(int codePoint);
+
+ public int compareTo(java.lang.Character anotherCharacter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int compare(char x, char y) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static char reverseBytes(char ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String getName(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native java.lang.String getNameImpl(int codePoint);
+
+ public static final int BYTES = 2; // 0x2
+
+ public static final byte COMBINING_SPACING_MARK = 8; // 0x8
+
+ public static final byte CONNECTOR_PUNCTUATION = 23; // 0x17
+
+ public static final byte CONTROL = 15; // 0xf
+
+ public static final byte CURRENCY_SYMBOL = 26; // 0x1a
+
+ public static final byte DASH_PUNCTUATION = 20; // 0x14
+
+ public static final byte DECIMAL_DIGIT_NUMBER = 9; // 0x9
+
+ private static final byte[] DIRECTIONALITY;
+
+ static {
+ DIRECTIONALITY = new byte[0];
+ }
+
+ public static final byte DIRECTIONALITY_ARABIC_NUMBER = 6; // 0x6
+
+ public static final byte DIRECTIONALITY_BOUNDARY_NEUTRAL = 9; // 0x9
+
+ public static final byte DIRECTIONALITY_COMMON_NUMBER_SEPARATOR = 7; // 0x7
+
+ public static final byte DIRECTIONALITY_EUROPEAN_NUMBER = 3; // 0x3
+
+ public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR = 4; // 0x4
+
+ public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR = 5; // 0x5
+
+ public static final byte DIRECTIONALITY_LEFT_TO_RIGHT = 0; // 0x0
+
+ public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING = 14; // 0xe
+
+ public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE = 15; // 0xf
+
+ public static final byte DIRECTIONALITY_NONSPACING_MARK = 8; // 0x8
+
+ public static final byte DIRECTIONALITY_OTHER_NEUTRALS = 13; // 0xd
+
+ public static final byte DIRECTIONALITY_PARAGRAPH_SEPARATOR = 10; // 0xa
+
+ public static final byte DIRECTIONALITY_POP_DIRECTIONAL_FORMAT = 18; // 0x12
+
+ public static final byte DIRECTIONALITY_RIGHT_TO_LEFT = 1; // 0x1
+
+ public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC = 2; // 0x2
+
+ public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING = 16; // 0x10
+
+ public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE = 17; // 0x11
+
+ public static final byte DIRECTIONALITY_SEGMENT_SEPARATOR = 11; // 0xb
+
+ public static final byte DIRECTIONALITY_UNDEFINED = -1; // 0xffffffff
+
+ public static final byte DIRECTIONALITY_WHITESPACE = 12; // 0xc
+
+ public static final byte ENCLOSING_MARK = 7; // 0x7
+
+ public static final byte END_PUNCTUATION = 22; // 0x16
+
+ static final int ERROR = -1; // 0xffffffff
+
+ public static final byte FINAL_QUOTE_PUNCTUATION = 30; // 0x1e
+
+ public static final byte FORMAT = 16; // 0x10
+
+ public static final byte INITIAL_QUOTE_PUNCTUATION = 29; // 0x1d
+
+ public static final byte LETTER_NUMBER = 10; // 0xa
+
+ public static final byte LINE_SEPARATOR = 13; // 0xd
+
+ public static final byte LOWERCASE_LETTER = 2; // 0x2
+
+ public static final byte MATH_SYMBOL = 25; // 0x19
+
+ public static final int MAX_CODE_POINT = 1114111; // 0x10ffff
+
+ public static final char MAX_HIGH_SURROGATE = 56319; // 0xdbff '\udbff'
+
+ public static final char MAX_LOW_SURROGATE = 57343; // 0xdfff '\udfff'
+
+ public static final int MAX_RADIX = 36; // 0x24
+
+ public static final char MAX_SURROGATE = 57343; // 0xdfff '\udfff'
+
+ public static final char MAX_VALUE = 65535; // 0xffff '\uffff'
+
+ public static final int MIN_CODE_POINT = 0; // 0x0
+
+ public static final char MIN_HIGH_SURROGATE = 55296; // 0xd800 '\ud800'
+
+ public static final char MIN_LOW_SURROGATE = 56320; // 0xdc00 '\udc00'
+
+ public static final int MIN_RADIX = 2; // 0x2
+
+ public static final int MIN_SUPPLEMENTARY_CODE_POINT = 65536; // 0x10000
+
+ public static final char MIN_SURROGATE = 55296; // 0xd800 '\ud800'
+
+ public static final char MIN_VALUE = 0; // 0x0000 '\u0000'
+
+ public static final byte MODIFIER_LETTER = 4; // 0x4
+
+ public static final byte MODIFIER_SYMBOL = 27; // 0x1b
+
+ public static final byte NON_SPACING_MARK = 6; // 0x6
+
+ public static final byte OTHER_LETTER = 5; // 0x5
+
+ public static final byte OTHER_NUMBER = 11; // 0xb
+
+ public static final byte OTHER_PUNCTUATION = 24; // 0x18
+
+ public static final byte OTHER_SYMBOL = 28; // 0x1c
+
+ public static final byte PARAGRAPH_SEPARATOR = 14; // 0xe
+
+ public static final byte PRIVATE_USE = 18; // 0x12
+
+ public static final int SIZE = 16; // 0x10
+
+ public static final byte SPACE_SEPARATOR = 12; // 0xc
+
+ public static final byte START_PUNCTUATION = 21; // 0x15
+
+ public static final byte SURROGATE = 19; // 0x13
+
+ public static final byte TITLECASE_LETTER = 3; // 0x3
+
+ public static final java.lang.Class<java.lang.Character> TYPE;
+
+ static {
+ TYPE = null;
+ }
+
+ public static final byte UNASSIGNED = 0; // 0x0
+
+ public static final byte UPPERCASE_LETTER = 1; // 0x1
+
+ private static final long serialVersionUID = 3786198910865385080L; // 0x348b47d96b1a2678L
+
+ @UnsupportedAppUsage
+ private final char value;
+
+ {
+ value = 0;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class CharacterCache {
+
+ private CharacterCache() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.lang.Character[] cache;
+
+ static {
+ cache = new java.lang.Character[0];
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static class Subset {
+
+ protected Subset(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String name;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static final class UnicodeBlock extends java.lang.Character.Subset {
+
+ private UnicodeBlock(java.lang.String idName) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ private UnicodeBlock(java.lang.String idName, boolean isMap) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ private UnicodeBlock(java.lang.String idName, java.lang.String alias) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ private UnicodeBlock(java.lang.String idName, java.lang.String... aliases) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Character.UnicodeBlock of(char c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Character.UnicodeBlock of(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Character.UnicodeBlock forName(java.lang.String blockName) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.lang.Character.UnicodeBlock AEGEAN_NUMBERS;
+
+ static {
+ AEGEAN_NUMBERS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ALCHEMICAL_SYMBOLS;
+
+ static {
+ ALCHEMICAL_SYMBOLS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ALPHABETIC_PRESENTATION_FORMS;
+
+ static {
+ ALPHABETIC_PRESENTATION_FORMS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ANCIENT_GREEK_MUSICAL_NOTATION;
+
+ static {
+ ANCIENT_GREEK_MUSICAL_NOTATION = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ANCIENT_GREEK_NUMBERS;
+
+ static {
+ ANCIENT_GREEK_NUMBERS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ANCIENT_SYMBOLS;
+
+ static {
+ ANCIENT_SYMBOLS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ARABIC;
+
+ static {
+ ARABIC = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ARABIC_EXTENDED_A;
+
+ static {
+ ARABIC_EXTENDED_A = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS;
+
+ static {
+ ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ARABIC_PRESENTATION_FORMS_A;
+
+ static {
+ ARABIC_PRESENTATION_FORMS_A = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ARABIC_PRESENTATION_FORMS_B;
+
+ static {
+ ARABIC_PRESENTATION_FORMS_B = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ARABIC_SUPPLEMENT;
+
+ static {
+ ARABIC_SUPPLEMENT = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ARMENIAN;
+
+ static {
+ ARMENIAN = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ARROWS;
+
+ static {
+ ARROWS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock AVESTAN;
+
+ static {
+ AVESTAN = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock BALINESE;
+
+ static {
+ BALINESE = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock BAMUM;
+
+ static {
+ BAMUM = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock BAMUM_SUPPLEMENT;
+
+ static {
+ BAMUM_SUPPLEMENT = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock BASIC_LATIN;
+
+ static {
+ BASIC_LATIN = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock BATAK;
+
+ static {
+ BATAK = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock BENGALI;
+
+ static {
+ BENGALI = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock BLOCK_ELEMENTS;
+
+ static {
+ BLOCK_ELEMENTS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock BOPOMOFO;
+
+ static {
+ BOPOMOFO = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock BOPOMOFO_EXTENDED;
+
+ static {
+ BOPOMOFO_EXTENDED = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock BOX_DRAWING;
+
+ static {
+ BOX_DRAWING = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock BRAHMI;
+
+ static {
+ BRAHMI = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock BRAILLE_PATTERNS;
+
+ static {
+ BRAILLE_PATTERNS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock BUGINESE;
+
+ static {
+ BUGINESE = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock BUHID;
+
+ static {
+ BUHID = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock BYZANTINE_MUSICAL_SYMBOLS;
+
+ static {
+ BYZANTINE_MUSICAL_SYMBOLS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CARIAN;
+
+ static {
+ CARIAN = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CHAKMA;
+
+ static {
+ CHAKMA = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CHAM;
+
+ static {
+ CHAM = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CHEROKEE;
+
+ static {
+ CHEROKEE = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CJK_COMPATIBILITY;
+
+ static {
+ CJK_COMPATIBILITY = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CJK_COMPATIBILITY_FORMS;
+
+ static {
+ CJK_COMPATIBILITY_FORMS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CJK_COMPATIBILITY_IDEOGRAPHS;
+
+ static {
+ CJK_COMPATIBILITY_IDEOGRAPHS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock
+ CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT;
+
+ static {
+ CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CJK_RADICALS_SUPPLEMENT;
+
+ static {
+ CJK_RADICALS_SUPPLEMENT = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CJK_STROKES;
+
+ static {
+ CJK_STROKES = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CJK_SYMBOLS_AND_PUNCTUATION;
+
+ static {
+ CJK_SYMBOLS_AND_PUNCTUATION = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CJK_UNIFIED_IDEOGRAPHS;
+
+ static {
+ CJK_UNIFIED_IDEOGRAPHS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A;
+
+ static {
+ CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B;
+
+ static {
+ CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C;
+
+ static {
+ CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D;
+
+ static {
+ CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock COMBINING_DIACRITICAL_MARKS;
+
+ static {
+ COMBINING_DIACRITICAL_MARKS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock COMBINING_DIACRITICAL_MARKS_SUPPLEMENT;
+
+ static {
+ COMBINING_DIACRITICAL_MARKS_SUPPLEMENT = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock COMBINING_HALF_MARKS;
+
+ static {
+ COMBINING_HALF_MARKS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock COMBINING_MARKS_FOR_SYMBOLS;
+
+ static {
+ COMBINING_MARKS_FOR_SYMBOLS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock COMMON_INDIC_NUMBER_FORMS;
+
+ static {
+ COMMON_INDIC_NUMBER_FORMS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CONTROL_PICTURES;
+
+ static {
+ CONTROL_PICTURES = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock COPTIC;
+
+ static {
+ COPTIC = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock COUNTING_ROD_NUMERALS;
+
+ static {
+ COUNTING_ROD_NUMERALS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CUNEIFORM;
+
+ static {
+ CUNEIFORM = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CUNEIFORM_NUMBERS_AND_PUNCTUATION;
+
+ static {
+ CUNEIFORM_NUMBERS_AND_PUNCTUATION = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CURRENCY_SYMBOLS;
+
+ static {
+ CURRENCY_SYMBOLS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CYPRIOT_SYLLABARY;
+
+ static {
+ CYPRIOT_SYLLABARY = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CYRILLIC;
+
+ static {
+ CYRILLIC = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CYRILLIC_EXTENDED_A;
+
+ static {
+ CYRILLIC_EXTENDED_A = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CYRILLIC_EXTENDED_B;
+
+ static {
+ CYRILLIC_EXTENDED_B = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock CYRILLIC_SUPPLEMENTARY;
+
+ static {
+ CYRILLIC_SUPPLEMENTARY = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock DESERET;
+
+ static {
+ DESERET = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock DEVANAGARI;
+
+ static {
+ DEVANAGARI = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock DEVANAGARI_EXTENDED;
+
+ static {
+ DEVANAGARI_EXTENDED = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock DINGBATS;
+
+ static {
+ DINGBATS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock DOMINO_TILES;
+
+ static {
+ DOMINO_TILES = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock EGYPTIAN_HIEROGLYPHS;
+
+ static {
+ EGYPTIAN_HIEROGLYPHS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock EMOTICONS;
+
+ static {
+ EMOTICONS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ENCLOSED_ALPHANUMERICS;
+
+ static {
+ ENCLOSED_ALPHANUMERICS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ENCLOSED_ALPHANUMERIC_SUPPLEMENT;
+
+ static {
+ ENCLOSED_ALPHANUMERIC_SUPPLEMENT = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ENCLOSED_CJK_LETTERS_AND_MONTHS;
+
+ static {
+ ENCLOSED_CJK_LETTERS_AND_MONTHS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ENCLOSED_IDEOGRAPHIC_SUPPLEMENT;
+
+ static {
+ ENCLOSED_IDEOGRAPHIC_SUPPLEMENT = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ETHIOPIC;
+
+ static {
+ ETHIOPIC = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ETHIOPIC_EXTENDED;
+
+ static {
+ ETHIOPIC_EXTENDED = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ETHIOPIC_EXTENDED_A;
+
+ static {
+ ETHIOPIC_EXTENDED_A = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ETHIOPIC_SUPPLEMENT;
+
+ static {
+ ETHIOPIC_SUPPLEMENT = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock GENERAL_PUNCTUATION;
+
+ static {
+ GENERAL_PUNCTUATION = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock GEOMETRIC_SHAPES;
+
+ static {
+ GEOMETRIC_SHAPES = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock GEORGIAN;
+
+ static {
+ GEORGIAN = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock GEORGIAN_SUPPLEMENT;
+
+ static {
+ GEORGIAN_SUPPLEMENT = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock GLAGOLITIC;
+
+ static {
+ GLAGOLITIC = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock GOTHIC;
+
+ static {
+ GOTHIC = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock GREEK;
+
+ static {
+ GREEK = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock GREEK_EXTENDED;
+
+ static {
+ GREEK_EXTENDED = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock GUJARATI;
+
+ static {
+ GUJARATI = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock GURMUKHI;
+
+ static {
+ GURMUKHI = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock HALFWIDTH_AND_FULLWIDTH_FORMS;
+
+ static {
+ HALFWIDTH_AND_FULLWIDTH_FORMS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock HANGUL_COMPATIBILITY_JAMO;
+
+ static {
+ HANGUL_COMPATIBILITY_JAMO = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock HANGUL_JAMO;
+
+ static {
+ HANGUL_JAMO = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock HANGUL_JAMO_EXTENDED_A;
+
+ static {
+ HANGUL_JAMO_EXTENDED_A = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock HANGUL_JAMO_EXTENDED_B;
+
+ static {
+ HANGUL_JAMO_EXTENDED_B = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock HANGUL_SYLLABLES;
+
+ static {
+ HANGUL_SYLLABLES = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock HANUNOO;
+
+ static {
+ HANUNOO = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock HEBREW;
+
+ static {
+ HEBREW = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock HIGH_PRIVATE_USE_SURROGATES;
+
+ static {
+ HIGH_PRIVATE_USE_SURROGATES = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock HIGH_SURROGATES;
+
+ static {
+ HIGH_SURROGATES = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock HIRAGANA;
+
+ static {
+ HIRAGANA = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock IDEOGRAPHIC_DESCRIPTION_CHARACTERS;
+
+ static {
+ IDEOGRAPHIC_DESCRIPTION_CHARACTERS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock IMPERIAL_ARAMAIC;
+
+ static {
+ IMPERIAL_ARAMAIC = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock INSCRIPTIONAL_PAHLAVI;
+
+ static {
+ INSCRIPTIONAL_PAHLAVI = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock INSCRIPTIONAL_PARTHIAN;
+
+ static {
+ INSCRIPTIONAL_PARTHIAN = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock IPA_EXTENSIONS;
+
+ static {
+ IPA_EXTENSIONS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock JAVANESE;
+
+ static {
+ JAVANESE = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock KAITHI;
+
+ static {
+ KAITHI = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock KANA_SUPPLEMENT;
+
+ static {
+ KANA_SUPPLEMENT = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock KANBUN;
+
+ static {
+ KANBUN = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock KANGXI_RADICALS;
+
+ static {
+ KANGXI_RADICALS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock KANNADA;
+
+ static {
+ KANNADA = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock KATAKANA;
+
+ static {
+ KATAKANA = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock KATAKANA_PHONETIC_EXTENSIONS;
+
+ static {
+ KATAKANA_PHONETIC_EXTENSIONS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock KAYAH_LI;
+
+ static {
+ KAYAH_LI = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock KHAROSHTHI;
+
+ static {
+ KHAROSHTHI = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock KHMER;
+
+ static {
+ KHMER = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock KHMER_SYMBOLS;
+
+ static {
+ KHMER_SYMBOLS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock LAO;
+
+ static {
+ LAO = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock LATIN_1_SUPPLEMENT;
+
+ static {
+ LATIN_1_SUPPLEMENT = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock LATIN_EXTENDED_A;
+
+ static {
+ LATIN_EXTENDED_A = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock LATIN_EXTENDED_ADDITIONAL;
+
+ static {
+ LATIN_EXTENDED_ADDITIONAL = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock LATIN_EXTENDED_B;
+
+ static {
+ LATIN_EXTENDED_B = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock LATIN_EXTENDED_C;
+
+ static {
+ LATIN_EXTENDED_C = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock LATIN_EXTENDED_D;
+
+ static {
+ LATIN_EXTENDED_D = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock LEPCHA;
+
+ static {
+ LEPCHA = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock LETTERLIKE_SYMBOLS;
+
+ static {
+ LETTERLIKE_SYMBOLS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock LIMBU;
+
+ static {
+ LIMBU = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock LINEAR_B_IDEOGRAMS;
+
+ static {
+ LINEAR_B_IDEOGRAMS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock LINEAR_B_SYLLABARY;
+
+ static {
+ LINEAR_B_SYLLABARY = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock LISU;
+
+ static {
+ LISU = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock LOW_SURROGATES;
+
+ static {
+ LOW_SURROGATES = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock LYCIAN;
+
+ static {
+ LYCIAN = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock LYDIAN;
+
+ static {
+ LYDIAN = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MAHJONG_TILES;
+
+ static {
+ MAHJONG_TILES = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MALAYALAM;
+
+ static {
+ MALAYALAM = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MANDAIC;
+
+ static {
+ MANDAIC = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MATHEMATICAL_ALPHANUMERIC_SYMBOLS;
+
+ static {
+ MATHEMATICAL_ALPHANUMERIC_SYMBOLS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MATHEMATICAL_OPERATORS;
+
+ static {
+ MATHEMATICAL_OPERATORS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MEETEI_MAYEK;
+
+ static {
+ MEETEI_MAYEK = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MEETEI_MAYEK_EXTENSIONS;
+
+ static {
+ MEETEI_MAYEK_EXTENSIONS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MEROITIC_CURSIVE;
+
+ static {
+ MEROITIC_CURSIVE = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MEROITIC_HIEROGLYPHS;
+
+ static {
+ MEROITIC_HIEROGLYPHS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MIAO;
+
+ static {
+ MIAO = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A;
+
+ static {
+ MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B;
+
+ static {
+ MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MISCELLANEOUS_SYMBOLS;
+
+ static {
+ MISCELLANEOUS_SYMBOLS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MISCELLANEOUS_SYMBOLS_AND_ARROWS;
+
+ static {
+ MISCELLANEOUS_SYMBOLS_AND_ARROWS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS;
+
+ static {
+ MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MISCELLANEOUS_TECHNICAL;
+
+ static {
+ MISCELLANEOUS_TECHNICAL = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MODIFIER_TONE_LETTERS;
+
+ static {
+ MODIFIER_TONE_LETTERS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MONGOLIAN;
+
+ static {
+ MONGOLIAN = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MUSICAL_SYMBOLS;
+
+ static {
+ MUSICAL_SYMBOLS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MYANMAR;
+
+ static {
+ MYANMAR = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock MYANMAR_EXTENDED_A;
+
+ static {
+ MYANMAR_EXTENDED_A = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock NEW_TAI_LUE;
+
+ static {
+ NEW_TAI_LUE = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock NKO;
+
+ static {
+ NKO = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock NUMBER_FORMS;
+
+ static {
+ NUMBER_FORMS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock OGHAM;
+
+ static {
+ OGHAM = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock OLD_ITALIC;
+
+ static {
+ OLD_ITALIC = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock OLD_PERSIAN;
+
+ static {
+ OLD_PERSIAN = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock OLD_SOUTH_ARABIAN;
+
+ static {
+ OLD_SOUTH_ARABIAN = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock OLD_TURKIC;
+
+ static {
+ OLD_TURKIC = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock OL_CHIKI;
+
+ static {
+ OL_CHIKI = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock OPTICAL_CHARACTER_RECOGNITION;
+
+ static {
+ OPTICAL_CHARACTER_RECOGNITION = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock ORIYA;
+
+ static {
+ ORIYA = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock OSMANYA;
+
+ static {
+ OSMANYA = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock PHAGS_PA;
+
+ static {
+ PHAGS_PA = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock PHAISTOS_DISC;
+
+ static {
+ PHAISTOS_DISC = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock PHOENICIAN;
+
+ static {
+ PHOENICIAN = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock PHONETIC_EXTENSIONS;
+
+ static {
+ PHONETIC_EXTENSIONS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock PHONETIC_EXTENSIONS_SUPPLEMENT;
+
+ static {
+ PHONETIC_EXTENSIONS_SUPPLEMENT = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock PLAYING_CARDS;
+
+ static {
+ PLAYING_CARDS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock PRIVATE_USE_AREA;
+
+ static {
+ PRIVATE_USE_AREA = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock REJANG;
+
+ static {
+ REJANG = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock RUMI_NUMERAL_SYMBOLS;
+
+ static {
+ RUMI_NUMERAL_SYMBOLS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock RUNIC;
+
+ static {
+ RUNIC = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SAMARITAN;
+
+ static {
+ SAMARITAN = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SAURASHTRA;
+
+ static {
+ SAURASHTRA = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SHARADA;
+
+ static {
+ SHARADA = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SHAVIAN;
+
+ static {
+ SHAVIAN = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SINHALA;
+
+ static {
+ SINHALA = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SMALL_FORM_VARIANTS;
+
+ static {
+ SMALL_FORM_VARIANTS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SORA_SOMPENG;
+
+ static {
+ SORA_SOMPENG = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SPACING_MODIFIER_LETTERS;
+
+ static {
+ SPACING_MODIFIER_LETTERS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SPECIALS;
+
+ static {
+ SPECIALS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SUNDANESE;
+
+ static {
+ SUNDANESE = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SUNDANESE_SUPPLEMENT;
+
+ static {
+ SUNDANESE_SUPPLEMENT = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SUPERSCRIPTS_AND_SUBSCRIPTS;
+
+ static {
+ SUPERSCRIPTS_AND_SUBSCRIPTS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SUPPLEMENTAL_ARROWS_A;
+
+ static {
+ SUPPLEMENTAL_ARROWS_A = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SUPPLEMENTAL_ARROWS_B;
+
+ static {
+ SUPPLEMENTAL_ARROWS_B = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SUPPLEMENTAL_MATHEMATICAL_OPERATORS;
+
+ static {
+ SUPPLEMENTAL_MATHEMATICAL_OPERATORS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SUPPLEMENTAL_PUNCTUATION;
+
+ static {
+ SUPPLEMENTAL_PUNCTUATION = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SUPPLEMENTARY_PRIVATE_USE_AREA_A;
+
+ static {
+ SUPPLEMENTARY_PRIVATE_USE_AREA_A = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SUPPLEMENTARY_PRIVATE_USE_AREA_B;
+
+ static {
+ SUPPLEMENTARY_PRIVATE_USE_AREA_B = null;
+ }
+
+ @Deprecated public static final java.lang.Character.UnicodeBlock SURROGATES_AREA;
+
+ static {
+ SURROGATES_AREA = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SYLOTI_NAGRI;
+
+ static {
+ SYLOTI_NAGRI = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock SYRIAC;
+
+ static {
+ SYRIAC = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock TAGALOG;
+
+ static {
+ TAGALOG = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock TAGBANWA;
+
+ static {
+ TAGBANWA = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock TAGS;
+
+ static {
+ TAGS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock TAI_LE;
+
+ static {
+ TAI_LE = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock TAI_THAM;
+
+ static {
+ TAI_THAM = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock TAI_VIET;
+
+ static {
+ TAI_VIET = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock TAI_XUAN_JING_SYMBOLS;
+
+ static {
+ TAI_XUAN_JING_SYMBOLS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock TAKRI;
+
+ static {
+ TAKRI = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock TAMIL;
+
+ static {
+ TAMIL = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock TELUGU;
+
+ static {
+ TELUGU = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock THAANA;
+
+ static {
+ THAANA = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock THAI;
+
+ static {
+ THAI = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock TIBETAN;
+
+ static {
+ TIBETAN = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock TIFINAGH;
+
+ static {
+ TIFINAGH = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock TRANSPORT_AND_MAP_SYMBOLS;
+
+ static {
+ TRANSPORT_AND_MAP_SYMBOLS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock UGARITIC;
+
+ static {
+ UGARITIC = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS;
+
+ static {
+ UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock
+ UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED;
+
+ static {
+ UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock VAI;
+
+ static {
+ VAI = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock VARIATION_SELECTORS;
+
+ static {
+ VARIATION_SELECTORS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock VARIATION_SELECTORS_SUPPLEMENT;
+
+ static {
+ VARIATION_SELECTORS_SUPPLEMENT = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock VEDIC_EXTENSIONS;
+
+ static {
+ VEDIC_EXTENSIONS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock VERTICAL_FORMS;
+
+ static {
+ VERTICAL_FORMS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock YIJING_HEXAGRAM_SYMBOLS;
+
+ static {
+ YIJING_HEXAGRAM_SYMBOLS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock YI_RADICALS;
+
+ static {
+ YI_RADICALS = null;
+ }
+
+ public static final java.lang.Character.UnicodeBlock YI_SYLLABLES;
+
+ static {
+ YI_SYLLABLES = null;
+ }
+
+ private static final int[] blockStarts;
+
+ static {
+ blockStarts = new int[0];
+ }
+
+ private static final java.lang.Character.UnicodeBlock[] blocks;
+
+ static {
+ blocks = new java.lang.Character.UnicodeBlock[0];
+ }
+
+ private static java.util.Map<java.lang.String, java.lang.Character.UnicodeBlock> map;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static enum UnicodeScript {
+ COMMON,
+ LATIN,
+ GREEK,
+ CYRILLIC,
+ ARMENIAN,
+ HEBREW,
+ ARABIC,
+ SYRIAC,
+ THAANA,
+ DEVANAGARI,
+ BENGALI,
+ GURMUKHI,
+ GUJARATI,
+ ORIYA,
+ TAMIL,
+ TELUGU,
+ KANNADA,
+ MALAYALAM,
+ SINHALA,
+ THAI,
+ LAO,
+ TIBETAN,
+ MYANMAR,
+ GEORGIAN,
+ HANGUL,
+ ETHIOPIC,
+ CHEROKEE,
+ CANADIAN_ABORIGINAL,
+ OGHAM,
+ RUNIC,
+ KHMER,
+ MONGOLIAN,
+ HIRAGANA,
+ KATAKANA,
+ BOPOMOFO,
+ HAN,
+ YI,
+ OLD_ITALIC,
+ GOTHIC,
+ DESERET,
+ INHERITED,
+ TAGALOG,
+ HANUNOO,
+ BUHID,
+ TAGBANWA,
+ LIMBU,
+ TAI_LE,
+ LINEAR_B,
+ UGARITIC,
+ SHAVIAN,
+ OSMANYA,
+ CYPRIOT,
+ BRAILLE,
+ BUGINESE,
+ COPTIC,
+ NEW_TAI_LUE,
+ GLAGOLITIC,
+ TIFINAGH,
+ SYLOTI_NAGRI,
+ OLD_PERSIAN,
+ KHAROSHTHI,
+ BALINESE,
+ CUNEIFORM,
+ PHOENICIAN,
+ PHAGS_PA,
+ NKO,
+ SUNDANESE,
+ BATAK,
+ LEPCHA,
+ OL_CHIKI,
+ VAI,
+ SAURASHTRA,
+ KAYAH_LI,
+ REJANG,
+ LYCIAN,
+ CARIAN,
+ LYDIAN,
+ CHAM,
+ TAI_THAM,
+ TAI_VIET,
+ AVESTAN,
+ EGYPTIAN_HIEROGLYPHS,
+ SAMARITAN,
+ MANDAIC,
+ LISU,
+ BAMUM,
+ JAVANESE,
+ MEETEI_MAYEK,
+ IMPERIAL_ARAMAIC,
+ OLD_SOUTH_ARABIAN,
+ INSCRIPTIONAL_PARTHIAN,
+ INSCRIPTIONAL_PAHLAVI,
+ OLD_TURKIC,
+ BRAHMI,
+ KAITHI,
+ MEROITIC_HIEROGLYPHS,
+ MEROITIC_CURSIVE,
+ SORA_SOMPENG,
+ CHAKMA,
+ SHARADA,
+ TAKRI,
+ MIAO,
+ UNKNOWN;
+
+ private UnicodeScript() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Character.UnicodeScript of(int codePoint) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Character.UnicodeScript forName(java.lang.String scriptName) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.util.HashMap<java.lang.String, java.lang.Character.UnicodeScript>
+ aliases = null;
+
+ private static final int[] scriptStarts = null;
+
+ private static final java.lang.Character.UnicodeScript[] scripts = null;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/Class.java b/ojluni/annotations/hiddenapi/java/lang/Class.java
new file mode 100644
index 0000000..12a69d7
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/Class.java
@@ -0,0 +1,491 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1994, 2014, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Class<T>
+ implements java.io.Serializable,
+ java.lang.reflect.GenericDeclaration,
+ java.lang.reflect.Type,
+ java.lang.reflect.AnnotatedElement {
+
+ @UnsupportedAppUsage
+ private Class() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toGenericString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Class<?> forName(java.lang.String className)
+ throws java.lang.ClassNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Class<?> forName(
+ java.lang.String name, boolean initialize, java.lang.ClassLoader loader)
+ throws java.lang.ClassNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native java.lang.Class<?> classForName(
+ java.lang.String className, boolean shouldInitialize, java.lang.ClassLoader classLoader)
+ throws java.lang.ClassNotFoundException;
+
+ public native T newInstance()
+ throws java.lang.IllegalAccessException, java.lang.InstantiationException;
+
+ public boolean isInstance(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isAssignableFrom(java.lang.Class<?> cls) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isInterface() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isPrimitive() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isFinalizable() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isAnnotation() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isSynthetic() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.String getNameNative();
+
+ public java.lang.ClassLoader getClassLoader() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized java.lang.reflect.TypeVariable<java.lang.Class<T>>[] getTypeParameters() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Class<? super T> getSuperclass() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.reflect.Type getGenericSuperclass() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Package getPackage() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getPackageName$() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Class<?>[] getInterfaces() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.Class<?>[] getInterfacesInternal();
+
+ public java.lang.reflect.Type[] getGenericInterfaces() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Class<?> getComponentType() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getModifiers() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] getSigners() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.reflect.Method getEnclosingMethodNative();
+
+ public java.lang.reflect.Method getEnclosingMethod() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.reflect.Constructor<?> getEnclosingConstructor() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.reflect.Constructor<?> getEnclosingConstructorNative();
+
+ private boolean classNameImpliesTopLevel() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public native java.lang.Class<?> getDeclaringClass();
+
+ public native java.lang.Class<?> getEnclosingClass();
+
+ public java.lang.String getSimpleName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getTypeName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getCanonicalName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public native boolean isAnonymousClass();
+
+ public boolean isLocalClass() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMemberClass() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean isLocalOrAnonymousClass() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Class<?>[] getClasses() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.reflect.Field[] getFields() throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void getPublicFieldsRecursive(java.util.List<java.lang.reflect.Field> result) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.reflect.Method[] getMethods() throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void getPublicMethodsInternal(java.util.List<java.lang.reflect.Method> result) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.reflect.Constructor<?>[] getConstructors() throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.reflect.Field getField(java.lang.String name)
+ throws java.lang.NoSuchFieldException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.reflect.Field getPublicFieldRecursive(java.lang.String name);
+
+ public java.lang.reflect.Method getMethod(
+ java.lang.String name, java.lang.Class<?>... parameterTypes)
+ throws java.lang.NoSuchMethodException, java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.reflect.Constructor<T> getConstructor(java.lang.Class<?>... parameterTypes)
+ throws java.lang.NoSuchMethodException, java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public native java.lang.Class<?>[] getDeclaredClasses();
+
+ public native java.lang.reflect.Field[] getDeclaredFields();
+
+ public native java.lang.reflect.Field[] getDeclaredFieldsUnchecked(boolean publicOnly);
+
+ public java.lang.reflect.Method[] getDeclaredMethods() throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public native java.lang.reflect.Method[] getDeclaredMethodsUnchecked(boolean publicOnly);
+
+ public java.lang.reflect.Constructor<?>[] getDeclaredConstructors()
+ throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.reflect.Constructor<?>[] getDeclaredConstructorsInternal(
+ boolean publicOnly);
+
+ public native java.lang.reflect.Field getDeclaredField(java.lang.String name)
+ throws java.lang.NoSuchFieldException;
+
+ private native java.lang.reflect.Field[] getPublicDeclaredFields();
+
+ public java.lang.reflect.Method getDeclaredMethod(
+ java.lang.String name, java.lang.Class<?>... parameterTypes)
+ throws java.lang.NoSuchMethodException, java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private java.lang.reflect.Method getMethod(
+ java.lang.String name,
+ java.lang.Class<?>[] parameterTypes,
+ boolean recursivePublicMethods)
+ throws java.lang.NoSuchMethodException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.reflect.Method getPublicMethodRecursive(
+ java.lang.String name, java.lang.Class<?>[] parameterTypes) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.reflect.Method getInstanceMethod(
+ java.lang.String name, java.lang.Class<?>[] parameterTypes)
+ throws java.lang.IllegalAccessException, java.lang.NoSuchMethodException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.reflect.Method findInterfaceMethod(
+ java.lang.String name, java.lang.Class<?>[] parameterTypes) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.reflect.Constructor<T> getDeclaredConstructor(
+ java.lang.Class<?>... parameterTypes)
+ throws java.lang.NoSuchMethodException, java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.InputStream getResourceAsStream(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.URL getResource(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.security.ProtectionDomain getProtectionDomain() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static native java.lang.Class<?> getPrimitiveClass(java.lang.String name);
+
+ private java.lang.String resolveName(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.reflect.Constructor<T> getConstructor0(
+ java.lang.Class<?>[] parameterTypes, int which) throws java.lang.NoSuchMethodException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.reflect.Constructor<T> getDeclaredConstructorInternal(
+ java.lang.Class<?>[] args);
+
+ public boolean desiredAssertionStatus() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.String getInnerClassName();
+
+ private native int getInnerClassFlags(int defaultValue);
+
+ public boolean isEnum() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public T[] getEnumConstants() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public T[] getEnumConstantsShared() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public T cast(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String cannotCastMsg(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <U> java.lang.Class<? extends U> asSubclass(java.lang.Class<U> clazz) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <A extends java.lang.annotation.Annotation> A getAnnotation(
+ java.lang.Class<A> annotationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isAnnotationPresent(
+ java.lang.Class<? extends java.lang.annotation.Annotation> annotationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <A extends java.lang.annotation.Annotation> A[] getAnnotationsByType(
+ java.lang.Class<A> annotationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.annotation.Annotation[] getAnnotations() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public native <A extends java.lang.annotation.Annotation> A getDeclaredAnnotation(
+ java.lang.Class<A> annotationClass);
+
+ public native java.lang.annotation.Annotation[] getDeclaredAnnotations();
+
+ private native boolean isDeclaredAnnotationPresent(
+ java.lang.Class<? extends java.lang.annotation.Annotation> annotationClass);
+
+ private java.lang.String getSignatureAttribute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.String[] getSignatureAnnotation();
+
+ public boolean isProxy() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getAccessFlags() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.reflect.Method getDeclaredMethodInternal(
+ java.lang.String name, java.lang.Class<?>[] args);
+
+ private static final int ANNOTATION = 8192; // 0x2000
+
+ private static final int ENUM = 16384; // 0x4000
+
+ private static final int FINALIZABLE = -2147483648; // 0x80000000
+
+ private static final int SYNTHETIC = 4096; // 0x1000
+
+ @UnsupportedAppUsage
+ private transient int accessFlags;
+
+ private transient int classFlags;
+
+ @UnsupportedAppUsage
+ private transient java.lang.ClassLoader classLoader;
+
+ private transient int classSize;
+
+ @UnsupportedAppUsage
+ private transient int clinitThreadId;
+
+ private transient java.lang.Class<?> componentType;
+
+ private transient short copiedMethodsOffset;
+
+ @UnsupportedAppUsage
+ private transient java.lang.Object dexCache;
+
+ @UnsupportedAppUsage
+ private transient int dexClassDefIndex;
+
+ private transient volatile int dexTypeIndex;
+
+ private transient dalvik.system.ClassExt extData;
+
+ private transient long iFields;
+
+ @UnsupportedAppUsage
+ private transient java.lang.Object[] ifTable;
+
+ private transient long methods;
+
+ @UnsupportedAppUsage
+ private transient java.lang.String name;
+
+ private transient int numReferenceInstanceFields;
+
+ private transient int numReferenceStaticFields;
+
+ @UnsupportedAppUsage
+ private transient int objectSize;
+
+ private transient int objectSizeAllocFastPath;
+
+ private transient int primitiveType;
+
+ private transient int referenceInstanceOffsets;
+
+ private transient long sFields;
+
+ private static final long serialVersionUID = 3206093459760846163L; // 0x2c7e5503d9bf9553L
+
+ @UnsupportedAppUsage
+ private transient int status;
+
+ private transient java.lang.Class<? super T> superClass;
+
+ private transient short virtualMethodsOffset;
+
+ private transient java.lang.Object vtable;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class Caches {
+
+ private Caches() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final libcore.util.BasicLruCache<java.lang.Class, java.lang.reflect.Type[]>
+ genericInterfaces;
+
+ static {
+ genericInterfaces = null;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/ClassLoader.java b/ojluni/annotations/hiddenapi/java/lang/ClassLoader.java
new file mode 100644
index 0000000..6af0cb8
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/ClassLoader.java
@@ -0,0 +1,252 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2013, 2015, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class ClassLoader {
+
+ private ClassLoader(java.lang.Void unused, java.lang.ClassLoader parent) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected ClassLoader(java.lang.ClassLoader parent) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected ClassLoader() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.ClassLoader createSystemClassLoader() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.Void checkCreateClassLoader() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Class<?> loadClass(java.lang.String name)
+ throws java.lang.ClassNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Class<?> loadClass(java.lang.String name, boolean resolve)
+ throws java.lang.ClassNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Class<?> findClass(java.lang.String name)
+ throws java.lang.ClassNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ protected final java.lang.Class<?> defineClass(byte[] b, int off, int len)
+ throws java.lang.ClassFormatError {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final java.lang.Class<?> defineClass(
+ java.lang.String name, byte[] b, int off, int len) throws java.lang.ClassFormatError {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final java.lang.Class<?> defineClass(
+ java.lang.String name,
+ byte[] b,
+ int off,
+ int len,
+ java.security.ProtectionDomain protectionDomain)
+ throws java.lang.ClassFormatError {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final java.lang.Class<?> defineClass(
+ java.lang.String name,
+ java.nio.ByteBuffer b,
+ java.security.ProtectionDomain protectionDomain)
+ throws java.lang.ClassFormatError {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final void resolveClass(java.lang.Class<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final java.lang.Class<?> findSystemClass(java.lang.String name)
+ throws java.lang.ClassNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Class<?> findBootstrapClassOrNull(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final java.lang.Class<?> findLoadedClass(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final void setSigners(java.lang.Class<?> c, java.lang.Object[] signers) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.URL getResource(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Enumeration<java.net.URL> getResources(java.lang.String name)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.net.URL findResource(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.util.Enumeration<java.net.URL> findResources(java.lang.String name)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected static boolean registerAsParallelCapable() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.net.URL getSystemResource(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Enumeration<java.net.URL> getSystemResources(java.lang.String name)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.net.URL getBootstrapResource(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.util.Enumeration<java.net.URL> getBootstrapResources(java.lang.String name)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.InputStream getResourceAsStream(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.io.InputStream getSystemResourceAsStream(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.ClassLoader getParent() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.ClassLoader getSystemClassLoader() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.lang.ClassLoader getClassLoader(java.lang.Class<?> caller) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Package definePackage(
+ java.lang.String name,
+ java.lang.String specTitle,
+ java.lang.String specVersion,
+ java.lang.String specVendor,
+ java.lang.String implTitle,
+ java.lang.String implVersion,
+ java.lang.String implVendor,
+ java.net.URL sealBase)
+ throws java.lang.IllegalArgumentException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Package getPackage(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Package[] getPackages() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.String findLibrary(java.lang.String libname) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setDefaultAssertionStatus(boolean enabled) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setPackageAssertionStatus(java.lang.String packageName, boolean enabled) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setClassAssertionStatus(java.lang.String className, boolean enabled) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clearAssertionStatus() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private transient long allocator;
+
+ private transient long classTable;
+
+ private final java.util.HashMap<java.lang.String, java.lang.Package> packages;
+
+ {
+ packages = null;
+ }
+
+ @UnsupportedAppUsage
+ private final java.lang.ClassLoader parent;
+
+ {
+ parent = null;
+ }
+
+ public final java.util.Map<java.util.List<java.lang.Class<?>>, java.lang.Class<?>> proxyCache;
+
+ {
+ proxyCache = null;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class SystemClassLoader {
+
+ private SystemClassLoader() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.ClassLoader loader;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/Double.java b/ojluni/annotations/hiddenapi/java/lang/Double.java
new file mode 100644
index 0000000..0542e66
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/Double.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 1994, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Double extends java.lang.Number
+ implements java.lang.Comparable<java.lang.Double> {
+
+ public Double(double value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Double(java.lang.String s) throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(double d) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toHexString(double d) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Double valueOf(java.lang.String s)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Double valueOf(double d) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static double parseDouble(java.lang.String s) throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isNaN(double v) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isInfinite(double v) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isFinite(double d) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isNaN() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isInfinite() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public byte byteValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public short shortValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int intValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long longValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public float floatValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public double doubleValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int hashCode(double value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long doubleToLongBits(double value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static native long doubleToRawLongBits(double value);
+
+ public static native double longBitsToDouble(long bits);
+
+ public int compareTo(java.lang.Double anotherDouble) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int compare(double d1, double d2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static double sum(double a, double b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static double max(double a, double b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static double min(double a, double b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final int BYTES = 8; // 0x8
+
+ public static final int MAX_EXPONENT = 1023; // 0x3ff
+
+ public static final double MAX_VALUE = 1.7976931348623157E308;
+
+ public static final int MIN_EXPONENT = -1022; // 0xfffffc02
+
+ public static final double MIN_NORMAL = 2.2250738585072014E-308;
+
+ public static final double MIN_VALUE = 4.9E-324;
+
+ public static final double NEGATIVE_INFINITY = (-1.0 / 0.0);
+
+ public static final double NaN = (0.0 / 0.0);
+
+ public static final double POSITIVE_INFINITY = (1.0 / 0.0);
+
+ public static final int SIZE = 64; // 0x40
+
+ public static final java.lang.Class<java.lang.Double> TYPE;
+
+ static {
+ TYPE = null;
+ }
+
+ private static final long serialVersionUID = -9172774392245257468L; // 0x80b3c24a296bfb04L
+
+ @UnsupportedAppUsage
+ private final double value;
+
+ {
+ value = 0;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/Enum.java b/ojluni/annotations/hiddenapi/java/lang/Enum.java
new file mode 100644
index 0000000..369e58e
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/Enum.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2003, 2011, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class Enum<E extends java.lang.Enum<E>>
+ implements java.lang.Comparable<E>, java.io.Serializable {
+
+ protected Enum(java.lang.String name, int ordinal) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String name() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int ordinal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean equals(java.lang.Object other) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final java.lang.Object clone() throws java.lang.CloneNotSupportedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int compareTo(E o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.Class<E> getDeclaringClass() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T extends java.lang.Enum<T>> T valueOf(
+ java.lang.Class<T> enumType, java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.Object[] enumValues(java.lang.Class<? extends java.lang.Enum> clazz) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public static <T extends java.lang.Enum<T>> T[] getSharedConstants(
+ java.lang.Class<T> enumType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final void finalize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream in)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObjectNoData() throws java.io.ObjectStreamException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private final java.lang.String name;
+
+ {
+ name = null;
+ }
+
+ @UnsupportedAppUsage
+ private final int ordinal;
+
+ {
+ ordinal = 0;
+ }
+
+ private static final libcore.util.BasicLruCache<
+ java.lang.Class<? extends java.lang.Enum>, java.lang.Object[]>
+ sharedConstantsCache;
+
+ static {
+ sharedConstantsCache = null;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/Float.java b/ojluni/annotations/hiddenapi/java/lang/Float.java
new file mode 100644
index 0000000..48d1322
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/Float.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 1994, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Float extends java.lang.Number implements java.lang.Comparable<java.lang.Float> {
+
+ public Float(float value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Float(double value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Float(java.lang.String s) throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(float f) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toHexString(float f) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Float valueOf(java.lang.String s)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Float valueOf(float f) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static float parseFloat(java.lang.String s) throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isNaN(float v) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isInfinite(float v) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isFinite(float f) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isNaN() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isInfinite() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public byte byteValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public short shortValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int intValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long longValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public float floatValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public double doubleValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int hashCode(float value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int floatToIntBits(float value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static native int floatToRawIntBits(float value);
+
+ public static native float intBitsToFloat(int bits);
+
+ public int compareTo(java.lang.Float anotherFloat) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int compare(float f1, float f2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static float sum(float a, float b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static float max(float a, float b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static float min(float a, float b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final int BYTES = 4; // 0x4
+
+ public static final int MAX_EXPONENT = 127; // 0x7f
+
+ public static final float MAX_VALUE = 3.4028235E38f;
+
+ public static final int MIN_EXPONENT = -126; // 0xffffff82
+
+ public static final float MIN_NORMAL = 1.17549435E-38f;
+
+ public static final float MIN_VALUE = 1.4E-45f;
+
+ public static final float NEGATIVE_INFINITY = (-1.0f / 0.0f);
+
+ public static final float NaN = (0.0f / 0.0f);
+
+ public static final float POSITIVE_INFINITY = (1.0f / 0.0f);
+
+ public static final int SIZE = 32; // 0x20
+
+ public static final java.lang.Class<java.lang.Float> TYPE;
+
+ static {
+ TYPE = null;
+ }
+
+ private static final long serialVersionUID = -2671257302660747028L; // 0xdaedc9a2db3cf0ecL
+
+ @UnsupportedAppUsage
+ private final float value;
+
+ {
+ value = 0;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/Integer.java b/ojluni/annotations/hiddenapi/java/lang/Integer.java
new file mode 100644
index 0000000..57fa263
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/Integer.java
@@ -0,0 +1,332 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1994, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Integer extends java.lang.Number
+ implements java.lang.Comparable<java.lang.Integer> {
+
+ public Integer(int value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Integer(java.lang.String s) throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(int i, int radix) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toUnsignedString(int i, int radix) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toHexString(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toOctalString(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toBinaryString(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String toUnsignedString0(int val, int shift) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static int formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toUnsignedString(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static void getChars(int i, int index, char[] buf) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static int stringSize(int x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int parseInt(java.lang.String s, int radix)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int parseInt(java.lang.String s) throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int parseUnsignedInt(java.lang.String s, int radix)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int parseUnsignedInt(java.lang.String s) throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Integer valueOf(java.lang.String s, int radix)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Integer valueOf(java.lang.String s)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Integer valueOf(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public byte byteValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public short shortValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int intValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long longValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public float floatValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public double doubleValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int hashCode(int value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Integer getInteger(java.lang.String nm) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Integer getInteger(java.lang.String nm, int val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Integer getInteger(java.lang.String nm, java.lang.Integer val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Integer decode(java.lang.String nm)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compareTo(java.lang.Integer anotherInteger) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int compare(int x, int y) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int compareUnsigned(int x, int y) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long toUnsignedLong(int x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int divideUnsigned(int dividend, int divisor) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int remainderUnsigned(int dividend, int divisor) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int highestOneBit(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int lowestOneBit(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int numberOfLeadingZeros(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int numberOfTrailingZeros(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int bitCount(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int rotateLeft(int i, int distance) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int rotateRight(int i, int distance) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int reverse(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int signum(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int reverseBytes(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int sum(int a, int b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int max(int a, int b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int min(int a, int b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final int BYTES = 4; // 0x4
+
+ static final char[] DigitOnes;
+
+ static {
+ DigitOnes = new char[0];
+ }
+
+ static final char[] DigitTens;
+
+ static {
+ DigitTens = new char[0];
+ }
+
+ public static final int MAX_VALUE = 2147483647; // 0x7fffffff
+
+ public static final int MIN_VALUE = -2147483648; // 0x80000000
+
+ public static final int SIZE = 32; // 0x20
+
+ private static final java.lang.String[] SMALL_NEG_VALUES;
+
+ static {
+ SMALL_NEG_VALUES = new java.lang.String[0];
+ }
+
+ private static final java.lang.String[] SMALL_NONNEG_VALUES;
+
+ static {
+ SMALL_NONNEG_VALUES = new java.lang.String[0];
+ }
+
+ public static final java.lang.Class<java.lang.Integer> TYPE;
+
+ static {
+ TYPE = null;
+ }
+
+ static final char[] digits;
+
+ static {
+ digits = new char[0];
+ }
+
+ private static final long serialVersionUID = 1360826667806852920L; // 0x12e2a0a4f7818738L
+
+ static final int[] sizeTable;
+
+ static {
+ sizeTable = new int[0];
+ }
+
+ @UnsupportedAppUsage
+ private final int value;
+
+ {
+ value = 0;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class IntegerCache {
+
+ private IntegerCache() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.lang.Integer[] cache;
+
+ static {
+ cache = new java.lang.Integer[0];
+ }
+
+ static final int high;
+
+ static {
+ high = 0;
+ }
+
+ static final int low = -128; // 0xffffff80
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/Long.java b/ojluni/annotations/hiddenapi/java/lang/Long.java
new file mode 100644
index 0000000..1190aa1
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/Long.java
@@ -0,0 +1,288 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1994, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Long extends java.lang.Number implements java.lang.Comparable<java.lang.Long> {
+
+ public Long(long value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Long(java.lang.String s) throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(long i, int radix) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toUnsignedString(long i, int radix) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.math.BigInteger toUnsignedBigInteger(long i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toHexString(long i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toOctalString(long i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toBinaryString(long i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.lang.String toUnsignedString0(long val, int shift) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static int formatUnsignedLong(long val, int shift, char[] buf, int offset, int len) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(long i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toUnsignedString(long i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static void getChars(long i, int index, char[] buf) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static int stringSize(long x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long parseLong(java.lang.String s, int radix)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long parseLong(java.lang.String s) throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long parseUnsignedLong(java.lang.String s, int radix)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long parseUnsignedLong(java.lang.String s)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Long valueOf(java.lang.String s, int radix)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Long valueOf(java.lang.String s)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Long valueOf(long l) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Long decode(java.lang.String nm)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public byte byteValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public short shortValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int intValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long longValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public float floatValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public double doubleValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int hashCode(long value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Long getLong(java.lang.String nm) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Long getLong(java.lang.String nm, long val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Long getLong(java.lang.String nm, java.lang.Long val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compareTo(java.lang.Long anotherLong) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int compare(long x, long y) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int compareUnsigned(long x, long y) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long divideUnsigned(long dividend, long divisor) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long remainderUnsigned(long dividend, long divisor) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long highestOneBit(long i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long lowestOneBit(long i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int numberOfLeadingZeros(long i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int numberOfTrailingZeros(long i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int bitCount(long i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long rotateLeft(long i, int distance) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long rotateRight(long i, int distance) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long reverse(long i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int signum(long i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long reverseBytes(long i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long sum(long a, long b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long max(long a, long b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long min(long a, long b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final int BYTES = 8; // 0x8
+
+ public static final long MAX_VALUE = 9223372036854775807L; // 0x7fffffffffffffffL
+
+ public static final long MIN_VALUE = -9223372036854775808L; // 0x8000000000000000L
+
+ public static final int SIZE = 64; // 0x40
+
+ public static final java.lang.Class<java.lang.Long> TYPE;
+
+ static {
+ TYPE = null;
+ }
+
+ private static final long serialVersionUID = 4290774380558885855L; // 0x3b8be490cc8f23dfL
+
+ @UnsupportedAppUsage
+ private final long value;
+
+ {
+ value = 0;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class LongCache {
+
+ private LongCache() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.lang.Long[] cache;
+
+ static {
+ cache = new java.lang.Long[0];
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/Object.java b/ojluni/annotations/hiddenapi/java/lang/Object.java
new file mode 100644
index 0000000..5289874
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/Object.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1994, 2012, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Object {
+
+ public Object() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.Class<?> getClass() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ static int identityHashCode(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native int identityHashCodeNative(java.lang.Object obj);
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Object clone() throws java.lang.CloneNotSupportedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.Object internalClone();
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final native void notify();
+
+ public final native void notifyAll();
+
+ public final void wait(long timeout) throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final native void wait(long timeout, int nanos) throws java.lang.InterruptedException;
+
+ public final void wait() throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void finalize() throws java.lang.Throwable {
+ throw new RuntimeException("Stub!");
+ }
+
+ private transient java.lang.Class<?> shadow$_klass_;
+
+ private transient int shadow$_monitor_;
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/Runtime.java b/ojluni/annotations/hiddenapi/java/lang/Runtime.java
new file mode 100644
index 0000000..c9a364c
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/Runtime.java
@@ -0,0 +1,195 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1995, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Runtime {
+
+ @UnsupportedAppUsage
+ private Runtime() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native void nativeExit(int code);
+
+ public static java.lang.Runtime getRuntime() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void exit(int status) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void addShutdownHook(java.lang.Thread hook) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeShutdownHook(java.lang.Thread hook) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void halt(int status) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public static void runFinalizersOnExit(boolean value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Process exec(java.lang.String command) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Process exec(java.lang.String command, java.lang.String[] envp)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Process exec(
+ java.lang.String command, java.lang.String[] envp, java.io.File dir)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Process exec(java.lang.String[] cmdarray) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Process exec(java.lang.String[] cmdarray, java.lang.String[] envp)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Process exec(
+ java.lang.String[] cmdarray, java.lang.String[] envp, java.io.File dir)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int availableProcessors() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public native long freeMemory();
+
+ public native long totalMemory();
+
+ public native long maxMemory();
+
+ public void gc() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native void nativeGc();
+
+ private static native void runFinalization0();
+
+ public void runFinalization() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void traceInstructions(boolean on) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void traceMethodCalls(boolean on) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void load(java.lang.String filename) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkTargetSdkVersionForLoad(java.lang.String methodName) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ void load(java.lang.String absolutePath, java.lang.ClassLoader loader) {
+ throw new RuntimeException("Stub!");
+ }
+
+ synchronized void load0(java.lang.Class<?> fromClass, java.lang.String filename) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void loadLibrary(java.lang.String libname) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void loadLibrary0(java.lang.Class<?> fromClass, java.lang.String libname) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public void loadLibrary(java.lang.String libname, java.lang.ClassLoader classLoader) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ synchronized void loadLibrary0(java.lang.ClassLoader loader, java.lang.String libname) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String[] getLibPaths() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String[] initLibPaths() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static native java.lang.String nativeLoad(
+ java.lang.String filename, java.lang.ClassLoader loader);
+
+ @Deprecated
+ public java.io.InputStream getLocalizedInputStream(java.io.InputStream in) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public java.io.OutputStream getLocalizedOutputStream(java.io.OutputStream out) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.Runtime currentRuntime;
+
+ private static boolean finalizeOnExit;
+
+ @UnsupportedAppUsage
+ private volatile java.lang.String[] mLibPaths;
+
+ private java.util.List<java.lang.Thread> shutdownHooks;
+
+ private boolean shuttingDown;
+
+ private boolean tracingMethods;
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/Short.java b/ojluni/annotations/hiddenapi/java/lang/Short.java
new file mode 100644
index 0000000..d465122
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/Short.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 1996, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Short extends java.lang.Number implements java.lang.Comparable<java.lang.Short> {
+
+ public Short(short value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Short(java.lang.String s) throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(short s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static short parseShort(java.lang.String s, int radix)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static short parseShort(java.lang.String s) throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Short valueOf(java.lang.String s, int radix)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Short valueOf(java.lang.String s)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Short valueOf(short s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Short decode(java.lang.String nm)
+ throws java.lang.NumberFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public byte byteValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public short shortValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int intValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long longValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public float floatValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public double doubleValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int hashCode(short value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compareTo(java.lang.Short anotherShort) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int compare(short x, short y) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static short reverseBytes(short i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int toUnsignedInt(short x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long toUnsignedLong(short x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final int BYTES = 2; // 0x2
+
+ public static final short MAX_VALUE = 32767; // 0x7fff
+
+ public static final short MIN_VALUE = -32768; // 0xffff8000
+
+ public static final int SIZE = 16; // 0x10
+
+ public static final java.lang.Class<java.lang.Short> TYPE;
+
+ static {
+ TYPE = null;
+ }
+
+ private static final long serialVersionUID = 7515723908773894738L; // 0x684d37133460da52L
+
+ @UnsupportedAppUsage
+ private final short value;
+
+ {
+ value = 0;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class ShortCache {
+
+ private ShortCache() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.lang.Short[] cache;
+
+ static {
+ cache = new java.lang.Short[0];
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/StackTraceElement.java b/ojluni/annotations/hiddenapi/java/lang/StackTraceElement.java
new file mode 100644
index 0000000..a396013
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/StackTraceElement.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2000, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class StackTraceElement implements java.io.Serializable {
+
+ public StackTraceElement(
+ java.lang.String declaringClass,
+ java.lang.String methodName,
+ java.lang.String fileName,
+ int lineNumber) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getFileName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getLineNumber() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getClassName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getMethodName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isNativeMethod() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private java.lang.String declaringClass;
+
+ @UnsupportedAppUsage
+ private java.lang.String fileName;
+
+ @UnsupportedAppUsage
+ private int lineNumber;
+
+ @UnsupportedAppUsage
+ private java.lang.String methodName;
+
+ private static final long serialVersionUID = 6992337162326171013L; // 0x6109c59a2636dd85L
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/String.java b/ojluni/annotations/hiddenapi/java/lang/String.java
new file mode 100644
index 0000000..51fdfb7
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/String.java
@@ -0,0 +1,489 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1994, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class String
+ implements java.io.Serializable,
+ java.lang.Comparable<java.lang.String>,
+ java.lang.CharSequence {
+
+ public String() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public String(java.lang.String original) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public String(char[] value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public String(char[] value, int offset, int count) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public String(int[] codePoints, int offset, int count) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public String(byte[] ascii, int hibyte, int offset, int count) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public String(byte[] ascii, int hibyte) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public String(byte[] bytes, int offset, int length, java.lang.String charsetName)
+ throws java.io.UnsupportedEncodingException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public String(byte[] bytes, int offset, int length, java.nio.charset.Charset charset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public String(byte[] bytes, java.lang.String charsetName)
+ throws java.io.UnsupportedEncodingException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public String(byte[] bytes, java.nio.charset.Charset charset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public String(byte[] bytes, int offset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public String(byte[] bytes) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public String(java.lang.StringBuffer buffer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public String(java.lang.StringBuilder builder) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ @UnsupportedAppUsage
+ String(int offset, int count, char[] value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int length() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public native char charAt(int index);
+
+ public int codePointAt(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int codePointBefore(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int codePointCount(int beginIndex, int endIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int offsetByCodePoints(int index, int codePointOffset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void getChars(char[] dst, int dstBegin) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ native void getCharsNoCheck(int start, int end, char[] buffer, int index);
+
+ @Deprecated
+ public void getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public byte[] getBytes(java.lang.String charsetName)
+ throws java.io.UnsupportedEncodingException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public byte[] getBytes(java.nio.charset.Charset charset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public byte[] getBytes() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object anObject) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contentEquals(java.lang.StringBuffer sb) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean nonSyncContentEquals(java.lang.AbstractStringBuilder sb) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contentEquals(java.lang.CharSequence cs) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equalsIgnoreCase(java.lang.String anotherString) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public native int compareTo(java.lang.String anotherString);
+
+ public int compareToIgnoreCase(java.lang.String str) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean regionMatches(int toffset, java.lang.String other, int ooffset, int len) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean regionMatches(
+ boolean ignoreCase, int toffset, java.lang.String other, int ooffset, int len) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean startsWith(java.lang.String prefix, int toffset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean startsWith(java.lang.String prefix) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean endsWith(java.lang.String suffix) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int indexOf(int ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int indexOf(int ch, int fromIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int indexOfSupplementary(int ch, int fromIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int lastIndexOf(int ch) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int lastIndexOf(int ch, int fromIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int lastIndexOfSupplementary(int ch, int fromIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int indexOf(java.lang.String str) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int indexOf(java.lang.String str, int fromIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int indexOf(java.lang.String source, java.lang.String target, int fromIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static int indexOf(
+ char[] source,
+ int sourceOffset,
+ int sourceCount,
+ java.lang.String target,
+ int fromIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ static int indexOf(
+ char[] source,
+ int sourceOffset,
+ int sourceCount,
+ char[] target,
+ int targetOffset,
+ int targetCount,
+ int fromIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int lastIndexOf(java.lang.String str) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int lastIndexOf(java.lang.String str, int fromIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int lastIndexOf(
+ java.lang.String source, java.lang.String target, int fromIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static int lastIndexOf(
+ char[] source,
+ int sourceOffset,
+ int sourceCount,
+ java.lang.String target,
+ int fromIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ static int lastIndexOf(
+ char[] source,
+ int sourceOffset,
+ int sourceCount,
+ char[] target,
+ int targetOffset,
+ int targetCount,
+ int fromIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String substring(int beginIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String substring(int beginIndex, int endIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.String fastSubstring(int start, int length);
+
+ public java.lang.CharSequence subSequence(int beginIndex, int endIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public native java.lang.String concat(java.lang.String str);
+
+ public java.lang.String replace(char oldChar, char newChar) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.String doReplace(char oldChar, char newChar);
+
+ public boolean matches(java.lang.String regex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.CharSequence s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String replaceFirst(java.lang.String regex, java.lang.String replacement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String replaceAll(java.lang.String regex, java.lang.String replacement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String replace(
+ java.lang.CharSequence target, java.lang.CharSequence replacement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String[] split(java.lang.String regex, int limit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String[] split(java.lang.String regex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String join(
+ java.lang.CharSequence delimiter, java.lang.CharSequence... elements) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String join(
+ java.lang.CharSequence delimiter,
+ java.lang.Iterable<? extends java.lang.CharSequence> elements) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toLowerCase(java.util.Locale locale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toLowerCase() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toUpperCase(java.util.Locale locale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toUpperCase() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String trim() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public native char[] toCharArray();
+
+ public static java.lang.String format(java.lang.String format, java.lang.Object... args) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String format(
+ java.util.Locale l, java.lang.String format, java.lang.Object... args) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String valueOf(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String valueOf(char[] data) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String valueOf(char[] data, int offset, int count) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String copyValueOf(char[] data, int offset, int count) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String copyValueOf(char[] data) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String valueOf(boolean b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String valueOf(char c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String valueOf(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String valueOf(long l) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String valueOf(float f) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String valueOf(double d) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public native java.lang.String intern();
+
+ public static final java.util.Comparator<java.lang.String> CASE_INSENSITIVE_ORDER;
+
+ static {
+ CASE_INSENSITIVE_ORDER = null;
+ }
+
+ @UnsupportedAppUsage
+ private final int count;
+
+ {
+ count = 0;
+ }
+
+ @UnsupportedAppUsage
+ private int hash;
+
+ private static final java.io.ObjectStreamField[] serialPersistentFields;
+
+ static {
+ serialPersistentFields = new java.io.ObjectStreamField[0];
+ }
+
+ private static final long serialVersionUID = -6849794470754667710L; // 0xa0f0a4387a3bb342L
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class CaseInsensitiveComparator
+ implements java.util.Comparator<java.lang.String>, java.io.Serializable {
+
+ private CaseInsensitiveComparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compare(java.lang.String s1, java.lang.String s2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readResolve() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = 8575799808933029326L; // 0x77035c7d5c50e5ceL
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/System.java b/ojluni/annotations/hiddenapi/java/lang/System.java
new file mode 100644
index 0000000..a401efd
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/System.java
@@ -0,0 +1,344 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1994, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class System {
+
+ @UnsupportedAppUsage
+ private System() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void setIn(java.io.InputStream in) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void setOut(java.io.PrintStream out) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void setErr(java.io.PrintStream err) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.io.Console console() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.nio.channels.Channel inheritedChannel() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native void setIn0(java.io.InputStream in);
+
+ private static native void setOut0(java.io.PrintStream out);
+
+ private static native void setErr0(java.io.PrintStream err);
+
+ public static void setSecurityManager(java.lang.SecurityManager s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.SecurityManager getSecurityManager() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static native long currentTimeMillis();
+
+ public static native long nanoTime();
+
+ public static native void arraycopy(
+ java.lang.Object src, int srcPos, java.lang.Object dest, int destPos, int length);
+
+ @UnsupportedAppUsage
+ private static void arraycopy(char[] src, int srcPos, char[] dst, int dstPos, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native void arraycopyCharUnchecked(
+ char[] src, int srcPos, char[] dst, int dstPos, int length);
+
+ @UnsupportedAppUsage
+ public static void arraycopy(byte[] src, int srcPos, byte[] dst, int dstPos, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native void arraycopyByteUnchecked(
+ byte[] src, int srcPos, byte[] dst, int dstPos, int length);
+
+ @UnsupportedAppUsage
+ private static void arraycopy(short[] src, int srcPos, short[] dst, int dstPos, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native void arraycopyShortUnchecked(
+ short[] src, int srcPos, short[] dst, int dstPos, int length);
+
+ @UnsupportedAppUsage
+ private static void arraycopy(int[] src, int srcPos, int[] dst, int dstPos, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native void arraycopyIntUnchecked(
+ int[] src, int srcPos, int[] dst, int dstPos, int length);
+
+ @UnsupportedAppUsage
+ private static void arraycopy(long[] src, int srcPos, long[] dst, int dstPos, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native void arraycopyLongUnchecked(
+ long[] src, int srcPos, long[] dst, int dstPos, int length);
+
+ @UnsupportedAppUsage
+ private static void arraycopy(float[] src, int srcPos, float[] dst, int dstPos, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native void arraycopyFloatUnchecked(
+ float[] src, int srcPos, float[] dst, int dstPos, int length);
+
+ private static void arraycopy(double[] src, int srcPos, double[] dst, int dstPos, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native void arraycopyDoubleUnchecked(
+ double[] src, int srcPos, double[] dst, int dstPos, int length);
+
+ @UnsupportedAppUsage
+ private static void arraycopy(
+ boolean[] src, int srcPos, boolean[] dst, int dstPos, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native void arraycopyBooleanUnchecked(
+ boolean[] src, int srcPos, boolean[] dst, int dstPos, int length);
+
+ public static int identityHashCode(java.lang.Object x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native java.lang.String[] specialProperties();
+
+ private static void parsePropertyAssignments(
+ java.util.Properties p, java.lang.String[] assignments) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.util.Properties initUnchangeableSystemProperties() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.util.Properties initProperties() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.util.Properties setDefaultChangeableProperties(java.util.Properties p) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void setUnchangeableSystemProperty(java.lang.String key, java.lang.String value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void addLegacyLocaleSystemProperties() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Properties getProperties() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String lineSeparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void setProperties(java.util.Properties props) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String getProperty(java.lang.String key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String getProperty(java.lang.String key, java.lang.String def) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String setProperty(java.lang.String key, java.lang.String value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String clearProperty(java.lang.String key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void checkKey(java.lang.String key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String getenv(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Map<java.lang.String, java.lang.String> getenv() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void exit(int status) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void gc() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void runFinalization() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public static void runFinalizersOnExit(boolean value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void load(java.lang.String filename) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void loadLibrary(java.lang.String libname) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static native java.lang.String mapLibraryName(java.lang.String libname);
+
+ private static java.io.PrintStream newPrintStream(
+ java.io.FileOutputStream fos, java.lang.String enc) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public static void logE(java.lang.String message) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public static void logE(java.lang.String message, java.lang.Throwable th) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void logI(java.lang.String message) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void logI(java.lang.String message, java.lang.Throwable th) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void logW(java.lang.String message) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public static void logW(java.lang.String message, java.lang.Throwable th) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static native void log(char type, java.lang.String message, java.lang.Throwable th);
+
+ private static final int ARRAYCOPY_SHORT_BOOLEAN_ARRAY_THRESHOLD = 32; // 0x20
+
+ private static final int ARRAYCOPY_SHORT_BYTE_ARRAY_THRESHOLD = 32; // 0x20
+
+ private static final int ARRAYCOPY_SHORT_CHAR_ARRAY_THRESHOLD = 32; // 0x20
+
+ private static final int ARRAYCOPY_SHORT_DOUBLE_ARRAY_THRESHOLD = 32; // 0x20
+
+ private static final int ARRAYCOPY_SHORT_FLOAT_ARRAY_THRESHOLD = 32; // 0x20
+
+ private static final int ARRAYCOPY_SHORT_INT_ARRAY_THRESHOLD = 32; // 0x20
+
+ private static final int ARRAYCOPY_SHORT_LONG_ARRAY_THRESHOLD = 32; // 0x20
+
+ private static final int ARRAYCOPY_SHORT_SHORT_ARRAY_THRESHOLD = 32; // 0x20
+
+ private static final java.lang.Object LOCK;
+
+ static {
+ LOCK = null;
+ }
+
+ private static volatile java.io.Console cons;
+
+ public static final java.io.PrintStream err;
+
+ static {
+ err = null;
+ }
+
+ public static final java.io.InputStream in;
+
+ static {
+ in = null;
+ }
+
+ private static boolean justRanFinalization;
+
+ private static java.lang.String lineSeparator;
+
+ public static final java.io.PrintStream out;
+
+ static {
+ out = null;
+ }
+
+ private static java.util.Properties props;
+
+ private static boolean runGC;
+
+ private static java.util.Properties unchangeableProps;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class PropertiesWithNonOverrideableDefaults extends java.util.Properties {
+
+ PropertiesWithNonOverrideableDefaults(java.util.Properties defaults) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object put(java.lang.Object key, java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object remove(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/Thread.java b/ojluni/annotations/hiddenapi/java/lang/Thread.java
new file mode 100644
index 0000000..aade593
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/Thread.java
@@ -0,0 +1,525 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1994, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Thread implements java.lang.Runnable {
+
+ public Thread() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Thread(java.lang.Runnable target) {
+ throw new RuntimeException("Stub!");
+ }
+
+ Thread(java.lang.Runnable target, java.security.AccessControlContext acc) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Thread(java.lang.ThreadGroup group, java.lang.Runnable target) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Thread(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Thread(java.lang.ThreadGroup group, java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ Thread(java.lang.ThreadGroup group, java.lang.String name, int priority, boolean daemon) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Thread(java.lang.Runnable target, java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Thread(java.lang.ThreadGroup group, java.lang.Runnable target, java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Thread(
+ java.lang.ThreadGroup group,
+ java.lang.Runnable target,
+ java.lang.String name,
+ long stackSize) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static synchronized int nextThreadNum() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static synchronized long nextThreadID() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void blockedOn(sun.nio.ch.Interruptible b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static native java.lang.Thread currentThread();
+
+ public static native void yield();
+
+ public static void sleep(long millis) throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native void sleep(java.lang.Object lock, long millis, int nanos)
+ throws java.lang.InterruptedException;
+
+ public static void sleep(long millis, int nanos) throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void init(
+ java.lang.ThreadGroup g,
+ java.lang.Runnable target,
+ java.lang.String name,
+ long stackSize) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void init(
+ java.lang.ThreadGroup g,
+ java.lang.Runnable target,
+ java.lang.String name,
+ long stackSize,
+ java.security.AccessControlContext acc) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Object clone() throws java.lang.CloneNotSupportedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void init2(java.lang.Thread parent) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void start() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native void nativeCreate(java.lang.Thread t, long stackSize, boolean daemon);
+
+ public void run() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void exit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public final void stop() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public final synchronized void stop(java.lang.Throwable obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void interrupt() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static native boolean interrupted();
+
+ public native boolean isInterrupted();
+
+ @Deprecated
+ public void destroy() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean isAlive() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public final void suspend() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public final void resume() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void setPriority(int newPriority) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int getPriority() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final synchronized void setName(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String getName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.ThreadGroup getThreadGroup() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int activeCount() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int enumerate(java.lang.Thread[] tarray) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public int countStackFrames() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void join(long millis) throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void join(long millis, int nanos) throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void join() throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void dumpStack() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void setDaemon(boolean on) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean isDaemon() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void checkAccess() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.ClassLoader getContextClassLoader() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setContextClassLoader(java.lang.ClassLoader cl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static native boolean holdsLock(java.lang.Object obj);
+
+ public java.lang.StackTraceElement[] getStackTrace() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Map<java.lang.Thread, java.lang.StackTraceElement[]>
+ getAllStackTraces() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean isCCLOverridden(java.lang.Class<?> cl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean auditSubclass(java.lang.Class<?> subcl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getId() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Thread.State getState() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void setDefaultUncaughtExceptionHandler(
+ java.lang.Thread.UncaughtExceptionHandler eh) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void setUncaughtExceptionPreHandler(
+ java.lang.Thread.UncaughtExceptionHandler eh) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public static java.lang.Thread.UncaughtExceptionHandler getUncaughtExceptionPreHandler() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Thread.UncaughtExceptionHandler getUncaughtExceptionHandler() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setUncaughtExceptionHandler(java.lang.Thread.UncaughtExceptionHandler eh) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public final void dispatchUncaughtException(java.lang.Throwable e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static void processQueue(
+ java.lang.ref.ReferenceQueue<java.lang.Class<?>> queue,
+ java.util.concurrent.ConcurrentMap<
+ ? extends java.lang.ref.WeakReference<java.lang.Class<?>>, ?>
+ map) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native void setPriority0(int newPriority);
+
+ private native void interrupt0();
+
+ private native void setNativeName(java.lang.String name);
+
+ private native int nativeGetStatus(boolean hasBeenStarted);
+
+ public final void unpark$() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void parkFor$(long nanos) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void parkUntil$(long time) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.lang.StackTraceElement[] EMPTY_STACK_TRACE;
+
+ static {
+ EMPTY_STACK_TRACE = new java.lang.StackTraceElement[0];
+ }
+
+ public static final int MAX_PRIORITY = 10; // 0xa
+
+ public static final int MIN_PRIORITY = 1; // 0x1
+
+ private static final int NANOS_PER_MILLI = 1000000; // 0xf4240
+
+ public static final int NORM_PRIORITY = 5; // 0x5
+
+ private static final java.lang.RuntimePermission SUBCLASS_IMPLEMENTATION_PERMISSION;
+
+ static {
+ SUBCLASS_IMPLEMENTATION_PERMISSION = null;
+ }
+
+ private volatile sun.nio.ch.Interruptible blocker;
+
+ private final java.lang.Object blockerLock;
+
+ {
+ blockerLock = null;
+ }
+
+ @UnsupportedAppUsage
+ private java.lang.ClassLoader contextClassLoader;
+
+ @UnsupportedAppUsage
+ private boolean daemon = false;
+
+ private static volatile java.lang.Thread.UncaughtExceptionHandler
+ defaultUncaughtExceptionHandler;
+
+ private long eetop;
+
+ @UnsupportedAppUsage
+ private java.lang.ThreadGroup group;
+
+ @UnsupportedAppUsage
+ java.lang.ThreadLocal.ThreadLocalMap inheritableThreadLocals;
+
+ @UnsupportedAppUsage
+ private java.security.AccessControlContext inheritedAccessControlContext;
+
+ @UnsupportedAppUsage
+ private final java.lang.Object lock;
+
+ {
+ lock = null;
+ }
+
+ @UnsupportedAppUsage
+ private volatile java.lang.String name;
+
+ private long nativeParkEventPointer;
+
+ @UnsupportedAppUsage
+ private volatile long nativePeer;
+
+ @UnsupportedAppUsage
+ volatile java.lang.Object parkBlocker;
+
+ private int parkState = 1; // 0x1
+
+ @UnsupportedAppUsage
+ private int priority;
+
+ private boolean single_step;
+
+ private long stackSize;
+
+ boolean started = false;
+
+ private boolean stillborn = false;
+
+ @UnsupportedAppUsage
+ private java.lang.Runnable target;
+
+ private static int threadInitNumber;
+
+ int threadLocalRandomProbe;
+
+ int threadLocalRandomSecondarySeed;
+
+ long threadLocalRandomSeed;
+
+ @UnsupportedAppUsage
+ java.lang.ThreadLocal.ThreadLocalMap threadLocals;
+
+ private java.lang.Thread threadQ;
+
+ @UnsupportedAppUsage
+ private static long threadSeqNumber;
+
+ private long tid;
+
+ private volatile java.lang.Thread.UncaughtExceptionHandler uncaughtExceptionHandler;
+
+ private static volatile java.lang.Thread.UncaughtExceptionHandler uncaughtExceptionPreHandler;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class Caches {
+
+ private Caches() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.util.concurrent.ConcurrentMap<
+ java.lang.Thread.WeakClassKey, java.lang.Boolean>
+ subclassAudits;
+
+ static {
+ subclassAudits = null;
+ }
+
+ static final java.lang.ref.ReferenceQueue<java.lang.Class<?>> subclassAuditsQueue;
+
+ static {
+ subclassAuditsQueue = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class ParkState {
+
+ private ParkState() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int PARKED = 3; // 0x3
+
+ private static final int PREEMPTIVELY_UNPARKED = 2; // 0x2
+
+ private static final int UNPARKED = 1; // 0x1
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static enum State {
+ NEW,
+ RUNNABLE,
+ BLOCKED,
+ WAITING,
+ TIMED_WAITING,
+ TERMINATED;
+
+ private State() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static interface UncaughtExceptionHandler {
+
+ public void uncaughtException(java.lang.Thread t, java.lang.Throwable e);
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class WeakClassKey extends java.lang.ref.WeakReference<java.lang.Class<?>> {
+
+ WeakClassKey(
+ java.lang.Class<?> cl, java.lang.ref.ReferenceQueue<java.lang.Class<?>> refQueue) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final int hash;
+
+ {
+ hash = 0;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/ThreadGroup.java b/ojluni/annotations/hiddenapi/java/lang/ThreadGroup.java
new file mode 100644
index 0000000..ee9feb0
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/ThreadGroup.java
@@ -0,0 +1,244 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1995, 2012, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ThreadGroup implements java.lang.Thread.UncaughtExceptionHandler {
+
+ private ThreadGroup() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ThreadGroup(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ThreadGroup(java.lang.ThreadGroup parent, java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private ThreadGroup(
+ java.lang.Void unused, java.lang.ThreadGroup parent, java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.Void checkParentAccess(java.lang.ThreadGroup parent) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String getName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.ThreadGroup getParent() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int getMaxPriority() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean isDaemon() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized boolean isDestroyed() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void setDaemon(boolean daemon) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void setMaxPriority(int pri) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean parentOf(java.lang.ThreadGroup g) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void checkAccess() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int activeCount() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int enumerate(java.lang.Thread[] list) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int enumerate(java.lang.Thread[] list, boolean recurse) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int enumerate(java.lang.Thread[] list, int n, boolean recurse) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int activeGroupCount() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int enumerate(java.lang.ThreadGroup[] list) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int enumerate(java.lang.ThreadGroup[] list, boolean recurse) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int enumerate(java.lang.ThreadGroup[] list, int n, boolean recurse) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public final void stop() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void interrupt() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public final void suspend() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean stopOrSuspend(boolean suspend) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public final void resume() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void destroy() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final void add(java.lang.ThreadGroup g) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void remove(java.lang.ThreadGroup g) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void addUnstarted() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ void add(java.lang.Thread t) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void threadStartFailed(java.lang.Thread t) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ void threadTerminated(java.lang.Thread t) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void remove(java.lang.Thread t) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void list() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void list(java.io.PrintStream out, int indent) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void uncaughtException(java.lang.Thread t, java.lang.Throwable e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public boolean allowThreadSuspension(boolean b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean daemon;
+
+ boolean destroyed;
+
+ @UnsupportedAppUsage
+ java.lang.ThreadGroup[] groups;
+
+ @UnsupportedAppUsage
+ static final java.lang.ThreadGroup mainThreadGroup;
+
+ static {
+ mainThreadGroup = null;
+ }
+
+ int maxPriority;
+
+ int nUnstartedThreads = 0; // 0x0
+
+ @UnsupportedAppUsage
+ java.lang.String name;
+
+ @UnsupportedAppUsage
+ int ngroups;
+
+ int nthreads;
+
+ @UnsupportedAppUsage
+ private final java.lang.ThreadGroup parent;
+
+ {
+ parent = null;
+ }
+
+ @UnsupportedAppUsage
+ static final java.lang.ThreadGroup systemThreadGroup;
+
+ static {
+ systemThreadGroup = null;
+ }
+
+ java.lang.Thread[] threads;
+
+ boolean vmAllowSuspension;
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/ThreadLocal.java b/ojluni/annotations/hiddenapi/java/lang/ThreadLocal.java
new file mode 100644
index 0000000..5772a6d
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/ThreadLocal.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) 1997, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ThreadLocal<T> {
+
+ public ThreadLocal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int nextHashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected T initialValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <S> java.lang.ThreadLocal<S> withInitial(
+ java.util.function.Supplier<? extends S> supplier) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public T get() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private T setInitialValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void set(T value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ java.lang.ThreadLocal.ThreadLocalMap getMap(java.lang.Thread t) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void createMap(java.lang.Thread t, T firstValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.lang.ThreadLocal.ThreadLocalMap createInheritedMap(
+ java.lang.ThreadLocal.ThreadLocalMap parentMap) {
+ throw new RuntimeException("Stub!");
+ }
+
+ T childValue(T parentValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int HASH_INCREMENT = 1640531527; // 0x61c88647
+
+ private static java.util.concurrent.atomic.AtomicInteger nextHashCode;
+
+ private final int threadLocalHashCode;
+
+ {
+ threadLocalHashCode = 0;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class SuppliedThreadLocal<T> extends java.lang.ThreadLocal<T> {
+
+ SuppliedThreadLocal(java.util.function.Supplier<? extends T> supplier) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected T initialValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.function.Supplier<? extends T> supplier;
+
+ {
+ supplier = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class ThreadLocalMap {
+
+ ThreadLocalMap(java.lang.ThreadLocal<?> firstKey, java.lang.Object firstValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private ThreadLocalMap(java.lang.ThreadLocal.ThreadLocalMap parentMap) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void setThreshold(int len) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int nextIndex(int i, int len) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int prevIndex(int i, int len) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.ThreadLocal.ThreadLocalMap.Entry getEntry(java.lang.ThreadLocal<?> key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.ThreadLocal.ThreadLocalMap.Entry getEntryAfterMiss(
+ java.lang.ThreadLocal<?> key, int i, java.lang.ThreadLocal.ThreadLocalMap.Entry e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void set(java.lang.ThreadLocal<?> key, java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void remove(java.lang.ThreadLocal<?> key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void replaceStaleEntry(
+ java.lang.ThreadLocal<?> key, java.lang.Object value, int staleSlot) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int expungeStaleEntry(int staleSlot) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean cleanSomeSlots(int i, int n) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void rehash() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void resize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void expungeStaleEntries() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int INITIAL_CAPACITY = 16; // 0x10
+
+ private int size = 0; // 0x0
+
+ private java.lang.ThreadLocal.ThreadLocalMap.Entry[] table;
+
+ private int threshold;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class Entry extends java.lang.ref.WeakReference<java.lang.ThreadLocal<?>> {
+
+ Entry(java.lang.ThreadLocal<?> k, java.lang.Object v) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.Object value;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/Throwable.java b/ojluni/annotations/hiddenapi/java/lang/Throwable.java
new file mode 100644
index 0000000..0bc7d12
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/Throwable.java
@@ -0,0 +1,247 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1994, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Throwable implements java.io.Serializable {
+
+ public Throwable() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Throwable(java.lang.String message) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Throwable(java.lang.String message, java.lang.Throwable cause) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Throwable(java.lang.Throwable cause) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected Throwable(
+ java.lang.String message,
+ java.lang.Throwable cause,
+ boolean enableSuppression,
+ boolean writableStackTrace) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getMessage() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getLocalizedMessage() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized java.lang.Throwable getCause() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized java.lang.Throwable initCause(java.lang.Throwable cause) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void printStackTrace() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void printStackTrace(java.io.PrintStream s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private void printStackTrace(java.lang.Throwable.PrintStreamOrWriter s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void printEnclosedStackTrace(
+ java.lang.Throwable.PrintStreamOrWriter s,
+ java.lang.StackTraceElement[] enclosingTrace,
+ java.lang.String caption,
+ java.lang.String prefix,
+ java.util.Set<java.lang.Throwable> dejaVu) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void printStackTrace(java.io.PrintWriter s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized java.lang.Throwable fillInStackTrace() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static native java.lang.Object nativeFillInStackTrace();
+
+ public java.lang.StackTraceElement[] getStackTrace() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private synchronized java.lang.StackTraceElement[] getOurStackTrace() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setStackTrace(java.lang.StackTraceElement[] stackTrace) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native java.lang.StackTraceElement[] nativeGetStackTrace(
+ java.lang.Object stackState);
+
+ private void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final synchronized void addSuppressed(java.lang.Throwable exception) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final synchronized java.lang.Throwable[] getSuppressed() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.lang.String CAUSE_CAPTION = "Caused by: ";
+
+ private static java.lang.Throwable[] EMPTY_THROWABLE_ARRAY;
+
+ private static final java.lang.String NULL_CAUSE_MESSAGE = "Cannot suppress a null exception.";
+
+ private static final java.lang.String SELF_SUPPRESSION_MESSAGE =
+ "Self-suppression not permitted";
+
+ private static final java.lang.String SUPPRESSED_CAPTION = "Suppressed: ";
+
+ @UnsupportedAppUsage
+ private transient volatile java.lang.Object backtrace;
+
+ @UnsupportedAppUsage
+ private java.lang.Throwable cause;
+
+ @UnsupportedAppUsage
+ private java.lang.String detailMessage;
+
+ private static final long serialVersionUID = -3042686055658047285L; // 0xd5c635273977b8cbL
+
+ @UnsupportedAppUsage
+ private java.lang.StackTraceElement[] stackTrace;
+
+ @UnsupportedAppUsage
+ private java.util.List<java.lang.Throwable> suppressedExceptions;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private abstract static class PrintStreamOrWriter {
+
+ private PrintStreamOrWriter() {
+ throw new RuntimeException("Stub!");
+ }
+
+ abstract java.lang.Object lock();
+
+ abstract void println(java.lang.Object o);
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class SentinelHolder {
+
+ private SentinelHolder() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.lang.StackTraceElement STACK_TRACE_ELEMENT_SENTINEL;
+
+ static {
+ STACK_TRACE_ELEMENT_SENTINEL = null;
+ }
+
+ public static final java.lang.StackTraceElement[] STACK_TRACE_SENTINEL;
+
+ static {
+ STACK_TRACE_SENTINEL = new java.lang.StackTraceElement[0];
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class WrappedPrintStream extends java.lang.Throwable.PrintStreamOrWriter {
+
+ WrappedPrintStream(java.io.PrintStream printStream) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.Object lock() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void println(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.io.PrintStream printStream;
+
+ {
+ printStream = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class WrappedPrintWriter extends java.lang.Throwable.PrintStreamOrWriter {
+
+ WrappedPrintWriter(java.io.PrintWriter printWriter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.Object lock() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void println(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.io.PrintWriter printWriter;
+
+ {
+ printWriter = null;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/Void.java b/ojluni/annotations/hiddenapi/java/lang/Void.java
new file mode 100644
index 0000000..e082300
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/Void.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 1996, 2011, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Void {
+
+ @UnsupportedAppUsage
+ private Void() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.lang.Class<java.lang.Void> TYPE;
+
+ static {
+ TYPE = null;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/invoke/MethodHandles.java b/ojluni/annotations/hiddenapi/java/lang/invoke/MethodHandles.java
new file mode 100644
index 0000000..dcb5f11
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/invoke/MethodHandles.java
@@ -0,0 +1,640 @@
+/*
+ * Copyright (c) 2008, 2017, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang.invoke;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class MethodHandles {
+
+ private MethodHandles() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandles.Lookup lookup() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandles.Lookup publicLookup() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T extends java.lang.reflect.Member> T reflectAs(
+ java.lang.Class<T> expected, java.lang.invoke.MethodHandle target) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.invoke.MethodHandleImpl getMethodHandleImpl(
+ java.lang.invoke.MethodHandle target) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void checkClassIsArray(java.lang.Class<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void checkTypeIsViewable(java.lang.Class<?> componentType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle arrayElementGetter(java.lang.Class<?> arrayClass)
+ throws java.lang.IllegalArgumentException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static byte arrayElementGetter(byte[] array, int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean arrayElementGetter(boolean[] array, int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static char arrayElementGetter(char[] array, int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static short arrayElementGetter(short[] array, int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int arrayElementGetter(int[] array, int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long arrayElementGetter(long[] array, int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static float arrayElementGetter(float[] array, int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static double arrayElementGetter(double[] array, int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle arrayElementSetter(java.lang.Class<?> arrayClass)
+ throws java.lang.IllegalArgumentException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void arrayElementSetter(byte[] array, int i, byte val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void arrayElementSetter(boolean[] array, int i, boolean val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void arrayElementSetter(char[] array, int i, char val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void arrayElementSetter(short[] array, int i, short val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void arrayElementSetter(int[] array, int i, int val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void arrayElementSetter(long[] array, int i, long val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void arrayElementSetter(float[] array, int i, float val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void arrayElementSetter(double[] array, int i, double val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.VarHandle arrayElementVarHandle(java.lang.Class<?> arrayClass)
+ throws java.lang.IllegalArgumentException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.VarHandle byteArrayViewVarHandle(
+ java.lang.Class<?> viewArrayClass, java.nio.ByteOrder byteOrder)
+ throws java.lang.IllegalArgumentException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.VarHandle byteBufferViewVarHandle(
+ java.lang.Class<?> viewArrayClass, java.nio.ByteOrder byteOrder)
+ throws java.lang.IllegalArgumentException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle spreadInvoker(
+ java.lang.invoke.MethodType type, int leadingArgCount) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle exactInvoker(java.lang.invoke.MethodType type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle invoker(java.lang.invoke.MethodType type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.invoke.MethodHandle methodHandleForVarHandleAccessor(
+ java.lang.invoke.VarHandle.AccessMode accessMode,
+ java.lang.invoke.MethodType type,
+ boolean isExactInvoker) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle varHandleExactInvoker(
+ java.lang.invoke.VarHandle.AccessMode accessMode, java.lang.invoke.MethodType type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle varHandleInvoker(
+ java.lang.invoke.VarHandle.AccessMode accessMode, java.lang.invoke.MethodType type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle explicitCastArguments(
+ java.lang.invoke.MethodHandle target, java.lang.invoke.MethodType newType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void explicitCastArgumentsChecks(
+ java.lang.invoke.MethodHandle target, java.lang.invoke.MethodType newType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle permuteArguments(
+ java.lang.invoke.MethodHandle target,
+ java.lang.invoke.MethodType newType,
+ int... reorder) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean permuteArgumentChecks(
+ int[] reorder,
+ java.lang.invoke.MethodType newType,
+ java.lang.invoke.MethodType oldType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle constant(
+ java.lang.Class<?> type, java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle identity(java.lang.Class<?> type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static byte identity(byte val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean identity(boolean val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static char identity(char val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static short identity(short val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int identity(int val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long identity(long val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static float identity(float val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static double identity(double val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle insertArguments(
+ java.lang.invoke.MethodHandle target, int pos, java.lang.Object... values) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.Class<?>[] insertArgumentsChecks(
+ java.lang.invoke.MethodHandle target, int insCount, int pos)
+ throws java.lang.RuntimeException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle dropArguments(
+ java.lang.invoke.MethodHandle target,
+ int pos,
+ java.util.List<java.lang.Class<?>> valueTypes) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.util.List<java.lang.Class<?>> copyTypes(
+ java.util.List<java.lang.Class<?>> types) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int dropArgumentChecks(
+ java.lang.invoke.MethodType oldType,
+ int pos,
+ java.util.List<java.lang.Class<?>> valueTypes) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle dropArguments(
+ java.lang.invoke.MethodHandle target, int pos, java.lang.Class<?>... valueTypes) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle filterArguments(
+ java.lang.invoke.MethodHandle target,
+ int pos,
+ java.lang.invoke.MethodHandle... filters) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void filterArgumentsCheckArity(
+ java.lang.invoke.MethodHandle target,
+ int pos,
+ java.lang.invoke.MethodHandle[] filters) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void filterArgumentChecks(
+ java.lang.invoke.MethodHandle target, int pos, java.lang.invoke.MethodHandle filter)
+ throws java.lang.RuntimeException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle collectArguments(
+ java.lang.invoke.MethodHandle target, int pos, java.lang.invoke.MethodHandle filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.invoke.MethodType collectArgumentsChecks(
+ java.lang.invoke.MethodHandle target, int pos, java.lang.invoke.MethodHandle filter)
+ throws java.lang.RuntimeException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle filterReturnValue(
+ java.lang.invoke.MethodHandle target, java.lang.invoke.MethodHandle filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void filterReturnValueChecks(
+ java.lang.invoke.MethodType targetType, java.lang.invoke.MethodType filterType)
+ throws java.lang.RuntimeException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle foldArguments(
+ java.lang.invoke.MethodHandle target, java.lang.invoke.MethodHandle combiner) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.Class<?> foldArgumentChecks(
+ int foldPos,
+ java.lang.invoke.MethodType targetType,
+ java.lang.invoke.MethodType combinerType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle guardWithTest(
+ java.lang.invoke.MethodHandle test,
+ java.lang.invoke.MethodHandle target,
+ java.lang.invoke.MethodHandle fallback) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.lang.RuntimeException misMatchedTypes(
+ java.lang.String what, java.lang.invoke.MethodType t1, java.lang.invoke.MethodType t2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle catchException(
+ java.lang.invoke.MethodHandle target,
+ java.lang.Class<? extends java.lang.Throwable> exType,
+ java.lang.invoke.MethodHandle handler) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.invoke.MethodHandle throwException(
+ java.lang.Class<?> returnType, java.lang.Class<? extends java.lang.Throwable> exType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static final class Lookup {
+
+ Lookup(java.lang.Class<?> lookupClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private Lookup(java.lang.Class<?> lookupClass, int allowedModes) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int fixmods(int mods) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Class<?> lookupClass() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int lookupModes() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.MethodHandles.Lookup in(java.lang.Class<?> requestedLookupClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void checkUnprivilegedlookupClass(
+ java.lang.Class<?> lookupClass, int allowedModes) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.MethodHandle findStatic(
+ java.lang.Class<?> refc, java.lang.String name, java.lang.invoke.MethodType type)
+ throws java.lang.IllegalAccessException, java.lang.NoSuchMethodException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.invoke.MethodHandle findVirtualForMH(
+ java.lang.String name, java.lang.invoke.MethodType type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.invoke.MethodHandle findVirtualForVH(
+ java.lang.String name, java.lang.invoke.MethodType type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.invoke.MethodHandle createMethodHandle(
+ java.lang.reflect.Method method,
+ int handleKind,
+ java.lang.invoke.MethodType methodType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.MethodHandle findVirtual(
+ java.lang.Class<?> refc, java.lang.String name, java.lang.invoke.MethodType type)
+ throws java.lang.IllegalAccessException, java.lang.NoSuchMethodException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.MethodHandle findConstructor(
+ java.lang.Class<?> refc, java.lang.invoke.MethodType type)
+ throws java.lang.IllegalAccessException, java.lang.NoSuchMethodException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.invoke.MethodHandle createMethodHandleForConstructor(
+ java.lang.reflect.Constructor constructor) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.invoke.MethodType initMethodType(
+ java.lang.invoke.MethodType constructorType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.MethodHandle findSpecial(
+ java.lang.Class<?> refc,
+ java.lang.String name,
+ java.lang.invoke.MethodType type,
+ java.lang.Class<?> specialCaller)
+ throws java.lang.IllegalAccessException, java.lang.NoSuchMethodException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.invoke.MethodHandle findSpecial(
+ java.lang.reflect.Method method,
+ java.lang.invoke.MethodType type,
+ java.lang.Class<?> refc,
+ java.lang.Class<?> specialCaller)
+ throws java.lang.IllegalAccessException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.MethodHandle findGetter(
+ java.lang.Class<?> refc, java.lang.String name, java.lang.Class<?> type)
+ throws java.lang.IllegalAccessException, java.lang.NoSuchFieldException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.invoke.MethodHandle findAccessor(
+ java.lang.Class<?> refc, java.lang.String name, java.lang.Class<?> type, int kind)
+ throws java.lang.IllegalAccessException, java.lang.NoSuchFieldException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.invoke.MethodHandle findAccessor(
+ java.lang.reflect.Field field,
+ java.lang.Class<?> refc,
+ java.lang.Class<?> type,
+ int kind,
+ boolean performAccessChecks)
+ throws java.lang.IllegalAccessException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.MethodHandle findSetter(
+ java.lang.Class<?> refc, java.lang.String name, java.lang.Class<?> type)
+ throws java.lang.IllegalAccessException, java.lang.NoSuchFieldException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.VarHandle findVarHandle(
+ java.lang.Class<?> recv, java.lang.String name, java.lang.Class<?> type)
+ throws java.lang.IllegalAccessException, java.lang.NoSuchFieldException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.reflect.Field findFieldOfType(
+ java.lang.Class<?> refc, java.lang.String name, java.lang.Class<?> type)
+ throws java.lang.NoSuchFieldException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void commonFieldChecks(
+ java.lang.reflect.Field field,
+ java.lang.Class<?> refc,
+ java.lang.Class<?> type,
+ boolean isStatic,
+ boolean performAccessChecks)
+ throws java.lang.IllegalAccessException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.MethodHandle findStaticGetter(
+ java.lang.Class<?> refc, java.lang.String name, java.lang.Class<?> type)
+ throws java.lang.IllegalAccessException, java.lang.NoSuchFieldException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.MethodHandle findStaticSetter(
+ java.lang.Class<?> refc, java.lang.String name, java.lang.Class<?> type)
+ throws java.lang.IllegalAccessException, java.lang.NoSuchFieldException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.VarHandle findStaticVarHandle(
+ java.lang.Class<?> decl, java.lang.String name, java.lang.Class<?> type)
+ throws java.lang.IllegalAccessException, java.lang.NoSuchFieldException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.MethodHandle bind(
+ java.lang.Object receiver, java.lang.String name, java.lang.invoke.MethodType type)
+ throws java.lang.IllegalAccessException, java.lang.NoSuchMethodException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.MethodHandle unreflect(java.lang.reflect.Method m)
+ throws java.lang.IllegalAccessException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.MethodHandle unreflectSpecial(
+ java.lang.reflect.Method m, java.lang.Class<?> specialCaller)
+ throws java.lang.IllegalAccessException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.MethodHandle unreflectConstructor(
+ java.lang.reflect.Constructor<?> c) throws java.lang.IllegalAccessException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.MethodHandle unreflectGetter(java.lang.reflect.Field f)
+ throws java.lang.IllegalAccessException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.MethodHandle unreflectSetter(java.lang.reflect.Field f)
+ throws java.lang.IllegalAccessException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.VarHandle unreflectVarHandle(java.lang.reflect.Field f)
+ throws java.lang.IllegalAccessException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.invoke.MethodHandleInfo revealDirect(
+ java.lang.invoke.MethodHandle target) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean hasPrivateAccess() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void checkAccess(
+ java.lang.Class<?> refc,
+ java.lang.Class<?> defc,
+ int mods,
+ java.lang.String methName)
+ throws java.lang.IllegalAccessException {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.String accessFailedMessage(
+ java.lang.Class<?> refc, java.lang.Class<?> defc, int mods) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkSpecialCaller(java.lang.Class<?> specialCaller)
+ throws java.lang.IllegalAccessException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void throwMakeAccessException(java.lang.String message, java.lang.Object from)
+ throws java.lang.IllegalAccessException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkReturnType(
+ java.lang.reflect.Method method, java.lang.invoke.MethodType methodType)
+ throws java.lang.NoSuchMethodException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int ALL_MODES = 15; // 0xf
+
+ static final java.lang.invoke.MethodHandles.Lookup IMPL_LOOKUP;
+
+ static {
+ IMPL_LOOKUP = null;
+ }
+
+ public static final int PACKAGE = 8; // 0x8
+
+ public static final int PRIVATE = 2; // 0x2
+
+ public static final int PROTECTED = 4; // 0x4
+
+ public static final int PUBLIC = 1; // 0x1
+
+ static final java.lang.invoke.MethodHandles.Lookup PUBLIC_LOOKUP;
+
+ static {
+ PUBLIC_LOOKUP = null;
+ }
+
+ private final int allowedModes;
+
+ {
+ allowedModes = 0;
+ }
+
+ private final java.lang.Class<?> lookupClass;
+
+ {
+ lookupClass = null;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/ref/Reference.java b/ojluni/annotations/hiddenapi/java/lang/ref/Reference.java
new file mode 100644
index 0000000..f2239ea
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/ref/Reference.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1997, 2017, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang.ref;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class Reference<T> {
+
+ Reference(T referent) {
+ throw new RuntimeException("Stub!");
+ }
+
+ Reference(T referent, java.lang.ref.ReferenceQueue<? super T> queue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public T get() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private final native T getReferent();
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ native void clearReferent();
+
+ public boolean isEnqueued() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean enqueue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void reachabilityFence(java.lang.Object ref) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean disableIntrinsic = false;
+
+ java.lang.ref.Reference<?> pendingNext;
+
+ final java.lang.ref.ReferenceQueue<? super T> queue;
+
+ {
+ queue = null;
+ }
+
+ java.lang.ref.Reference queueNext;
+
+ @UnsupportedAppUsage
+ volatile T referent;
+
+ private static boolean slowPathEnabled = false;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class SinkHolder {
+
+ private SinkHolder() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static volatile int finalize_count = 0; // 0x0
+
+ static volatile java.lang.Object sink;
+
+ private static java.lang.Object sinkUser;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/ref/ReferenceQueue.java b/ojluni/annotations/hiddenapi/java/lang/ref/ReferenceQueue.java
new file mode 100644
index 0000000..423b830
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/ref/ReferenceQueue.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1997, 2005, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang.ref;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ReferenceQueue<T> {
+
+ public ReferenceQueue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean enqueueLocked(java.lang.ref.Reference<? extends T> r) {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isEnqueued(java.lang.ref.Reference<? extends T> reference) {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean enqueue(java.lang.ref.Reference<? extends T> reference) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.ref.Reference<? extends T> reallyPollLocked() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.ref.Reference<? extends T> poll() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.ref.Reference<? extends T> remove(long timeout)
+ throws java.lang.IllegalArgumentException, java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.ref.Reference<? extends T> remove() throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void enqueuePending(java.lang.ref.Reference<?> list) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ static void add(java.lang.ref.Reference<?> list) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.ref.Reference<? extends T> head;
+
+ private final java.lang.Object lock;
+
+ {
+ lock = null;
+ }
+
+ private static final java.lang.ref.Reference sQueueNextUnenqueued;
+
+ static {
+ sQueueNextUnenqueued = null;
+ }
+
+ private java.lang.ref.Reference<? extends T> tail;
+
+ public static java.lang.ref.Reference<?> unenqueued;
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/reflect/AccessibleObject.java b/ojluni/annotations/hiddenapi/java/lang/reflect/AccessibleObject.java
new file mode 100644
index 0000000..b105a24
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/reflect/AccessibleObject.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1997, 2014, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang.reflect;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class AccessibleObject implements java.lang.reflect.AnnotatedElement {
+
+ protected AccessibleObject() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void setAccessible(java.lang.reflect.AccessibleObject[] array, boolean flag)
+ throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setAccessible(boolean flag) throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void setAccessible0(java.lang.reflect.AccessibleObject obj, boolean flag)
+ throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isAccessible() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T extends java.lang.annotation.Annotation> T getAnnotation(
+ java.lang.Class<T> annotationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isAnnotationPresent(
+ java.lang.Class<? extends java.lang.annotation.Annotation> annotationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T extends java.lang.annotation.Annotation> T[] getAnnotationsByType(
+ java.lang.Class<T> annotationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.annotation.Annotation[] getAnnotations() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T extends java.lang.annotation.Annotation> T getDeclaredAnnotation(
+ java.lang.Class<T> annotationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T extends java.lang.annotation.Annotation> T[] getDeclaredAnnotationsByType(
+ java.lang.Class<T> annotationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.annotation.Annotation[] getDeclaredAnnotations() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ boolean override;
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/reflect/Constructor.java b/ojluni/annotations/hiddenapi/java/lang/reflect/Constructor.java
new file mode 100644
index 0000000..79d24e3
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/reflect/Constructor.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1996, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang.reflect;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Constructor<T> extends java.lang.reflect.Executable {
+
+ private Constructor() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private Constructor(
+ java.lang.Class<?> serializationCtor, java.lang.Class<?> serializationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public java.lang.reflect.Constructor<T> serializationCopy(
+ java.lang.Class<?> ctor, java.lang.Class<?> cl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean hasGenericInformation() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Class<T> getDeclaringClass() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getModifiers() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.reflect.TypeVariable<java.lang.reflect.Constructor<T>>[] getTypeParameters() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Class<?>[] getParameterTypes() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getParameterCount() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.reflect.Type[] getGenericParameterTypes() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public native java.lang.Class<?>[] getExceptionTypes();
+
+ public java.lang.reflect.Type[] getGenericExceptionTypes() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void specificToStringHeader(java.lang.StringBuilder sb) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toGenericString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void specificToGenericStringHeader(java.lang.StringBuilder sb) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public T newInstance(java.lang.Object... initargs)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException,
+ java.lang.InstantiationException, java.lang.reflect.InvocationTargetException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native java.lang.Object newInstanceFromSerialization(
+ java.lang.Class<?> ctorClass, java.lang.Class<?> allocClass)
+ throws java.lang.IllegalArgumentException, java.lang.InstantiationException,
+ java.lang.reflect.InvocationTargetException;
+
+ private native T newInstance0(java.lang.Object... args)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException,
+ java.lang.InstantiationException, java.lang.reflect.InvocationTargetException;
+
+ public boolean isVarArgs() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isSynthetic() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T extends java.lang.annotation.Annotation> T getAnnotation(
+ java.lang.Class<T> annotationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.annotation.Annotation[] getDeclaredAnnotations() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.annotation.Annotation[][] getParameterAnnotations() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.util.Comparator<java.lang.reflect.Method> ORDER_BY_SIGNATURE;
+
+ static {
+ ORDER_BY_SIGNATURE = null;
+ }
+
+ private final java.lang.Class<?> serializationClass;
+
+ {
+ serializationClass = null;
+ }
+
+ private final java.lang.Class<?> serializationCtor;
+
+ {
+ serializationCtor = null;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/reflect/Executable.java b/ojluni/annotations/hiddenapi/java/lang/reflect/Executable.java
new file mode 100644
index 0000000..e40b1b1
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/reflect/Executable.java
@@ -0,0 +1,269 @@
+/*
+ * Copyright (c) 2012, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang.reflect;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class Executable extends java.lang.reflect.AccessibleObject
+ implements java.lang.reflect.Member, java.lang.reflect.GenericDeclaration {
+
+ Executable() {
+ throw new RuntimeException("Stub!");
+ }
+
+ abstract boolean hasGenericInformation();
+
+ boolean equalParamTypes(java.lang.Class<?>[] params1, java.lang.Class<?>[] params2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void separateWithCommas(java.lang.Class<?>[] types, java.lang.StringBuilder sb) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void printModifiersIfNonzero(java.lang.StringBuilder sb, int mask, boolean isDefault) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.String sharedToString(
+ int modifierMask,
+ boolean isDefault,
+ java.lang.Class<?>[] parameterTypes,
+ java.lang.Class<?>[] exceptionTypes) {
+ throw new RuntimeException("Stub!");
+ }
+
+ abstract void specificToStringHeader(java.lang.StringBuilder sb);
+
+ java.lang.String sharedToGenericString(int modifierMask, boolean isDefault) {
+ throw new RuntimeException("Stub!");
+ }
+
+ abstract void specificToGenericStringHeader(java.lang.StringBuilder sb);
+
+ public abstract java.lang.Class<?> getDeclaringClass();
+
+ public abstract java.lang.String getName();
+
+ public abstract int getModifiers();
+
+ public abstract java.lang.reflect.TypeVariable<?>[] getTypeParameters();
+
+ public abstract java.lang.Class<?>[] getParameterTypes();
+
+ public int getParameterCount() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.reflect.Type[] getGenericParameterTypes() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.reflect.Type[] getAllGenericParameterTypes() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.reflect.Parameter[] getParameters() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.reflect.Parameter[] synthesizeAllParams() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void verifyParameters(java.lang.reflect.Parameter[] parameters) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.reflect.Parameter[] privateGetParameters() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean hasRealParameterData() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.reflect.Parameter[] getParameters0();
+
+ public abstract java.lang.Class<?>[] getExceptionTypes();
+
+ public java.lang.reflect.Type[] getGenericExceptionTypes() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.lang.String toGenericString();
+
+ public boolean isVarArgs() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isSynthetic() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.lang.annotation.Annotation[][] getParameterAnnotations();
+
+ public <T extends java.lang.annotation.Annotation> T getAnnotation(
+ java.lang.Class<T> annotationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native <T extends java.lang.annotation.Annotation> T getAnnotationNative(
+ java.lang.Class<T> annotationClass);
+
+ public <T extends java.lang.annotation.Annotation> T[] getAnnotationsByType(
+ java.lang.Class<T> annotationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.annotation.Annotation[] getDeclaredAnnotations() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.annotation.Annotation[] getDeclaredAnnotationsNative();
+
+ private static int fixMethodFlags(int flags) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int getModifiersInternal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.lang.Class<?> getDeclaringClassInternal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final native java.lang.Class<?>[] getParameterTypesInternal();
+
+ final native int getParameterCountInternal();
+
+ public final boolean isAnnotationPresent(
+ java.lang.Class<? extends java.lang.annotation.Annotation> annotationType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native boolean isAnnotationPresentNative(
+ java.lang.Class<? extends java.lang.annotation.Annotation> annotationType);
+
+ final java.lang.annotation.Annotation[][] getParameterAnnotationsInternal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.annotation.Annotation[][] getParameterAnnotationsNative();
+
+ public final int getAccessFlags() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final long getArtMethod() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final boolean hasGenericInformationInternal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.lang.reflect.Executable.GenericInfo getMethodOrConstructorGenericInfoInternal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String getSignatureAttribute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.String[] getSignatureAnnotation();
+
+ final boolean equalNameAndParametersInternal(java.lang.reflect.Method m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ native int compareMethodParametersInternal(java.lang.reflect.Method meth);
+
+ final native java.lang.String getMethodNameInternal();
+
+ final native java.lang.Class<?> getMethodReturnTypeInternal();
+
+ final boolean isDefaultMethodInternal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final boolean isBridgeMethodInternal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int accessFlags;
+
+ @UnsupportedAppUsage
+ private long artMethod;
+
+ private java.lang.Class<?> declaringClass;
+
+ private java.lang.Class<?> declaringClassOfOverriddenMethod;
+
+ private int dexMethodIndex;
+
+ private transient volatile boolean hasRealParameterData;
+
+ private transient volatile java.lang.reflect.Parameter[] parameters;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class GenericInfo {
+
+ GenericInfo(
+ libcore.reflect.ListOfTypes exceptions,
+ libcore.reflect.ListOfTypes parameters,
+ java.lang.reflect.Type ret,
+ java.lang.reflect.TypeVariable<?>[] formal) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.lang.reflect.TypeVariable<?>[] formalTypeParameters;
+
+ {
+ formalTypeParameters = new java.lang.reflect.TypeVariable[0];
+ }
+
+ final libcore.reflect.ListOfTypes genericExceptionTypes;
+
+ {
+ genericExceptionTypes = null;
+ }
+
+ final libcore.reflect.ListOfTypes genericParameterTypes;
+
+ {
+ genericParameterTypes = null;
+ }
+
+ final java.lang.reflect.Type genericReturnType;
+
+ {
+ genericReturnType = null;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/reflect/Field.java b/ojluni/annotations/hiddenapi/java/lang/reflect/Field.java
new file mode 100644
index 0000000..2048f74
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/reflect/Field.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1996, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang.reflect;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Field extends java.lang.reflect.AccessibleObject
+ implements java.lang.reflect.Member {
+
+ private Field() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Class<?> getDeclaringClass() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.String getNameInternal();
+
+ public int getModifiers() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEnumConstant() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isSynthetic() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Class<?> getType() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.reflect.Type getGenericType() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String getSignatureAttribute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.String[] getSignatureAnnotation();
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toGenericString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public native java.lang.Object get(java.lang.Object obj)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public native boolean getBoolean(java.lang.Object obj)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public native byte getByte(java.lang.Object obj)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public native char getChar(java.lang.Object obj)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public native short getShort(java.lang.Object obj)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public native int getInt(java.lang.Object obj)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public native long getLong(java.lang.Object obj)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public native float getFloat(java.lang.Object obj)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public native double getDouble(java.lang.Object obj)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public native void set(java.lang.Object obj, java.lang.Object value)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public native void setBoolean(java.lang.Object obj, boolean z)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public native void setByte(java.lang.Object obj, byte b)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public native void setChar(java.lang.Object obj, char c)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public native void setShort(java.lang.Object obj, short s)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public native void setInt(java.lang.Object obj, int i)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public native void setLong(java.lang.Object obj, long l)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public native void setFloat(java.lang.Object obj, float f)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public native void setDouble(java.lang.Object obj, double d)
+ throws java.lang.IllegalAccessException, java.lang.IllegalArgumentException;
+
+ public <T extends java.lang.annotation.Annotation> T getAnnotation(
+ java.lang.Class<T> annotationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native <A extends java.lang.annotation.Annotation> A getAnnotationNative(
+ java.lang.Class<A> annotationType);
+
+ public <T extends java.lang.annotation.Annotation> T[] getAnnotationsByType(
+ java.lang.Class<T> annotationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isAnnotationPresent(
+ java.lang.Class<? extends java.lang.annotation.Annotation> annotationType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native boolean isAnnotationPresentNative(
+ java.lang.Class<? extends java.lang.annotation.Annotation> annotationType);
+
+ public native java.lang.annotation.Annotation[] getDeclaredAnnotations();
+
+ public int getDexFieldIndex() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public int getOffset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public native long getArtField();
+
+ @UnsupportedAppUsage
+ private int accessFlags;
+
+ private java.lang.Class<?> declaringClass;
+
+ private int dexFieldIndex;
+
+ private int offset;
+
+ private java.lang.Class<?> type;
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/reflect/Parameter.java b/ojluni/annotations/hiddenapi/java/lang/reflect/Parameter.java
new file mode 100644
index 0000000..40ccf9e
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/reflect/Parameter.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang.reflect;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Parameter implements java.lang.reflect.AnnotatedElement {
+
+ @UnsupportedAppUsage
+ Parameter(
+ java.lang.String name,
+ int modifiers,
+ java.lang.reflect.Executable executable,
+ int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isNamePresent() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.reflect.Executable getDeclaringExecutable() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getModifiers() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.String getRealName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.reflect.Type getParameterizedType() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Class<?> getType() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isImplicit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isSynthetic() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isVarArgs() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T extends java.lang.annotation.Annotation> T getAnnotation(
+ java.lang.Class<T> annotationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native <A extends java.lang.annotation.Annotation> A getAnnotationNative(
+ java.lang.reflect.Executable executable,
+ int parameterIndex,
+ java.lang.Class<A> annotationType);
+
+ public <T extends java.lang.annotation.Annotation> T[] getAnnotationsByType(
+ java.lang.Class<T> annotationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.annotation.Annotation[] getDeclaredAnnotations() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T extends java.lang.annotation.Annotation> T getDeclaredAnnotation(
+ java.lang.Class<T> annotationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T extends java.lang.annotation.Annotation> T[] getDeclaredAnnotationsByType(
+ java.lang.Class<T> annotationClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.annotation.Annotation[] getAnnotations() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.lang.reflect.Executable executable;
+
+ {
+ executable = null;
+ }
+
+ private final int index;
+
+ {
+ index = 0;
+ }
+
+ private final int modifiers;
+
+ {
+ modifiers = 0;
+ }
+
+ private final java.lang.String name;
+
+ {
+ name = null;
+ }
+
+ private transient volatile java.lang.Class<?> parameterClassCache;
+
+ private transient volatile java.lang.reflect.Type parameterTypeCache;
+}
diff --git a/ojluni/annotations/hiddenapi/java/lang/reflect/Proxy.java b/ojluni/annotations/hiddenapi/java/lang/reflect/Proxy.java
new file mode 100644
index 0000000..e65bf19
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/lang/reflect/Proxy.java
@@ -0,0 +1,262 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1999, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang.reflect;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Proxy implements java.io.Serializable {
+
+ private Proxy() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected Proxy(java.lang.reflect.InvocationHandler h) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.Class<?> getProxyClass(
+ java.lang.ClassLoader loader, java.lang.Class<?>... interfaces)
+ throws java.lang.IllegalArgumentException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.Class<?> getProxyClass0(
+ java.lang.ClassLoader loader, java.lang.Class<?>... interfaces) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.util.List<java.lang.Class<?>[]> deduplicateAndGetExceptions(
+ java.util.List<java.lang.reflect.Method> methods) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.Class<?>[] intersectExceptions(
+ java.lang.Class<?>[] aExceptions, java.lang.Class<?>[] bExceptions) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void validateReturnTypes(java.util.List<java.lang.reflect.Method> methods) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.util.List<java.lang.reflect.Method> getMethods(
+ java.lang.Class<?>[] interfaces) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void getMethodsRecursive(
+ java.lang.Class<?>[] interfaces, java.util.List<java.lang.reflect.Method> methods) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native java.lang.Class<?> generateProxy(
+ java.lang.String name,
+ java.lang.Class<?>[] interfaces,
+ java.lang.ClassLoader loader,
+ java.lang.reflect.Method[] methods,
+ java.lang.Class<?>[][] exceptions);
+
+ public static java.lang.Object newProxyInstance(
+ java.lang.ClassLoader loader,
+ java.lang.Class<?>[] interfaces,
+ java.lang.reflect.InvocationHandler h)
+ throws java.lang.IllegalArgumentException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isProxyClass(java.lang.Class<?> cl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.reflect.InvocationHandler getInvocationHandler(java.lang.Object proxy)
+ throws java.lang.IllegalArgumentException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static java.lang.Object invoke(
+ java.lang.reflect.Proxy proxy, java.lang.reflect.Method method, java.lang.Object[] args)
+ throws java.lang.Throwable {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.util.Comparator<java.lang.reflect.Method>
+ ORDER_BY_SIGNATURE_AND_SUBTYPE;
+
+ static {
+ ORDER_BY_SIGNATURE_AND_SUBTYPE = null;
+ }
+
+ private static final java.lang.Class<?>[] constructorParams;
+
+ static {
+ constructorParams = new java.lang.Class[0];
+ }
+
+ protected java.lang.reflect.InvocationHandler h;
+
+ private static final java.lang.Object key0;
+
+ static {
+ key0 = null;
+ }
+
+ private static final java.lang.reflect.WeakCache<
+ java.lang.ClassLoader, java.lang.Class<?>[], java.lang.Class<?>>
+ proxyClassCache;
+
+ static {
+ proxyClassCache = null;
+ }
+
+ private static final long serialVersionUID = -2222568056686623797L; // 0xe127da20cc1043cbL
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static final class Key1 extends java.lang.ref.WeakReference<java.lang.Class<?>> {
+
+ Key1(java.lang.Class<?> intf) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final int hash;
+
+ {
+ hash = 0;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static final class Key2 extends java.lang.ref.WeakReference<java.lang.Class<?>> {
+
+ Key2(java.lang.Class<?> intf1, java.lang.Class<?> intf2) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final int hash;
+
+ {
+ hash = 0;
+ }
+
+ private final java.lang.ref.WeakReference<java.lang.Class<?>> ref2;
+
+ {
+ ref2 = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static final class KeyFactory
+ implements java.util.function.BiFunction<
+ java.lang.ClassLoader, java.lang.Class<?>[], java.lang.Object> {
+
+ private KeyFactory() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object apply(
+ java.lang.ClassLoader classLoader, java.lang.Class<?>[] interfaces) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static final class KeyX {
+
+ KeyX(java.lang.Class<?>[] interfaces) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean equals(
+ java.lang.ref.WeakReference<java.lang.Class<?>>[] refs1,
+ java.lang.ref.WeakReference<java.lang.Class<?>>[] refs2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final int hash;
+
+ {
+ hash = 0;
+ }
+
+ private final java.lang.ref.WeakReference<java.lang.Class<?>>[] refs;
+
+ {
+ refs = new java.lang.ref.WeakReference[0];
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static final class ProxyClassFactory
+ implements java.util.function.BiFunction<
+ java.lang.ClassLoader, java.lang.Class<?>[], java.lang.Class<?>> {
+
+ private ProxyClassFactory() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Class<?> apply(
+ java.lang.ClassLoader loader, java.lang.Class<?>[] interfaces) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.util.concurrent.atomic.AtomicLong nextUniqueNumber;
+
+ static {
+ nextUniqueNumber = null;
+ }
+
+ private static final java.lang.String proxyClassNamePrefix = "$Proxy";
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/net/Authenticator.java b/ojluni/annotations/hiddenapi/java/net/Authenticator.java
new file mode 100644
index 0000000..2765044
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/net/Authenticator.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 1997, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class Authenticator {
+
+ public Authenticator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void reset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static synchronized void setDefault(java.net.Authenticator a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.net.PasswordAuthentication requestPasswordAuthentication(
+ java.net.InetAddress addr,
+ int port,
+ java.lang.String protocol,
+ java.lang.String prompt,
+ java.lang.String scheme) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.net.PasswordAuthentication requestPasswordAuthentication(
+ java.lang.String host,
+ java.net.InetAddress addr,
+ int port,
+ java.lang.String protocol,
+ java.lang.String prompt,
+ java.lang.String scheme) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.net.PasswordAuthentication requestPasswordAuthentication(
+ java.lang.String host,
+ java.net.InetAddress addr,
+ int port,
+ java.lang.String protocol,
+ java.lang.String prompt,
+ java.lang.String scheme,
+ java.net.URL url,
+ java.net.Authenticator.RequestorType reqType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final java.lang.String getRequestingHost() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final java.net.InetAddress getRequestingSite() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final int getRequestingPort() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final java.lang.String getRequestingProtocol() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final java.lang.String getRequestingPrompt() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final java.lang.String getRequestingScheme() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.net.PasswordAuthentication getPasswordAuthentication() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.net.URL getRequestingURL() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.net.Authenticator.RequestorType getRequestorType() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.net.Authenticator.RequestorType requestingAuthType;
+
+ private java.lang.String requestingHost;
+
+ private int requestingPort;
+
+ private java.lang.String requestingPrompt;
+
+ private java.lang.String requestingProtocol;
+
+ private java.lang.String requestingScheme;
+
+ private java.net.InetAddress requestingSite;
+
+ private java.net.URL requestingURL;
+
+ @UnsupportedAppUsage
+ private static java.net.Authenticator theAuthenticator;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static enum RequestorType {
+ PROXY,
+ SERVER;
+
+ private RequestorType() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/net/DatagramSocket.java b/ojluni/annotations/hiddenapi/java/net/DatagramSocket.java
new file mode 100644
index 0000000..fd804c7
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/net/DatagramSocket.java
@@ -0,0 +1,239 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1995, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class DatagramSocket implements java.io.Closeable {
+
+ public DatagramSocket() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected DatagramSocket(java.net.DatagramSocketImpl impl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public DatagramSocket(java.net.SocketAddress bindaddr) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public DatagramSocket(int port) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public DatagramSocket(int port, java.net.InetAddress laddr) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized void connectInternal(java.net.InetAddress address, int port)
+ throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkOldImpl() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void createImpl() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.net.DatagramSocketImpl getImpl() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void bind(java.net.SocketAddress addr) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void checkAddress(java.net.InetAddress addr, java.lang.String op) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void connect(java.net.InetAddress address, int port) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void connect(java.net.SocketAddress addr) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void disconnect() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isBound() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isConnected() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.InetAddress getInetAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getPort() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.SocketAddress getRemoteSocketAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.SocketAddress getLocalSocketAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void send(java.net.DatagramPacket p) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void receive(java.net.DatagramPacket p) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean checkFiltering(java.net.DatagramPacket p) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.InetAddress getLocalAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getLocalPort() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setSoTimeout(int timeout) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int getSoTimeout() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setSendBufferSize(int size) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int getSendBufferSize() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setReceiveBufferSize(int size) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int getReceiveBufferSize() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setReuseAddress(boolean on) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized boolean getReuseAddress() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setBroadcast(boolean on) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized boolean getBroadcast() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setTrafficClass(int tc) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int getTrafficClass() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void close() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isClosed() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.channels.DatagramChannel getChannel() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static synchronized void setDatagramSocketImplFactory(
+ java.net.DatagramSocketImplFactory fac) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public java.io.FileDescriptor getFileDescriptor$() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final int ST_CONNECTED = 1; // 0x1
+
+ static final int ST_CONNECTED_NO_IMPL = 2; // 0x2
+
+ static final int ST_NOT_CONNECTED = 0; // 0x0
+
+ private boolean bound = false;
+
+ private int bytesLeftToFilter;
+
+ private java.lang.Object closeLock;
+
+ private boolean closed = false;
+
+ int connectState = 0; // 0x0
+
+ java.net.InetAddress connectedAddress;
+
+ int connectedPort = -1; // 0xffffffff
+
+ private boolean created = false;
+
+ private boolean explicitFilter = false;
+
+ static java.net.DatagramSocketImplFactory factory;
+
+ @UnsupportedAppUsage
+ java.net.DatagramSocketImpl impl;
+
+ static java.lang.Class<?> implClass;
+
+ boolean oldImpl = false;
+
+ private java.net.SocketException pendingConnectException;
+}
diff --git a/ojluni/annotations/hiddenapi/java/net/HttpCookie.java b/ojluni/annotations/hiddenapi/java/net/HttpCookie.java
new file mode 100644
index 0000000..113e804
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/net/HttpCookie.java
@@ -0,0 +1,306 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2005, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class HttpCookie implements java.lang.Cloneable {
+
+ public HttpCookie(java.lang.String name, java.lang.String value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private HttpCookie(java.lang.String name, java.lang.String value, java.lang.String header) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.List<java.net.HttpCookie> parse(java.lang.String header) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.util.List<java.net.HttpCookie> parse(
+ java.lang.String header, boolean retainHeader) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasExpired() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setComment(java.lang.String purpose) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getComment() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setCommentURL(java.lang.String purpose) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getCommentURL() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setDiscard(boolean discard) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean getDiscard() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setPortlist(java.lang.String ports) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getPortlist() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setDomain(java.lang.String pattern) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getDomain() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setMaxAge(long expiry) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getMaxAge() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setPath(java.lang.String uri) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getPath() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setSecure(boolean flag) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean getSecure() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setValue(java.lang.String newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getVersion() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setVersion(int v) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isHttpOnly() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setHttpOnly(boolean httpOnly) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean domainMatches(java.lang.String domain, java.lang.String host) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean isFullyQualifiedDomainName(java.lang.String s, int firstCharacter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object clone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean isToken(java.lang.String value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.net.HttpCookie parseInternal(
+ java.lang.String header, boolean retainHeader) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void assignAttribute(
+ java.net.HttpCookie cookie, java.lang.String attrName, java.lang.String attrValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String header() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String toNetscapeHeaderString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String toRFC2965HeaderString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int guessCookieVersion(java.lang.String header) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String stripOffSurroundingQuote(java.lang.String str) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean equalsIgnoreCase(java.lang.String s, java.lang.String t) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean startsWithIgnoreCase(java.lang.String s, java.lang.String start) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.util.List<java.lang.String> splitMultiCookies(java.lang.String header) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.util.TimeZone GMT;
+
+ static {
+ GMT = null;
+ }
+
+ private static final long MAX_AGE_UNSPECIFIED = -1L; // 0xffffffffffffffffL
+
+ private static final java.util.Set<java.lang.String> RESERVED_NAMES;
+
+ static {
+ RESERVED_NAMES = null;
+ }
+
+ private static final java.lang.String SET_COOKIE = "set-cookie:";
+
+ private static final java.lang.String SET_COOKIE2 = "set-cookie2:";
+
+ @UnsupportedAppUsage
+ static final java.util.Map<java.lang.String, java.net.HttpCookie.CookieAttributeAssignor>
+ assignors;
+
+ static {
+ assignors = null;
+ }
+
+ @UnsupportedAppUsage
+ private java.lang.String comment;
+
+ @UnsupportedAppUsage
+ private java.lang.String commentURL;
+
+ @UnsupportedAppUsage
+ private java.lang.String domain;
+
+ @UnsupportedAppUsage
+ private final java.lang.String header;
+
+ {
+ header = null;
+ }
+
+ @UnsupportedAppUsage
+ private boolean httpOnly;
+
+ @UnsupportedAppUsage
+ private long maxAge = -1L; // 0xffffffffffffffffL
+
+ @UnsupportedAppUsage
+ private final java.lang.String name;
+
+ {
+ name = null;
+ }
+
+ @UnsupportedAppUsage
+ private java.lang.String path;
+
+ @UnsupportedAppUsage
+ private java.lang.String portlist;
+
+ @UnsupportedAppUsage
+ private boolean secure;
+
+ @UnsupportedAppUsage
+ private boolean toDiscard;
+
+ @UnsupportedAppUsage
+ private static final java.lang.String tspecials = ",;= \t";
+
+ @UnsupportedAppUsage
+ private java.lang.String value;
+
+ @UnsupportedAppUsage
+ private int version = 1; // 0x1
+
+ @UnsupportedAppUsage
+ private final long whenCreated;
+
+ {
+ whenCreated = 0;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static interface CookieAttributeAssignor {
+
+ public void assign(
+ java.net.HttpCookie cookie, java.lang.String attrName, java.lang.String attrValue);
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/net/Inet4Address.java b/ojluni/annotations/hiddenapi/java/net/Inet4Address.java
new file mode 100644
index 0000000..16395ea
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/net/Inet4Address.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2000, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Inet4Address extends java.net.InetAddress {
+
+ @UnsupportedAppUsage
+ Inet4Address() {
+ throw new RuntimeException("Stub!");
+ }
+
+ Inet4Address(java.lang.String hostName, byte[] addr) {
+ throw new RuntimeException("Stub!");
+ }
+
+ Inet4Address(java.lang.String hostName, int address) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object writeReplace() throws java.io.ObjectStreamException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMulticastAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isAnyLocalAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isLoopbackAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isLinkLocalAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isSiteLocalAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMCGlobal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMCNodeLocal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMCLinkLocal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMCSiteLocal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMCOrgLocal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public byte[] getAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getHostAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.lang.String numericToTextFormat(byte[] src) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public static final java.net.InetAddress ALL;
+
+ static {
+ ALL = null;
+ }
+
+ @UnsupportedAppUsage
+ public static final java.net.InetAddress ANY;
+
+ static {
+ ANY = null;
+ }
+
+ static final int INADDRSZ = 4; // 0x4
+
+ public static final java.net.InetAddress LOOPBACK;
+
+ static {
+ LOOPBACK = null;
+ }
+
+ private static final long serialVersionUID = 3286316764910316507L; // 0x2d9b57af9fe3ebdbL
+}
diff --git a/ojluni/annotations/hiddenapi/java/net/Inet6Address.java b/ojluni/annotations/hiddenapi/java/net/Inet6Address.java
new file mode 100644
index 0000000..f46fa58
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/net/Inet6Address.java
@@ -0,0 +1,318 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2000, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Inet6Address extends java.net.InetAddress {
+
+ @UnsupportedAppUsage
+ Inet6Address() {
+ throw new RuntimeException("Stub!");
+ }
+
+ Inet6Address(java.lang.String hostName, byte[] addr, int scope_id) {
+ throw new RuntimeException("Stub!");
+ }
+
+ Inet6Address(java.lang.String hostName, byte[] addr) {
+ throw new RuntimeException("Stub!");
+ }
+
+ Inet6Address(java.lang.String hostName, byte[] addr, java.net.NetworkInterface nif)
+ throws java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ Inet6Address(java.lang.String hostName, byte[] addr, java.lang.String ifname)
+ throws java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.net.Inet6Address getByAddress(
+ java.lang.String host, byte[] addr, java.net.NetworkInterface nif)
+ throws java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.net.Inet6Address getByAddress(
+ java.lang.String host, byte[] addr, int scope_id) throws java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void initstr(java.lang.String hostName, byte[] addr, java.lang.String ifname)
+ throws java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void initif(java.lang.String hostName, byte[] addr, java.net.NetworkInterface nif)
+ throws java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean isDifferentLocalAddressType(byte[] thisAddr, byte[] otherAddr) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int deriveNumericScope(byte[] thisAddr, java.net.NetworkInterface ifc)
+ throws java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int deriveNumericScope(java.lang.String ifname) throws java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMulticastAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isAnyLocalAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isLoopbackAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isLinkLocalAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static boolean isLinkLocalAddress(byte[] ipaddress) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isSiteLocalAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static boolean isSiteLocalAddress(byte[] ipaddress) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMCGlobal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMCNodeLocal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMCLinkLocal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMCSiteLocal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMCOrgLocal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public byte[] getAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getScopeId() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.NetworkInterface getScopedInterface() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getHostAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isIPv4CompatibleAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.lang.String numericToTextFormat(byte[] src) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public static final java.net.InetAddress ANY;
+
+ static {
+ ANY = null;
+ }
+
+ private static final long FIELDS_OFFSET;
+
+ static {
+ FIELDS_OFFSET = 0;
+ }
+
+ static final int INADDRSZ = 16; // 0x10
+
+ private static final int INT16SZ = 2; // 0x2
+
+ public static final java.net.InetAddress LOOPBACK;
+
+ static {
+ LOOPBACK = null;
+ }
+
+ private static final sun.misc.Unsafe UNSAFE;
+
+ static {
+ UNSAFE = null;
+ }
+
+ @UnsupportedAppUsage
+ private final transient java.net.Inet6Address.Inet6AddressHolder holder6;
+
+ {
+ holder6 = null;
+ }
+
+ private static final java.io.ObjectStreamField[] serialPersistentFields;
+
+ static {
+ serialPersistentFields = new java.io.ObjectStreamField[0];
+ }
+
+ private static final long serialVersionUID = 6880410070516793377L; // 0x5f7c2081522c8021L
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class Inet6AddressHolder {
+
+ private Inet6AddressHolder() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private Inet6AddressHolder(
+ byte[] ipaddress,
+ int scope_id,
+ boolean scope_id_set,
+ java.net.NetworkInterface ifname,
+ boolean scope_ifname_set) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setAddr(byte[] addr) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void init(byte[] addr, int scope_id) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void init(byte[] addr, java.net.NetworkInterface nif) throws java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isIPv4CompatibleAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isMulticastAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isAnyLocalAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isLoopbackAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isLinkLocalAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isSiteLocalAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isMCGlobal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isMCNodeLocal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isMCLinkLocal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isMCSiteLocal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isMCOrgLocal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ byte[] ipaddress;
+
+ @UnsupportedAppUsage
+ int scope_id;
+
+ @UnsupportedAppUsage
+ boolean scope_id_set;
+
+ @UnsupportedAppUsage
+ java.net.NetworkInterface scope_ifname;
+
+ boolean scope_ifname_set;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/net/InetAddress.java b/ojluni/annotations/hiddenapi/java/net/InetAddress.java
new file mode 100644
index 0000000..2a7148d
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/net/InetAddress.java
@@ -0,0 +1,294 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1995, 2015, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class InetAddress implements java.io.Serializable {
+
+ InetAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ java.net.InetAddress.InetAddressHolder holder() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readResolve() throws java.io.ObjectStreamException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMulticastAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isAnyLocalAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isLoopbackAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isLinkLocalAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isSiteLocalAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMCGlobal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMCNodeLocal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMCLinkLocal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMCSiteLocal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isMCOrgLocal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isReachable(int timeout) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isReachable(java.net.NetworkInterface netif, int ttl, int timeout)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isReachableByICMP(int timeout) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getHostName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getCanonicalHostName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String getHostFromNameService(java.net.InetAddress addr) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public byte[] getAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getHostAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.net.InetAddress getByAddress(java.lang.String host, byte[] addr)
+ throws java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.net.InetAddress getByAddress(
+ java.lang.String host, byte[] addr, int scopeId) throws java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.net.InetAddress getByName(java.lang.String host)
+ throws java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.net.InetAddress[] getAllByName(java.lang.String host)
+ throws java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.net.InetAddress getLoopbackAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.net.InetAddress getByAddress(byte[] addr)
+ throws java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.net.InetAddress getLocalHost() throws java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.net.InetAddress anyLocalAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObjectNoData(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public static boolean isNumeric(java.lang.String address) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.net.InetAddress parseNumericAddressNoThrow(java.lang.String address) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.net.InetAddress disallowDeprecatedFormats(
+ java.lang.String address, java.net.InetAddress inetAddress) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public static java.net.InetAddress parseNumericAddress(java.lang.String numericAddress) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public static void clearDnsCache() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.net.InetAddress getByNameOnNet(java.lang.String host, int netId)
+ throws java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public static java.net.InetAddress[] getAllByNameOnNet(java.lang.String host, int netId)
+ throws java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.lang.ClassLoader BOOT_CLASSLOADER;
+
+ static {
+ BOOT_CLASSLOADER = null;
+ }
+
+ static final int NETID_UNSET = 0; // 0x0
+
+ private transient java.lang.String canonicalHostName;
+
+ @UnsupportedAppUsage
+ transient java.net.InetAddress.InetAddressHolder holder;
+
+ static final java.net.InetAddressImpl impl;
+
+ static {
+ impl = null;
+ }
+
+ private static final sun.net.spi.nameservice.NameService nameService;
+
+ static {
+ nameService = null;
+ }
+
+ private static final java.io.ObjectStreamField[] serialPersistentFields;
+
+ static {
+ serialPersistentFields = new java.io.ObjectStreamField[0];
+ }
+
+ private static final long serialVersionUID = 3286316764910316507L; // 0x2d9b57af9fe3ebdbL
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class InetAddressHolder {
+
+ InetAddressHolder() {
+ throw new RuntimeException("Stub!");
+ }
+
+ InetAddressHolder(java.lang.String hostName, int address, int family) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void init(java.lang.String hostName, int family) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.String getHostName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.String getOriginalHostName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ int getAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ int getFamily() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ int address;
+
+ @UnsupportedAppUsage
+ int family;
+
+ @UnsupportedAppUsage
+ java.lang.String hostName;
+
+ @UnsupportedAppUsage
+ java.lang.String originalHostName;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/net/InetSocketAddress.java b/ojluni/annotations/hiddenapi/java/net/InetSocketAddress.java
new file mode 100644
index 0000000..0a54f95
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/net/InetSocketAddress.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2000, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class InetSocketAddress extends java.net.SocketAddress {
+
+ public InetSocketAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public InetSocketAddress(int port) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public InetSocketAddress(java.net.InetAddress addr, int port) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public InetSocketAddress(java.lang.String hostname, int port) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private InetSocketAddress(int port, java.lang.String hostname) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int checkPort(int port) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String checkHost(java.lang.String hostname) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.net.InetSocketAddress createUnresolved(java.lang.String host, int port) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream in)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObjectNoData() throws java.io.ObjectStreamException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int getPort() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.net.InetAddress getAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String getHostName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String getHostString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean isUnresolved() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long FIELDS_OFFSET;
+
+ static {
+ FIELDS_OFFSET = 0;
+ }
+
+ private static final sun.misc.Unsafe UNSAFE;
+
+ static {
+ UNSAFE = null;
+ }
+
+ @UnsupportedAppUsage
+ private final transient java.net.InetSocketAddress.InetSocketAddressHolder holder;
+
+ {
+ holder = null;
+ }
+
+ private static final java.io.ObjectStreamField[] serialPersistentFields;
+
+ static {
+ serialPersistentFields = new java.io.ObjectStreamField[0];
+ }
+
+ private static final long serialVersionUID = 5076001401234631237L; // 0x467194616ff9aa45L
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class InetSocketAddressHolder {
+
+ private InetSocketAddressHolder(
+ java.lang.String hostname, java.net.InetAddress addr, int port) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int getPort() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.net.InetAddress getAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String getHostName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String getHostString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean isUnresolved() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.net.InetAddress addr;
+
+ private java.lang.String hostname;
+
+ private int port;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/net/InterfaceAddress.java b/ojluni/annotations/hiddenapi/java/net/InterfaceAddress.java
new file mode 100644
index 0000000..7287847
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/net/InterfaceAddress.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2005, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class InterfaceAddress {
+
+ @UnsupportedAppUsage
+ InterfaceAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ InterfaceAddress(
+ java.net.InetAddress address,
+ java.net.Inet4Address broadcast,
+ java.net.InetAddress netmask) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private short countPrefixLength(java.net.InetAddress netmask) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.InetAddress getAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.InetAddress getBroadcast() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public short getNetworkPrefixLength() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.net.InetAddress address;
+
+ private java.net.Inet4Address broadcast;
+
+ private short maskLength = 0; // 0x0
+}
diff --git a/ojluni/annotations/hiddenapi/java/net/Proxy.java b/ojluni/annotations/hiddenapi/java/net/Proxy.java
new file mode 100644
index 0000000..4df3fa4
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/net/Proxy.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2003, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Proxy {
+
+ @UnsupportedAppUsage
+ private Proxy() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Proxy(java.net.Proxy.Type type, java.net.SocketAddress sa) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.Proxy.Type type() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.SocketAddress address() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.net.Proxy NO_PROXY;
+
+ static {
+ NO_PROXY = null;
+ }
+
+ private java.net.SocketAddress sa;
+
+ private java.net.Proxy.Type type;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static enum Type {
+ DIRECT,
+ HTTP,
+ SOCKS;
+
+ private Type() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/net/ServerSocket.java b/ojluni/annotations/hiddenapi/java/net/ServerSocket.java
new file mode 100644
index 0000000..eabb247
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/net/ServerSocket.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 1995, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ServerSocket implements java.io.Closeable {
+
+ ServerSocket(java.net.SocketImpl impl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ServerSocket() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ServerSocket(int port) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ServerSocket(int port, int backlog) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ServerSocket(int port, int backlog, java.net.InetAddress bindAddr)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.SocketImpl getImpl() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkOldImpl() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void setImpl() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void createImpl() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void bind(java.net.SocketAddress endpoint) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void bind(java.net.SocketAddress endpoint, int backlog) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.InetAddress getInetAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getLocalPort() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.SocketAddress getLocalSocketAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.Socket accept() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final void implAccept(java.net.Socket s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void close() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.channels.ServerSocketChannel getChannel() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isBound() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isClosed() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setSoTimeout(int timeout) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int getSoTimeout() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setReuseAddress(boolean on) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean getReuseAddress() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setBound() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setCreated() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static synchronized void setSocketFactory(java.net.SocketImplFactory fac)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setReceiveBufferSize(int size) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int getReceiveBufferSize() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setPerformancePreferences(int connectionTime, int latency, int bandwidth) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.FileDescriptor getFileDescriptor$() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean bound = false;
+
+ private java.lang.Object closeLock;
+
+ private boolean closed = false;
+
+ private boolean created = false;
+
+ @UnsupportedAppUsage
+ private static java.net.SocketImplFactory factory;
+
+ private java.net.SocketImpl impl;
+
+ private boolean oldImpl = false;
+}
diff --git a/ojluni/annotations/hiddenapi/java/net/Socket.java b/ojluni/annotations/hiddenapi/java/net/Socket.java
new file mode 100644
index 0000000..2ad18ff
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/net/Socket.java
@@ -0,0 +1,320 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1995, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Socket implements java.io.Closeable {
+
+ public Socket() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Socket(java.net.Proxy proxy) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected Socket(java.net.SocketImpl impl) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Socket(java.lang.String host, int port)
+ throws java.io.IOException, java.net.UnknownHostException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Socket(java.net.InetAddress address, int port) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Socket(java.lang.String host, int port, java.net.InetAddress localAddr, int localPort)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Socket(
+ java.net.InetAddress address, int port, java.net.InetAddress localAddr, int localPort)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public Socket(java.lang.String host, int port, boolean stream) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public Socket(java.net.InetAddress host, int port, boolean stream) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private Socket(
+ java.net.InetAddress[] addresses,
+ int port,
+ java.net.SocketAddress localAddr,
+ boolean stream)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.net.InetAddress[] nonNullAddress(java.net.InetAddress address) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void createImpl(boolean stream) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkOldImpl() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setImpl() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.net.SocketImpl getImpl() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void connect(java.net.SocketAddress endpoint) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void connect(java.net.SocketAddress endpoint, int timeout) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void bind(java.net.SocketAddress bindpoint) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkAddress(java.net.InetAddress addr, java.lang.String op) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void postAccept() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setCreated() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setBound() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setConnected() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.InetAddress getInetAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.InetAddress getLocalAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getPort() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getLocalPort() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.SocketAddress getRemoteSocketAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.SocketAddress getLocalSocketAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.channels.SocketChannel getChannel() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.InputStream getInputStream() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.OutputStream getOutputStream() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setTcpNoDelay(boolean on) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean getTcpNoDelay() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setSoLinger(boolean on, int linger) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getSoLinger() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void sendUrgentData(int data) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setOOBInline(boolean on) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean getOOBInline() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setSoTimeout(int timeout) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int getSoTimeout() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setSendBufferSize(int size) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int getSendBufferSize() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setReceiveBufferSize(int size) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int getReceiveBufferSize() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setKeepAlive(boolean on) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean getKeepAlive() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setTrafficClass(int tc) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getTrafficClass() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setReuseAddress(boolean on) throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean getReuseAddress() throws java.net.SocketException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void close() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void shutdownInput() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void shutdownOutput() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isConnected() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isBound() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isClosed() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isInputShutdown() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isOutputShutdown() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static synchronized void setSocketImplFactory(java.net.SocketImplFactory fac)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setPerformancePreferences(int connectionTime, int latency, int bandwidth) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public java.io.FileDescriptor getFileDescriptor$() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean bound = false;
+
+ private java.lang.Object closeLock;
+
+ private boolean closed = false;
+
+ private boolean connected = false;
+
+ private boolean created = false;
+
+ @UnsupportedAppUsage
+ private static java.net.SocketImplFactory factory;
+
+ @UnsupportedAppUsage
+ java.net.SocketImpl impl;
+
+ private boolean oldImpl = false;
+
+ private boolean shutIn = false;
+
+ private boolean shutOut = false;
+}
diff --git a/ojluni/annotations/hiddenapi/java/net/SocketException.java b/ojluni/annotations/hiddenapi/java/net/SocketException.java
new file mode 100644
index 0000000..03e48e9
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/net/SocketException.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1995, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class SocketException extends java.io.IOException {
+
+ public SocketException(java.lang.String msg) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public SocketException() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public SocketException(java.lang.Throwable cause) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public SocketException(java.lang.String msg, java.lang.Throwable cause) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = -5935874303556886934L; // 0xad9f89c5411f5e6aL
+}
diff --git a/ojluni/annotations/hiddenapi/java/net/SocketImpl.java b/ojluni/annotations/hiddenapi/java/net/SocketImpl.java
new file mode 100644
index 0000000..be5c4f8
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/net/SocketImpl.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1995, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class SocketImpl implements java.net.SocketOptions {
+
+ public SocketImpl() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected abstract void create(boolean stream) throws java.io.IOException;
+
+ protected abstract void connect(java.lang.String host, int port) throws java.io.IOException;
+
+ protected abstract void connect(java.net.InetAddress address, int port)
+ throws java.io.IOException;
+
+ protected abstract void connect(java.net.SocketAddress address, int timeout)
+ throws java.io.IOException;
+
+ protected abstract void bind(java.net.InetAddress host, int port) throws java.io.IOException;
+
+ protected abstract void listen(int backlog) throws java.io.IOException;
+
+ protected abstract void accept(java.net.SocketImpl s) throws java.io.IOException;
+
+ protected abstract java.io.InputStream getInputStream() throws java.io.IOException;
+
+ protected abstract java.io.OutputStream getOutputStream() throws java.io.IOException;
+
+ protected abstract int available() throws java.io.IOException;
+
+ protected abstract void close() throws java.io.IOException;
+
+ protected void shutdownInput() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void shutdownOutput() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.io.FileDescriptor getFileDescriptor() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.FileDescriptor getFD$() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.net.InetAddress getInetAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected int getPort() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected boolean supportsUrgentData() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected abstract void sendUrgentData(int data) throws java.io.IOException;
+
+ protected int getLocalPort() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setSocket(java.net.Socket soc) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.net.Socket getSocket() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setServerSocket(java.net.ServerSocket soc) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.net.ServerSocket getServerSocket() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void reset() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void setPerformancePreferences(int connectionTime, int latency, int bandwidth) {
+ throw new RuntimeException("Stub!");
+ }
+
+ <T> void setOption(java.net.SocketOption<T> name, T value) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ <T> T getOption(java.net.SocketOption<T> name) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.net.InetAddress address;
+
+ protected java.io.FileDescriptor fd;
+
+ protected int localport;
+
+ protected int port;
+
+ @UnsupportedAppUsage
+ java.net.ServerSocket serverSocket;
+
+ @UnsupportedAppUsage
+ java.net.Socket socket;
+}
diff --git a/ojluni/annotations/hiddenapi/java/net/SocksSocketImpl.java b/ojluni/annotations/hiddenapi/java/net/SocksSocketImpl.java
new file mode 100644
index 0000000..6e0f66c
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/net/SocksSocketImpl.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2000, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+class SocksSocketImpl extends java.net.PlainSocketImpl implements java.net.SocksConsts {
+
+ @UnsupportedAppUsage
+ SocksSocketImpl() {
+ throw new RuntimeException("Stub!");
+ }
+
+ SocksSocketImpl(java.lang.String server, int port) {
+ throw new RuntimeException("Stub!");
+ }
+
+ SocksSocketImpl(java.net.Proxy proxy) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setV4() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized void privilegedConnect(java.lang.String host, int port, int timeout)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void superConnectServer(java.lang.String host, int port, int timeout)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int remainingMillis(long deadlineMillis) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int readSocksReply(java.io.InputStream in, byte[] data) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int readSocksReply(java.io.InputStream in, byte[] data, long deadlineMillis)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean authenticate(
+ byte method, java.io.InputStream in, java.io.BufferedOutputStream out)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean authenticate(
+ byte method,
+ java.io.InputStream in,
+ java.io.BufferedOutputStream out,
+ long deadlineMillis)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void connectV4(
+ java.io.InputStream in,
+ java.io.OutputStream out,
+ java.net.InetSocketAddress endpoint,
+ long deadlineMillis)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void connect(java.net.SocketAddress endpoint, int timeout)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.net.InetAddress getInetAddress() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected int getPort() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected int getLocalPort() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void close() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String getUserName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean applicationSetProxy;
+
+ private java.io.InputStream cmdIn;
+
+ private java.io.OutputStream cmdOut;
+
+ private java.net.Socket cmdsock;
+
+ private java.net.InetSocketAddress external_address;
+
+ private java.lang.String server;
+
+ private int serverPort = 1080; // 0x438
+
+ private boolean useV4 = false;
+}
diff --git a/ojluni/annotations/hiddenapi/java/net/URI.java b/ojluni/annotations/hiddenapi/java/net/URI.java
new file mode 100644
index 0000000..2287ab8
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/net/URI.java
@@ -0,0 +1,808 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2000, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class URI implements java.lang.Comparable<java.net.URI>, java.io.Serializable {
+
+ private URI() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public URI(java.lang.String str) throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public URI(
+ java.lang.String scheme,
+ java.lang.String userInfo,
+ java.lang.String host,
+ int port,
+ java.lang.String path,
+ java.lang.String query,
+ java.lang.String fragment)
+ throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public URI(
+ java.lang.String scheme,
+ java.lang.String authority,
+ java.lang.String path,
+ java.lang.String query,
+ java.lang.String fragment)
+ throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public URI(
+ java.lang.String scheme,
+ java.lang.String host,
+ java.lang.String path,
+ java.lang.String fragment)
+ throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public URI(java.lang.String scheme, java.lang.String ssp, java.lang.String fragment)
+ throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.net.URI create(java.lang.String str) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.URI parseServerAuthority() throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.URI normalize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.URI resolve(java.net.URI uri) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.URI resolve(java.lang.String str) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.URI relativize(java.net.URI uri) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.URL toURL() throws java.net.MalformedURLException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getScheme() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isAbsolute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isOpaque() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getRawSchemeSpecificPart() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getSchemeSpecificPart() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getRawAuthority() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getAuthority() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getRawUserInfo() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getUserInfo() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getHost() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getPort() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getRawPath() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getPath() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getRawQuery() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getQuery() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getRawFragment() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getFragment() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object ob) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compareTo(java.net.URI that) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toASCIIString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream os) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream is)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int toLower(char c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int toUpper(char c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean equal(java.lang.String s, java.lang.String t) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean equalIgnoringCase(java.lang.String s, java.lang.String t) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int hash(int hash, java.lang.String s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int normalizedHash(int hash, java.lang.String s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int hashIgnoringCase(int hash, java.lang.String s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int compare(java.lang.String s, java.lang.String t) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int compareIgnoringCase(java.lang.String s, java.lang.String t) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void checkPath(
+ java.lang.String s, java.lang.String scheme, java.lang.String path)
+ throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void appendAuthority(
+ java.lang.StringBuffer sb,
+ java.lang.String authority,
+ java.lang.String userInfo,
+ java.lang.String host,
+ int port) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void appendSchemeSpecificPart(
+ java.lang.StringBuffer sb,
+ java.lang.String opaquePart,
+ java.lang.String authority,
+ java.lang.String userInfo,
+ java.lang.String host,
+ int port,
+ java.lang.String path,
+ java.lang.String query) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void appendFragment(java.lang.StringBuffer sb, java.lang.String fragment) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String toString(
+ java.lang.String scheme,
+ java.lang.String opaquePart,
+ java.lang.String authority,
+ java.lang.String userInfo,
+ java.lang.String host,
+ int port,
+ java.lang.String path,
+ java.lang.String query,
+ java.lang.String fragment) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void defineSchemeSpecificPart() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void defineString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String resolvePath(
+ java.lang.String base, java.lang.String child, boolean absolute) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.net.URI resolve(java.net.URI base, java.net.URI child) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.net.URI normalize(java.net.URI u) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.net.URI relativize(java.net.URI base, java.net.URI child) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int needsNormalization(java.lang.String path) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void split(char[] path, int[] segs) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int join(char[] path, int[] segs) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void removeDots(char[] path, int[] segs, boolean removeLeading) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void maybeAddLeadingDot(char[] path, int[] segs) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String normalize(java.lang.String ps) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String normalize(java.lang.String ps, boolean removeLeading) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static long lowMask(java.lang.String chars) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static long highMask(java.lang.String chars) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static long lowMask(char first, char last) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static long highMask(char first, char last) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean match(char c, long lowMask, long highMask) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void appendEscape(java.lang.StringBuffer sb, byte b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void appendEncoded(java.lang.StringBuffer sb, char c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String quote(java.lang.String s, long lowMask, long highMask) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String encode(java.lang.String s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int decode(char c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static byte decode(char c1, char c2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String decode(java.lang.String s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long H_ALPHA;
+
+ static {
+ H_ALPHA = 0;
+ }
+
+ private static final long H_ALPHANUM;
+
+ static {
+ H_ALPHANUM = 0;
+ }
+
+ private static final long H_DASH;
+
+ static {
+ H_DASH = 0;
+ }
+
+ private static final long H_DIGIT = 0L; // 0x0L
+
+ private static final long H_DOT;
+
+ static {
+ H_DOT = 0;
+ }
+
+ private static final long H_ESCAPED = 0L; // 0x0L
+
+ private static final long H_HEX;
+
+ static {
+ H_HEX = 0;
+ }
+
+ private static final long H_LEFT_BRACKET;
+
+ static {
+ H_LEFT_BRACKET = 0;
+ }
+
+ private static final long H_LOWALPHA;
+
+ static {
+ H_LOWALPHA = 0;
+ }
+
+ private static final long H_MARK;
+
+ static {
+ H_MARK = 0;
+ }
+
+ private static final long H_PATH;
+
+ static {
+ H_PATH = 0;
+ }
+
+ private static final long H_PCHAR;
+
+ static {
+ H_PCHAR = 0;
+ }
+
+ private static final long H_REG_NAME;
+
+ static {
+ H_REG_NAME = 0;
+ }
+
+ private static final long H_RESERVED;
+
+ static {
+ H_RESERVED = 0;
+ }
+
+ private static final long H_SCHEME;
+
+ static {
+ H_SCHEME = 0;
+ }
+
+ private static final long H_SERVER;
+
+ static {
+ H_SERVER = 0;
+ }
+
+ private static final long H_SERVER_PERCENT;
+
+ static {
+ H_SERVER_PERCENT = 0;
+ }
+
+ private static final long H_UNDERSCORE;
+
+ static {
+ H_UNDERSCORE = 0;
+ }
+
+ private static final long H_UNRESERVED;
+
+ static {
+ H_UNRESERVED = 0;
+ }
+
+ private static final long H_UPALPHA;
+
+ static {
+ H_UPALPHA = 0;
+ }
+
+ private static final long H_URIC;
+
+ static {
+ H_URIC = 0;
+ }
+
+ private static final long H_URIC_NO_SLASH;
+
+ static {
+ H_URIC_NO_SLASH = 0;
+ }
+
+ private static final long H_USERINFO;
+
+ static {
+ H_USERINFO = 0;
+ }
+
+ private static final long L_ALPHA = 0L; // 0x0L
+
+ private static final long L_ALPHANUM;
+
+ static {
+ L_ALPHANUM = 0;
+ }
+
+ private static final long L_DASH;
+
+ static {
+ L_DASH = 0;
+ }
+
+ private static final long L_DIGIT;
+
+ static {
+ L_DIGIT = 0;
+ }
+
+ private static final long L_DOT;
+
+ static {
+ L_DOT = 0;
+ }
+
+ private static final long L_ESCAPED = 1L; // 0x1L
+
+ private static final long L_HEX;
+
+ static {
+ L_HEX = 0;
+ }
+
+ private static final long L_LEFT_BRACKET;
+
+ static {
+ L_LEFT_BRACKET = 0;
+ }
+
+ private static final long L_LOWALPHA = 0L; // 0x0L
+
+ private static final long L_MARK;
+
+ static {
+ L_MARK = 0;
+ }
+
+ private static final long L_PATH;
+
+ static {
+ L_PATH = 0;
+ }
+
+ private static final long L_PCHAR;
+
+ static {
+ L_PCHAR = 0;
+ }
+
+ private static final long L_REG_NAME;
+
+ static {
+ L_REG_NAME = 0;
+ }
+
+ private static final long L_RESERVED;
+
+ static {
+ L_RESERVED = 0;
+ }
+
+ private static final long L_SCHEME;
+
+ static {
+ L_SCHEME = 0;
+ }
+
+ private static final long L_SERVER;
+
+ static {
+ L_SERVER = 0;
+ }
+
+ private static final long L_SERVER_PERCENT;
+
+ static {
+ L_SERVER_PERCENT = 0;
+ }
+
+ private static final long L_UNDERSCORE;
+
+ static {
+ L_UNDERSCORE = 0;
+ }
+
+ private static final long L_UNRESERVED;
+
+ static {
+ L_UNRESERVED = 0;
+ }
+
+ private static final long L_UPALPHA = 0L; // 0x0L
+
+ private static final long L_URIC;
+
+ static {
+ L_URIC = 0;
+ }
+
+ private static final long L_URIC_NO_SLASH;
+
+ static {
+ L_URIC_NO_SLASH = 0;
+ }
+
+ private static final long L_USERINFO;
+
+ static {
+ L_USERINFO = 0;
+ }
+
+ private transient java.lang.String authority;
+
+ private transient volatile java.lang.String decodedAuthority;
+
+ private transient volatile java.lang.String decodedFragment;
+
+ private transient volatile java.lang.String decodedPath;
+
+ private transient volatile java.lang.String decodedQuery;
+
+ private transient volatile java.lang.String decodedSchemeSpecificPart;
+
+ private transient volatile java.lang.String decodedUserInfo;
+
+ @UnsupportedAppUsage
+ private transient java.lang.String fragment;
+
+ private transient volatile int hash;
+
+ private static final char[] hexDigits;
+
+ static {
+ hexDigits = new char[0];
+ }
+
+ @UnsupportedAppUsage
+ private transient java.lang.String host;
+
+ private transient java.lang.String path;
+
+ @UnsupportedAppUsage
+ private transient int port = -1; // 0xffffffff
+
+ @UnsupportedAppUsage
+ private transient java.lang.String query;
+
+ private transient java.lang.String scheme;
+
+ private transient volatile java.lang.String schemeSpecificPart;
+
+ static final long serialVersionUID = -6052424284110960213L; // 0xac01782e439e49abL
+
+ @UnsupportedAppUsage
+ private volatile java.lang.String string;
+
+ private transient java.lang.String userInfo;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class Parser {
+
+ Parser(java.lang.String s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void fail(java.lang.String reason) throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void fail(java.lang.String reason, int p) throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void failExpecting(java.lang.String expected, int p)
+ throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void failExpecting(java.lang.String expected, java.lang.String prior, int p)
+ throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String substring(int start, int end) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private char charAt(int p) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean at(int start, int end, char c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean at(int start, int end, java.lang.String s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int scan(int start, int end, char c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int scan(int start, int end, java.lang.String err, java.lang.String stop) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int scanEscape(int start, int n, char first) throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int scan(int start, int n, long lowMask, long highMask)
+ throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkChars(
+ int start, int end, long lowMask, long highMask, java.lang.String what)
+ throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkChar(int p, long lowMask, long highMask, java.lang.String what)
+ throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void parse(boolean rsa) throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int parseHierarchical(int start, int n) throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int parseAuthority(int start, int n) throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int parseServer(int start, int n) throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int scanByte(int start, int n) throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int scanIPv4Address(int start, int n, boolean strict)
+ throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int takeIPv4Address(int start, int n, java.lang.String expected)
+ throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int parseIPv4Address(int start, int n) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int parseHostname(int start, int n) throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int parseIPv6Reference(int start, int n) throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int scanHexPost(int start, int n) throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int scanHexSeq(int start, int n) throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String input;
+
+ private int ipv6byteCount = 0; // 0x0
+
+ private boolean requireServerAuthority = false;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/net/URL.java b/ojluni/annotations/hiddenapi/java/net/URL.java
new file mode 100644
index 0000000..905413c
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/net/URL.java
@@ -0,0 +1,280 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1995, 2015, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class URL implements java.io.Serializable {
+
+ public URL(java.lang.String protocol, java.lang.String host, int port, java.lang.String file)
+ throws java.net.MalformedURLException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public URL(java.lang.String protocol, java.lang.String host, java.lang.String file)
+ throws java.net.MalformedURLException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public URL(
+ java.lang.String protocol,
+ java.lang.String host,
+ int port,
+ java.lang.String file,
+ java.net.URLStreamHandler handler)
+ throws java.net.MalformedURLException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public URL(java.lang.String spec) throws java.net.MalformedURLException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public URL(java.net.URL context, java.lang.String spec) throws java.net.MalformedURLException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public URL(java.net.URL context, java.lang.String spec, java.net.URLStreamHandler handler)
+ throws java.net.MalformedURLException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean isValidProtocol(java.lang.String protocol) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkSpecifyHandler(java.lang.SecurityManager sm) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void set(
+ java.lang.String protocol,
+ java.lang.String host,
+ int port,
+ java.lang.String file,
+ java.lang.String ref) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void set(
+ java.lang.String protocol,
+ java.lang.String host,
+ int port,
+ java.lang.String authority,
+ java.lang.String userInfo,
+ java.lang.String path,
+ java.lang.String query,
+ java.lang.String ref) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getQuery() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getPath() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getUserInfo() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getAuthority() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getPort() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getDefaultPort() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getProtocol() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getHost() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getFile() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getRef() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean sameFile(java.net.URL other) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toExternalForm() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.URI toURI() throws java.net.URISyntaxException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.URLConnection openConnection() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.URLConnection openConnection(java.net.Proxy proxy) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.InputStream openStream() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object getContent() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object getContent(java.lang.Class[] classes) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void setURLStreamHandlerFactory(java.net.URLStreamHandlerFactory fac) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.net.URLStreamHandler getURLStreamHandler(java.lang.String protocol) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.net.URLStreamHandler createBuiltinHandler(java.lang.String protocol)
+ throws java.lang.ClassNotFoundException, java.lang.IllegalAccessException,
+ java.lang.InstantiationException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.util.Set<java.lang.String> createBuiltinHandlerClassNames() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readResolve() throws java.io.ObjectStreamException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.net.URL setDeserializedFields(java.net.URLStreamHandler handler) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.net.URL fabricateNewURL() throws java.io.InvalidObjectException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean isBuiltinStreamHandler(java.lang.String handlerClassName) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void resetState() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void setSerializedHashCode(int hc) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.util.Set<java.lang.String> BUILTIN_HANDLER_CLASS_NAMES;
+
+ static {
+ BUILTIN_HANDLER_CLASS_NAMES = null;
+ }
+
+ private java.lang.String authority;
+
+ @UnsupportedAppUsage
+ static java.net.URLStreamHandlerFactory factory;
+
+ private java.lang.String file;
+
+ @UnsupportedAppUsage
+ transient java.net.URLStreamHandler handler;
+
+ @UnsupportedAppUsage
+ static java.util.Hashtable<java.lang.String, java.net.URLStreamHandler> handlers;
+
+ private int hashCode = -1; // 0xffffffff
+
+ private java.lang.String host;
+
+ transient java.net.InetAddress hostAddress;
+
+ private transient java.lang.String path;
+
+ private int port = -1; // 0xffffffff
+
+ @UnsupportedAppUsage
+ private java.lang.String protocol;
+
+ private static final java.lang.String protocolPathProp = "java.protocol.handler.pkgs";
+
+ private transient java.lang.String query;
+
+ private java.lang.String ref;
+
+ private static final java.io.ObjectStreamField[] serialPersistentFields;
+
+ static {
+ serialPersistentFields = new java.io.ObjectStreamField[0];
+ }
+
+ static final long serialVersionUID = -7627629688361524110L; // 0x962537361afce472L
+
+ private static java.lang.Object streamHandlerLock;
+
+ private transient java.lang.String userInfo;
+}
diff --git a/ojluni/annotations/hiddenapi/java/net/URLClassLoader.java b/ojluni/annotations/hiddenapi/java/net/URLClassLoader.java
new file mode 100644
index 0000000..105b0c7
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/net/URLClassLoader.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 1997, 2015, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.net;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class URLClassLoader extends java.security.SecureClassLoader implements java.io.Closeable {
+
+ public URLClassLoader(java.net.URL[] urls, java.lang.ClassLoader parent) {
+ throw new RuntimeException("Stub!");
+ }
+
+ URLClassLoader(
+ java.net.URL[] urls,
+ java.lang.ClassLoader parent,
+ java.security.AccessControlContext acc) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public URLClassLoader(java.net.URL[] urls) {
+ throw new RuntimeException("Stub!");
+ }
+
+ URLClassLoader(java.net.URL[] urls, java.security.AccessControlContext acc) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public URLClassLoader(
+ java.net.URL[] urls,
+ java.lang.ClassLoader parent,
+ java.net.URLStreamHandlerFactory factory) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.io.InputStream getResourceAsStream(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void close() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void addURL(java.net.URL url) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.URL[] getURLs() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Class<?> findClass(java.lang.String name)
+ throws java.lang.ClassNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Package getAndVerifyPackage(
+ java.lang.String pkgname, java.util.jar.Manifest man, java.net.URL url) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void definePackageInternal(
+ java.lang.String pkgname, java.util.jar.Manifest man, java.net.URL url) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Class<?> defineClass(java.lang.String name, sun.misc.Resource res)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Package definePackage(
+ java.lang.String name, java.util.jar.Manifest man, java.net.URL url)
+ throws java.lang.IllegalArgumentException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean isSealed(java.lang.String name, java.util.jar.Manifest man) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.net.URL findResource(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Enumeration<java.net.URL> findResources(java.lang.String name)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.security.PermissionCollection getPermissions(
+ java.security.CodeSource codesource) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.net.URLClassLoader newInstance(
+ java.net.URL[] urls, java.lang.ClassLoader parent) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.net.URLClassLoader newInstance(java.net.URL[] urls) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private final java.security.AccessControlContext acc;
+
+ {
+ acc = null;
+ }
+
+ private java.util.WeakHashMap<java.io.Closeable, java.lang.Void> closeables;
+
+ @UnsupportedAppUsage
+ private final sun.misc.URLClassPath ucp;
+
+ {
+ ucp = null;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/nio/Buffer.java b/ojluni/annotations/hiddenapi/java/nio/Buffer.java
new file mode 100644
index 0000000..cbcd8c1
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/nio/Buffer.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2000, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.nio;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class Buffer {
+
+ Buffer(int mark, int pos, int lim, int cap, int elementSizeShift) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int capacity() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int position() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.Buffer position(int newPosition) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int limit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.Buffer limit(int newLimit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.Buffer mark() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.Buffer reset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.Buffer clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.Buffer flip() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.Buffer rewind() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int remaining() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean hasRemaining() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract boolean isReadOnly();
+
+ public abstract boolean hasArray();
+
+ public abstract java.lang.Object array();
+
+ public abstract int arrayOffset();
+
+ public abstract boolean isDirect();
+
+ final int nextGetIndex() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int nextGetIndex(int nb) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int nextPutIndex() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int nextPutIndex(int nb) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int checkIndex(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int checkIndex(int i, int nb) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int markValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void truncate() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void discardMark() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static void checkBounds(int off, int len, int size) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getElementSizeShift() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final int SPLITERATOR_CHARACTERISTICS = 16464; // 0x4050
+
+ @UnsupportedAppUsage
+ final int _elementSizeShift;
+
+ {
+ _elementSizeShift = 0;
+ }
+
+ @UnsupportedAppUsage
+ long address;
+
+ @UnsupportedAppUsage
+ private int capacity;
+
+ @UnsupportedAppUsage
+ private int limit;
+
+ private int mark = -1; // 0xffffffff
+
+ @UnsupportedAppUsage
+ int position = 0; // 0x0
+}
diff --git a/ojluni/annotations/hiddenapi/java/nio/ByteBuffer.java b/ojluni/annotations/hiddenapi/java/nio/ByteBuffer.java
new file mode 100644
index 0000000..65b6d58
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/nio/ByteBuffer.java
@@ -0,0 +1,285 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2000, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+// -- This file was mechanically generated: Do not edit! -- //
+
+package java.nio;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class ByteBuffer extends java.nio.Buffer
+ implements java.lang.Comparable<java.nio.ByteBuffer> {
+
+ ByteBuffer(int mark, int pos, int lim, int cap, byte[] hb, int offset) {
+ super(0, 0, 0, 0, 0);
+ throw new RuntimeException("Stub!");
+ }
+
+ ByteBuffer(int mark, int pos, int lim, int cap) {
+ super(0, 0, 0, 0, 0);
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.nio.ByteBuffer allocateDirect(int capacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.nio.ByteBuffer allocate(int capacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.nio.ByteBuffer wrap(byte[] array, int offset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.nio.ByteBuffer wrap(byte[] array) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.nio.ByteBuffer slice();
+
+ public abstract java.nio.ByteBuffer duplicate();
+
+ public abstract java.nio.ByteBuffer asReadOnlyBuffer();
+
+ public abstract byte get();
+
+ public abstract java.nio.ByteBuffer put(byte b);
+
+ public abstract byte get(int index);
+
+ public abstract java.nio.ByteBuffer put(int index, byte b);
+
+ public java.nio.ByteBuffer get(byte[] dst, int offset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.ByteBuffer get(byte[] dst) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.ByteBuffer put(java.nio.ByteBuffer src) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.ByteBuffer put(byte[] src, int offset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer put(byte[] src) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean hasArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final byte[] array() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int arrayOffset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.nio.ByteBuffer compact();
+
+ public abstract boolean isDirect();
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object ob) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean equals(byte x, byte y) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compareTo(java.nio.ByteBuffer that) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int compare(byte x, byte y) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteOrder order() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer order(java.nio.ByteOrder bo) {
+ throw new RuntimeException("Stub!");
+ }
+
+ abstract byte _get(int i);
+
+ abstract void _put(int i, byte b);
+
+ public abstract char getChar();
+
+ public abstract java.nio.ByteBuffer putChar(char value);
+
+ public abstract char getChar(int index);
+
+ abstract char getCharUnchecked(int index);
+
+ abstract void getUnchecked(int pos, char[] dst, int dstOffset, int length);
+
+ public abstract java.nio.ByteBuffer putChar(int index, char value);
+
+ abstract void putCharUnchecked(int index, char value);
+
+ abstract void putUnchecked(int pos, char[] dst, int srcOffset, int length);
+
+ public abstract java.nio.CharBuffer asCharBuffer();
+
+ public abstract short getShort();
+
+ public abstract java.nio.ByteBuffer putShort(short value);
+
+ public abstract short getShort(int index);
+
+ abstract short getShortUnchecked(int index);
+
+ abstract void getUnchecked(int pos, short[] dst, int dstOffset, int length);
+
+ public abstract java.nio.ByteBuffer putShort(int index, short value);
+
+ abstract void putShortUnchecked(int index, short value);
+
+ abstract void putUnchecked(int pos, short[] dst, int srcOffset, int length);
+
+ public abstract java.nio.ShortBuffer asShortBuffer();
+
+ public abstract int getInt();
+
+ public abstract java.nio.ByteBuffer putInt(int value);
+
+ public abstract int getInt(int index);
+
+ abstract int getIntUnchecked(int index);
+
+ abstract void getUnchecked(int pos, int[] dst, int dstOffset, int length);
+
+ public abstract java.nio.ByteBuffer putInt(int index, int value);
+
+ abstract void putIntUnchecked(int index, int value);
+
+ abstract void putUnchecked(int pos, int[] dst, int srcOffset, int length);
+
+ public abstract java.nio.IntBuffer asIntBuffer();
+
+ public abstract long getLong();
+
+ public abstract java.nio.ByteBuffer putLong(long value);
+
+ public abstract long getLong(int index);
+
+ abstract long getLongUnchecked(int index);
+
+ abstract void getUnchecked(int pos, long[] dst, int dstOffset, int length);
+
+ public abstract java.nio.ByteBuffer putLong(int index, long value);
+
+ abstract void putLongUnchecked(int index, long value);
+
+ abstract void putUnchecked(int pos, long[] dst, int srcOffset, int length);
+
+ public abstract java.nio.LongBuffer asLongBuffer();
+
+ public abstract float getFloat();
+
+ public abstract java.nio.ByteBuffer putFloat(float value);
+
+ public abstract float getFloat(int index);
+
+ abstract float getFloatUnchecked(int index);
+
+ abstract void getUnchecked(int pos, float[] dst, int dstOffset, int length);
+
+ public abstract java.nio.ByteBuffer putFloat(int index, float value);
+
+ abstract void putFloatUnchecked(int index, float value);
+
+ abstract void putUnchecked(int pos, float[] dst, int srcOffset, int length);
+
+ public abstract java.nio.FloatBuffer asFloatBuffer();
+
+ public abstract double getDouble();
+
+ public abstract java.nio.ByteBuffer putDouble(double value);
+
+ public abstract double getDouble(int index);
+
+ abstract double getDoubleUnchecked(int index);
+
+ abstract void getUnchecked(int pos, double[] dst, int dstOffset, int length);
+
+ public abstract java.nio.ByteBuffer putDouble(int index, double value);
+
+ abstract void putDoubleUnchecked(int index, double value);
+
+ abstract void putUnchecked(int pos, double[] dst, int srcOffset, int length);
+
+ public abstract java.nio.DoubleBuffer asDoubleBuffer();
+
+ public boolean isAccessible() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setAccessible(boolean value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean bigEndian = true;
+
+ @UnsupportedAppUsage
+ final byte[] hb;
+
+ {
+ hb = new byte[0];
+ }
+
+ @UnsupportedAppUsage
+ boolean isReadOnly;
+
+ boolean nativeByteOrder;
+
+ @UnsupportedAppUsage
+ final int offset;
+
+ {
+ offset = 0;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/nio/CharBuffer.java b/ojluni/annotations/hiddenapi/java/nio/CharBuffer.java
new file mode 100644
index 0000000..891e8c3
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/nio/CharBuffer.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2000, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+// -- This file was mechanically generated: Do not edit! -- //
+
+package java.nio;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class CharBuffer extends java.nio.Buffer
+ implements java.lang.Comparable<java.nio.CharBuffer>,
+ java.lang.Appendable,
+ java.lang.CharSequence,
+ java.lang.Readable {
+
+ CharBuffer(int mark, int pos, int lim, int cap, char[] hb, int offset) {
+ super(0, 0, 0, 0, 0);
+ throw new RuntimeException("Stub!");
+ }
+
+ CharBuffer(int mark, int pos, int lim, int cap) {
+ super(0, 0, 0, 0, 0);
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.nio.CharBuffer allocate(int capacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.nio.CharBuffer wrap(char[] array, int offset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.nio.CharBuffer wrap(char[] array) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int read(java.nio.CharBuffer target) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.nio.CharBuffer wrap(java.lang.CharSequence csq, int start, int end) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.nio.CharBuffer wrap(java.lang.CharSequence csq) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.nio.CharBuffer slice();
+
+ public abstract java.nio.CharBuffer duplicate();
+
+ public abstract java.nio.CharBuffer asReadOnlyBuffer();
+
+ public abstract char get();
+
+ public abstract java.nio.CharBuffer put(char c);
+
+ public abstract char get(int index);
+
+ abstract char getUnchecked(int index);
+
+ public abstract java.nio.CharBuffer put(int index, char c);
+
+ public java.nio.CharBuffer get(char[] dst, int offset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.CharBuffer get(char[] dst) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.CharBuffer put(java.nio.CharBuffer src) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.CharBuffer put(char[] src, int offset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.CharBuffer put(char[] src) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.CharBuffer put(java.lang.String src, int start, int end) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.CharBuffer put(java.lang.String src) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean hasArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final char[] array() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int arrayOffset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.nio.CharBuffer compact();
+
+ public abstract boolean isDirect();
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object ob) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean equals(char x, char y) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compareTo(java.nio.CharBuffer that) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int compare(char x, char y) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ abstract java.lang.String toString(int start, int end);
+
+ public final int length() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final char charAt(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.nio.CharBuffer subSequence(int start, int end);
+
+ public java.nio.CharBuffer append(java.lang.CharSequence csq) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.CharBuffer append(java.lang.CharSequence csq, int start, int end) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.CharBuffer append(char c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.nio.ByteOrder order();
+
+ public java.util.stream.IntStream chars() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final char[] hb;
+
+ {
+ hb = new char[0];
+ }
+
+ boolean isReadOnly;
+
+ final int offset;
+
+ {
+ offset = 0;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/nio/DirectByteBuffer.java b/ojluni/annotations/hiddenapi/java/nio/DirectByteBuffer.java
new file mode 100644
index 0000000..6624f0c
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/nio/DirectByteBuffer.java
@@ -0,0 +1,477 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2000, 2011, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.nio;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class DirectByteBuffer extends java.nio.MappedByteBuffer implements sun.nio.ch.DirectBuffer {
+
+ DirectByteBuffer(int capacity, java.nio.DirectByteBuffer.MemoryRef memoryRef) {
+ super(0, 0, 0, 0);
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private DirectByteBuffer(long addr, int cap) {
+ super(0, 0, 0, 0);
+ throw new RuntimeException("Stub!");
+ }
+
+ public DirectByteBuffer(
+ int cap,
+ long addr,
+ java.io.FileDescriptor fd,
+ java.lang.Runnable unmapper,
+ boolean isReadOnly) {
+ super(0, 0, 0, 0);
+ throw new RuntimeException("Stub!");
+ }
+
+ DirectByteBuffer(
+ java.nio.DirectByteBuffer.MemoryRef memoryRef,
+ int mark,
+ int pos,
+ int lim,
+ int cap,
+ int off) {
+ super(0, 0, 0, 0);
+ throw new RuntimeException("Stub!");
+ }
+
+ DirectByteBuffer(
+ java.nio.DirectByteBuffer.MemoryRef memoryRef,
+ int mark,
+ int pos,
+ int lim,
+ int cap,
+ int off,
+ boolean isReadOnly) {
+ super(0, 0, 0, 0);
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.Object attachment() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final sun.misc.Cleaner cleaner() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer slice() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer duplicate() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer asReadOnlyBuffer() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final long address() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private long ix(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private byte get(long a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final byte get() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final byte get(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.ByteBuffer get(byte[] dst, int dstOffset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.nio.ByteBuffer put(long a, byte x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.ByteBuffer put(java.nio.ByteBuffer src) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer put(byte x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer put(int i, byte x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.ByteBuffer put(byte[] src, int srcOffset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer compact() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean isDirect() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean isReadOnly() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final byte _get(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void _put(int i, byte b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final char getChar() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final char getChar(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ char getCharUnchecked(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void getUnchecked(int pos, char[] dst, int dstOffset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.nio.ByteBuffer putChar(long a, char x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer putChar(char x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer putChar(int i, char x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void putCharUnchecked(int i, char x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void putUnchecked(int pos, char[] src, int srcOffset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.CharBuffer asCharBuffer() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private short getShort(long a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final short getShort() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final short getShort(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ short getShortUnchecked(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void getUnchecked(int pos, short[] dst, int dstOffset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.nio.ByteBuffer putShort(long a, short x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer putShort(short x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer putShort(int i, short x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void putShortUnchecked(int i, short x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void putUnchecked(int pos, short[] src, int srcOffset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ShortBuffer asShortBuffer() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int getInt(long a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getInt() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getInt(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int getIntUnchecked(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void getUnchecked(int pos, int[] dst, int dstOffset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.nio.ByteBuffer putInt(long a, int x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer putInt(int x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer putInt(int i, int x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void putIntUnchecked(int i, int x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void putUnchecked(int pos, int[] src, int srcOffset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.IntBuffer asIntBuffer() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private long getLong(long a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final long getLong() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final long getLong(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final long getLongUnchecked(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void getUnchecked(int pos, long[] dst, int dstOffset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.nio.ByteBuffer putLong(long a, long x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer putLong(long x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer putLong(int i, long x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void putLongUnchecked(int i, long x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void putUnchecked(int pos, long[] src, int srcOffset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.LongBuffer asLongBuffer() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private float getFloat(long a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final float getFloat() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final float getFloat(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final float getFloatUnchecked(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void getUnchecked(int pos, float[] dst, int dstOffset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.nio.ByteBuffer putFloat(long a, float x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer putFloat(float x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer putFloat(int i, float x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void putFloatUnchecked(int i, float x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void putUnchecked(int pos, float[] src, int srcOffset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.FloatBuffer asFloatBuffer() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private double getDouble(long a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final double getDouble() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final double getDouble(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final double getDoubleUnchecked(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void getUnchecked(int pos, double[] dst, int dstOffset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.nio.ByteBuffer putDouble(long a, double x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer putDouble(double x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer putDouble(int i, double x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void putDoubleUnchecked(int i, double x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void putUnchecked(int pos, double[] src, int srcOffset, int length) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.DoubleBuffer asDoubleBuffer() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean isAccessible() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void setAccessible(boolean value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final sun.misc.Cleaner cleaner;
+
+ {
+ cleaner = null;
+ }
+
+ final java.nio.DirectByteBuffer.MemoryRef memoryRef;
+
+ {
+ memoryRef = null;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MemoryRef {
+
+ MemoryRef(int capacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ MemoryRef(long allocatedAddress, java.lang.Object originalBufferObject) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void free() {
+ throw new RuntimeException("Stub!");
+ }
+
+ long allocatedAddress;
+
+ byte[] buffer;
+
+ boolean isAccessible;
+
+ boolean isFreed;
+
+ final int offset;
+
+ {
+ offset = 0;
+ }
+
+ final java.lang.Object originalBufferObject;
+
+ {
+ originalBufferObject = null;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/nio/charset/Charset.java b/ojluni/annotations/hiddenapi/java/nio/charset/Charset.java
new file mode 100644
index 0000000..daaa265
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/nio/charset/Charset.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2000, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.nio.charset;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class Charset implements java.lang.Comparable<java.nio.charset.Charset> {
+
+ protected Charset(java.lang.String canonicalName, java.lang.String[] aliases) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static boolean atBugLevel(java.lang.String bl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void checkName(java.lang.String s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void cache(java.lang.String charsetName, java.nio.charset.Charset cs) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.util.Iterator<java.nio.charset.spi.CharsetProvider> providers() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.nio.charset.Charset lookupViaProviders(java.lang.String charsetName) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.nio.charset.Charset lookup(java.lang.String charsetName) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.nio.charset.Charset lookup2(java.lang.String charsetName) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean isSupported(java.lang.String charsetName) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.nio.charset.Charset forName(java.lang.String charsetName) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.nio.charset.Charset forNameUEE(java.lang.String charsetName)
+ throws java.io.UnsupportedEncodingException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void put(
+ java.util.Iterator<java.nio.charset.Charset> i,
+ java.util.Map<java.lang.String, java.nio.charset.Charset> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.SortedMap<java.lang.String, java.nio.charset.Charset>
+ availableCharsets() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.nio.charset.Charset defaultCharset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String name() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.util.Set<java.lang.String> aliases() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String displayName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean isRegistered() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String displayName(java.util.Locale locale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract boolean contains(java.nio.charset.Charset cs);
+
+ public abstract java.nio.charset.CharsetDecoder newDecoder();
+
+ public abstract java.nio.charset.CharsetEncoder newEncoder();
+
+ public boolean canEncode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.CharBuffer decode(java.nio.ByteBuffer bb) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer encode(java.nio.CharBuffer cb) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.ByteBuffer encode(java.lang.String str) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int compareTo(java.nio.charset.Charset that) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean equals(java.lang.Object ob) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.util.Set<java.lang.String> aliasSet;
+
+ private final java.lang.String[] aliases;
+
+ {
+ aliases = new java.lang.String[0];
+ }
+
+ private static volatile java.lang.String bugLevel;
+
+ private static volatile java.util.Map.Entry<java.lang.String, java.nio.charset.Charset> cache1;
+
+ private static final java.util.HashMap<java.lang.String, java.nio.charset.Charset> cache2;
+
+ static {
+ cache2 = null;
+ }
+
+ @UnsupportedAppUsage
+ private static java.nio.charset.Charset defaultCharset;
+
+ private static java.lang.ThreadLocal<java.lang.ThreadLocal<?>> gate;
+
+ private final java.lang.String name;
+
+ {
+ name = null;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/nio/charset/CharsetEncoder.java b/ojluni/annotations/hiddenapi/java/nio/charset/CharsetEncoder.java
new file mode 100644
index 0000000..f053cae
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/nio/charset/CharsetEncoder.java
@@ -0,0 +1,195 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2000, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+// -- This file was mechanically generated: Do not edit! -- //
+
+package java.nio.charset;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class CharsetEncoder {
+
+ protected CharsetEncoder(
+ java.nio.charset.Charset cs,
+ float averageBytesPerChar,
+ float maxBytesPerChar,
+ byte[] replacement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ CharsetEncoder(
+ java.nio.charset.Charset cs,
+ float averageBytesPerChar,
+ float maxBytesPerChar,
+ byte[] replacement,
+ boolean trusted) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected CharsetEncoder(
+ java.nio.charset.Charset cs, float averageBytesPerChar, float maxBytesPerChar) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.charset.Charset charset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final byte[] replacement() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.charset.CharsetEncoder replaceWith(byte[] newReplacement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void implReplaceWith(byte[] newReplacement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isLegalReplacement(byte[] repl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.charset.CodingErrorAction malformedInputAction() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.charset.CharsetEncoder onMalformedInput(
+ java.nio.charset.CodingErrorAction newAction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void implOnMalformedInput(java.nio.charset.CodingErrorAction newAction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.charset.CodingErrorAction unmappableCharacterAction() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.charset.CharsetEncoder onUnmappableCharacter(
+ java.nio.charset.CodingErrorAction newAction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void implOnUnmappableCharacter(java.nio.charset.CodingErrorAction newAction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final float averageBytesPerChar() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final float maxBytesPerChar() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.charset.CoderResult encode(
+ java.nio.CharBuffer in, java.nio.ByteBuffer out, boolean endOfInput) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.charset.CoderResult flush(java.nio.ByteBuffer out) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.nio.charset.CoderResult implFlush(java.nio.ByteBuffer out) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.nio.charset.CharsetEncoder reset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void implReset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected abstract java.nio.charset.CoderResult encodeLoop(
+ java.nio.CharBuffer in, java.nio.ByteBuffer out);
+
+ public final java.nio.ByteBuffer encode(java.nio.CharBuffer in)
+ throws java.nio.charset.CharacterCodingException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private boolean canEncode(java.nio.CharBuffer cb) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean canEncode(char c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean canEncode(java.lang.CharSequence cs) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void throwIllegalStateException(int from, int to) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int ST_CODING = 1; // 0x1
+
+ private static final int ST_END = 2; // 0x2
+
+ private static final int ST_FLUSHED = 3; // 0x3
+
+ private static final int ST_RESET = 0; // 0x0
+
+ private final float averageBytesPerChar;
+
+ {
+ averageBytesPerChar = 0;
+ }
+
+ private java.lang.ref.WeakReference<java.nio.charset.CharsetDecoder> cachedDecoder;
+
+ private final java.nio.charset.Charset charset;
+
+ {
+ charset = null;
+ }
+
+ private java.nio.charset.CodingErrorAction malformedInputAction;
+
+ private final float maxBytesPerChar;
+
+ {
+ maxBytesPerChar = 0;
+ }
+
+ private byte[] replacement;
+
+ private int state = 0; // 0x0
+
+ private static java.lang.String[] stateNames;
+
+ private java.nio.charset.CodingErrorAction unmappableCharacterAction;
+}
diff --git a/ojluni/annotations/hiddenapi/java/security/KeyPairGenerator.java b/ojluni/annotations/hiddenapi/java/security/KeyPairGenerator.java
new file mode 100644
index 0000000..2dba7cd
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/security/KeyPairGenerator.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 1997, 2014, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.security;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class KeyPairGenerator extends java.security.KeyPairGeneratorSpi {
+
+ protected KeyPairGenerator(java.lang.String algorithm) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getAlgorithm() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static java.security.KeyPairGenerator getInstance(
+ sun.security.jca.GetInstance.Instance instance, java.lang.String algorithm) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.security.KeyPairGenerator getInstance(java.lang.String algorithm)
+ throws java.security.NoSuchAlgorithmException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.security.KeyPairGenerator getInstance(
+ java.lang.String algorithm, java.lang.String provider)
+ throws java.security.NoSuchAlgorithmException, java.security.NoSuchProviderException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.security.KeyPairGenerator getInstance(
+ java.lang.String algorithm, java.security.Provider provider)
+ throws java.security.NoSuchAlgorithmException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.security.Provider getProvider() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void disableFailover() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void initialize(int keysize) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void initialize(int keysize, java.security.SecureRandom random) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void initialize(java.security.spec.AlgorithmParameterSpec params)
+ throws java.security.InvalidAlgorithmParameterException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void initialize(
+ java.security.spec.AlgorithmParameterSpec params, java.security.SecureRandom random)
+ throws java.security.InvalidAlgorithmParameterException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.security.KeyPair genKeyPair() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.security.KeyPair generateKeyPair() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.lang.String algorithm;
+
+ {
+ algorithm = null;
+ }
+
+ java.security.Provider provider;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static final class Delegate extends java.security.KeyPairGenerator {
+
+ Delegate(java.security.KeyPairGeneratorSpi spi, java.lang.String algorithm) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ Delegate(
+ sun.security.jca.GetInstance.Instance instance,
+ java.util.Iterator<java.security.Provider.Service> serviceIterator,
+ java.lang.String algorithm) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.security.KeyPairGeneratorSpi nextSpi(
+ java.security.KeyPairGeneratorSpi oldSpi, boolean reinit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void disableFailover() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void initialize(int keysize, java.security.SecureRandom random) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void initialize(
+ java.security.spec.AlgorithmParameterSpec params, java.security.SecureRandom random)
+ throws java.security.InvalidAlgorithmParameterException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.security.KeyPair generateKeyPair() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int I_NONE = 1; // 0x1
+
+ private static final int I_PARAMS = 3; // 0x3
+
+ private static final int I_SIZE = 2; // 0x2
+
+ private int initKeySize;
+
+ private java.security.spec.AlgorithmParameterSpec initParams;
+
+ private java.security.SecureRandom initRandom;
+
+ private int initType;
+
+ private final java.lang.Object lock;
+
+ {
+ lock = null;
+ }
+
+ private java.util.Iterator<java.security.Provider.Service> serviceIterator;
+
+ private volatile java.security.KeyPairGeneratorSpi spi;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/security/KeyStore.java b/ojluni/annotations/hiddenapi/java/security/KeyStore.java
new file mode 100644
index 0000000..ae64169
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/security/KeyStore.java
@@ -0,0 +1,538 @@
+/*
+ * Copyright (c) 1997, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.security;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class KeyStore {
+
+ protected KeyStore(
+ java.security.KeyStoreSpi keyStoreSpi,
+ java.security.Provider provider,
+ java.lang.String type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.security.KeyStore getInstance(java.lang.String type)
+ throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.security.KeyStore getInstance(
+ java.lang.String type, java.lang.String provider)
+ throws java.security.KeyStoreException, java.security.NoSuchProviderException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.security.KeyStore getInstance(
+ java.lang.String type, java.security.Provider provider)
+ throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.lang.String getDefaultType() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.security.Provider getProvider() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String getType() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.security.Key getKey(java.lang.String alias, char[] password)
+ throws java.security.KeyStoreException, java.security.NoSuchAlgorithmException,
+ java.security.UnrecoverableKeyException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.security.cert.Certificate[] getCertificateChain(java.lang.String alias)
+ throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.security.cert.Certificate getCertificate(java.lang.String alias)
+ throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.util.Date getCreationDate(java.lang.String alias)
+ throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void setKeyEntry(
+ java.lang.String alias,
+ java.security.Key key,
+ char[] password,
+ java.security.cert.Certificate[] chain)
+ throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void setKeyEntry(
+ java.lang.String alias, byte[] key, java.security.cert.Certificate[] chain)
+ throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void setCertificateEntry(
+ java.lang.String alias, java.security.cert.Certificate cert)
+ throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void deleteEntry(java.lang.String alias) throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.util.Enumeration<java.lang.String> aliases()
+ throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean containsAlias(java.lang.String alias)
+ throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int size() throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean isKeyEntry(java.lang.String alias) throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean isCertificateEntry(java.lang.String alias)
+ throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String getCertificateAlias(java.security.cert.Certificate cert)
+ throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void store(java.io.OutputStream stream, char[] password)
+ throws java.security.cert.CertificateException, java.io.IOException,
+ java.security.KeyStoreException, java.security.NoSuchAlgorithmException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void store(java.security.KeyStore.LoadStoreParameter param)
+ throws java.security.cert.CertificateException, java.io.IOException,
+ java.security.KeyStoreException, java.security.NoSuchAlgorithmException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void load(java.io.InputStream stream, char[] password)
+ throws java.security.cert.CertificateException, java.io.IOException,
+ java.security.NoSuchAlgorithmException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void load(java.security.KeyStore.LoadStoreParameter param)
+ throws java.security.cert.CertificateException, java.io.IOException,
+ java.security.NoSuchAlgorithmException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.security.KeyStore.Entry getEntry(
+ java.lang.String alias, java.security.KeyStore.ProtectionParameter protParam)
+ throws java.security.KeyStoreException, java.security.NoSuchAlgorithmException,
+ java.security.UnrecoverableEntryException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void setEntry(
+ java.lang.String alias,
+ java.security.KeyStore.Entry entry,
+ java.security.KeyStore.ProtectionParameter protParam)
+ throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean entryInstanceOf(
+ java.lang.String alias,
+ java.lang.Class<? extends java.security.KeyStore.Entry> entryClass)
+ throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.lang.String KEYSTORE_TYPE = "keystore.type";
+
+ private boolean initialized = false;
+
+ @UnsupportedAppUsage
+ private java.security.KeyStoreSpi keyStoreSpi;
+
+ private java.security.Provider provider;
+
+ private java.lang.String type;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public abstract static class Builder {
+
+ protected Builder() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.security.KeyStore getKeyStore() throws java.security.KeyStoreException;
+
+ public abstract java.security.KeyStore.ProtectionParameter getProtectionParameter(
+ java.lang.String alias) throws java.security.KeyStoreException;
+
+ public static java.security.KeyStore.Builder newInstance(
+ java.security.KeyStore keyStore,
+ java.security.KeyStore.ProtectionParameter protectionParameter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.security.KeyStore.Builder newInstance(
+ java.lang.String type,
+ java.security.Provider provider,
+ java.io.File file,
+ java.security.KeyStore.ProtectionParameter protection) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.security.KeyStore.Builder newInstance(
+ java.lang.String type,
+ java.security.Provider provider,
+ java.security.KeyStore.ProtectionParameter protection) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final int MAX_CALLBACK_TRIES = 3; // 0x3
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static final class FileBuilder extends java.security.KeyStore.Builder {
+
+ FileBuilder(
+ java.lang.String type,
+ java.security.Provider provider,
+ java.io.File file,
+ java.security.KeyStore.ProtectionParameter protection,
+ java.security.AccessControlContext context) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized java.security.KeyStore getKeyStore()
+ throws java.security.KeyStoreException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized java.security.KeyStore.ProtectionParameter getProtectionParameter(
+ java.lang.String alias) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.security.AccessControlContext context;
+
+ {
+ context = null;
+ }
+
+ private final java.io.File file;
+
+ {
+ file = null;
+ }
+
+ private java.security.KeyStore.ProtectionParameter keyProtection;
+
+ private java.security.KeyStore keyStore;
+
+ private java.lang.Throwable oldException;
+
+ private java.security.KeyStore.ProtectionParameter protection;
+
+ private final java.security.Provider provider;
+
+ {
+ provider = null;
+ }
+
+ private final java.lang.String type;
+
+ {
+ type = null;
+ }
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static class CallbackHandlerProtection
+ implements java.security.KeyStore.ProtectionParameter {
+
+ public CallbackHandlerProtection(javax.security.auth.callback.CallbackHandler handler) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public javax.security.auth.callback.CallbackHandler getCallbackHandler() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final javax.security.auth.callback.CallbackHandler handler;
+
+ {
+ handler = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static interface Entry {
+
+ public default java.util.Set<java.security.KeyStore.Entry.Attribute> getAttributes() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static interface Attribute {
+
+ public java.lang.String getName();
+
+ public java.lang.String getValue();
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static interface LoadStoreParameter {
+
+ public java.security.KeyStore.ProtectionParameter getProtectionParameter();
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static class PasswordProtection
+ implements java.security.KeyStore.ProtectionParameter, javax.security.auth.Destroyable {
+
+ public PasswordProtection(char[] password) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public PasswordProtection(
+ char[] password,
+ java.lang.String protectionAlgorithm,
+ java.security.spec.AlgorithmParameterSpec protectionParameters) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getProtectionAlgorithm() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.security.spec.AlgorithmParameterSpec getProtectionParameters() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized char[] getPassword() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void destroy() throws javax.security.auth.DestroyFailedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized boolean isDestroyed() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private volatile boolean destroyed = false;
+
+ private final char[] password;
+
+ {
+ password = new char[0];
+ }
+
+ private final java.lang.String protectionAlgorithm;
+
+ {
+ protectionAlgorithm = null;
+ }
+
+ private final java.security.spec.AlgorithmParameterSpec protectionParameters;
+
+ {
+ protectionParameters = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static final class PrivateKeyEntry implements java.security.KeyStore.Entry {
+
+ public PrivateKeyEntry(
+ java.security.PrivateKey privateKey, java.security.cert.Certificate[] chain) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public PrivateKeyEntry(
+ java.security.PrivateKey privateKey,
+ java.security.cert.Certificate[] chain,
+ java.util.Set<java.security.KeyStore.Entry.Attribute> attributes) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.security.PrivateKey getPrivateKey() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.security.cert.Certificate[] getCertificateChain() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.security.cert.Certificate getCertificate() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<java.security.KeyStore.Entry.Attribute> getAttributes() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.Set<java.security.KeyStore.Entry.Attribute> attributes;
+
+ {
+ attributes = null;
+ }
+
+ private final java.security.cert.Certificate[] chain;
+
+ {
+ chain = new java.security.cert.Certificate[0];
+ }
+
+ private final java.security.PrivateKey privKey;
+
+ {
+ privKey = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static interface ProtectionParameter {}
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static final class SecretKeyEntry implements java.security.KeyStore.Entry {
+
+ public SecretKeyEntry(javax.crypto.SecretKey secretKey) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public SecretKeyEntry(
+ javax.crypto.SecretKey secretKey,
+ java.util.Set<java.security.KeyStore.Entry.Attribute> attributes) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public javax.crypto.SecretKey getSecretKey() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<java.security.KeyStore.Entry.Attribute> getAttributes() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.Set<java.security.KeyStore.Entry.Attribute> attributes;
+
+ {
+ attributes = null;
+ }
+
+ private final javax.crypto.SecretKey sKey;
+
+ {
+ sKey = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class SimpleLoadStoreParameter implements java.security.KeyStore.LoadStoreParameter {
+
+ SimpleLoadStoreParameter(java.security.KeyStore.ProtectionParameter protection) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.security.KeyStore.ProtectionParameter getProtectionParameter() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.security.KeyStore.ProtectionParameter protection;
+
+ {
+ protection = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static final class TrustedCertificateEntry implements java.security.KeyStore.Entry {
+
+ public TrustedCertificateEntry(java.security.cert.Certificate trustedCert) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public TrustedCertificateEntry(
+ java.security.cert.Certificate trustedCert,
+ java.util.Set<java.security.KeyStore.Entry.Attribute> attributes) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.security.cert.Certificate getTrustedCertificate() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<java.security.KeyStore.Entry.Attribute> getAttributes() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.Set<java.security.KeyStore.Entry.Attribute> attributes;
+
+ {
+ attributes = null;
+ }
+
+ private final java.security.cert.Certificate cert;
+
+ {
+ cert = null;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/security/Signature.java b/ojluni/annotations/hiddenapi/java/security/Signature.java
new file mode 100644
index 0000000..a249f65
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/security/Signature.java
@@ -0,0 +1,385 @@
+/*
+ * Copyright (c) 1996, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (C) 2014 The Android Open Source Project
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.security;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class Signature extends java.security.SignatureSpi {
+
+ protected Signature(java.lang.String algorithm) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.security.Signature getInstance(java.lang.String algorithm)
+ throws java.security.NoSuchAlgorithmException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static java.security.Signature getInstance(
+ sun.security.jca.GetInstance.Instance instance, java.lang.String algorithm) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean isSpi(java.security.Provider.Service s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.security.Signature getInstance(
+ java.lang.String algorithm, java.lang.String provider)
+ throws java.security.NoSuchAlgorithmException, java.security.NoSuchProviderException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.security.Signature getInstance(
+ java.lang.String algorithm, java.security.Provider provider)
+ throws java.security.NoSuchAlgorithmException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.security.Signature getInstanceRSA(java.security.Provider p)
+ throws java.security.NoSuchAlgorithmException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.security.Provider getProvider() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void chooseFirstProvider() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void initVerify(java.security.PublicKey publicKey)
+ throws java.security.InvalidKeyException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void initVerify(java.security.cert.Certificate certificate)
+ throws java.security.InvalidKeyException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void initSign(java.security.PrivateKey privateKey)
+ throws java.security.InvalidKeyException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void initSign(
+ java.security.PrivateKey privateKey, java.security.SecureRandom random)
+ throws java.security.InvalidKeyException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final byte[] sign() throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int sign(byte[] outbuf, int offset, int len)
+ throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean verify(byte[] signature) throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean verify(byte[] signature, int offset, int length)
+ throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void update(byte b) throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void update(byte[] data) throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void update(byte[] data, int off, int len)
+ throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void update(java.nio.ByteBuffer data) throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String getAlgorithm() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public final void setParameter(java.lang.String param, java.lang.Object value)
+ throws java.security.InvalidParameterException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void setParameter(java.security.spec.AlgorithmParameterSpec params)
+ throws java.security.InvalidAlgorithmParameterException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.security.AlgorithmParameters getParameters() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public final java.lang.Object getParameter(java.lang.String param)
+ throws java.security.InvalidParameterException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object clone() throws java.lang.CloneNotSupportedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.security.SignatureSpi getCurrentSpi() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.lang.String RSA_CIPHER = "RSA/ECB/PKCS1Padding";
+
+ private static final java.lang.String RSA_SIGNATURE = "NONEwithRSA";
+
+ protected static final int SIGN = 2; // 0x2
+
+ protected static final int UNINITIALIZED = 0; // 0x0
+
+ protected static final int VERIFY = 3; // 0x3
+
+ private java.lang.String algorithm;
+
+ java.security.Provider provider;
+
+ private static final java.util.List<sun.security.jca.ServiceId> rsaIds;
+
+ static {
+ rsaIds = null;
+ }
+
+ private static final java.util.Map<java.lang.String, java.lang.Boolean> signatureInfo;
+
+ static {
+ signatureInfo = null;
+ }
+
+ protected int state = 0; // 0x0
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class CipherAdapter extends java.security.SignatureSpi {
+
+ CipherAdapter(javax.crypto.Cipher cipher) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void engineInitVerify(java.security.PublicKey publicKey)
+ throws java.security.InvalidKeyException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void engineInitSign(java.security.PrivateKey privateKey)
+ throws java.security.InvalidKeyException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void engineInitSign(
+ java.security.PrivateKey privateKey, java.security.SecureRandom random)
+ throws java.security.InvalidKeyException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void engineUpdate(byte b) throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void engineUpdate(byte[] b, int off, int len)
+ throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected byte[] engineSign() throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected boolean engineVerify(byte[] sigBytes) throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void engineSetParameter(java.lang.String param, java.lang.Object value)
+ throws java.security.InvalidParameterException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Object engineGetParameter(java.lang.String param)
+ throws java.security.InvalidParameterException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final javax.crypto.Cipher cipher;
+
+ {
+ cipher = null;
+ }
+
+ private java.io.ByteArrayOutputStream data;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class Delegate extends java.security.Signature {
+
+ Delegate(java.security.SignatureSpi sigSpi, java.lang.String algorithm) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ Delegate(java.lang.String algorithm) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object clone() throws java.lang.CloneNotSupportedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.security.SignatureSpi newInstance(java.security.Provider.Service s)
+ throws java.security.NoSuchAlgorithmException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void chooseFirstProvider() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void chooseProvider(
+ int type, java.security.Key key, java.security.SecureRandom random)
+ throws java.security.InvalidKeyException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void init(
+ java.security.SignatureSpi spi,
+ int type,
+ java.security.Key key,
+ java.security.SecureRandom random)
+ throws java.security.InvalidKeyException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void engineInitVerify(java.security.PublicKey publicKey)
+ throws java.security.InvalidKeyException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void engineInitSign(java.security.PrivateKey privateKey)
+ throws java.security.InvalidKeyException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void engineInitSign(
+ java.security.PrivateKey privateKey, java.security.SecureRandom sr)
+ throws java.security.InvalidKeyException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void engineUpdate(byte b) throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void engineUpdate(byte[] b, int off, int len)
+ throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void engineUpdate(java.nio.ByteBuffer data) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected byte[] engineSign() throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected int engineSign(byte[] outbuf, int offset, int len)
+ throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected boolean engineVerify(byte[] sigBytes) throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected boolean engineVerify(byte[] sigBytes, int offset, int length)
+ throws java.security.SignatureException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void engineSetParameter(java.lang.String param, java.lang.Object value)
+ throws java.security.InvalidParameterException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void engineSetParameter(java.security.spec.AlgorithmParameterSpec params)
+ throws java.security.InvalidAlgorithmParameterException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Object engineGetParameter(java.lang.String param)
+ throws java.security.InvalidParameterException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.security.AlgorithmParameters engineGetParameters() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.security.SignatureSpi getCurrentSpi() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int I_PRIV = 2; // 0x2
+
+ private static final int I_PRIV_SR = 3; // 0x3
+
+ private static final int I_PUB = 1; // 0x1
+
+ private final java.lang.Object lock;
+
+ {
+ lock = null;
+ }
+
+ private java.security.SignatureSpi sigSpi;
+
+ private static int warnCount = 10; // 0xa
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/security/spec/ECParameterSpec.java b/ojluni/annotations/hiddenapi/java/security/spec/ECParameterSpec.java
new file mode 100644
index 0000000..db13a4b
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/security/spec/ECParameterSpec.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2003, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.security.spec;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ECParameterSpec implements java.security.spec.AlgorithmParameterSpec {
+
+ public ECParameterSpec(
+ java.security.spec.EllipticCurve curve,
+ java.security.spec.ECPoint g,
+ java.math.BigInteger n,
+ int h) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.security.spec.EllipticCurve getCurve() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.security.spec.ECPoint getGenerator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.math.BigInteger getOrder() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getCofactor() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public void setCurveName(java.lang.String curveName) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public java.lang.String getCurveName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.security.spec.EllipticCurve curve;
+
+ {
+ curve = null;
+ }
+
+ private java.lang.String curveName;
+
+ private final java.security.spec.ECPoint g;
+
+ {
+ g = null;
+ }
+
+ private final int h;
+
+ {
+ h = 0;
+ }
+
+ private final java.math.BigInteger n;
+
+ {
+ n = null;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/text/Collator.java b/ojluni/annotations/hiddenapi/java/text/Collator.java
new file mode 100644
index 0000000..82aa868
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/text/Collator.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1997, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * (C) Copyright Taligent, Inc. 1996-1998 - All Rights Reserved
+ * (C) Copyright IBM Corp. 1996-1998 - All Rights Reserved
+ *
+ * The original version of this source code and documentation is copyrighted
+ * and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
+ * materials are provided under terms of a License Agreement between Taligent
+ * and Sun. This technology is protected by multiple US and International
+ * patents. This notice and attribution to Taligent may not be removed.
+ * Taligent is a registered trademark of Taligent, Inc.
+ *
+ */
+
+package java.text;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class Collator
+ implements java.util.Comparator<java.lang.Object>, java.lang.Cloneable {
+
+ protected Collator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ Collator(android.icu.text.Collator icuColl) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static synchronized java.text.Collator getInstance() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static synchronized java.text.Collator getInstance(java.util.Locale desiredLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract int compare(java.lang.String source, java.lang.String target);
+
+ public int compare(java.lang.Object o1, java.lang.Object o2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.text.CollationKey getCollationKey(java.lang.String source);
+
+ public boolean equals(java.lang.String source, java.lang.String target) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int getStrength() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setStrength(int newStrength) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int getDecomposition() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setDecomposition(int decompositionMode) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static synchronized java.util.Locale[] getAvailableLocales() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int decompositionMode_Java_ICU(int mode) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int decompositionMode_ICU_Java(int mode) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object clone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object that) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract int hashCode();
+
+ public static final int CANONICAL_DECOMPOSITION = 1; // 0x1
+
+ public static final int FULL_DECOMPOSITION = 2; // 0x2
+
+ public static final int IDENTICAL = 3; // 0x3
+
+ public static final int NO_DECOMPOSITION = 0; // 0x0
+
+ public static final int PRIMARY = 0; // 0x0
+
+ public static final int SECONDARY = 1; // 0x1
+
+ public static final int TERTIARY = 2; // 0x2
+
+ @UnsupportedAppUsage
+ android.icu.text.Collator icuColl;
+}
diff --git a/ojluni/annotations/hiddenapi/java/text/DateFormat.java b/ojluni/annotations/hiddenapi/java/text/DateFormat.java
new file mode 100644
index 0000000..7a1973f
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/text/DateFormat.java
@@ -0,0 +1,375 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1996, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * (C) Copyright Taligent, Inc. 1996 - All Rights Reserved
+ * (C) Copyright IBM Corp. 1996 - All Rights Reserved
+ *
+ * The original version of this source code and documentation is copyrighted
+ * and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
+ * materials are provided under terms of a License Agreement between Taligent
+ * and Sun. This technology is protected by multiple US and International
+ * patents. This notice and attribution to Taligent may not be removed.
+ * Taligent is a registered trademark of Taligent, Inc.
+ *
+ */
+
+package java.text;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class DateFormat extends java.text.Format {
+
+ protected DateFormat() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.StringBuffer format(
+ java.lang.Object obj,
+ java.lang.StringBuffer toAppendTo,
+ java.text.FieldPosition fieldPosition) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.lang.StringBuffer format(
+ java.util.Date date,
+ java.lang.StringBuffer toAppendTo,
+ java.text.FieldPosition fieldPosition);
+
+ public final java.lang.String format(java.util.Date date) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Date parse(java.lang.String source) throws java.text.ParseException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.util.Date parse(java.lang.String source, java.text.ParsePosition pos);
+
+ public java.lang.Object parseObject(java.lang.String source, java.text.ParsePosition pos) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.DateFormat getTimeInstance() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.DateFormat getTimeInstance(int style) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.DateFormat getTimeInstance(int style, java.util.Locale aLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.DateFormat getDateInstance() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.DateFormat getDateInstance(int style) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.DateFormat getDateInstance(int style, java.util.Locale aLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.DateFormat getDateTimeInstance() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.DateFormat getDateTimeInstance(int dateStyle, int timeStyle) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.DateFormat getDateTimeInstance(
+ int dateStyle, int timeStyle, java.util.Locale aLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.DateFormat getInstance() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final void set24HourTimePref(java.lang.Boolean is24Hour) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Locale[] getAvailableLocales() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setCalendar(java.util.Calendar newCalendar) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Calendar getCalendar() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setNumberFormat(java.text.NumberFormat newNumberFormat) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.text.NumberFormat getNumberFormat() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setTimeZone(java.util.TimeZone zone) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.TimeZone getTimeZone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setLenient(boolean lenient) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isLenient() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object clone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.text.DateFormat get(
+ int timeStyle, int dateStyle, int flags, java.util.Locale loc) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final int AM_PM_FIELD = 14; // 0xe
+
+ public static final int DATE_FIELD = 3; // 0x3
+
+ public static final int DAY_OF_WEEK_FIELD = 9; // 0x9
+
+ public static final int DAY_OF_WEEK_IN_MONTH_FIELD = 11; // 0xb
+
+ public static final int DAY_OF_YEAR_FIELD = 10; // 0xa
+
+ public static final int DEFAULT = 2; // 0x2
+
+ public static final int ERA_FIELD = 0; // 0x0
+
+ public static final int FULL = 0; // 0x0
+
+ public static final int HOUR0_FIELD = 16; // 0x10
+
+ public static final int HOUR1_FIELD = 15; // 0xf
+
+ public static final int HOUR_OF_DAY0_FIELD = 5; // 0x5
+
+ public static final int HOUR_OF_DAY1_FIELD = 4; // 0x4
+
+ public static final int LONG = 1; // 0x1
+
+ public static final int MEDIUM = 2; // 0x2
+
+ public static final int MILLISECOND_FIELD = 8; // 0x8
+
+ public static final int MINUTE_FIELD = 6; // 0x6
+
+ public static final int MONTH_FIELD = 2; // 0x2
+
+ public static final int SECOND_FIELD = 7; // 0x7
+
+ public static final int SHORT = 3; // 0x3
+
+ public static final int TIMEZONE_FIELD = 17; // 0x11
+
+ public static final int WEEK_OF_MONTH_FIELD = 13; // 0xd
+
+ public static final int WEEK_OF_YEAR_FIELD = 12; // 0xc
+
+ public static final int YEAR_FIELD = 1; // 0x1
+
+ protected java.util.Calendar calendar;
+
+ @UnsupportedAppUsage
+ public static java.lang.Boolean is24Hour;
+
+ protected java.text.NumberFormat numberFormat;
+
+ private static final long serialVersionUID = 7218322306649953788L; // 0x642ca1e4c22615fcL
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static class Field extends java.text.Format.Field {
+
+ protected Field(java.lang.String name, int calendarField) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.text.DateFormat.Field ofCalendarField(int calendarField) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getCalendarField() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Object readResolve() throws java.io.InvalidObjectException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.DateFormat.Field AM_PM;
+
+ static {
+ AM_PM = null;
+ }
+
+ public static final java.text.DateFormat.Field DAY_OF_MONTH;
+
+ static {
+ DAY_OF_MONTH = null;
+ }
+
+ public static final java.text.DateFormat.Field DAY_OF_WEEK;
+
+ static {
+ DAY_OF_WEEK = null;
+ }
+
+ public static final java.text.DateFormat.Field DAY_OF_WEEK_IN_MONTH;
+
+ static {
+ DAY_OF_WEEK_IN_MONTH = null;
+ }
+
+ public static final java.text.DateFormat.Field DAY_OF_YEAR;
+
+ static {
+ DAY_OF_YEAR = null;
+ }
+
+ public static final java.text.DateFormat.Field ERA;
+
+ static {
+ ERA = null;
+ }
+
+ public static final java.text.DateFormat.Field HOUR0;
+
+ static {
+ HOUR0 = null;
+ }
+
+ public static final java.text.DateFormat.Field HOUR1;
+
+ static {
+ HOUR1 = null;
+ }
+
+ public static final java.text.DateFormat.Field HOUR_OF_DAY0;
+
+ static {
+ HOUR_OF_DAY0 = null;
+ }
+
+ public static final java.text.DateFormat.Field HOUR_OF_DAY1;
+
+ static {
+ HOUR_OF_DAY1 = null;
+ }
+
+ public static final java.text.DateFormat.Field MILLISECOND;
+
+ static {
+ MILLISECOND = null;
+ }
+
+ public static final java.text.DateFormat.Field MINUTE;
+
+ static {
+ MINUTE = null;
+ }
+
+ public static final java.text.DateFormat.Field MONTH;
+
+ static {
+ MONTH = null;
+ }
+
+ public static final java.text.DateFormat.Field SECOND;
+
+ static {
+ SECOND = null;
+ }
+
+ public static final java.text.DateFormat.Field TIME_ZONE;
+
+ static {
+ TIME_ZONE = null;
+ }
+
+ public static final java.text.DateFormat.Field WEEK_OF_MONTH;
+
+ static {
+ WEEK_OF_MONTH = null;
+ }
+
+ public static final java.text.DateFormat.Field WEEK_OF_YEAR;
+
+ static {
+ WEEK_OF_YEAR = null;
+ }
+
+ public static final java.text.DateFormat.Field YEAR;
+
+ static {
+ YEAR = null;
+ }
+
+ private int calendarField;
+
+ private static final java.text.DateFormat.Field[] calendarToFieldMapping;
+
+ static {
+ calendarToFieldMapping = new java.text.DateFormat.Field[0];
+ }
+
+ private static final java.util.Map<java.lang.String, java.text.DateFormat.Field>
+ instanceMap;
+
+ static {
+ instanceMap = null;
+ }
+
+ private static final long serialVersionUID = 7441350119349544720L; // 0x6744fc81f123e710L
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/text/DecimalFormatSymbols.java b/ojluni/annotations/hiddenapi/java/text/DecimalFormatSymbols.java
new file mode 100644
index 0000000..52395a9
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/text/DecimalFormatSymbols.java
@@ -0,0 +1,289 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1996, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
+ * (C) Copyright IBM Corp. 1996 - 1998 - All Rights Reserved
+ *
+ * The original version of this source code and documentation is copyrighted
+ * and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
+ * materials are provided under terms of a License Agreement between Taligent
+ * and Sun. This technology is protected by multiple US and International
+ * patents. This notice and attribution to Taligent may not be removed.
+ * Taligent is a registered trademark of Taligent, Inc.
+ *
+ */
+
+package java.text;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class DecimalFormatSymbols implements java.lang.Cloneable, java.io.Serializable {
+
+ public DecimalFormatSymbols() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public DecimalFormatSymbols(java.util.Locale locale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Locale[] getAvailableLocales() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.DecimalFormatSymbols getInstance() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.DecimalFormatSymbols getInstance(java.util.Locale locale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public char getZeroDigit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setZeroDigit(char zeroDigit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public char getGroupingSeparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setGroupingSeparator(char groupingSeparator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public char getDecimalSeparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setDecimalSeparator(char decimalSeparator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public char getPerMill() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setPerMill(char perMill) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public char getPercent() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public java.lang.String getPercentString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setPercent(char percent) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public char getDigit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setDigit(char digit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public char getPatternSeparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setPatternSeparator(char patternSeparator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getInfinity() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setInfinity(java.lang.String infinity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getNaN() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setNaN(java.lang.String NaN) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public char getMinusSign() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getMinusSignString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setMinusSign(char minusSign) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getCurrencySymbol() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setCurrencySymbol(java.lang.String currency) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getInternationalCurrencySymbol() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setInternationalCurrencySymbol(java.lang.String currencyCode) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Currency getCurrency() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setCurrency(java.util.Currency currency) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public char getMonetaryDecimalSeparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setMonetaryDecimalSeparator(char sep) {
+ throw new RuntimeException("Stub!");
+ }
+
+ char getExponentialSymbol() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getExponentSeparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setExponentialSymbol(char exp) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setExponentSeparator(java.lang.String exp) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object clone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void initialize(java.util.Locale locale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static char maybeStripMarkers(java.lang.String symbol, char fallback) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected android.icu.text.DecimalFormatSymbols getIcuDecimalFormatSymbols() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected static java.text.DecimalFormatSymbols fromIcuInstance(
+ android.icu.text.DecimalFormatSymbols dfs) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream stream) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream stream)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String NaN;
+
+ private transient android.icu.text.DecimalFormatSymbols cachedIcuDFS;
+
+ private transient java.util.Currency currency;
+
+ private java.lang.String currencySymbol;
+
+ private static final int currentSerialVersion = 3; // 0x3
+
+ private char decimalSeparator;
+
+ private char digit;
+
+ private char exponential;
+
+ private java.lang.String exponentialSeparator;
+
+ private char groupingSeparator;
+
+ private java.lang.String infinity;
+
+ private java.lang.String intlCurrencySymbol;
+
+ private java.util.Locale locale;
+
+ private char minusSign;
+
+ private char monetarySeparator;
+
+ private char patternSeparator;
+
+ private char perMill;
+
+ private char percent;
+
+ private static final java.io.ObjectStreamField[] serialPersistentFields;
+
+ static {
+ serialPersistentFields = new java.io.ObjectStreamField[0];
+ }
+
+ private int serialVersionOnStream = 3; // 0x3
+
+ static final long serialVersionUID = 5772796243397350300L; // 0x501d17990868939cL
+
+ private char zeroDigit;
+}
diff --git a/ojluni/annotations/hiddenapi/java/text/NumberFormat.java b/ojluni/annotations/hiddenapi/java/text/NumberFormat.java
new file mode 100644
index 0000000..a570716
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/text/NumberFormat.java
@@ -0,0 +1,343 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1996, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
+ * (C) Copyright IBM Corp. 1996 - 1998 - All Rights Reserved
+ *
+ * The original version of this source code and documentation is copyrighted
+ * and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
+ * materials are provided under terms of a License Agreement between Taligent
+ * and Sun. This technology is protected by multiple US and International
+ * patents. This notice and attribution to Taligent may not be removed.
+ * Taligent is a registered trademark of Taligent, Inc.
+ *
+ */
+
+package java.text;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class NumberFormat extends java.text.Format {
+
+ protected NumberFormat() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.StringBuffer format(
+ java.lang.Object number,
+ java.lang.StringBuffer toAppendTo,
+ java.text.FieldPosition pos) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.Object parseObject(
+ java.lang.String source, java.text.ParsePosition pos) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String format(double number) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String format(long number) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.lang.StringBuffer format(
+ double number, java.lang.StringBuffer toAppendTo, java.text.FieldPosition pos);
+
+ public abstract java.lang.StringBuffer format(
+ long number, java.lang.StringBuffer toAppendTo, java.text.FieldPosition pos);
+
+ public abstract java.lang.Number parse(
+ java.lang.String source, java.text.ParsePosition parsePosition);
+
+ public java.lang.Number parse(java.lang.String source) throws java.text.ParseException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isParseIntegerOnly() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setParseIntegerOnly(boolean value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.NumberFormat getInstance() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.text.NumberFormat getInstance(java.util.Locale inLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.NumberFormat getNumberInstance() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.text.NumberFormat getNumberInstance(java.util.Locale inLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.NumberFormat getIntegerInstance() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.text.NumberFormat getIntegerInstance(java.util.Locale inLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.NumberFormat getCurrencyInstance() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.text.NumberFormat getCurrencyInstance(java.util.Locale inLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.NumberFormat getPercentInstance() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.text.NumberFormat getPercentInstance(java.util.Locale inLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Locale[] getAvailableLocales() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object clone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isGroupingUsed() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setGroupingUsed(boolean newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getMaximumIntegerDigits() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setMaximumIntegerDigits(int newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getMinimumIntegerDigits() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setMinimumIntegerDigits(int newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getMaximumFractionDigits() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setMaximumFractionDigits(int newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getMinimumFractionDigits() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setMinimumFractionDigits(int newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Currency getCurrency() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setCurrency(java.util.Currency currency) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.math.RoundingMode getRoundingMode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setRoundingMode(java.math.RoundingMode roundingMode) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static java.text.NumberFormat getInstance(java.util.Locale desiredLocale, int choice) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream stream)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream stream) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int CURRENCYSTYLE = 1; // 0x1
+
+ public static final int FRACTION_FIELD = 1; // 0x1
+
+ private static final int INTEGERSTYLE = 3; // 0x3
+
+ public static final int INTEGER_FIELD = 0; // 0x0
+
+ private static final int NUMBERSTYLE = 0; // 0x0
+
+ private static final int PERCENTSTYLE = 2; // 0x2
+
+ static final int currentSerialVersion = 1; // 0x1
+
+ private boolean groupingUsed = true;
+
+ private byte maxFractionDigits = 3; // 0x3
+
+ private byte maxIntegerDigits = 40; // 0x28
+
+ private int maximumFractionDigits = 3; // 0x3
+
+ private int maximumIntegerDigits = 40; // 0x28
+
+ private byte minFractionDigits = 0; // 0x0
+
+ private byte minIntegerDigits = 1; // 0x1
+
+ private int minimumFractionDigits = 0; // 0x0
+
+ private int minimumIntegerDigits = 1; // 0x1
+
+ private boolean parseIntegerOnly = false;
+
+ private int serialVersionOnStream = 1; // 0x1
+
+ static final long serialVersionUID = -2308460125733713944L; // 0xdff6b3bf137d07e8L
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static class Field extends java.text.Format.Field {
+
+ protected Field(java.lang.String name) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Object readResolve() throws java.io.InvalidObjectException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.text.NumberFormat.Field CURRENCY;
+
+ static {
+ CURRENCY = null;
+ }
+
+ public static final java.text.NumberFormat.Field DECIMAL_SEPARATOR;
+
+ static {
+ DECIMAL_SEPARATOR = null;
+ }
+
+ public static final java.text.NumberFormat.Field EXPONENT;
+
+ static {
+ EXPONENT = null;
+ }
+
+ public static final java.text.NumberFormat.Field EXPONENT_SIGN;
+
+ static {
+ EXPONENT_SIGN = null;
+ }
+
+ public static final java.text.NumberFormat.Field EXPONENT_SYMBOL;
+
+ static {
+ EXPONENT_SYMBOL = null;
+ }
+
+ public static final java.text.NumberFormat.Field FRACTION;
+
+ static {
+ FRACTION = null;
+ }
+
+ public static final java.text.NumberFormat.Field GROUPING_SEPARATOR;
+
+ static {
+ GROUPING_SEPARATOR = null;
+ }
+
+ public static final java.text.NumberFormat.Field INTEGER;
+
+ static {
+ INTEGER = null;
+ }
+
+ public static final java.text.NumberFormat.Field PERCENT;
+
+ static {
+ PERCENT = null;
+ }
+
+ public static final java.text.NumberFormat.Field PERMILLE;
+
+ static {
+ PERMILLE = null;
+ }
+
+ public static final java.text.NumberFormat.Field SIGN;
+
+ static {
+ SIGN = null;
+ }
+
+ private static final java.util.Map<java.lang.String, java.text.NumberFormat.Field>
+ instanceMap;
+
+ static {
+ instanceMap = null;
+ }
+
+ private static final long serialVersionUID = 7494728892700160890L; // 0x6802a038193ff37aL
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/time/Duration.java b/ojluni/annotations/hiddenapi/java/time/Duration.java
new file mode 100644
index 0000000..3090adb
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/time/Duration.java
@@ -0,0 +1,379 @@
+/*
+ * Copyright (c) 2012, 2015, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Copyright (c) 2007-2012, Stephen Colebourne & Michael Nascimento Santos
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * * Neither the name of JSR-310 nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package java.time;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Duration
+ implements java.time.temporal.TemporalAmount,
+ java.lang.Comparable<java.time.Duration>,
+ java.io.Serializable {
+
+ private Duration(long seconds, int nanos) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.Duration ofDays(long days) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.Duration ofHours(long hours) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.Duration ofMinutes(long minutes) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.Duration ofSeconds(long seconds) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.Duration ofSeconds(long seconds, long nanoAdjustment) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.Duration ofMillis(long millis) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.Duration ofNanos(long nanos) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.Duration of(long amount, java.time.temporal.TemporalUnit unit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.Duration from(java.time.temporal.TemporalAmount amount) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.Duration parse(java.lang.CharSequence text) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static long parseNumber(
+ java.lang.CharSequence text,
+ java.lang.String parsed,
+ int multiplier,
+ java.lang.String errorText) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int parseFraction(
+ java.lang.CharSequence text, java.lang.String parsed, int negate) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.time.Duration create(
+ boolean negate,
+ long daysAsSecs,
+ long hoursAsSecs,
+ long minsAsSecs,
+ long secs,
+ int nanos) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.Duration between(
+ java.time.temporal.Temporal startInclusive, java.time.temporal.Temporal endExclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.time.Duration create(long seconds, int nanoAdjustment) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long get(java.time.temporal.TemporalUnit unit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.List<java.time.temporal.TemporalUnit> getUnits() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isZero() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isNegative() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getSeconds() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getNano() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration withSeconds(long seconds) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration withNanos(int nanoOfSecond) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration plus(java.time.Duration duration) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration plus(long amountToAdd, java.time.temporal.TemporalUnit unit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration plusDays(long daysToAdd) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration plusHours(long hoursToAdd) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration plusMinutes(long minutesToAdd) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration plusSeconds(long secondsToAdd) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration plusMillis(long millisToAdd) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration plusNanos(long nanosToAdd) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.time.Duration plus(long secondsToAdd, long nanosToAdd) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration minus(java.time.Duration duration) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration minus(long amountToSubtract, java.time.temporal.TemporalUnit unit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration minusDays(long daysToSubtract) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration minusHours(long hoursToSubtract) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration minusMinutes(long minutesToSubtract) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration minusSeconds(long secondsToSubtract) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration minusMillis(long millisToSubtract) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration minusNanos(long nanosToSubtract) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration multipliedBy(long multiplicand) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration dividedBy(long divisor) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private java.math.BigDecimal toSeconds() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.time.Duration create(java.math.BigDecimal seconds) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration negated() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Duration abs() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.temporal.Temporal addTo(java.time.temporal.Temporal temporal) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.temporal.Temporal subtractFrom(java.time.temporal.Temporal temporal) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long toDays() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long toHours() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long toMinutes() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long toMillis() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long toNanos() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compareTo(java.time.Duration otherDuration) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object otherDuration) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object writeReplace() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s) throws java.io.InvalidObjectException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void writeExternal(java.io.DataOutput out) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.time.Duration readExternal(java.io.DataInput in) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.math.BigInteger BI_NANOS_PER_SECOND;
+
+ static {
+ BI_NANOS_PER_SECOND = null;
+ }
+
+ private static final java.util.regex.Pattern PATTERN;
+
+ static {
+ PATTERN = null;
+ }
+
+ public static final java.time.Duration ZERO;
+
+ static {
+ ZERO = null;
+ }
+
+ private final int nanos;
+
+ {
+ nanos = 0;
+ }
+
+ private final long seconds;
+
+ {
+ seconds = 0;
+ }
+
+ private static final long serialVersionUID = 3078945930695997490L; // 0x2aba9d02d1c4f832L
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class DurationUnits {
+
+ private DurationUnits() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.util.List<java.time.temporal.TemporalUnit> UNITS;
+
+ static {
+ UNITS = null;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/time/OffsetDateTime.java b/ojluni/annotations/hiddenapi/java/time/OffsetDateTime.java
new file mode 100644
index 0000000..f95f12f
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/time/OffsetDateTime.java
@@ -0,0 +1,465 @@
+/*
+ * Copyright (c) 2012, 2015, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Copyright (c) 2007-2012, Stephen Colebourne & Michael Nascimento Santos
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * * Neither the name of JSR-310 nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package java.time;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class OffsetDateTime
+ implements java.time.temporal.Temporal,
+ java.time.temporal.TemporalAdjuster,
+ java.lang.Comparable<java.time.OffsetDateTime>,
+ java.io.Serializable {
+
+ @UnsupportedAppUsage
+ private OffsetDateTime(java.time.LocalDateTime dateTime, java.time.ZoneOffset offset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Comparator<java.time.OffsetDateTime> timeLineOrder() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int compareInstant(
+ java.time.OffsetDateTime datetime1, java.time.OffsetDateTime datetime2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.OffsetDateTime now() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.OffsetDateTime now(java.time.ZoneId zone) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.OffsetDateTime now(java.time.Clock clock) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.OffsetDateTime of(
+ java.time.LocalDate date, java.time.LocalTime time, java.time.ZoneOffset offset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.OffsetDateTime of(
+ java.time.LocalDateTime dateTime, java.time.ZoneOffset offset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.OffsetDateTime of(
+ int year,
+ int month,
+ int dayOfMonth,
+ int hour,
+ int minute,
+ int second,
+ int nanoOfSecond,
+ java.time.ZoneOffset offset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.OffsetDateTime ofInstant(
+ java.time.Instant instant, java.time.ZoneId zone) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.OffsetDateTime from(java.time.temporal.TemporalAccessor temporal) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.OffsetDateTime parse(java.lang.CharSequence text) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.OffsetDateTime parse(
+ java.lang.CharSequence text, java.time.format.DateTimeFormatter formatter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.time.OffsetDateTime with(
+ java.time.LocalDateTime dateTime, java.time.ZoneOffset offset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isSupported(java.time.temporal.TemporalField field) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isSupported(java.time.temporal.TemporalUnit unit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.temporal.ValueRange range(java.time.temporal.TemporalField field) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int get(java.time.temporal.TemporalField field) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getLong(java.time.temporal.TemporalField field) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.ZoneOffset getOffset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime withOffsetSameLocal(java.time.ZoneOffset offset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime withOffsetSameInstant(java.time.ZoneOffset offset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.LocalDateTime toLocalDateTime() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.LocalDate toLocalDate() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getYear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getMonthValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Month getMonth() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getDayOfMonth() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getDayOfYear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.DayOfWeek getDayOfWeek() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.LocalTime toLocalTime() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getHour() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getMinute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getSecond() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getNano() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime with(java.time.temporal.TemporalAdjuster adjuster) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime with(java.time.temporal.TemporalField field, long newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime withYear(int year) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime withMonth(int month) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime withDayOfMonth(int dayOfMonth) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime withDayOfYear(int dayOfYear) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime withHour(int hour) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime withMinute(int minute) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime withSecond(int second) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime withNano(int nanoOfSecond) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime truncatedTo(java.time.temporal.TemporalUnit unit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime plus(java.time.temporal.TemporalAmount amountToAdd) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime plus(long amountToAdd, java.time.temporal.TemporalUnit unit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime plusYears(long years) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime plusMonths(long months) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime plusWeeks(long weeks) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime plusDays(long days) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime plusHours(long hours) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime plusMinutes(long minutes) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime plusSeconds(long seconds) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime plusNanos(long nanos) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime minus(java.time.temporal.TemporalAmount amountToSubtract) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime minus(
+ long amountToSubtract, java.time.temporal.TemporalUnit unit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime minusYears(long years) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime minusMonths(long months) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime minusWeeks(long weeks) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime minusDays(long days) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime minusHours(long hours) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime minusMinutes(long minutes) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime minusSeconds(long seconds) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetDateTime minusNanos(long nanos) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <R> R query(java.time.temporal.TemporalQuery<R> query) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.temporal.Temporal adjustInto(java.time.temporal.Temporal temporal) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long until(
+ java.time.temporal.Temporal endExclusive, java.time.temporal.TemporalUnit unit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String format(java.time.format.DateTimeFormatter formatter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.ZonedDateTime atZoneSameInstant(java.time.ZoneId zone) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.ZonedDateTime atZoneSimilarLocal(java.time.ZoneId zone) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.OffsetTime toOffsetTime() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.ZonedDateTime toZonedDateTime() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.time.Instant toInstant() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long toEpochSecond() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compareTo(java.time.OffsetDateTime other) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isAfter(java.time.OffsetDateTime other) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isBefore(java.time.OffsetDateTime other) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEqual(java.time.OffsetDateTime other) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object writeReplace() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s) throws java.io.InvalidObjectException {
+ throw new RuntimeException("Stub!");
+ }
+
+ void writeExternal(java.io.ObjectOutput out) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.time.OffsetDateTime readExternal(java.io.ObjectInput in)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.time.OffsetDateTime MAX;
+
+ static {
+ MAX = null;
+ }
+
+ public static final java.time.OffsetDateTime MIN;
+
+ static {
+ MIN = null;
+ }
+
+ private final java.time.LocalDateTime dateTime;
+
+ {
+ dateTime = null;
+ }
+
+ private final java.time.ZoneOffset offset;
+
+ {
+ offset = null;
+ }
+
+ private static final long serialVersionUID = 2287754244819255394L; // 0x1fbfbc5d57d80062L
+}
diff --git a/ojluni/annotations/hiddenapi/java/time/ZoneId.java b/ojluni/annotations/hiddenapi/java/time/ZoneId.java
new file mode 100644
index 0000000..f3ae76a
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/time/ZoneId.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2012, 2015, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Copyright (c) 2007-2012, Stephen Colebourne & Michael Nascimento Santos
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * * Neither the name of JSR-310 nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package java.time;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class ZoneId implements java.io.Serializable {
+
+ ZoneId() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.ZoneId systemDefault() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Set<java.lang.String> getAvailableZoneIds() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.ZoneId of(
+ java.lang.String zoneId, java.util.Map<java.lang.String, java.lang.String> aliasMap) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.ZoneId of(java.lang.String zoneId) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.ZoneId ofOffset(java.lang.String prefix, java.time.ZoneOffset offset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ static java.time.ZoneId of(java.lang.String zoneId, boolean checkAvailable) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.time.ZoneId ofWithPrefix(
+ java.lang.String zoneId, int prefixLength, boolean checkAvailable) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.time.ZoneId from(java.time.temporal.TemporalAccessor temporal) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.lang.String getId();
+
+ public java.lang.String getDisplayName(
+ java.time.format.TextStyle style, java.util.Locale locale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.time.temporal.TemporalAccessor toTemporal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.time.zone.ZoneRules getRules();
+
+ public java.time.ZoneId normalized() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s) throws java.io.InvalidObjectException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object writeReplace() {
+ throw new RuntimeException("Stub!");
+ }
+
+ abstract void write(java.io.DataOutput out) throws java.io.IOException;
+
+ public static final java.util.Map<java.lang.String, java.lang.String> SHORT_IDS;
+
+ static {
+ SHORT_IDS = null;
+ }
+
+ private static final long serialVersionUID = 8352817235686L; // 0x798cab446e6L
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/ArrayDeque.java b/ojluni/annotations/hiddenapi/java/util/ArrayDeque.java
new file mode 100644
index 0000000..59315d8
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/ArrayDeque.java
@@ -0,0 +1,322 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Written by Josh Bloch of Google Inc. and released to the public domain,
+ * as explained at http://creativecommons.org/publicdomain/zero/1.0/.
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ArrayDeque<E> extends java.util.AbstractCollection<E>
+ implements java.util.Deque<E>, java.lang.Cloneable, java.io.Serializable {
+
+ public ArrayDeque() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ArrayDeque(int numElements) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ArrayDeque(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void allocateElements(int numElements) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void doubleCapacity() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void addFirst(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void addLast(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offerFirst(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offerLast(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E removeFirst() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E removeLast() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E pollFirst() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E pollLast() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E getFirst() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E getLast() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E peekFirst() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E peekLast() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeFirstOccurrence(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeLastOccurrence(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offer(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E poll() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E element() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E peek() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void push(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E pop() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkInvariants() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean delete(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> descendingIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ArrayDeque<E> clone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int MIN_INITIAL_CAPACITY = 8; // 0x8
+
+ @UnsupportedAppUsage
+ transient java.lang.Object[] elements;
+
+ @UnsupportedAppUsage
+ transient int head;
+
+ private static final long serialVersionUID = 2340985798034038923L; // 0x207cda2e240da08bL
+
+ @UnsupportedAppUsage
+ transient int tail;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class DeqIterator implements java.util.Iterator<E> {
+
+ private DeqIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int cursor;
+
+ private int fence;
+
+ private int lastRet = -1; // 0xffffffff
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class DeqSpliterator<E> implements java.util.Spliterator<E> {
+
+ DeqSpliterator(java.util.ArrayDeque<E> deq, int origin, int fence) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int getFence() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ArrayDeque.DeqSpliterator<E> trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super E> consumer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(java.util.function.Consumer<? super E> consumer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long estimateSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.ArrayDeque<E> deq;
+
+ {
+ deq = null;
+ }
+
+ private int fence;
+
+ private int index;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class DescendingIterator implements java.util.Iterator<E> {
+
+ private DescendingIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int cursor;
+
+ private int fence;
+
+ private int lastRet = -1; // 0xffffffff
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/ArrayList.java b/ojluni/annotations/hiddenapi/java/util/ArrayList.java
new file mode 100644
index 0000000..7457f1e
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/ArrayList.java
@@ -0,0 +1,431 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1997, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ArrayList<E> extends java.util.AbstractList<E>
+ implements java.util.List<E>,
+ java.util.RandomAccess,
+ java.lang.Cloneable,
+ java.io.Serializable {
+
+ public ArrayList(int initialCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ArrayList() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ArrayList(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void trimToSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void ensureCapacity(int minCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void ensureCapacityInternal(int minCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void ensureExplicitCapacity(int minCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void grow(int minCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int hugeCapacity(int minCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int indexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int lastIndexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object clone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E get(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E set(int index, E element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void add(int index, E element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E remove(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void fastRemove(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(int index, java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void removeRange(int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String outOfBoundsMsg(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean retainAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean batchRemove(java.util.Collection<?> c, boolean complement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ListIterator<E> listIterator(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ListIterator<E> listIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.List<E> subList(int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static void subListRangeCheck(int fromIndex, int toIndex, int size) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeIf(java.util.function.Predicate<? super E> filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void replaceAll(java.util.function.UnaryOperator<E> operator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void sort(java.util.Comparator<? super E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.lang.Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
+
+ static {
+ DEFAULTCAPACITY_EMPTY_ELEMENTDATA = new java.lang.Object[0];
+ }
+
+ private static final int DEFAULT_CAPACITY = 10; // 0xa
+
+ private static final java.lang.Object[] EMPTY_ELEMENTDATA;
+
+ static {
+ EMPTY_ELEMENTDATA = new java.lang.Object[0];
+ }
+
+ private static final int MAX_ARRAY_SIZE = 2147483639; // 0x7ffffff7
+
+ @UnsupportedAppUsage
+ transient java.lang.Object[] elementData;
+
+ private static final long serialVersionUID = 8683452581122892189L; // 0x7881d21d99c7619dL
+
+ @UnsupportedAppUsage
+ private int size;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ArrayListSpliterator<E> implements java.util.Spliterator<E> {
+
+ ArrayListSpliterator(
+ java.util.ArrayList<E> list, int origin, int fence, int expectedModCount) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int getFence() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ArrayList.ArrayListSpliterator<E> trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long estimateSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int expectedModCount;
+
+ private int fence;
+
+ private int index;
+
+ private final java.util.ArrayList<E> list;
+
+ {
+ list = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class Itr implements java.util.Iterator<E> {
+
+ private Itr() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super E> consumer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ int cursor;
+
+ int expectedModCount;
+
+ int lastRet = -1; // 0xffffffff
+
+ protected int limit;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class ListItr extends Itr implements java.util.ListIterator<E> {
+
+ ListItr(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasPrevious() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int nextIndex() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int previousIndex() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E previous() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void set(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class SubList extends java.util.AbstractList<E> implements java.util.RandomAccess {
+
+ SubList(java.util.AbstractList<E> parent, int offset, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E set(int index, E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E get(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void add(int index, E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E remove(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void removeRange(int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(int index, java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ListIterator<E> listIterator(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.List<E> subList(int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String outOfBoundsMsg(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private final int offset;
+
+ {
+ offset = 0;
+ }
+
+ @UnsupportedAppUsage
+ private final java.util.AbstractList<E> parent;
+
+ {
+ parent = null;
+ }
+
+ @UnsupportedAppUsage
+ private final int parentOffset;
+
+ {
+ parentOffset = 0;
+ }
+
+ @UnsupportedAppUsage
+ int size;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/Arrays.java b/ojluni/annotations/hiddenapi/java/util/Arrays.java
new file mode 100644
index 0000000..c763a2d
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/Arrays.java
@@ -0,0 +1,831 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1997, 2014, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Arrays {
+
+ private Arrays() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void rangeCheck(int arrayLength, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void sort(int[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void sort(int[] a, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void sort(long[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void sort(long[] a, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void sort(short[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void sort(short[] a, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void sort(char[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void sort(char[] a, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void sort(byte[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void sort(byte[] a, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void sort(float[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void sort(float[] a, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void sort(double[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void sort(double[] a, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelSort(byte[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelSort(byte[] a, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelSort(char[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelSort(char[] a, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelSort(short[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelSort(short[] a, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelSort(int[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelSort(int[] a, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelSort(long[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelSort(long[] a, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelSort(float[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelSort(float[] a, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelSort(double[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelSort(double[] a, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T extends java.lang.Comparable<? super T>> void parallelSort(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T extends java.lang.Comparable<? super T>> void parallelSort(
+ T[] a, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> void parallelSort(T[] a, java.util.Comparator<? super T> cmp) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> void parallelSort(
+ T[] a, int fromIndex, int toIndex, java.util.Comparator<? super T> cmp) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void sort(java.lang.Object[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void sort(java.lang.Object[] a, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void mergeSort(
+ java.lang.Object[] src, java.lang.Object[] dest, int low, int high, int off) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void swap(java.lang.Object[] x, int a, int b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> void sort(T[] a, java.util.Comparator<? super T> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> void sort(
+ T[] a, int fromIndex, int toIndex, java.util.Comparator<? super T> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> void parallelPrefix(T[] array, java.util.function.BinaryOperator<T> op) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> void parallelPrefix(
+ T[] array, int fromIndex, int toIndex, java.util.function.BinaryOperator<T> op) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelPrefix(long[] array, java.util.function.LongBinaryOperator op) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelPrefix(
+ long[] array, int fromIndex, int toIndex, java.util.function.LongBinaryOperator op) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelPrefix(double[] array, java.util.function.DoubleBinaryOperator op) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelPrefix(
+ double[] array,
+ int fromIndex,
+ int toIndex,
+ java.util.function.DoubleBinaryOperator op) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelPrefix(int[] array, java.util.function.IntBinaryOperator op) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelPrefix(
+ int[] array, int fromIndex, int toIndex, java.util.function.IntBinaryOperator op) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int binarySearch(long[] a, long key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int binarySearch(long[] a, int fromIndex, int toIndex, long key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int binarySearch0(long[] a, int fromIndex, int toIndex, long key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int binarySearch(int[] a, int key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int binarySearch(int[] a, int fromIndex, int toIndex, int key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int binarySearch(short[] a, short key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int binarySearch(short[] a, int fromIndex, int toIndex, short key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int binarySearch0(short[] a, int fromIndex, int toIndex, short key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int binarySearch(char[] a, char key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int binarySearch(char[] a, int fromIndex, int toIndex, char key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int binarySearch0(char[] a, int fromIndex, int toIndex, char key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int binarySearch(byte[] a, byte key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int binarySearch0(byte[] a, int fromIndex, int toIndex, byte key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int binarySearch(double[] a, double key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int binarySearch(double[] a, int fromIndex, int toIndex, double key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int binarySearch0(double[] a, int fromIndex, int toIndex, double key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int binarySearch(float[] a, float key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int binarySearch(float[] a, int fromIndex, int toIndex, float key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int binarySearch0(float[] a, int fromIndex, int toIndex, float key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int binarySearch(java.lang.Object[] a, java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int binarySearch(
+ java.lang.Object[] a, int fromIndex, int toIndex, java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int binarySearch0(
+ java.lang.Object[] a, int fromIndex, int toIndex, java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> int binarySearch(T[] a, T key, java.util.Comparator<? super T> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> int binarySearch(
+ T[] a, int fromIndex, int toIndex, T key, java.util.Comparator<? super T> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static <T> int binarySearch0(
+ T[] a, int fromIndex, int toIndex, T key, java.util.Comparator<? super T> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean equals(long[] a, long[] a2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean equals(int[] a, int[] a2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean equals(short[] a, short[] a2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean equals(char[] a, char[] a2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean equals(byte[] a, byte[] a2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean equals(boolean[] a, boolean[] a2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean equals(double[] a, double[] a2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean equals(float[] a, float[] a2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean equals(java.lang.Object[] a, java.lang.Object[] a2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(long[] a, long val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(long[] a, int fromIndex, int toIndex, long val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(int[] a, int val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(int[] a, int fromIndex, int toIndex, int val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(short[] a, short val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(short[] a, int fromIndex, int toIndex, short val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(char[] a, char val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(char[] a, int fromIndex, int toIndex, char val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(byte[] a, byte val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(byte[] a, int fromIndex, int toIndex, byte val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(boolean[] a, boolean val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(boolean[] a, int fromIndex, int toIndex, boolean val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(double[] a, double val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(double[] a, int fromIndex, int toIndex, double val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(float[] a, float val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(float[] a, int fromIndex, int toIndex, float val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(java.lang.Object[] a, java.lang.Object val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void fill(
+ java.lang.Object[] a, int fromIndex, int toIndex, java.lang.Object val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> T[] copyOf(T[] original, int newLength) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T, U> T[] copyOf(
+ U[] original, int newLength, java.lang.Class<? extends T[]> newType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static byte[] copyOf(byte[] original, int newLength) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static short[] copyOf(short[] original, int newLength) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int[] copyOf(int[] original, int newLength) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long[] copyOf(long[] original, int newLength) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static char[] copyOf(char[] original, int newLength) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static float[] copyOf(float[] original, int newLength) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static double[] copyOf(double[] original, int newLength) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean[] copyOf(boolean[] original, int newLength) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> T[] copyOfRange(T[] original, int from, int to) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T, U> T[] copyOfRange(
+ U[] original, int from, int to, java.lang.Class<? extends T[]> newType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static byte[] copyOfRange(byte[] original, int from, int to) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static short[] copyOfRange(short[] original, int from, int to) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int[] copyOfRange(int[] original, int from, int to) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static long[] copyOfRange(long[] original, int from, int to) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static char[] copyOfRange(char[] original, int from, int to) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static float[] copyOfRange(float[] original, int from, int to) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static double[] copyOfRange(double[] original, int from, int to) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean[] copyOfRange(boolean[] original, int from, int to) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.List<T> asList(T... a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int hashCode(long[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int hashCode(int[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int hashCode(short[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int hashCode(char[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int hashCode(byte[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int hashCode(boolean[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int hashCode(float[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int hashCode(double[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int hashCode(java.lang.Object[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int deepHashCode(java.lang.Object[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean deepEquals(java.lang.Object[] a1, java.lang.Object[] a2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static boolean deepEquals0(java.lang.Object e1, java.lang.Object e2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(long[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(int[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(short[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(char[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(byte[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(boolean[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(float[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(double[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String toString(java.lang.Object[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String deepToString(java.lang.Object[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static void deepToString(
+ java.lang.Object[] a,
+ java.lang.StringBuilder buf,
+ java.util.Set<java.lang.Object[]> dejaVu) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> void setAll(
+ T[] array, java.util.function.IntFunction<? extends T> generator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> void parallelSetAll(
+ T[] array, java.util.function.IntFunction<? extends T> generator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void setAll(int[] array, java.util.function.IntUnaryOperator generator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelSetAll(int[] array, java.util.function.IntUnaryOperator generator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void setAll(long[] array, java.util.function.IntToLongFunction generator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelSetAll(
+ long[] array, java.util.function.IntToLongFunction generator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void setAll(double[] array, java.util.function.IntToDoubleFunction generator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void parallelSetAll(
+ double[] array, java.util.function.IntToDoubleFunction generator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.Spliterator<T> spliterator(T[] array) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.Spliterator<T> spliterator(
+ T[] array, int startInclusive, int endExclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Spliterator.OfInt spliterator(int[] array) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Spliterator.OfInt spliterator(
+ int[] array, int startInclusive, int endExclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Spliterator.OfLong spliterator(long[] array) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Spliterator.OfLong spliterator(
+ long[] array, int startInclusive, int endExclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Spliterator.OfDouble spliterator(double[] array) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Spliterator.OfDouble spliterator(
+ double[] array, int startInclusive, int endExclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.stream.Stream<T> stream(T[] array) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.stream.Stream<T> stream(
+ T[] array, int startInclusive, int endExclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.stream.IntStream stream(int[] array) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.stream.IntStream stream(
+ int[] array, int startInclusive, int endExclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.stream.LongStream stream(long[] array) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.stream.LongStream stream(
+ long[] array, int startInclusive, int endExclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.stream.DoubleStream stream(double[] array) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.stream.DoubleStream stream(
+ double[] array, int startInclusive, int endExclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int INSERTIONSORT_THRESHOLD = 7; // 0x7
+
+ public static final int MIN_ARRAY_SORT_GRAN = 8192; // 0x2000
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class ArrayList<E> extends java.util.AbstractList<E>
+ implements java.util.RandomAccess, java.io.Serializable {
+
+ ArrayList(E[] array) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E get(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E set(int index, E element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int indexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void replaceAll(java.util.function.UnaryOperator<E> operator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void sort(java.util.Comparator<? super E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private final E[] a;
+
+ {
+ a = null;
+ }
+
+ private static final long serialVersionUID = -2764017481108945198L; // 0xd9a43cbecd8806d2L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class NaturalOrder implements java.util.Comparator<java.lang.Object> {
+
+ NaturalOrder() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compare(java.lang.Object first, java.lang.Object second) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.util.Arrays.NaturalOrder INSTANCE;
+
+ static {
+ INSTANCE = null;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/Calendar.java b/ojluni/annotations/hiddenapi/java/util/Calendar.java
new file mode 100644
index 0000000..99a76f7
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/Calendar.java
@@ -0,0 +1,734 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1996, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * (C) Copyright Taligent, Inc. 1996-1998 - All Rights Reserved
+ * (C) Copyright IBM Corp. 1996-1998 - All Rights Reserved
+ *
+ * The original version of this source code and documentation is copyrighted
+ * and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
+ * materials are provided under terms of a License Agreement between Taligent
+ * and Sun. This technology is protected by multiple US and International
+ * patents. This notice and attribution to Taligent may not be removed.
+ * Taligent is a registered trademark of Taligent, Inc.
+ *
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class Calendar
+ implements java.io.Serializable,
+ java.lang.Cloneable,
+ java.lang.Comparable<java.util.Calendar> {
+
+ protected Calendar() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected Calendar(java.util.TimeZone zone, java.util.Locale aLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Calendar getInstance() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Calendar getInstance(java.util.TimeZone zone) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Calendar getInstance(java.util.Locale aLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Calendar getInstance(
+ java.util.TimeZone zone, java.util.Locale aLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Calendar getJapaneseImperialInstance(
+ java.util.TimeZone zone, java.util.Locale aLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.util.Calendar createCalendar(
+ java.util.TimeZone zone, java.util.Locale aLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static synchronized java.util.Locale[] getAvailableLocales() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected abstract void computeTime();
+
+ protected abstract void computeFields();
+
+ public final java.util.Date getTime() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void setTime(java.util.Date date) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getTimeInMillis() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setTimeInMillis(long millis) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int get(int field) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final int internalGet(int field) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void internalSet(int field, int value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void set(int field, int value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void set(int year, int month, int date) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void set(int year, int month, int date, int hourOfDay, int minute) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void set(int year, int month, int date, int hourOfDay, int minute, int second) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void clear(int field) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean isSet(int field) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getDisplayName(int field, int style, java.util.Locale locale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map<java.lang.String, java.lang.Integer> getDisplayNames(
+ int field, int style, java.util.Locale locale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.util.Map<java.lang.String, java.lang.Integer> getDisplayNamesImpl(
+ int field, int style, java.util.Locale locale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean checkDisplayNameParams(
+ int field,
+ int style,
+ int minStyle,
+ int maxStyle,
+ java.util.Locale locale,
+ int fieldMask) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String[] getFieldStrings(
+ int field, int style, java.text.DateFormatSymbols symbols) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void complete() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final boolean isExternallySet(int field) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int getSetStateFields() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void setFieldsComputed(int fieldMask) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void setFieldsNormalized(int fieldMask) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final boolean isPartiallyNormalized() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final boolean isFullyNormalized() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void setUnnormalized() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static boolean isFieldSet(int fieldMask, int field) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int selectFields() {
+ throw new RuntimeException("Stub!");
+ }
+
+ int getBaseStyle(int style) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int toStandaloneStyle(int style) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean isStandaloneStyle(int style) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean isNarrowStyle(int style) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean isNarrowFormatStyle(int style) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int aggregateStamp(int stamp_a, int stamp_b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Set<java.lang.String> getAvailableCalendarTypes() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getCalendarType() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean before(java.lang.Object when) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean after(java.lang.Object when) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compareTo(java.util.Calendar anotherCalendar) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract void add(int field, int amount);
+
+ public abstract void roll(int field, boolean up);
+
+ public void roll(int field, int amount) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setTimeZone(java.util.TimeZone value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.TimeZone getTimeZone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.TimeZone getZone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setZoneShared(boolean shared) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setLenient(boolean lenient) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isLenient() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setFirstDayOfWeek(int value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getFirstDayOfWeek() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setMinimalDaysInFirstWeek(int value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getMinimalDaysInFirstWeek() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isWeekDateSupported() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getWeekYear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setWeekDate(int weekYear, int weekOfYear, int dayOfWeek) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getWeeksInWeekYear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract int getMinimum(int field);
+
+ public abstract int getMaximum(int field);
+
+ public abstract int getGreatestMinimum(int field);
+
+ public abstract int getLeastMaximum(int field);
+
+ public int getActualMinimum(int field) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getActualMaximum(int field) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object clone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.lang.String getFieldName(int field) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void appendValue(
+ java.lang.StringBuilder sb, java.lang.String item, boolean valid, long value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void setWeekCountData(java.util.Locale desiredLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void updateTime() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int compareTo(long t) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static long getMillisOf(java.util.Calendar calendar) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void adjustStamp() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void invalidateWeekFields() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized void writeObject(java.io.ObjectOutputStream stream)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream stream)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.time.Instant toInstant() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final int ALL_FIELDS = 131071; // 0x1ffff
+
+ public static final int ALL_STYLES = 0; // 0x0
+
+ public static final int AM = 0; // 0x0
+
+ public static final int AM_PM = 9; // 0x9
+
+ static final int AM_PM_MASK = 512; // 0x200
+
+ public static final int APRIL = 3; // 0x3
+
+ public static final int AUGUST = 7; // 0x7
+
+ private static final int COMPUTED = 1; // 0x1
+
+ public static final int DATE = 5; // 0x5
+
+ static final int DATE_MASK = 32; // 0x20
+
+ public static final int DAY_OF_MONTH = 5; // 0x5
+
+ static final int DAY_OF_MONTH_MASK = 32; // 0x20
+
+ public static final int DAY_OF_WEEK = 7; // 0x7
+
+ public static final int DAY_OF_WEEK_IN_MONTH = 8; // 0x8
+
+ static final int DAY_OF_WEEK_IN_MONTH_MASK = 256; // 0x100
+
+ static final int DAY_OF_WEEK_MASK = 128; // 0x80
+
+ public static final int DAY_OF_YEAR = 6; // 0x6
+
+ static final int DAY_OF_YEAR_MASK = 64; // 0x40
+
+ public static final int DECEMBER = 11; // 0xb
+
+ public static final int DST_OFFSET = 16; // 0x10
+
+ static final int DST_OFFSET_MASK = 65536; // 0x10000
+
+ public static final int ERA = 0; // 0x0
+
+ static final int ERA_MASK = 1; // 0x1
+
+ public static final int FEBRUARY = 1; // 0x1
+
+ public static final int FIELD_COUNT = 17; // 0x11
+
+ private static final java.lang.String[] FIELD_NAME;
+
+ static {
+ FIELD_NAME = new java.lang.String[0];
+ }
+
+ public static final int FRIDAY = 6; // 0x6
+
+ public static final int HOUR = 10; // 0xa
+
+ static final int HOUR_MASK = 1024; // 0x400
+
+ public static final int HOUR_OF_DAY = 11; // 0xb
+
+ static final int HOUR_OF_DAY_MASK = 2048; // 0x800
+
+ public static final int JANUARY = 0; // 0x0
+
+ public static final int JULY = 6; // 0x6
+
+ public static final int JUNE = 5; // 0x5
+
+ public static final int LONG = 2; // 0x2
+
+ public static final int LONG_FORMAT = 2; // 0x2
+
+ public static final int LONG_STANDALONE = 32770; // 0x8002
+
+ public static final int MARCH = 2; // 0x2
+
+ public static final int MAY = 4; // 0x4
+
+ public static final int MILLISECOND = 14; // 0xe
+
+ static final int MILLISECOND_MASK = 16384; // 0x4000
+
+ private static final int MINIMUM_USER_STAMP = 2; // 0x2
+
+ public static final int MINUTE = 12; // 0xc
+
+ static final int MINUTE_MASK = 4096; // 0x1000
+
+ public static final int MONDAY = 2; // 0x2
+
+ public static final int MONTH = 2; // 0x2
+
+ static final int MONTH_MASK = 4; // 0x4
+
+ public static final int NARROW_FORMAT = 4; // 0x4
+
+ public static final int NARROW_STANDALONE = 32772; // 0x8004
+
+ public static final int NOVEMBER = 10; // 0xa
+
+ public static final int OCTOBER = 9; // 0x9
+
+ public static final int PM = 1; // 0x1
+
+ public static final int SATURDAY = 7; // 0x7
+
+ public static final int SECOND = 13; // 0xd
+
+ static final int SECOND_MASK = 8192; // 0x2000
+
+ public static final int SEPTEMBER = 8; // 0x8
+
+ public static final int SHORT = 1; // 0x1
+
+ public static final int SHORT_FORMAT = 1; // 0x1
+
+ public static final int SHORT_STANDALONE = 32769; // 0x8001
+
+ static final int STANDALONE_MASK = 32768; // 0x8000
+
+ public static final int SUNDAY = 1; // 0x1
+
+ public static final int THURSDAY = 5; // 0x5
+
+ public static final int TUESDAY = 3; // 0x3
+
+ public static final int UNDECIMBER = 12; // 0xc
+
+ private static final int UNSET = 0; // 0x0
+
+ public static final int WEDNESDAY = 4; // 0x4
+
+ public static final int WEEK_OF_MONTH = 4; // 0x4
+
+ static final int WEEK_OF_MONTH_MASK = 16; // 0x10
+
+ public static final int WEEK_OF_YEAR = 3; // 0x3
+
+ static final int WEEK_OF_YEAR_MASK = 8; // 0x8
+
+ public static final int YEAR = 1; // 0x1
+
+ static final int YEAR_MASK = 2; // 0x2
+
+ public static final int ZONE_OFFSET = 15; // 0xf
+
+ static final int ZONE_OFFSET_MASK = 32768; // 0x8000
+
+ transient boolean areAllFieldsSet;
+
+ protected boolean areFieldsSet;
+
+ private static final java.util.concurrent.ConcurrentMap<java.util.Locale, int[]>
+ cachedLocaleData;
+
+ static {
+ cachedLocaleData = null;
+ }
+
+ static final int currentSerialVersion = 1; // 0x1
+
+ protected int[] fields;
+
+ private int firstDayOfWeek;
+
+ protected boolean[] isSet;
+
+ protected boolean isTimeSet;
+
+ private boolean lenient = true;
+
+ private int minimalDaysInFirstWeek;
+
+ private int nextStamp = 2; // 0x2
+
+ private int serialVersionOnStream = 1; // 0x1
+
+ static final long serialVersionUID = -1807547505821590642L; // 0xe6ea4d1ec8dc5b8eL
+
+ private transient boolean sharedZone = false;
+
+ private transient int[] stamp;
+
+ protected long time;
+
+ @UnsupportedAppUsage
+ private java.util.TimeZone zone;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class AvailableCalendarTypes {
+
+ private AvailableCalendarTypes() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.util.Set<java.lang.String> SET;
+
+ static {
+ SET = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static class Builder {
+
+ public Builder() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Calendar.Builder setInstant(long instant) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Calendar.Builder setInstant(java.util.Date instant) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Calendar.Builder set(int field, int value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Calendar.Builder setFields(int... fieldValuePairs) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Calendar.Builder setDate(int year, int month, int dayOfMonth) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Calendar.Builder setTimeOfDay(int hourOfDay, int minute, int second) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Calendar.Builder setTimeOfDay(
+ int hourOfDay, int minute, int second, int millis) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Calendar.Builder setWeekDate(int weekYear, int weekOfYear, int dayOfWeek) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Calendar.Builder setTimeZone(java.util.TimeZone zone) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Calendar.Builder setLenient(boolean lenient) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Calendar.Builder setCalendarType(java.lang.String type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Calendar.Builder setLocale(java.util.Locale locale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Calendar.Builder setWeekDefinition(
+ int firstDayOfWeek, int minimalDaysInFirstWeek) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Calendar build() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void allocateFields() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void internalSet(int field, int value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean isInstantSet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean isSet(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean isValidWeekParameter(int value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int NFIELDS = 18; // 0x12
+
+ private static final int WEEK_YEAR = 17; // 0x11
+
+ private int[] fields;
+
+ private int firstDayOfWeek;
+
+ private long instant;
+
+ private boolean lenient = true;
+
+ private java.util.Locale locale;
+
+ private int maxFieldIndex;
+
+ private int minimalDaysInFirstWeek;
+
+ private int nextStamp;
+
+ private java.lang.String type;
+
+ private java.util.TimeZone zone;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class CalendarAccessControlContext {
+
+ private CalendarAccessControlContext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.security.AccessControlContext INSTANCE;
+
+ static {
+ INSTANCE = null;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/Collections.java b/ojluni/annotations/hiddenapi/java/util/Collections.java
new file mode 100644
index 0000000..010ba3d
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/Collections.java
@@ -0,0 +1,3651 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1997, 2014, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Collections {
+
+ private Collections() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T extends java.lang.Comparable<? super T>> void sort(java.util.List<T> list) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> void sort(java.util.List<T> list, java.util.Comparator<? super T> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> int binarySearch(
+ java.util.List<? extends java.lang.Comparable<? super T>> list, T key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static <T> int indexedBinarySearch(
+ java.util.List<? extends java.lang.Comparable<? super T>> list, T key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static <T> int iteratorBinarySearch(
+ java.util.List<? extends java.lang.Comparable<? super T>> list, T key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static <T> T get(java.util.ListIterator<? extends T> i, int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> int binarySearch(
+ java.util.List<? extends T> list, T key, java.util.Comparator<? super T> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static <T> int indexedBinarySearch(
+ java.util.List<? extends T> l, T key, java.util.Comparator<? super T> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static <T> int iteratorBinarySearch(
+ java.util.List<? extends T> l, T key, java.util.Comparator<? super T> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void reverse(java.util.List<?> list) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void shuffle(java.util.List<?> list) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void shuffle(java.util.List<?> list, java.util.Random rnd) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void swap(java.util.List<?> list, int i, int j) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void swap(java.lang.Object[] arr, int i, int j) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> void fill(java.util.List<? super T> list, T obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> void copy(java.util.List<? super T> dest, java.util.List<? extends T> src) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T extends java.lang.Object & java.lang.Comparable<? super T>> T min(
+ java.util.Collection<? extends T> coll) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> T min(
+ java.util.Collection<? extends T> coll, java.util.Comparator<? super T> comp) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T extends java.lang.Object & java.lang.Comparable<? super T>> T max(
+ java.util.Collection<? extends T> coll) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> T max(
+ java.util.Collection<? extends T> coll, java.util.Comparator<? super T> comp) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static void rotate(java.util.List<?> list, int distance) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static <T> void rotate1(java.util.List<T> list, int distance) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void rotate2(java.util.List<?> list, int distance) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> boolean replaceAll(java.util.List<T> list, T oldVal, T newVal) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int indexOfSubList(java.util.List<?> source, java.util.List<?> target) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int lastIndexOfSubList(java.util.List<?> source, java.util.List<?> target) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.Collection<T> unmodifiableCollection(
+ java.util.Collection<? extends T> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.Set<T> unmodifiableSet(java.util.Set<? extends T> s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.SortedSet<T> unmodifiableSortedSet(java.util.SortedSet<T> s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.NavigableSet<T> unmodifiableNavigableSet(
+ java.util.NavigableSet<T> s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.List<T> unmodifiableList(java.util.List<? extends T> list) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <K, V> java.util.Map<K, V> unmodifiableMap(
+ java.util.Map<? extends K, ? extends V> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <K, V> java.util.SortedMap<K, V> unmodifiableSortedMap(
+ java.util.SortedMap<K, ? extends V> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <K, V> java.util.NavigableMap<K, V> unmodifiableNavigableMap(
+ java.util.NavigableMap<K, ? extends V> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.Collection<T> synchronizedCollection(java.util.Collection<T> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <T> java.util.Collection<T> synchronizedCollection(
+ java.util.Collection<T> c, java.lang.Object mutex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.Set<T> synchronizedSet(java.util.Set<T> s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <T> java.util.Set<T> synchronizedSet(java.util.Set<T> s, java.lang.Object mutex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.SortedSet<T> synchronizedSortedSet(java.util.SortedSet<T> s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.NavigableSet<T> synchronizedNavigableSet(
+ java.util.NavigableSet<T> s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.List<T> synchronizedList(java.util.List<T> list) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <T> java.util.List<T> synchronizedList(java.util.List<T> list, java.lang.Object mutex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <K, V> java.util.Map<K, V> synchronizedMap(java.util.Map<K, V> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <K, V> java.util.SortedMap<K, V> synchronizedSortedMap(
+ java.util.SortedMap<K, V> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <K, V> java.util.NavigableMap<K, V> synchronizedNavigableMap(
+ java.util.NavigableMap<K, V> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E> java.util.Collection<E> checkedCollection(
+ java.util.Collection<E> c, java.lang.Class<E> type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <T> T[] zeroLengthArray(java.lang.Class<T> type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E> java.util.Queue<E> checkedQueue(
+ java.util.Queue<E> queue, java.lang.Class<E> type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E> java.util.Set<E> checkedSet(java.util.Set<E> s, java.lang.Class<E> type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E> java.util.SortedSet<E> checkedSortedSet(
+ java.util.SortedSet<E> s, java.lang.Class<E> type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E> java.util.NavigableSet<E> checkedNavigableSet(
+ java.util.NavigableSet<E> s, java.lang.Class<E> type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E> java.util.List<E> checkedList(
+ java.util.List<E> list, java.lang.Class<E> type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <K, V> java.util.Map<K, V> checkedMap(
+ java.util.Map<K, V> m, java.lang.Class<K> keyType, java.lang.Class<V> valueType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <K, V> java.util.SortedMap<K, V> checkedSortedMap(
+ java.util.SortedMap<K, V> m, java.lang.Class<K> keyType, java.lang.Class<V> valueType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <K, V> java.util.NavigableMap<K, V> checkedNavigableMap(
+ java.util.NavigableMap<K, V> m,
+ java.lang.Class<K> keyType,
+ java.lang.Class<V> valueType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.Iterator<T> emptyIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.ListIterator<T> emptyListIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.Enumeration<T> emptyEnumeration() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final <T> java.util.Set<T> emptySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E> java.util.SortedSet<E> emptySortedSet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E> java.util.NavigableSet<E> emptyNavigableSet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final <T> java.util.List<T> emptyList() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final <K, V> java.util.Map<K, V> emptyMap() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final <K, V> java.util.SortedMap<K, V> emptySortedMap() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final <K, V> java.util.NavigableMap<K, V> emptyNavigableMap() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.Set<T> singleton(T o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <E> java.util.Iterator<E> singletonIterator(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <T> java.util.Spliterator<T> singletonSpliterator(T element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.List<T> singletonList(T o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <K, V> java.util.Map<K, V> singletonMap(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.List<T> nCopies(int n, T o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.Comparator<T> reverseOrder() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.Comparator<T> reverseOrder(java.util.Comparator<T> cmp) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.Enumeration<T> enumeration(java.util.Collection<T> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.ArrayList<T> list(java.util.Enumeration<T> e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static boolean eq(java.lang.Object o1, java.lang.Object o2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static int frequency(java.util.Collection<?> c, java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static boolean disjoint(java.util.Collection<?> c1, java.util.Collection<?> c2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> boolean addAll(java.util.Collection<? super T> c, T... elements) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E> java.util.Set<E> newSetFromMap(java.util.Map<E, java.lang.Boolean> map) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.Queue<T> asLifoQueue(java.util.Deque<T> deque) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int BINARYSEARCH_THRESHOLD = 5000; // 0x1388
+
+ private static final int COPY_THRESHOLD = 10; // 0xa
+
+ public static final java.util.List EMPTY_LIST;
+
+ static {
+ EMPTY_LIST = null;
+ }
+
+ public static final java.util.Map EMPTY_MAP;
+
+ static {
+ EMPTY_MAP = null;
+ }
+
+ public static final java.util.Set EMPTY_SET;
+
+ static {
+ EMPTY_SET = null;
+ }
+
+ private static final int FILL_THRESHOLD = 25; // 0x19
+
+ private static final int INDEXOFSUBLIST_THRESHOLD = 35; // 0x23
+
+ private static final int REPLACEALL_THRESHOLD = 11; // 0xb
+
+ private static final int REVERSE_THRESHOLD = 18; // 0x12
+
+ private static final int ROTATE_THRESHOLD = 100; // 0x64
+
+ private static final int SHUFFLE_THRESHOLD = 5; // 0x5
+
+ private static java.util.Random r;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class AsLIFOQueue<E> extends java.util.AbstractQueue<E>
+ implements java.util.Queue<E>, java.io.Serializable {
+
+ AsLIFOQueue(java.util.Deque<E> q) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offer(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E poll() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E peek() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E element() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean retainAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeIf(java.util.function.Predicate<? super E> filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.Stream<E> stream() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.Stream<E> parallelStream() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.Deque<E> q;
+
+ {
+ q = null;
+ }
+
+ private static final long serialVersionUID = 1802017725587941708L; // 0x19020d92eca0694cL
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class CheckedCollection<E> implements java.util.Collection<E>, java.io.Serializable {
+
+ CheckedCollection(java.util.Collection<E> c, java.lang.Class<E> type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ E typeCheck(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String badElementMsg(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsAll(java.util.Collection<?> coll) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeAll(java.util.Collection<?> coll) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean retainAll(java.util.Collection<?> coll) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private E[] zeroLengthElementArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.Collection<E> checkedCopyOf(java.util.Collection<? extends E> coll) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(java.util.Collection<? extends E> coll) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeIf(java.util.function.Predicate<? super E> filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.Stream<E> stream() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.Stream<E> parallelStream() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.Collection<E> c;
+
+ {
+ c = null;
+ }
+
+ private static final long serialVersionUID = 1578914078182001775L; // 0x15e96dfd18e6cc6fL
+
+ final java.lang.Class<E> type;
+
+ {
+ type = null;
+ }
+
+ private E[] zeroLengthElementArray;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class CheckedList<E> extends java.util.Collections.CheckedCollection<E>
+ implements java.util.List<E> {
+
+ CheckedList(java.util.List<E> list, java.lang.Class<E> type) {
+ super(null, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E get(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E remove(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int indexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int lastIndexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E set(int index, E element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void add(int index, E element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(int index, java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ListIterator<E> listIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ListIterator<E> listIterator(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.List<E> subList(int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void replaceAll(java.util.function.UnaryOperator<E> operator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void sort(java.util.Comparator<? super E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.List<E> list;
+
+ {
+ list = null;
+ }
+
+ private static final long serialVersionUID = 65247728283967356L; // 0xe7ce7692c45f7cL
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class CheckedMap<K, V> implements java.util.Map<K, V>, java.io.Serializable {
+
+ CheckedMap(
+ java.util.Map<K, V> m, java.lang.Class<K> keyType, java.lang.Class<V> valueType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void typeCheck(java.lang.Object key, java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.util.function.BiFunction<? super K, ? super V, ? extends V> typeCheck(
+ java.util.function.BiFunction<? super K, ? super V, ? extends V> func) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String badKeyMsg(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String badValueMsg(java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsKey(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsValue(java.lang.Object v) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V get(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V remove(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<K> keySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Collection<V> values() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V put(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void putAll(java.util.Map<? extends K, ? extends V> t) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<java.util.Map.Entry<K, V>> entrySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.BiConsumer<? super K, ? super V> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void replaceAll(
+ java.util.function.BiFunction<? super K, ? super V, ? extends V> function) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V putIfAbsent(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object key, java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean replace(K key, V oldValue, V newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V replace(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V computeIfAbsent(
+ K key, java.util.function.Function<? super K, ? extends V> mappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V computeIfPresent(
+ K key,
+ java.util.function.BiFunction<? super K, ? super V, ? extends V>
+ remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V compute(
+ K key,
+ java.util.function.BiFunction<? super K, ? super V, ? extends V>
+ remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V merge(
+ K key,
+ V value,
+ java.util.function.BiFunction<? super V, ? super V, ? extends V>
+ remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private transient java.util.Set<java.util.Map.Entry<K, V>> entrySet;
+
+ final java.lang.Class<K> keyType;
+
+ {
+ keyType = null;
+ }
+
+ private final java.util.Map<K, V> m;
+
+ {
+ m = null;
+ }
+
+ private static final long serialVersionUID = 5742860141034234728L; // 0x4fb2bcdf0d186368L
+
+ final java.lang.Class<V> valueType;
+
+ {
+ valueType = null;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class CheckedEntrySet<K, V> implements java.util.Set<java.util.Map.Entry<K, V>> {
+
+ CheckedEntrySet(
+ java.util.Set<java.util.Map.Entry<K, V>> s, java.lang.Class<V> valueType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(java.util.Map.Entry<K, V> e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(java.util.Collection<? extends java.util.Map.Entry<K, V>> coll) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<java.util.Map.Entry<K, V>> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean retainAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean batchRemove(java.util.Collection<?> c, boolean complement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <K, V, T>
+ java.util.Collections.CheckedMap.CheckedEntrySet.CheckedEntry<K, V, T>
+ checkedEntry(
+ java.util.Map.Entry<K, V> e, java.lang.Class<T> valueType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.Set<java.util.Map.Entry<K, V>> s;
+
+ {
+ s = null;
+ }
+
+ private final java.lang.Class<V> valueType;
+
+ {
+ valueType = null;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class CheckedEntry<K, V, T> implements java.util.Map.Entry<K, V> {
+
+ CheckedEntry(java.util.Map.Entry<K, V> e, java.lang.Class<T> valueType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K getKey() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V getValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V setValue(V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String badValueMsg(java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.Map.Entry<K, V> e;
+
+ {
+ e = null;
+ }
+
+ private final java.lang.Class<T> valueType;
+
+ {
+ valueType = null;
+ }
+ }
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class CheckedNavigableMap<K, V> extends java.util.Collections.CheckedSortedMap<K, V>
+ implements java.util.NavigableMap<K, V>, java.io.Serializable {
+
+ CheckedNavigableMap(
+ java.util.NavigableMap<K, V> m,
+ java.lang.Class<K> keyType,
+ java.lang.Class<V> valueType) {
+ super(null, null, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Comparator<? super K> comparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K firstKey() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K lastKey() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> lowerEntry(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K lowerKey(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> floorEntry(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K floorKey(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> ceilingEntry(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K ceilingKey(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> higherEntry(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K higherKey(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> firstEntry() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> lastEntry() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> pollFirstEntry() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> pollLastEntry() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableMap<K, V> descendingMap() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<K> keySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<K> navigableKeySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<K> descendingKeySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableMap<K, V> subMap(K fromKey, K toKey) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableMap<K, V> headMap(K toKey) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableMap<K, V> tailMap(K fromKey) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableMap<K, V> subMap(
+ K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.NavigableMap<K, V> nm;
+
+ {
+ nm = null;
+ }
+
+ private static final long serialVersionUID = -4852462692372534096L; // 0xbca896e4074cacb0L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class CheckedNavigableSet<E> extends java.util.Collections.CheckedSortedSet<E>
+ implements java.util.NavigableSet<E>, java.io.Serializable {
+
+ CheckedNavigableSet(java.util.NavigableSet<E> s, java.lang.Class<E> type) {
+ super(null, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public E lower(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E floor(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E ceiling(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E higher(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E pollFirst() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E pollLast() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> descendingSet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> descendingIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> subSet(E fromElement, E toElement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> headSet(E toElement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> tailSet(E fromElement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> subSet(
+ E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> headSet(E toElement, boolean inclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.NavigableSet<E> ns;
+
+ {
+ ns = null;
+ }
+
+ private static final long serialVersionUID = -5429120189805438922L; // 0xb4a7e3f3bbbed836L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class CheckedQueue<E> extends java.util.Collections.CheckedCollection<E>
+ implements java.util.Queue<E>, java.io.Serializable {
+
+ CheckedQueue(java.util.Queue<E> queue, java.lang.Class<E> elementType) {
+ super(null, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public E element() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E peek() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E poll() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offer(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.Queue<E> queue;
+
+ {
+ queue = null;
+ }
+
+ private static final long serialVersionUID = 1433151992604707767L; // 0x13e39424e458cbb7L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class CheckedRandomAccessList<E> extends java.util.Collections.CheckedList<E>
+ implements java.util.RandomAccess {
+
+ CheckedRandomAccessList(java.util.List<E> list, java.lang.Class<E> type) {
+ super(null, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.List<E> subList(int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = 1638200125423088369L; // 0x16bc0e55a2d7f2f1L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class CheckedSet<E> extends java.util.Collections.CheckedCollection<E>
+ implements java.util.Set<E>, java.io.Serializable {
+
+ CheckedSet(java.util.Set<E> s, java.lang.Class<E> elementType) {
+ super(null, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = 4694047833775013803L; // 0x41249ba27ad9ffabL
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class CheckedSortedMap<K, V> extends java.util.Collections.CheckedMap<K, V>
+ implements java.util.SortedMap<K, V>, java.io.Serializable {
+
+ CheckedSortedMap(
+ java.util.SortedMap<K, V> m,
+ java.lang.Class<K> keyType,
+ java.lang.Class<V> valueType) {
+ super(null, null, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Comparator<? super K> comparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K firstKey() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K lastKey() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedMap<K, V> subMap(K fromKey, K toKey) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedMap<K, V> headMap(K toKey) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedMap<K, V> tailMap(K fromKey) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = 1599671320688067438L; // 0x16332c973afe036eL
+
+ private final java.util.SortedMap<K, V> sm;
+
+ {
+ sm = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class CheckedSortedSet<E> extends java.util.Collections.CheckedSet<E>
+ implements java.util.SortedSet<E>, java.io.Serializable {
+
+ CheckedSortedSet(java.util.SortedSet<E> s, java.lang.Class<E> type) {
+ super(null, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Comparator<? super E> comparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E first() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E last() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedSet<E> subSet(E fromElement, E toElement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedSet<E> headSet(E toElement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedSet<E> tailSet(E fromElement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = 1599911165492914959L; // 0x163406ba7362eb0fL
+
+ private final java.util.SortedSet<E> ss;
+
+ {
+ ss = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class CopiesList<E> extends java.util.AbstractList<E>
+ implements java.util.RandomAccess, java.io.Serializable {
+
+ CopiesList(int n, E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int indexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int lastIndexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E get(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.List<E> subList(int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.Stream<E> stream() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.Stream<E> parallelStream() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final E element;
+
+ {
+ element = null;
+ }
+
+ final int n;
+
+ {
+ n = 0;
+ }
+
+ private static final long serialVersionUID = 2739099268398711800L; // 0x26033c45b17003f8L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class EmptyEnumeration<E> implements java.util.Enumeration<E> {
+
+ private EmptyEnumeration() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasMoreElements() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E nextElement() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.util.Collections.EmptyEnumeration<java.lang.Object> EMPTY_ENUMERATION;
+
+ static {
+ EMPTY_ENUMERATION = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class EmptyIterator<E> implements java.util.Iterator<E> {
+
+ private EmptyIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.util.Collections.EmptyIterator<java.lang.Object> EMPTY_ITERATOR;
+
+ static {
+ EMPTY_ITERATOR = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class EmptyList<E> extends java.util.AbstractList<E>
+ implements java.util.RandomAccess, java.io.Serializable {
+
+ @UnsupportedAppUsage
+ private EmptyList() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ListIterator<E> listIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E get(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeIf(java.util.function.Predicate<? super E> filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void replaceAll(java.util.function.UnaryOperator<E> operator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void sort(java.util.Comparator<? super E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readResolve() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = 8842843931221139166L; // 0x7ab817b43ca79edeL
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class EmptyListIterator<E> extends java.util.Collections.EmptyIterator<E>
+ implements java.util.ListIterator<E> {
+
+ private EmptyListIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasPrevious() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E previous() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int nextIndex() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int previousIndex() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void set(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.util.Collections.EmptyListIterator<java.lang.Object> EMPTY_ITERATOR;
+
+ static {
+ EMPTY_ITERATOR = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class EmptyMap<K, V> extends java.util.AbstractMap<K, V>
+ implements java.io.Serializable {
+
+ @UnsupportedAppUsage
+ private EmptyMap() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsKey(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsValue(java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V get(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<K> keySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Collection<V> values() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<java.util.Map.Entry<K, V>> entrySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V getOrDefault(java.lang.Object k, V defaultValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.BiConsumer<? super K, ? super V> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void replaceAll(
+ java.util.function.BiFunction<? super K, ? super V, ? extends V> function) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V putIfAbsent(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object key, java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean replace(K key, V oldValue, V newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V replace(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V computeIfAbsent(
+ K key, java.util.function.Function<? super K, ? extends V> mappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V computeIfPresent(
+ K key,
+ java.util.function.BiFunction<? super K, ? super V, ? extends V>
+ remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V compute(
+ K key,
+ java.util.function.BiFunction<? super K, ? super V, ? extends V>
+ remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V merge(
+ K key,
+ V value,
+ java.util.function.BiFunction<? super V, ? super V, ? extends V>
+ remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readResolve() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = 6428348081105594320L; // 0x593614855adce7d0L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class EmptySet<E> extends java.util.AbstractSet<E>
+ implements java.io.Serializable {
+
+ private EmptySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeIf(java.util.function.Predicate<? super E> filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readResolve() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = 1582296315990362920L; // 0x15f5721db403cb28L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class ReverseComparator
+ implements java.util.Comparator<java.lang.Comparable<java.lang.Object>>,
+ java.io.Serializable {
+
+ private ReverseComparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compare(
+ java.lang.Comparable<java.lang.Object> c1,
+ java.lang.Comparable<java.lang.Object> c2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readResolve() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Comparator<java.lang.Comparable<java.lang.Object>> reversed() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.util.Collections.ReverseComparator REVERSE_ORDER;
+
+ static {
+ REVERSE_ORDER = null;
+ }
+
+ private static final long serialVersionUID = 7207038068494060240L; // 0x64048af0534e4ad0L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class ReverseComparator2<T>
+ implements java.util.Comparator<T>, java.io.Serializable {
+
+ ReverseComparator2(java.util.Comparator<T> cmp) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compare(T t1, T t2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Comparator<T> reversed() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.Comparator<T> cmp;
+
+ {
+ cmp = null;
+ }
+
+ private static final long serialVersionUID = 4374092139857L; // 0x3fa6c354d51L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class SetFromMap<E> extends java.util.AbstractSet<E>
+ implements java.util.Set<E>, java.io.Serializable {
+
+ SetFromMap(java.util.Map<E, java.lang.Boolean> map) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean retainAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeIf(java.util.function.Predicate<? super E> filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.Stream<E> stream() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.Stream<E> parallelStream() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream stream)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.Map<E, java.lang.Boolean> m;
+
+ {
+ m = null;
+ }
+
+ private transient java.util.Set<E> s;
+
+ private static final long serialVersionUID = 2454657854757543876L; // 0x2210b25045f21fc4L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class SingletonList<E> extends java.util.AbstractList<E>
+ implements java.util.RandomAccess, java.io.Serializable {
+
+ SingletonList(E obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E get(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeIf(java.util.function.Predicate<? super E> filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void replaceAll(java.util.function.UnaryOperator<E> operator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void sort(java.util.Comparator<? super E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final E element;
+
+ {
+ element = null;
+ }
+
+ private static final long serialVersionUID = 3093736618740652951L; // 0x2aef29103ca79b97L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class SingletonMap<K, V> extends java.util.AbstractMap<K, V>
+ implements java.io.Serializable {
+
+ SingletonMap(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsKey(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsValue(java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V get(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<K> keySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<java.util.Map.Entry<K, V>> entrySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Collection<V> values() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V getOrDefault(java.lang.Object key, V defaultValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.BiConsumer<? super K, ? super V> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void replaceAll(
+ java.util.function.BiFunction<? super K, ? super V, ? extends V> function) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V putIfAbsent(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object key, java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean replace(K key, V oldValue, V newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V replace(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V computeIfAbsent(
+ K key, java.util.function.Function<? super K, ? extends V> mappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V computeIfPresent(
+ K key,
+ java.util.function.BiFunction<? super K, ? super V, ? extends V>
+ remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V compute(
+ K key,
+ java.util.function.BiFunction<? super K, ? super V, ? extends V>
+ remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V merge(
+ K key,
+ V value,
+ java.util.function.BiFunction<? super V, ? super V, ? extends V>
+ remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private transient java.util.Set<java.util.Map.Entry<K, V>> entrySet;
+
+ private final K k;
+
+ {
+ k = null;
+ }
+
+ private transient java.util.Set<K> keySet;
+
+ private static final long serialVersionUID = -6979724477215052911L; // 0x9f230991717f6b91L
+
+ private final V v;
+
+ {
+ v = null;
+ }
+
+ private transient java.util.Collection<V> values;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class SingletonSet<E> extends java.util.AbstractSet<E>
+ implements java.io.Serializable {
+
+ SingletonSet(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeIf(java.util.function.Predicate<? super E> filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final E element;
+
+ {
+ element = null;
+ }
+
+ private static final long serialVersionUID = 3193687207550431679L; // 0x2c52419829c0b1bfL
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class SynchronizedCollection<E>
+ implements java.util.Collection<E>, java.io.Serializable {
+
+ SynchronizedCollection(java.util.Collection<E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ SynchronizedCollection(java.util.Collection<E> c, java.lang.Object mutex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsAll(java.util.Collection<?> coll) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(java.util.Collection<? extends E> coll) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeAll(java.util.Collection<?> coll) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean retainAll(java.util.Collection<?> coll) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super E> consumer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeIf(java.util.function.Predicate<? super E> filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.Stream<E> stream() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.Stream<E> parallelStream() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ final java.util.Collection<E> c;
+
+ {
+ c = null;
+ }
+
+ final java.lang.Object mutex;
+
+ {
+ mutex = null;
+ }
+
+ private static final long serialVersionUID = 3053995032091335093L; // 0x2a61f84d099c99b5L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class SynchronizedList<E> extends java.util.Collections.SynchronizedCollection<E>
+ implements java.util.List<E> {
+
+ SynchronizedList(java.util.List<E> list) {
+ super((java.util.Collection) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ SynchronizedList(java.util.List<E> list, java.lang.Object mutex) {
+ super((java.util.Collection) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E get(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E set(int index, E element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void add(int index, E element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E remove(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int indexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int lastIndexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(int index, java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ListIterator<E> listIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ListIterator<E> listIterator(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.List<E> subList(int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void replaceAll(java.util.function.UnaryOperator<E> operator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void sort(java.util.Comparator<? super E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readResolve() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ final java.util.List<E> list;
+
+ {
+ list = null;
+ }
+
+ private static final long serialVersionUID = -7754090372962971524L; // 0x9463efe38344107cL
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class SynchronizedMap<K, V>
+ implements java.util.Map<K, V>, java.io.Serializable {
+
+ SynchronizedMap(java.util.Map<K, V> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ SynchronizedMap(java.util.Map<K, V> m, java.lang.Object mutex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsKey(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsValue(java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V get(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V put(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V remove(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void putAll(java.util.Map<? extends K, ? extends V> map) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<K> keySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<java.util.Map.Entry<K, V>> entrySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Collection<V> values() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V getOrDefault(java.lang.Object k, V defaultValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.BiConsumer<? super K, ? super V> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void replaceAll(
+ java.util.function.BiFunction<? super K, ? super V, ? extends V> function) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V putIfAbsent(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object key, java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean replace(K key, V oldValue, V newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V replace(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V computeIfAbsent(
+ K key, java.util.function.Function<? super K, ? extends V> mappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V computeIfPresent(
+ K key,
+ java.util.function.BiFunction<? super K, ? super V, ? extends V>
+ remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V compute(
+ K key,
+ java.util.function.BiFunction<? super K, ? super V, ? extends V>
+ remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V merge(
+ K key,
+ V value,
+ java.util.function.BiFunction<? super V, ? super V, ? extends V>
+ remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private transient java.util.Set<java.util.Map.Entry<K, V>> entrySet;
+
+ private transient java.util.Set<K> keySet;
+
+ @UnsupportedAppUsage
+ private final java.util.Map<K, V> m;
+
+ {
+ m = null;
+ }
+
+ final java.lang.Object mutex;
+
+ {
+ mutex = null;
+ }
+
+ private static final long serialVersionUID = 1978198479659022715L; // 0x1b73f9094b4b397bL
+
+ private transient java.util.Collection<V> values;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class SynchronizedNavigableMap<K, V>
+ extends java.util.Collections.SynchronizedSortedMap<K, V>
+ implements java.util.NavigableMap<K, V> {
+
+ SynchronizedNavigableMap(java.util.NavigableMap<K, V> m) {
+ super((java.util.SortedMap) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ SynchronizedNavigableMap(java.util.NavigableMap<K, V> m, java.lang.Object mutex) {
+ super((java.util.SortedMap) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> lowerEntry(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K lowerKey(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> floorEntry(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K floorKey(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> ceilingEntry(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K ceilingKey(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> higherEntry(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K higherKey(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> firstEntry() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> lastEntry() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> pollFirstEntry() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> pollLastEntry() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableMap<K, V> descendingMap() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<K> keySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<K> navigableKeySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<K> descendingKeySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedMap<K, V> subMap(K fromKey, K toKey) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedMap<K, V> headMap(K toKey) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedMap<K, V> tailMap(K fromKey) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableMap<K, V> subMap(
+ K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.NavigableMap<K, V> nm;
+
+ {
+ nm = null;
+ }
+
+ private static final long serialVersionUID = 699392247599746807L; // 0x9b4bd8b2cd84ef7L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class SynchronizedNavigableSet<E> extends java.util.Collections.SynchronizedSortedSet<E>
+ implements java.util.NavigableSet<E> {
+
+ SynchronizedNavigableSet(java.util.NavigableSet<E> s) {
+ super((java.util.SortedSet) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ SynchronizedNavigableSet(java.util.NavigableSet<E> s, java.lang.Object mutex) {
+ super((java.util.SortedSet) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public E lower(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E floor(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E ceiling(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E higher(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E pollFirst() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E pollLast() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> descendingSet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> descendingIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> subSet(E fromElement, E toElement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> headSet(E toElement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> tailSet(E fromElement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> subSet(
+ E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> headSet(E toElement, boolean inclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.NavigableSet<E> ns;
+
+ {
+ ns = null;
+ }
+
+ private static final long serialVersionUID = -5505529816273629798L; // 0xb3986dcd38b04d9aL
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class SynchronizedRandomAccessList<E> extends java.util.Collections.SynchronizedList<E>
+ implements java.util.RandomAccess {
+
+ SynchronizedRandomAccessList(java.util.List<E> list) {
+ super((java.util.List) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ SynchronizedRandomAccessList(java.util.List<E> list, java.lang.Object mutex) {
+ super((java.util.List) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.List<E> subList(int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object writeReplace() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = 1530674583602358482L; // 0x153e0c6c865668d2L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class SynchronizedSet<E> extends java.util.Collections.SynchronizedCollection<E>
+ implements java.util.Set<E> {
+
+ SynchronizedSet(java.util.Set<E> s) {
+ super((java.util.Collection) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ SynchronizedSet(java.util.Set<E> s, java.lang.Object mutex) {
+ super((java.util.Collection) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = 487447009682186044L; // 0x6c3c27902eedf3cL
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class SynchronizedSortedMap<K, V> extends java.util.Collections.SynchronizedMap<K, V>
+ implements java.util.SortedMap<K, V> {
+
+ SynchronizedSortedMap(java.util.SortedMap<K, V> m) {
+ super((java.util.Map) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ SynchronizedSortedMap(java.util.SortedMap<K, V> m, java.lang.Object mutex) {
+ super((java.util.Map) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Comparator<? super K> comparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedMap<K, V> subMap(K fromKey, K toKey) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedMap<K, V> headMap(K toKey) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedMap<K, V> tailMap(K fromKey) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K firstKey() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K lastKey() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = -8798146769416483793L; // 0x85e6b420b72e0c2fL
+
+ private final java.util.SortedMap<K, V> sm;
+
+ {
+ sm = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class SynchronizedSortedSet<E> extends java.util.Collections.SynchronizedSet<E>
+ implements java.util.SortedSet<E> {
+
+ SynchronizedSortedSet(java.util.SortedSet<E> s) {
+ super((java.util.Set) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ SynchronizedSortedSet(java.util.SortedSet<E> s, java.lang.Object mutex) {
+ super((java.util.Set) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Comparator<? super E> comparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedSet<E> subSet(E fromElement, E toElement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedSet<E> headSet(E toElement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedSet<E> tailSet(E fromElement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E first() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E last() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = 8695801310862127406L; // 0x78adb1384b50312eL
+
+ private final java.util.SortedSet<E> ss;
+
+ {
+ ss = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class UnmodifiableCollection<E>
+ implements java.util.Collection<E>, java.io.Serializable {
+
+ UnmodifiableCollection(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsAll(java.util.Collection<?> coll) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(java.util.Collection<? extends E> coll) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeAll(java.util.Collection<?> coll) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean retainAll(java.util.Collection<?> coll) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeIf(java.util.function.Predicate<? super E> filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.Stream<E> stream() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.Stream<E> parallelStream() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ final java.util.Collection<? extends E> c;
+
+ {
+ c = null;
+ }
+
+ private static final long serialVersionUID = 1820017752578914078L; // 0x19420080cb5ef71eL
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class UnmodifiableList<E> extends java.util.Collections.UnmodifiableCollection<E>
+ implements java.util.List<E> {
+
+ UnmodifiableList(java.util.List<? extends E> list) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E get(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E set(int index, E element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void add(int index, E element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E remove(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int indexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int lastIndexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(int index, java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void replaceAll(java.util.function.UnaryOperator<E> operator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void sort(java.util.Comparator<? super E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ListIterator<E> listIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ListIterator<E> listIterator(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.List<E> subList(int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readResolve() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.List<? extends E> list;
+
+ {
+ list = null;
+ }
+
+ private static final long serialVersionUID = -283967356065247728L; // 0xfc0f2531b5ec8e10L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class UnmodifiableMap<K, V>
+ implements java.util.Map<K, V>, java.io.Serializable {
+
+ UnmodifiableMap(java.util.Map<? extends K, ? extends V> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsKey(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsValue(java.lang.Object val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V get(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V put(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V remove(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void putAll(java.util.Map<? extends K, ? extends V> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<K> keySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<java.util.Map.Entry<K, V>> entrySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Collection<V> values() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V getOrDefault(java.lang.Object k, V defaultValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.BiConsumer<? super K, ? super V> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void replaceAll(
+ java.util.function.BiFunction<? super K, ? super V, ? extends V> function) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V putIfAbsent(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object key, java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean replace(K key, V oldValue, V newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V replace(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V computeIfAbsent(
+ K key, java.util.function.Function<? super K, ? extends V> mappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V computeIfPresent(
+ K key,
+ java.util.function.BiFunction<? super K, ? super V, ? extends V>
+ remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V compute(
+ K key,
+ java.util.function.BiFunction<? super K, ? super V, ? extends V>
+ remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V merge(
+ K key,
+ V value,
+ java.util.function.BiFunction<? super V, ? super V, ? extends V>
+ remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private transient java.util.Set<java.util.Map.Entry<K, V>> entrySet;
+
+ private transient java.util.Set<K> keySet;
+
+ @UnsupportedAppUsage
+ private final java.util.Map<? extends K, ? extends V> m;
+
+ {
+ m = null;
+ }
+
+ private static final long serialVersionUID = -1034234728574286014L; // 0xf1a5a8fe74f50742L
+
+ private transient java.util.Collection<V> values;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class UnmodifiableEntrySet<K, V>
+ extends java.util.Collections.UnmodifiableSet<java.util.Map.Entry<K, V>> {
+
+ UnmodifiableEntrySet(
+ java.util.Set<? extends java.util.Map.Entry<? extends K, ? extends V>> s) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ static <K, V> java.util.function.Consumer<java.util.Map.Entry<K, V>> entryConsumer(
+ java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(
+ java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<java.util.Map.Entry<K, V>> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.Stream<java.util.Map.Entry<K, V>> stream() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.Stream<java.util.Map.Entry<K, V>> parallelStream() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<java.util.Map.Entry<K, V>> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsAll(java.util.Collection<?> coll) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID =
+ 7854390611657943733L; // 0x6d0066a59f08eab5L
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class UnmodifiableEntry<K, V> implements java.util.Map.Entry<K, V> {
+
+ UnmodifiableEntry(java.util.Map.Entry<? extends K, ? extends V> e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K getKey() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V getValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V setValue(V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.util.Map.Entry<? extends K, ? extends V> e;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class UnmodifiableEntrySetSpliterator<K, V>
+ implements java.util.Spliterator<java.util.Map.Entry<K, V>> {
+
+ UnmodifiableEntrySetSpliterator(
+ java.util.Spliterator<java.util.Map.Entry<K, V>> s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(
+ java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(
+ java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<java.util.Map.Entry<K, V>> trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long estimateSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getExactSizeIfKnown() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasCharacteristics(int characteristics) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Comparator<? super java.util.Map.Entry<K, V>> getComparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.Spliterator<java.util.Map.Entry<K, V>> s;
+
+ {
+ s = null;
+ }
+ }
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class UnmodifiableNavigableMap<K, V>
+ extends java.util.Collections.UnmodifiableSortedMap<K, V>
+ implements java.util.NavigableMap<K, V>, java.io.Serializable {
+
+ UnmodifiableNavigableMap(java.util.NavigableMap<K, ? extends V> m) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public K lowerKey(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K floorKey(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K ceilingKey(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K higherKey(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> lowerEntry(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> floorEntry(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> ceilingEntry(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> higherEntry(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> firstEntry() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> lastEntry() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> pollFirstEntry() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> pollLastEntry() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableMap<K, V> descendingMap() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<K> navigableKeySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<K> descendingKeySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableMap<K, V> subMap(
+ K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.util.Collections.UnmodifiableNavigableMap.EmptyNavigableMap<?, ?>
+ EMPTY_NAVIGABLE_MAP;
+
+ static {
+ EMPTY_NAVIGABLE_MAP = null;
+ }
+
+ private final java.util.NavigableMap<K, ? extends V> nm;
+
+ {
+ nm = null;
+ }
+
+ private static final long serialVersionUID = -4858195264774772197L; // 0xbc943925819d6a1bL
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class EmptyNavigableMap<K, V>
+ extends java.util.Collections.UnmodifiableNavigableMap<K, V>
+ implements java.io.Serializable {
+
+ EmptyNavigableMap() {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<K> navigableKeySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readResolve() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID =
+ -2239321462712562324L; // 0xe0ec54fe7d1c0d6cL
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class UnmodifiableNavigableSet<E> extends java.util.Collections.UnmodifiableSortedSet<E>
+ implements java.util.NavigableSet<E>, java.io.Serializable {
+
+ UnmodifiableNavigableSet(java.util.NavigableSet<E> s) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public E lower(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E floor(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E ceiling(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E higher(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E pollFirst() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E pollLast() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> descendingSet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> descendingIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> subSet(
+ E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> headSet(E toElement, boolean inclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.util.NavigableSet<?> EMPTY_NAVIGABLE_SET;
+
+ static {
+ EMPTY_NAVIGABLE_SET = null;
+ }
+
+ private final java.util.NavigableSet<E> ns;
+
+ {
+ ns = null;
+ }
+
+ private static final long serialVersionUID = -6027448201786391929L; // 0xac5a33cb96748287L
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class EmptyNavigableSet<E>
+ extends java.util.Collections.UnmodifiableNavigableSet<E>
+ implements java.io.Serializable {
+
+ public EmptyNavigableSet() {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readResolve() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID =
+ -6291252904449939134L; // 0xa8b0fad0de1de942L
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class UnmodifiableRandomAccessList<E> extends java.util.Collections.UnmodifiableList<E>
+ implements java.util.RandomAccess {
+
+ UnmodifiableRandomAccessList(java.util.List<? extends E> list) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.List<E> subList(int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object writeReplace() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = -2542308836966382001L; // 0xdcb7e7951f48464fL
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class UnmodifiableSet<E> extends java.util.Collections.UnmodifiableCollection<E>
+ implements java.util.Set<E>, java.io.Serializable {
+
+ UnmodifiableSet(java.util.Set<? extends E> s) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = -9215047833775013803L; // 0x801d92d18f9b8055L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class UnmodifiableSortedMap<K, V> extends java.util.Collections.UnmodifiableMap<K, V>
+ implements java.util.SortedMap<K, V>, java.io.Serializable {
+
+ UnmodifiableSortedMap(java.util.SortedMap<K, ? extends V> m) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Comparator<? super K> comparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedMap<K, V> subMap(K fromKey, K toKey) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedMap<K, V> headMap(K toKey) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedMap<K, V> tailMap(K fromKey) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K firstKey() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K lastKey() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = -8806743815996713206L; // 0x85c82928d3a5d70aL
+
+ private final java.util.SortedMap<K, ? extends V> sm;
+
+ {
+ sm = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class UnmodifiableSortedSet<E> extends java.util.Collections.UnmodifiableSet<E>
+ implements java.util.SortedSet<E>, java.io.Serializable {
+
+ UnmodifiableSortedSet(java.util.SortedSet<E> s) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Comparator<? super E> comparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedSet<E> subSet(E fromElement, E toElement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedSet<E> headSet(E toElement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.SortedSet<E> tailSet(E fromElement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E first() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E last() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = -4929149591599911165L; // 0xbb98248febecef03L
+
+ private final java.util.SortedSet<E> ss;
+
+ {
+ ss = null;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/EnumMap.java b/ojluni/annotations/hiddenapi/java/util/EnumMap.java
new file mode 100644
index 0000000..81cd885
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/EnumMap.java
@@ -0,0 +1,377 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2003, 2012, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class EnumMap<K extends java.lang.Enum<K>, V> extends java.util.AbstractMap<K, V>
+ implements java.io.Serializable, java.lang.Cloneable {
+
+ public EnumMap(java.lang.Class<K> keyType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public EnumMap(java.util.EnumMap<K, ? extends V> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public EnumMap(java.util.Map<K, ? extends V> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object maskNull(java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private V unmaskNull(java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsValue(java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsKey(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean containsMapping(java.lang.Object key, java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V get(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V put(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V remove(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean removeMapping(java.lang.Object key, java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean isValidKey(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void putAll(java.util.Map<? extends K, ? extends V> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<K> keySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Collection<V> values() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<java.util.Map.Entry<K, V>> entrySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean equals(java.util.EnumMap<?, ?> em) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int entryHashCode(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.EnumMap<K, V> clone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void typeCheck(K key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static <K extends java.lang.Enum<K>> K[] getKeyUniverse(java.lang.Class<K> keyType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.lang.Object NULL;
+
+ static {
+ NULL = null;
+ }
+
+ private static final java.lang.Enum<?>[] ZERO_LENGTH_ENUM_ARRAY;
+
+ static {
+ ZERO_LENGTH_ENUM_ARRAY = new java.lang.Enum[0];
+ }
+
+ private transient java.util.Set<java.util.Map.Entry<K, V>> entrySet;
+
+ @UnsupportedAppUsage
+ private final java.lang.Class<K> keyType;
+
+ {
+ keyType = null;
+ }
+
+ private transient K[] keyUniverse;
+
+ private static final long serialVersionUID = 458661240069192865L; // 0x65d7df7be907ca1L
+
+ private transient int size = 0; // 0x0
+
+ private transient java.lang.Object[] vals;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class EntryIterator
+ extends EnumMapIterator<java.util.Map.Entry<K, V>> {
+
+ private EntryIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.util.EnumMap.EntryIterator.Entry lastReturnedEntry;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class Entry implements java.util.Map.Entry<K, V> {
+
+ private Entry(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K getKey() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V getValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V setValue(V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkIndexForEntryUse() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int index;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class EntrySet extends java.util.AbstractSet<java.util.Map.Entry<K, V>> {
+
+ private EntrySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<java.util.Map.Entry<K, V>> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object[] fillEntryArray(java.lang.Object[] a) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private abstract class EnumMapIterator<T> implements java.util.Iterator<T> {
+
+ private EnumMapIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkLastReturnedIndex() {
+ throw new RuntimeException("Stub!");
+ }
+
+ int index = 0; // 0x0
+
+ int lastReturnedIndex = -1; // 0xffffffff
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class KeyIterator extends EnumMapIterator<K> {
+
+ private KeyIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K next() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class KeySet extends java.util.AbstractSet<K> {
+
+ private KeySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<K> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class ValueIterator extends EnumMapIterator<V> {
+
+ private ValueIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V next() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class Values extends java.util.AbstractCollection<V> {
+
+ private Values() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<V> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/EnumSet.java b/ojluni/annotations/hiddenapi/java/util/EnumSet.java
new file mode 100644
index 0000000..f8edb19
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/EnumSet.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2003, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class EnumSet<E extends java.lang.Enum<E>> extends java.util.AbstractSet<E>
+ implements java.lang.Cloneable, java.io.Serializable {
+
+ EnumSet(java.lang.Class<E> elementType, java.lang.Enum<?>[] universe) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E extends java.lang.Enum<E>> java.util.EnumSet<E> noneOf(
+ java.lang.Class<E> elementType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E extends java.lang.Enum<E>> java.util.EnumSet<E> allOf(
+ java.lang.Class<E> elementType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ abstract void addAll();
+
+ public static <E extends java.lang.Enum<E>> java.util.EnumSet<E> copyOf(
+ java.util.EnumSet<E> s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E extends java.lang.Enum<E>> java.util.EnumSet<E> copyOf(
+ java.util.Collection<E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E extends java.lang.Enum<E>> java.util.EnumSet<E> complementOf(
+ java.util.EnumSet<E> s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E extends java.lang.Enum<E>> java.util.EnumSet<E> of(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E extends java.lang.Enum<E>> java.util.EnumSet<E> of(E e1, E e2) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E extends java.lang.Enum<E>> java.util.EnumSet<E> of(E e1, E e2, E e3) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E extends java.lang.Enum<E>> java.util.EnumSet<E> of(E e1, E e2, E e3, E e4) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E extends java.lang.Enum<E>> java.util.EnumSet<E> of(
+ E e1, E e2, E e3, E e4, E e5) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E extends java.lang.Enum<E>> java.util.EnumSet<E> of(E first, E... rest) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <E extends java.lang.Enum<E>> java.util.EnumSet<E> range(E from, E to) {
+ throw new RuntimeException("Stub!");
+ }
+
+ abstract void addRange(E from, E to);
+
+ public java.util.EnumSet<E> clone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ abstract void complement();
+
+ final void typeCheck(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static <E extends java.lang.Enum<E>> E[] getUniverse(java.lang.Class<E> elementType) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.Object writeReplace() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream stream)
+ throws java.io.InvalidObjectException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.Enum<?>[] ZERO_LENGTH_ENUM_ARRAY;
+
+ @UnsupportedAppUsage
+ final java.lang.Class<E> elementType;
+
+ {
+ elementType = null;
+ }
+
+ final java.lang.Enum<?>[] universe;
+
+ {
+ universe = new java.lang.Enum[0];
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class SerializationProxy<E extends java.lang.Enum<E>>
+ implements java.io.Serializable {
+
+ SerializationProxy(java.util.EnumSet<E> set) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readResolve() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.lang.Class<E> elementType;
+
+ {
+ elementType = null;
+ }
+
+ private final java.lang.Enum<?>[] elements;
+
+ {
+ elements = new java.lang.Enum[0];
+ }
+
+ private static final long serialVersionUID = 362491234563181265L; // 0x507d3db7654cad1L
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/HashMap.java b/ojluni/annotations/hiddenapi/java/util/HashMap.java
new file mode 100644
index 0000000..90db8fb
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/HashMap.java
@@ -0,0 +1,706 @@
+/*
+ * Copyright (c) 1997, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class HashMap<K, V> extends java.util.AbstractMap<K, V>
+ implements java.util.Map<K, V>, java.lang.Cloneable, java.io.Serializable {
+
+ public HashMap(int initialCapacity, float loadFactor) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public HashMap(int initialCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public HashMap() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public HashMap(java.util.Map<? extends K, ? extends V> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final int hash(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.lang.Class<?> comparableClassFor(java.lang.Object x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static int compareComparables(java.lang.Class<?> kc, java.lang.Object k, java.lang.Object x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final int tableSizeFor(int cap) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void putMapEntries(java.util.Map<? extends K, ? extends V> m, boolean evict) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V get(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.HashMap.Node<K, V> getNode(int hash, java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsKey(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V put(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.HashMap.Node<K, V>[] resize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void treeifyBin(java.util.HashMap.Node<K, V>[] tab, int hash) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void putAll(java.util.Map<? extends K, ? extends V> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V remove(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.HashMap.Node<K, V> removeNode(
+ int hash,
+ java.lang.Object key,
+ java.lang.Object value,
+ boolean matchValue,
+ boolean movable) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsValue(java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<K> keySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Collection<V> values() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<java.util.Map.Entry<K, V>> entrySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V getOrDefault(java.lang.Object key, V defaultValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V putIfAbsent(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object key, java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean replace(K key, V oldValue, V newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V replace(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V computeIfAbsent(
+ K key, java.util.function.Function<? super K, ? extends V> mappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V computeIfPresent(
+ K key,
+ java.util.function.BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V compute(
+ K key,
+ java.util.function.BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V merge(
+ K key,
+ V value,
+ java.util.function.BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.BiConsumer<? super K, ? super V> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void replaceAll(
+ java.util.function.BiFunction<? super K, ? super V, ? extends V> function) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object clone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final float loadFactor() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int capacity() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.HashMap.Node<K, V> newNode(
+ int hash, K key, V value, java.util.HashMap.Node<K, V> next) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.HashMap.Node<K, V> replacementNode(
+ java.util.HashMap.Node<K, V> p, java.util.HashMap.Node<K, V> next) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.HashMap.TreeNode<K, V> newTreeNode(
+ int hash, K key, V value, java.util.HashMap.Node<K, V> next) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.HashMap.TreeNode<K, V> replacementTreeNode(
+ java.util.HashMap.Node<K, V> p, java.util.HashMap.Node<K, V> next) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void reinitialize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void afterNodeAccess(java.util.HashMap.Node<K, V> p) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void afterNodeInsertion(boolean evict) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void afterNodeRemoval(java.util.HashMap.Node<K, V> p) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void internalWriteEntries(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final int DEFAULT_INITIAL_CAPACITY = 16; // 0x10
+
+ static final float DEFAULT_LOAD_FACTOR = 0.75f;
+
+ static final int MAXIMUM_CAPACITY = 1073741824; // 0x40000000
+
+ static final int MIN_TREEIFY_CAPACITY = 64; // 0x40
+
+ static final int TREEIFY_THRESHOLD = 8; // 0x8
+
+ static final int UNTREEIFY_THRESHOLD = 6; // 0x6
+
+ transient java.util.Set<java.util.Map.Entry<K, V>> entrySet;
+
+ final float loadFactor;
+
+ {
+ loadFactor = 0;
+ }
+
+ @UnsupportedAppUsage
+ transient int modCount;
+
+ private static final long serialVersionUID = 362498820763181265L; // 0x507dac1c31660d1L
+
+ transient int size;
+
+ @UnsupportedAppUsage
+ transient java.util.HashMap.Node<K, V>[] table;
+
+ int threshold;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ final class EntryIterator extends java.util.HashMap.HashIterator
+ implements java.util.Iterator<java.util.Map.Entry<K, V>> {
+
+ public java.util.Map.Entry<K, V> next() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ final class EntrySet extends java.util.AbstractSet<java.util.Map.Entry<K, V>> {
+
+ EntrySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<java.util.Map.Entry<K, V>> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<java.util.Map.Entry<K, V>> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class EntrySpliterator<K, V> extends java.util.HashMap.HashMapSpliterator<K, V>
+ implements java.util.Spliterator<java.util.Map.Entry<K, V>> {
+
+ EntrySpliterator(
+ java.util.HashMap<K, V> m, int origin, int fence, int est, int expectedModCount) {
+ super(null, 0, 0, 0, 0);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.HashMap.EntrySpliterator<K, V> trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(
+ java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(
+ java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ abstract class HashIterator {
+
+ HashIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public final boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.HashMap.Node<K, V> nextNode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public final void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.HashMap.Node<K, V> current;
+
+ int expectedModCount;
+
+ int index;
+
+ java.util.HashMap.Node<K, V> next;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class HashMapSpliterator<K, V> {
+
+ HashMapSpliterator(
+ java.util.HashMap<K, V> m, int origin, int fence, int est, int expectedModCount) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int getFence() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final long estimateSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.HashMap.Node<K, V> current;
+
+ int est;
+
+ int expectedModCount;
+
+ int fence;
+
+ int index;
+
+ final java.util.HashMap<K, V> map;
+
+ {
+ map = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ final class KeyIterator extends java.util.HashMap.HashIterator
+ implements java.util.Iterator<K> {
+
+ public K next() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ final class KeySet extends java.util.AbstractSet<K> {
+
+ KeySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<K> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<K> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super K> action) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class KeySpliterator<K, V> extends java.util.HashMap.HashMapSpliterator<K, V>
+ implements java.util.Spliterator<K> {
+
+ KeySpliterator(
+ java.util.HashMap<K, V> m, int origin, int fence, int est, int expectedModCount) {
+ super(null, 0, 0, 0, 0);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.HashMap.KeySpliterator<K, V> trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super K> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(java.util.function.Consumer<? super K> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class Node<K, V> implements java.util.Map.Entry<K, V> {
+
+ Node(int hash, K key, V value, java.util.HashMap.Node<K, V> next) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final K getKey() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final V getValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final V setValue(V newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int hash;
+
+ {
+ hash = 0;
+ }
+
+ @UnsupportedAppUsage
+ final K key;
+
+ {
+ key = null;
+ }
+
+ @UnsupportedAppUsage
+ java.util.HashMap.Node<K, V> next;
+
+ @UnsupportedAppUsage
+ V value;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class TreeNode<K, V> extends java.util.LinkedHashMap.LinkedHashMapEntry<K, V> {
+
+ TreeNode(int hash, K key, V val, java.util.HashMap.Node<K, V> next) {
+ super(0, null, null, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.HashMap.TreeNode<K, V> root() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <K, V> void moveRootToFront(
+ java.util.HashMap.Node<K, V>[] tab, java.util.HashMap.TreeNode<K, V> root) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.HashMap.TreeNode<K, V> find(int h, java.lang.Object k, java.lang.Class<?> kc) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.HashMap.TreeNode<K, V> getTreeNode(int h, java.lang.Object k) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static int tieBreakOrder(java.lang.Object a, java.lang.Object b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void treeify(java.util.HashMap.Node<K, V>[] tab) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.HashMap.Node<K, V> untreeify(java.util.HashMap<K, V> map) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.HashMap.TreeNode<K, V> putTreeVal(
+ java.util.HashMap<K, V> map, java.util.HashMap.Node<K, V>[] tab, int h, K k, V v) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void removeTreeNode(
+ java.util.HashMap<K, V> map, java.util.HashMap.Node<K, V>[] tab, boolean movable) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void split(
+ java.util.HashMap<K, V> map,
+ java.util.HashMap.Node<K, V>[] tab,
+ int index,
+ int bit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <K, V> java.util.HashMap.TreeNode<K, V> rotateLeft(
+ java.util.HashMap.TreeNode<K, V> root, java.util.HashMap.TreeNode<K, V> p) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <K, V> java.util.HashMap.TreeNode<K, V> rotateRight(
+ java.util.HashMap.TreeNode<K, V> root, java.util.HashMap.TreeNode<K, V> p) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <K, V> java.util.HashMap.TreeNode<K, V> balanceInsertion(
+ java.util.HashMap.TreeNode<K, V> root, java.util.HashMap.TreeNode<K, V> x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <K, V> java.util.HashMap.TreeNode<K, V> balanceDeletion(
+ java.util.HashMap.TreeNode<K, V> root, java.util.HashMap.TreeNode<K, V> x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <K, V> boolean checkInvariants(java.util.HashMap.TreeNode<K, V> t) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.HashMap.TreeNode<K, V> left;
+
+ java.util.HashMap.TreeNode<K, V> parent;
+
+ java.util.HashMap.TreeNode<K, V> prev;
+
+ boolean red;
+
+ java.util.HashMap.TreeNode<K, V> right;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ final class ValueIterator extends java.util.HashMap.HashIterator
+ implements java.util.Iterator<V> {
+
+ public V next() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ValueSpliterator<K, V> extends java.util.HashMap.HashMapSpliterator<K, V>
+ implements java.util.Spliterator<V> {
+
+ ValueSpliterator(
+ java.util.HashMap<K, V> m, int origin, int fence, int est, int expectedModCount) {
+ super(null, 0, 0, 0, 0);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.HashMap.ValueSpliterator<K, V> trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super V> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(java.util.function.Consumer<? super V> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ final class Values extends java.util.AbstractCollection<V> {
+
+ Values() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<V> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<V> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super V> action) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/HashSet.java b/ojluni/annotations/hiddenapi/java/util/HashSet.java
new file mode 100644
index 0000000..a006121
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/HashSet.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 1997, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class HashSet<E> extends java.util.AbstractSet<E>
+ implements java.util.Set<E>, java.lang.Cloneable, java.io.Serializable {
+
+ public HashSet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public HashSet(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public HashSet(int initialCapacity, float loadFactor) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public HashSet(int initialCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ HashSet(int initialCapacity, float loadFactor, boolean dummy) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object clone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.lang.Object PRESENT;
+
+ static {
+ PRESENT = null;
+ }
+
+ @UnsupportedAppUsage
+ private transient java.util.HashMap<E, java.lang.Object> map;
+
+ static final long serialVersionUID = -5024744406713321676L; // 0xba44859596b8b734L
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/LinkedHashMap.java b/ojluni/annotations/hiddenapi/java/util/LinkedHashMap.java
new file mode 100644
index 0000000..9dd8e37
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/LinkedHashMap.java
@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) 1997, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class LinkedHashMap<K, V> extends java.util.HashMap<K, V> implements java.util.Map<K, V> {
+
+ public LinkedHashMap(int initialCapacity, float loadFactor) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public LinkedHashMap(int initialCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public LinkedHashMap() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public LinkedHashMap(java.util.Map<? extends K, ? extends V> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void linkNodeLast(java.util.LinkedHashMap.LinkedHashMapEntry<K, V> p) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void transferLinks(
+ java.util.LinkedHashMap.LinkedHashMapEntry<K, V> src,
+ java.util.LinkedHashMap.LinkedHashMapEntry<K, V> dst) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void reinitialize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.HashMap.Node<K, V> newNode(int hash, K key, V value, java.util.HashMap.Node<K, V> e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.HashMap.Node<K, V> replacementNode(
+ java.util.HashMap.Node<K, V> p, java.util.HashMap.Node<K, V> next) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.HashMap.TreeNode<K, V> newTreeNode(
+ int hash, K key, V value, java.util.HashMap.Node<K, V> next) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.HashMap.TreeNode<K, V> replacementTreeNode(
+ java.util.HashMap.Node<K, V> p, java.util.HashMap.Node<K, V> next) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void afterNodeRemoval(java.util.HashMap.Node<K, V> e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void afterNodeInsertion(boolean evict) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void afterNodeAccess(java.util.HashMap.Node<K, V> e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void internalWriteEntries(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsValue(java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V get(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V getOrDefault(java.lang.Object key, V defaultValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public java.util.Map.Entry<K, V> eldest() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<K> keySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Collection<V> values() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<java.util.Map.Entry<K, V>> entrySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.BiConsumer<? super K, ? super V> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void replaceAll(
+ java.util.function.BiFunction<? super K, ? super V, ? extends V> function) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ final boolean accessOrder;
+
+ {
+ accessOrder = false;
+ }
+
+ transient java.util.LinkedHashMap.LinkedHashMapEntry<K, V> head;
+
+ private static final long serialVersionUID = 3801124242820219131L; // 0x34c04e5c106cc0fbL
+
+ transient java.util.LinkedHashMap.LinkedHashMapEntry<K, V> tail;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ final class LinkedEntryIterator extends java.util.LinkedHashMap.LinkedHashIterator
+ implements java.util.Iterator<java.util.Map.Entry<K, V>> {
+
+ public java.util.Map.Entry<K, V> next() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ final class LinkedEntrySet extends java.util.AbstractSet<java.util.Map.Entry<K, V>> {
+
+ LinkedEntrySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<java.util.Map.Entry<K, V>> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<java.util.Map.Entry<K, V>> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ abstract class LinkedHashIterator {
+
+ LinkedHashIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public final boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.LinkedHashMap.LinkedHashMapEntry<K, V> nextNode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.LinkedHashMap.LinkedHashMapEntry<K, V> current;
+
+ int expectedModCount;
+
+ java.util.LinkedHashMap.LinkedHashMapEntry<K, V> next;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class LinkedHashMapEntry<K, V> extends java.util.HashMap.Node<K, V> {
+
+ LinkedHashMapEntry(int hash, K key, V value, java.util.HashMap.Node<K, V> next) {
+ super(0, null, null, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.LinkedHashMap.LinkedHashMapEntry<K, V> after;
+
+ java.util.LinkedHashMap.LinkedHashMapEntry<K, V> before;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ final class LinkedKeyIterator extends java.util.LinkedHashMap.LinkedHashIterator
+ implements java.util.Iterator<K> {
+
+ public K next() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ final class LinkedKeySet extends java.util.AbstractSet<K> {
+
+ LinkedKeySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<K> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<K> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super K> action) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ final class LinkedValueIterator extends java.util.LinkedHashMap.LinkedHashIterator
+ implements java.util.Iterator<V> {
+
+ public V next() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ final class LinkedValues extends java.util.AbstractCollection<V> {
+
+ LinkedValues() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<V> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<V> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super V> action) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/LinkedList.java b/ojluni/annotations/hiddenapi/java/util/LinkedList.java
new file mode 100644
index 0000000..c7eb048
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/LinkedList.java
@@ -0,0 +1,427 @@
+/*
+ * Copyright (c) 1997, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class LinkedList<E> extends java.util.AbstractSequentialList<E>
+ implements java.util.List<E>,
+ java.util.Deque<E>,
+ java.lang.Cloneable,
+ java.io.Serializable {
+
+ public LinkedList() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public LinkedList(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void linkFirst(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void linkLast(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void linkBefore(E e, java.util.LinkedList.Node<E> succ) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private E unlinkFirst(java.util.LinkedList.Node<E> f) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private E unlinkLast(java.util.LinkedList.Node<E> l) {
+ throw new RuntimeException("Stub!");
+ }
+
+ E unlink(java.util.LinkedList.Node<E> x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E getFirst() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E getLast() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E removeFirst() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E removeLast() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void addFirst(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void addLast(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(int index, java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E get(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E set(int index, E element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void add(int index, E element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E remove(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean isElementIndex(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean isPositionIndex(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String outOfBoundsMsg(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkElementIndex(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkPositionIndex(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.LinkedList.Node<E> node(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int indexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int lastIndexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E peek() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E element() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E poll() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offer(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offerFirst(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offerLast(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E peekFirst() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E peekLast() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E pollFirst() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E pollLast() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void push(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E pop() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeFirstOccurrence(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeLastOccurrence(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ListIterator<E> listIterator(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> descendingIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.util.LinkedList<E> superClone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object clone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ transient java.util.LinkedList.Node<E> first;
+
+ transient java.util.LinkedList.Node<E> last;
+
+ private static final long serialVersionUID = 876323262645176354L; // 0xc29535d4a608822L
+
+ @UnsupportedAppUsage
+ transient int size = 0; // 0x0
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class DescendingIterator implements java.util.Iterator<E> {
+
+ private DescendingIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.LinkedList.ListItr itr;
+
+ {
+ itr = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class LLSpliterator<E> implements java.util.Spliterator<E> {
+
+ LLSpliterator(java.util.LinkedList<E> list, int est, int expectedModCount) {
+ throw new RuntimeException("Stub!");
+ }
+
+ int getEst() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long estimateSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final int BATCH_UNIT = 1024; // 0x400
+
+ static final int MAX_BATCH = 33554432; // 0x2000000
+
+ int batch;
+
+ java.util.LinkedList.Node<E> current;
+
+ int est;
+
+ int expectedModCount;
+
+ final java.util.LinkedList<E> list;
+
+ {
+ list = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class ListItr implements java.util.ListIterator<E> {
+
+ ListItr(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasPrevious() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E previous() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int nextIndex() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int previousIndex() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void set(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void checkForComodification() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int expectedModCount;
+
+ private java.util.LinkedList.Node<E> lastReturned;
+
+ private java.util.LinkedList.Node<E> next;
+
+ private int nextIndex;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class Node<E> {
+
+ Node(java.util.LinkedList.Node<E> prev, E element, java.util.LinkedList.Node<E> next) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ E item;
+
+ @UnsupportedAppUsage
+ java.util.LinkedList.Node<E> next;
+
+ java.util.LinkedList.Node<E> prev;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/Locale.java b/ojluni/annotations/hiddenapi/java/util/Locale.java
new file mode 100644
index 0000000..3f6a54f
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/Locale.java
@@ -0,0 +1,775 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1996, 2014, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
+ * (C) Copyright IBM Corp. 1996 - 1998 - All Rights Reserved
+ *
+ * The original version of this source code and documentation
+ * is copyrighted and owned by Taligent, Inc., a wholly-owned
+ * subsidiary of IBM. These materials are provided under terms
+ * of a License Agreement between Taligent and Sun. This technology
+ * is protected by multiple US and International patents.
+ *
+ * This notice and attribution to Taligent may not be removed.
+ * Taligent is a registered trademark of Taligent, Inc.
+ *
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Locale implements java.lang.Cloneable, java.io.Serializable {
+
+ private Locale(
+ sun.util.locale.BaseLocale baseLocale, sun.util.locale.LocaleExtensions extensions) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Locale(java.lang.String language, java.lang.String country, java.lang.String variant) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Locale(java.lang.String language, java.lang.String country) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Locale(java.lang.String language) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static java.util.Locale createConstant(
+ java.lang.String lang, java.lang.String country) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.util.Locale getInstance(
+ java.lang.String language, java.lang.String country, java.lang.String variant) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.util.Locale getInstance(
+ java.lang.String language,
+ java.lang.String script,
+ java.lang.String country,
+ java.lang.String variant,
+ sun.util.locale.LocaleExtensions extensions) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ static java.util.Locale getInstance(
+ sun.util.locale.BaseLocale baseloc, sun.util.locale.LocaleExtensions extensions) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Locale getDefault() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Locale getDefault(java.util.Locale.Category category) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Locale initDefault() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.util.Locale initDefault(java.util.Locale.Category category) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static synchronized void setDefault(java.util.Locale newLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static synchronized void setDefault(
+ java.util.Locale.Category category, java.util.Locale newLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Locale[] getAvailableLocales() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String[] getISOCountries() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String[] getISOLanguages() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getLanguage() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getScript() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getCountry() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getVariant() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasExtensions() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Locale stripExtensions() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getExtension(char key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<java.lang.Character> getExtensionKeys() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<java.lang.String> getUnicodeLocaleAttributes() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getUnicodeLocaleType(java.lang.String key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<java.lang.String> getUnicodeLocaleKeys() {
+ throw new RuntimeException("Stub!");
+ }
+
+ sun.util.locale.BaseLocale getBaseLocale() {
+ throw new RuntimeException("Stub!");
+ }
+
+ sun.util.locale.LocaleExtensions getLocaleExtensions() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toLanguageTag() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Locale forLanguageTag(java.lang.String languageTag) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getISO3Language() throws java.util.MissingResourceException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getISO3Country() throws java.util.MissingResourceException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getDisplayLanguage() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getDisplayLanguage(java.util.Locale locale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String normalizeAndValidateLanguage(
+ java.lang.String language, boolean strict) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean isAsciiAlphaNum(java.lang.String string) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getDisplayScript() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getDisplayScript(java.util.Locale inLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getDisplayCountry() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getDisplayCountry(java.util.Locale locale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String normalizeAndValidateRegion(
+ java.lang.String region, boolean strict) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean isValidBcp47Alpha(
+ java.lang.String string, int lowerBound, int upperBound) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean isUnM49AreaCode(java.lang.String code) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getDisplayVariant() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getDisplayVariant(java.util.Locale inLocale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String normalizeAndValidateVariant(java.lang.String variant) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean isValidVariantSubtag(java.lang.String subTag) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getDisplayName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getDisplayName(java.util.Locale locale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object clone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String formatList(
+ java.lang.String[] stringList,
+ java.lang.String listPattern,
+ java.lang.String listCompositionPattern) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String[] composeList(
+ java.text.MessageFormat format, java.lang.String[] list) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean isUnicodeExtensionKey(java.lang.String s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream in)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object readResolve() throws java.io.ObjectStreamException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String convertOldISOCodes(java.lang.String language) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static sun.util.locale.LocaleExtensions getCompatibilityExtensions(
+ java.lang.String language,
+ java.lang.String script,
+ java.lang.String country,
+ java.lang.String variant) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String adjustLanguageCode(java.lang.String languageCode) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.List<java.util.Locale> filter(
+ java.util.List<java.util.Locale.LanguageRange> priorityList,
+ java.util.Collection<java.util.Locale> locales,
+ java.util.Locale.FilteringMode mode) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.List<java.util.Locale> filter(
+ java.util.List<java.util.Locale.LanguageRange> priorityList,
+ java.util.Collection<java.util.Locale> locales) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.List<java.lang.String> filterTags(
+ java.util.List<java.util.Locale.LanguageRange> priorityList,
+ java.util.Collection<java.lang.String> tags,
+ java.util.Locale.FilteringMode mode) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.List<java.lang.String> filterTags(
+ java.util.List<java.util.Locale.LanguageRange> priorityList,
+ java.util.Collection<java.lang.String> tags) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.Locale lookup(
+ java.util.List<java.util.Locale.LanguageRange> priorityList,
+ java.util.Collection<java.util.Locale> locales) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String lookupTag(
+ java.util.List<java.util.Locale.LanguageRange> priorityList,
+ java.util.Collection<java.lang.String> tags) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.util.Locale CANADA;
+
+ static {
+ CANADA = null;
+ }
+
+ public static final java.util.Locale CANADA_FRENCH;
+
+ static {
+ CANADA_FRENCH = null;
+ }
+
+ public static final java.util.Locale CHINA;
+
+ static {
+ CHINA = null;
+ }
+
+ public static final java.util.Locale CHINESE;
+
+ static {
+ CHINESE = null;
+ }
+
+ private static final int DISPLAY_COUNTRY = 1; // 0x1
+
+ private static final int DISPLAY_LANGUAGE = 0; // 0x0
+
+ private static final int DISPLAY_SCRIPT = 3; // 0x3
+
+ private static final int DISPLAY_VARIANT = 2; // 0x2
+
+ public static final java.util.Locale ENGLISH;
+
+ static {
+ ENGLISH = null;
+ }
+
+ public static final java.util.Locale FRANCE;
+
+ static {
+ FRANCE = null;
+ }
+
+ public static final java.util.Locale FRENCH;
+
+ static {
+ FRENCH = null;
+ }
+
+ public static final java.util.Locale GERMAN;
+
+ static {
+ GERMAN = null;
+ }
+
+ public static final java.util.Locale GERMANY;
+
+ static {
+ GERMANY = null;
+ }
+
+ public static final java.util.Locale ITALIAN;
+
+ static {
+ ITALIAN = null;
+ }
+
+ public static final java.util.Locale ITALY;
+
+ static {
+ ITALY = null;
+ }
+
+ public static final java.util.Locale JAPAN;
+
+ static {
+ JAPAN = null;
+ }
+
+ public static final java.util.Locale JAPANESE;
+
+ static {
+ JAPANESE = null;
+ }
+
+ public static final java.util.Locale KOREA;
+
+ static {
+ KOREA = null;
+ }
+
+ public static final java.util.Locale KOREAN;
+
+ static {
+ KOREAN = null;
+ }
+
+ private static final java.util.Locale.Cache LOCALECACHE;
+
+ static {
+ LOCALECACHE = null;
+ }
+
+ public static final java.util.Locale PRC;
+
+ static {
+ PRC = null;
+ }
+
+ public static final char PRIVATE_USE_EXTENSION = 120; // 0x0078 'x'
+
+ public static final java.util.Locale ROOT;
+
+ static {
+ ROOT = null;
+ }
+
+ public static final java.util.Locale SIMPLIFIED_CHINESE;
+
+ static {
+ SIMPLIFIED_CHINESE = null;
+ }
+
+ public static final java.util.Locale TAIWAN;
+
+ static {
+ TAIWAN = null;
+ }
+
+ public static final java.util.Locale TRADITIONAL_CHINESE;
+
+ static {
+ TRADITIONAL_CHINESE = null;
+ }
+
+ public static final java.util.Locale UK;
+
+ static {
+ UK = null;
+ }
+
+ private static final java.lang.String UNDETERMINED_LANGUAGE = "und";
+
+ public static final char UNICODE_LOCALE_EXTENSION = 117; // 0x0075 'u'
+
+ public static final java.util.Locale US;
+
+ static {
+ US = null;
+ }
+
+ private transient sun.util.locale.BaseLocale baseLocale;
+
+ private static volatile java.util.Locale defaultDisplayLocale;
+
+ private static volatile java.util.Locale defaultFormatLocale;
+
+ private transient volatile int hashCodeValue = 0; // 0x0
+
+ private static volatile java.lang.String[] isoCountries;
+
+ private static volatile java.lang.String[] isoLanguages;
+
+ private transient volatile java.lang.String languageTag;
+
+ private transient sun.util.locale.LocaleExtensions localeExtensions;
+
+ private static final java.io.ObjectStreamField[] serialPersistentFields;
+
+ static {
+ serialPersistentFields = new java.io.ObjectStreamField[0];
+ }
+
+ static final long serialVersionUID = 9149081749638150636L; // 0x7ef811609c30f9ecL
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static final class Builder {
+
+ public Builder() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Locale.Builder setLocale(java.util.Locale locale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Locale.Builder setLanguageTag(java.lang.String languageTag) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Locale.Builder setLanguage(java.lang.String language) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Locale.Builder setScript(java.lang.String script) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Locale.Builder setRegion(java.lang.String region) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Locale.Builder setVariant(java.lang.String variant) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Locale.Builder setExtension(char key, java.lang.String value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Locale.Builder setUnicodeLocaleKeyword(
+ java.lang.String key, java.lang.String type) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Locale.Builder addUnicodeLocaleAttribute(java.lang.String attribute) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Locale.Builder removeUnicodeLocaleAttribute(java.lang.String attribute) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Locale.Builder clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Locale.Builder clearExtensions() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Locale build() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final sun.util.locale.InternalLocaleBuilder localeBuilder;
+
+ {
+ localeBuilder = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class Cache
+ extends sun.util.locale.LocaleObjectCache<
+ java.util.Locale.LocaleKey, java.util.Locale> {
+
+ private Cache() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.util.Locale createObject(java.util.Locale.LocaleKey key) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static enum Category {
+ DISPLAY,
+ FORMAT;
+
+ private Category(
+ java.lang.String languageKey,
+ java.lang.String scriptKey,
+ java.lang.String countryKey,
+ java.lang.String variantKey) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private Category() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.lang.String countryKey = null;
+
+ final java.lang.String languageKey = null;
+
+ final java.lang.String scriptKey = null;
+
+ final java.lang.String variantKey = null;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static enum FilteringMode {
+ AUTOSELECT_FILTERING,
+ EXTENDED_FILTERING,
+ IGNORE_EXTENDED_RANGES,
+ MAP_EXTENDED_RANGES,
+ REJECT_EXTENDED_RANGES;
+
+ private FilteringMode() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static final class LanguageRange {
+
+ public LanguageRange(java.lang.String range) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public LanguageRange(java.lang.String range, double weight) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean isSubtagIllFormed(java.lang.String subtag, boolean isFirstSubtag) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getRange() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public double getWeight() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.List<java.util.Locale.LanguageRange> parse(
+ java.lang.String ranges) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.List<java.util.Locale.LanguageRange> parse(
+ java.lang.String ranges,
+ java.util.Map<java.lang.String, java.util.List<java.lang.String>> map) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.List<java.util.Locale.LanguageRange> mapEquivalents(
+ java.util.List<java.util.Locale.LanguageRange> priorityList,
+ java.util.Map<java.lang.String, java.util.List<java.lang.String>> map) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final double MAX_WEIGHT = 1.0;
+
+ public static final double MIN_WEIGHT = 0.0;
+
+ private volatile int hash = 0; // 0x0
+
+ private final java.lang.String range;
+
+ {
+ range = null;
+ }
+
+ private final double weight;
+
+ {
+ weight = 0;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static final class LocaleKey {
+
+ private LocaleKey(
+ sun.util.locale.BaseLocale baseLocale,
+ sun.util.locale.LocaleExtensions extensions) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final sun.util.locale.BaseLocale base;
+
+ {
+ base = null;
+ }
+
+ private final sun.util.locale.LocaleExtensions exts;
+
+ {
+ exts = null;
+ }
+
+ private final int hash;
+
+ {
+ hash = 0;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class NoImagePreloadHolder {
+
+ private NoImagePreloadHolder() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static volatile java.util.Locale defaultLocale;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/PriorityQueue.java b/ojluni/annotations/hiddenapi/java/util/PriorityQueue.java
new file mode 100644
index 0000000..b8d2a18
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/PriorityQueue.java
@@ -0,0 +1,277 @@
+/*
+ * Copyright (c) 2003, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class PriorityQueue<E> extends java.util.AbstractQueue<E> implements java.io.Serializable {
+
+ public PriorityQueue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public PriorityQueue(int initialCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public PriorityQueue(java.util.Comparator<? super E> comparator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public PriorityQueue(int initialCapacity, java.util.Comparator<? super E> comparator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public PriorityQueue(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public PriorityQueue(java.util.PriorityQueue<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public PriorityQueue(java.util.SortedSet<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void initFromPriorityQueue(java.util.PriorityQueue<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void initElementsFromCollection(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void initFromCollection(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void grow(int minCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int hugeCapacity(int minCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offer(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E peek() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int indexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean removeEq(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E poll() {
+ throw new RuntimeException("Stub!");
+ }
+
+ E removeAt(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void siftUp(int k, E x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void siftUpComparable(int k, E x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void siftUpUsingComparator(int k, E x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void siftDown(int k, E x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void siftDownComparable(int k, E x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void siftDownUsingComparator(int k, E x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void heapify() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Comparator<? super E> comparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int DEFAULT_INITIAL_CAPACITY = 11; // 0xb
+
+ private static final int MAX_ARRAY_SIZE = 2147483639; // 0x7ffffff7
+
+ private final java.util.Comparator<? super E> comparator;
+
+ {
+ comparator = null;
+ }
+
+ @UnsupportedAppUsage
+ transient int modCount;
+
+ @UnsupportedAppUsage
+ transient java.lang.Object[] queue;
+
+ private static final long serialVersionUID = -7720805057305804111L; // 0x94da30b4fb3f82b1L
+
+ @UnsupportedAppUsage
+ int size;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private final class Itr implements java.util.Iterator<E> {
+
+ private Itr() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int cursor;
+
+ private int expectedModCount;
+
+ private java.util.ArrayDeque<E> forgetMeNot;
+
+ private int lastRet = -1; // 0xffffffff
+
+ private E lastRetElt;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class PriorityQueueSpliterator<E> implements java.util.Spliterator<E> {
+
+ PriorityQueueSpliterator(
+ java.util.PriorityQueue<E> pq, int origin, int fence, int expectedModCount) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int getFence() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.PriorityQueue.PriorityQueueSpliterator<E> trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long estimateSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int expectedModCount;
+
+ private int fence;
+
+ private int index;
+
+ private final java.util.PriorityQueue<E> pq;
+
+ {
+ pq = null;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/Properties.java b/ojluni/annotations/hiddenapi/java/util/Properties.java
new file mode 100644
index 0000000..3aee2d1
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/Properties.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1995, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Properties extends java.util.Hashtable<java.lang.Object, java.lang.Object> {
+
+ public Properties() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Properties(java.util.Properties defaults) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized java.lang.Object setProperty(java.lang.String key, java.lang.String value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void load(java.io.Reader reader) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void load(java.io.InputStream inStream) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void load0(java.util.Properties.LineReader lr) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String loadConvert(char[] in, int off, int len, char[] convtBuf) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private java.lang.String saveConvert(
+ java.lang.String theString, boolean escapeSpace, boolean escapeUnicode) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void writeComments(java.io.BufferedWriter bw, java.lang.String comments)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public void save(java.io.OutputStream out, java.lang.String comments) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void store(java.io.Writer writer, java.lang.String comments) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void store(java.io.OutputStream out, java.lang.String comments)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void store0(java.io.BufferedWriter bw, java.lang.String comments, boolean escUnicode)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void loadFromXML(java.io.InputStream in)
+ throws java.io.IOException, java.util.InvalidPropertiesFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void storeToXML(java.io.OutputStream os, java.lang.String comment)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void storeToXML(
+ java.io.OutputStream os, java.lang.String comment, java.lang.String encoding)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getProperty(java.lang.String key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getProperty(java.lang.String key, java.lang.String defaultValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Enumeration<?> propertyNames() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<java.lang.String> stringPropertyNames() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void list(java.io.PrintStream out) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void list(java.io.PrintWriter out) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized void enumerate(java.util.Hashtable<java.lang.String, java.lang.Object> h) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized void enumerateStringProperties(
+ java.util.Hashtable<java.lang.String, java.lang.String> h) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static char toHex(int nibble) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.util.Properties defaults;
+
+ private static final char[] hexDigit;
+
+ static {
+ hexDigit = new char[0];
+ }
+
+ private static final long serialVersionUID = 4112578634029874840L; // 0x3912d07a70363e98L
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ class LineReader {
+
+ public LineReader(java.io.InputStream inStream) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public LineReader(java.io.Reader reader) {
+ throw new RuntimeException("Stub!");
+ }
+
+ int readLine() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ byte[] inByteBuf;
+
+ char[] inCharBuf;
+
+ int inLimit = 0; // 0x0
+
+ int inOff = 0; // 0x0
+
+ java.io.InputStream inStream;
+
+ char[] lineBuf;
+
+ java.io.Reader reader;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/Random.java b/ojluni/annotations/hiddenapi/java/util/Random.java
new file mode 100644
index 0000000..ce80aa1
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/Random.java
@@ -0,0 +1,380 @@
+/*
+ * Copyright (c) 1995, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Random implements java.io.Serializable {
+
+ public Random() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Random(long seed) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static long seedUniquifier() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static long initialScramble(long seed) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setSeed(long seed) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected int next(int bits) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void nextBytes(byte[] bytes) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final long internalNextLong(long origin, long bound) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int internalNextInt(int origin, int bound) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final double internalNextDouble(double origin, double bound) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int nextInt() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int nextInt(int bound) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long nextLong() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean nextBoolean() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public float nextFloat() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public double nextDouble() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized double nextGaussian() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.IntStream ints(long streamSize) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.IntStream ints() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.IntStream ints(
+ long streamSize, int randomNumberOrigin, int randomNumberBound) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.IntStream ints(int randomNumberOrigin, int randomNumberBound) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.LongStream longs(long streamSize) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.LongStream longs() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.LongStream longs(
+ long streamSize, long randomNumberOrigin, long randomNumberBound) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.LongStream longs(long randomNumberOrigin, long randomNumberBound) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.DoubleStream doubles(long streamSize) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.DoubleStream doubles() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.DoubleStream doubles(
+ long streamSize, double randomNumberOrigin, double randomNumberBound) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.DoubleStream doubles(
+ double randomNumberOrigin, double randomNumberBound) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void resetSeed(long seedVal) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.lang.String BadBound = "bound must be positive";
+
+ static final java.lang.String BadRange = "bound must be greater than origin";
+
+ static final java.lang.String BadSize = "size must be non-negative";
+
+ private static final double DOUBLE_UNIT = 1.1102230246251565E-16;
+
+ private static final long addend = 11L; // 0xbL
+
+ private boolean haveNextNextGaussian = false;
+
+ private static final long mask = 281474976710655L; // 0xffffffffffffL
+
+ private static final long multiplier = 25214903917L; // 0x5deece66dL
+
+ private double nextNextGaussian;
+
+ private final java.util.concurrent.atomic.AtomicLong seed;
+
+ {
+ seed = null;
+ }
+
+ private static final long seedOffset;
+
+ static {
+ seedOffset = 0;
+ }
+
+ private static final java.util.concurrent.atomic.AtomicLong seedUniquifier;
+
+ static {
+ seedUniquifier = null;
+ }
+
+ private static final java.io.ObjectStreamField[] serialPersistentFields;
+
+ static {
+ serialPersistentFields = new java.io.ObjectStreamField[0];
+ }
+
+ static final long serialVersionUID = 3905348978240129619L; // 0x363296344bf00a53L
+
+ private static final sun.misc.Unsafe unsafe;
+
+ static {
+ unsafe = null;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class RandomDoublesSpliterator implements java.util.Spliterator.OfDouble {
+
+ RandomDoublesSpliterator(
+ java.util.Random rng, long index, long fence, double origin, double bound) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Random.RandomDoublesSpliterator trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long estimateSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(java.util.function.DoubleConsumer consumer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.DoubleConsumer consumer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final double bound;
+
+ {
+ bound = 0;
+ }
+
+ final long fence;
+
+ {
+ fence = 0;
+ }
+
+ long index;
+
+ final double origin;
+
+ {
+ origin = 0;
+ }
+
+ final java.util.Random rng;
+
+ {
+ rng = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class RandomIntsSpliterator implements java.util.Spliterator.OfInt {
+
+ RandomIntsSpliterator(java.util.Random rng, long index, long fence, int origin, int bound) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Random.RandomIntsSpliterator trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long estimateSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(java.util.function.IntConsumer consumer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.IntConsumer consumer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int bound;
+
+ {
+ bound = 0;
+ }
+
+ final long fence;
+
+ {
+ fence = 0;
+ }
+
+ long index;
+
+ final int origin;
+
+ {
+ origin = 0;
+ }
+
+ final java.util.Random rng;
+
+ {
+ rng = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class RandomLongsSpliterator implements java.util.Spliterator.OfLong {
+
+ RandomLongsSpliterator(
+ java.util.Random rng, long index, long fence, long origin, long bound) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Random.RandomLongsSpliterator trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long estimateSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(java.util.function.LongConsumer consumer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.LongConsumer consumer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final long bound;
+
+ {
+ bound = 0;
+ }
+
+ final long fence;
+
+ {
+ fence = 0;
+ }
+
+ long index;
+
+ final long origin;
+
+ {
+ origin = 0;
+ }
+
+ final java.util.Random rng;
+
+ {
+ rng = null;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/TimerTask.java b/ojluni/annotations/hiddenapi/java/util/TimerTask.java
new file mode 100644
index 0000000..8a5c6d5
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/TimerTask.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 1999, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class TimerTask implements java.lang.Runnable {
+
+ protected TimerTask() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract void run();
+
+ public boolean cancel() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long scheduledExecutionTime() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final int CANCELLED = 3; // 0x3
+
+ static final int EXECUTED = 2; // 0x2
+
+ static final int SCHEDULED = 1; // 0x1
+
+ static final int VIRGIN = 0; // 0x0
+
+ final java.lang.Object lock;
+
+ {
+ lock = null;
+ }
+
+ long nextExecutionTime;
+
+ @UnsupportedAppUsage
+ long period = 0; // 0x0
+
+ int state = 0; // 0x0
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/UUID.java b/ojluni/annotations/hiddenapi/java/util/UUID.java
new file mode 100644
index 0000000..0585e5de
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/UUID.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2003, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class UUID implements java.io.Serializable, java.lang.Comparable<java.util.UUID> {
+
+ private UUID(byte[] data) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public UUID(long mostSigBits, long leastSigBits) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.UUID randomUUID() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.UUID nameUUIDFromBytes(byte[] name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.UUID fromString(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getLeastSignificantBits() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getMostSignificantBits() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int version() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int variant() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long timestamp() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int clockSequence() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long node() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.String digits(long val, int digits) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int compareTo(java.util.UUID val) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private final long leastSigBits;
+
+ {
+ leastSigBits = 0;
+ }
+
+ @UnsupportedAppUsage
+ private final long mostSigBits;
+
+ {
+ mostSigBits = 0;
+ }
+
+ private static final long serialVersionUID = -4856846361193249489L; // 0xbc9903f7986d852fL
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class Holder {
+
+ private Holder() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final java.security.SecureRandom numberGenerator;
+
+ static {
+ numberGenerator = null;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/Vector.java b/ojluni/annotations/hiddenapi/java/util/Vector.java
new file mode 100644
index 0000000..394a097
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/Vector.java
@@ -0,0 +1,402 @@
+/*
+ * Copyright (c) 1994, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Vector<E> extends java.util.AbstractList<E>
+ implements java.util.List<E>,
+ java.util.RandomAccess,
+ java.lang.Cloneable,
+ java.io.Serializable {
+
+ public Vector(int initialCapacity, int capacityIncrement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Vector(int initialCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Vector() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Vector(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void copyInto(java.lang.Object[] anArray) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void trimToSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void ensureCapacity(int minCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void ensureCapacityHelper(int minCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void grow(int minCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int hugeCapacity(int minCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setSize(int newSize) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int capacity() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Enumeration<E> elements() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int indexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int indexOf(java.lang.Object o, int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int lastIndexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int lastIndexOf(java.lang.Object o, int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized E elementAt(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized E firstElement() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized E lastElement() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setElementAt(E obj, int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void removeElementAt(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void insertElementAt(E obj, int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void addElement(E obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized boolean removeElement(java.lang.Object obj) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void removeAllElements() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized java.lang.Object clone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ E elementData(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized E get(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized E set(int index, E element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized boolean add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void add(int index, E element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized E remove(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized boolean containsAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized boolean addAll(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized boolean removeAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized boolean retainAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized boolean addAll(int index, java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized java.util.List<E> subList(int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected synchronized void removeRange(int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized java.util.ListIterator<E> listIterator(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized java.util.ListIterator<E> listIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void forEach(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized boolean removeIf(java.util.function.Predicate<? super E> filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void replaceAll(java.util.function.UnaryOperator<E> operator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void sort(java.util.Comparator<? super E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int MAX_ARRAY_SIZE = 2147483639; // 0x7ffffff7
+
+ protected int capacityIncrement;
+
+ protected int elementCount;
+
+ protected java.lang.Object[] elementData;
+
+ private static final long serialVersionUID = -2767605614048989439L; // 0xd9977d5b803baf01L
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class Itr implements java.util.Iterator<E> {
+
+ private Itr() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void checkForComodification() {
+ throw new RuntimeException("Stub!");
+ }
+
+ int cursor;
+
+ int expectedModCount;
+
+ int lastRet = -1; // 0xffffffff
+
+ protected int limit;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ final class ListItr extends Itr implements java.util.ListIterator<E> {
+
+ ListItr(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasPrevious() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int nextIndex() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int previousIndex() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E previous() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void set(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class VectorSpliterator<E> implements java.util.Spliterator<E> {
+
+ VectorSpliterator(
+ java.util.Vector<E> list,
+ java.lang.Object[] array,
+ int origin,
+ int fence,
+ int expectedModCount) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int getFence() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long estimateSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object[] array;
+
+ private int expectedModCount;
+
+ private int fence;
+
+ private int index;
+
+ private final java.util.Vector<E> list;
+
+ {
+ list = null;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/concurrent/ConcurrentHashMap.java b/ojluni/annotations/hiddenapi/java/util/concurrent/ConcurrentHashMap.java
new file mode 100644
index 0000000..86d503f
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/concurrent/ConcurrentHashMap.java
@@ -0,0 +1,2788 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ConcurrentHashMap<K, V> extends java.util.AbstractMap<K, V>
+ implements java.util.concurrent.ConcurrentMap<K, V>, java.io.Serializable {
+
+ public ConcurrentHashMap() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ConcurrentHashMap(int initialCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ConcurrentHashMap(java.util.Map<? extends K, ? extends V> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ConcurrentHashMap(int initialCapacity, float loadFactor) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final int spread(int h) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int tableSizeFor(int c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.lang.Class<?> comparableClassFor(java.lang.Object x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static int compareComparables(java.lang.Class<?> kc, java.lang.Object k, java.lang.Object x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final <K, V> java.util.concurrent.ConcurrentHashMap.Node<K, V> tabAt(
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab, int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final <K, V> boolean casTabAt(
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab,
+ int i,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V> c,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V> v) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final <K, V> void setTabAt(
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab,
+ int i,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V> v) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V get(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsKey(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsValue(java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V put(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final V putVal(K key, V value, boolean onlyIfAbsent) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void putAll(java.util.Map<? extends K, ? extends V> m) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V remove(java.lang.Object key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final V replaceNode(java.lang.Object key, V value, java.lang.Object cv) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<K> keySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Collection<V> values() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Set<java.util.Map.Entry<K, V>> entrySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V putIfAbsent(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object key, java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean replace(K key, V oldValue, V newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V replace(K key, V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V getOrDefault(java.lang.Object key, V defaultValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.BiConsumer<? super K, ? super V> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void replaceAll(
+ java.util.function.BiFunction<? super K, ? super V, ? extends V> function) {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean removeEntryIf(
+ java.util.function.Predicate<? super java.util.Map.Entry<K, V>> function) {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean removeValueIf(java.util.function.Predicate<? super V> function) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V computeIfAbsent(
+ K key, java.util.function.Function<? super K, ? extends V> mappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V computeIfPresent(
+ K key,
+ java.util.function.BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V compute(
+ K key,
+ java.util.function.BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V merge(
+ K key,
+ V value,
+ java.util.function.BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Enumeration<K> keys() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Enumeration<V> elements() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long mappingCount() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <K>
+ java.util.concurrent.ConcurrentHashMap.KeySetView<K, java.lang.Boolean> newKeySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <K>
+ java.util.concurrent.ConcurrentHashMap.KeySetView<K, java.lang.Boolean> newKeySet(
+ int initialCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.concurrent.ConcurrentHashMap.KeySetView<K, V> keySet(V mappedValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final int resizeStamp(int n) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.concurrent.ConcurrentHashMap.Node<K, V>[] initTable() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final void addCount(long x, int check) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.concurrent.ConcurrentHashMap.Node<K, V>[] helpTransfer(
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V> f) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final void tryPresize(int size) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final void transfer(
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] nextTab) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final long sumCount() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final void fullAddCount(long x, boolean wasUncontended) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final void treeifyBin(
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab, int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <K, V> java.util.concurrent.ConcurrentHashMap.Node<K, V> untreeify(
+ java.util.concurrent.ConcurrentHashMap.Node<K, V> b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int batchFor(long b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(
+ long parallelismThreshold, java.util.function.BiConsumer<? super K, ? super V> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <U> void forEach(
+ long parallelismThreshold,
+ java.util.function.BiFunction<? super K, ? super V, ? extends U> transformer,
+ java.util.function.Consumer<? super U> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <U> U search(
+ long parallelismThreshold,
+ java.util.function.BiFunction<? super K, ? super V, ? extends U> searchFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <U> U reduce(
+ long parallelismThreshold,
+ java.util.function.BiFunction<? super K, ? super V, ? extends U> transformer,
+ java.util.function.BiFunction<? super U, ? super U, ? extends U> reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public double reduceToDouble(
+ long parallelismThreshold,
+ java.util.function.ToDoubleBiFunction<? super K, ? super V> transformer,
+ double basis,
+ java.util.function.DoubleBinaryOperator reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long reduceToLong(
+ long parallelismThreshold,
+ java.util.function.ToLongBiFunction<? super K, ? super V> transformer,
+ long basis,
+ java.util.function.LongBinaryOperator reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int reduceToInt(
+ long parallelismThreshold,
+ java.util.function.ToIntBiFunction<? super K, ? super V> transformer,
+ int basis,
+ java.util.function.IntBinaryOperator reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachKey(
+ long parallelismThreshold, java.util.function.Consumer<? super K> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <U> void forEachKey(
+ long parallelismThreshold,
+ java.util.function.Function<? super K, ? extends U> transformer,
+ java.util.function.Consumer<? super U> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <U> U searchKeys(
+ long parallelismThreshold,
+ java.util.function.Function<? super K, ? extends U> searchFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K reduceKeys(
+ long parallelismThreshold,
+ java.util.function.BiFunction<? super K, ? super K, ? extends K> reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <U> U reduceKeys(
+ long parallelismThreshold,
+ java.util.function.Function<? super K, ? extends U> transformer,
+ java.util.function.BiFunction<? super U, ? super U, ? extends U> reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public double reduceKeysToDouble(
+ long parallelismThreshold,
+ java.util.function.ToDoubleFunction<? super K> transformer,
+ double basis,
+ java.util.function.DoubleBinaryOperator reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long reduceKeysToLong(
+ long parallelismThreshold,
+ java.util.function.ToLongFunction<? super K> transformer,
+ long basis,
+ java.util.function.LongBinaryOperator reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int reduceKeysToInt(
+ long parallelismThreshold,
+ java.util.function.ToIntFunction<? super K> transformer,
+ int basis,
+ java.util.function.IntBinaryOperator reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachValue(
+ long parallelismThreshold, java.util.function.Consumer<? super V> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <U> void forEachValue(
+ long parallelismThreshold,
+ java.util.function.Function<? super V, ? extends U> transformer,
+ java.util.function.Consumer<? super U> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <U> U searchValues(
+ long parallelismThreshold,
+ java.util.function.Function<? super V, ? extends U> searchFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V reduceValues(
+ long parallelismThreshold,
+ java.util.function.BiFunction<? super V, ? super V, ? extends V> reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <U> U reduceValues(
+ long parallelismThreshold,
+ java.util.function.Function<? super V, ? extends U> transformer,
+ java.util.function.BiFunction<? super U, ? super U, ? extends U> reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public double reduceValuesToDouble(
+ long parallelismThreshold,
+ java.util.function.ToDoubleFunction<? super V> transformer,
+ double basis,
+ java.util.function.DoubleBinaryOperator reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long reduceValuesToLong(
+ long parallelismThreshold,
+ java.util.function.ToLongFunction<? super V> transformer,
+ long basis,
+ java.util.function.LongBinaryOperator reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int reduceValuesToInt(
+ long parallelismThreshold,
+ java.util.function.ToIntFunction<? super V> transformer,
+ int basis,
+ java.util.function.IntBinaryOperator reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachEntry(
+ long parallelismThreshold,
+ java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <U> void forEachEntry(
+ long parallelismThreshold,
+ java.util.function.Function<java.util.Map.Entry<K, V>, ? extends U> transformer,
+ java.util.function.Consumer<? super U> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <U> U searchEntries(
+ long parallelismThreshold,
+ java.util.function.Function<java.util.Map.Entry<K, V>, ? extends U> searchFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> reduceEntries(
+ long parallelismThreshold,
+ java.util.function.BiFunction<
+ java.util.Map.Entry<K, V>,
+ java.util.Map.Entry<K, V>,
+ ? extends java.util.Map.Entry<K, V>>
+ reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <U> U reduceEntries(
+ long parallelismThreshold,
+ java.util.function.Function<java.util.Map.Entry<K, V>, ? extends U> transformer,
+ java.util.function.BiFunction<? super U, ? super U, ? extends U> reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public double reduceEntriesToDouble(
+ long parallelismThreshold,
+ java.util.function.ToDoubleFunction<java.util.Map.Entry<K, V>> transformer,
+ double basis,
+ java.util.function.DoubleBinaryOperator reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long reduceEntriesToLong(
+ long parallelismThreshold,
+ java.util.function.ToLongFunction<java.util.Map.Entry<K, V>> transformer,
+ long basis,
+ java.util.function.LongBinaryOperator reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int reduceEntriesToInt(
+ long parallelismThreshold,
+ java.util.function.ToIntFunction<java.util.Map.Entry<K, V>> transformer,
+ int basis,
+ java.util.function.IntBinaryOperator reducer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int ABASE;
+
+ static {
+ ABASE = 0;
+ }
+
+ private static final int ASHIFT;
+
+ static {
+ ASHIFT = 0;
+ }
+
+ private static final long BASECOUNT;
+
+ static {
+ BASECOUNT = 0;
+ }
+
+ private static final long CELLSBUSY;
+
+ static {
+ CELLSBUSY = 0;
+ }
+
+ private static final long CELLVALUE;
+
+ static {
+ CELLVALUE = 0;
+ }
+
+ private static final int DEFAULT_CAPACITY = 16; // 0x10
+
+ private static final int DEFAULT_CONCURRENCY_LEVEL = 16; // 0x10
+
+ static final int HASH_BITS = 2147483647; // 0x7fffffff
+
+ private static final float LOAD_FACTOR = 0.75f;
+
+ private static final int MAXIMUM_CAPACITY = 1073741824; // 0x40000000
+
+ static final int MAX_ARRAY_SIZE = 2147483639; // 0x7ffffff7
+
+ private static final int MAX_RESIZERS = 65535; // 0xffff
+
+ private static final int MIN_TRANSFER_STRIDE = 16; // 0x10
+
+ static final int MIN_TREEIFY_CAPACITY = 64; // 0x40
+
+ static final int MOVED = -1; // 0xffffffff
+
+ static final int NCPU;
+
+ static {
+ NCPU = 0;
+ }
+
+ static final int RESERVED = -3; // 0xfffffffd
+
+ private static final int RESIZE_STAMP_BITS = 16; // 0x10
+
+ private static final int RESIZE_STAMP_SHIFT = 16; // 0x10
+
+ private static final long SIZECTL;
+
+ static {
+ SIZECTL = 0;
+ }
+
+ private static final long TRANSFERINDEX;
+
+ static {
+ TRANSFERINDEX = 0;
+ }
+
+ static final int TREEBIN = -2; // 0xfffffffe
+
+ static final int TREEIFY_THRESHOLD = 8; // 0x8
+
+ private static final sun.misc.Unsafe U;
+
+ static {
+ U = null;
+ }
+
+ static final int UNTREEIFY_THRESHOLD = 6; // 0x6
+
+ private transient volatile long baseCount;
+
+ private transient volatile int cellsBusy;
+
+ private transient volatile java.util.concurrent.ConcurrentHashMap.CounterCell[] counterCells;
+
+ private transient java.util.concurrent.ConcurrentHashMap.EntrySetView<K, V> entrySet;
+
+ private transient java.util.concurrent.ConcurrentHashMap.KeySetView<K, V> keySet;
+
+ private transient volatile java.util.concurrent.ConcurrentHashMap.Node<K, V>[] nextTable;
+
+ private static final java.io.ObjectStreamField[] serialPersistentFields;
+
+ static {
+ serialPersistentFields = new java.io.ObjectStreamField[0];
+ }
+
+ private static final long serialVersionUID = 7249069246763182397L; // 0x6499de129d87293dL
+
+ private transient volatile int sizeCtl;
+
+ transient volatile java.util.concurrent.ConcurrentHashMap.Node<K, V>[] table;
+
+ private transient volatile int transferIndex;
+
+ private transient java.util.concurrent.ConcurrentHashMap.ValuesView<K, V> values;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class BaseIterator<K, V> extends java.util.concurrent.ConcurrentHashMap.Traverser<K, V> {
+
+ BaseIterator(
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab,
+ int size,
+ int index,
+ int limit,
+ java.util.concurrent.ConcurrentHashMap<K, V> map) {
+ super(null, 0, 0, 0);
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ public final boolean hasMoreElements() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.concurrent.ConcurrentHashMap.Node<K, V> lastReturned;
+
+ final java.util.concurrent.ConcurrentHashMap<K, V> map;
+
+ {
+ map = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ abstract static class BulkTask<K, V, R> extends java.util.concurrent.CountedCompleter<R> {
+
+ BulkTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> par,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.concurrent.ConcurrentHashMap.Node<K, V> advance() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void pushState(
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t, int i, int n) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void recoverState(int n) {
+ throw new RuntimeException("Stub!");
+ }
+
+ int baseIndex;
+
+ int baseLimit;
+
+ final int baseSize;
+
+ {
+ baseSize = 0;
+ }
+
+ int batch;
+
+ int index;
+
+ java.util.concurrent.ConcurrentHashMap.Node<K, V> next;
+
+ java.util.concurrent.ConcurrentHashMap.TableStack<K, V> spare;
+
+ java.util.concurrent.ConcurrentHashMap.TableStack<K, V> stack;
+
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ abstract static class CollectionView<K, V, E>
+ implements java.util.Collection<E>, java.io.Serializable {
+
+ CollectionView(java.util.concurrent.ConcurrentHashMap<K, V> map) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.concurrent.ConcurrentHashMap<K, V> getMap() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.util.Iterator<E> iterator();
+
+ public abstract boolean contains(java.lang.Object o);
+
+ public abstract boolean remove(java.lang.Object o);
+
+ public final java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean containsAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean removeAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean retainAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.lang.String OOME_MSG = "Required array size too large";
+
+ final java.util.concurrent.ConcurrentHashMap<K, V> map;
+
+ {
+ map = null;
+ }
+
+ private static final long serialVersionUID = 7249069246763182397L; // 0x6499de129d87293dL
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class CounterCell {
+
+ CounterCell(long x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ volatile long value;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class EntryIterator<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BaseIterator<K, V>
+ implements java.util.Iterator<java.util.Map.Entry<K, V>> {
+
+ EntryIterator(
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab,
+ int index,
+ int size,
+ int limit,
+ java.util.concurrent.ConcurrentHashMap<K, V> map) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> next() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class EntrySetView<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.CollectionView<
+ K, V, java.util.Map.Entry<K, V>>
+ implements java.util.Set<java.util.Map.Entry<K, V>>, java.io.Serializable {
+
+ EntrySetView(java.util.concurrent.ConcurrentHashMap<K, V> map) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<java.util.Map.Entry<K, V>> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(java.util.Map.Entry<K, V> e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(java.util.Collection<? extends java.util.Map.Entry<K, V>> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeIf(
+ java.util.function.Predicate<? super java.util.Map.Entry<K, V>> filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<java.util.Map.Entry<K, V>> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = 2249069246763182397L; // 0x1f364c905893293dL
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class EntrySpliterator<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.Traverser<K, V>
+ implements java.util.Spliterator<java.util.Map.Entry<K, V>> {
+
+ EntrySpliterator(
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab,
+ int size,
+ int index,
+ int limit,
+ long est,
+ java.util.concurrent.ConcurrentHashMap<K, V> map) {
+ super(null, 0, 0, 0);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.concurrent.ConcurrentHashMap.EntrySpliterator<K, V> trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(
+ java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(
+ java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long estimateSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+
+ long est;
+
+ final java.util.concurrent.ConcurrentHashMap<K, V> map;
+
+ {
+ map = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ForEachEntryTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Void> {
+
+ ForEachEntryTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action;
+
+ {
+ action = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ForEachKeyTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Void> {
+
+ ForEachKeyTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.function.Consumer<? super K> action) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.function.Consumer<? super K> action;
+
+ {
+ action = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ForEachMappingTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Void> {
+
+ ForEachMappingTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.function.BiConsumer<? super K, ? super V> action) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.function.BiConsumer<? super K, ? super V> action;
+
+ {
+ action = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ForEachTransformedEntryTask<K, V, U>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Void> {
+
+ ForEachTransformedEntryTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.function.Function<java.util.Map.Entry<K, V>, ? extends U> transformer,
+ java.util.function.Consumer<? super U> action) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.function.Consumer<? super U> action;
+
+ {
+ action = null;
+ }
+
+ final java.util.function.Function<java.util.Map.Entry<K, V>, ? extends U> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ForEachTransformedKeyTask<K, V, U>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Void> {
+
+ ForEachTransformedKeyTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.function.Function<? super K, ? extends U> transformer,
+ java.util.function.Consumer<? super U> action) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.function.Consumer<? super U> action;
+
+ {
+ action = null;
+ }
+
+ final java.util.function.Function<? super K, ? extends U> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ForEachTransformedMappingTask<K, V, U>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Void> {
+
+ ForEachTransformedMappingTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.function.BiFunction<? super K, ? super V, ? extends U> transformer,
+ java.util.function.Consumer<? super U> action) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.function.Consumer<? super U> action;
+
+ {
+ action = null;
+ }
+
+ final java.util.function.BiFunction<? super K, ? super V, ? extends U> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ForEachTransformedValueTask<K, V, U>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Void> {
+
+ ForEachTransformedValueTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.function.Function<? super V, ? extends U> transformer,
+ java.util.function.Consumer<? super U> action) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.function.Consumer<? super U> action;
+
+ {
+ action = null;
+ }
+
+ final java.util.function.Function<? super V, ? extends U> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ForEachValueTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Void> {
+
+ ForEachValueTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.function.Consumer<? super V> action) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.function.Consumer<? super V> action;
+
+ {
+ action = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ForwardingNode<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.Node<K, V> {
+
+ ForwardingNode(java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab) {
+ super(0, null, null, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.concurrent.ConcurrentHashMap.Node<K, V> find(int h, java.lang.Object k) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.concurrent.ConcurrentHashMap.Node<K, V>[] nextTable;
+
+ {
+ nextTable = new java.util.concurrent.ConcurrentHashMap.Node[0];
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class KeyIterator<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BaseIterator<K, V>
+ implements java.util.Iterator<K>, java.util.Enumeration<K> {
+
+ KeyIterator(
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab,
+ int index,
+ int size,
+ int limit,
+ java.util.concurrent.ConcurrentHashMap<K, V> map) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public K next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K nextElement() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static class KeySetView<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.CollectionView<K, V, K>
+ implements java.util.Set<K>, java.io.Serializable {
+
+ KeySetView(java.util.concurrent.ConcurrentHashMap<K, V> map, V value) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public V getMappedValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<K> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(K e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(java.util.Collection<? extends K> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<K> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super K> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = 7249069246763182397L; // 0x6499de129d87293dL
+
+ private final V value;
+
+ {
+ value = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class KeySpliterator<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.Traverser<K, V>
+ implements java.util.Spliterator<K> {
+
+ KeySpliterator(
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab,
+ int size,
+ int index,
+ int limit,
+ long est) {
+ super(null, 0, 0, 0);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.concurrent.ConcurrentHashMap.KeySpliterator<K, V> trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super K> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(java.util.function.Consumer<? super K> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long estimateSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+
+ long est;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MapEntry<K, V> implements java.util.Map.Entry<K, V> {
+
+ MapEntry(K key, V val, java.util.concurrent.ConcurrentHashMap<K, V> map) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public K getKey() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V getValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V setValue(V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final K key;
+
+ {
+ key = null;
+ }
+
+ final java.util.concurrent.ConcurrentHashMap<K, V> map;
+
+ {
+ map = null;
+ }
+
+ V val;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MapReduceEntriesTask<K, V, U>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, U> {
+
+ MapReduceEntriesTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.MapReduceEntriesTask<K, V, U> nextRight,
+ java.util.function.Function<java.util.Map.Entry<K, V>, ? extends U> transformer,
+ java.util.function.BiFunction<? super U, ? super U, ? extends U> reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public U getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceEntriesTask<K, V, U> nextRight;
+
+ final java.util.function.BiFunction<? super U, ? super U, ? extends U> reducer;
+
+ {
+ reducer = null;
+ }
+
+ U result;
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceEntriesTask<K, V, U> rights;
+
+ final java.util.function.Function<java.util.Map.Entry<K, V>, ? extends U> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MapReduceEntriesToDoubleTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Double> {
+
+ MapReduceEntriesToDoubleTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.MapReduceEntriesToDoubleTask<K, V> nextRight,
+ java.util.function.ToDoubleFunction<java.util.Map.Entry<K, V>> transformer,
+ double basis,
+ java.util.function.DoubleBinaryOperator reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Double getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final double basis;
+
+ {
+ basis = 0;
+ }
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceEntriesToDoubleTask<K, V> nextRight;
+
+ final java.util.function.DoubleBinaryOperator reducer;
+
+ {
+ reducer = null;
+ }
+
+ double result;
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceEntriesToDoubleTask<K, V> rights;
+
+ final java.util.function.ToDoubleFunction<java.util.Map.Entry<K, V>> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MapReduceEntriesToIntTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Integer> {
+
+ MapReduceEntriesToIntTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.MapReduceEntriesToIntTask<K, V> nextRight,
+ java.util.function.ToIntFunction<java.util.Map.Entry<K, V>> transformer,
+ int basis,
+ java.util.function.IntBinaryOperator reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Integer getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int basis;
+
+ {
+ basis = 0;
+ }
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceEntriesToIntTask<K, V> nextRight;
+
+ final java.util.function.IntBinaryOperator reducer;
+
+ {
+ reducer = null;
+ }
+
+ int result;
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceEntriesToIntTask<K, V> rights;
+
+ final java.util.function.ToIntFunction<java.util.Map.Entry<K, V>> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MapReduceEntriesToLongTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Long> {
+
+ MapReduceEntriesToLongTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.MapReduceEntriesToLongTask<K, V> nextRight,
+ java.util.function.ToLongFunction<java.util.Map.Entry<K, V>> transformer,
+ long basis,
+ java.util.function.LongBinaryOperator reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Long getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final long basis;
+
+ {
+ basis = 0;
+ }
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceEntriesToLongTask<K, V> nextRight;
+
+ final java.util.function.LongBinaryOperator reducer;
+
+ {
+ reducer = null;
+ }
+
+ long result;
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceEntriesToLongTask<K, V> rights;
+
+ final java.util.function.ToLongFunction<java.util.Map.Entry<K, V>> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MapReduceKeysTask<K, V, U>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, U> {
+
+ MapReduceKeysTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.MapReduceKeysTask<K, V, U> nextRight,
+ java.util.function.Function<? super K, ? extends U> transformer,
+ java.util.function.BiFunction<? super U, ? super U, ? extends U> reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public U getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceKeysTask<K, V, U> nextRight;
+
+ final java.util.function.BiFunction<? super U, ? super U, ? extends U> reducer;
+
+ {
+ reducer = null;
+ }
+
+ U result;
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceKeysTask<K, V, U> rights;
+
+ final java.util.function.Function<? super K, ? extends U> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MapReduceKeysToDoubleTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Double> {
+
+ MapReduceKeysToDoubleTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.MapReduceKeysToDoubleTask<K, V> nextRight,
+ java.util.function.ToDoubleFunction<? super K> transformer,
+ double basis,
+ java.util.function.DoubleBinaryOperator reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Double getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final double basis;
+
+ {
+ basis = 0;
+ }
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceKeysToDoubleTask<K, V> nextRight;
+
+ final java.util.function.DoubleBinaryOperator reducer;
+
+ {
+ reducer = null;
+ }
+
+ double result;
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceKeysToDoubleTask<K, V> rights;
+
+ final java.util.function.ToDoubleFunction<? super K> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MapReduceKeysToIntTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Integer> {
+
+ MapReduceKeysToIntTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.MapReduceKeysToIntTask<K, V> nextRight,
+ java.util.function.ToIntFunction<? super K> transformer,
+ int basis,
+ java.util.function.IntBinaryOperator reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Integer getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int basis;
+
+ {
+ basis = 0;
+ }
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceKeysToIntTask<K, V> nextRight;
+
+ final java.util.function.IntBinaryOperator reducer;
+
+ {
+ reducer = null;
+ }
+
+ int result;
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceKeysToIntTask<K, V> rights;
+
+ final java.util.function.ToIntFunction<? super K> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MapReduceKeysToLongTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Long> {
+
+ MapReduceKeysToLongTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.MapReduceKeysToLongTask<K, V> nextRight,
+ java.util.function.ToLongFunction<? super K> transformer,
+ long basis,
+ java.util.function.LongBinaryOperator reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Long getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final long basis;
+
+ {
+ basis = 0;
+ }
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceKeysToLongTask<K, V> nextRight;
+
+ final java.util.function.LongBinaryOperator reducer;
+
+ {
+ reducer = null;
+ }
+
+ long result;
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceKeysToLongTask<K, V> rights;
+
+ final java.util.function.ToLongFunction<? super K> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MapReduceMappingsTask<K, V, U>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, U> {
+
+ MapReduceMappingsTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.MapReduceMappingsTask<K, V, U> nextRight,
+ java.util.function.BiFunction<? super K, ? super V, ? extends U> transformer,
+ java.util.function.BiFunction<? super U, ? super U, ? extends U> reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public U getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceMappingsTask<K, V, U> nextRight;
+
+ final java.util.function.BiFunction<? super U, ? super U, ? extends U> reducer;
+
+ {
+ reducer = null;
+ }
+
+ U result;
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceMappingsTask<K, V, U> rights;
+
+ final java.util.function.BiFunction<? super K, ? super V, ? extends U> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MapReduceMappingsToDoubleTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Double> {
+
+ MapReduceMappingsToDoubleTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.MapReduceMappingsToDoubleTask<K, V>
+ nextRight,
+ java.util.function.ToDoubleBiFunction<? super K, ? super V> transformer,
+ double basis,
+ java.util.function.DoubleBinaryOperator reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Double getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final double basis;
+
+ {
+ basis = 0;
+ }
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceMappingsToDoubleTask<K, V> nextRight;
+
+ final java.util.function.DoubleBinaryOperator reducer;
+
+ {
+ reducer = null;
+ }
+
+ double result;
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceMappingsToDoubleTask<K, V> rights;
+
+ final java.util.function.ToDoubleBiFunction<? super K, ? super V> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MapReduceMappingsToIntTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Integer> {
+
+ MapReduceMappingsToIntTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.MapReduceMappingsToIntTask<K, V> nextRight,
+ java.util.function.ToIntBiFunction<? super K, ? super V> transformer,
+ int basis,
+ java.util.function.IntBinaryOperator reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Integer getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int basis;
+
+ {
+ basis = 0;
+ }
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceMappingsToIntTask<K, V> nextRight;
+
+ final java.util.function.IntBinaryOperator reducer;
+
+ {
+ reducer = null;
+ }
+
+ int result;
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceMappingsToIntTask<K, V> rights;
+
+ final java.util.function.ToIntBiFunction<? super K, ? super V> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MapReduceMappingsToLongTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Long> {
+
+ MapReduceMappingsToLongTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.MapReduceMappingsToLongTask<K, V> nextRight,
+ java.util.function.ToLongBiFunction<? super K, ? super V> transformer,
+ long basis,
+ java.util.function.LongBinaryOperator reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Long getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final long basis;
+
+ {
+ basis = 0;
+ }
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceMappingsToLongTask<K, V> nextRight;
+
+ final java.util.function.LongBinaryOperator reducer;
+
+ {
+ reducer = null;
+ }
+
+ long result;
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceMappingsToLongTask<K, V> rights;
+
+ final java.util.function.ToLongBiFunction<? super K, ? super V> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MapReduceValuesTask<K, V, U>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, U> {
+
+ MapReduceValuesTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.MapReduceValuesTask<K, V, U> nextRight,
+ java.util.function.Function<? super V, ? extends U> transformer,
+ java.util.function.BiFunction<? super U, ? super U, ? extends U> reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public U getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceValuesTask<K, V, U> nextRight;
+
+ final java.util.function.BiFunction<? super U, ? super U, ? extends U> reducer;
+
+ {
+ reducer = null;
+ }
+
+ U result;
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceValuesTask<K, V, U> rights;
+
+ final java.util.function.Function<? super V, ? extends U> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MapReduceValuesToDoubleTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Double> {
+
+ MapReduceValuesToDoubleTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.MapReduceValuesToDoubleTask<K, V> nextRight,
+ java.util.function.ToDoubleFunction<? super V> transformer,
+ double basis,
+ java.util.function.DoubleBinaryOperator reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Double getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final double basis;
+
+ {
+ basis = 0;
+ }
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceValuesToDoubleTask<K, V> nextRight;
+
+ final java.util.function.DoubleBinaryOperator reducer;
+
+ {
+ reducer = null;
+ }
+
+ double result;
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceValuesToDoubleTask<K, V> rights;
+
+ final java.util.function.ToDoubleFunction<? super V> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MapReduceValuesToIntTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Integer> {
+
+ MapReduceValuesToIntTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.MapReduceValuesToIntTask<K, V> nextRight,
+ java.util.function.ToIntFunction<? super V> transformer,
+ int basis,
+ java.util.function.IntBinaryOperator reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Integer getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int basis;
+
+ {
+ basis = 0;
+ }
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceValuesToIntTask<K, V> nextRight;
+
+ final java.util.function.IntBinaryOperator reducer;
+
+ {
+ reducer = null;
+ }
+
+ int result;
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceValuesToIntTask<K, V> rights;
+
+ final java.util.function.ToIntFunction<? super V> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class MapReduceValuesToLongTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, java.lang.Long> {
+
+ MapReduceValuesToLongTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.MapReduceValuesToLongTask<K, V> nextRight,
+ java.util.function.ToLongFunction<? super V> transformer,
+ long basis,
+ java.util.function.LongBinaryOperator reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Long getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final long basis;
+
+ {
+ basis = 0;
+ }
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceValuesToLongTask<K, V> nextRight;
+
+ final java.util.function.LongBinaryOperator reducer;
+
+ {
+ reducer = null;
+ }
+
+ long result;
+
+ java.util.concurrent.ConcurrentHashMap.MapReduceValuesToLongTask<K, V> rights;
+
+ final java.util.function.ToLongFunction<? super V> transformer;
+
+ {
+ transformer = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class Node<K, V> implements java.util.Map.Entry<K, V> {
+
+ Node(int hash, K key, V val, java.util.concurrent.ConcurrentHashMap.Node<K, V> next) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final K getKey() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final V getValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final V setValue(V value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.concurrent.ConcurrentHashMap.Node<K, V> find(int h, java.lang.Object k) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int hash;
+
+ {
+ hash = 0;
+ }
+
+ final K key;
+
+ {
+ key = null;
+ }
+
+ volatile java.util.concurrent.ConcurrentHashMap.Node<K, V> next;
+
+ volatile V val;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ReduceEntriesTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<
+ K, V, java.util.Map.Entry<K, V>> {
+
+ ReduceEntriesTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.ReduceEntriesTask<K, V> nextRight,
+ java.util.function.BiFunction<
+ java.util.Map.Entry<K, V>,
+ java.util.Map.Entry<K, V>,
+ ? extends java.util.Map.Entry<K, V>>
+ reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Map.Entry<K, V> getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.concurrent.ConcurrentHashMap.ReduceEntriesTask<K, V> nextRight;
+
+ final java.util.function.BiFunction<
+ java.util.Map.Entry<K, V>,
+ java.util.Map.Entry<K, V>,
+ ? extends java.util.Map.Entry<K, V>>
+ reducer;
+
+ {
+ reducer = null;
+ }
+
+ java.util.Map.Entry<K, V> result;
+
+ java.util.concurrent.ConcurrentHashMap.ReduceEntriesTask<K, V> rights;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ReduceKeysTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, K> {
+
+ ReduceKeysTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.ReduceKeysTask<K, V> nextRight,
+ java.util.function.BiFunction<? super K, ? super K, ? extends K> reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public K getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.concurrent.ConcurrentHashMap.ReduceKeysTask<K, V> nextRight;
+
+ final java.util.function.BiFunction<? super K, ? super K, ? extends K> reducer;
+
+ {
+ reducer = null;
+ }
+
+ K result;
+
+ java.util.concurrent.ConcurrentHashMap.ReduceKeysTask<K, V> rights;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ReduceValuesTask<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, V> {
+
+ ReduceValuesTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.concurrent.ConcurrentHashMap.ReduceValuesTask<K, V> nextRight,
+ java.util.function.BiFunction<? super V, ? super V, ? extends V> reducer) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public V getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.concurrent.ConcurrentHashMap.ReduceValuesTask<K, V> nextRight;
+
+ final java.util.function.BiFunction<? super V, ? super V, ? extends V> reducer;
+
+ {
+ reducer = null;
+ }
+
+ V result;
+
+ java.util.concurrent.ConcurrentHashMap.ReduceValuesTask<K, V> rights;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ReservationNode<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.Node<K, V> {
+
+ ReservationNode() {
+ super(0, null, null, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.concurrent.ConcurrentHashMap.Node<K, V> find(int h, java.lang.Object k) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class SearchEntriesTask<K, V, U>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, U> {
+
+ SearchEntriesTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.function.Function<java.util.Map.Entry<K, V>, ? extends U> searchFunction,
+ java.util.concurrent.atomic.AtomicReference<U> result) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public U getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.concurrent.atomic.AtomicReference<U> result;
+
+ {
+ result = null;
+ }
+
+ final java.util.function.Function<java.util.Map.Entry<K, V>, ? extends U> searchFunction;
+
+ {
+ searchFunction = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class SearchKeysTask<K, V, U>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, U> {
+
+ SearchKeysTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.function.Function<? super K, ? extends U> searchFunction,
+ java.util.concurrent.atomic.AtomicReference<U> result) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public U getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.concurrent.atomic.AtomicReference<U> result;
+
+ {
+ result = null;
+ }
+
+ final java.util.function.Function<? super K, ? extends U> searchFunction;
+
+ {
+ searchFunction = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class SearchMappingsTask<K, V, U>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, U> {
+
+ SearchMappingsTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.function.BiFunction<? super K, ? super V, ? extends U> searchFunction,
+ java.util.concurrent.atomic.AtomicReference<U> result) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public U getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.concurrent.atomic.AtomicReference<U> result;
+
+ {
+ result = null;
+ }
+
+ final java.util.function.BiFunction<? super K, ? super V, ? extends U> searchFunction;
+
+ {
+ searchFunction = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class SearchValuesTask<K, V, U>
+ extends java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, U> {
+
+ SearchValuesTask(
+ java.util.concurrent.ConcurrentHashMap.BulkTask<K, V, ?> p,
+ int b,
+ int i,
+ int f,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t,
+ java.util.function.Function<? super V, ? extends U> searchFunction,
+ java.util.concurrent.atomic.AtomicReference<U> result) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public U getRawResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void compute() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.concurrent.atomic.AtomicReference<U> result;
+
+ {
+ result = null;
+ }
+
+ final java.util.function.Function<? super V, ? extends U> searchFunction;
+
+ {
+ searchFunction = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class Segment<K, V> extends java.util.concurrent.locks.ReentrantLock
+ implements java.io.Serializable {
+
+ Segment(float lf) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final float loadFactor;
+
+ {
+ loadFactor = 0;
+ }
+
+ private static final long serialVersionUID = 2249069246763182397L; // 0x1f364c905893293dL
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class TableStack<K, V> {
+
+ TableStack() {
+ throw new RuntimeException("Stub!");
+ }
+
+ int index;
+
+ int length;
+
+ java.util.concurrent.ConcurrentHashMap.TableStack<K, V> next;
+
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class Traverser<K, V> {
+
+ Traverser(
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab,
+ int size,
+ int index,
+ int limit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.concurrent.ConcurrentHashMap.Node<K, V> advance() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void pushState(
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] t, int i, int n) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void recoverState(int n) {
+ throw new RuntimeException("Stub!");
+ }
+
+ int baseIndex;
+
+ int baseLimit;
+
+ final int baseSize;
+
+ {
+ baseSize = 0;
+ }
+
+ int index;
+
+ java.util.concurrent.ConcurrentHashMap.Node<K, V> next;
+
+ java.util.concurrent.ConcurrentHashMap.TableStack<K, V> spare;
+
+ java.util.concurrent.ConcurrentHashMap.TableStack<K, V> stack;
+
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class TreeBin<K, V> extends java.util.concurrent.ConcurrentHashMap.Node<K, V> {
+
+ TreeBin(java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> b) {
+ super(0, null, null, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ static int tieBreakOrder(java.lang.Object a, java.lang.Object b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void lockRoot() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void unlockRoot() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void contendedLock() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.concurrent.ConcurrentHashMap.Node<K, V> find(int h, java.lang.Object k) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> putTreeVal(int h, K k, V v) {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean removeTreeNode(java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> p) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <K, V> java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> rotateLeft(
+ java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> root,
+ java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> p) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <K, V> java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> rotateRight(
+ java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> root,
+ java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> p) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <K, V> java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> balanceInsertion(
+ java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> root,
+ java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <K, V> java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> balanceDeletion(
+ java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> root,
+ java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static <K, V> boolean checkInvariants(
+ java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> t) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long LOCKSTATE;
+
+ static {
+ LOCKSTATE = 0;
+ }
+
+ static final int READER = 4; // 0x4
+
+ private static final sun.misc.Unsafe U;
+
+ static {
+ U = null;
+ }
+
+ static final int WAITER = 2; // 0x2
+
+ static final int WRITER = 1; // 0x1
+
+ volatile java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> first;
+
+ volatile int lockState;
+
+ java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> root;
+
+ volatile java.lang.Thread waiter;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class TreeNode<K, V> extends java.util.concurrent.ConcurrentHashMap.Node<K, V> {
+
+ TreeNode(
+ int hash,
+ K key,
+ V val,
+ java.util.concurrent.ConcurrentHashMap.Node<K, V> next,
+ java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> parent) {
+ super(0, null, null, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.concurrent.ConcurrentHashMap.Node<K, V> find(int h, java.lang.Object k) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> findTreeNode(
+ int h, java.lang.Object k, java.lang.Class<?> kc) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> left;
+
+ java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> parent;
+
+ java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> prev;
+
+ boolean red;
+
+ java.util.concurrent.ConcurrentHashMap.TreeNode<K, V> right;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ValueIterator<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.BaseIterator<K, V>
+ implements java.util.Iterator<V>, java.util.Enumeration<V> {
+
+ ValueIterator(
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab,
+ int index,
+ int size,
+ int limit,
+ java.util.concurrent.ConcurrentHashMap<K, V> map) {
+ super(null, 0, 0, 0, null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public V next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V nextElement() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ValueSpliterator<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.Traverser<K, V>
+ implements java.util.Spliterator<V> {
+
+ ValueSpliterator(
+ java.util.concurrent.ConcurrentHashMap.Node<K, V>[] tab,
+ int size,
+ int index,
+ int limit,
+ long est) {
+ super(null, 0, 0, 0);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.concurrent.ConcurrentHashMap.ValueSpliterator<K, V> trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super V> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(java.util.function.Consumer<? super V> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long estimateSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+
+ long est;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class ValuesView<K, V>
+ extends java.util.concurrent.ConcurrentHashMap.CollectionView<K, V, V>
+ implements java.util.Collection<V>, java.io.Serializable {
+
+ ValuesView(java.util.concurrent.ConcurrentHashMap<K, V> map) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<V> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(V e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(java.util.Collection<? extends V> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeIf(java.util.function.Predicate<? super V> filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<V> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super V> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = 2249069246763182397L; // 0x1f364c905893293dL
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/concurrent/CopyOnWriteArrayList.java b/ojluni/annotations/hiddenapi/java/util/concurrent/CopyOnWriteArrayList.java
new file mode 100644
index 0000000..7d526a7
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/concurrent/CopyOnWriteArrayList.java
@@ -0,0 +1,497 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group. Adapted and released, under explicit permission,
+ * from JDK ArrayList.java which carries the following copyright:
+ *
+ * Copyright 1997 by Sun Microsystems, Inc.,
+ * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
+ * All rights reserved.
+ */
+
+package java.util.concurrent;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class CopyOnWriteArrayList<E>
+ implements java.util.List<E>,
+ java.util.RandomAccess,
+ java.lang.Cloneable,
+ java.io.Serializable {
+
+ public CopyOnWriteArrayList() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public CopyOnWriteArrayList(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public CopyOnWriteArrayList(E[] toCopyIn) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.lang.Object[] getArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void setArray(java.lang.Object[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int indexOf(
+ java.lang.Object o, java.lang.Object[] elements, int index, int fence) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int lastIndexOf(java.lang.Object o, java.lang.Object[] elements, int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int indexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int indexOf(E e, int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int lastIndexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int lastIndexOf(E e, int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object clone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private E get(java.lang.Object[] a, int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.lang.String outOfBounds(int index, int size) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E get(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E set(int index, E element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void add(int index, E element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E remove(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean remove(java.lang.Object o, java.lang.Object[] snapshot, int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void removeRange(int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addIfAbsent(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean addIfAbsent(E e, java.lang.Object[] snapshot) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean retainAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int addAllAbsent(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(int index, java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeIf(java.util.function.Predicate<? super E> filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void replaceAll(java.util.function.UnaryOperator<E> operator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void sort(java.util.Comparator<? super E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ListIterator<E> listIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ListIterator<E> listIterator(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.List<E> subList(int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void resetLock() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long LOCK;
+
+ static {
+ LOCK = 0;
+ }
+
+ private static final sun.misc.Unsafe U;
+
+ static {
+ U = null;
+ }
+
+ @UnsupportedAppUsage
+ private transient volatile java.lang.Object[] elements;
+
+ final transient java.lang.Object lock;
+
+ {
+ lock = null;
+ }
+
+ private static final long serialVersionUID = 8673264195747942595L; // 0x785d9fd546ab90c3L
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class COWIterator<E> implements java.util.ListIterator<E> {
+
+ COWIterator(java.lang.Object[] elements, int initialCursor) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasPrevious() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E previous() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int nextIndex() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int previousIndex() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void set(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int cursor;
+
+ private final java.lang.Object[] snapshot;
+
+ {
+ snapshot = new java.lang.Object[0];
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class COWSubList<E> extends java.util.AbstractList<E>
+ implements java.util.RandomAccess {
+
+ COWSubList(java.util.concurrent.CopyOnWriteArrayList<E> list, int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkForComodification() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void rangeCheck(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E set(int index, E element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E get(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void add(int index, E element) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E remove(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ListIterator<E> listIterator(int index) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.List<E> subList(int fromIndex, int toIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void replaceAll(java.util.function.UnaryOperator<E> operator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void sort(java.util.Comparator<? super E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean retainAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeIf(java.util.function.Predicate<? super E> filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Object[] expectedArray;
+
+ private final java.util.concurrent.CopyOnWriteArrayList<E> l;
+
+ {
+ l = null;
+ }
+
+ private final int offset;
+
+ {
+ offset = 0;
+ }
+
+ private int size;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class COWSubListIterator<E> implements java.util.ListIterator<E> {
+
+ COWSubListIterator(java.util.List<E> l, int index, int offset, int size) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasPrevious() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E previous() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int nextIndex() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int previousIndex() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void set(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.ListIterator<E> it;
+
+ {
+ it = null;
+ }
+
+ private final int offset;
+
+ {
+ offset = 0;
+ }
+
+ private final int size;
+
+ {
+ size = 0;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/concurrent/CopyOnWriteArraySet.java b/ojluni/annotations/hiddenapi/java/util/concurrent/CopyOnWriteArraySet.java
new file mode 100644
index 0000000..98c53b0
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/concurrent/CopyOnWriteArraySet.java
@@ -0,0 +1,132 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class CopyOnWriteArraySet<E> extends java.util.AbstractSet<E>
+ implements java.io.Serializable {
+
+ public CopyOnWriteArraySet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public CopyOnWriteArraySet(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean containsAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int compareSets(java.lang.Object[] snapshot, java.util.Set<?> set) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addAll(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean retainAll(java.util.Collection<?> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean equals(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeIf(java.util.function.Predicate<? super E> filter) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEach(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private final java.util.concurrent.CopyOnWriteArrayList<E> al;
+
+ {
+ al = null;
+ }
+
+ private static final long serialVersionUID = 5457747651344034263L; // 0x4bbdd092901569d7L
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/concurrent/Executors.java b/ojluni/annotations/hiddenapi/java/util/concurrent/Executors.java
new file mode 100644
index 0000000..1fbd62c
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/concurrent/Executors.java
@@ -0,0 +1,429 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Executors {
+
+ private Executors() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.ExecutorService newFixedThreadPool(int nThreads) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.ExecutorService newWorkStealingPool(int parallelism) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.ExecutorService newWorkStealingPool() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.ExecutorService newFixedThreadPool(
+ int nThreads, java.util.concurrent.ThreadFactory threadFactory) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.ExecutorService newSingleThreadExecutor() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.ExecutorService newSingleThreadExecutor(
+ java.util.concurrent.ThreadFactory threadFactory) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.ExecutorService newCachedThreadPool() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.ExecutorService newCachedThreadPool(
+ java.util.concurrent.ThreadFactory threadFactory) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.ScheduledExecutorService newSingleThreadScheduledExecutor() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.ScheduledExecutorService newSingleThreadScheduledExecutor(
+ java.util.concurrent.ThreadFactory threadFactory) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.ScheduledExecutorService newScheduledThreadPool(
+ int corePoolSize) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.ScheduledExecutorService newScheduledThreadPool(
+ int corePoolSize, java.util.concurrent.ThreadFactory threadFactory) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.ExecutorService unconfigurableExecutorService(
+ java.util.concurrent.ExecutorService executor) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.ScheduledExecutorService
+ unconfigurableScheduledExecutorService(
+ java.util.concurrent.ScheduledExecutorService executor) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.ThreadFactory defaultThreadFactory() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.ThreadFactory privilegedThreadFactory() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.concurrent.Callable<T> callable(java.lang.Runnable task, T result) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.Callable<java.lang.Object> callable(
+ java.lang.Runnable task) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.Callable<java.lang.Object> callable(
+ java.security.PrivilegedAction<?> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.concurrent.Callable<java.lang.Object> callable(
+ java.security.PrivilegedExceptionAction<?> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.concurrent.Callable<T> privilegedCallable(
+ java.util.concurrent.Callable<T> callable) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static <T> java.util.concurrent.Callable<T> privilegedCallableUsingCurrentClassLoader(
+ java.util.concurrent.Callable<T> callable) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class DefaultThreadFactory implements java.util.concurrent.ThreadFactory {
+
+ DefaultThreadFactory() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Thread newThread(java.lang.Runnable r) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.lang.ThreadGroup group;
+
+ {
+ group = null;
+ }
+
+ private final java.lang.String namePrefix;
+
+ {
+ namePrefix = null;
+ }
+
+ private static final java.util.concurrent.atomic.AtomicInteger poolNumber;
+
+ static {
+ poolNumber = null;
+ }
+
+ private final java.util.concurrent.atomic.AtomicInteger threadNumber;
+
+ {
+ threadNumber = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class DelegatedExecutorService
+ extends java.util.concurrent.AbstractExecutorService {
+
+ DelegatedExecutorService(java.util.concurrent.ExecutorService executor) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void execute(java.lang.Runnable command) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void shutdown() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.List<java.lang.Runnable> shutdownNow() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isShutdown() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isTerminated() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean awaitTermination(long timeout, java.util.concurrent.TimeUnit unit)
+ throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.concurrent.Future<?> submit(java.lang.Runnable task) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> java.util.concurrent.Future<T> submit(java.util.concurrent.Callable<T> task) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> java.util.concurrent.Future<T> submit(java.lang.Runnable task, T result) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> java.util.List<java.util.concurrent.Future<T>> invokeAll(
+ java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks)
+ throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> java.util.List<java.util.concurrent.Future<T>> invokeAll(
+ java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks,
+ long timeout,
+ java.util.concurrent.TimeUnit unit)
+ throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T invokeAny(
+ java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks)
+ throws java.util.concurrent.ExecutionException, java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T invokeAny(
+ java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks,
+ long timeout,
+ java.util.concurrent.TimeUnit unit)
+ throws java.util.concurrent.ExecutionException, java.lang.InterruptedException,
+ java.util.concurrent.TimeoutException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.concurrent.ExecutorService e;
+
+ {
+ e = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class DelegatedScheduledExecutorService
+ extends java.util.concurrent.Executors.DelegatedExecutorService
+ implements java.util.concurrent.ScheduledExecutorService {
+
+ DelegatedScheduledExecutorService(java.util.concurrent.ScheduledExecutorService executor) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.concurrent.ScheduledFuture<?> schedule(
+ java.lang.Runnable command, long delay, java.util.concurrent.TimeUnit unit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <V> java.util.concurrent.ScheduledFuture<V> schedule(
+ java.util.concurrent.Callable<V> callable,
+ long delay,
+ java.util.concurrent.TimeUnit unit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.concurrent.ScheduledFuture<?> scheduleAtFixedRate(
+ java.lang.Runnable command,
+ long initialDelay,
+ long period,
+ java.util.concurrent.TimeUnit unit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.concurrent.ScheduledFuture<?> scheduleWithFixedDelay(
+ java.lang.Runnable command,
+ long initialDelay,
+ long delay,
+ java.util.concurrent.TimeUnit unit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.concurrent.ScheduledExecutorService e;
+
+ {
+ e = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class FinalizableDelegatedExecutorService
+ extends java.util.concurrent.Executors.DelegatedExecutorService {
+
+ FinalizableDelegatedExecutorService(java.util.concurrent.ExecutorService executor) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void finalize() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static final class PrivilegedCallable<T> implements java.util.concurrent.Callable<T> {
+
+ PrivilegedCallable(java.util.concurrent.Callable<T> task) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public T call() throws java.lang.Exception {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.security.AccessControlContext acc;
+
+ {
+ acc = null;
+ }
+
+ final java.util.concurrent.Callable<T> task;
+
+ {
+ task = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static final class PrivilegedCallableUsingCurrentClassLoader<T>
+ implements java.util.concurrent.Callable<T> {
+
+ PrivilegedCallableUsingCurrentClassLoader(java.util.concurrent.Callable<T> task) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public T call() throws java.lang.Exception {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.security.AccessControlContext acc;
+
+ {
+ acc = null;
+ }
+
+ final java.lang.ClassLoader ccl;
+
+ {
+ ccl = null;
+ }
+
+ final java.util.concurrent.Callable<T> task;
+
+ {
+ task = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class PrivilegedThreadFactory
+ extends java.util.concurrent.Executors.DefaultThreadFactory {
+
+ PrivilegedThreadFactory() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Thread newThread(java.lang.Runnable r) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.security.AccessControlContext acc;
+
+ {
+ acc = null;
+ }
+
+ final java.lang.ClassLoader ccl;
+
+ {
+ ccl = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static final class RunnableAdapter<T> implements java.util.concurrent.Callable<T> {
+
+ RunnableAdapter(java.lang.Runnable task, T result) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public T call() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final T result;
+
+ {
+ result = null;
+ }
+
+ @UnsupportedAppUsage
+ private final java.lang.Runnable task;
+
+ {
+ task = null;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/concurrent/FutureTask.java b/ojluni/annotations/hiddenapi/java/util/concurrent/FutureTask.java
new file mode 100644
index 0000000..2274611
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/concurrent/FutureTask.java
@@ -0,0 +1,176 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class FutureTask<V> implements java.util.concurrent.RunnableFuture<V> {
+
+ public FutureTask(java.util.concurrent.Callable<V> callable) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public FutureTask(java.lang.Runnable runnable, V result) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private V report(int s) throws java.util.concurrent.ExecutionException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isCancelled() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isDone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean cancel(boolean mayInterruptIfRunning) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V get() throws java.util.concurrent.ExecutionException, java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public V get(long timeout, java.util.concurrent.TimeUnit unit)
+ throws java.util.concurrent.ExecutionException, java.lang.InterruptedException,
+ java.util.concurrent.TimeoutException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void done() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void set(V v) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void setException(java.lang.Throwable t) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void run() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected boolean runAndReset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void handlePossibleCancellationInterrupt(int s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void finishCompletion() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int awaitDone(boolean timed, long nanos) throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void removeWaiter(java.util.concurrent.FutureTask.WaitNode node) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int CANCELLED = 4; // 0x4
+
+ private static final int COMPLETING = 1; // 0x1
+
+ @UnsupportedAppUsage
+ private static final int EXCEPTIONAL = 3; // 0x3
+
+ private static final int INTERRUPTED = 6; // 0x6
+
+ private static final int INTERRUPTING = 5; // 0x5
+
+ private static final int NEW = 0; // 0x0
+
+ private static final int NORMAL = 2; // 0x2
+
+ private static final long RUNNER;
+
+ static {
+ RUNNER = 0;
+ }
+
+ private static final long STATE;
+
+ static {
+ STATE = 0;
+ }
+
+ private static final sun.misc.Unsafe U;
+
+ static {
+ U = null;
+ }
+
+ private static final long WAITERS;
+
+ static {
+ WAITERS = 0;
+ }
+
+ @UnsupportedAppUsage
+ private java.util.concurrent.Callable<V> callable;
+
+ @UnsupportedAppUsage
+ private java.lang.Object outcome;
+
+ private volatile java.lang.Thread runner;
+
+ @UnsupportedAppUsage
+ private volatile int state;
+
+ private volatile java.util.concurrent.FutureTask.WaitNode waiters;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class WaitNode {
+
+ WaitNode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ volatile java.util.concurrent.FutureTask.WaitNode next;
+
+ volatile java.lang.Thread thread;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/concurrent/LinkedBlockingDeque.java b/ojluni/annotations/hiddenapi/java/util/concurrent/LinkedBlockingDeque.java
new file mode 100644
index 0000000..de84037
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/concurrent/LinkedBlockingDeque.java
@@ -0,0 +1,444 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class LinkedBlockingDeque<E> extends java.util.AbstractQueue<E>
+ implements java.util.concurrent.BlockingDeque<E>, java.io.Serializable {
+
+ public LinkedBlockingDeque() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public LinkedBlockingDeque(int capacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public LinkedBlockingDeque(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean linkFirst(Node<E> node) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean linkLast(Node<E> node) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private E unlinkFirst() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private E unlinkLast() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void unlink(Node<E> x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void addFirst(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void addLast(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offerFirst(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offerLast(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void putFirst(E e) throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void putLast(E e) throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offerFirst(E e, long timeout, java.util.concurrent.TimeUnit unit)
+ throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offerLast(E e, long timeout, java.util.concurrent.TimeUnit unit)
+ throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E removeFirst() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E removeLast() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E pollFirst() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E pollLast() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E takeFirst() throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E takeLast() throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E pollFirst(long timeout, java.util.concurrent.TimeUnit unit)
+ throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E pollLast(long timeout, java.util.concurrent.TimeUnit unit)
+ throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E getFirst() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E getLast() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E peekFirst() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E peekLast() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeFirstOccurrence(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean removeLastOccurrence(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offer(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void put(E e) throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offer(E e, long timeout, java.util.concurrent.TimeUnit unit)
+ throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E poll() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E take() throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E poll(long timeout, java.util.concurrent.TimeUnit unit)
+ throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E element() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E peek() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int remainingCapacity() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int drainTo(java.util.Collection<? super E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int drainTo(java.util.Collection<? super E> c, int maxElements) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void push(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E pop() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> descendingIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final int capacity;
+
+ {
+ capacity = 0;
+ }
+
+ private transient int count;
+
+ @UnsupportedAppUsage
+ transient Node<E> first;
+
+ transient Node<E> last;
+
+ @UnsupportedAppUsage
+ final java.util.concurrent.locks.ReentrantLock lock;
+
+ {
+ lock = null;
+ }
+
+ private final java.util.concurrent.locks.Condition notEmpty;
+
+ {
+ notEmpty = null;
+ }
+
+ private final java.util.concurrent.locks.Condition notFull;
+
+ {
+ notFull = null;
+ }
+
+ private static final long serialVersionUID = -387911632671998426L; // 0xfa9ddc6ce257fe26L
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private abstract class AbstractItr implements java.util.Iterator<E> {
+
+ AbstractItr() {
+ throw new RuntimeException("Stub!");
+ }
+
+ abstract Node<E> firstNode();
+
+ abstract Node<E> nextNode(
+ Node<E> n);
+
+ private Node<E> succ(
+ Node<E> n) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void advance() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private Node<E> lastRet;
+
+ Node<E> next;
+
+ E nextItem;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class DescendingItr extends AbstractItr {
+
+ DescendingItr() {
+ throw new RuntimeException("Stub!");
+ }
+
+ Node<E> firstNode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ Node<E> nextNode(
+ Node<E> n) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class Itr extends AbstractItr {
+
+ Itr() {
+ throw new RuntimeException("Stub!");
+ }
+
+ Node<E> firstNode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ Node<E> nextNode(
+ Node<E> n) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class LBDSpliterator<E> implements java.util.Spliterator<E> {
+
+ LBDSpliterator(java.util.concurrent.LinkedBlockingDeque<E> queue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long estimateSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final int MAX_BATCH = 33554432; // 0x2000000
+
+ int batch;
+
+ Node<E> current;
+
+ long est;
+
+ boolean exhausted;
+
+ final java.util.concurrent.LinkedBlockingDeque<E> queue;
+
+ {
+ queue = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class Node<E> {
+
+ Node(E x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ E item;
+
+ Node<E> next;
+
+ Node<E> prev;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/concurrent/LinkedBlockingQueue.java b/ojluni/annotations/hiddenapi/java/util/concurrent/LinkedBlockingQueue.java
new file mode 100644
index 0000000..f7aec5c
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/concurrent/LinkedBlockingQueue.java
@@ -0,0 +1,300 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class LinkedBlockingQueue<E> extends java.util.AbstractQueue<E>
+ implements java.util.concurrent.BlockingQueue<E>, java.io.Serializable {
+
+ public LinkedBlockingQueue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public LinkedBlockingQueue(int capacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public LinkedBlockingQueue(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void signalNotEmpty() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void signalNotFull() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void enqueue(java.util.concurrent.LinkedBlockingQueue.Node<E> node) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private E dequeue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void fullyLock() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void fullyUnlock() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int remainingCapacity() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void put(E e) throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offer(E e, long timeout, java.util.concurrent.TimeUnit unit)
+ throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offer(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E take() throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E poll(long timeout, java.util.concurrent.TimeUnit unit)
+ throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E poll() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E peek() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void unlink(
+ java.util.concurrent.LinkedBlockingQueue.Node<E> p,
+ java.util.concurrent.LinkedBlockingQueue.Node<E> trail) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int drainTo(java.util.Collection<? super E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int drainTo(java.util.Collection<? super E> c, int maxElements) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private final int capacity;
+
+ {
+ capacity = 0;
+ }
+
+ private final java.util.concurrent.atomic.AtomicInteger count;
+
+ {
+ count = null;
+ }
+
+ @UnsupportedAppUsage
+ transient java.util.concurrent.LinkedBlockingQueue.Node<E> head;
+
+ private transient java.util.concurrent.LinkedBlockingQueue.Node<E> last;
+
+ private final java.util.concurrent.locks.Condition notEmpty;
+
+ {
+ notEmpty = null;
+ }
+
+ private final java.util.concurrent.locks.Condition notFull;
+
+ {
+ notFull = null;
+ }
+
+ @UnsupportedAppUsage
+ private final java.util.concurrent.locks.ReentrantLock putLock;
+
+ {
+ putLock = null;
+ }
+
+ private static final long serialVersionUID = -6903933977591709194L; // 0xa0304ca040e581f6L
+
+ @UnsupportedAppUsage
+ private final java.util.concurrent.locks.ReentrantLock takeLock;
+
+ {
+ takeLock = null;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class Itr implements java.util.Iterator<E> {
+
+ Itr() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.util.concurrent.LinkedBlockingQueue.Node<E> current;
+
+ private E currentElement;
+
+ private java.util.concurrent.LinkedBlockingQueue.Node<E> lastRet;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class LBQSpliterator<E> implements java.util.Spliterator<E> {
+
+ LBQSpliterator(java.util.concurrent.LinkedBlockingQueue<E> queue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long estimateSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final int MAX_BATCH = 33554432; // 0x2000000
+
+ int batch;
+
+ java.util.concurrent.LinkedBlockingQueue.Node<E> current;
+
+ long est;
+
+ boolean exhausted;
+
+ final java.util.concurrent.LinkedBlockingQueue<E> queue;
+
+ {
+ queue = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static class Node<E> {
+
+ Node(E x) {
+ throw new RuntimeException("Stub!");
+ }
+
+ E item;
+
+ java.util.concurrent.LinkedBlockingQueue.Node<E> next;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/concurrent/PriorityBlockingQueue.java b/ojluni/annotations/hiddenapi/java/util/concurrent/PriorityBlockingQueue.java
new file mode 100644
index 0000000..0577e8c
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/concurrent/PriorityBlockingQueue.java
@@ -0,0 +1,316 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class PriorityBlockingQueue<E> extends java.util.AbstractQueue<E>
+ implements java.util.concurrent.BlockingQueue<E>, java.io.Serializable {
+
+ public PriorityBlockingQueue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public PriorityBlockingQueue(int initialCapacity) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public PriorityBlockingQueue(int initialCapacity, java.util.Comparator<? super E> comparator) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public PriorityBlockingQueue(java.util.Collection<? extends E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void tryGrow(java.lang.Object[] array, int oldCap) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private E dequeue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static <T> void siftUpComparable(int k, T x, java.lang.Object[] array) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static <T> void siftUpUsingComparator(
+ int k, T x, java.lang.Object[] array, java.util.Comparator<? super T> cmp) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static <T> void siftDownComparable(int k, T x, java.lang.Object[] array, int n) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static <T> void siftDownUsingComparator(
+ int k, T x, java.lang.Object[] array, int n, java.util.Comparator<? super T> cmp) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void heapify() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean add(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offer(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void put(E e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean offer(E e, long timeout, java.util.concurrent.TimeUnit unit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E poll() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E take() throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E poll(long timeout, java.util.concurrent.TimeUnit unit)
+ throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E peek() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Comparator<? super E> comparator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int remainingCapacity() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int indexOf(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void removeAt(int i) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void removeEQ(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean contains(java.lang.Object o) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int drainTo(java.util.Collection<? super E> c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int drainTo(java.util.Collection<? super E> c, int maxElements) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void clear() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object[] toArray() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public <T> T[] toArray(T[] a) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Iterator<E> iterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Spliterator<E> spliterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long ALLOCATIONSPINLOCK;
+
+ static {
+ ALLOCATIONSPINLOCK = 0;
+ }
+
+ private static final int DEFAULT_INITIAL_CAPACITY = 11; // 0xb
+
+ private static final int MAX_ARRAY_SIZE = 2147483639; // 0x7ffffff7
+
+ private static final sun.misc.Unsafe U;
+
+ static {
+ U = null;
+ }
+
+ private transient volatile int allocationSpinLock;
+
+ private transient java.util.Comparator<? super E> comparator;
+
+ @UnsupportedAppUsage
+ private final java.util.concurrent.locks.ReentrantLock lock;
+
+ {
+ lock = null;
+ }
+
+ @UnsupportedAppUsage
+ private final java.util.concurrent.locks.Condition notEmpty;
+
+ {
+ notEmpty = null;
+ }
+
+ private java.util.PriorityQueue<E> q;
+
+ private transient java.lang.Object[] queue;
+
+ private static final long serialVersionUID = 5595510919245408276L; // 0x4da73f88e6712814L
+
+ private transient int size;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ final class Itr implements java.util.Iterator<E> {
+
+ Itr(java.lang.Object[] array) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public E next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void remove() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.lang.Object[] array;
+
+ {
+ array = new java.lang.Object[0];
+ }
+
+ int cursor;
+
+ int lastRet;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class PBQSpliterator<E> implements java.util.Spliterator<E> {
+
+ PBQSpliterator(
+ java.util.concurrent.PriorityBlockingQueue<E> queue,
+ java.lang.Object[] array,
+ int index,
+ int fence) {
+ throw new RuntimeException("Stub!");
+ }
+
+ int getFence() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.concurrent.PriorityBlockingQueue.PBQSpliterator<E> trySplit() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void forEachRemaining(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryAdvance(java.util.function.Consumer<? super E> action) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long estimateSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int characteristics() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.Object[] array;
+
+ int fence;
+
+ int index;
+
+ final java.util.concurrent.PriorityBlockingQueue<E> queue;
+
+ {
+ queue = null;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/concurrent/ThreadPoolExecutor.java b/ojluni/annotations/hiddenapi/java/util/concurrent/ThreadPoolExecutor.java
new file mode 100644
index 0000000..e89f678
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/concurrent/ThreadPoolExecutor.java
@@ -0,0 +1,508 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ThreadPoolExecutor extends java.util.concurrent.AbstractExecutorService {
+
+ public ThreadPoolExecutor(
+ int corePoolSize,
+ int maximumPoolSize,
+ long keepAliveTime,
+ java.util.concurrent.TimeUnit unit,
+ java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ThreadPoolExecutor(
+ int corePoolSize,
+ int maximumPoolSize,
+ long keepAliveTime,
+ java.util.concurrent.TimeUnit unit,
+ java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue,
+ java.util.concurrent.ThreadFactory threadFactory) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ThreadPoolExecutor(
+ int corePoolSize,
+ int maximumPoolSize,
+ long keepAliveTime,
+ java.util.concurrent.TimeUnit unit,
+ java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue,
+ java.util.concurrent.RejectedExecutionHandler handler) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ThreadPoolExecutor(
+ int corePoolSize,
+ int maximumPoolSize,
+ long keepAliveTime,
+ java.util.concurrent.TimeUnit unit,
+ java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue,
+ java.util.concurrent.ThreadFactory threadFactory,
+ java.util.concurrent.RejectedExecutionHandler handler) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int runStateOf(int c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int workerCountOf(int c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int ctlOf(int rs, int wc) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean runStateLessThan(int c, int s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean runStateAtLeast(int c, int s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean isRunning(int c) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean compareAndIncrementWorkerCount(int expect) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean compareAndDecrementWorkerCount(int expect) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void decrementWorkerCount() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void advanceRunState(int targetState) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void tryTerminate() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkShutdownAccess() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void interruptWorkers() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void interruptIdleWorkers(boolean onlyOne) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void interruptIdleWorkers() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void reject(java.lang.Runnable command) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void onShutdown() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final boolean isRunningOrShutdown(boolean shutdownOK) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.util.List<java.lang.Runnable> drainQueue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean addWorker(java.lang.Runnable firstTask, boolean core) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void addWorkerFailed(java.util.concurrent.ThreadPoolExecutor.Worker w) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void processWorkerExit(
+ java.util.concurrent.ThreadPoolExecutor.Worker w, boolean completedAbruptly) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.Runnable getTask() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void runWorker(java.util.concurrent.ThreadPoolExecutor.Worker w) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void execute(java.lang.Runnable command) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void shutdown() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.List<java.lang.Runnable> shutdownNow() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isShutdown() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isTerminating() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isTerminated() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean awaitTermination(long timeout, java.util.concurrent.TimeUnit unit)
+ throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void finalize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setThreadFactory(java.util.concurrent.ThreadFactory threadFactory) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.concurrent.ThreadFactory getThreadFactory() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setRejectedExecutionHandler(java.util.concurrent.RejectedExecutionHandler handler) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.concurrent.RejectedExecutionHandler getRejectedExecutionHandler() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setCorePoolSize(int corePoolSize) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getCorePoolSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean prestartCoreThread() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void ensurePrestart() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int prestartAllCoreThreads() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean allowsCoreThreadTimeOut() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void allowCoreThreadTimeOut(boolean value) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setMaximumPoolSize(int maximumPoolSize) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getMaximumPoolSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setKeepAliveTime(long time, java.util.concurrent.TimeUnit unit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getKeepAliveTime(java.util.concurrent.TimeUnit unit) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.concurrent.BlockingQueue<java.lang.Runnable> getQueue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean remove(java.lang.Runnable task) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void purge() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getPoolSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getActiveCount() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getLargestPoolSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getTaskCount() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getCompletedTaskCount() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void beforeExecute(java.lang.Thread t, java.lang.Runnable r) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void afterExecute(java.lang.Runnable r, java.lang.Throwable t) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void terminated() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int CAPACITY = 536870911; // 0x1fffffff
+
+ private static final int COUNT_BITS = 29; // 0x1d
+
+ private static final boolean ONLY_ONE = true;
+
+ private static final int RUNNING = -536870912; // 0xe0000000
+
+ private static final int SHUTDOWN = 0; // 0x0
+
+ private static final int STOP = 536870912; // 0x20000000
+
+ private static final int TERMINATED = 1610612736; // 0x60000000
+
+ private static final int TIDYING = 1073741824; // 0x40000000
+
+ @UnsupportedAppUsage
+ private volatile boolean allowCoreThreadTimeOut;
+
+ private long completedTaskCount;
+
+ private volatile int corePoolSize;
+
+ @UnsupportedAppUsage
+ private final java.util.concurrent.atomic.AtomicInteger ctl;
+
+ {
+ ctl = null;
+ }
+
+ @UnsupportedAppUsage
+ private static final java.util.concurrent.RejectedExecutionHandler defaultHandler;
+
+ static {
+ defaultHandler = null;
+ }
+
+ private volatile java.util.concurrent.RejectedExecutionHandler handler;
+
+ private volatile long keepAliveTime;
+
+ private int largestPoolSize;
+
+ @UnsupportedAppUsage
+ private final java.util.concurrent.locks.ReentrantLock mainLock;
+
+ {
+ mainLock = null;
+ }
+
+ private volatile int maximumPoolSize;
+
+ private static final java.lang.RuntimePermission shutdownPerm;
+
+ static {
+ shutdownPerm = null;
+ }
+
+ private final java.util.concurrent.locks.Condition termination;
+
+ {
+ termination = null;
+ }
+
+ private volatile java.util.concurrent.ThreadFactory threadFactory;
+
+ private final java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue;
+
+ {
+ workQueue = null;
+ }
+
+ private final java.util.HashSet<java.util.concurrent.ThreadPoolExecutor.Worker> workers;
+
+ {
+ workers = null;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static class AbortPolicy implements java.util.concurrent.RejectedExecutionHandler {
+
+ public AbortPolicy() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void rejectedExecution(
+ java.lang.Runnable r, java.util.concurrent.ThreadPoolExecutor e) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static class CallerRunsPolicy implements java.util.concurrent.RejectedExecutionHandler {
+
+ public CallerRunsPolicy() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void rejectedExecution(
+ java.lang.Runnable r, java.util.concurrent.ThreadPoolExecutor e) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static class DiscardOldestPolicy
+ implements java.util.concurrent.RejectedExecutionHandler {
+
+ public DiscardOldestPolicy() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void rejectedExecution(
+ java.lang.Runnable r, java.util.concurrent.ThreadPoolExecutor e) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ public static class DiscardPolicy implements java.util.concurrent.RejectedExecutionHandler {
+
+ public DiscardPolicy() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void rejectedExecution(
+ java.lang.Runnable r, java.util.concurrent.ThreadPoolExecutor e) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private final class Worker extends java.util.concurrent.locks.AbstractQueuedSynchronizer
+ implements java.lang.Runnable {
+
+ Worker(java.lang.Runnable firstTask) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void run() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected boolean isHeldExclusively() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected boolean tryAcquire(int unused) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected boolean tryRelease(int unused) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void lock() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryLock() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void unlock() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isLocked() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void interruptIfStarted() {
+ throw new RuntimeException("Stub!");
+ }
+
+ volatile long completedTasks;
+
+ java.lang.Runnable firstTask;
+
+ private static final long serialVersionUID = 6138294804551838833L; // 0x552f9a9a47f02c71L
+
+ final java.lang.Thread thread;
+
+ {
+ thread = null;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/concurrent/atomic/AtomicInteger.java b/ojluni/annotations/hiddenapi/java/util/concurrent/atomic/AtomicInteger.java
new file mode 100644
index 0000000..a5718ac
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/concurrent/atomic/AtomicInteger.java
@@ -0,0 +1,153 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent.atomic;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class AtomicInteger extends java.lang.Number implements java.io.Serializable {
+
+ public AtomicInteger(int initialValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public AtomicInteger() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int get() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void set(int newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final void lazySet(int newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int getAndSet(int newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean compareAndSet(int expect, int update) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean weakCompareAndSet(int expect, int update) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int getAndIncrement() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int getAndDecrement() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int getAndAdd(int delta) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int incrementAndGet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int decrementAndGet() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int addAndGet(int delta) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int getAndUpdate(java.util.function.IntUnaryOperator updateFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int updateAndGet(java.util.function.IntUnaryOperator updateFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int getAndAccumulate(
+ int x, java.util.function.IntBinaryOperator accumulatorFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int accumulateAndGet(
+ int x, java.util.function.IntBinaryOperator accumulatorFunction) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int intValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long longValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public float floatValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public double doubleValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final sun.misc.Unsafe U;
+
+ static {
+ U = null;
+ }
+
+ private static final long VALUE;
+
+ static {
+ VALUE = 0;
+ }
+
+ private static final long serialVersionUID = 6214790243416807050L; // 0x563f5ecc8c6c168aL
+
+ @UnsupportedAppUsage
+ private volatile int value;
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/concurrent/locks/ReentrantLock.java b/ojluni/annotations/hiddenapi/java/util/concurrent/locks/ReentrantLock.java
new file mode 100644
index 0000000..1ad6e8d
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/concurrent/locks/ReentrantLock.java
@@ -0,0 +1,218 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent.locks;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ReentrantLock implements java.util.concurrent.locks.Lock, java.io.Serializable {
+
+ public ReentrantLock() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ReentrantLock(boolean fair) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void lock() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void lockInterruptibly() throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryLock() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean tryLock(long timeout, java.util.concurrent.TimeUnit unit)
+ throws java.lang.InterruptedException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void unlock() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.concurrent.locks.Condition newCondition() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getHoldCount() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isHeldByCurrentThread() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isLocked() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean isFair() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.lang.Thread getOwner() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean hasQueuedThreads() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final boolean hasQueuedThread(java.lang.Thread thread) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public final int getQueueLength() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.util.Collection<java.lang.Thread> getQueuedThreads() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasWaiters(java.util.concurrent.locks.Condition condition) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getWaitQueueLength(java.util.concurrent.locks.Condition condition) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.util.Collection<java.lang.Thread> getWaitingThreads(
+ java.util.concurrent.locks.Condition condition) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = 7373984872572414699L; // 0x6655a82c2cc86aebL
+
+ @UnsupportedAppUsage
+ private final java.util.concurrent.locks.ReentrantLock.Sync sync;
+
+ {
+ sync = null;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class FairSync extends java.util.concurrent.locks.ReentrantLock.Sync {
+
+ FairSync() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void lock() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected boolean tryAcquire(int acquires) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = -3000897897090466540L; // 0xd65aab4314b4bd14L
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class NonfairSync extends java.util.concurrent.locks.ReentrantLock.Sync {
+
+ NonfairSync() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void lock() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected boolean tryAcquire(int acquires) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = 7316153563782823691L; // 0x658832e7537bbf0bL
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ abstract static class Sync extends java.util.concurrent.locks.AbstractQueuedSynchronizer {
+
+ Sync() {
+ throw new RuntimeException("Stub!");
+ }
+
+ abstract void lock();
+
+ final boolean nonfairTryAcquire(int acquires) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final boolean tryRelease(int releases) {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected final boolean isHeldExclusively() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject newCondition() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.lang.Thread getOwner() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final int getHoldCount() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final boolean isLocked() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readObject(java.io.ObjectInputStream s)
+ throws java.lang.ClassNotFoundException, java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final long serialVersionUID = -5179523762034025860L; // 0xb81ea294aa445a7cL
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/jar/JarFile.java b/ojluni/annotations/hiddenapi/java/util/jar/JarFile.java
new file mode 100644
index 0000000..1c97964
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/jar/JarFile.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1997, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util.jar;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class JarFile extends java.util.zip.ZipFile {
+
+ public JarFile(java.lang.String name) throws java.io.IOException {
+ super((java.lang.String) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public JarFile(java.lang.String name, boolean verify) throws java.io.IOException {
+ super((java.lang.String) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public JarFile(java.io.File file) throws java.io.IOException {
+ super((java.lang.String) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public JarFile(java.io.File file, boolean verify) throws java.io.IOException {
+ super((java.lang.String) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public JarFile(java.io.File file, boolean verify, int mode) throws java.io.IOException {
+ super((java.lang.String) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.jar.Manifest getManifest() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized java.util.jar.Manifest getManifestFromReference()
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private native java.lang.String[] getMetaInfEntryNames();
+
+ public java.util.jar.JarEntry getJarEntry(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.zip.ZipEntry getEntry(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Enumeration<java.util.jar.JarEntry> entries() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.Stream<java.util.jar.JarEntry> stream() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void maybeInstantiateVerifier() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void initializeVerifier() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private byte[] getBytes(java.util.zip.ZipEntry ze) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized java.io.InputStream getInputStream(java.util.zip.ZipEntry ze)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized java.util.jar.JarEntry getManEntry() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasClassPathAttribute() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean match(char[] src, byte[] b, int[] lastOcc, int[] optoSft) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkForSpecialAttributes() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.jar.JarEntry newEntry(java.util.zip.ZipEntry ze) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final char[] CLASSPATH_CHARS;
+
+ static {
+ CLASSPATH_CHARS = new char[0];
+ }
+
+ private static final int[] CLASSPATH_LASTOCC;
+
+ static {
+ CLASSPATH_LASTOCC = new int[0];
+ }
+
+ private static final int[] CLASSPATH_OPTOSFT;
+
+ static {
+ CLASSPATH_OPTOSFT = new int[0];
+ }
+
+ public static final java.lang.String MANIFEST_NAME = "META-INF/MANIFEST.MF";
+
+ private volatile boolean hasCheckedSpecialAttributes;
+
+ private boolean hasClassPathAttribute;
+
+ private java.util.jar.JarVerifier jv;
+
+ private boolean jvInitialized;
+
+ private java.util.jar.JarEntry manEntry;
+
+ @UnsupportedAppUsage
+ private java.util.jar.Manifest manifest;
+
+ private boolean verify;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class JarEntryIterator
+ implements java.util.Enumeration<java.util.jar.JarEntry>,
+ java.util.Iterator<java.util.jar.JarEntry> {
+
+ private JarEntryIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.jar.JarEntry next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasMoreElements() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.jar.JarEntry nextElement() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.Enumeration<? extends java.util.zip.ZipEntry> e;
+
+ {
+ e = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class JarFileEntry extends java.util.jar.JarEntry {
+
+ JarFileEntry(java.util.zip.ZipEntry ze) {
+ super((java.lang.String) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.jar.Attributes getAttributes() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.security.cert.Certificate[] getCertificates() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.security.CodeSigner[] getCodeSigners() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/logging/Handler.java b/ojluni/annotations/hiddenapi/java/util/logging/Handler.java
new file mode 100644
index 0000000..2d04f15
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/logging/Handler.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2000, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util.logging;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class Handler {
+
+ protected Handler() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract void publish(java.util.logging.LogRecord record);
+
+ public abstract void flush();
+
+ public abstract void close() throws java.lang.SecurityException;
+
+ public synchronized void setFormatter(java.util.logging.Formatter newFormatter)
+ throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.logging.Formatter getFormatter() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setEncoding(java.lang.String encoding)
+ throws java.lang.SecurityException, java.io.UnsupportedEncodingException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getEncoding() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setFilter(java.util.logging.Filter newFilter)
+ throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.logging.Filter getFilter() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setErrorManager(java.util.logging.ErrorManager em) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.logging.ErrorManager getErrorManager() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void reportError(java.lang.String msg, java.lang.Exception ex, int code) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void setLevel(java.util.logging.Level newLevel)
+ throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.logging.Level getLevel() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isLoggable(java.util.logging.LogRecord record) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void checkPermission() throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private volatile java.lang.String encoding;
+
+ private volatile java.util.logging.ErrorManager errorManager;
+
+ private volatile java.util.logging.Filter filter;
+
+ private volatile java.util.logging.Formatter formatter;
+
+ private volatile java.util.logging.Level logLevel;
+
+ private final java.util.logging.LogManager manager;
+
+ {
+ manager = null;
+ }
+
+ private static final int offValue;
+
+ static {
+ offValue = 0;
+ }
+
+ @UnsupportedAppUsage
+ boolean sealed = true;
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/logging/LogManager.java b/ojluni/annotations/hiddenapi/java/util/logging/LogManager.java
new file mode 100644
index 0000000..a140100
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/logging/LogManager.java
@@ -0,0 +1,518 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 2000, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util.logging;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class LogManager {
+
+ protected LogManager() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private LogManager(java.lang.Void checked) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.Void checkSubclassPermissions() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void ensureLogManagerInitialized() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.logging.LogManager getLogManager() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readPrimordialConfiguration() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public void addPropertyChangeListener(java.beans.PropertyChangeListener l)
+ throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public void removePropertyChangeListener(java.beans.PropertyChangeListener l)
+ throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.util.logging.LogManager.LoggerContext getUserContext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.logging.LogManager.LoggerContext getSystemContext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.util.List<java.util.logging.LogManager.LoggerContext> contexts() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.logging.Logger demandLogger(
+ java.lang.String name, java.lang.String resourceBundleName, java.lang.Class<?> caller) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.logging.Logger demandSystemLogger(
+ java.lang.String name, java.lang.String resourceBundleName) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.Class getClassInstance(java.lang.String cname)
+ throws java.lang.ClassNotFoundException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void loadLoggerHandlers(
+ java.util.logging.Logger logger,
+ java.lang.String name,
+ java.lang.String handlersPropertyName) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void drainLoggerRefQueueBounded() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean addLogger(java.util.logging.Logger logger) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void doSetLevel(java.util.logging.Logger logger, java.util.logging.Level level) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void doSetParent(
+ java.util.logging.Logger logger, java.util.logging.Logger parent) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.logging.Logger getLogger(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Enumeration<java.lang.String> getLoggerNames() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void readConfiguration() throws java.io.IOException, java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void reset() throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void resetLogger(java.util.logging.Logger logger) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.String[] parseClassNames(java.lang.String propertyName) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void readConfiguration(java.io.InputStream ins)
+ throws java.io.IOException, java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getProperty(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.String getStringProperty(java.lang.String name, java.lang.String defaultValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ int getIntProperty(java.lang.String name, int defaultValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean getBooleanProperty(java.lang.String name, boolean defaultValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.logging.Level getLevelProperty(
+ java.lang.String name, java.util.logging.Level defaultValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.logging.Filter getFilterProperty(
+ java.lang.String name, java.util.logging.Filter defaultValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ java.util.logging.Formatter getFormatterProperty(
+ java.lang.String name, java.util.logging.Formatter defaultValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized void initializeGlobalHandlers() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void checkPermission() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void checkAccess() throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized void setLevelsOnExistingLoggers() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static synchronized java.util.logging.LoggingMXBean getLoggingMXBean() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.lang.String LOGGING_MXBEAN_NAME = "java.util.logging:type=Logging";
+
+ private static final int MAX_ITERATIONS = 400; // 0x190
+
+ private java.util.WeakHashMap<java.lang.Object, java.util.logging.LogManager.LoggerContext>
+ contextsMap;
+
+ private final java.security.Permission controlPermission;
+
+ {
+ controlPermission = null;
+ }
+
+ private boolean deathImminent;
+
+ private static final java.util.logging.Level defaultLevel;
+
+ static {
+ defaultLevel = null;
+ }
+
+ private volatile boolean initializationDone = false;
+
+ private boolean initializedCalled = false;
+
+ private boolean initializedGlobalHandlers = true;
+
+ private final java.util.Map<java.lang.Object, java.lang.Integer> listenerMap;
+
+ {
+ listenerMap = null;
+ }
+
+ private final java.lang.ref.ReferenceQueue<java.util.logging.Logger> loggerRefQueue;
+
+ {
+ loggerRefQueue = null;
+ }
+
+ private static java.util.logging.LoggingMXBean loggingMXBean;
+
+ private static final java.util.logging.LogManager manager;
+
+ static {
+ manager = null;
+ }
+
+ private volatile java.util.Properties props;
+
+ private volatile boolean readPrimordialConfiguration;
+
+ private volatile java.util.logging.Logger rootLogger;
+
+ private final java.util.logging.LogManager.LoggerContext systemContext;
+
+ {
+ systemContext = null;
+ }
+
+ private final java.util.logging.LogManager.LoggerContext userContext;
+
+ {
+ userContext = null;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class Beans {
+
+ private Beans() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.Class<?> getClass(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.reflect.Constructor<?> getConstructor(
+ java.lang.Class<?> c, java.lang.Class<?>... types) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.lang.reflect.Method getMethod(
+ java.lang.Class<?> c, java.lang.String name, java.lang.Class<?>... types) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static boolean isBeansPresent() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.lang.Object newPropertyChangeEvent(
+ java.lang.Object source,
+ java.lang.String prop,
+ java.lang.Object oldValue,
+ java.lang.Object newValue) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static void invokePropertyChange(java.lang.Object listener, java.lang.Object ev) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final java.lang.Class<?> propertyChangeEventClass;
+
+ static {
+ propertyChangeEventClass = null;
+ }
+
+ private static final java.lang.Class<?> propertyChangeListenerClass;
+
+ static {
+ propertyChangeListenerClass = null;
+ }
+
+ private static final java.lang.reflect.Method propertyChangeMethod;
+
+ static {
+ propertyChangeMethod = null;
+ }
+
+ private static final java.lang.reflect.Constructor<?> propertyEventCtor;
+
+ static {
+ propertyEventCtor = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class Cleaner extends java.lang.Thread {
+
+ private Cleaner() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void run() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class LogNode {
+
+ LogNode(
+ java.util.logging.LogManager.LogNode parent,
+ java.util.logging.LogManager.LoggerContext context) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void walkAndSetParent(java.util.logging.Logger parent) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.HashMap<java.lang.String, java.util.logging.LogManager.LogNode> children;
+
+ final java.util.logging.LogManager.LoggerContext context;
+
+ {
+ context = null;
+ }
+
+ java.util.logging.LogManager.LoggerWeakRef loggerRef;
+
+ java.util.logging.LogManager.LogNode parent;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ class LoggerContext {
+
+ private LoggerContext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final boolean requiresDefaultLoggers() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.logging.LogManager getOwner() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.logging.Logger getRootLogger() {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.logging.Logger getGlobalLogger() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.logging.Logger demandLogger(
+ java.lang.String name, java.lang.String resourceBundleName) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void ensureInitialized() {
+ throw new RuntimeException("Stub!");
+ }
+
+ synchronized java.util.logging.Logger findLogger(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void ensureAllDefaultLoggers(java.util.logging.Logger logger) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void ensureDefaultLogger(java.util.logging.Logger logger) {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean addLocalLogger(java.util.logging.Logger logger) {
+ throw new RuntimeException("Stub!");
+ }
+
+ synchronized boolean addLocalLogger(
+ java.util.logging.Logger logger, boolean addDefaultLoggersIfNeeded) {
+ throw new RuntimeException("Stub!");
+ }
+
+ synchronized void removeLoggerRef(
+ java.lang.String name, java.util.logging.LogManager.LoggerWeakRef ref) {
+ throw new RuntimeException("Stub!");
+ }
+
+ synchronized java.util.Enumeration<java.lang.String> getLoggerNames() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void processParentHandlers(java.util.logging.Logger logger, java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.logging.LogManager.LogNode getNode(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.util.Hashtable<
+ java.lang.String, java.util.logging.LogManager.LoggerWeakRef>
+ namedLoggers;
+
+ {
+ namedLoggers = null;
+ }
+
+ private final java.util.logging.LogManager.LogNode root;
+
+ {
+ root = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ final class LoggerWeakRef extends java.lang.ref.WeakReference<java.util.logging.Logger> {
+
+ LoggerWeakRef(java.util.logging.Logger logger) {
+ super(null);
+ throw new RuntimeException("Stub!");
+ }
+
+ void dispose() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setNode(java.util.logging.LogManager.LogNode node) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setParentRef(java.lang.ref.WeakReference<java.util.logging.Logger> parentRef) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private boolean disposed = false;
+
+ private java.lang.String name;
+
+ private java.util.logging.LogManager.LogNode node;
+
+ private java.lang.ref.WeakReference<java.util.logging.Logger> parentRef;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private final class RootLogger extends java.util.logging.Logger {
+
+ private RootLogger() {
+ super("", null, null, LogManager.this, true);
+ throw new RuntimeException("Stub!");
+ }
+
+ public void log(java.util.logging.LogRecord record) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void addHandler(java.util.logging.Handler h) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void removeHandler(java.util.logging.Handler h) {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.logging.Handler[] accessCheckedHandlers() {
+ throw new RuntimeException("Stub!");
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ final class SystemLoggerContext extends java.util.logging.LogManager.LoggerContext {
+
+ SystemLoggerContext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.logging.Logger demandLogger(
+ java.lang.String name, java.lang.String resourceBundleName) {
+ throw new RuntimeException("Stub!");
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/logging/Logger.java b/ojluni/annotations/hiddenapi/java/util/logging/Logger.java
new file mode 100644
index 0000000..f504c96
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/logging/Logger.java
@@ -0,0 +1,572 @@
+/*
+ * Copyright (c) 2000, 2014, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util.logging;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Logger {
+
+ protected Logger(java.lang.String name, java.lang.String resourceBundleName) {
+ throw new RuntimeException("Stub!");
+ }
+
+ Logger(
+ java.lang.String name,
+ java.lang.String resourceBundleName,
+ java.lang.Class<?> caller,
+ java.util.logging.LogManager manager,
+ boolean isSystemLogger) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private Logger(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.util.logging.Logger getGlobal() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void setCallersClassLoaderRef(java.lang.Class<?> caller) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.lang.ClassLoader getCallersClassLoader() {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setLogManager(java.util.logging.LogManager manager) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void checkPermission() throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.util.logging.Logger demandLogger(
+ java.lang.String name, java.lang.String resourceBundleName, java.lang.Class<?> caller) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.logging.Logger getLogger(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.logging.Logger getLogger(
+ java.lang.String name, java.lang.String resourceBundleName) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.util.logging.Logger getPlatformLogger(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.logging.Logger getAnonymousLogger() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.util.logging.Logger getAnonymousLogger(java.lang.String resourceBundleName) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.ResourceBundle getResourceBundle() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getResourceBundleName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setFilter(java.util.logging.Filter newFilter) throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.logging.Filter getFilter() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void log(java.util.logging.LogRecord record) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void doLog(java.util.logging.LogRecord lr) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void log(java.util.logging.Level level, java.lang.String msg) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void log(
+ java.util.logging.Level level,
+ java.util.function.Supplier<java.lang.String> msgSupplier) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void log(java.util.logging.Level level, java.lang.String msg, java.lang.Object param1) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void log(
+ java.util.logging.Level level, java.lang.String msg, java.lang.Object[] params) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void log(
+ java.util.logging.Level level, java.lang.String msg, java.lang.Throwable thrown) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void log(
+ java.util.logging.Level level,
+ java.lang.Throwable thrown,
+ java.util.function.Supplier<java.lang.String> msgSupplier) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void logp(
+ java.util.logging.Level level,
+ java.lang.String sourceClass,
+ java.lang.String sourceMethod,
+ java.lang.String msg) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void logp(
+ java.util.logging.Level level,
+ java.lang.String sourceClass,
+ java.lang.String sourceMethod,
+ java.util.function.Supplier<java.lang.String> msgSupplier) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void logp(
+ java.util.logging.Level level,
+ java.lang.String sourceClass,
+ java.lang.String sourceMethod,
+ java.lang.String msg,
+ java.lang.Object param1) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void logp(
+ java.util.logging.Level level,
+ java.lang.String sourceClass,
+ java.lang.String sourceMethod,
+ java.lang.String msg,
+ java.lang.Object[] params) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void logp(
+ java.util.logging.Level level,
+ java.lang.String sourceClass,
+ java.lang.String sourceMethod,
+ java.lang.String msg,
+ java.lang.Throwable thrown) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void logp(
+ java.util.logging.Level level,
+ java.lang.String sourceClass,
+ java.lang.String sourceMethod,
+ java.lang.Throwable thrown,
+ java.util.function.Supplier<java.lang.String> msgSupplier) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void doLog(java.util.logging.LogRecord lr, java.lang.String rbname) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void doLog(java.util.logging.LogRecord lr, java.util.ResourceBundle rb) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public void logrb(
+ java.util.logging.Level level,
+ java.lang.String sourceClass,
+ java.lang.String sourceMethod,
+ java.lang.String bundleName,
+ java.lang.String msg) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public void logrb(
+ java.util.logging.Level level,
+ java.lang.String sourceClass,
+ java.lang.String sourceMethod,
+ java.lang.String bundleName,
+ java.lang.String msg,
+ java.lang.Object param1) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public void logrb(
+ java.util.logging.Level level,
+ java.lang.String sourceClass,
+ java.lang.String sourceMethod,
+ java.lang.String bundleName,
+ java.lang.String msg,
+ java.lang.Object[] params) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void logrb(
+ java.util.logging.Level level,
+ java.lang.String sourceClass,
+ java.lang.String sourceMethod,
+ java.util.ResourceBundle bundle,
+ java.lang.String msg,
+ java.lang.Object... params) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @Deprecated
+ public void logrb(
+ java.util.logging.Level level,
+ java.lang.String sourceClass,
+ java.lang.String sourceMethod,
+ java.lang.String bundleName,
+ java.lang.String msg,
+ java.lang.Throwable thrown) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void logrb(
+ java.util.logging.Level level,
+ java.lang.String sourceClass,
+ java.lang.String sourceMethod,
+ java.util.ResourceBundle bundle,
+ java.lang.String msg,
+ java.lang.Throwable thrown) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void entering(java.lang.String sourceClass, java.lang.String sourceMethod) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void entering(
+ java.lang.String sourceClass, java.lang.String sourceMethod, java.lang.Object param1) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void entering(
+ java.lang.String sourceClass,
+ java.lang.String sourceMethod,
+ java.lang.Object[] params) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void exiting(java.lang.String sourceClass, java.lang.String sourceMethod) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void exiting(
+ java.lang.String sourceClass, java.lang.String sourceMethod, java.lang.Object result) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void throwing(
+ java.lang.String sourceClass,
+ java.lang.String sourceMethod,
+ java.lang.Throwable thrown) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void severe(java.lang.String msg) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void warning(java.lang.String msg) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void info(java.lang.String msg) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void config(java.lang.String msg) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void fine(java.lang.String msg) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void finer(java.lang.String msg) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void finest(java.lang.String msg) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void severe(java.util.function.Supplier<java.lang.String> msgSupplier) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void warning(java.util.function.Supplier<java.lang.String> msgSupplier) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void info(java.util.function.Supplier<java.lang.String> msgSupplier) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void config(java.util.function.Supplier<java.lang.String> msgSupplier) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void fine(java.util.function.Supplier<java.lang.String> msgSupplier) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void finer(java.util.function.Supplier<java.lang.String> msgSupplier) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void finest(java.util.function.Supplier<java.lang.String> msgSupplier) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setLevel(java.util.logging.Level newLevel) throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ final boolean isLevelInitialized() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.logging.Level getLevel() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isLoggable(java.util.logging.Level level) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void addHandler(java.util.logging.Handler handler) throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void removeHandler(java.util.logging.Handler handler)
+ throws java.lang.SecurityException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.logging.Handler[] getHandlers() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.util.logging.Handler[] accessCheckedHandlers() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setUseParentHandlers(boolean useParentHandlers) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean getUseParentHandlers() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static java.util.ResourceBundle findSystemResourceBundle(java.util.Locale locale) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized java.util.ResourceBundle findResourceBundle(
+ java.lang.String name, boolean useCallersClassLoader) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private synchronized void setupResourceInfo(
+ java.lang.String name, java.lang.Class<?> callersClass) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setResourceBundle(java.util.ResourceBundle bundle) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.logging.Logger getParent() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setParent(java.util.logging.Logger parent) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void doSetParent(java.util.logging.Logger newParent) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final void removeChildLogger(java.util.logging.LogManager.LoggerWeakRef child) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void updateEffectiveLevel() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.util.logging.Logger.LoggerBundle getEffectiveLoggerBundle() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final java.lang.String GLOBAL_LOGGER_NAME = "global";
+
+ private static final java.util.logging.Logger.LoggerBundle NO_RESOURCE_BUNDLE;
+
+ static {
+ NO_RESOURCE_BUNDLE = null;
+ }
+
+ private static final java.util.logging.Logger.LoggerBundle SYSTEM_BUNDLE;
+
+ static {
+ SYSTEM_BUNDLE = null;
+ }
+
+ static final java.lang.String SYSTEM_LOGGER_RB_NAME = "sun.util.logging.resources.logging";
+
+ private boolean anonymous;
+
+ private java.lang.ref.WeakReference<java.lang.ClassLoader> callersClassLoaderRef;
+
+ private java.util.ResourceBundle catalog;
+
+ private java.util.Locale catalogLocale;
+
+ private java.lang.String catalogName;
+
+ private static final java.util.logging.Handler[] emptyHandlers;
+
+ static {
+ emptyHandlers = new java.util.logging.Handler[0];
+ }
+
+ private volatile java.util.logging.Filter filter;
+
+ @Deprecated public static final java.util.logging.Logger global;
+
+ static {
+ global = null;
+ }
+
+ private final java.util.concurrent.CopyOnWriteArrayList<java.util.logging.Handler> handlers;
+
+ {
+ handlers = null;
+ }
+
+ private final boolean isSystemLogger;
+
+ {
+ isSystemLogger = false;
+ }
+
+ private java.util.ArrayList<java.util.logging.LogManager.LoggerWeakRef> kids;
+
+ private volatile java.util.logging.Level levelObject;
+
+ private volatile int levelValue;
+
+ private volatile java.util.logging.Logger.LoggerBundle loggerBundle;
+
+ private volatile java.util.logging.LogManager manager;
+
+ private java.lang.String name;
+
+ private static final int offValue;
+
+ static {
+ offValue = 0;
+ }
+
+ private volatile java.util.logging.Logger parent;
+
+ @UnsupportedAppUsage
+ private static final java.lang.Object treeLock;
+
+ static {
+ treeLock = null;
+ }
+
+ private volatile boolean useParentHandlers = true;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static final class LoggerBundle {
+
+ private LoggerBundle(java.lang.String resourceBundleName, java.util.ResourceBundle bundle) {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean isSystemBundle() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.util.logging.Logger.LoggerBundle get(
+ java.lang.String name, java.util.ResourceBundle bundle) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.lang.String resourceBundleName;
+
+ {
+ resourceBundleName = null;
+ }
+
+ final java.util.ResourceBundle userBundle;
+
+ {
+ userBundle = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class SystemLoggerHelper {
+
+ private SystemLoggerHelper() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static boolean getBooleanProperty(java.lang.String key) {
+ throw new RuntimeException("Stub!");
+ }
+
+ static boolean disableCallerCheck;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/regex/Matcher.java b/ojluni/annotations/hiddenapi/java/util/regex/Matcher.java
new file mode 100644
index 0000000..18d6d95
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/regex/Matcher.java
@@ -0,0 +1,309 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1999, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util.regex;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public final class Matcher implements java.util.regex.MatchResult {
+
+ Matcher(java.util.regex.Pattern parent, java.lang.CharSequence text) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.regex.Pattern pattern() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.regex.MatchResult toMatchResult() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.regex.Matcher usePattern(java.util.regex.Pattern newPattern) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.regex.Matcher reset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.regex.Matcher reset(java.lang.CharSequence input) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int start() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int start(int group) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int start(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int end() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int end(int group) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int end(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String group() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String group(int group) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String group(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int groupCount() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean matches() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean find() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean find(int start) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean lookingAt() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static java.lang.String quoteReplacement(java.lang.String s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.regex.Matcher appendReplacement(
+ java.lang.StringBuffer sb, java.lang.String replacement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void appendEvaluated(java.lang.StringBuffer buffer, java.lang.String s) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.StringBuffer appendTail(java.lang.StringBuffer sb) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String replaceAll(java.lang.String replacement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String replaceFirst(java.lang.String replacement) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.regex.Matcher region(int start, int end) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int regionStart() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int regionEnd() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasTransparentBounds() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.regex.Matcher useTransparentBounds(boolean b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasAnchoringBounds() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.regex.Matcher useAnchoringBounds(boolean b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hitEnd() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean requireEnd() {
+ throw new RuntimeException("Stub!");
+ }
+
+ int getTextLength() {
+ throw new RuntimeException("Stub!");
+ }
+
+ java.lang.CharSequence getSubSequence(int beginIndex, int endIndex) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.util.regex.Matcher reset(java.lang.CharSequence input, int start, int end) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void resetForInput() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void ensureMatch() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int getMatchedGroupIndex(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native int getMatchedGroupIndex0(long patternAddr, java.lang.String name);
+
+ private static native boolean findImpl(long addr, int startIndex, int[] offsets);
+
+ private static native boolean findNextImpl(long addr, int[] offsets);
+
+ private static native long getNativeFinalizer();
+
+ private static native int groupCountImpl(long addr);
+
+ private static native boolean hitEndImpl(long addr);
+
+ private static native boolean lookingAtImpl(long addr, int[] offsets);
+
+ private static native boolean matchesImpl(long addr, int[] offsets);
+
+ private static native int nativeSize();
+
+ private static native long openImpl(long patternAddr);
+
+ private static native boolean requireEndImpl(long addr);
+
+ private static native void setInputImpl(long addr, java.lang.String s, int start, int end);
+
+ private static native void useAnchoringBoundsImpl(long addr, boolean value);
+
+ private static native void useTransparentBoundsImpl(long addr, boolean value);
+
+ private long address;
+
+ boolean anchoringBounds = true;
+
+ @UnsupportedAppUsage
+ int appendPos = 0; // 0x0
+
+ int from;
+
+ int[] groups;
+
+ private boolean matchFound;
+
+ private java.lang.Runnable nativeFinalizer;
+
+ private java.lang.CharSequence originalInput;
+
+ private java.util.regex.Pattern parentPattern;
+
+ private static final libcore.util.NativeAllocationRegistry registry;
+
+ static {
+ registry = null;
+ }
+
+ java.lang.String text;
+
+ int to;
+
+ boolean transparentBounds = false;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ static final class OffsetBasedMatchResult implements java.util.regex.MatchResult {
+
+ OffsetBasedMatchResult(java.lang.String input, int[] offsets) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int start() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int start(int group) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int end() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int end(int group) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String group() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String group(int group) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int groupCount() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private final java.lang.String input;
+
+ {
+ input = null;
+ }
+
+ private final int[] offsets;
+
+ {
+ offsets = new int[0];
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/zip/Adler32.java b/ojluni/annotations/hiddenapi/java/util/zip/Adler32.java
new file mode 100644
index 0000000..f78844f
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/zip/Adler32.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 1996, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util.zip;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Adler32 implements java.util.zip.Checksum {
+
+ public Adler32() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void update(int b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void update(byte[] b, int off, int len) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void update(byte[] b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void update(java.nio.ByteBuffer buffer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void reset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static native int update(int adler, int b);
+
+ private static native int updateBytes(int adler, byte[] b, int off, int len);
+
+ private static native int updateByteBuffer(int adler, long addr, int off, int len);
+
+ private int adler = 1; // 0x1
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/zip/CRC32.java b/ojluni/annotations/hiddenapi/java/util/zip/CRC32.java
new file mode 100644
index 0000000..0e25349
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/zip/CRC32.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 1996, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util.zip;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class CRC32 implements java.util.zip.Checksum {
+
+ public CRC32() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void update(int b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void update(byte[] b, int off, int len) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void update(byte[] b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void update(java.nio.ByteBuffer buffer) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void reset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getValue() {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static native int update(int crc, int b);
+
+ private static native int updateBytes(int crc, byte[] b, int off, int len);
+
+ private static native int updateByteBuffer(int adler, long addr, int off, int len);
+
+ private int crc;
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/zip/Deflater.java b/ojluni/annotations/hiddenapi/java/util/zip/Deflater.java
new file mode 100644
index 0000000..f8f419d
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/zip/Deflater.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) 1996, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util.zip;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Deflater {
+
+ public Deflater(int level, boolean nowrap) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Deflater(int level) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Deflater() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setInput(byte[] b, int off, int len) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setInput(byte[] b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setDictionary(byte[] b, int off, int len) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setDictionary(byte[] b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setStrategy(int strategy) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setLevel(int level) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean needsInput() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void finish() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean finished() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int deflate(byte[] b, int off, int len) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int deflate(byte[] b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int deflate(byte[] b, int off, int len, int flush) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getAdler() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getTotalIn() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getBytesRead() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getTotalOut() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getBytesWritten() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void reset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void end() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void finalize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void ensureOpen() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native long init(int level, int strategy, boolean nowrap);
+
+ private static native void setDictionary(long addr, byte[] b, int off, int len);
+
+ private native int deflateBytes(long addr, byte[] b, int off, int len, int flush);
+
+ private static native int getAdler(long addr);
+
+ private static native void reset(long addr);
+
+ private static native void end(long addr);
+
+ public static final int BEST_COMPRESSION = 9; // 0x9
+
+ public static final int BEST_SPEED = 1; // 0x1
+
+ public static final int DEFAULT_COMPRESSION = -1; // 0xffffffff
+
+ public static final int DEFAULT_STRATEGY = 0; // 0x0
+
+ public static final int DEFLATED = 8; // 0x8
+
+ public static final int FILTERED = 1; // 0x1
+
+ public static final int FULL_FLUSH = 3; // 0x3
+
+ public static final int HUFFMAN_ONLY = 2; // 0x2
+
+ public static final int NO_COMPRESSION = 0; // 0x0
+
+ public static final int NO_FLUSH = 0; // 0x0
+
+ public static final int SYNC_FLUSH = 2; // 0x2
+
+ @UnsupportedAppUsage
+ private byte[] buf;
+
+ private long bytesRead;
+
+ private long bytesWritten;
+
+ @UnsupportedAppUsage
+ private boolean finish;
+
+ @UnsupportedAppUsage
+ private boolean finished;
+
+ private final dalvik.system.CloseGuard guard;
+
+ {
+ guard = null;
+ }
+
+ @UnsupportedAppUsage
+ private int len;
+
+ @UnsupportedAppUsage
+ private int level;
+
+ @UnsupportedAppUsage
+ private int off;
+
+ @UnsupportedAppUsage
+ private boolean setParams;
+
+ @UnsupportedAppUsage
+ private int strategy;
+
+ private final java.util.zip.ZStreamRef zsRef;
+
+ {
+ zsRef = null;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/zip/Inflater.java b/ojluni/annotations/hiddenapi/java/util/zip/Inflater.java
new file mode 100644
index 0000000..c4194d2
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/zip/Inflater.java
@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1996, 2013, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util.zip;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Inflater {
+
+ public Inflater(boolean nowrap) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public Inflater() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setInput(byte[] b, int off, int len) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setInput(byte[] b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setDictionary(byte[] b, int off, int len) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setDictionary(byte[] b) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getRemaining() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean needsInput() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean needsDictionary() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean finished() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int inflate(byte[] b, int off, int len) throws java.util.zip.DataFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int inflate(byte[] b) throws java.util.zip.DataFormatException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getAdler() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getTotalIn() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getBytesRead() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getTotalOut() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getBytesWritten() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void reset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void end() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void finalize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void ensureOpen() {
+ throw new RuntimeException("Stub!");
+ }
+
+ boolean ended() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native long init(boolean nowrap);
+
+ private static native void setDictionary(long addr, byte[] b, int off, int len);
+
+ private native int inflateBytes(long addr, byte[] b, int off, int len)
+ throws java.util.zip.DataFormatException;
+
+ private static native int getAdler(long addr);
+
+ private static native void reset(long addr);
+
+ private static native void end(long addr);
+
+ @UnsupportedAppUsage
+ private byte[] buf;
+
+ private long bytesRead;
+
+ private long bytesWritten;
+
+ private static final byte[] defaultBuf;
+
+ static {
+ defaultBuf = new byte[0];
+ }
+
+ @UnsupportedAppUsage
+ private boolean finished;
+
+ private final dalvik.system.CloseGuard guard;
+
+ {
+ guard = null;
+ }
+
+ @UnsupportedAppUsage
+ private int len;
+
+ @UnsupportedAppUsage
+ private boolean needDict;
+
+ @UnsupportedAppUsage
+ private int off;
+
+ private final java.util.zip.ZStreamRef zsRef;
+
+ {
+ zsRef = null;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/zip/ZipEntry.java b/ojluni/annotations/hiddenapi/java/util/zip/ZipEntry.java
new file mode 100644
index 0000000..87ca0f5
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/zip/ZipEntry.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1995, 2015, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util.zip;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ZipEntry implements java.util.zip.ZipConstants, java.lang.Cloneable {
+
+ @UnsupportedAppUsage
+ public ZipEntry(
+ java.lang.String name,
+ java.lang.String comment,
+ long crc,
+ long compressedSize,
+ long size,
+ int compressionMethod,
+ int xdostime,
+ byte[] extra,
+ long dataOffset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ZipEntry(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ZipEntry(java.util.zip.ZipEntry e) {
+ throw new RuntimeException("Stub!");
+ }
+
+ ZipEntry() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getDataOffset() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setTime(long time) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getTime() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.zip.ZipEntry setLastModifiedTime(java.nio.file.attribute.FileTime time) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.file.attribute.FileTime getLastModifiedTime() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.zip.ZipEntry setLastAccessTime(java.nio.file.attribute.FileTime time) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.file.attribute.FileTime getLastAccessTime() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.zip.ZipEntry setCreationTime(java.nio.file.attribute.FileTime time) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.nio.file.attribute.FileTime getCreationTime() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setSize(long size) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getCompressedSize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setCompressedSize(long csize) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setCrc(long crc) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long getCrc() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setMethod(int method) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getMethod() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setExtra(byte[] extra) {
+ throw new RuntimeException("Stub!");
+ }
+
+ void setExtra0(byte[] extra, boolean doZIP64) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public byte[] getExtra() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setComment(java.lang.String comment) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getComment() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean isDirectory() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String toString() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int hashCode() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.Object clone() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final int DEFLATED = 8; // 0x8
+
+ static final long DOSTIME_BEFORE_1980 = 2162688L; // 0x210000L
+
+ public static final int STORED = 0; // 0x0
+
+ public static final long UPPER_DOSTIME_BOUND = 4036608000000L; // 0x3abd8960000L
+
+ java.nio.file.attribute.FileTime atime;
+
+ java.lang.String comment;
+
+ long crc = -1; // 0xffffffff
+
+ long csize = -1; // 0xffffffff
+
+ java.nio.file.attribute.FileTime ctime;
+
+ long dataOffset;
+
+ byte[] extra;
+
+ int flag = 0; // 0x0
+
+ @UnsupportedAppUsage
+ int method = -1; // 0xffffffff
+
+ java.nio.file.attribute.FileTime mtime;
+
+ java.lang.String name;
+
+ long size = -1; // 0xffffffff
+
+ long xdostime = -1; // 0xffffffff
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/zip/ZipFile.java b/ojluni/annotations/hiddenapi/java/util/zip/ZipFile.java
new file mode 100644
index 0000000..3c6d5ff
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/zip/ZipFile.java
@@ -0,0 +1,341 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1995, 2015, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util.zip;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ZipFile implements java.util.zip.ZipConstants, java.io.Closeable {
+
+ public ZipFile(java.lang.String name) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ZipFile(java.io.File file, int mode) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ZipFile(java.io.File file) throws java.io.IOException, java.util.zip.ZipException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ZipFile(java.io.File file, int mode, java.nio.charset.Charset charset)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ZipFile(java.lang.String name, java.nio.charset.Charset charset)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public ZipFile(java.io.File file, java.nio.charset.Charset charset) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getComment() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.zip.ZipEntry getEntry(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static native long getEntry(long jzfile, byte[] name, boolean addSlash);
+
+ private static native void freeEntry(long jzfile, long jzentry);
+
+ public java.io.InputStream getInputStream(java.util.zip.ZipEntry entry)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.util.zip.Inflater getInflater() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void releaseInflater(java.util.zip.Inflater inf) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.lang.String getName() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.Enumeration<? extends java.util.zip.ZipEntry> entries() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.stream.Stream<? extends java.util.zip.ZipEntry> stream() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.util.zip.ZipEntry getZipEntry(java.lang.String name, long jzentry) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native long getNextEntry(long jzfile, int i);
+
+ public int size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void close() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void finalize() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ @UnsupportedAppUsage
+ private static native void close(long jzfile);
+
+ private void ensureOpen() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void ensureOpenOrZipException() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean startsWithLocHeader() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int getFileDescriptor() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static native int getFileDescriptor(long jzfile);
+
+ private static native long open(
+ java.lang.String name, int mode, long lastModified, boolean usemmap)
+ throws java.io.IOException;
+
+ private static native int getTotal(long jzfile);
+
+ private static native boolean startsWithLOC(long jzfile);
+
+ private static native int read(long jzfile, long jzentry, long pos, byte[] b, int off, int len);
+
+ private static native long getEntryTime(long jzentry);
+
+ private static native long getEntryCrc(long jzentry);
+
+ private static native long getEntryCSize(long jzentry);
+
+ private static native long getEntrySize(long jzentry);
+
+ private static native int getEntryMethod(long jzentry);
+
+ private static native int getEntryFlag(long jzentry);
+
+ private static native byte[] getCommentBytes(long jzfile);
+
+ private static native byte[] getEntryBytes(long jzentry, int type);
+
+ private static native java.lang.String getZipMessage(long jzfile);
+
+ private static final int DEFLATED = 8; // 0x8
+
+ private static final int JZENTRY_COMMENT = 2; // 0x2
+
+ private static final int JZENTRY_EXTRA = 1; // 0x1
+
+ private static final int JZENTRY_NAME = 0; // 0x0
+
+ public static final int OPEN_DELETE = 4; // 0x4
+
+ public static final int OPEN_READ = 1; // 0x1
+
+ private static final int STORED = 0; // 0x0
+
+ private volatile boolean closeRequested = false;
+
+ private final java.io.File fileToRemoveOnClose;
+
+ {
+ fileToRemoveOnClose = null;
+ }
+
+ private final dalvik.system.CloseGuard guard;
+
+ {
+ guard = null;
+ }
+
+ private java.util.Deque<java.util.zip.Inflater> inflaterCache;
+
+ @UnsupportedAppUsage
+ private long jzfile;
+
+ private final boolean locsig;
+
+ {
+ locsig = false;
+ }
+
+ private final java.lang.String name;
+
+ {
+ name = null;
+ }
+
+ private final java.util.Map<java.io.InputStream, java.util.zip.Inflater> streams;
+
+ {
+ streams = null;
+ }
+
+ private final int total;
+
+ {
+ total = 0;
+ }
+
+ private static final boolean usemmap;
+
+ static {
+ usemmap = false;
+ }
+
+ private java.util.zip.ZipCoder zc;
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class ZipEntryIterator
+ implements java.util.Enumeration<java.util.zip.ZipEntry>,
+ java.util.Iterator<java.util.zip.ZipEntry> {
+
+ public ZipEntryIterator() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasMoreElements() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public boolean hasNext() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.zip.ZipEntry nextElement() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.zip.ZipEntry next() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int i = 0; // 0x0
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class ZipFileInflaterInputStream extends java.util.zip.InflaterInputStream {
+
+ ZipFileInflaterInputStream(
+ java.util.zip.ZipFile.ZipFileInputStream zfin,
+ java.util.zip.Inflater inf,
+ int size) {
+ super((java.io.InputStream) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public void close() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void fill() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int available() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void finalize() throws java.lang.Throwable {
+ throw new RuntimeException("Stub!");
+ }
+
+ private volatile boolean closeRequested = false;
+
+ private boolean eof = false;
+
+ private final java.util.zip.ZipFile.ZipFileInputStream zfin;
+
+ {
+ zfin = null;
+ }
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private class ZipFileInputStream extends java.io.InputStream {
+
+ ZipFileInputStream(long jzentry) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int read(byte[] b, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int read() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long skip(long n) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int available() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long size() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void close() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected void finalize() {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected long jzentry;
+
+ private long pos;
+
+ protected long rem;
+
+ protected long size;
+
+ private volatile boolean zfisCloseRequested = false;
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/zip/ZipInputStream.java b/ojluni/annotations/hiddenapi/java/util/zip/ZipInputStream.java
new file mode 100644
index 0000000..90947b7
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/zip/ZipInputStream.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1996, 2015, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util.zip;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ZipInputStream extends java.util.zip.InflaterInputStream
+ implements java.util.zip.ZipConstants {
+
+ public ZipInputStream(java.io.InputStream in) {
+ super((java.io.InputStream) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public ZipInputStream(java.io.InputStream in, java.nio.charset.Charset charset) {
+ super((java.io.InputStream) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ private void ensureOpen() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public java.util.zip.ZipEntry getNextEntry() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void closeEntry() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int available() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public int read(byte[] b, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public long skip(long n) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void close() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private java.util.zip.ZipEntry readLOC() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ protected java.util.zip.ZipEntry createZipEntry(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readEnd(java.util.zip.ZipEntry e) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void readFully(byte[] b, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static final int DEFLATED = 8; // 0x8
+
+ private static final int STORED = 0; // 0x0
+
+ private byte[] b;
+
+ private boolean closed = false;
+
+ private java.util.zip.CRC32 crc;
+
+ private java.util.zip.ZipEntry entry;
+
+ private boolean entryEOF = false;
+
+ @UnsupportedAppUsage
+ private int flag;
+
+ private long remaining;
+
+ @UnsupportedAppUsage
+ private byte[] tmpbuf;
+
+ private java.util.zip.ZipCoder zc;
+}
diff --git a/ojluni/annotations/hiddenapi/java/util/zip/ZipOutputStream.java b/ojluni/annotations/hiddenapi/java/util/zip/ZipOutputStream.java
new file mode 100644
index 0000000..943fefa
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/java/util/zip/ZipOutputStream.java
@@ -0,0 +1,183 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1996, 2015, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util.zip;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ZipOutputStream extends java.util.zip.DeflaterOutputStream
+ implements java.util.zip.ZipConstants {
+
+ public ZipOutputStream(java.io.OutputStream out) {
+ super((java.io.OutputStream) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ public ZipOutputStream(java.io.OutputStream out, java.nio.charset.Charset charset) {
+ super((java.io.OutputStream) null);
+ throw new RuntimeException("Stub!");
+ }
+
+ private static int version(java.util.zip.ZipEntry e) throws java.util.zip.ZipException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void ensureOpen() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setComment(java.lang.String comment) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setMethod(int method) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void setLevel(int level) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void putNextEntry(java.util.zip.ZipEntry e) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void closeEntry() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public synchronized void write(byte[] b, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void finish() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public void close() throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeLOC(java.util.zip.ZipOutputStream.XEntry xentry) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeEXT(java.util.zip.ZipEntry e) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeCEN(java.util.zip.ZipOutputStream.XEntry xentry) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeEND(long off, long len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private int getExtraLen(byte[] extra) {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeExtra(byte[] extra) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeByte(int v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeShort(int v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeInt(long v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeLong(long v) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ private void writeBytes(byte[] b, int off, int len) throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static final int DEFLATED = 8; // 0x8
+
+ public static final int STORED = 0; // 0x0
+
+ private boolean closed = false;
+
+ private byte[] comment;
+
+ private java.util.zip.CRC32 crc;
+
+ private java.util.zip.ZipOutputStream.XEntry current;
+
+ private boolean finished;
+
+ private static final boolean inhibitZip64 = false;
+
+ private long locoff = 0; // 0x0
+
+ @UnsupportedAppUsage
+ private int method = 8; // 0x8
+
+ @UnsupportedAppUsage
+ private java.util.HashSet<java.lang.String> names;
+
+ @UnsupportedAppUsage
+ private long written = 0; // 0x0
+
+ private java.util.Vector<java.util.zip.ZipOutputStream.XEntry> xentries;
+
+ private final java.util.zip.ZipCoder zc;
+
+ {
+ zc = null;
+ }
+
+ @SuppressWarnings({"unchecked", "deprecation", "all"})
+ private static class XEntry {
+
+ public XEntry(java.util.zip.ZipEntry entry, long offset) {
+ throw new RuntimeException("Stub!");
+ }
+
+ final java.util.zip.ZipEntry entry;
+
+ {
+ entry = null;
+ }
+
+ final long offset;
+
+ {
+ offset = 0;
+ }
+ }
+}
diff --git a/ojluni/annotations/hiddenapi/javax/net/ssl/SSLServerSocketFactory.java b/ojluni/annotations/hiddenapi/javax/net/ssl/SSLServerSocketFactory.java
new file mode 100644
index 0000000..9752f65
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/javax/net/ssl/SSLServerSocketFactory.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1997, 2012, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package javax.net.ssl;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class SSLServerSocketFactory extends javax.net.ServerSocketFactory {
+
+ protected SSLServerSocketFactory() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void log(java.lang.String msg) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static synchronized javax.net.ServerSocketFactory getDefault() {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.lang.String[] getDefaultCipherSuites();
+
+ public abstract java.lang.String[] getSupportedCipherSuites();
+
+ @UnsupportedAppUsage
+ private static javax.net.ssl.SSLServerSocketFactory defaultServerSocketFactory;
+
+ private static int lastVersion = -1; // 0xffffffff
+}
diff --git a/ojluni/annotations/hiddenapi/javax/net/ssl/SSLSocketFactory.java b/ojluni/annotations/hiddenapi/javax/net/ssl/SSLSocketFactory.java
new file mode 100644
index 0000000..2e8cb3b
--- /dev/null
+++ b/ojluni/annotations/hiddenapi/javax/net/ssl/SSLSocketFactory.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1997, 2012, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package javax.net.ssl;
+
+import dalvik.annotation.compat.UnsupportedAppUsage;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public abstract class SSLSocketFactory extends javax.net.SocketFactory {
+
+ public SSLSocketFactory() {
+ throw new RuntimeException("Stub!");
+ }
+
+ private static void log(java.lang.String msg) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public static synchronized javax.net.SocketFactory getDefault() {
+ throw new RuntimeException("Stub!");
+ }
+
+ static java.lang.String getSecurityProperty(java.lang.String name) {
+ throw new RuntimeException("Stub!");
+ }
+
+ public abstract java.lang.String[] getDefaultCipherSuites();
+
+ public abstract java.lang.String[] getSupportedCipherSuites();
+
+ public abstract java.net.Socket createSocket(
+ java.net.Socket s, java.lang.String host, int port, boolean autoClose)
+ throws java.io.IOException;
+
+ @UnsupportedAppUsage
+ public java.net.Socket createSocket(
+ java.net.Socket s, java.io.InputStream consumed, boolean autoClose)
+ throws java.io.IOException {
+ throw new RuntimeException("Stub!");
+ }
+
+ static final boolean DEBUG;
+
+ static {
+ DEBUG = false;
+ }
+
+ @UnsupportedAppUsage
+ private static javax.net.ssl.SSLSocketFactory defaultSocketFactory;
+
+ private static int lastVersion = -1; // 0xffffffff
+}
diff --git a/openjdk_java_files.bp b/openjdk_java_files.bp
index 0b06102..e71016e 100644
--- a/openjdk_java_files.bp
+++ b/openjdk_java_files.bp
@@ -1805,6 +1805,12 @@
],
}
+// Classes that provide information about hidden APIs.
+filegroup {
+ name: "openjdk_hiddenapi_javadoc_files",
+ srcs: ["ojluni/annotations/hiddenapi/**/*.java"],
+}
+
// Generates stub files for the classes exposed in the public API, without
// javadoc. This can be used as a starting point for adding a new file to
// libcore/ojluni/annotations/sdk. See libcore/ojluni/annotations/README.