--- a/jdk/.hgtags Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/.hgtags Mon Apr 24 10:49:43 2017 -0700
@@ -408,3 +408,4 @@
50171f8c47961710cbf87aead6f03fa431d8d240 jdk-9+163
6dea581453d7c0e767e3169cfec8b423a381e71d jdk-9+164
a7942c3b1e59495dbf51dc7c41aab355fcd253d7 jdk-9+165
+5d2b48f1f0a322aca719b49ff02ab421705bffc7 jdk-9+166
--- a/jdk/src/java.base/share/classes/java/lang/Runtime.java Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/src/java.base/share/classes/java/lang/Runtime.java Mon Apr 24 10:49:43 2017 -0700
@@ -930,10 +930,9 @@
}
/**
- * Returns the version of the Java Runtime Environment as a {@link
- * Runtime.Version}.
+ * Returns the version of the Java Runtime Environment as a {@link Version}.
*
- * @return the {@link Runtime.Version} of the Java Runtime Environment
+ * @return the {@link Version} of the Java Runtime Environment
*
* @since 9
*/
@@ -948,7 +947,7 @@
/**
* A representation of a version string for an implementation of the
- * Java SE Platform. A version string contains a version number
+ * Java SE Platform. A version string consists of a version number
* optionally followed by pre-release and build information.
*
* <h2><a name="verNum">Version numbers</a></h2>
@@ -960,7 +959,7 @@
* </p>
*
* <blockquote><pre>
- * ^[1-9][0-9]*(((\.0)*\.[1-9][0-9]*)*)*$
+ * [1-9][0-9]*((\.0)*\.[1-9][0-9]*)*
* </pre></blockquote>
*
* <p> The sequence may be of arbitrary length but the first three
@@ -1026,10 +1025,13 @@
*
* <p> A <em>version string</em>, {@code $VSTR}, consists of a version
* number {@code $VNUM}, as described above, optionally followed by
- * pre-release and build information, in the format </p>
+ * pre-release and build information, in one of the following formats:
+ * </p>
*
* <blockquote><pre>
- * $VNUM(-$PRE)?(\+($BUILD)?(-$OPT)?)?
+ * $VNUM(-$PRE)?\+$BUILD(-$OPT)?
+ * $VNUM-$PRE(-$OPT)?
+ * $VNUM(+-$OPT)?
* </pre></blockquote>
*
* <p> where: </p>
@@ -1039,17 +1041,17 @@
* <li><p> <a name="pre">{@code $PRE}</a>, matching {@code ([a-zA-Z0-9]+)}
* --- A pre-release identifier. Typically {@code ea}, for a
* potentially unstable early-access release under active development,
- * or {@code internal}, for an internal developer build.
+ * or {@code internal}, for an internal developer build. </p></li>
*
* <li><p> <a name="build">{@code $BUILD}</a>, matching {@code
* (0|[1-9][0-9]*)} --- The build number, incremented for each promoted
* build. {@code $BUILD} is reset to {@code 1} when any portion of {@code
- * $VNUM} is incremented. </p>
+ * $VNUM} is incremented. </p></li>
*
* <li><p> <a name="opt">{@code $OPT}</a>, matching {@code
- * ([-a-zA-Z0-9\.]+)} --- Additional build information, if desired. In
+ * ([-a-zA-Z0-9.]+)} --- Additional build information, if desired. In
* the case of an {@code internal} build this will often contain the date
- * and time of the build. </p>
+ * and time of the build. </p></li>
*
* </ul>
*
@@ -1067,15 +1069,21 @@
*
* <p> A <em>short version string</em>, {@code $SVSTR}, often useful in
* less formal contexts, is a version number optionally followed by a
- * pre-release identifier:
+ * pre-release identifier:</p>
*
* <blockquote><pre>
* $VNUM(-$PRE)?
* </pre></blockquote>
*
+ * <p>This is a <a href="./doc-files/ValueBased.html">value-based</a>
+ * class; use of identity-sensitive operations (including reference equality
+ * ({@code ==}), identity hash code, or synchronization) on instances of
+ * {@code Version} may have unpredictable results and should be avoided.
+ * </p>
+ *
* @since 9
*/
- public static class Version
+ public static final class Version
implements Comparable<Version>
{
private final List<Integer> version;
@@ -1083,9 +1091,18 @@
private final Optional<Integer> build;
private final Optional<String> optional;
- Version(List<Integer> version, Optional<String> pre,
- Optional<Integer> build, Optional<String> optional) {
- this.version = Collections.unmodifiableList(version);
+ /*
+ * List of version number components passed to this constructor MUST
+ * be at least unmodifiable (ideally immutable). In the case on an
+ * unmodifiable list, the caller MUST hand the list over to this
+ * constructor and never change the underlying list.
+ */
+ private Version(List<Integer> unmodifiableListOfVersions,
+ Optional<String> pre,
+ Optional<Integer> build,
+ Optional<String> optional)
+ {
+ this.version = unmodifiableListOfVersions;
this.pre = pre;
this.build = build;
this.optional = optional;
@@ -1129,9 +1146,11 @@
+ s + "'");
// $VNUM is a dot-separated list of integers of arbitrary length
- List<Integer> version = new ArrayList<>();
- for (String i : m.group(VersionPattern.VNUM_GROUP).split("\\."))
- version.add(Integer.parseInt(i));
+ String[] split = m.group(VersionPattern.VNUM_GROUP).split("\\.");
+ Integer[] version = new Integer[split.length];
+ for (int i = 0; i < split.length; i++) {
+ version[i] = Integer.parseInt(split[i]);
+ }
Optional<String> pre = Optional.ofNullable(
m.group(VersionPattern.PRE_GROUP));
@@ -1158,7 +1177,7 @@
+ " build or optional components: '" + s + "'");
}
}
- return new Version(version, pre, build, optional);
+ return new Version(List.of(version), pre, build, optional);
}
private static boolean isSimpleNumber(String s) {
@@ -1269,9 +1288,7 @@
* During this comparison, a version with optional build information is
* considered to be greater than a version without one. </p>
*
- * <p> A version is not comparable to any other type of object.
- *
- * @param ob
+ * @param obj
* The object to be compared
*
* @return A negative integer, zero, or a positive integer if this
@@ -1282,8 +1299,8 @@
* If the given object is {@code null}
*/
@Override
- public int compareTo(Version ob) {
- return compare(ob, false);
+ public int compareTo(Version obj) {
+ return compare(obj, false);
}
/**
@@ -1294,9 +1311,10 @@
* described in {@link #compareTo(Version)} with the exception that the
* optional build information is always ignored. </p>
*
- * <p> A version is not comparable to any other type of object.
+ * <p> This method provides ordering which is consistent with
+ * {@code equalsIgnoreOptional()}. </p>
*
- * @param ob
+ * @param obj
* The object to be compared
*
* @return A negative integer, zero, or a positive integer if this
@@ -1306,47 +1324,47 @@
* @throws NullPointerException
* If the given object is {@code null}
*/
- public int compareToIgnoreOptional(Version ob) {
- return compare(ob, true);
+ public int compareToIgnoreOptional(Version obj) {
+ return compare(obj, true);
}
- private int compare(Version ob, boolean ignoreOpt) {
- if (ob == null)
- throw new NullPointerException("Invalid argument");
+ private int compare(Version obj, boolean ignoreOpt) {
+ if (obj == null)
+ throw new NullPointerException();
- int ret = compareVersion(ob);
+ int ret = compareVersion(obj);
if (ret != 0)
return ret;
- ret = comparePre(ob);
+ ret = comparePre(obj);
if (ret != 0)
return ret;
- ret = compareBuild(ob);
+ ret = compareBuild(obj);
if (ret != 0)
return ret;
if (!ignoreOpt)
- return compareOptional(ob);
+ return compareOptional(obj);
return 0;
}
- private int compareVersion(Version ob) {
+ private int compareVersion(Version obj) {
int size = version.size();
- int oSize = ob.version().size();
+ int oSize = obj.version().size();
int min = Math.min(size, oSize);
for (int i = 0; i < min; i++) {
int val = version.get(i);
- int oVal = ob.version().get(i);
+ int oVal = obj.version().get(i);
if (val != oVal)
return val - oVal;
}
return size - oSize;
}
- private int comparePre(Version ob) {
- Optional<String> oPre = ob.pre();
+ private int comparePre(Version obj) {
+ Optional<String> oPre = obj.pre();
if (!pre.isPresent()) {
if (oPre.isPresent())
return 1;
@@ -1368,8 +1386,8 @@
return 0;
}
- private int compareBuild(Version ob) {
- Optional<Integer> oBuild = ob.build();
+ private int compareBuild(Version obj) {
+ Optional<Integer> oBuild = obj.build();
if (oBuild.isPresent()) {
return (build.isPresent()
? build.get().compareTo(oBuild.get())
@@ -1380,8 +1398,8 @@
return 0;
}
- private int compareOptional(Version ob) {
- Optional<String> oOpt = ob.optional();
+ private int compareOptional(Version obj) {
+ Optional<String> oOpt = obj.optional();
if (!optional.isPresent()) {
if (oOpt.isPresent())
return -1;
@@ -1427,10 +1445,7 @@
* <p> Two {@code Version}s are equal if and only if they represent the
* same version string.
*
- * <p> This method satisfies the general contract of the {@link
- * Object#equals(Object) Object.equals} method. </p>
- *
- * @param ob
+ * @param obj
* The object to which this {@code Version} is to be compared
*
* @return {@code true} if, and only if, the given object is a {@code
@@ -1438,12 +1453,12 @@
*
*/
@Override
- public boolean equals(Object ob) {
- boolean ret = equalsIgnoreOptional(ob);
+ public boolean equals(Object obj) {
+ boolean ret = equalsIgnoreOptional(obj);
if (!ret)
return false;
- Version that = (Version)ob;
+ Version that = (Version)obj;
return (this.optional().equals(that.optional()));
}
@@ -1454,7 +1469,7 @@
* <p> Two {@code Version}s are equal if and only if they represent the
* same version string disregarding the optional build information.
*
- * @param ob
+ * @param obj
* The object to which this {@code Version} is to be compared
*
* @return {@code true} if, and only if, the given object is a {@code
@@ -1462,13 +1477,13 @@
* ignoring the optional build information
*
*/
- public boolean equalsIgnoreOptional(Object ob) {
- if (this == ob)
+ public boolean equalsIgnoreOptional(Object obj) {
+ if (this == obj)
return true;
- if (!(ob instanceof Version))
+ if (!(obj instanceof Version))
return false;
- Version that = (Version)ob;
+ Version that = (Version)obj;
return (this.version().equals(that.version())
&& this.pre().equals(that.pre())
&& this.build().equals(that.build()));
@@ -1477,9 +1492,6 @@
/**
* Returns the hash code of this version.
*
- * <p> This method satisfies the general contract of the {@link
- * Object#hashCode Object.hashCode} method.
- *
* @return The hashcode of this version
*/
@Override
@@ -1507,8 +1519,7 @@
private static final String BUILD
= "(?:(?<PLUS>\\+)(?<BUILD>0|[1-9][0-9]*)?)?";
private static final String OPT = "(?:-(?<OPT>[-a-zA-Z0-9.]+))?";
- private static final String VSTR_FORMAT
- = "^" + VNUM + PRE + BUILD + OPT + "$";
+ private static final String VSTR_FORMAT = VNUM + PRE + BUILD + OPT;
static final Pattern VSTR_PATTERN = Pattern.compile(VSTR_FORMAT);
--- a/jdk/src/java.base/share/classes/java/lang/VersionProps.java.template Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/src/java.base/share/classes/java/lang/VersionProps.java.template Mon Apr 24 10:49:43 2017 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 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
@@ -26,7 +26,7 @@
package java.lang;
import java.io.PrintStream;
-import java.util.ArrayList;
+import java.util.Arrays;
import java.util.List;
import java.util.Optional;
@@ -77,21 +77,32 @@
// This method is reflectively used by regression tests.
static List<Integer> parseVersionNumbers(String version) {
- List<Integer> verNumbers = new ArrayList<>(4);
+ // Let's find the size of an array required to hold $VNUM components
+ int size = 0;
int prevIndex = 0;
+ do {
+ prevIndex = version.indexOf('.', prevIndex) + 1;
+ size++;
+ } while (prevIndex > 0);
+ Integer[] verNumbers = new Integer[size];
+
+ // Fill in the array with $VNUM components
+ int n = 0;
+ prevIndex = 0;
int index = version.indexOf('.');
- while (index > 0) {
- verNumbers.add(parseVersionNumber(version, prevIndex, index));
+ while (index > -1) {
+ verNumbers[n] = parseVersionNumber(version, prevIndex, index);
prevIndex = index + 1; // Skip the period
index = version.indexOf('.', prevIndex);
+ n++;
}
- verNumbers.add(parseVersionNumber(version, prevIndex, version.length()));
+ verNumbers[n] = parseVersionNumber(version, prevIndex, version.length());
- if (verNumbers.get(0) == 0 || verNumbers.get(verNumbers.size() - 1) == 0)
- throw new IllegalArgumentException("Leading/trailing zeros not supported (" +
- verNumbers + ")");
+ if (verNumbers[0] == 0 || verNumbers[n] == 0)
+ throw new IllegalArgumentException("Leading/trailing zeros not allowed (" +
+ Arrays.toString(verNumbers) + ")");
- return verNumbers;
+ return List.of(verNumbers);
}
static List<Integer> versionNumbers() {
--- a/jdk/src/java.base/share/classes/java/time/chrono/HijrahChronology.java Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/src/java.base/share/classes/java/time/chrono/HijrahChronology.java Mon Apr 24 10:49:43 2017 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 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
@@ -813,8 +813,9 @@
private Properties readConfigProperties(final String calendarType) throws Exception {
String resourceName = RESOURCE_PREFIX + calendarType + RESOURCE_SUFFIX;
PrivilegedAction<InputStream> getResourceAction = () -> HijrahChronology.class.getResourceAsStream(resourceName);
- FilePermission perm = new FilePermission("<<ALL FILES>>", "read");
- try (InputStream is = AccessController.doPrivileged(getResourceAction, null, perm)) {
+ FilePermission perm1 = new FilePermission("<<ALL FILES>>", "read");
+ RuntimePermission perm2 = new RuntimePermission("accessSystemModules");
+ try (InputStream is = AccessController.doPrivileged(getResourceAction, null, perm1, perm2)) {
if (is == null) {
throw new RuntimeException("Hijrah calendar resource not found: /java/time/chrono/" + resourceName);
}
--- a/jdk/src/java.base/share/classes/java/util/Optional.java Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/src/java.base/share/classes/java/util/Optional.java Mon Apr 24 10:49:43 2017 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2012, 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 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
@@ -36,9 +36,9 @@
* {@code get()} returns the value.
*
* <p>Additional methods that depend on the presence or absence of a contained
- * value are provided, such as {@link #orElse(java.lang.Object) orElse()}
+ * value are provided, such as {@link #orElse(Object) orElse()}
* (returns a default value if no value is present) and
- * {@link #ifPresent(java.util.function.Consumer) ifPresent()} (performs an
+ * {@link #ifPresent(Consumer) ifPresent()} (performs an
* action if a value is present).
*
* <p>This is a <a href="../lang/doc-files/ValueBased.html">value-based</a>
@@ -46,6 +46,13 @@
* ({@code ==}), identity hash code, or synchronization) on instances of
* {@code Optional} may have unpredictable results and should be avoided.
*
+ * @apiNote
+ * {@code Optional} is primarily intended for use as a method return type where
+ * there is a clear need to represent "no result," and where using {@code null}
+ * is likely to cause errors. A variable whose type is {@code Optional} should
+ * never itself be {@code null}; it should always point to an {@code Optional}
+ * instance.
+ *
* @param <T> the type of value
* @since 1.8
*/
@@ -129,6 +136,12 @@
* If a value is present, returns the value, otherwise throws
* {@code NoSuchElementException}.
*
+ * @apiNote
+ * The methods {@link #orElse(Object) orElse} and
+ * {@link #orElseGet(Supplier) orElseGet}
+ * are generally preferable to this method, as they return a substitute
+ * value if the value is absent, instead of throwing an exception.
+ *
* @return the non-{@code null} value described by this {@code Optional}
* @throws NoSuchElementException if no value is present
* @see Optional#isPresent()
--- a/jdk/src/java.base/share/classes/java/util/OptionalDouble.java Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/src/java.base/share/classes/java/util/OptionalDouble.java Mon Apr 24 10:49:43 2017 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 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
@@ -37,7 +37,7 @@
* <p>Additional methods that depend on the presence or absence of a contained
* value are provided, such as {@link #orElse(double) orElse()}
* (returns a default value if no value is present) and
- * {@link #ifPresent(java.util.function.DoubleConsumer) ifPresent()} (performs
+ * {@link #ifPresent(DoubleConsumer) ifPresent()} (performs
* an action if a value is present).
*
* <p>This is a <a href="../lang/doc-files/ValueBased.html">value-based</a>
@@ -45,6 +45,12 @@
* ({@code ==}), identity hash code, or synchronization) on instances of
* {@code OptionalDouble} may have unpredictable results and should be avoided.
*
+ * @apiNote
+ * {@code OptionalDouble} is primarily intended for use as a method return type where
+ * there is a clear need to represent "no result." A variable whose type is
+ * {@code OptionalDouble} should never itself be {@code null}; it should always point
+ * to an {@code OptionalDouble} instance.
+ *
* @since 1.8
*/
public final class OptionalDouble {
@@ -110,6 +116,12 @@
* If a value is present, returns the value, otherwise throws
* {@code NoSuchElementException}.
*
+ * @apiNote
+ * The methods {@link #orElse(double) orElse} and
+ * {@link #orElseGet(DoubleSupplier) orElseGet}
+ * are generally preferable to this method, as they return a substitute
+ * value if the value is absent, instead of throwing an exception.
+ *
* @return the value described by this {@code OptionalDouble}
* @throws NoSuchElementException if no value is present
* @see OptionalDouble#isPresent()
--- a/jdk/src/java.base/share/classes/java/util/OptionalInt.java Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/src/java.base/share/classes/java/util/OptionalInt.java Mon Apr 24 10:49:43 2017 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 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
@@ -37,7 +37,7 @@
* <p>Additional methods that depend on the presence or absence of a contained
* value are provided, such as {@link #orElse(int) orElse()}
* (returns a default value if no value is present) and
- * {@link #ifPresent(java.util.function.IntConsumer) ifPresent()} (performs an
+ * {@link #ifPresent(IntConsumer) ifPresent()} (performs an
* action if a value is present).
*
* <p>This is a <a href="../lang/doc-files/ValueBased.html">value-based</a>
@@ -45,6 +45,12 @@
* ({@code ==}), identity hash code, or synchronization) on instances of
* {@code OptionalInt} may have unpredictable results and should be avoided.
*
+ * @apiNote
+ * {@code OptionalInt} is primarily intended for use as a method return type where
+ * there is a clear need to represent "no result." A variable whose type is
+ * {@code OptionalInt} should never itself be {@code null}; it should always point
+ * to an {@code OptionalInt} instance.
+ *
* @since 1.8
*/
public final class OptionalInt {
@@ -110,6 +116,12 @@
* If a value is present, returns the value, otherwise throws
* {@code NoSuchElementException}.
*
+ * @apiNote
+ * The methods {@link #orElse(int) orElse} and
+ * {@link #orElseGet(IntSupplier) orElseGet}
+ * are generally preferable to this method, as they return a substitute
+ * value if the value is absent, instead of throwing an exception.
+ *
* @return the value described by this {@code OptionalInt}
* @throws NoSuchElementException if no value is present
* @see OptionalInt#isPresent()
--- a/jdk/src/java.base/share/classes/java/util/OptionalLong.java Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/src/java.base/share/classes/java/util/OptionalLong.java Mon Apr 24 10:49:43 2017 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 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
@@ -37,7 +37,7 @@
* <p>Additional methods that depend on the presence or absence of a contained
* value are provided, such as {@link #orElse(long) orElse()}
* (returns a default value if no value is present) and
- * {@link #ifPresent(java.util.function.LongConsumer) ifPresent()} (performs an
+ * {@link #ifPresent(LongConsumer) ifPresent()} (performs an
* action if a value is present).
*
* <p>This is a <a href="../lang/doc-files/ValueBased.html">value-based</a>
@@ -45,6 +45,12 @@
* ({@code ==}), identity hash code, or synchronization) on instances of
* {@code OptionalLong} may have unpredictable results and should be avoided.
*
+ * @apiNote
+ * {@code OptionalLong} is primarily intended for use as a method return type where
+ * there is a clear need to represent "no result." A variable whose type is
+ * {@code OptionalLong} should never itself be {@code null}; it should always point
+ * to an {@code OptionalLong} instance.
+ *
* @since 1.8
*/
public final class OptionalLong {
@@ -110,6 +116,12 @@
* If a value is present, returns the value, otherwise throws
* {@code NoSuchElementException}.
*
+ * @apiNote
+ * The methods {@link #orElse(long) orElse} and
+ * {@link #orElseGet(LongSupplier) orElseGet}
+ * are generally preferable to this method, as they return a substitute
+ * value if the value is absent, instead of throwing an exception.
+ *
* @return the value described by this {@code OptionalLong}
* @throws NoSuchElementException if no value is present
* @see OptionalLong#isPresent()
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.base/share/specs/serialization/changelog.md Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,181 @@
+---
+# Copyright (c) 2005, 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.
+#
+# 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.
+
+include-before: '[CONTENTS](index.html) | [PREV](index.html) | [NEXT](serial-arch.html)'
+include-after: '[CONTENTS](index.html) | [PREV](index.html) | [NEXT](serial-arch.html)'
+
+title: 'Java Object Serialization Specification: 0 - Change History'
+---
+
+-------------------------------------------------------------------------------
+
+May 12, 2005 Updates for Java^TM^ SE Development Kit, v6 Beta 1
+
+- Added statement about how an array object returned by a `readResolve`
+ invocation for an unshared read is handled.
+- Clarified the behavior in the event of an invalid `serialPersistentFields`
+ value.
+- Clarified that `serialVersionUID` matching is waived for array classes.
+- Clarified when `IllegalArgumentException` is thrown by
+ `ObjectOutputStream.PutFields` methods.
+
+July 24, 2003 Updates for Java^TM^ 2 SDK, Standard Edition, v1.5 Beta 1
+
+- Added support for serializing enum constants.
+- Added specification of class modifier flags used in the computation of
+ default `serialVersionUID` values to [Section 4.6, "Stream Unique
+ Identifiers"](class.html#stream-unique-identifiers).
+
+Aug. 16, 2001 Updates for Java^TM^ 2 SDK, Standard Edition, v1.4 Beta 2
+
+- Added support for class-defined `readObjectNoData` methods, to be used for
+ initializing serializable class fields in cases not covered by
+ class-defined readObject methods. See [Section 3.5, "The readObjectNoData
+ Method"](input.html#the-readobjectnodata-method), as well as Appendix A,
+ "Security in Object Serialization".
+- New methods `ObjectOutputStream.writeUnshared` and
+ `ObjectInputStream.readUnshared` provide a mechanism for ensuring unique
+ references to deserialized objects. See [Section 2.1, "The
+ ObjectOutputStream Class"](output.html#the-objectoutputstream-class),
+ [Section 3.1, "The ObjectInputStream
+ Class"](input.html#the-objectinputstream-class), as well as Appendix A,
+ "Security in Object Serialization".
+- Documented new security checks in the one-argument constructors for
+ `ObjectOutputStream` and `ObjectInputStream`. See [Section 2.1, "The
+ ObjectOutputStream Class"](output.html#the-objectoutputstream-class) and
+ [Section 3.1, "The ObjectInputStream
+ Class"](input.html#the-objectinputstream-class).
+- Added caution against using inner classes for serialization in [Section
+ 1.10, "The Serializable
+ Interface"](serial-arch.html#the-serializable-interface).
+- Clarified requirement that class-defined `writeObject` methods invoke
+ `ObjectOutputStream.defaultWriteObject` or `writeFields` once before
+ writing optional data, and that class-defined `readObject` methods invoke
+ `ObjectInputStream.defaultReadObject` or `readFields` once before reading
+ optional data. See [Section 2.3, "The writeObject
+ Method"](output.html#the-writeobject-method) and [Section 3.4, "The
+ readObject Method"](input.html#the-readobject-method).
+- Clarified the behavior of `ObjectInputStream` when class-defined
+ `readObject` or `readExternal` methods attempt read operations which exceed
+ the bounds of available data; see [Section 3.4, "The readObject
+ Method"](input.html#the-readobject-method) and [Section 3.6, "The
+ readExternal Method"](input.html#the-readexternal-method).
+- Clarified the description of non-proxy class descriptor field type strings
+ to require that they be written in "field descriptor" format; see [Section
+ 6.2, "Stream Elements"](protocol.html#stream-elements).
+
+July 30, 1999 Updates for Java^TM^ 2 SDK, Standard Edition, v1.3 Beta
+
+- Added the ability to write `String` objects for which the UTF encoding is
+ longer than 65535 bytes in length. See [Section 6.2, "Stream
+ Elements"](protocol.html#stream-elements).
+- New methods `ObjectOutputStream.writeClassDescriptor` and
+ `ObjectInputStream.readClassDescriptor` provide a means of customizing the
+ serialized representation of `ObjectStreamClass` class descriptors. See
+ [Section 2.1, "The ObjectOutputStream
+ Class"](output.html#the-objectoutputstream-class) and [Section 3.1, "The
+ ObjectInputStream Class"](input.html#the-objectinputstream-class).
+- Expanded Appendix A, "[Security in Object
+ Serialization"](security.html#security-in-object-serialization).
+
+Sept. 30, 1998 Updates for JDK^TM^ 1.2 Beta4 RC1
+
+- Documentation corrections only.
+
+June 22, 1998 Updates for JDK^TM^ 1.2 Beta4
+
+- Eliminated JDK^TM^ 1.2 `java.io` interfaces, `Replaceable` and
+ `Resolvable`.References to either of these classes as an interface should
+ be replaced with `java.io.Serializable`. Serialization will use reflection
+ to invoke the methods, `writeReplace` and `readResolve`, if the
+ Serializable class defines these methods. See [Section 2.5, "The
+ writeReplace Method"](output.html#the-writereplace-method) and [Section
+ 3.7, "The readResolve Method"](input.html#the-readresolve-method).
+- New javadoc tags *@serial*, *@serialField*, and *@serialData* provide a way
+ to document the Serialized Form of a Serializable class. Javadoc generates
+ a serialization specification based on the contents of these tags. See
+ [Section 1.6, "Documenting Serializable Fields and Data for a
+ Class"](serial-arch.html#documenting-serializable-fields-and-data-for-a-class).
+- Special Serializable class member, `serialPersistentFields`, must be
+ declared private. See [Section 1.5, "Defining Serializable Fields for a
+ Class"](serial-arch.html#defining-serializable-fields-for-a-class).
+- Clarified the steps involved in computing the `serialVersionUID` in
+ [Section 4.6, "Stream Unique
+ Identifiers"](class.html#stream-unique-identifiers).
+
+Feb. 6, 1998 Updates for JDK^TM^ 1.2 Beta 3
+
+- Introduced the concept of `STREAM_PROTOCOL` versions. Added the
+ `STREAM_PROTOCOL_2` version to indicate a new format for `Externalizable`
+ objects that enable skipping by an `Externalizable` object within the
+ stream, even when the object's class is not available in the local Virtual
+ Machine. Compatibility issues are discussed in [Section 6.3, "Stream
+ Protocol Versions"](protocol.html#stream-protocol-versions).
+- `The ObjectInputStream.resolveClass` method can return a local class in a
+ different package than the name of the class within the stream. This
+ capability enables renaming of packages between releases. The
+ `serialVersionUID` and the base class name must be the same in the stream
+ and in the local version of the class. See [Section 3.1, "The
+ ObjectInputStream Class"](input.html#the-objectinputstream-class).
+- Allow substitution of `String` or `array` objects when writing them to or
+ reading them from the stream. See [Section 2.1, "The ObjectOutputStream
+ Class"](output.html#the-objectoutputstream-class) and [Section 3.1, "The
+ ObjectInputStream Class"](input.html#the-objectinputstream-class).
+
+Sept. 4, 1997 Updates for JDK^TM^ 1.2 Beta1
+
+- Separated the Replaceable interface into two interfaces: Replaceable and
+ Resolvable. The Replaceable interface allows a class to nominate its own
+ replacement just before serializing the object to the stream. The
+ Resolvable interface allows a class to nominate its own replacement when
+ reading an object from the stream.
+- Modified serialization to use the JDK^TM^ 1.2 security model. There is a
+ check for `SerializablePermission "enableSubstitution"` within the
+ `ObjectInputStream.enableReplace` and `ObjectOutputStream.enableResolve`
+ methods. See [Section 2.1, "The ObjectOutputStream
+ Class"](output.html#the-objectoutputstream-class) and [Section 3.1, "The
+ ObjectInputStream Class"](input.html#the-objectinputstream-class).
+- Updated `writeObject`'s exception handler to write handled `IOException`s
+ into the stream. See [Section 2.1, "The ObjectOutputStream
+ Class"](output.html#the-objectoutputstream-class).
+
+July 3, 1997 Updates for JDK^TM^ 1.2 Alpha
+
+- Documented the requirements for specifying the serialized state of classes.
+ See [Section 1.5, "Defining Serializable Fields for a
+ Class"](serial-arch.html#defining-serializable-fields-for-a-class).
+- Added the Serializable Fields API to allow classes more flexibility in
+ accessing the serialized fields of a class. The stream protocol is
+ unchanged. See [Section 1.7, "Accessing Serializable Fields of a
+ Class](serial-arch.html#accessing-serializable-fields-of-a-class),"
+ [Section 2.2, "The ObjectOutputStream.PutField
+ Class](output.html#the-objectoutputstream.putfield-class)," and [Section
+ 3.2, "The ObjectInputStream.GetField
+ Class"](input.html#the-objectinputstream.getfield-class).
+- Clarified that field descriptors and data are written to and read from the
+ stream in canonical order. See [Section 4.1, "The ObjectStreamClass
+ Class"](class.html#the-objectstreamclass-class).
+
+-------------------------------------------------------------------------------
+
+*[Copyright](../../../legal/SMICopyright.html) © 2005, 2017, Oracle
+and/or its affiliates. All rights reserved.*
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.base/share/specs/serialization/class.md Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,368 @@
+---
+# Copyright (c) 2005, 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.
+#
+# 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.
+
+include-before: '[CONTENTS](index.html) | [PREV](input.html) | [NEXT](version.html)'
+include-after: '[CONTENTS](index.html) | [PREV](input.html) | [NEXT](version.html)'
+
+title: 'Java Object Serialization Specification: 4 - Class Descriptors'
+---
+
+- [The ObjectStreamClass Class](#the-objectstreamclass-class)
+- [Dynamic Proxy Class Descriptors](#dynamic-proxy-class-descriptors)
+- [Serialized Form](#serialized-form)
+- [The ObjectStreamField Class](#the-objectstreamfield-class)
+- [Inspecting Serializable Classes](#inspecting-serializable-classes)
+- [Stream Unique Identifiers](#stream-unique-identifiers)
+
+-------------------------------------------------------------------------------
+
+## 4.1 The ObjectStreamClass Class
+
+The `ObjectStreamClass` provides information about classes that are saved in a
+Serialization stream. The descriptor provides the fully-qualified name of the
+class and its serialization version UID. A `SerialVersionUID` identifies the
+unique original class version for which this class is capable of writing
+streams and from which it can read.
+
+```
+package java.io;
+
+public class ObjectStreamClass
+{
+ public static ObjectStreamClass lookup(Class cl);
+
+ public static ObjectStreamClass lookupAny(Class cl);
+
+ public String getName();
+
+ public Class forClass();
+
+ public ObjectStreamField[] getFields();
+
+ public long getSerialVersionUID();
+
+ public String toString();
+}
+```
+
+The `lookup` method returns the `ObjectStreamClass` descriptor for the
+specified class in the virtual machine. If the class has defined
+`serialVersionUID` it is retrieved from the class. If the `serialVersionUID` is
+not defined by the class, it is computed from the definition of the class in
+the virtual machine. *I*f the specified class is not serializable or
+externalizable, *null* is returned.
+
+The `lookupAny` method behaves like the `lookup` method, except that it returns
+the descriptor for any class, regardless of whether it implements
+`Serializable`. The `serialVersionUID` of a class that does not implement
+`Serializable` is *0L.*
+
+The `getName` method returns the name of the class, in the same format that is
+used by the `Class.getName` method.
+
+The `forClass` method returns the `Class` in the local virtual machine if one
+was found by `ObjectInputStream.resolveClass` method. Otherwise, it returns
+*null*.
+
+The `getFields` method returns an array of `ObjectStreamField` objects that
+represent the serializable fields of this class.
+
+The `getSerialVersionUID` method returns the `serialVersionUID` of this class.
+Refer to [Section 4.6, "Stream Unique
+Identifiers"](#stream-unique-identifiers). If not specified by the class, the
+value returned is a hash computed from the class's name, interfaces, methods,
+and fields using the Secure Hash Algorithm (SHA) as defined by the National
+Institute of Standards.
+
+The `toString` method returns a printable representation of the class
+descriptor including the name of the class and the `serialVersionUID`.
+
+## 4.2 Dynamic Proxy Class Descriptors
+
+ObjectStreamClass descriptors are also used to provide information about
+dynamic proxy classes (e.g., classes obtained via calls to the getProxyClass
+method of java.lang.reflect.Proxy) saved in a serialization stream. A dynamic
+proxy class itself has no serializable fields and a serialVersionUID of 0L. In
+other words, when the Class object for a dynamic proxy class is passed to the
+static lookup method of ObjectStreamClass, the returned ObjectStreamClass
+instance will have the following properties:
+
+- Invoking its getSerialVersionUID method will return 0L.
+- Invoking its getFields method will return an array of length zero.
+- Invoking its getField method with any String argument will return null.
+
+## 4.3 Serialized Form
+
+The serialized form of an ObjectStreamClass instance depends on whether or not
+the Class object it represents is serializable, externalizable, or a dynamic
+proxy class.
+
+When an `ObjectStreamClass` instance that does not represent a dynamic proxy
+class is written to the stream, it writes the class name and
+`serialVersionUID`, flags, and the number of fields. Depending on the class,
+additional information may be written:
+
+- For non-serializable classes, the number of fields is always zero. Neither
+ the `SC_SERIALIZABLE` nor the `SC_EXTERNALIZABLE` flag bits are set.
+
+- For serializable classes, the `SC_SERIALIZABLE` flag is set, the number of
+ fields counts the number of serializable fields and is followed by a
+ descriptor for each serializable field. The descriptors are written in
+ canonical order. The descriptors for primitive typed fields are written
+ first sorted by field name followed by descriptors for the object typed
+ fields sorted by field name. The names are sorted using `String.compareTo`.
+ For details of the format, refer to [Section 6.4, "Grammar for the Stream
+ Format"](protocol.html#grammar-for-the-stream-format).
+
+- For externalizable classes, flags includes the `SC_EXTERNALIZABLE` flag,
+ and the number of fields is always zero.
+
+- For enum types, flags includes the `SC_ENUM` flag, and the number of fields
+ is always zero.
+
+When an ObjectOutputStream serializes the ObjectStreamClass descriptor for a
+dynamic proxy class, as determined by passing its Class object to the
+isProxyClass method of java.lang.reflect.Proxy, it writes the number of
+interfaces that the dynamic proxy class implements, followed by the interface
+names. Interfaces are listed in the order that they are returned by invoking
+the getInterfaces method on the Class object of the dynamic proxy class.
+
+The serialized representations of ObjectStreamClass descriptors for dynamic
+proxy classes and non-dynamic proxy classes are differentiated through the use
+of different typecodes (`TC_PROXYCLASSDESC` and `TC_CLASSDESC`, respectively);
+for a more detailed specification of the grammar, see [Section 6.4, "Grammar
+for the Stream Format"](protocol.html#grammar-for-the-stream-format).
+
+## 4.4 The ObjectStreamField Class
+
+An `ObjectStreamField` represents a serializable field of a serializable class.
+The serializable fields of a class can be retrieved from the
+`ObjectStreamClass`.
+
+The special static serializable field, `serialPersistentFields`, is an array of
+`ObjectStreamField` components that is used to override the default
+serializable fields.
+
+```
+package java.io;
+
+public class ObjectStreamField implements Comparable {
+
+ public ObjectStreamField(String fieldName,
+ Class fieldType);
+
+ public ObjectStreamField(String fieldName,
+ Class fieldType,
+ boolean unshared);
+
+ public String getName();
+
+ public Class getType();
+
+ public String getTypeString();
+
+ public char getTypeCode();
+
+ public boolean isPrimitive();
+
+ public boolean isUnshared();
+
+ public int getOffset();
+
+ protected void setOffset(int offset);
+
+ public int compareTo(Object obj);
+
+ public String toString();
+}
+```
+
+`ObjectStreamField` objects are used to specify the serializable fields of a
+class or to describe the fields present in a stream. Its constructors accept
+arguments describing the field to represent: a string specifying the name of
+the field, a `Class` object specifying the type of the field, and a `boolean`
+flag (implicitly `false` for the two-argument constructor) indicating whether
+or not values of the represented field should be read and written as "unshared"
+objects if default serialization/deserialization is in use (see the
+descriptions of the `ObjectInputStream.readUnshared` and
+`ObjectOutputStream.writeUnshared` methods in [Section 3.1, "The
+ObjectInputStream Class"](input.html#the-objectinputstream-class) and [Section
+2.1, "The ObjectOutputStream Class"](output.html#the-objectoutputstream-class),
+respectively).
+
+The `getName` method returns the name of the serializable field.
+
+The `getType` method returns the type of the field.
+
+The `getTypeString` method returns the type signature of the field.
+
+The `getTypeCode` method returns a character encoding of the field type ('`B`'
+for `byte`, '`C`' for `char`, '`D`' for `double`, '`F`' for `float`, '`I`' for
+`int`, '`J`' for `long`, '`L`' for non-array object types, '`S`' for `short`,
+'`Z`' for `boolean`, and '`[`' for arrays).
+
+The `isPrimitive` method returns `true` if the field is of primitive type, or
+`false` otherwise.
+
+The `isUnshared` method returns `true` if values of the field should be written
+as "unshared" objects, or `false` otherwise.
+
+The `getOffset` method returns the offset of the field's value within instance
+data of the class defining the field.
+
+The `setOffset` method allows `ObjectStreamField` subclasses to modify the
+offset value returned by the `getOffset` method.
+
+The `compareTo` method compares `ObjectStreamFields` for use in sorting.
+Primitive fields are ranked as "smaller" than non-primitive fields; fields
+otherwise equal are ranked alphabetically.
+
+The `toString` method returns a printable representation with name and type.
+
+## 4.5 Inspecting Serializable Classes
+
+The program *serialver* can be used to find out if a class is serializable and
+to get its `serialVersionUID`. When invoked with the-show option, it puts up a
+simple user interface. To find out if a class is serializable and to find out
+its *serialVersionUID*`,` enter its full class name, then press either the
+Enter or the Show button. The string printed can be copied and pasted into the
+evolved class.
+
+> 
+
+When invoked on the command line with one or more class names, serialver prints
+the `serialVersionUID` for each class in a form suitable for copying into an
+evolving class. When invoked with no arguments, it prints a usage line.
+
+## 4.6 Stream Unique Identifiers
+
+Each versioned class must identify the original class version for which it is
+capable of writing streams and from which it can read. For example, a versioned
+class must declare:
+
+```
+private static final long serialVersionUID = 3487495895819393L;
+```
+
+The stream-unique identifier is a 64-bit hash of the class name, interface
+class names, methods, and fields. The value must be declared in all versions of
+a class except the first. It may be declared in the original class but is not
+required. The value is fixed for all compatible classes. If the SUID is not
+declared for a class, the value defaults to the hash for that class. The
+`serialVersionUID` for dynamic proxy classes and enum types always have the
+value *0L*. Array classes cannot declare an explicit `serialVersionUID`, so
+they always have the default computed value, but the requirement for matching
+`serialVersionUID` values is waived for array classes.
+
+**Note:** It is strongly recommended that all serializable classes explicitly
+declare `serialVersionUID` values, since the default `serialVersionUID`
+computation is highly sensitive to class details that may vary depending on
+compiler implementations, and can thus result in unexpected `serialVersionUID`
+conflicts during deserialization, causing deserialization to fail.
+
+The initial version of an `Externalizable` class must output a stream data
+format that is extensible in the future. The initial version of the method
+`readExternal` has to be able to read the output format of all future versions
+of the method `writeExternal`.
+
+The `serialVersionUID` is computed using the signature of a stream of bytes
+that reflect the class definition. The National Institute of Standards and
+Technology (NIST) Secure Hash Algorithm (SHA-1) is used to compute a signature
+for the stream. The first two 32-bit quantities are used to form a 64-bit hash.
+A `java.lang.DataOutputStream` is used to convert primitive data types to a
+sequence of bytes. The values input to the stream are defined by the Java
+Virtual Machine (VM) specification for classes. Class modifiers may include the
+`ACC_PUBLIC`, `ACC_FINAL`, `ACC_INTERFACE`, and `ACC_ABSTRACT` flags; other
+flags are ignored and do not affect `serialVersionUID` computation. Similarly,
+for field modifiers, only the `ACC_PUBLIC`, `ACC_PRIVATE`, `ACC_PROTECTED`,
+`ACC_STATIC`, `ACC_FINAL`, `ACC_VOLATILE`, and `ACC_TRANSIENT` flags are used
+when computing `serialVersionUID` values. For constructor and method modifiers,
+only the `ACC_PUBLIC`, `ACC_PRIVATE`, `ACC_PROTECTED`, `ACC_STATIC`,
+`ACC_FINAL`, `ACC_SYNCHRONIZED`, `ACC_NATIVE`, `ACC_ABSTRACT` and `ACC_STRICT`
+flags are used. Names and descriptors are written in the format used by the
+`java.io.DataOutputStream.writeUTF` method.
+
+The sequence of items in the stream is as follows:
+
+1. The class name.
+
+2. The class modifiers written as a 32-bit integer.
+
+3. The name of each interface sorted by name.
+
+4. For each field of the class sorted by field name (except `private static`
+ and `private transient` fields:
+
+ a. The name of the field.
+
+ b. The modifiers of the field written as a 32-bit integer.
+
+ c. The descriptor of the field.
+
+5. If a class initializer exists, write out the following:
+
+ a. The name of the method, `<clinit>`.
+
+ b. The modifier of the method, `java.lang.reflect.Modifier.STATIC`,
+ written as a 32-bit integer.
+
+ c. The descriptor of the method, `()V`.
+
+6. For each non-`private` constructor sorted by method name and signature:
+
+ a. The name of the method, `<init>`.
+
+ b. The modifiers of the method written as a 32-bit integer.
+
+ c. The descriptor of the method.
+
+7. For each non-`private` method sorted by method name and signature:
+
+ a. The name of the method.
+
+ b. The modifiers of the method written as a 32-bit integer.
+
+ c. The descriptor of the method.
+
+8. The SHA-1 algorithm is executed on the stream of bytes produced by
+ `DataOutputStream` and produces five 32-bit values `sha[0..4]`.
+
+9. The hash value is assembled from the first and second 32-bit values of the
+ SHA-1 message digest. If the result of the message digest, the five 32-bit
+ words `H0 H1 H2 H3 H4`, is in an array of five `int` values named `sha`,
+ the hash value would be computed as follows:
+
+```
+ long hash = ((sha[0] >>> 24) & 0xFF) |
+ ((sha[0] >>> 16) & 0xFF) << 8 |
+ ((sha[0] >>> 8) & 0xFF) << 16 |
+ ((sha[0] >>> 0) & 0xFF) << 24 |
+ ((sha[1] >>> 24) & 0xFF) << 32 |
+ ((sha[1] >>> 16) & 0xFF) << 40 |
+ ((sha[1] >>> 8) & 0xFF) << 48 |
+ ((sha[1] >>> 0) & 0xFF) << 56;
+```
+
+-------------------------------------------------------------------------------
+
+*[Copyright](../../../legal/SMICopyright.html) © 2005, 2017, Oracle
+and/or its affiliates. All rights reserved.*
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.base/share/specs/serialization/examples.md Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,111 @@
+---
+# Copyright (c) 2005, 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.
+#
+# 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.
+
+include-before: '[CONTENTS](index.html) | [PREV](exceptions.html) | NEXT'
+include-after: '[CONTENTS](index.html) | [PREV](exceptions.html) | NEXT'
+
+title: 'Java Object Serialization Specification: C - Example of Serializable Fields'
+---
+
+- [Example Alternate Implementation of
+ java.io.File](#c.1-example-alternate-implementation-of-java.io.file)
+
+-------------------------------------------------------------------------------
+
+## C.1 Example Alternate Implementation of java.io.File
+
+This appendix provides a brief example of how an existing class could be
+specified and implemented to interoperate with the existing implementation but
+without requiring the same assumptions about the representation of the file
+name as a *String*.
+
+The system class `java.io.File` represents a filename and has methods for
+parsing, manipulating files and directories by name. It has a single private
+field that contains the current file name. The semantics of the methods that
+parse paths depend on the current path separator which is held in a static
+field. This path separator is part of the serialized state of a file so that
+file name can be adjusted when read.
+
+The serialized state of a `File` object is defined as the serializable fields
+and the sequence of data values for the file. In this case, there is one of
+each.
+
+```
+Serializable Fields:
+ String path; // path name with embedded separators
+Serializable Data:
+ char // path name separator for path name
+```
+
+An alternate implementation might be defined as follows:
+
+```
+class File implements java.io.Serializable {
+ ...
+ private String[] pathcomponents;
+ // Define serializable fields with the ObjectStreamClass
+
+ /**
+ * @serialField path String
+ * Path components separated by separator.
+ */
+
+ private static final ObjectStreamField[] serialPersistentFields
+ = { new ObjectStreamField("path", String.class) };
+ ...
+ /**
+ * @serialData Default fields followed by separator character.
+ */
+
+ private void writeObject(ObjectOutputStream s)
+ throws IOException
+ {
+ ObjectOutputStream.PutField fields = s.putFields();
+ StringBuffer str = new StringBuffer();
+ for(int i = 0; i < pathcomponents; i++) {
+ str.append(separator);
+ str.append(pathcomponents[i]);
+ }
+ fields.put("path", str.toString());
+ s.writeFields();
+ s.writeChar(separatorChar); // Add the separator character
+ }
+ ...
+
+ private void readObject(ObjectInputStream s)
+ throws IOException
+ {
+ ObjectInputStream.GetField fields = s.readFields();
+ String path = (String)fields.get("path", null);
+ ...
+ char sep = s.readChar(); // read the previous separator char
+
+ // parse path into components using the separator
+ // and store into pathcomponents array.
+ }
+}
+```
+
+-------------------------------------------------------------------------------
+
+*[Copyright](../../../legal/SMICopyright.html) © 2005, 2017, Oracle
+and/or its affiliates. All rights reserved.*
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.base/share/specs/serialization/exceptions.md Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,97 @@
+---
+# Copyright (c) 2005, 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.
+#
+# 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.
+
+include-before: '[CONTENTS](index.html) | [PREV](security.html) | [NEXT](examples.html)'
+include-after: '[CONTENTS](index.html) | [PREV](security.html) | [NEXT](examples.html)'
+
+title: 'Java Object Serialization Specification: B - Exceptions In Object Serialization'
+---
+
+-------------------------------------------------------------------------------
+
+All exceptions thrown by serialization classes are subclasses of
+`ObjectStreamException` which is a subclass of `IOException`.
+
+### `ObjectStreamException`
+
+Superclass of all serialization exceptions.
+
+### `InvalidClassException`
+
+Thrown when a class cannot be used to restore objects for any of these reasons:
+
+- The class does not match the serial version of the class in the stream.
+- The class contains fields with invalid primitive data types.
+- The `Externalizable` class does not have a public no-arg constructor.
+- The `Serializable` class can not access the no-arg constructor of its
+ closest non-Serializable superclass.
+
+### `NotSerializableException`
+
+Thrown by a `readObject` or `writeObject` method to terminate serialization or
+deserialization.
+
+### `StreamCorruptedException`
+
+Thrown:
+
+- If the stream header is invalid.
+- If control information not found.
+- If control information is invalid.
+- JDK 1.1.5 or less attempts to call `readExternal` on a `PROTOCOL_VERSION_2`
+ stream.
+
+### `NotActiveException`
+
+Thrown if `writeObject` state is invalid within the following
+`ObjectOutputStream` methods:
+
+- `defaultWriteObject`
+- `putFields`
+- `writeFields`
+
+Thrown if `readObject` state is invalid within the following
+`ObjectInputStream` methods:
+
+- `defaultReadObject`
+- `readFields`
+- `registerValidation`
+
+### `InvalidObjectException`
+
+Thrown when a restored object cannot be made valid.
+
+### `OptionalDataException`
+
+Thrown by `readObject` when there is primitive data in the stream and an object
+is expected. The length field of the exception indicates the number of bytes
+that are available in the current block.
+
+### `WriteAbortedException`
+
+Thrown when reading a stream terminated by an exception that occurred while the
+stream was being written.
+
+-------------------------------------------------------------------------------
+
+*[Copyright](../../../legal/SMICopyright.html) © 2005, 2017, Oracle
+and/or its affiliates. All rights reserved.*
Binary file jdk/src/java.base/share/specs/serialization/images/class.gif has changed
Binary file jdk/src/java.base/share/specs/serialization/images/version.gif has changed
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.base/share/specs/serialization/index.md Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,134 @@
+---
+# Copyright (c) 2005, 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.
+#
+# 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.
+
+include-before: 'CONTENTS | PREV | [NEXT](changelog.html)'
+include-after: 'CONTENTS | PREV | [NEXT](changelog.html)'
+
+title: 'Java Object Serialization Specification: Contents'
+---
+
+-------------------------------------------------------------------------------
+
+## Table of Contents
+
+### 0 [Change History](changelog.html)
+
+### 1 [System Architecture](serial-arch.html)
+
+- 1.1 [Overview](serial-arch.html#overview)
+- 1.2 [Writing to an Object
+ Stream](serial-arch.html#writing-to-an-object-stream)
+- 1.3 [Reading from an Object
+ Stream](serial-arch.html#reading-from-an-object-stream)
+- 1.4 [Object Streams as
+ Containers](serial-arch.html#object-streams-as-containers)
+- 1.5 [Defining Serializable Fields for a
+ Class](serial-arch.html#defining-serializable-fields-for-a-class)
+- 1.6 [Documenting Serializable Fields and Data for a
+ Class](serial-arch.html#documenting-serializable-fields-and-data-for-a-class)
+- 1.7 [Accessing Serializable Fields of a
+ Class](serial-arch.html#accessing-serializable-fields-of-a-class)
+- 1.8 [The ObjectOutput
+ Interface](serial-arch.html#the-objectoutput-interface)
+- 1.9 [The ObjectInput Interface](serial-arch.html#the-objectinput-interface)
+- 1.10 [The Serializable
+ Interface](serial-arch.html#the-serializable-interface)
+- 1.11 [The Externalizable
+ Interface](serial-arch.html#the-externalizable-interface)
+- 1.12 [Serialization of Enum
+ Constants](serial-arch.html#serialization-of-enum-constants)
+- 1.13 [Protecting Sensitive
+ Information](serial-arch.html#protecting-sensitive-information)
+
+### 2 [Object Output Classes](output.html)
+
+- 2.1 [The ObjectOutputStream
+ Class](output.html#the-objectoutputstream-class)
+- 2.2 [The ObjectOutputStream.PutField
+ Class](output.html#the-objectoutputstream.putfield-class)
+- 2.3 [The writeObject Method](output.html#the-writeobject-method)
+- 2.4 [The writeExternal Method](output.html#the-writeexternal-method)
+- 2.5 [The writeReplace Method](output.html#the-writereplace-method)
+- 2.6 [The useProtocolVersion
+ Method](output.html#the-useprotocolversion-method)
+
+### 3 [Object Input Classes](input.html)
+
+- 3.1 [The ObjectInputStream Class](input.html#the-objectinputstream-class)
+- 3.2 [The ObjectInputStream.GetField
+ Class](input.html#the-objectinputstream.getfield-class)
+- 3.3 [The ObjectInputValidation
+ Interface](input.html#the-objectinputvalidation-interface)
+- 3.4 [The readObject Method](input.html#the-readobject-method)
+- 3.5 [The readObjectNoData Method](input.html#the-readobjectnodata-method)
+- 3.6 [The readExternal Method](input.html#the-readexternal-method)
+- 3.7 [The readResolve Method](input.html#the-readresolve-method)
+
+### 4 [Class Descriptors](class.html)
+
+- 4.1 [The ObjectStreamClass Class](class.html#the-objectstreamclass-class)
+- 4.2 [Dynamic Proxy Class
+ Descriptors](class.html#dynamic-proxy-class-descriptors)
+- 4.3 [Serialized Form](class.html#serialized-form)
+- 4.4 [The ObjectStreamField Class](class.html#the-objectstreamfield-class)
+- 4.5 [Inspecting Serializable
+ Classes](class.html#inspecting-serializable-classes)
+- 4.6 [Stream Unique Identifiers](class.html#stream-unique-identifiers)
+
+### 5 [Versioning of Serializable Objects](version.html)
+
+- 5.1 [Overview](version.html#overview)
+- 5.2 [Goals](version.html#goals)
+- 5.3 [Assumptions](version.html#assumptions)
+- 5.4 [Who's Responsible for Versioning of
+ Streams](version.html#whos-responsible-for-versioning-of-streams)
+- 5.5 [Compatible Java Type
+ Evolution](version.html#compatible-java-type-evolution)
+- 5.6 [Type Changes Affecting
+ Serialization](version.html#type-changes-affecting-serialization)
+ - 5.6.1 [Incompatible Changes](version.html#incompatible-changes)
+ - 5.6.2 [Compatible Changes](version.html#compatible-changes)
+
+### 6 [Object Serialization Stream Protocol](protocol.html)
+
+- 6.1 [Overview](protocol.html#overview)
+- 6.2 [Stream Elements](protocol.html#stream-elements)
+- 6.3 [Stream Protocol Versions](protocol.html#stream-protocol-versions)
+- 6.4 [Grammar for the Stream
+ Format](protocol.html#grammar-for-the-stream-format)
+ - 6.4.1 [Rules of the Grammar](protocol.html#rules-of-the-grammar)
+ - 6.4.2 [Terminal Symbols and
+ Constants](protocol.html#terminal-symbols-and-constants)
+
+### A [Security in Object Serialization](security.html)
+
+### B [Exceptions In Object Serialization](exceptions.html)
+
+### C [Example of Serializable Fields](examples.html)
+
+- [C.1 Example Alternate Implementation of
+ `java.io.File`](examples.html#c.1-example-alternate-implementation-of-java.io.file)
+
+-------------------------------------------------------------------------------
+
+*[Copyright](../../../legal/SMICopyright.html) © 2005, 2017, Oracle
+and/or its affiliates. All rights reserved.*
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.base/share/specs/serialization/input.md Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,672 @@
+---
+# Copyright (c) 2005, 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.
+#
+# 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.
+
+include-before: '[CONTENTS](index.html) | [PREV](output.html) | [NEXT](class.html)'
+include-after: '[CONTENTS](index.html) | [PREV](output.html) | [NEXT](class.html)'
+
+title: 'Java Object Serialization Specification: 3 - Object Input Classes'
+---
+
+- [The ObjectInputStream Class](#the-objectinputstream-class)
+- [The ObjectInputStream.GetField
+ Class](#the-objectinputstream.getfield-class)
+- [The ObjectInputValidation Interface](#the-objectinputvalidation-interface)
+- [The readObject Method](#the-readobject-method)
+- [The readExternal Method](#the-readexternal-method)
+- [The readResolve Method](#the-readresolve-method)
+
+-------------------------------------------------------------------------------
+
+## 3.1 The ObjectInputStream Class
+
+Class `ObjectInputStream` implements object deserialization. It maintains the
+state of the stream including the set of objects already deserialized. Its
+methods allow primitive types and objects to be read from a stream written by
+`ObjectOutputStream`. It manages restoration of the object and the objects that
+it refers to from the stream.
+
+```
+package java.io;
+
+public class ObjectInputStream
+ extends InputStream
+ implements ObjectInput, ObjectStreamConstants
+{
+ public ObjectInputStream(InputStream in)
+ throws StreamCorruptedException, IOException;
+
+ public final Object readObject()
+ throws OptionalDataException, ClassNotFoundException,
+ IOException;
+
+ public Object readUnshared()
+ throws OptionalDataException, ClassNotFoundException,
+ IOException;
+
+ public void defaultReadObject()
+ throws IOException, ClassNotFoundException,
+ NotActiveException;
+
+ public GetField readFields()
+ throws IOException;
+
+ public synchronized void registerValidation(
+ ObjectInputValidation obj, int prio)
+ throws NotActiveException, InvalidObjectException;
+
+ protected ObjectStreamClass readClassDescriptor()
+ throws IOException, ClassNotFoundException;
+
+ protected Class resolveClass(ObjectStreamClass v)
+ throws IOException, ClassNotFoundException;
+
+ protected Object resolveObject(Object obj)
+ throws IOException;
+
+ protected boolean enableResolveObject(boolean enable)
+ throws SecurityException;
+
+ protected void readStreamHeader()
+ throws IOException, StreamCorruptedException;
+
+ public int read() throws IOException;
+
+ public int read(byte[] data, int offset, int length)
+ throws IOException
+
+ public int available() throws IOException;
+
+ public void close() throws IOException;
+
+ public boolean readBoolean() throws IOException;
+
+ public byte readByte() throws IOException;
+
+ public int readUnsignedByte() throws IOException;
+
+ public short readShort() throws IOException;
+
+ public int readUnsignedShort() throws IOException;
+
+ public char readChar() throws IOException;
+
+ public int readInt() throws IOException;
+
+ public long readLong() throws IOException;
+
+ public float readFloat() throws IOException;
+
+ public double readDouble() throws IOException;
+
+ public void readFully(byte[] data) throws IOException;
+
+ public void readFully(byte[] data, int offset, int size)
+ throws IOException;
+
+ public int skipBytes(int len) throws IOException;
+
+ public String readLine() throws IOException;
+
+ public String readUTF() throws IOException;
+
+ // Class to provide access to serializable fields.
+ static abstract public class GetField
+ {
+ public ObjectStreamClass getObjectStreamClass();
+
+ public boolean defaulted(String name)
+ throws IOException, IllegalArgumentException;
+
+ public char get(String name, char default)
+ throws IOException, IllegalArgumentException;
+
+ public boolean get(String name, boolean default)
+ throws IOException, IllegalArgumentException;
+
+ public byte get(String name, byte default)
+ throws IOException, IllegalArgumentException;
+
+ public short get(String name, short default)
+ throws IOException, IllegalArgumentException;
+
+ public int get(String name, int default)
+ throws IOException, IllegalArgumentException;
+
+ public long get(String name, long default)
+ throws IOException, IllegalArgumentException;
+
+ public float get(String name, float default)
+ throws IOException, IllegalArgumentException;
+
+ public double get(String name, double default)
+ throws IOException, IllegalArgumentException;
+
+ public Object get(String name, Object default)
+ throws IOException, IllegalArgumentException;
+ }
+
+ protected ObjectInputStream()
+ throws StreamCorruptedException, IOException;
+
+ protected readObjectOverride()
+ throws OptionalDataException, ClassNotFoundException,
+ IOException;
+}
+```
+
+The single-argument `ObjectInputStream` constructor requires an `InputStream`.
+The constructor calls `readStreamHeader` to read and verifies the header and
+version written by the corresponding `ObjectOutputStream.writeStreamHeader`
+method. If a security manager is installed, this constructor checks for the
+`"enableSubclassImplementation"` `SerializablePermission` when invoked directly
+or indirectly by the constructor of a subclass which overrides the `readFields`
+and/or `readUnshared` methods.
+
+**Note:** The `ObjectInputStream` constructor blocks until it completes reading
+the serialization stream header. Code which waits for an `ObjectInputStream` to
+be constructed before creating the corresponding `ObjectOutputStream` for that
+stream will deadlock, since the `ObjectInputStream` constructor will block
+until a header is written to the stream, and the header will not be written to
+the stream until the `ObjectOutputStream` constructor executes. This problem
+can be resolved by creating the `ObjectOutputStream` before the
+`ObjectInputStream`, or otherwise removing the timing dependency between
+completion of `ObjectInputStream` construction and the creation of the
+`ObjectOutputStream`.
+
+The `readObject` method is used to deserialize an object from the stream. It
+reads from the stream to reconstruct an object.
+
+1. If the `ObjectInputStream` subclass is overriding the implementation, call
+ the `readObjectOverride` method and return. Reimplementation is described
+ at the end of this section.
+
+2. If a block data record occurs in the stream, throw a `BlockDataException`
+ with the number of available bytes.
+
+3. If the object in the stream is null, return null.
+
+4. If the object in the stream is a handle to a previous object, return the
+ object.
+
+5. If the object in the stream is a `Class`, read its `ObjectStreamClass`
+ descriptor, add it and its handle to the set of known objects, and return
+ the corresponding `Class` object.
+
+6. If the object in the stream is an `ObjectStreamClass`, read in its data
+ according to the formats described in [Section 4.3, "Serialized
+ Form"](class.html#serialized-form). Add it and its handle to the set of
+ known objects. In versions 1.3 and later of the Java 2 SDK, Standard
+ Edition, the `readClassDescriptor` method is called to read in the
+ `ObjectStreamClass` if it represents a class that is not a dynamic proxy
+ class, as indicated in the stream data. If the class descriptor represents
+ a dynamic proxy class, call the `resolveProxyClass` method on the stream to
+ get the local class for the descriptor; otherwise, call the `resolveClass`
+ method on the stream to get the local class. If the class cannot be
+ resolved, throw a ClassNotFoundException. Return the resulting
+ `ObjectStreamClass` object.
+
+7. If the object in the stream is a `String`, read its length information
+ followed by the contents of the string encoded in modified UTF-8. For
+ details, refer to [Section 6.2, "Stream
+ Elements"](protocol.html#stream-elements). Add the `String` and its handle
+ to the set of known objects, and proceed to Step 12.
+
+8. If the object in the stream is an array, read its `ObjectStreamClass` and
+ the length of the array. Allocate the array, and add it and its handle in
+ the set of known objects. Read each element using the appropriate method
+ for its type and assign it to the array. Proceed to Step 12.
+
+9. If the object in the stream is an enum constant, read its
+ `ObjectStreamClass` and the enum constant name. If the `ObjectStreamClass`
+ represents a class that is not an enum type, an `InvalidClassException` is
+ thrown. Obtain a reference to the enum constant by calling the
+ `java.lang.Enum.valueOf` method, passing the enum type bound to the
+ received `ObjectStreamClass` along with the received name as arguments. If
+ the `valueOf` method throws an `IllegalArgumentException`, an
+ `InvalidObjectException` is thrown with the `IllegalArgumentException` as
+ its cause. Add the enum constant and its handle in the set of known
+ objects, and proceed to Step 12.
+
+10. For all other objects, the `ObjectStreamClass` of the object is read from
+ the stream. The local class for that `ObjectStreamClass` is retrieved. The
+ class must be serializable or externalizable, and must not be an enum type.
+ If the class does not satisfy these criteria, an `InvalidClassException` is
+ thrown.
+
+11. An instance of the class is allocated. The instance and its handle are
+ added to the set of known objects. The contents restored appropriately:
+
+ a. For serializable objects, the no-arg constructor for the first
+ non-serializable supertype is run. For serializable classes, the fields
+ are initialized to the default value appropriate for its type. Then the
+ fields of each class are restored by calling class-specific
+ `readObject` methods, or if these are not defined, by calling the
+ `defaultReadObject` method. Note that field initializers and
+ constructors are not executed for serializable classes during
+ deserialization. In the normal case, the version of the class that
+ wrote the stream will be the same as the class reading the stream. In
+ this case, all of the supertypes of the object in the stream will match
+ the supertypes in the currently-loaded class. If the version of the
+ class that wrote the stream had different supertypes than the loaded
+ class, the `ObjectInputStream` must be more careful about restoring or
+ initializing the state of the differing classes. It must step through
+ the classes, matching the available data in the stream with the classes
+ of the object being restored. Data for classes that occur in the
+ stream, but do not occur in the object, is discarded. For classes that
+ occur in the object, but not in the stream, the class fields are set to
+ default values by default serialization.
+
+ b. For externalizable objects, the no-arg constructor for the class is run
+ and then the `readExternal` method is called to restore the contents of
+ the object.
+
+12. Process potential substitutions by the class of the object and/or by a
+ subclass of `ObjectInputStream`:
+
+ a. If the class of the object is not an enum type and defines the
+ appropriate `readResolve` method, the method is called to allow the
+ object to replace itself.
+
+ b. Then if previously enabled by `enableResolveObject,` the
+ `resolveObject` method is called to allow subclasses of the stream to
+ examine and replace the object. If the previous step did replace the
+ original object, the `resolveObject` method is called with the
+ replacement object. If a replacement took place, the table of known
+ objects is updated so the replacement object is associated with the
+ handle. The replacement object is then returned from `readObject`.
+
+All of the methods for reading primitives types only consume bytes from the
+block data records in the stream. If a read for primitive data occurs when the
+next item in the stream is an object, the read methods return *-1* or the
+`EOFException` as appropriate. The value of a primitive type is read by a
+`DataInputStream` from the block data record.
+
+The exceptions thrown reflect errors during the traversal or exceptions that
+occur on the underlying stream. If any exception is thrown, the underlying
+stream is left in an unknown and unusable state.
+
+When the reset token occurs in the stream, all of the state of the stream is
+discarded. The set of known objects is cleared.
+
+When the exception token occurs in the stream, the exception is read and a new
+`WriteAbortedException` is thrown with the terminating exception as an
+argument. The stream context is reset as described earlier.
+
+The `readUnshared` method is used to read "unshared" objects from the stream.
+This method is identical to `readObject`, except that it prevents subsequent
+calls to `readObject` and `readUnshared` from returning additional references
+to the deserialized instance returned by the original call to `readUnshared`.
+Specifically:
+
+- If `readUnshared` is called to deserialize a back-reference (the stream
+ representation of an object which has been written previously to the
+ stream), an `ObjectStreamException` will be thrown.
+
+- If `readUnshared` returns successfully, then any subsequent attempts to
+ deserialize back-references to the stream handle deserialized by
+ `readUnshared` will cause an `ObjectStreamException` to be thrown.
+
+Deserializing an object via `readUnshared` invalidates the stream handle
+associated with the returned object. Note that this in itself does not always
+guarantee that the reference returned by `readUnshared` is unique; the
+deserialized object may define a `readResolve` method which returns an object
+visible to other parties, or `readUnshared` may return a `Class` object or enum
+constant obtainable elsewhere in the stream or through external means. If the
+deserialized object defines a `readResolve` method and the invocation of that
+method returns an array, then `readUnshared` returns a shallow clone of that
+array; this guarantees that the returned array object is unique and cannot be
+obtained a second time from an invocation of `readObject` or `readUnshared` on
+the `ObjectInputStream`, even if the underlying data stream has been
+manipulated.
+
+The `defaultReadObject` method is used to read the fields and object from the
+stream. It uses the class descriptor in the stream to read the fields in the
+canonical order by name and type from the stream. The values are assigned to
+the matching fields by name in the current class. Details of the versioning
+mechanism can be found in [Section 5.5, "Compatible Java Type
+Evolution"](version.html#compatible-java-type-evolution). Any field of the
+object that does not appear in the stream is set to its default value. Values
+that appear in the stream, but not in the object, are discarded. This occurs
+primarily when a later version of a class has written additional fields that do
+not occur in the earlier version. This method may only be called from the
+`readObject` method while restoring the fields of a class. When called at any
+other time, the `NotActiveException` is thrown.
+
+The `readFields` method reads the values of the serializable fields from the
+stream and makes them available via the `GetField` class. The `readFields`
+method is only callable from within the `readObject` method of a serializable
+class. It cannot be called more than once or if `defaultReadObject` has been
+called. The `GetFields` object uses the current object's `ObjectStreamClass` to
+verify the fields that can be retrieved for this class. The `GetFields` object
+returned by `readFields` is only valid during this call to the classes
+`readObject` method. The fields may be retrieved in any order. Additional data
+may only be read directly from stream after `readFields` has been called.
+
+The `registerValidation` method can be called to request a callback when the
+entire graph has been restored but before the object is returned to the
+original caller of `readObject`. The order of validate callbacks can be
+controlled using the priority. Callbacks registered with higher values are
+called before those with lower values. The object to be validated must support
+the `ObjectInputValidation` interface and implement the `validateObject`
+method. It is only correct to register validations during a call to a class's
+`readObject` method. Otherwise, a `NotActiveException` is thrown. If the
+callback object supplied to `registerValidation` is null, an
+`InvalidObjectException` is thrown.
+
+Starting with the Java SDK, Standard Edition, v1.3, the `readClassDescriptor`
+method is used to read in all `ObjectStreamClass` objects.
+`readClassDescriptor` is called when the `ObjectInputStream` expects a class
+descriptor as the next item in the serialization stream. Subclasses of
+`ObjectInputStream` may override this method to read in class descriptors that
+have been written in non-standard formats (by subclasses of
+`ObjectOutputStream` which have overridden the `writeClassDescriptor` method).
+By default, this method reads class descriptors according to the format
+described in [Section 6.4, "Grammar for the Stream
+Format"](protocol.html#grammar-for-the-stream-format).
+
+The `resolveClass` method is called while a class is being deserialized, and
+after the class descriptor has been read. Subclasses may extend this method to
+read other information about the class written by the corresponding subclass of
+`ObjectOutputStream`. The method must find and return the class with the given
+name and `serialVersionUID`. The default implementation locates the class by
+calling the class loader of the closest caller of `readObject` that has a class
+loader. If the class cannot be found `ClassNotFoundException` should be thrown.
+Prior to JDK 1.1.6, the `resolveClass` method was required to return the same
+fully qualified class name as the class name in the stream. In order to
+accommodate package renaming across releases, `method` `resolveClass` only
+needs to return a class with the same base class name and `SerialVersionUID` in
+JDK 1.1.6 and later versions.
+
+The `resolveObject` method is used by trusted subclasses to monitor or
+substitute one object for another during deserialization. Resolving objects
+must be enabled explicitly by calling `enableResolveObject` before calling
+`readObject` for the first object to be resolved. Once enabled, `resolveObject`
+is called once for each serializable object just prior to the first time it is
+being returned from `readObject`. Note that the `resolveObject` method is not
+called for objects of the specially handled classes, `Class`,
+`ObjectStreamClass`, `String`, and arrays. A subclass's implementation of
+`resolveObject` may return a substitute object that will be assigned or
+returned instead of the original. The object returned must be of a type that is
+consistent and assignable to every reference of the original object or else a
+`ClassCastException` will be thrown. All assignments are type-checked. All
+references in the stream to the original object will be replaced by references
+to the substitute object.
+
+The `enableResolveObject` method is called by trusted subclasses of
+`ObjectOutputStream` to enable the monitoring or substitution of one object for
+another during deserialization. Replacing objects is disabled until
+`enableResolveObject` is called with a `true` value. It may thereafter be
+disabled by setting it to `false`. The previous setting is returned. The
+`enableResolveObject` method checks if the stream has permission to request
+substitution during serialization. To ensure that the private state of objects
+is not unintentionally exposed, only trusted streams may use `resolveObject`.
+Trusted classes are those classes with a class loader equal to null or belong
+to a security protection domain that provides permission to enable
+substitution.
+
+If the subclass of `ObjectInputStream` is not considered part of the system
+domain, a line has to be added to the security policy file to provide to a
+subclass of `ObjectInputStream` permission to call `enableResolveObject`. The
+`SerializablePermission` to add is `"enableSubstitution"`.
+`AccessControlException` is thrown if the protection domain of the subclass of
+`ObjectStreamClass` does not have permission to `"enableSubstitution"` by
+calling `enableResolveObject`. See the document Java Security Architecture (JDK
+1.2) for additional information about the security model.
+
+The `readStreamHeader` method reads and verifies the magic number and version
+of the stream. If they do not match, the `StreamCorruptedMismatch` is thrown.
+
+To override the implementation of deserialization, a subclass of
+`ObjectInputStream` should call the protected no-arg `ObjectInputStream`,
+constructor. There is a security check within the no-arg constructor for
+`SerializablePermission "enableSubclassImplementation"` to ensure that only
+trusted classes are allowed to override the default implementation. This
+constructor does not allocate any private data for `ObjectInputStream` and sets
+a flag that indicates that the final `readObject` method should invoke the
+`readObjectOverride` method and return. All other `ObjectInputStream` methods
+are not final and can be directly overridden by the subclass.
+
+## 3.2 The ObjectInputStream.GetField Class
+
+The class `ObjectInputStream.GetField` provides the API for getting the values
+of serializable fields. The protocol of the stream is the same as used by
+`defaultReadObject.` Using `readFields` to access the serializable fields does
+not change the format of the stream. It only provides an alternate API to
+access the values which does not require the class to have the corresponding
+non-transient and non-static fields for each named serializable field. The
+serializable fields are those declared using `serialPersistentFields` or if it
+is not declared the non-transient and non-static fields of the object. When the
+stream is read the available serializable fields are those written to the
+stream when the object was serialized. If the class that wrote the stream is a
+different version not all fields will correspond to the serializable fields of
+the current class. The available fields can be retrieved from the
+`ObjectStreamClass` of the `GetField` object.
+
+The `getObjectStreamClass` method returns an `ObjectStreamClass` object
+representing the class in the stream. It contains the list of serializable
+fields.
+
+The `defaulted` method returns *true* if the field is not present in the
+stream. An `IllegalArgumentException` is thrown if the requested field is not a
+serializable field of the current class.
+
+Each `get` method returns the specified serializable field from the stream. I/O
+exceptions will be thrown if the underlying stream throws an exception. An
+`IllegalArgumentException` is thrown if the name or type does not match the
+name and type of an field serializable field of the current class. The default
+value is returned if the stream does not contain an explicit value for the
+field.
+
+## 3.3 The ObjectInputValidation Interface
+
+This interface allows an object to be called when a complete graph of objects
+has been deserialized. If the object cannot be made valid, it should throw the
+`ObjectInvalidException`. Any exception that occurs during a call to
+`validateObject` will terminate the validation process, and the
+`InvalidObjectException` will be thrown.
+
+```
+package java.io;
+
+public interface ObjectInputValidation
+{
+ public void validateObject()
+ throws InvalidObjectException;
+}
+```
+
+## 3.4 The readObject Method
+
+For serializable objects, the `readObject` method allows a class to control the
+deserialization of its own fields. Here is its signature:
+
+```
+private void readObject(ObjectInputStream stream)
+ throws IOException, ClassNotFoundException;
+```
+
+Each subclass of a serializable object may define its own `readObject` method.
+If a class does not implement the method, the default serialization provided by
+`defaultReadObject` will be used. When implemented, the class is only
+responsible for restoring its own fields, not those of its supertypes or
+subtypes.
+
+The `readObject` method of the class, if implemented, is responsible for
+restoring the state of the class. The values of every field of the object
+whether transient or not, static or not are set to the default value for the
+fields type. Either `ObjectInputStream`'s `defaultReadObject` or `readFields`
+method must be called once (and only once) before reading any optional data
+written by the corresponding `writeObject` method; even if no optional data is
+read, `defaultReadObject` or `readFields` must still be invoked once. If the
+`readObject` method of the class attempts to read more data than is present in
+the optional part of the stream for this class, the stream will return `-1` for
+bytewise reads, throw an `EOFException` for primitive data reads (e.g.,
+`readInt`, `readFloat`), or throw an `OptionalDataException` with the `eof`
+field set to `true` for object reads.
+
+The responsibility for the format, structure, and versioning of the optional
+data lies completely with the class. The `@serialData` javadoc tag within the
+javadoc comment for the `readObject` method should be used to document the
+format and structure of the optional data.
+
+If the class being restored is not present in the stream being read, then its
+`readObjectNoData` method, if defined, is invoked (instead of `readObject`);
+otherwise, its fields are initialized to the appropriate default values. For
+further detail, see [Section 3.5, "The readObjectNoData
+Method"](#the-readobjectnodata-method).
+
+Reading an object from the `ObjectInputStream` is analogous to creating a new
+object. Just as a new object's constructors are invoked in the order from the
+superclass to the subclass, an object being read from a stream is deserialized
+from superclass to subclass. The `readObject` or `readObjectNoData` method is
+called instead of the constructor for each `Serializable` subclass during
+deserialization.
+
+One last similarity between a constructor and a `readObject` method is that
+both provide the opportunity to invoke a method on an object that is not fully
+constructed. Any overridable (neither private, static nor final) method called
+while an object is being constructed can potentially be overridden by a
+subclass. Methods called during the construction phase of an object are
+resolved by the actual type of the object, not the type currently being
+initialized by either its constructor or `readObject`/`readObjectNoData`
+method. Therefore, calling an overridable method from within a `readObject` or
+`readObjectNoData` method may result in the unintentional invocation of a
+subclass method before the superclass has been fully initialized.
+
+## 3.5 The readObjectNoData Method
+
+For serializable objects, the `readObjectNoData` method allows a class to
+control the initialization of its own fields in the event that a subclass
+instance is deserialized and the serialization stream does not list the class
+in question as a superclass of the deserialized object. This may occur in cases
+where the receiving party uses a different version of the deserialized
+instance's class than the sending party, and the receiver's version extends
+classes that are not extended by the sender's version. This may also occur if
+the serialization stream has been tampered; hence, `readObjectNoData` is useful
+for initializing deserialized objects properly despite a "hostile" or
+incomplete source stream.
+
+```
+private void readObjectNoData() throws ObjectStreamException;
+```
+
+Each serializable class may define its own `readObjectNoData` method. If a
+serializable class does not define a `readObjectNoData` method, then in the
+circumstances listed above the fields of the class will be initialized to their
+default values (as listed in The Java Language Specification); this behavior is
+consistent with that of `ObjectInputStream` prior to version 1.4 of the Java 2
+SDK, Standard Edition, when support for `readObjectNoData` methods was
+introduced. If a serializable class does define a `readObjectNoData` method and
+the aforementioned conditions arise, then `readObjectNoData` will be invoked at
+the point during deserialization when a class-defined `readObject` method would
+otherwise be called had the class in question been listed by the stream as a
+superclass of the instance being deserialized.
+
+## 3.6 The readExternal Method
+
+Objects implementing `java.io.Externalizable` must implement the `readExternal`
+method to restore the entire state of the object. It must coordinate with its
+superclasses to restore their state. All of the methods of `ObjectInput` are
+available to restore the object's primitive typed fields and object fields.
+
+```
+public void readExternal(ObjectInput stream)
+ throws IOException;
+```
+
+**Note:** The `readExternal` method is public, and it raises the risk of a
+client being able to overwrite an existing object from a stream. The class may
+add its own checks to insure that this is only called when appropriate.
+
+A new stream protocol version has been introduced in JDK 1.2 to correct a
+problem with `Externalizable` objects. The old definition of `Externalizable`
+objects required the local virtual machine to find a `readExternal` method to
+be able to properly read an `Externalizable` object from the stream. The new
+format adds enough information to the stream protocol so serialization can skip
+an `Externalizable` object when the local `readExternal` method is not
+available. Due to class evolution rules, serialization must be able to skip an
+`Externalizable` object in the input stream if there is not a mapping for the
+object using the local classes.
+
+An additional benefit of the new `Externalizable` stream format is that
+`ObjectInputStream` can detect attempts to read more External data than is
+available, and can also skip by any data that is left unconsumed by a
+`readExternal` method. The behavior of `ObjectInputStream` in response to a
+read past the end of External data is the same as the behavior when a
+class-defined `readObject` method attempts to read past the end of its optional
+data: bytewise reads will return `-1`, primitive reads will throw
+`EOFException`s, and object reads will throw `OptionalDataException`s with the
+`eof` field set to `true`.
+
+Due to the format change, JDK 1.1.6 and earlier releases are not able to read
+the new format. `StreamCorruptedException` is thrown when JDK 1.1.6 or earlier
+attempts to read an `Externalizable` object from a stream written in
+`PROTOCOL_VERSION_2`. Compatibility issues are discussed in more detail in
+[Section 6.3, "Stream Protocol
+Versions"](protocol.html#stream-protocol-versions).
+
+## 3.7 The readResolve Method
+
+For Serializable and Externalizable classes, the `readResolve` method allows a
+class to replace/resolve the object read from the stream before it is returned
+to the caller. By implementing the `readResolve` method, a class can directly
+control the types and instances of its own instances being deserialized. The
+method is defined as follows:
+
+```
+ANY-ACCESS-MODIFIER Object readResolve()
+ throws ObjectStreamException;
+```
+
+The `readResolve` method is called when `ObjectInputStream` has read an object
+from the stream and is preparing to return it to the caller.
+`ObjectInputStream` checks whether the class of the object defines the
+`readResolve` method. If the method is defined, the `readResolve` method is
+called to allow the object in the stream to designate the object to be
+returned. The object returned should be of a type that is compatible with all
+uses. If it is not compatible, a `ClassCastException` will be thrown when the
+type mismatch is discovered.
+
+For example, a `Symbol` class could be created for which only a single instance
+of each symbol binding existed within a virtual machine. The `readResolve`
+method would be implemented to determine if that symbol was already defined and
+substitute the preexisting equivalent `Symbol` object to maintain the identity
+constraint. In this way the uniqueness of `Symbol` objects can be maintained
+across serialization.
+
+**Note:** The `readResolve` method is not invoked on the object until the
+object is fully constructed, so any references to this object in its object
+graph will not be updated to the new object nominated by `readResolve`.
+However, during the serialization of an object with the `writeReplace` method,
+all references to the original object in the replacement object's object graph
+are replaced with references to the replacement object. Therefore in cases
+where an object being serialized nominates a replacement object whose object
+graph has a reference to the original object, deserialization will result in an
+incorrect graph of objects. Furthermore, if the reference types of the object
+being read (nominated by `writeReplace`) and the original object are not
+compatible, the construction of the object graph will raise a
+`ClassCastException`.
+
+-------------------------------------------------------------------------------
+
+*[Copyright](../../../legal/SMICopyright.html) © 2005, 2017, Oracle
+and/or its affiliates. All rights reserved.*
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.base/share/specs/serialization/output.md Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,513 @@
+---
+# Copyright (c) 2005, 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.
+#
+# 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.
+
+include-before: '[CONTENTS](index.html) | [PREV](serial-arch.html) | [NEXT](input.html)'
+include-after: '[CONTENTS](index.html) | [PREV](serial-arch.html) | [NEXT](input.html)'
+
+title: 'Java Object Serialization Specification: 2 - Object Output Classes'
+---
+
+- [The ObjectOutputStream Class](#the-objectoutputstream-class)
+- [The ObjectOutputStream.PutField
+ Class](#the-objectoutputstream.putfield-class)
+- [The writeObject Method](#the-writeobject-method)
+- [The writeExternal Method](#the-writeexternal-method)
+- [The writeReplace Method](#the-writereplace-method)
+- [The useProtocolVersion Method](#the-useprotocolversion-method)
+
+-------------------------------------------------------------------------------
+
+## 2.1 The ObjectOutputStream Class
+
+Class `ObjectOutputStream` implements object serialization. It maintains the
+state of the stream including the set of objects already serialized. Its
+methods control the traversal of objects to be serialized to save the specified
+objects and the objects to which they refer.
+
+```
+package java.io;
+
+public class ObjectOutputStream
+ extends OutputStream
+ implements ObjectOutput, ObjectStreamConstants
+{
+ public ObjectOutputStream(OutputStream out)
+ throws IOException;
+
+ public final void writeObject(Object obj)
+ throws IOException;
+
+ public void writeUnshared(Object obj)
+ throws IOException;
+
+ public void defaultWriteObject()
+ throws IOException, NotActiveException;
+
+ public PutField putFields()
+ throws IOException;
+
+ public writeFields()
+ throws IOException;
+
+ public void reset() throws IOException;
+
+ protected void annotateClass(Class cl) throws IOException;
+
+ protected void writeClassDescriptor(ObjectStreamClass desc)
+ throws IOException;
+
+ protected Object replaceObject(Object obj) throws IOException;
+
+ protected boolean enableReplaceObject(boolean enable)
+ throws SecurityException;
+
+ protected void writeStreamHeader() throws IOException;
+
+ public void write(int data) throws IOException;
+
+ public void write(byte b[]) throws IOException;
+
+ public void write(byte b[], int off, int len) throws IOException;
+
+ public void flush() throws IOException;
+
+ protected void drain() throws IOException;
+
+ public void close() throws IOException;
+
+ public void writeBoolean(boolean data) throws IOException;
+
+ public void writeByte(int data) throws IOException;
+
+ public void writeShort(int data) throws IOException;
+
+ public void writeChar(int data) throws IOException;
+
+ public void writeInt(int data) throws IOException;
+
+ public void writeLong(long data) throws IOException;
+
+ public void writeFloat(float data) throws IOException;
+
+ public void writeDouble(double data) throws IOException;
+
+ public void writeBytes(String data) throws IOException;
+
+ public void writeChars(String data) throws IOException;
+
+ public void writeUTF(String data) throws IOException;
+
+ // Inner class to provide access to serializable fields.
+ abstract static public class PutField
+ {
+ public void put(String name, boolean value)
+ throws IOException, IllegalArgumentException;
+
+ public void put(String name, char data)
+ throws IOException, IllegalArgumentException;
+
+ public void put(String name, byte data)
+ throws IOException, IllegalArgumentException;
+
+ public void put(String name, short data)
+ throws IOException, IllegalArgumentException;
+
+ public void put(String name, int data)
+ throws IOException, IllegalArgumentException;
+
+ public void put(String name, long data)
+ throws IOException, IllegalArgumentException;
+
+ public void put(String name, float data)
+ throws IOException, IllegalArgumentException;
+
+ public void put(String name, double data)
+ throws IOException, IllegalArgumentException;
+
+ public void put(String name, Object data)
+ throws IOException, IllegalArgumentException;
+ }
+
+ public void useProtocolVersion(int version) throws IOException;
+
+ protected ObjectOutputStream()
+ throws IOException;
+
+ protected writeObjectOverride()
+ throws NotActiveException, IOException;
+}
+```
+
+The single-argument `ObjectOutputStream` constructor creates an
+`ObjectOutputStream` that serializes objects to the given `OutputStream`. The
+constructor calls `writeStreamHeader` to write a magic number and version to
+the stream that will be read and verified by a corresponding call to
+`readStreamHeader` in the single-argument `ObjectInputStream` constructor. If a
+security manager is installed, this constructor checks for the
+`"enableSubclassImplementation"` `SerializablePermission` when invoked directly
+or indirectly by the constructor of a subclass which overrides the `putFields`
+and/or `writeUnshared` methods.
+
+The `writeObject` method is used to serialize an object to the stream. An
+object is serialized as follows:
+
+1. If a subclass is overriding the implementation, call the
+ `writeObjectOverride` method and return. Overriding the implementation is
+ described at the end of this section.
+
+2. If there is data in the block-data buffer, the data is written to the
+ stream and the buffer is reset.
+
+3. If the object is null, null is put in the stream and `writeObject` returns.
+
+4. If the object has been previously replaced, as described in Step 8, write
+ the handle of the replacement to the stream and `writeObject` returns.
+
+5. If the object has already been written to the stream, its handle is written
+ to the stream and `writeObject` returns.
+
+6. If the object is a `Class`, the corresponding `ObjectStreamClass` is
+ written to the stream, a handle is assigned for the class, and
+ `writeObject` returns.
+
+7. If the object is an `ObjectStreamClass`, a handle is assigned to the
+ object, after which it is written to the stream using one of the class
+ descriptor formats described in [Section 4.3, "Serialized
+ Form"](class.html#serialized-form). In versions 1.3 and later of the Java 2
+ SDK, Standard Edition, the `writeClassDescriptor` method is called to
+ output the `ObjectStreamClass` if it represents a class that is not a
+ dynamic proxy class, as determined by passing the associated `Class` object
+ to the `isProxyClass` method of `java.lang.reflect.Proxy`. Afterwards, an
+ annotation for the represented class is written: if the class is a dynamic
+ proxy class, then the `annotateProxyClass` method is called; otherwise, the
+ `annotateClass` method is called. The `writeObject` method then returns.
+
+8. Process potential substitutions by the class of the object and/or by a
+ subclass of `ObjectInputStream`.
+
+ a. If the class of an object is not an enum type and defines the
+ appropriate `writeReplace` method, the method is called. Optionally, it
+ can return a substitute object to be serialized.
+
+ b. Then, if enabled by calling the `enableReplaceObject` method, the
+ `replaceObject` method is called to allow subclasses of
+ `ObjectOutputStream` to substitute for the object being serialized. If
+ the original object was replaced in the previous step, the
+ `replaceObject` method is called with the replacement object.
+
+ If the original object was replaced by either one or both steps above, the
+ mapping from the original object to the replacement is recorded for later
+ use in Step 4. Then, Steps 3 through 7 are repeated on the new object.
+
+ If the replacement object is not one of the types covered by Steps 3
+ through 7, processing resumes using the replacement object at Step 10.
+
+9. If the object is a `java.lang.String,` the string is written as length
+ information followed by the contents of the string encoded in modified
+ UTF-8. For details, refer to [Section 6.2, "Stream
+ Elements"](protocol.html#stream-elements). A handle is assigned to the
+ string, and `writeObject` returns.
+
+10. If the object is an array, `writeObject` is called recursively to write the
+ `ObjectStreamClass` of the array. The handle for the array is assigned. It
+ is followed by the length of the array. Each element of the array is then
+ written to the stream, after which `writeObject` returns.
+
+11. If the object is an enum constant, the `ObjectStreamClass` for the enum
+ type of the constant is written by recursively calling `writeObject`. It
+ will appear in the stream only the first time it is referenced. A handle is
+ assigned for the enum constant. Next, the value returned by the `name`
+ method of the enum constant is written as a `String` object, as described
+ in step 9. Note that if the same name string has appeared previously in the
+ stream, a back reference to it will be written. The `writeObject` method
+ then returns.
+
+12. For regular objects, the `ObjectStreamClass` for the class of the object is
+ written by recursively calling `writeObject`. It will appear in the stream
+ only the first time it is referenced. A handle is assigned for the object.
+
+13. The contents of the object are written to the stream.
+
+ a. If the object is serializable, the highest serializable class is
+ located. For that class, and each derived class, that class's fields
+ are written. If the class does not have a `writeObject` method, the
+ `defaultWriteObject` method is called to write the serializable fields
+ to the stream. If the class does have a `writeObject` method, it is
+ called. It may call `defaultWriteObject` or `putFields` and
+ `writeFields` to save the state of the object, and then it can write
+ other information to the stream.
+
+ b. If the object is externalizable, the `writeExternal` method of the
+ object is called.
+
+ c. If the object is neither serializable or externalizable, the
+ `NotSerializableException` is thrown.
+
+Exceptions may occur during the traversal or may occur in the underlying
+stream. For any subclass of `IOException`, the exception is written to the
+stream using the exception protocol and the stream state is discarded. If a
+second `IOException` is thrown while attempting to write the first exception
+into the stream, the stream is left in an unknown state and
+`StreamCorruptedException` is thrown from `writeObject`. For other exceptions,
+the stream is aborted and left in an unknown and unusable state.
+
+The `writeUnshared` method writes an "unshared" object to the
+`ObjectOutputStream`. This method is identical to `writeObject`, except that it
+always writes the given object as a new, unique object in the stream (as
+opposed to a back-reference pointing to a previously serialized instance).
+Specifically:
+
+- An object written via `writeUnshared` is always serialized in the same
+ manner as a newly appearing object (an object that has not been written to
+ the stream yet), regardless of whether or not the object has been written
+ previously.
+
+- If `writeObject` is used to write an object that has been previously
+ written with `writeUnshared`, the previous `writeUnshared` operation is
+ treated as if it were a write of a separate object. In other words,
+ `ObjectOutputStream` will never generate back-references to object data
+ written by calls to `writeUnshared`.
+
+While writing an object via `writeUnshared` does not in itself guarantee a
+unique reference to the object when it is deserialized, it allows a single
+object to be defined multiple times in a stream, so that multiple calls to the
+`ObjectInputStream.readUnshared` method (see [Section 3.1, "The
+ObjectInputStream Class"](input.html#the-objectinputstream-class)) by the
+receiver will not conflict. Note that the rules described above only apply to
+the base-level object written with `writeUnshared`, and not to any transitively
+referenced sub-objects in the object graph to be serialized.
+
+The `defaultWriteObject` method implements the default serialization mechanism
+for the current class. This method may be called only from a class's
+`writeObject` method. The method writes all of the serializable fields of the
+current class to the stream. If called from outside the `writeObject` method,
+the `NotActiveException` is thrown.
+
+The `putFields` method returns a `PutField` object the caller uses to set the
+values of the serializable fields in the stream. The fields may be set in any
+order. After all of the fields have been set, `writeFields` must be called to
+write the field values in the canonical order to the stream. If a field is not
+set, the default value appropriate for its type will be written to the stream.
+This method may only be called from within the `writeObject` method of a
+serializable class. It may not be called more than once or if
+`defaultWriteObject` has been called. Only after `writeFields` has been called
+can other data be written to the stream.
+
+The `reset` method resets the stream state to be the same as if it had just
+been constructed. `Reset` will discard the state of any objects already written
+to the stream. The current point in the stream is marked as reset, so the
+corresponding `ObjectInputStream` will reset at the same point. Objects
+previously written to the stream will not be remembered as already having been
+written to the stream. They will be written to the stream again. This is useful
+when the contents of an object or objects must be sent again. `Reset` may not
+be called while objects are being serialized. If called inappropriately, an
+`IOException` is thrown.
+
+Starting with the Java 2 SDK, Standard Edition, v1.3, the
+`writeClassDescriptor` method is called when an `ObjectStreamClass` needs to be
+serialized. `writeClassDescriptor` is responsible for writing a representation
+of the `ObjectStreamClass` to the serialization stream. Subclasses may override
+this method to customize the way in which class descriptors are written to the
+serialization stream. If this method is overridden, then the corresponding
+`readClassDescriptor` method in `ObjectInputStream` should also be overridden
+to reconstitute the class descriptor from its custom stream representation. By
+default, `writeClassDescriptor` writes class descriptors according to the
+format specified in [Section 6.4, "Grammar for the Stream
+Format"](protocol.html#grammar-for-the-stream-format). Note that this method
+will only be called if the `ObjectOutputStream` is not using the old
+serialization stream format (see [Section 6.3, "Stream Protocol
+Versions"](protocol.html#stream-protocol-versions)). If the serialization
+stream is using the old format (`ObjectStreamConstants.PROTOCOL_VERSION_1`),
+the class descriptor will be written internally in a manner that cannot be
+overridden or customized.
+
+The `annotateClass` method is called while a `Class` is being serialized, and
+after the class descriptor has been written to the stream. Subclasses may
+extend this method and write other information to the stream about the class.
+This information must be read by the `resolveClass` method in a corresponding
+`ObjectInputStream` subclass.
+
+An `ObjectOutputStream` subclass can implement the `replaceObject` method to
+monitor or replace objects during serialization. Replacing objects must be
+enabled explicitly by calling `enableReplaceObject` before calling
+`writeObject` with the first object to be replaced. Once enabled,
+`replaceObject` is called for each object just prior to serializing the object
+for the first time. Note that the `replaceObject` method is not called for
+objects of the specially handled classes, `Class` and `ObjectStreamClass`. An
+implementation of a subclass may return a substitute object that will be
+serialized instead of the original. The substitute object must be serializable.
+All references in the stream to the original object will be replaced by the
+substitute object.
+
+When objects are being replaced, the subclass must ensure that the substituted
+object is compatible with every field where the reference will be stored, or
+that a complementary substitution will be made during deserialization. Objects,
+whose type is not a subclass of the type of the field or array element, will
+later abort the deserialization by raising a `ClassCastException` and the
+reference will not be stored.
+
+The `enableReplaceObject` method can be called by trusted subclasses of
+`ObjectOutputStream` to enable the substitution of one object for another
+during serialization. Replacing objects is disabled until `enableReplaceObject`
+is called with a `true` value. It may thereafter be disabled by setting it to
+`false`. The previous setting is returned. The `enableReplaceObject` method
+checks that the stream requesting the replacement can be trusted. To ensure
+that the private state of objects is not unintentionally exposed, only trusted
+stream subclasses may use `replaceObject`. Trusted classes are those classes
+that belong to a security protection domain with permission to enable
+Serializable substitution.
+
+If the subclass of `ObjectOutputStream` is not considered part of the system
+domain, `SerializablePermission "enableSubstitution"` must be added to the
+security policy file. `AccessControlException` is thrown if the protection
+domain of the subclass of `ObjectInputStream` does not have permission to
+`"enableSubstitution"` by calling `enableReplaceObject`. See the document Java
+Security Architecture (JDK1.2) for additional information about the security
+model.
+
+The `writeStreamHeader` method writes the magic number and version to the
+stream. This information must be read by the `readStreamHeader` method of
+`ObjectInputStream`. Subclasses may need to implement this method to identify
+the stream's unique format.
+
+The `flush` method is used to empty any buffers being held by the stream and to
+forward the flush to the underlying stream. The `drain` method may be used by
+subclassers to empty only the `ObjectOutputStream`'s buffers without forcing
+the underlying stream to be flushed.
+
+All of the write methods for primitive types encode their values using a
+`DataOutputStream` to put them in the standard stream format. The bytes are
+buffered into block data records so they can be distinguished from the encoding
+of objects. This buffering allows primitive data to be skipped if necessary for
+class versioning. It also allows the stream to be parsed without invoking
+class-specific methods.
+
+To override the implementation of serialization, the subclass of
+`ObjectOutputStream` should call the protected no-arg `ObjectOutputStream`,
+constructor. There is a security check within the no-arg constructor for
+`SerializablePermission "enableSubclassImplementation"` to ensure that only
+trusted classes are allowed to override the default implementation. This
+constructor does not allocate any private data for `ObjectOutputStream` and
+sets a flag that indicates that the final `writeObject` method should invoke
+the `writeObjectOverride` method and return. All other `ObjectOutputStream`
+methods are not final and can be directly overridden by the subclass.
+
+## 2.2 The ObjectOutputStream.PutField Class
+
+Class `PutField` provides the API for setting values of the serializable fields
+for a class when the class does not use default serialization. Each method puts
+the specified named value into the stream. An `IllegalArgumentException` is
+thrown if `name` does not match the name of a serializable field for the class
+whose fields are being written, or if the type of the named field does not
+match the second parameter type of the specific `put` method invoked.
+
+## 2.3 The writeObject Method
+
+For serializable objects, the `writeObject` method allows a class to control
+the serialization of its own fields. Here is its signature:
+
+```
+private void writeObject(ObjectOutputStream stream)
+ throws IOException;
+```
+
+Each subclass of a serializable object may define its own `writeObject` method.
+If a class does not implement the method, the default serialization provided by
+`defaultWriteObject` will be used. When implemented, the class is only
+responsible for writing its own fields, not those of its supertypes or
+subtypes.
+
+The class's `writeObject` method, if implemented, is responsible for saving the
+state of the class. Either `ObjectOutputStream`'s `defaultWriteObject` or
+`writeFields` method must be called once (and only once) before writing any
+optional data that will be needed by the corresponding `readObject` method to
+restore the state of the object; even if no optional data is written,
+`defaultWriteObject` or `writeFields` must still be invoked once. If
+`defaultWriteObject` or `writeFields` is not invoked once prior to the writing
+of optional data (if any), then the behavior of instance deserialization is
+undefined in cases where the `ObjectInputStream` cannot resolve the class which
+defined the `writeObject` method in question.
+
+The responsibility for the format, structure, and versioning of the optional
+data lies completely with the class.
+
+## 2.4 The writeExternal Method
+
+Objects implementing `java.io.Externalizable` must implement the
+`writeExternal` method to save the entire state of the object. It must
+coordinate with its superclasses to save their state. All of the methods of
+`ObjectOutput` are available to save the object's primitive typed fields and
+object fields.
+
+```
+public void writeExternal(ObjectOutput stream)
+ throws IOException;
+```
+
+A new default format for writing Externalizable data has been introduced in JDK
+1.2. The new format specifies that primitive data will be written in block data
+mode by `writeExternal` methods. Additionally, a tag denoting the end of the
+External object is appended to the stream after the `writeExternal` method
+returns. The benefits of this format change are discussed in [Section 3.6, "The
+readExternal Method"](input.html#the-readexternal-method). Compatibility issues
+caused by this change are discussed in [Section 2.6, "The useProtocolVersion
+Method"](#the-useprotocolversion-method).
+
+## 2.5 The writeReplace Method
+
+For Serializable and Externalizable classes, the `writeReplace` method allows a
+class of an object to nominate its own replacement in the stream before the
+object is written. By implementing the `writeReplace` method, a class can
+directly control the types and instances of its own instances being serialized.
+
+The method is defined as follows:
+
+```
+ANY-ACCESS-MODIFIER Object writeReplace()
+ throws ObjectStreamException;
+```
+
+The `writeReplace` method is called when `ObjectOutputStream` is preparing to
+write the object to the stream. The `ObjectOutputStream` checks whether the
+class defines the `writeReplace` method. If the method is defined, the
+`writeReplace` method is called to allow the object to designate its
+replacement in the stream. The object returned should be either of the same
+type as the object passed in or an object that when read and resolved will
+result in an object of a type that is compatible with all references to the
+object. If it is not, a `ClassCastException` will occur when the type mismatch
+is discovered.
+
+## 2.6 The useProtocolVersion Method
+
+Due to a stream protocol change that was not backwards compatible, a mechanism
+has been added to enable the current Virtual Machine to write a serialization
+stream that is readable by a previous release. Of course, the problems that are
+corrected by the new stream format will exist when using the backwards
+compatible protocol.
+
+Stream protocol versions are discussed in [Section 6.3, "Stream Protocol
+Versions"](protocol.html#stream-protocol-versions).
+
+-------------------------------------------------------------------------------
+
+*[Copyright](../../../legal/SMICopyright.html) © 2005, 2017, Oracle
+and/or its affiliates. All rights reserved.*
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.base/share/specs/serialization/protocol.md Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,504 @@
+---
+# Copyright (c) 2005, 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.
+#
+# 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.
+
+include-before: '[CONTENTS](index.html) | [PREV](version.html) | [NEXT](security.html)'
+include-after: '[CONTENTS](index.html) | [PREV](version.html) | [NEXT](security.html)'
+
+title: 'Java Object Serialization Specification: 6 - Object Serialization Stream Protocol'
+---
+
+- [Overview](#overview)
+- [Stream Elements](#stream-elements)
+- [Stream Protocol Versions](#stream-protocol-versions)
+- [Grammar for the Stream Format](#grammar-for-the-stream-format)
+- [Example](#example)
+
+-------------------------------------------------------------------------------
+
+## 6.1 Overview
+
+The stream format satisfies the following design goals:
+
+- Is compact and is structured for efficient reading.
+- Allows skipping through the stream using only the knowledge of the
+ structure and format of the stream. Does not require invoking any per class
+ code.
+- Requires only stream access to the data.
+
+## 6.2 Stream Elements
+
+A basic structure is needed to represent objects in a stream. Each attribute of
+the object needs to be represented: its classes, its fields, and data written
+and later read by class-specific methods. The representation of objects in the
+stream can be described with a grammar. There are special representations for
+null objects, new objects, classes, arrays, strings, and back references to any
+object already in the stream. Each object written to the stream is assigned a
+handle that is used to refer back to the object. Handles are assigned
+sequentially starting from 0x7E0000. The handles restart at 0x7E0000 when the
+stream is reset.
+
+A class object is represented by the following:
+
+- Its `ObjectStreamClass` object.
+
+An `ObjectStreamClass` object for a Class that is not a dynamic proxy class is
+represented by the following:
+
+- The Stream Unique Identifier (SUID) of compatible classes.
+
+- A set of flags indicating various properties of the class, such as whether
+ the class defines a `writeObject` method, and whether the class is
+ serializable, externalizable, or an enum type
+
+- The number of serializable fields
+
+- The array of fields of the class that are serialized by the default
+ mechanismFor arrays and object fields, the type of the field is included as
+ a string which must be in "field descriptor" format (e.g.,
+ "`Ljava/lang/Object;`") as specified in The Java Virtual Machine
+ Specification.
+
+- Optional block-data records or objects written by the `annotateClass`
+ method
+
+- The `ObjectStreamClass` of its supertype (null if the superclass is not
+ serializable)
+
+An `ObjectStreamClass` object for a dynamic proxy class is represented by the
+following:
+
+- The number of interfaces that the dynamic proxy class implements
+
+- The names of all of the interfaces implemented by the dynamic proxy class,
+ listed in the order that they are returned by invoking the `getInterfaces`
+ method on the Class object.
+
+- Optional block-data records or objects written by the `annotateProxyClass`
+ method.
+
+- The ObjectStreamClass of its supertype, `java.lang.reflect.Proxy`.
+
+The representation of `String` objects consists of length information followed
+by the contents of the string encoded in modified UTF-8. The modified UTF-8
+encoding is the same as used in the Java Virtual Machine and in the
+`java.io.DataInput` and `DataOutput` interfaces; it differs from standard UTF-8
+in the representation of supplementary characters and of the null character.
+The form of the length information depends on the length of the string in
+modified UTF-8 encoding. If the modified UTF-8 encoding of the given `String`
+is less than 65536 bytes in length, the length is written as 2 bytes
+representing an unsigned 16-bit integer. Starting with the Java 2 platform,
+Standard Edition, v1.3, if the length of the string in modified UTF-8 encoding
+is 65536 bytes or more, the length is written in 8 bytes representing a signed
+64-bit integer. The typecode preceding the `String` in the serialization stream
+indicates which format was used to write the `String`.
+
+Arrays are represented by the following:
+
+- Their `ObjectStreamClass` object.
+
+- The number of elements.
+
+- The sequence of values. The type of the values is implicit in the type of
+ the array. for example the values of a byte array are of type byte.
+
+Enum constants are represented by the following:
+
+- The `ObjectStreamClass` object of the constant's base enum type.
+
+- The constant's name string.
+
+New objects in the stream are represented by the following:
+
+- The most derived class of the object.
+
+- Data for each serializable class of the object, with the highest superclass
+ first. For each class the stream contains the following:
+
+ - The serializable fields.See [Section 1.5, "Defining Serializable Fields
+ for a
+ Class"](serial-arch.html#defining-serializable-fields-for-a-class).
+
+ - If the class has `writeObject`/`readObject` methods, there may be
+ optional objects and/or block-data records of primitive types written
+ by the `writeObject` method followed by an `endBlockData` code.
+
+All primitive data written by classes is buffered and wrapped in block-data
+records, regardless if the data is written to the stream within a `writeObject`
+method or written directly to the stream from outside a `writeObject` method.
+This data can only be read by the corresponding `readObject` methods or be read
+directly from the stream. Objects written by the `writeObject` method terminate
+any previous block-data record and are written either as regular objects or
+null or back references, as appropriate. The block-data records allow error
+recovery to discard any optional data. When called from within a class, the
+stream can discard any data or objects until the `endBlockData`.
+
+## 6.3 Stream Protocol Versions
+
+It was necessary to make a change to the serialization stream format in JDK 1.2
+that is not backwards compatible to all minor releases of JDK 1.1. To provide
+for cases where backwards compatibility is required, a capability has been
+added to indicate what `PROTOCOL_VERSION` to use when writing a serialization
+stream. The method `ObjectOutputStream.useProtocolVersion` takes as a parameter
+the protocol version to use to write the serialization stream.
+
+The Stream Protocol Versions are as follows:
+
+- `ObjectStreamConstants.PROTOCOL_VERSION_1`: Indicates the initial stream
+ format.
+
+- `ObjectStreamConstants.PROTOCOL_VERSION_2`: Indicates the new external data
+ format. Primitive data is written in block data mode and is terminated with
+ `TC_ENDBLOCKDATA`.
+
+ Block data boundaries have been standardized. Primitive data written in
+ block data mode is normalized to not exceed 1024 byte chunks. The benefit
+ of this change was to tighten the specification of serialized data format
+ within the stream. This change is fully backward and forward compatible.
+
+JDK 1.2 defaults to writing `PROTOCOL_VERSION_2`.
+
+JDK 1.1 defaults to writing `PROTOCOL_VERSION_1`.
+
+JDK 1.1.7 and greater can read both versions.
+
+Releases prior to JDK 1.1.7 can only read `PROTOCOL_VERSION_1`.
+
+## 6.4 Grammar for the Stream Format
+
+The table below contains the grammar for the stream format. Nonterminal symbols
+are shown in italics. Terminal symbols in a *fixed width font*. Definitions of
+nonterminals are followed by a ":". The definition is followed by one or more
+alternatives, each on a separate line. The following table describes the
+notation:
+
+ ------------- --------------------------------------------------------------
+ **Notation** **Meaning**
+ ------------- --------------------------------------------------------------
+ (*datatype*) This token has the data type specified, such as byte.
+
+ *token*\[n\] A predefined number of occurrences of the token, that is an
+ array.
+
+ *x0001* A literal value expressed in hexadecimal. The number of hex
+ digits reflects the size of the value.
+
+ <*xxx*> A value read from the stream used to indicate the length of an
+ array.
+ ------------- --------------------------------------------------------------
+
+Note that the symbol (utf) is used to designate a string written using 2-byte
+length information, and (long-utf) is used to designate a string written using
+8-byte length information. For details, refer to [Section 6.2, "Stream
+Elements"](#stream-elements).
+
+### 6.4.1 Rules of the Grammar
+
+A Serialized stream is represented by any stream satisfying the *stream* rule.
+
+```
+stream:
+ magic version contents
+
+contents:
+ content
+ contents content
+
+content:
+ object
+ blockdata
+
+object:
+ newObject
+ newClass
+ newArray
+ newString
+ newEnum
+ newClassDesc
+ prevObject
+ nullReference
+ exception
+ TC_RESET
+
+newClass:
+ TC_CLASS classDesc newHandle
+
+classDesc:
+ newClassDesc
+ nullReference
+ (ClassDesc)prevObject // an object required to be of type ClassDesc
+
+superClassDesc:
+ classDesc
+
+newClassDesc:
+ TC_CLASSDESC className serialVersionUID newHandle classDescInfo
+ TC_PROXYCLASSDESC newHandle proxyClassDescInfo
+
+classDescInfo:
+ classDescFlags fields classAnnotation superClassDesc
+
+className:
+ (utf)
+
+serialVersionUID:
+ (long)
+
+classDescFlags:
+ (byte) // Defined in Terminal Symbols and Constants
+
+proxyClassDescInfo:
+ (int)<count> proxyInterfaceName[count] classAnnotation
+ superClassDesc
+
+proxyInterfaceName:
+ (utf)
+
+fields:
+ (short)<count> fieldDesc[count]
+
+fieldDesc:
+ primitiveDesc
+ objectDesc
+
+primitiveDesc:
+ prim_typecode fieldName
+
+objectDesc:
+ obj_typecode fieldName className1
+
+fieldName:
+ (utf)
+
+className1:
+ (String)object // String containing the field's type,
+ // in field descriptor format
+
+classAnnotation:
+ endBlockData
+ contents endBlockData // contents written by annotateClass
+
+prim_typecode:
+ 'B' // byte
+ 'C' // char
+ 'D' // double
+ 'F' // float
+ 'I' // integer
+ 'J' // long
+ 'S' // short
+ 'Z' // boolean
+
+obj_typecode:
+ '[' // array
+ 'L' // object
+
+newArray:
+ TC_ARRAY classDesc newHandle (int)<size> values[size]
+
+newObject:
+ TC_OBJECT classDesc newHandle classdata[] // data for each class
+
+classdata:
+ nowrclass // SC_SERIALIZABLE & classDescFlag &&
+ // !(SC_WRITE_METHOD & classDescFlags)
+ wrclass objectAnnotation // SC_SERIALIZABLE & classDescFlag &&
+ // SC_WRITE_METHOD & classDescFlags
+ externalContents // SC_EXTERNALIZABLE & classDescFlag &&
+ // !(SC_BLOCKDATA & classDescFlags
+ objectAnnotation // SC_EXTERNALIZABLE & classDescFlag&&
+ // SC_BLOCKDATA & classDescFlags
+
+nowrclass:
+ values // fields in order of class descriptor
+
+wrclass:
+ nowrclass
+
+objectAnnotation:
+ endBlockData
+ contents endBlockData // contents written by writeObject
+ // or writeExternal PROTOCOL_VERSION_2.
+
+blockdata:
+ blockdatashort
+ blockdatalong
+
+blockdatashort:
+ TC_BLOCKDATA (unsigned byte)<size> (byte)[size]
+
+blockdatalong:
+ TC_BLOCKDATALONG (int)<size> (byte)[size]
+
+endBlockData:
+ TC_ENDBLOCKDATA
+
+externalContent: // Only parseable by readExternal
+ (bytes) // primitive data
+ object
+
+externalContents: // externalContent written by
+ externalContent // writeExternal in PROTOCOL_VERSION_1.
+ externalContents externalContent
+
+newString:
+ TC_STRING newHandle (utf)
+ TC_LONGSTRING newHandle (long-utf)
+
+newEnum:
+ TC_ENUM classDesc newHandle enumConstantName
+
+enumConstantName:
+ (String)object
+
+prevObject:
+ TC_REFERENCE (int)handle
+
+nullReference:
+ TC_NULL
+
+exception:
+ TC_EXCEPTION reset (Throwable)object reset
+
+magic:
+ STREAM_MAGIC
+
+version:
+ STREAM_VERSION
+
+values: // The size and types are described by the
+ // classDesc for the current object
+
+newHandle: // The next number in sequence is assigned
+ // to the object being serialized or deserialized
+
+reset: // The set of known objects is discarded
+ // so the objects of the exception do not
+ // overlap with the previously sent objects
+ // or with objects that may be sent after
+ // the exception
+```
+
+### 6.4.2 Terminal Symbols and Constants
+
+The following symbols in `java.io.ObjectStreamConstants` define the terminal
+and constant values expected in a stream.
+
+```
+final static short STREAM_MAGIC = (short)0xaced;
+final static short STREAM_VERSION = 5;
+final static byte TC_NULL = (byte)0x70;
+final static byte TC_REFERENCE = (byte)0x71;
+final static byte TC_CLASSDESC = (byte)0x72;
+final static byte TC_OBJECT = (byte)0x73;
+final static byte TC_STRING = (byte)0x74;
+final static byte TC_ARRAY = (byte)0x75;
+final static byte TC_CLASS = (byte)0x76;
+final static byte TC_BLOCKDATA = (byte)0x77;
+final static byte TC_ENDBLOCKDATA = (byte)0x78;
+final static byte TC_RESET = (byte)0x79;
+final static byte TC_BLOCKDATALONG = (byte)0x7A;
+final static byte TC_EXCEPTION = (byte)0x7B;
+final static byte TC_LONGSTRING = (byte) 0x7C;
+final static byte TC_PROXYCLASSDESC = (byte) 0x7D;
+final static byte TC_ENUM = (byte) 0x7E;
+final static int baseWireHandle = 0x7E0000;
+```
+
+The flag byte *classDescFlags* may include values of
+
+```
+final static byte SC_WRITE_METHOD = 0x01; //if SC_SERIALIZABLE
+final static byte SC_BLOCK_DATA = 0x08; //if SC_EXTERNALIZABLE
+final static byte SC_SERIALIZABLE = 0x02;
+final static byte SC_EXTERNALIZABLE = 0x04;
+final static byte SC_ENUM = 0x10;
+```
+
+The flag `SC_WRITE_METHOD` is set if the Serializable class writing the stream
+had a `writeObject` method that may have written additional data to the stream.
+In this case a `TC_ENDBLOCKDATA` marker is always expected to terminate the
+data for that class.
+
+The flag `SC_BLOCKDATA` is set if the `Externalizable` class is written into
+the stream using `STREAM_PROTOCOL_2`. By default, this is the protocol used to
+write `Externalizable` objects into the stream in JDK 1.2. JDK 1.1 writes
+`STREAM_PROTOCOL_1`.
+
+The flag `SC_SERIALIZABLE` is set if the class that wrote the stream extended
+`java.io.Serializable` but not `java.io.Externalizable`, the class reading the
+stream must also extend `java.io.Serializable` and the default serialization
+mechanism is to be used.
+
+The flag `SC_EXTERNALIZABLE` is set if the class that wrote the stream extended
+`java.io.Externalizable`, the class reading the data must also extend
+`Externalizable` and the data will be read using its `writeExternal` and
+`readExternal` methods.
+
+The flag `SC_ENUM` is set if the class that wrote the stream was an enum type.
+The receiver's corresponding class must also be an enum type. Data for
+constants of the enum type will be written and read as described in [Section
+1.12, "Serialization of Enum
+Constants"](serial-arch.html#serialization-of-enum-constants).
+
+#### Example
+
+Consider the case of an original class and two instances in a linked list:
+
+```
+class List implements java.io.Serializable {
+ int value;
+ List next;
+ public static void main(String[] args) {
+ try {
+ List list1 = new List();
+ List list2 = new List();
+ list1.value = 17;
+ list1.next = list2;
+ list2.value = 19;
+ list2.next = null;
+
+ ByteArrayOutputStream o = new ByteArrayOutputStream();
+ ObjectOutputStream out = new ObjectOutputStream(o);
+ out.writeObject(list1);
+ out.writeObject(list2);
+ out.flush();
+ ...
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ }
+ }
+}
+```
+
+The resulting stream contains:
+
+```
+ 00: ac ed 00 05 73 72 00 04 4c 69 73 74 69 c8 8a 15 >....sr..Listi...<
+ 10: 40 16 ae 68 02 00 02 49 00 05 76 61 6c 75 65 4c >Z......I..valueL<
+ 20: 00 04 6e 65 78 74 74 00 06 4c 4c 69 73 74 3b 78 >..nextt..LList;x<
+ 30: 70 00 00 00 11 73 71 00 7e 00 00 00 00 00 13 70 >p....sq.~......p<
+ 40: 71 00 7e 00 03 >q.~..<
+```
+
+-------------------------------------------------------------------------------
+
+*[Copyright](../../../legal/SMICopyright.html) © 2005, 2017, Oracle
+and/or its affiliates. All rights reserved.*
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.base/share/specs/serialization/security.md Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,38 @@
+---
+# Copyright (c) 2005, 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.
+#
+# 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.
+
+include-before: '[CONTENTS](index.html) | [PREV](protocol.html) | [NEXT](exceptions.html)'
+include-after: '[CONTENTS](index.html) | [PREV](protocol.html) | [NEXT](exceptions.html)'
+
+title: 'Java Object Serialization Specification: A - Security in Object Serialization'
+---
+
+-------------------------------------------------------------------------------
+
+Refer to the [Secure Coding Guidelines for the Java Programming
+Language](http://www.oracle.com/technetwork/java/seccodeguide-139067.html) for
+information about security in object serialization.
+
+-------------------------------------------------------------------------------
+
+*[Copyright](../../../legal/SMICopyright.html) © 2005, 2017, Oracle
+and/or its affiliates. All rights reserved.*
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.base/share/specs/serialization/serial-arch.md Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,575 @@
+---
+# Copyright (c) 2005, 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.
+#
+# 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.
+
+include-before: '[CONTENTS](index.html) | [PREV](changelog.html) | [NEXT](output.html)'
+include-after: '[CONTENTS](index.html) | [PREV](changelog.html) | [NEXT](output.html)'
+
+title: 'Java Object Serialization Specification: 1 - System Architecture'
+---
+
+- [Overview](#overview)
+- [Writing to an Object Stream](#writing-to-an-object-stream)
+- [Reading from an Object Stream](#reading-from-an-object-stream)
+- [Object Streams as Containers](#object-streams-as-containers)
+- [Defining Serializable Fields for a
+ Class](#defining-serializable-fields-for-a-class)
+- [Documenting Serializable Fields and Data for a
+ Class](#documenting-serializable-fields-and-data-for-a-class)
+- [Accessing Serializable Fields of a
+ Class](#accessing-serializable-fields-of-a-class)
+- [The ObjectOutput Interface](#the-objectoutput-interface)
+- [The ObjectInput Interface](#the-objectinput-interface)
+- [The Serializable Interface](#the-serializable-interface)
+- [The Externalizable Interface](#the-externalizable-interface)
+- [Serialization of Enum Constants](#serialization-of-enum-constants)
+- [Protecting Sensitive Information](#protecting-sensitive-information)
+
+-------------------------------------------------------------------------------
+
+## 1.1 Overview
+
+The ability to store and retrieve Java^TM^ objects is essential to building all
+but the most transient applications. The key to storing and retrieving objects
+in a serialized form is representing the state of objects sufficient to
+reconstruct the object(s). Objects to be saved in the stream may support either
+the `Serializable` or the `Externalizable` interface. For Java^TM^ objects, the
+serialized form must be able to identify and verify the Java^TM^ class from
+which the contents of the object were saved and to restore the contents to a
+new instance. For serializable objects, the stream includes sufficient
+information to restore the fields in the stream to a compatible version of the
+class. For Externalizable objects, the class is solely responsible for the
+external format of its contents.
+
+Objects to be stored and retrieved frequently refer to other objects. Those
+other objects must be stored and retrieved at the same time to maintain the
+relationships between the objects. When an object is stored, all of the objects
+that are reachable from that object are stored as well.
+
+The goals for serializing Java^TM^ objects are to:
+
+- Have a simple yet extensible mechanism.
+- Maintain the Java^TM^ object type and safety properties in the serialized
+ form.
+- Be extensible to support marshaling and unmarshaling as needed for remote
+ objects.
+- Be extensible to support simple persistence of Java^TM^ objects.
+- Require per class implementation only for customization.
+- Allow the object to define its external format.
+
+## 1.2 Writing to an Object Stream
+
+Writing objects and primitives to a stream is a straightforward process. For
+example:
+
+```
+// Serialize today's date to a file.
+ FileOutputStream f = new FileOutputStream("tmp");
+ ObjectOutput s = new ObjectOutputStream(f);
+ s.writeObject("Today");
+ s.writeObject(new Date());
+ s.flush();
+```
+
+First an `OutputStream`, in this case a `FileOutputStream`, is needed to
+receive the bytes. Then an `ObjectOutputStream` is created that writes to the
+`FileOutputStream`. Next, the string "Today" and a Date object are written to
+the stream. More generally, objects are written with the `writeObject` method
+and primitives are written to the stream with the methods of `DataOutput`.
+
+The `writeObject` method (see [Section 2.3, "The writeObject
+Method"](output.html#the-writeobject-method)) serializes the specified object
+and traverses its references to other objects in the object graph recursively
+to create a complete serialized representation of the graph. Within a stream,
+the first reference to any object results in the object being serialized or
+externalized and the assignment of a handle for that object. Subsequent
+references to that object are encoded as the handle. Using object handles
+preserves sharing and circular references that occur naturally in object
+graphs. Subsequent references to an object use only the handle allowing a very
+compact representation.
+
+Special handling is required for arrays, enum constants, and objects of type
+`Class`, `ObjectStreamClass`, and `String`. Other objects must implement either
+the `Serializable` or the `Externalizable` interface to be saved in or restored
+from a stream.
+
+Primitive data types are written to the stream with the methods in the
+`DataOutput` interface, such as `writeInt`, `writeFloat`, or `writeUTF`.
+Individual bytes and arrays of bytes are written with the methods of
+`OutputStream`. Except for serializable fields, primitive data is written to
+the stream in block-data records, with each record prefixed by a marker and an
+indication of the number of bytes in the record.
+
+`ObjectOutputStream` can be extended to customize the information about classes
+in the stream or to replace objects to be serialized. Refer to the
+`annotateClass` and `replaceObject` method descriptions for details.
+
+## 1.3 Reading from an Object Stream
+
+Reading an object from a stream, like writing, is straightforward:
+
+```
+// Deserialize a string and date from a file.
+ FileInputStream in = new FileInputStream("tmp");
+ ObjectInputStream s = new ObjectInputStream(in);
+ String today = (String)s.readObject();
+ Date date = (Date)s.readObject();
+```
+
+First an `InputStream`, in this case a `FileInputStream`, is needed as the
+source stream. Then an `ObjectInputStream` is created that reads from the
+`InputStream`. Next, the string "Today" and a Date object are read from the
+stream. Generally, objects are read with the `readObject` method and primitives
+are read from the stream with the methods of `DataInput`.
+
+The `readObject` method deserializes the next object in the stream and
+traverses its references to other objects recursively to create the complete
+graph of objects serialized.
+
+Primitive data types are read from the stream with the methods in the
+`DataInput` interface, such as `readInt`, `readFloat`, or `readUTF`. Individual
+bytes and arrays of bytes are read with the methods of `InputStream`. Except
+for serializable fields, primitive data is read from block-data records.
+
+`ObjectInputStream` can be extended to utilize customized information in the
+stream about classes or to replace objects that have been deserialized. Refer
+to the `resolveClass` and `resolveObject` method descriptions for details.
+
+## 1.4 Object Streams as Containers
+
+Object Serialization produces and consumes a stream of bytes that contain one
+or more primitives and objects. The objects written to the stream, in turn,
+refer to other objects, which are also represented in the stream. Object
+Serialization produces just one stream format that encodes and stores the
+contained objects.
+
+Each object that acts as a container implements an interface which allows
+primitives and objects to be stored in or retrieved from it. These interfaces
+are the `ObjectOutput` and `ObjectInput` interfaces which:
+
+- Provide a stream to write to and to read from
+- Handle requests to write primitive types and objects to the stream
+- Handle requests to read primitive types and objects from the stream
+
+Each object which is to be stored in a stream must explicitly allow itself to
+be stored and must implement the protocols needed to save and restore its
+state. Object Serialization defines two such protocols. The protocols allow the
+container to ask the object to write and read its state.
+
+To be stored in an Object Stream, each object must implement either the
+`Serializable` or the `Externalizable` interface:
+
+- For a `Serializable` class, Object Serialization can automatically save and
+ restore fields of each class of an object and automatically handle classes
+ that evolve by adding fields or supertypes. A serializable class can
+ declare which of its fields are saved or restored, and write and read
+ optional values and objects.
+
+- For an `Externalizable` class, Object Serialization delegates to the class
+ complete control over its external format and how the state of the
+ supertype(s) is saved and restored.
+
+## 1.5 Defining Serializable Fields for a Class
+
+The serializable fields of a class can be defined two different ways. Default
+serializable fields of a class are defined to be the non-transient and
+non-static fields. This default computation can be overridden by declaring a
+special field in the `Serializable` class, `serialPersistentFields`. This field
+must be initialized with an array of `ObjectStreamField` objects that list the
+names and types of the serializable fields. The modifiers for the field are
+required to be private, static, and final. If the field's value is null or is
+otherwise not an instance of `ObjectStreamField[]`, or if the field does not
+have the required modifiers, then the behavior is as if the field were not
+declared at all.
+
+For example, the following declaration duplicates the default behavior.
+
+```
+class List implements Serializable {
+ List next;
+
+ private static final ObjectStreamField[] serialPersistentFields
+ = {new ObjectStreamField("next", List.class)};
+
+}
+```
+
+By using `serialPersistentFields` to define the Serializable fields for a
+class, there no longer is a limitation that a serializable field must be a
+field within the current definition of the `Serializable` class. The
+`writeObject` and `readObject` methods of the `Serializable` class can map the
+current implementation of the class to the serializable fields of the class
+using the interface that is described in [Section 1.7, "Accessing Serializable
+Fields of a Class"](#accessing-serializable-fields-of-a-class). Therefore, the
+fields for a `Serializable` class can change in a later release, as long as it
+maintains the mapping back to its Serializable fields that must remain
+compatible across release boundaries.
+
+**Note:** There is, however, a limitation to the use of this mechanism to
+specify serializable fields for inner classes. Inner classes can only contain
+final static fields that are initialized to constants or expressions built up
+from constants. Consequently, it is not possible to set
+`serialPersistentFields` for an inner class (though it is possible to set it
+for static member classes). For other restrictions pertaining to serialization
+of inner class instances, see section [Section 1.10, "The Serializable
+Interface"](#the-serializable-interface).
+
+## 1.6 Documenting Serializable Fields and Data for a Class
+
+It is important to document the serializable state of a class to enable
+interoperability with alternative implementations of a Serializable class and
+to document class evolution. Documenting a serializable field gives one a final
+opportunity to review whether or not the field should be serializable. The
+serialization javadoc tags, `@serial`, `@serialField`, and `@serialData`,
+provide a way to document the serialized form for a Serializable class within
+the source code.
+
+- The `@serial` tag should be placed in the javadoc comment for a default
+ serializable field. The syntax is as follows: `@serial` *field-description*
+ The optional *field-description* describes the meaning of the field and its
+ acceptable values. The *field-description* can span multiple lines. When a
+ field is added after the initial release, a *@since* tag indicates the
+ version the field was added. The *field-description* for `@serial` provides
+ serialization-specific documentation and is appended to the javadoc comment
+ for the field within the serialized form documentation.
+
+- The `@serialField` tag is used to document an `ObjectStreamField` component
+ of a `serialPersistentFields` array. One of these tags should be used for
+ each `ObjectStreamField` component. The syntax is as follows:
+ `@serialField` *field-name field-type field-description*
+
+- The `@serialData` tag describes the sequences and types of data written or
+ read. The tag describes the sequence and type of optional data written by
+ `writeObject` or all data written by the `Externalizable.writeExternal`
+ method. The syntax is as follows: `@serialData` *data-description*
+
+The javadoc application recognizes the serialization javadoc tags and generates
+a specification for each Serializable and Externalizable class. See [Section
+C.1, "Example Alternate Implementation of
+java.io.File"](examples.html#c.1-example-alternate-implementation-of-java.io.file)
+for an example that uses these tags.
+
+When a class is declared Serializable, the serializable state of the object is
+defined by serializable fields (by name and type) plus optional data. Optional
+data can only be written explicitly by the `writeObject` method of a
+`Serializable` class. Optional data can be read by the `Serializable` class'
+`readObject` method or serialization will skip unread optional data.
+
+When a class is declared Externalizable, the data that is written to the stream
+by the class itself defines the serialized state. The class must specify the
+order, types, and meaning of each datum that is written to the stream. The
+class must handle its own evolution, so that it can continue to read data
+written by and write data that can be read by previous versions. The class must
+coordinate with the superclass when saving and restoring data. The location of
+the superclasses data in the stream must be specified.
+
+The designer of a Serializable class must ensure that the information saved for
+the class is appropriate for persistence and follows the
+serialization-specified rules for interoperability and evolution. Class
+evolution is explained in greater detail in [Chapter
+5](version.html#versioning-of-serializable-objects), "Versioning of
+Serializable Objects".
+
+## 1.7 Accessing Serializable Fields of a Class
+
+Serialization provides two mechanisms for accessing the serializable fields in
+a stream:
+
+- The default mechanism requires no customization
+- The Serializable Fields API allows a class to explicitly access/set the
+ serializable fields by name and type
+
+The default mechanism is used automatically when reading or writing objects
+that implement the `Serializable` interface and do no further customization.
+The serializable fields are mapped to the corresponding fields of the class and
+values are either written to the stream from those fields or are read in and
+assigned respectively. If the class provides `writeObject` and `readObject`
+methods, the default mechanism can be invoked by calling `defaultWriteObject`
+and `defaultReadObject`. When the `writeObject` and `readObject` methods are
+implemented, the class has an opportunity to modify the serializable field
+values before they are written or after they are read.
+
+When the default mechanism cannot be used, the serializable class can use the
+`putFields` method of `ObjectOutputStream` to put the values for the
+serializable fields into the stream. The `writeFields` method of
+`ObjectOutputStream` puts the values in the correct order, then writes them to
+the stream using the existing protocol for serialization. Correspondingly, the
+`readFields` method of `ObjectInputStream` reads the values from the stream and
+makes them available to the class by name in any order. See [Section 2.2, "The
+ObjectOutputStream.PutField
+Class"](output.html#the-objectoutputstream.putfield-class) and [Section 3.2,
+"The ObjectInputStream.GetField
+Class"](input.html#the-objectinputstream.getfield-class) for a detailed
+description of the Serializable Fields API.
+
+## 1.8 The ObjectOutput Interface
+
+The `ObjectOutput` interface provides an abstract, stream-based interface to
+object storage. It extends the DataOutput interface so those methods can be
+used for writing primitive data types. Objects that implement this interface
+can be used to store primitives and objects.
+
+```
+package java.io;
+
+public interface ObjectOutput extends DataOutput
+{
+ public void writeObject(Object obj) throws IOException;
+ public void write(int b) throws IOException;
+ public void write(byte b[]) throws IOException;
+ public void write(byte b[], int off, int len) throws IOException;
+ public void flush() throws IOException;
+ public void close() throws IOException;
+}
+```
+
+`The` `writeObject` method is used to write an object. The exceptions thrown
+reflect errors while accessing the object or its fields, or exceptions that
+occur in writing to storage. If any exception is thrown, the underlying storage
+may be corrupted. If this occurs, refer to the object that is implementing this
+interface for more information.
+
+## 1.9 The ObjectInput Interface
+
+The `ObjectInput` interface provides an abstract stream based interface to
+object retrieval. It extends the `DataInput` interface so those methods for
+reading primitive data types are accessible in this interface.
+
+```
+package java.io;
+
+public interface ObjectInput extends DataInput
+{
+ public Object readObject()
+ throws ClassNotFoundException, IOException;
+ public int read() throws IOException;
+ public int read(byte b[]) throws IOException;
+ public int read(byte b[], int off, int len) throws IOException;
+ public long skip(long n) throws IOException;
+ public int available() throws IOException;
+ public void close() throws IOException;
+}
+```
+
+The `readObject` method is used to read and return an object. The exceptions
+thrown reflect errors while accessing the objects or its fields or exceptions
+that occur in reading from the storage. If any exception is thrown, the
+underlying storage may be corrupted. If this occurs, refer to the object
+implementing this interface for additional information.
+
+## 1.10 The Serializable Interface
+
+Object Serialization produces a stream with information about the Java^TM^
+classes for the objects which are being saved. For serializable objects,
+sufficient information is kept to restore those objects even if a different
+(but compatible) version of the implementation of the class is present. The
+`Serializable` interface is defined to identify classes which implement the
+serializable protocol:
+
+```
+package java.io;
+
+public interface Serializable {};
+```
+
+A Serializable class must do the following:
+
+- Implement the `java.io.Serializable` interface
+
+- Identify the fields that should be serializable
+
+ (Use the `serialPersistentFields` member to explicitly declare them
+ serializable or use the transient keyword to denote nonserializable
+ fields.)
+
+- Have access to the no-arg constructor of its first nonserializable
+ superclass
+
+The class can optionally define the following methods:
+
+- A `writeObject` method to control what information is saved or to append
+ additional information to the stream
+
+- A `readObject` method either to read the information written by the
+ corresponding `writeObject` method or to update the state of the object
+ after it has been restored
+
+- A `writeReplace` method to allow a class to nominate a replacement object
+ to be written to the stream
+
+ (See [Section 2.5, "The writeReplace
+ Method"](output.html#the-writereplace-method) for additional information.)
+
+- A `readResolve` method to allow a class to designate a replacement object
+ for the object just read from the stream
+
+ (See [Section 3.7, "The readResolve
+ Method](input.html#the-readresolve-method) for additional information.)
+
+`ObjectOutputStream` and `ObjectInputStream` allow the serializable classes on
+which they operate to evolve (allow changes to the classes that are compatible
+with the earlier versions of the classes). See [Section 5.5, "Compatible Java
+Type Evolution"](version.html#compatible-java-type-evolution) for information
+about the mechanism which is used to allow compatible changes.
+
+**Note:** Serialization of inner classes (i.e., nested classes that are not
+static member classes), including local and anonymous classes, is strongly
+discouraged for several reasons. Because inner classes declared in non-static
+contexts contain implicit non-transient references to enclosing class
+instances, serializing such an inner class instance will result in
+serialization of its associated outer class instance as well. Synthetic fields
+generated by `javac` (or other Java^TM^ compilers) to implement inner classes
+are implementation dependent and may vary between compilers; differences in
+such fields can disrupt compatibility as well as result in conflicting default
+`serialVersionUID` values. The names assigned to local and anonymous inner
+classes are also implementation dependent and may differ between compilers.
+Since inner classes cannot declare static members other than compile-time
+constant fields, they cannot use the `serialPersistentFields` mechanism to
+designate serializable fields. Finally, because inner classes associated with
+outer instances do not have zero-argument constructors (constructors of such
+inner classes implicitly accept the enclosing instance as a prepended
+parameter), they cannot implement `Externalizable`. None of the issues listed
+above, however, apply to static member classes.
+
+## 1.11 The Externalizable Interface
+
+For Externalizable objects, only the identity of the class of the object is
+saved by the container; the class must save and restore the contents. The
+`Externalizable` interface is defined as follows:
+
+```
+package java.io;
+
+public interface Externalizable extends Serializable
+{
+ public void writeExternal(ObjectOutput out)
+ throws IOException;
+
+ public void readExternal(ObjectInput in)
+ throws IOException, java.lang.ClassNotFoundException;
+}
+```
+
+The class of an Externalizable object must do the following:
+
+- Implement the `java.io.Externalizable` interface
+
+- Implement a `writeExternal` method to save the state of the object
+
+ (It must explicitly coordinate with its supertype to save its state.)
+
+- Implement a `readExternal` method to read the data written by the
+ `writeExternal` method from the stream and restore the state of the object
+
+ (It must explicitly coordinate with the supertype to save its state.)
+
+- Have the `writeExternal` and `readExternal` methods be solely responsible
+ for the format, if an externally defined format is written
+
+ **Note:** The `writeExternal` and `readExternal` methods are public and
+ raise the risk that a client may be able to write or read information in
+ the object other than by using its methods and fields. These methods must
+ be used only when the information held by the object is not sensitive or
+ when exposing it does not present a security risk.
+
+- Have a public no-arg constructor
+
+ **Note:** Inner classes associated with enclosing instances cannot have
+ no-arg constructors, since constructors of such classes implicitly accept
+ the enclosing instance as a prepended parameter. Consequently the
+ `Externalizable` interface mechanism cannot be used for inner classes and
+ they should implement the `Serializable` interface, if they must be
+ serialized. Several limitations exist for serializable inner classes as
+ well, however; see [Section 1.10, "The Serializable
+ Interface"](#the-serializable-interface), for a full enumeration.
+
+An Externalizable class can optionally define the following methods:
+
+- A `writeReplace` method to allow a class to nominate a replacement object
+ to be written to the stream
+
+ (See [Section 2.5, "The writeReplace
+ Method"](output.html#the-writereplace-method) for additional information.)
+
+- A `readResolve` method to allow a class to designate a replacement object
+ for the object just read from the stream
+
+ (See [Section 3.7, "The readResolve
+ Method"](input.html#the-readresolve-method) for additional information.)
+
+## 1.12 Serialization of Enum Constants
+
+Enum constants are serialized differently than ordinary serializable or
+externalizable objects. The serialized form of an enum constant consists solely
+of its name; field values of the constant are not present in the form. To
+serialize an enum constant, `ObjectOutputStream` writes the value returned by
+the enum constant's `name` method. To deserialize an enum constant,
+`ObjectInputStream` reads the constant name from the stream; the deserialized
+constant is then obtained by calling the `java.lang.Enum.valueOf` method,
+passing the constant's enum type along with the received constant name as
+arguments. Like other serializable or externalizable objects, enum constants
+can function as the targets of back references appearing subsequently in the
+serialization stream.
+
+The process by which enum constants are serialized cannot be customized: any
+class-specific `writeObject`, `readObject`, `readObjectNoData`, `writeReplace`,
+and `readResolve` methods defined by enum types are ignored during
+serialization and deserialization. Similarly, any `serialPersistentFields` or
+`serialVersionUID` field declarations are also ignored--all enum types have a
+fixed `serialVersionUID` of `0L`. Documenting serializable fields and data for
+enum types is unnecessary, since there is no variation in the type of data
+sent.
+
+## 1.13 Protecting Sensitive Information
+
+When developing a class that provides controlled access to resources, care must
+be taken to protect sensitive information and functions. During
+deserialization, the private state of the object is restored. For example, a
+file descriptor contains a handle that provides access to an operating system
+resource. Being able to forge a file descriptor would allow some forms of
+illegal access, since restoring state is done from a stream. Therefore, the
+serializing runtime must take the conservative approach and not trust the
+stream to contain only valid representations of objects. To avoid compromising
+a class, the sensitive state of an object must not be restored from the stream,
+or it must be reverified by the class. Several techniques are available to
+protect sensitive data in classes.
+
+The easiest technique is to mark fields that contain sensitive data as *private
+transient*. Transient fields are not persistent and will not be saved by any
+persistence mechanism. Marking the field will prevent the state from appearing
+in the stream and from being restored during deserialization. Since writing and
+reading (of private fields) cannot be superseded outside of the class, the
+transient fields of the class are safe.
+
+Particularly sensitive classes should not be serialized at all. To accomplish
+this, the object should not implement either the `Serializable` or the
+`Externalizable` interface.
+
+Some classes may find it beneficial to allow writing and reading but
+specifically handle and revalidate the state as it is deserialized. The class
+should implement `writeObject` and `readObject` methods to save and restore
+only the appropriate state. If access should be denied, throwing a
+`NotSerializableException` will prevent further access.
+
+-------------------------------------------------------------------------------
+
+*[Copyright](../../../legal/SMICopyright.html) © 2005, 2017, Oracle
+and/or its affiliates. All rights reserved.*
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.base/share/specs/serialization/version.md Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,304 @@
+---
+# Copyright (c) 2005, 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.
+#
+# 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.
+
+include-before: '[CONTENTS](index.html) | [PREV](class.html) | [NEXT](protocol.html)'
+include-after: '[CONTENTS](index.html) | [PREV](class.html) | [NEXT](protocol.html)'
+
+title: 'Java Object Serialization Specification: 5 - Versioning of Serializable Objects'
+---
+
+- [Overview](#overview)
+- [Goals](#goals)
+- [Assumptions](#assumptions)
+- [Who's Responsible for Versioning of
+ Streams](#whos-responsible-for-versioning-of-streams)
+- [Compatible Java Type Evolution](#compatible-java-type-evolution)
+- [Type Changes Affecting
+ Serialization](#type-changes-affecting-serialization)
+
+-------------------------------------------------------------------------------
+
+## 5.1 Overview
+
+When Java objects use serialization to save state in files, or as blobs in
+databases, the potential arises that the version of a class reading the data is
+different than the version that wrote the data.
+
+Versioning raises some fundamental questions about the identity of a class,
+including what constitutes a compatible change. A ***compatible change*** is a
+change that does not affect the contract between the class and its callers.
+
+This section describes the goals, assumptions, and a solution that attempts to
+address this problem by restricting the kinds of changes allowed and by
+carefully choosing the mechanisms.
+
+The proposed solution provides a mechanism for "automatic" handling of classes
+that evolve by adding fields and adding classes. Serialization will handle
+versioning without class-specific methods to be implemented for each version.
+The stream format can be traversed without invoking class-specific methods.
+
+## 5.2 Goals
+
+The goals are to:
+
+- Support bidirectional communication between different versions of a class
+ operating in different virtual machines by:
+
+ - Defining a mechanism that allows Java classes to read streams written
+ by older versions of the same class.
+
+ - Defining a mechanism that allows Java classes to write streams intended
+ to be read by older versions of the same class.
+
+- Provide default serialization for persistence and for RMI.
+
+- Perform well and produce compact streams in simple cases, so that RMI can
+ use serialization.
+
+- Be able to identify and load classes that match the exact class used to
+ write the stream.
+
+- Keep the overhead low for nonversioned classes.
+
+- Use a stream format that allows the traversal of the stream without having
+ to invoke methods specific to the objects saved in the stream.
+
+## 5.3 Assumptions
+
+The assumptions are that:
+
+- Versioning will only apply to serializable classes since it must control
+ the stream format to achieve it goals. Externalizable classes will be
+ responsible for their own versioning which is tied to the external format.
+
+- All data and objects must be read from, or skipped in, the stream in the
+ same order as they were written.
+
+- Classes evolve individually as well as in concert with supertypes and
+ subtypes.
+
+- Classes are identified by name. Two classes with the same name may be
+ different versions or completely different classes that can be
+ distinguished only by comparing their interfaces or by comparing hashes of
+ the interfaces.
+
+- Default serialization will not perform any type conversions.
+
+- The stream format only needs to support a linear sequence of type changes,
+ not arbitrary branching of a type.
+
+## 5.4 Who's Responsible for Versioning of Streams
+
+In the evolution of classes, it is the responsibility of the evolved (later
+version) class to maintain the contract established by the nonevolved class.
+This takes two forms. First, the evolved class must not break the existing
+assumptions about the interface provided by the original version, so that the
+evolved class can be used in place of the original. Secondly, when
+communicating with the original (or previous) versions, the evolved class must
+provide sufficient and equivalent information to allow the earlier version to
+continue to satisfy the nonevolved contract.
+
+> 
+
+For the purposes of the discussion here, each class implements and extends the
+interface or contract defined by its supertype. New versions of a class, for
+example `foo'`, must continue to satisfy the contract for `foo` and may extend
+the interface or modify its implementation.
+
+Communication between objects via serialization is not part of the contract
+defined by these interfaces. Serialization is a private protocol between the
+implementations. It is the responsibility of the implementations to communicate
+sufficiently to allow each implementation to continue to satisfy the contract
+expected by its clients.
+
+## 5.5 Compatible Java Type Evolution
+
+The Java Language Specification discusses binary compatibility of Java classes
+as those classes evolve. Most of the flexibility of binary compatibility comes
+from the use of late binding of symbolic references for the names of classes,
+interfaces, fields, methods, and so on.
+
+The following are the principle aspects of the design for versioning of
+serialized object streams.
+
+- The default serialization mechanism will use a symbolic model for binding
+ the fields in the stream to the fields in the corresponding class in the
+ virtual machine.
+
+- Each class referenced in the stream will uniquely identify itself, its
+ supertype, and the types and names of each serializable field written to
+ the stream. The fields are ordered with the primitive types first sorted by
+ field name, followed by the object fields sorted by field name.
+
+- Two types of data may occur in the stream for each class: required data
+ (corresponding directly to the serializable fields of the object); and
+ optional data (consisting of an arbitrary sequence of primitives and
+ objects). The stream format defines how the required and optional data
+ occur in the stream so that the whole class, the required, or the optional
+ parts can be skipped if necessary.
+
+ - The required data consists of the fields of the object in the order
+ defined by the class descriptor.
+
+ - The optional data is written to the stream and does not correspond
+ directly to fields of the class. The class itself is responsible for
+ the length, types, and versioning of this optional information.
+
+- If defined for a class, the `writeObject`/`readObject` methods supersede
+ the default mechanism to write/read the state of the class. These methods
+ write and read the optional data for a class. The required data is written
+ by calling `defaultWriteObject` and read by calling `defaultReadObject`.
+
+- The stream format of each class is identified by the use of a Stream Unique
+ Identifier (SUID). By default, this is the hash of the class. All later
+ versions of the class must declare the Stream Unique Identifier (SUID) that
+ they are compatible with. This guards against classes with the same name
+ that might inadvertently be identified as being versions of a single class.
+
+- Subtypes of `ObjectOutputStream` and `ObjectInputStream` may include their
+ own information identifying the class using the `annotateClass` method; for
+ example, `MarshalOutputStream` embeds the URL of the class.
+
+## 5.6 Type Changes Affecting Serialization
+
+With these concepts, we can now describe how the design will cope with the
+different cases of an evolving class. The cases are described in terms of a
+stream written by some version of a class. When the stream is read back by the
+same version of the class, there is no loss of information or functionality.
+The stream is the only source of information about the original class. Its
+class descriptions, while a subset of the original class description, are
+sufficient to match up the data in the stream with the version of the class
+being reconstituted.
+
+The descriptions are from the perspective of the stream being read in order to
+reconstitute either an earlier or later version of the class. In the parlance
+of RPC systems, this is a "receiver makes right" system. The writer writes its
+data in the most suitable form and the receiver must interpret that information
+to extract the parts it needs and to fill in the parts that are not available.
+
+### 5.6.1 Incompatible Changes
+
+Incompatible changes to classes are those changes for which the guarantee of
+interoperability cannot be maintained. The incompatible changes that may occur
+while evolving a class are:
+
+- Deleting fields - If a field is deleted in a class, the stream written will
+ not contain its value. When the stream is read by an earlier class, the
+ value of the field will be set to the default value because no value is
+ available in the stream. However, this default value may adversely impair
+ the ability of the earlier version to fulfill its contract.
+
+- Moving classes up or down the hierarchy - This cannot be allowed since the
+ data in the stream appears in the wrong sequence.
+
+- Changing a nonstatic field to static or a nontransient field to transient -
+ When relying on default serialization, this change is equivalent to
+ deleting a field from the class. This version of the class will not write
+ that data to the stream, so it will not be available to be read by earlier
+ versions of the class. As when deleting a field, the field of the earlier
+ version will be initialized to the default value, which can cause the class
+ to fail in unexpected ways.
+
+- Changing the declared type of a primitive field - Each version of the class
+ writes the data with its declared type. Earlier versions of the class
+ attempting to read the field will fail because the type of the data in the
+ stream does not match the type of the field.
+
+- Changing the `writeObject` or `readObject` method so that it no longer
+ writes or reads the default field data or changing it so that it attempts
+ to write it or read it when the previous version did not. The default field
+ data must consistently either appear or not appear in the stream.
+
+- Changing a class from `Serializable` to `Externalizable` or vice versa is
+ an incompatible change since the stream will contain data that is
+ incompatible with the implementation of the available class.
+
+- Changing a class from a non-enum type to an enum type or vice versa since
+ the stream will contain data that is incompatible with the implementation
+ of the available class.
+
+- Removing either `Serializable` or `Externalizable` is an incompatible
+ change since when written it will no longer supply the fields needed by
+ older versions of the class.
+
+- Adding the `writeReplace` or `readResolve` method to a class is
+ incompatible if the behavior would produce an object that is incompatible
+ with any older version of the class.
+
+### 5.6.2 Compatible Changes
+
+The compatible changes to a class are handled as follows:
+
+- Adding fields - When the class being reconstituted has a field that does
+ not occur in the stream, that field in the object will be initialized to
+ the default value for its type. If class-specific initialization is needed,
+ the class may provide a readObject method that can initialize the field to
+ nondefault values.
+
+- Adding classes - The stream will contain the type hierarchy of each object
+ in the stream. Comparing this hierarchy in the stream with the current
+ class can detect additional classes. Since there is no information in the
+ stream from which to initialize the object, the class's fields will be
+ initialized to the default values.
+
+- Removing classes - Comparing the class hierarchy in the stream with that of
+ the current class can detect that a class has been deleted. In this case,
+ the fields and objects corresponding to that class are read from the
+ stream. Primitive fields are discarded, but the objects referenced by the
+ deleted class are created, since they may be referred to later in the
+ stream. They will be garbage-collected when the stream is garbage-collected
+ or reset.
+
+- Adding `writeObject`/`readObject` methods - If the version reading the
+ stream has these methods then `readObject` is expected, as usual, to read
+ the required data written to the stream by the default serialization. It
+ should call `defaultReadObject` first before reading any optional data. The
+ `writeObject` method is expected as usual to call `defaultWriteObject` to
+ write the required data and then may write optional data.
+
+- Removing `writeObject`/`readObject` methods - If the class reading the
+ stream does not have these methods, the required data will be read by
+ default serialization, and the optional data will be discarded.
+
+- Adding `java.io.Serializable` - This is equivalent to adding types. There
+ will be no values in the stream for this class so its fields will be
+ initialized to default values. The support for subclassing nonserializable
+ classes requires that the class's supertype have a no-arg constructor and
+ the class itself will be initialized to default values. If the no-arg
+ constructor is not available, the `InvalidClassException` is thrown.
+
+- Changing the access to a field - The access modifiers public, package,
+ protected, and private have no effect on the ability of serialization to
+ assign values to the fields.
+
+- Changing a field from static to nonstatic or transient to nontransient -
+ When relying on default serialization to compute the serializable fields,
+ this change is equivalent to adding a field to the class. The new field
+ will be written to the stream but earlier classes will ignore the value
+ since serialization will not assign values to static or transient fields.
+
+-------------------------------------------------------------------------------
+
+*[Copyright](../../../legal/SMICopyright.html) © 2005, 2017, Oracle
+and/or its affiliates. All rights reserved.*
--- a/jdk/src/java.management/share/classes/mgmt-overview.html Mon Apr 24 07:10:37 2017 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,38 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
-<html>
- <head>
- <title>Monitoring and Management</title>
-
-<!--
-
-Copyright (c) 2004, 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.
--->
-
- </head>
-<body bgcolor="white">
-
-
- </body>
-</html>
-
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.management/share/specs/JVM-MANAGEMENT-MIB.mib Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,3266 @@
+--
+--
+--
+-- Copyright (c) 2004, 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.
+--
+--
+-- The JVM-MANAGEMENT-MIB Module
+--
+-- See jvmManagementMIB MODULE-IDENTITY for a description overview.
+-- See conformance statements for mandatory objects
+--
+
+JVM-MANAGEMENT-MIB DEFINITIONS ::= BEGIN
+
+IMPORTS
+ MODULE-IDENTITY, OBJECT-TYPE, NOTIFICATION-TYPE, Counter32, Gauge32,
+ Integer32, Counter64, enterprises
+ FROM SNMPv2-SMI
+ DisplayString, TEXTUAL-CONVENTION, RowPointer
+ FROM SNMPv2-TC
+ MODULE-COMPLIANCE, OBJECT-GROUP, NOTIFICATION-GROUP
+ FROM SNMPv2-CONF;
+
+-- Module Identity
+------------------
+
+jvmMgtMIB MODULE-IDENTITY
+ LAST-UPDATED "200403041800Z"
+ -- Format is "YYYYMMDDhhmmZ"
+ ORGANIZATION "Sun Microsystems, Inc."
+ CONTACT-INFO "Sun Microsystems, Inc.
+ 4150 Network Circle
+ Santa Clara, CA 95054
+ 1-800-555-9SUN or
+ 1-650-960-1300
+ http://www.sun.com
+ or contact your local support representative"
+ DESCRIPTION
+ "Copyright 2004 Sun Microsystems, Inc. All rights reserved.
+
+ This module defines the MIB that provides access to the
+ Java[tm] Virtual Machine monitoring data.
+ This module is derived from the Java[tm] programming language APIs
+ described in the java.lang.management package of
+ Java[tm] 2, Standard Edition, 5.0.
+
+ See the Java programming language APIs of JSR 163 for
+ 'Monitoring and Management of the Java[TM] Virtual Machine'
+ for more details.
+
+ Where the Java programming language API uses long, or int,
+ the MIB often uses the corresponding unsigned quantity -
+ which is closer to the object semantics.
+
+ In those cases, it often happens that the -1 value that might
+ be used by the API to indicate an unknown/unimplemented
+ value cannot be used. Instead the MIB uses the value 0, which
+ stricly speaking cannot be distinguished from a valid value.
+ In many cases however, a running system will have non-zero
+ values, so using 0 instead of -1 to indicate an unknown
+ quantity does not lose any functionality.
+ "
+ REVISION "200403041800Z"
+ -- Format is "YYYYMMDDhhmmZ"
+ DESCRIPTION
+ "
+ JVM-MANAGEMENT-MIB - JSR 163 Final Release 1.0
+ "
+
+ ::= { standard jsr163(163) 1 }
+
+
+-- Enterprise OIDs
+------------------
+
+-- internet OBJECT IDENTIFIER ::= { iso(1) org(3) dod(6) 1 }
+-- private OBJECT IDENTIFIER ::= { internet 4 }
+-- enterprises OBJECT IDENTIFIER ::= { private 1 }
+ sun OBJECT IDENTIFIER ::= { enterprises 42 }
+ jmgt OBJECT IDENTIFIER ::= { sun products(2) 145 }
+ -- experimental OBJECT IDENTIFIER ::= { jmgt 1 }
+ standard OBJECT IDENTIFIER ::= { jmgt 3 }
+
+----------------------------------------------------------------------------
+-- Textual Conventions
+----------------------
+--
+-- Note: Some of the TEXTUAL-CONVENTIONs defined in this module are
+-- OCTET STRING with a 1023 size limitation (SIZE(0..1023)).
+--
+-- As per RFC2578, section 7.1.2. OCTET STRING:
+--
+-- "The OCTET STRING type represents arbitrary binary or textual data.
+-- Although the SMI-specified size limitation for this type is 65535
+-- octets, MIB designers should realize that there may be
+-- implementation and interoperability limitations for sizes in
+-- excess of 255 octets."
+--
+-- As a consequence an agent implementing this MIB may decide to
+-- restrict this maximum size to a lesser value than 1023, provided that
+-- it makes it clear in an AGENT-CAPABILITY statement.
+--
+----------------------------------------------------------------------------
+
+JvmUnsigned64TC ::= TEXTUAL-CONVENTION
+ STATUS current
+ DESCRIPTION
+ "A non-negative 64-bit bit integer, without counter
+ semantics."
+ -- We have cloned the Unsigned64TC defined in RFC 2564 rather
+ -- than importing it because the JVM-MANAGEMENT-MIB and the
+ -- APPLICATION-MIB are not related.
+ --
+ REFERENCE "RFC 2564 - APPLICATION-MIB, Unsigned64TC."
+ SYNTAX Counter64
+
+
+JvmJavaObjectNameTC ::= TEXTUAL-CONVENTION
+ DISPLAY-HINT "255a"
+ STATUS current
+ DESCRIPTION
+ "An Object Name, as implemented by the java.lang.management API,
+ which identify a runtime Object (e.g. a Class Loader, a
+ Memory Manager, etc...).
+ The name is assumed to be unique in the scope of the object's
+ class.
+
+ This object syntax is equivalent to a DisplayString, but with a
+ a 1023 bytes size limits (instead of 255 for a DisplayString).
+
+ Note that the SNMP agent may have to truncate the string returned
+ by the underlying API if it does not fit in this type.
+ (1023 bytes max).
+ "
+ SYNTAX OCTET STRING (SIZE (0..1023))
+
+JvmPathElementTC ::= TEXTUAL-CONVENTION
+ DISPLAY-HINT "255a"
+ STATUS current
+ DESCRIPTION
+ "A file or directory element in a PATH/CLASSPATH/LIBRARY_PATH
+ structure.
+
+ This object syntax is equivalent to a DisplayString, but with a
+ a 1023 bytes size limits (instead of 255 for a DisplayString).
+
+ Note that the SNMP agent may have to truncate the string returned
+ by the underlying API if it does not fit in this type.
+ (1023 bytes max).
+ "
+ SYNTAX OCTET STRING (SIZE (0..1023))
+
+JvmArgValueTC ::= TEXTUAL-CONVENTION
+ DISPLAY-HINT "255a"
+ STATUS current
+ DESCRIPTION
+ "A string representing an input argument.
+
+ This object syntax is equivalent to a DisplayString, but with a
+ a 1023 bytes size limits (instead of 255 for a DisplayString).
+
+ Note that the SNMP agent may have to truncate the string returned
+ by the underlying API if it does not fit in this type.
+ (1023 bytes max).
+ "
+ SYNTAX OCTET STRING (SIZE (0..1023))
+
+JvmVerboseLevelTC ::= TEXTUAL-CONVENTION
+ STATUS current
+ DESCRIPTION
+ "Defines whether the verbose flag for a feature is active.
+ verbose: the flag is on.
+ silent: the flag is off.
+ "
+ SYNTAX INTEGER { silent(1), verbose(2) }
+
+
+JvmImplSupportStateTC ::= TEXTUAL-CONVENTION
+ STATUS current
+ DESCRIPTION
+ "Defines whether a feature is supported or not.
+ "
+ SYNTAX INTEGER { unsupported(1), supported(2) }
+
+JvmImplOptFeatureStateTC ::= TEXTUAL-CONVENTION
+ STATUS current
+ DESCRIPTION
+ "Defines whether an optional feature is supported, enabled,
+ or disabled.
+
+ An optional feature can be:
+
+ unsupported: The JVM does not support this feature.
+ enabled : The JVM supports this feature, and it
+ is enabled.
+ disabled : The JVM supports this feature, and it
+ is disabled.
+
+ Only enabled(3) and disabled(4) may be supplied as values to a
+ SET request. unsupported(1) can only be set internally by the
+ agent.
+ "
+ SYNTAX INTEGER { unsupported(1), enabled(3), disabled(4) }
+
+JvmTimeMillis64TC ::= TEXTUAL-CONVENTION
+ STATUS current
+ DESCRIPTION
+ "An elapsed time, expressed in milli-seconds.
+ This type is based on Counter64, but without its specific
+ semantics.
+ "
+ SYNTAX Counter64
+
+JvmTimeNanos64TC ::= TEXTUAL-CONVENTION
+ STATUS current
+ DESCRIPTION
+ "An elapsed time, expressed in nano-seconds.
+ This type is based on Counter64, but without its specific
+ semantics.
+ "
+ SYNTAX Counter64
+
+JvmPositive32TC ::= TEXTUAL-CONVENTION
+ STATUS current
+ DESCRIPTION
+ "A positive Integer32. In Java that would be a number
+ in [0..Integer.MAX_VALUE].
+ "
+ -- We use Integer32 (0..2147483647) rather than Unsigned32 because
+ -- Unsigned32 (0..2147483647) because Unsigned32 is based on
+ -- Gauge32 - which has a specific ASN.1 tag and a specific semantics.
+ -- In principle you cannot use a Gauge32 as base type for an index
+ -- in a table.
+ -- Note also that Unsigned32 is (0..2^32-1)
+ -- while Positive32 is (0..2^31-1)
+ --
+ SYNTAX Integer32 (0..2147483647)
+
+JvmManagedMemoryTypeTC ::= TEXTUAL-CONVENTION
+ STATUS current
+ DESCRIPTION
+ "
+ Defines the type of memory contained in a memory pool.
+ The pool may contain, heap memory or non-heap memory.
+ "
+ SYNTAX INTEGER { nonheap(1), heap(2) }
+
+
+JvmValidityStateTC ::= TEXTUAL-CONVENTION
+ STATUS current
+ DESCRIPTION
+ "
+ Defines whether an object is still valid.
+ "
+ SYNTAX INTEGER { invalid(1), valid(2) }
+
+
+JvmThreadStateTC ::= TEXTUAL-CONVENTION
+ STATUS current
+ DESCRIPTION
+ "Defines the possible states of a thread running in the
+ Java virtual machine. They are virtual machine thread states
+ and do not reflect any operating system thread states.
+
+ The first two bits: inNative(1) and suspended(2) can be
+ combined together and with any other bits. The remaining
+ bits 3-9, are mutually exclusive. Bits 10-16 are reserved
+ for future evolution of this MIB.
+
+ An agent MUST always return a thread state with one of the
+ bits in the range 3-9 set to 1. The other(9) bit should only
+ be set to 1 if new thread states which are mutally exclusive
+ with bits 3-8 are defined. An implementation can define
+ additional implementation dependant states and uses bits
+ from bit 17.
+
+ See java.lang.Thread.State,
+ java.lang.management.ThreadInfo.
+ "
+ --
+ -- Take care that in SNMP bits are numbered starting at 1, from
+ -- left to right (1 is the highest bit). A bitmap defined by the
+ -- BITS construct is thus a byte array where bit 1 is the highest bit
+ -- of the first byte.
+ --
+ SYNTAX BITS { -- Bits 1-2 may be specified in any combination
+ inNative(1),
+ suspended(2),
+
+ -- Bits 3-9 are mutually exclusive. Attempting to
+ -- set more than a single bit to 1 will result in
+ -- a returned error-status of inconsistentValue.
+ newThread(3),
+ runnable(4),
+ blocked(5),
+ terminated(6),
+ waiting(7),
+ timedWaiting(8),
+ other(9)
+ -- Bits 10-16 are reserved for future use by
+ -- this MIB
+ }
+
+
+JvmIndex64TC ::= TEXTUAL-CONVENTION
+ STATUS current
+ DESCRIPTION
+ "A 64 bits string mapping an unsigned 64 bits integer value
+ in big-endian ordering (i.e: 1 is encoded as 0x0000000000000001).
+
+ This type can be used when an unsigned 64 bits integer needs
+ to be used inside a table index.
+ "
+ SYNTAX OCTET STRING (SIZE(8))
+
+
+-- OBJECT-TYPE OID tree
+-----------------------
+
+jvmMgtMIBObjects
+ OBJECT IDENTIFIER ::= { jvmMgtMIB 1 }
+jvmMgtMIBNotifications
+ OBJECT IDENTIFIER ::= { jvmMgtMIB 2 }
+jvmMgtMIBConformance
+ OBJECT IDENTIFIER ::= { jvmMgtMIB 3 }
+
+-----------------------------------------------------------------------
+--
+-- The JVM Class Loading group
+--
+-- A collection of objects used to monitor Class Loading in the
+-- Java Virtual Machine. These objects define the SNMP management
+-- interface for the class loading system of the Java virtual machine.
+--
+-- This group only contains a few scalar object and no tables. The objects
+-- from this group are mapped from the java.lang.management.ClassLoadingMXBean
+-- interface.
+--
+-- See J2SE 5.0 API Specification,
+-- java.lang.management.ClassLoadingMXBean
+-----------------------------------------------------------------------
+
+-- Root OBJECT IDENTIFIER for ClassLoading group.
+--
+jvmClassLoading OBJECT IDENTIFIER ::= { jvmMgtMIBObjects 1 }
+
+-- The following objects are mapped from the ClassLoadingMXBean interface.
+-----------------------------------------------------------------------
+
+jvmClassesLoadedCount OBJECT-TYPE
+ SYNTAX Gauge32
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The number of classes currently loaded in the JVM.
+
+ See java.lang.management.ClassLoadingMXBean.getLoadedClassCount()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ClassLoadingMXBean"
+ ::= { jvmClassLoading 1 }
+
+jvmClassesTotalLoadedCount OBJECT-TYPE
+ SYNTAX Counter64
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The total number of classes that have been loaded since
+ the JVM has started execution.
+
+ See java.lang.management.ClassLoadingMXBean.
+ getTotalLoadedClassCount()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ClassLoadingMXBean"
+ ::= { jvmClassLoading 2 }
+
+jvmClassesUnloadedCount OBJECT-TYPE
+ SYNTAX Counter64
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The total number of classes that have been unloaded since
+ the JVM has started execution.
+
+ See java.lang.management.ClassLoadingMXBean.getUnloadedClassCount()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ClassLoadingMXBean"
+ ::= { jvmClassLoading 3 }
+
+jvmClassesVerboseLevel OBJECT-TYPE
+ SYNTAX JvmVerboseLevelTC
+ MAX-ACCESS read-write
+ STATUS current
+ DESCRIPTION
+ "Enables or disables the verbose output for the class loading
+ system. The verbose output information and the output stream
+ to which the verbose information is emitted are implementation
+ dependent. Typically, a Java virtual machine implementation
+ prints a message each time a class file is loaded.
+
+ verbose: if the verbose output is enabled.
+ silent: otherwise.
+
+ See java.lang.management.ClassLoadingMXBean.isVerbose(),
+ java.lang.management.ClassLoadingMXBean.setVerbose()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ClassLoadingMXBean"
+ DEFVAL { silent }
+ ::= { jvmClassLoading 4 }
+
+
+-----------------------------------------------------------------------
+--
+-- The JVM Memory group
+--
+-- A collection of objects used to monitor memory management in the
+-- Java Virtual Machine. These objects define management interface for
+-- the memory system of the Java virtual machine.
+--
+-- Memory:
+--
+-- The memory system of the Java virtual machine manages the following
+-- kinds of memory: heap, and non-heap. More information on these types
+-- of memory can be obtained from the J2SE 5.0 API Specification,
+-- java.lang.management.MemoryMXBean.
+--
+-- Memory Pools and Memory Managers:
+--
+-- Memory pools and memory managers are the abstract entities that monitor
+-- and manage the memory system of the Java virtual machine.
+--
+-- Memory managers are represented by the jvmMemManagerTable, which contains
+-- one row per Memory manager.
+-- The garbage collector is one type of memory manager responsible for
+-- reclaiming memory occupied by unreachable objects.
+-- The jvmMemGCTable is an extension of the jvmMemManagerTable, which contains
+-- the attribute specific to garbage collectors. A garbage collector entity
+-- is thus represented by one row in the jvmMemManagerTable, and one
+-- extension row in the jvmMemGCTable.
+--
+-- Memory Pools are represented by the jvmMemPoolTable, which contains one
+-- row per memory pool. A Java virtual machine may create or remove
+-- memory pools during execution. A memory pool can belong to either the
+-- heap or the non-heap memory.
+--
+-- A memory manager is responsible for managing one or more memory pools.
+-- A memory pool can be managed by more than one memory manager.
+-- The jvmMemMgrRelPoolTable represents this managing/managed relationship.
+--
+-- A Java virtual machine may add or remove memory managers during execution.
+--
+-- See J2SE 5.0 API Specification, java.lang.management.MemoryMXBean for
+-- more information on memory types, memory managers, memory pools,
+-- and the memory subsystem.
+--
+-----------------------------------------------------------------------
+
+-- Root OBJECT IDENTIFIER for the JVM Memory group.
+--
+jvmMemory OBJECT IDENTIFIER ::= { jvmMgtMIBObjects 2 }
+
+-- The following objects are mapped from the MemoryMXBean interface.
+-----------------------------------------------------------------------
+
+jvmMemoryPendingFinalCount OBJECT-TYPE
+ SYNTAX Gauge32
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The approximate number objects that are pending for finalization.
+
+ See java.lang.management.MemoryMXBean.
+ getObjectPendingFinalizationCount()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryMXBean"
+ ::= { jvmMemory 1 }
+
+jvmMemoryGCVerboseLevel OBJECT-TYPE
+ SYNTAX JvmVerboseLevelTC
+ MAX-ACCESS read-write
+ STATUS current
+ DESCRIPTION
+ "Enables or disables verbose output for the memory system.
+ The verbose output information and the output stream to which
+ the verbose information is emitted are implementation dependent.
+ Typically, a Java virtual machine implementation prints a
+ message whenever it frees memory at garbage collection.
+
+ verbose: if the verbose output is enabled,
+ silent: otherwise.
+
+ See java.lang.management.MemoryMXBean.isVerbose(),
+ java.lang.management.MemoryMXBean.setVerbose()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryMXBean"
+ ::= { jvmMemory 2 }
+
+jvmMemoryGCCall OBJECT-TYPE
+ SYNTAX INTEGER { unsupported(1), supported(2), start(3),
+ started(4), failed(5) }
+ MAX-ACCESS read-write
+ STATUS current
+ DESCRIPTION
+ "This object makes it possible to remotelly trigger the
+ Garbage Collector in the JVM.
+
+ This object's syntax is an enumeration which defines:
+
+ * Two state values, that can be returned from a GET request:
+
+ unsupported(1): means that remote invocation of gc() is not
+ supported by the SNMP agent.
+ supported(2) : means that remote invocation of gc() is supported
+ by the SNMP agent.
+
+ * One action value, that can be provided in a SET request to
+ trigger the garbage collector:
+
+ start(3) : means that a manager wishes to trigger
+ garbage collection.
+
+ * Two result value, that will be returned in the response to a
+ SET request when remote invocation of gc is supported
+ by the SNMP agent:
+
+ started(4) : means that garbage collection was
+ successfully triggered. It does not mean
+ however that the action was successfullly
+ completed: gc might still be running when
+ this value is returned.
+ failed(5) : means that garbage collection couldn't be
+ triggered.
+
+ * If remote invocation is not supported by the SNMP agent, then
+ unsupported(1) will always be returned as a result of either
+ a GET request, or a SET request with start(3) as input value.
+
+ * If a SET request with anything but start(3) is received, then
+ the agent will return a wrongValue error.
+
+ See java.lang.management.MemoryMXBean.gc()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryMXBean"
+ ::= { jvmMemory 3 }
+
+-- The object identifiers in the range jvmMemory.[4-9] are reserved for future
+-- evolution of this MIB.
+--
+-- We use the range jvmMemory.[10..19] for objects related to global JVM
+-- heap memory usage, as returned by
+-- java.lang.management.MemoryMXBean.getHeapMemoryUsage().
+-- Object identifiers in the range jvmMemory.[14..19] are not used but
+-- reserved for future evolution of this MIB.
+--
+jvmMemoryHeapInitSize OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ Total amount of memory (in bytes) that the Java virtual machine
+ initially requests from the operating system for memory management
+ for heap memory pools.
+
+ See java.lang.management.MemoryMXBean.getHeapMemoryUsage().getInit()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemory 10 }
+
+
+jvmMemoryHeapUsed OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ Total amount of used memory (in bytes) from heap memory pools.
+
+ See java.lang.management.MemoryMXBean.getHeapMemoryUsage().getUsed()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemory 11 }
+
+jvmMemoryHeapCommitted OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ Total amount of memory (in bytes) committed by heap memory pools.
+
+ See java.lang.management.MemoryMXBean.getHeapMemoryUsage().
+ getCommitted()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemory 12 }
+
+jvmMemoryHeapMaxSize OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ Total maximum size of memory (in bytes) for all heap memory pools.
+
+ See java.lang.management.MemoryMXBean.getHeapMemoryUsage().getMax()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemory 13 }
+
+-- We use the range jvmMemory.[20..29] for objects related to global JVM
+-- heap memory usage, as returned by
+-- lang.management.MemoryMXBean.getNonHeapMemoryUsage().
+-- Object identifiers in the range jvmMemory.[24..29] are not used but are
+-- reserved for future evolution of this MIB.
+--
+jvmMemoryNonHeapInitSize OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ Total amount of memory (in bytes) that the Java virtual machine
+ initially requests from the operating system for memory management
+ for non heap memory pools.
+
+ See java.lang.management.MemoryMXBean.getNonHeapMemoryUsage().getInit()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemory 20 }
+
+
+jvmMemoryNonHeapUsed OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ Total amount of used memory (in bytes) from non heap memory pools.
+
+ See java.lang.management.MemoryMXBean.getNonHeapMemoryUsage().getUsed()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemory 21 }
+
+jvmMemoryNonHeapCommitted OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ Total amount of memory (in bytes) committed by non heap memory pools.
+
+ See java.lang.management.MemoryMXBean.
+ getNonHeapMemoryUsage().getCommitted()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemory 22 }
+
+jvmMemoryNonHeapMaxSize OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ Total maximum size of memory (in bytes) for all non heap memory pools.
+
+ See java.lang.management.MemoryMXBean.getNonHeapMemoryUsage().getMax()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemory 23 }
+
+-- The object identifiers in the range jvmMemory.[30-99] are not used but are
+-- reserved for future evolution of this MIB.
+--
+-- The JVM Memory Manager Table
+--
+-- The jvmMemManagerTable represent memory manager abstract entities.
+-- The jvmMemManagerTable contains one row per memory manager. In
+-- addition, those memory managers which are also garbage collectors have
+-- an extension row in the jvmMemGCTable.
+--
+-- See J2SE 5.0 API Specification, java.lang.management.MemoryMXBean for
+-- a detailed description of the memory subsystem.
+--
+-- See J2SE 5.0 API Specification, java.lang.management.MemoryManagerMXBean
+-- for more information on memory managers.
+--
+-----------------------------------------------------------------------
+--
+-- We use the range jvmMemory.[100..109] for objects related to memory
+-- managers.
+-- Object identifiers in the range jvmMemory.[102-109] are not used
+-- but are reserved for future evolution of this MIB.
+--
+jvmMemManagerTable OBJECT-TYPE
+ SYNTAX SEQUENCE OF JvmMemManagerEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "The Memory Manager Table contains the whole list of Memory
+ Managers as returned by ManagementFactory.getMemoryManagerMXBeans().
+
+ When a MemoryManagerMXBean object is an instance of
+ GarbageCollectorMXBean, then additional information specific to
+ the GarbageCollectorMXBean class will be found in the
+ jvmGCTable, at the same index.
+
+ Relationships between MemoryManagers and MemoryPools are shown
+ by the Memory Manager-Pool Relation table (jvmMemMgrPoolRelTable).
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryManagerMXBean"
+ ::= { jvmMemory 100 }
+
+jvmMemManagerEntry OBJECT-TYPE
+ SYNTAX JvmMemManagerEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "A jvmMemManagerEntry conceptual row represent an instance of the
+ java.lang.management.MemoryManagerMXBean interface. If that instance
+ is also an instance of java.lang.management.GarbageCollectorMXBean,
+ then additional information will be found in the jvmGCTable, at the
+ same index.
+
+ Columnar objects in this table are mapped from attributes of
+ the MemoryManagerMXBean interface.
+
+ See java.lang.management.MemoryManagerMXBean
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryManagerMXBean"
+ INDEX { jvmMemManagerIndex }
+ ::= { jvmMemManagerTable 1 }
+
+JvmMemManagerEntry ::= SEQUENCE {
+ jvmMemManagerIndex JvmPositive32TC,
+ jvmMemManagerName JvmJavaObjectNameTC,
+ jvmMemManagerState JvmValidityStateTC
+}
+
+jvmMemManagerIndex OBJECT-TYPE
+ SYNTAX JvmPositive32TC
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "An index opaquely computed by the agent and which uniquely
+ identifies a Memory Manager.
+
+ The jvmMemManagerIndex index is opaquely computed by the agent,
+ from e.g the hash code of the MemoryManager (or MemoryManager name).
+ The agent is responsible for allocating a free index when it needs
+ one (e.g. if two objects have the same hash, then it may increment
+ one of the values until the conflict is resolved). As a result a
+ manager must not depend on the value of that index across,
+ e.g. reboot of the agent, as this value is not guaranteed to
+ stay identical after the agent restarts.
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryManagerMXBean"
+ ::= { jvmMemManagerEntry 1 }
+
+jvmMemManagerName OBJECT-TYPE
+ SYNTAX JvmJavaObjectNameTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The name of this memory manager, as returned by
+ MemoryManagerMXBean.getName().
+
+ See java.mangement.MemoryManagerMXBean.getName().
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryManagerMXBean"
+ ::= { jvmMemManagerEntry 2 }
+
+jvmMemManagerState OBJECT-TYPE
+ SYNTAX JvmValidityStateTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ Indicates whether this memory manager is valid in the Java
+ virtual machine. A memory manager becomes invalid once the
+ Java virtual machine removes it from the memory system.
+
+ See java.lang.management.MemoryManagerMXBean.isValid()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryManagerMXBean"
+ ::= { jvmMemManagerEntry 3 }
+
+
+-- The JVM Garbage Collector Table
+--
+-- The jvmMemGCTable is an extension of the jvmMemManagerTable.
+-- It represents garbage collector abstract entities. A garbage collector
+-- is a memory manager responsible for reclaiming memory occupied by
+-- unreachable objects.
+--
+-- A garbage collector is thus represented by one row in the
+-- jvmMemManagerTable, plus an extension row in the jvmMemGCTable.
+-- The extension row in the jvmMemGCTable contains those attributes which
+-- are specific to garbage collectors.
+--
+-- See J2SE 5.0 API Specification, java.lang.management.MemoryMXBean for
+-- a detailed description of the memory subsystem.
+--
+-- See J2SE 5.0 API Specification, java.lang.management.MemoryManagerMXBean
+-- for more information on memory managers, and
+-- java.lang.management.GarbageCollectorMXBean for more information on
+-- garbage collectors.
+--
+-----------------------------------------------------------------------
+
+jvmMemGCTable OBJECT-TYPE
+ SYNTAX SEQUENCE OF JvmMemGCEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "The Garbage Collector table provides additional information
+ on those MemoryManagers which are also GarbageCollectors.
+ This table extends the jvmMemManagerTable table. The index
+ used in the jvmMemGCTable table is imported from the
+ jvmMemManagerTable table. If a row from the jvmMemManagerTable
+ table is deleted, and if it has an extension in the jvmMemGCTable
+ table, then the extension row will also be deleted.
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.GarbageCollectorMXBean"
+ ::= { jvmMemory 101 }
+
+jvmMemGCEntry OBJECT-TYPE
+ SYNTAX JvmMemGCEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "Provide additional information on Garbage Collectors.
+
+ Columnar objects in this table are mapped from the
+ GarbageCollectorMXBean interface.
+
+ See java.lang.management.GarbageCollectorMXBean
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.GarbageCollectorMXBean"
+ INDEX { jvmMemManagerIndex }
+ ::= {jvmMemGCTable 1 }
+
+JvmMemGCEntry ::= SEQUENCE {
+ jvmMemGCCount Counter64,
+ jvmMemGCTimeMs JvmTimeMillis64TC
+}
+
+jvmMemGCCount OBJECT-TYPE
+ SYNTAX Counter64
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The total number of collections that have occurred,
+ as returned by GarbageCollectorMXBean.getCollectionCount().
+
+ If garbage collection statistics are not available, this
+ object is set to 0.
+
+ See java.lang.management.GarbageCollectorMXBean.getCollectionCount()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.GarbageCollectorMXBean"
+ ::= { jvmMemGCEntry 2 }
+
+jvmMemGCTimeMs OBJECT-TYPE
+ SYNTAX JvmTimeMillis64TC
+ UNITS "milliseconds"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The approximate accumulated collection elapsed time in
+ milliseconds, since the Java virtual machine has started.
+ This object is set to 0 if the collection elapsed time is
+ undefined for this collector.
+
+ See java.lang.management.GarbageCollectorMXBean.getCollectionTime()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.GarbageCollectorMXBean"
+ DEFVAL { 0 }
+ ::= { jvmMemGCEntry 3 }
+
+-- The JVM Memory Pool Table
+--
+-- The jvmMemPoolTable represent memory pool abstract entities.
+-- The jvmMemPoolTable contains one row per memory pool.
+--
+-- See J2SE 5.0 API Specification, java.lang.management.MemoryMXBean for
+-- a detailed description of the memory subsystem.
+--
+-- See J2SE 5.0 API Specification, java.lang.management.MemoryPoolMXBean
+-- for more information on memory pool.
+--
+-----------------------------------------------------------------------
+--
+-- We use the range jvmMemory.[110..119] for objects related to memory pools.
+-- Object identifiers in the range jvmMemory.[111-119] are not used but
+-- are reserved for future evolution of this MIB.
+--
+jvmMemPoolTable OBJECT-TYPE
+ SYNTAX SEQUENCE OF JvmMemPoolEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "The Memory Pool Table contains the whole list of MemoryPools
+ as returned by ManagementFactory.getMemoryPoolMXBeans().
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean"
+ ::= { jvmMemory 110 }
+
+jvmMemPoolEntry OBJECT-TYPE
+ SYNTAX JvmMemPoolEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "
+ Represents a memory pool. The pool may contain heap memory or
+ non-heap memory. A row in this table represents
+ an instance of MemoryPoolMXBean.
+
+ See java.lang.management.MemoryPoolMXBean
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean"
+ INDEX { jvmMemPoolIndex }
+ ::= { jvmMemPoolTable 1 }
+
+JvmMemPoolEntry ::= SEQUENCE {
+ jvmMemPoolIndex JvmPositive32TC,
+ jvmMemPoolName JvmJavaObjectNameTC,
+ jvmMemPoolType JvmManagedMemoryTypeTC,
+ jvmMemPoolState JvmValidityStateTC,
+ jvmMemPoolPeakReset JvmTimeMillis64TC,
+
+ jvmMemPoolInitSize JvmUnsigned64TC,
+ jvmMemPoolUsed JvmUnsigned64TC,
+ jvmMemPoolCommitted JvmUnsigned64TC,
+ jvmMemPoolMaxSize JvmUnsigned64TC,
+
+ jvmMemPoolPeakUsed JvmUnsigned64TC,
+ jvmMemPoolPeakCommitted JvmUnsigned64TC,
+ jvmMemPoolPeakMaxSize JvmUnsigned64TC,
+
+ jvmMemPoolCollectUsed JvmUnsigned64TC,
+ jvmMemPoolCollectCommitted JvmUnsigned64TC,
+ jvmMemPoolCollectMaxSize JvmUnsigned64TC,
+
+ jvmMemPoolThreshold JvmUnsigned64TC,
+ jvmMemPoolThreshdCount Counter64,
+ jvmMemPoolThreshdSupport JvmImplSupportStateTC,
+ jvmMemPoolCollectThreshold JvmUnsigned64TC,
+ jvmMemPoolCollectThreshdCount Counter64,
+ jvmMemPoolCollectThreshdSupport JvmImplSupportStateTC
+
+}
+
+jvmMemPoolIndex OBJECT-TYPE
+ SYNTAX JvmPositive32TC
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "An index value opaquely computed by the agent which uniquely
+ identifies a row in the jvmMemPoolTable.
+
+ The jvmMemPoolIndex index is opaquely computed by the agent,
+ from e.g the hash code of the MemoryPool (or MemoryPool name).
+ The agent is responsible for allocating a free index when it
+ needs one (e.g. if two objects have the same hash, then it may
+ increment one of the values until the conflict is resolved).
+ As a result a manager must not depend on the value of that
+ index across, e.g. reboot of the agent, as this value is not
+ guaranteed to stay identical after the agent restarts.
+ "
+ ::= { jvmMemPoolEntry 1 }
+
+jvmMemPoolName OBJECT-TYPE
+ SYNTAX JvmJavaObjectNameTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The name of this memory pool, as returned by
+ MemoryPoolMXBean.getName().
+
+ See java.lang.management.MemoryPoolMXBean.getName()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean"
+ ::= { jvmMemPoolEntry 2 }
+
+jvmMemPoolType OBJECT-TYPE
+ SYNTAX JvmManagedMemoryTypeTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The type of memory managed in this pool. This pool may be used for
+ heap memory or non-heap memory.
+
+ See java.lang.management.MemoryPoolMXBean.getMemoryType()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean"
+ ::= { jvmMemPoolEntry 3 }
+
+jvmMemPoolState OBJECT-TYPE
+ SYNTAX JvmValidityStateTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ Indicates whether this memory pool is valid in the Java
+ virtual machine. A memory pool becomes invalid once the
+ Java virtual machine removes it from the memory system.
+
+ See java.lang.management.MemoryPoolMXBean.isValid()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean"
+ ::= { jvmMemPoolEntry 4 }
+
+jvmMemPoolPeakReset OBJECT-TYPE
+ SYNTAX JvmTimeMillis64TC
+ UNITS "milliseconds"
+ MAX-ACCESS read-write
+ STATUS current
+ DESCRIPTION
+ "
+ This object indicates the last time - in milliseconds - at which
+ the peak memory usage statistic of this memory pool was reset
+ to the current memory usage. This corresponds to a time stamp
+ as returned by java.lang.System.currentTimeMillis();
+
+ Setting this object to a time earlier than its current time value
+ has no effect. Setting this object to a time later than its current
+ time value causes the peak memory usage statistic of this memory
+ pool to be reset to the current memory usage. The new value of this
+ object will be the time at which the reset operation is triggered.
+
+ There could be a delay between the time at which the reset operation
+ is triggered and the time at which the actual resetting happens, so
+ this value is only indicative.
+
+ See java.lang.management.MemoryPoolMXBean.resetPeakUsage()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean"
+ ::= { jvmMemPoolEntry 5 }
+
+
+-- The object identifier arcs in the range jvmMemPoolEntry.[6-9] are
+-- reserved for future evolution of this MIB.
+--
+-- We use the range jvmMemPoolEntry.[10..19] for objects related to this
+-- pool memory usage, as returned by
+-- java.lang.management.MemoryPoolMXBean.getUsage().
+-- Object identifiers in the range jvmMemPoolEntry.[14..19] are not
+-- used but are reserved for future evolution of this MIB.
+--
+jvmMemPoolInitSize OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ Initial size of this memory pool.
+
+ See java.lang.management.MemoryPoolMXBean.getUsage().getInit()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemPoolEntry 10 }
+
+
+jvmMemPoolUsed OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ Amount of used memory in this memory pool.
+
+ See java.lang.management.MemoryPoolMXBean.getUsage().getUsed()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemPoolEntry 11 }
+
+jvmMemPoolCommitted OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ Amount of committed memory in this memory pool.
+
+ See java.lang.management.MemoryPoolMXBean.getUsage().getCommitted()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemPoolEntry 12 }
+
+jvmMemPoolMaxSize OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ Maximal size of this memory pool.
+
+ See java.lang.management.MemoryPoolMXBean.getUsage().getMax()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemPoolEntry 13 }
+
+-- We use the range jvmMemPoolEntry.[20..29] for objects related to
+-- this pool peak memory usage, as returned by
+-- java.lang.management.MemoryPoolMXBean.getPeakUsage().
+-- The object identifier arc jvmMemPoolEntry.20 which would have been
+-- used for the initial size is not used because the notion of initial
+-- size in the context of peak usage is meaningless.
+-- Therefore, we start numbering objects at 21.
+-- Object identifiers in the range jvmMemPoolEntry.[24..29] are not
+-- used but are reserved for future evolution of this MIB.
+--
+jvmMemPoolPeakUsed OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ Amount of used memory in this memory pool when the peak usage
+ was reached.
+
+ See java.lang.management.MemoryPoolMXBean.getPeakUsage().getUsed()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemPoolEntry 21 }
+
+jvmMemPoolPeakCommitted OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ Amount of committed memory in this memory pool when the peak usage
+ was reached.
+
+ See java.lang.management.MemoryPoolMXBean.getPeakUsage().getCommitted()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemPoolEntry 22 }
+
+jvmMemPoolPeakMaxSize OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ Maximal size of this memory pool when the peak usage
+ was reached.
+
+ See java.lang.management.MemoryPoolMXBean.getPeakUsage().getMax()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemPoolEntry 23 }
+
+-- We use the range jvmMemPoolEntry.[30..39] for objects related to this
+-- pool collection memory usage, as returned by
+-- java.lang.management.MemoryPoolMXBean.getCollectionUsage().
+-- The object identifier arc jvmMemPoolEntry.30 which would have been used
+-- for the initial size is not used because the notion of initial size in the
+-- context of collection usage is meaningless.
+-- Therefore, we start numbering objects at 31.
+-- Object identifiers in the range jvmMemPoolEntry.[34..39] are not used
+-- but are reserved for future evolution of this MIB.
+--
+jvmMemPoolCollectUsed OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ The amount of used memory at the most recent time that the
+ Java virtual machine has expended effort in recycling unused objects
+ in this memory pool.
+
+ See java.lang.management.MemoryPoolMXBean.getCollectionUsage().getUsed()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemPoolEntry 31 }
+
+jvmMemPoolCollectCommitted OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ The amount of committed memory at the most recent time that the
+ Java virtual machine has expended effort in recycling unused objects
+ in this memory pool.
+
+ See java.lang.management.MemoryPoolMXBean.getCollectionUsage().
+ getCommitted()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemPoolEntry 32 }
+
+jvmMemPoolCollectMaxSize OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "
+ The value of the maximum amount of memory at the most recent time
+ that the Java virtual machine has expended effort in recycling
+ unused objects in this memory pool.
+
+ See java.lang.management.MemoryPoolMXBean.getCollectionUsage().getMax()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean,
+ java.lang.management.MemoryUsage"
+ ::= { jvmMemPoolEntry 33 }
+
+-- Object identifiers in the range jvmMemPoolEntry.[40-109] are reserved
+-- for future evolution of this MIB.
+--
+-- We use the range jvmMemPoolEntry.[110..119] for objects related to this
+-- pool memory usage thresholds (range jvmMemPoolEntry.[10..19] was used for
+-- this pool memory usage).
+-- Object identifier arcs in the range jvmMemPoolEntry.[113..119] are not
+-- used but are reserved for future evolution of this MIB.
+--
+jvmMemPoolThreshold OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-write
+ STATUS current
+ DESCRIPTION
+ "The threshold value for the memory usage of this memory pool,
+ in bytes. A zero value (0) indicates that no threshold value is
+ configured.
+ When the amount of used memory crosses over this threshold
+ value the JVM will trigger a usage memory threshold exceeded
+ notification, and the jvmMemPoolThreshdCount increases.
+
+ If memory usage threshold is not supported, then this object, if
+ implemented, will always be equals to 0. In that case, attempting
+ to set this object will trigger an inconsistentValue error.
+
+ See also jvmMemPoolThreshdSupport.
+
+ See java.lang.management.MemoryPoolMXBean.getUsageThreshold(),
+ java.lang.management.MemoryPoolMXBean.setUsageThreshold(long),
+ java.lang.management.MemoryPoolMXBean.getUsageThresholdCount(),
+ java.lang.management.MemoryPoolMXBean.isUsageThresholdSupported()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean"
+ DEFVAL { 0 }
+ ::= { jvmMemPoolEntry 110 }
+
+jvmMemPoolThreshdCount OBJECT-TYPE
+ SYNTAX Counter64
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The number of times that the memory usage has crossed
+ the usage threshold, as detected by the Java virtual machine.
+
+ If memory usage threshold is not supported, then this object, if
+ implemented, will always be equals to 0.
+
+ See also jvmMemPoolThresholdSupport.
+
+ See java.lang.management.MemoryPoolMXBean.getUsageThresholdCount(),
+ java.lang.management.MemoryPoolMXBean.isUsageThresholdSupported()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean"
+ ::= { jvmMemPoolEntry 111 }
+
+jvmMemPoolThreshdSupport OBJECT-TYPE
+ SYNTAX JvmImplSupportStateTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "Tells whether this memory pool supports usage threshold.
+
+ See java.lang.management.MemoryPoolMXBean.isUsageThresholdSupported()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean"
+ ::= { jvmMemPoolEntry 112 }
+
+-- Object identifiers in the range jvmMemPoolEntry.[120-129] are reserved
+-- for future evolution of this MIB.
+--
+-- We use the range jvmMemPoolEntry.[130..139] for objects related to
+-- this pool memory collection usage thresholds (range
+-- jvmMemPoolEntry.[30..39] was used for this pool collection memory usage).
+-- Object identifiers in the range jvmMemPoolEntry.[133..139] are not used
+-- but are reserved for future evolution of this MIB.
+--
+jvmMemPoolCollectThreshold OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ UNITS "bytes"
+ MAX-ACCESS read-write
+ STATUS current
+ DESCRIPTION
+ "The threshold value for the collection usage of this memory pool,
+ in bytes. A zero value (0) indicates that no threshold value is
+ configured.
+ When the amount of used memory crosses over this threshold
+ value the JVM will trigger a collection memory threshold exceeded
+ notification, and the jvmMemPoolCollectThreshdCount increases.
+
+ If collection usage threshold is not supported, then this object, if
+ implemented, will always be equals to 0. In that case, attempting
+ to set this object will trigger an inconsistentValue error.
+
+ See also jvmMemPoolCollectThreshdSupport.
+
+ See java.lang.management.MemoryPoolMXBean.
+ getCollectionUsageThreshold(),
+ java.lang.management.MemoryPoolMXBean.
+ setCollectionUsageThreshold(long),
+ java.lang.management.MemoryPoolMXBean.
+ isCollectionUsageThresholdSupported(),
+ java.lang.management.MemoryPoolMXBean.
+ getCollectionUsageThresholdCount()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean"
+ DEFVAL { 0 }
+ ::= { jvmMemPoolEntry 131 }
+
+jvmMemPoolCollectThreshdCount OBJECT-TYPE
+ SYNTAX Counter64
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The number of times that the memory usage has crossed
+ the collection usage threshold, as detected by the Java virtual
+ machine.
+
+ If memory usage threshold is not supported, then this object, if
+ implemented, will always be equals to 0.
+
+ See also jvmMemPoolCollectThreshdSupport.
+
+ See java.lang.management.MemoryPoolMXBean.
+ getCollectionUsageThresholdCount(),
+ java.lang.management.MemoryPoolMXBean.
+ isCollectionUsageThresholdSupported()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean"
+ ::= { jvmMemPoolEntry 132 }
+
+jvmMemPoolCollectThreshdSupport OBJECT-TYPE
+ SYNTAX JvmImplSupportStateTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "Tells whether this memory pool supports collection usage threshold.
+
+ See java.lang.management.MemoryPoolMXBean.
+ isCollectionUsageThresholdSupported()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean"
+ ::= { jvmMemPoolEntry 133 }
+
+-- The JVM Memory Manager-Pool Relation Table
+-----------------------------------------------------------------------
+-- The JVM Memory Pool Table
+--
+-- The jvmMemPoolTable represent memory pool abstract entities.
+-- The jvmMemPoolTable contains one row per memory pool.
+--
+-- See J2SE 5.0 API Specification, java.lang.management.MemoryMXBean for
+-- a detailed description of the memory subsystem.
+--
+-- See J2SE 5.0 API Specification, java.lang.management.MemoryPoolMXBean
+-- for more information on memory pool.
+--
+-----------------------------------------------------------------------
+--
+-- We use the range jvmMemory.[110..119] for objects related to memory pools.
+-- Object identifier arcs in the range jvmMemory.[111-119] are not used
+-- but are reserved for future evolution of this MIB.
+--
+
+jvmMemMgrPoolRelTable OBJECT-TYPE
+ SYNTAX SEQUENCE OF JvmMemMgrPoolRelEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "The Memory Manager-Pool Relation Table shows the
+ Memory Manager / Memory Pool relations, as returned by
+ MemoryPoolMXBean.getMemoryManagerNames() and
+ MemoryManagerMXBean.getMemoryPoolNames().
+ This table imports the indexes from the jvmMemManagerTable table
+ and jvmMemPoolTable table. The jvmMemMgrRelManagerName and
+ jvmMemMgrRelPoolName objects are not actually necessary since
+ the indexes are self-sufficient to express the relationship -
+ but the names will make the table more understandable when displayed
+ in a management console.
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean,
+ java.lang.management.MemoryManagerMXBean"
+ ::= { jvmMemory 120 }
+
+jvmMemMgrPoolRelEntry OBJECT-TYPE
+ SYNTAX JvmMemMgrPoolRelEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "A row in this table indicates that the Memory Manager identified
+ by jvmMemManagerIndex manages the Memory Pool identified by
+ jvmMemPoolIndex. Note that a pool may be managed by several
+ memory managers, and a memory manager can manage several
+ memory pool.
+
+ See java.lang.management.MemoryManagerMXBean.getMemoryPoolNames(),
+ java.lang.management.MemoryPoolMXBean.getMemoryManagerNames()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean,
+ java.lang.management.MemoryManagerMXBean"
+ INDEX { jvmMemManagerIndex, jvmMemPoolIndex }
+ ::= { jvmMemMgrPoolRelTable 1 }
+
+JvmMemMgrPoolRelEntry ::= SEQUENCE {
+ jvmMemMgrRelManagerName JvmJavaObjectNameTC,
+ jvmMemMgrRelPoolName JvmJavaObjectNameTC
+}
+
+jvmMemMgrRelManagerName OBJECT-TYPE
+ SYNTAX JvmJavaObjectNameTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The name of the memory manager.
+
+ See java.manangement.MemoryManagerMXBean.getName();
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryManagerMXBean"
+ ::= { jvmMemMgrPoolRelEntry 2 }
+
+jvmMemMgrRelPoolName OBJECT-TYPE
+ SYNTAX JvmJavaObjectNameTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The name of the memory pool.
+
+ See java.manangement.MemoryPoolMXBean.getName();
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryPoolMXBean"
+ ::= { jvmMemMgrPoolRelEntry 3 }
+
+
+-----------------------------------------------------------------------
+--
+-- The JVM Thread group
+--
+-- A collection of objects used to monitor threads in the
+-- Java Virtual Machine. These objects define the SNMP management
+-- interface for the thread system of the Java virtual machine.
+--
+-- The jvmThreadInstanceTable represents the threads which are currently
+-- alive in the system. The representation of a thread is derived from the
+-- set of methods in the ThreadMXBean that return information about a
+-- given thread.
+--
+-- See J2SE 5.0 API Specification, java.lang.management.ThreadMXBean for
+-- a detailed description of the threading subsystem.
+--
+-----------------------------------------------------------------------
+
+--
+-----------------------------------------------------------------------
+
+jvmThreading OBJECT IDENTIFIER ::= { jvmMgtMIBObjects 3 }
+
+-- The following objects are mapped from the ThreadMXBean interface.
+-----------------------------------------------------------------------
+
+jvmThreadCount OBJECT-TYPE
+ SYNTAX Gauge32
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The current number of live threads.
+
+ See java.lang.management.ThreadMXBean.getThreadCount()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean"
+ ::= { jvmThreading 1 }
+
+jvmThreadDaemonCount OBJECT-TYPE
+ SYNTAX Gauge32
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The current number of daemon threads.
+
+ See java.lang.management.ThreadMXBean.getDaemonThreadCount()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean"
+ ::= { jvmThreading 2 }
+
+jvmThreadPeakCount OBJECT-TYPE
+ SYNTAX Counter32
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The peak thread count since the execution of the application.
+
+ See java.lang.management.ThreadMXBean.getPeakThreadCount()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean"
+ ::= { jvmThreading 3 }
+
+jvmThreadTotalStartedCount OBJECT-TYPE
+ SYNTAX Counter64
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The total number of threads created and started since the Java
+ Virtual Machine started.
+
+ See java.lang.management.ThreadMXBean.getTotalStartedThreadCount()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean"
+ ::= { jvmThreading 4 }
+
+jvmThreadContentionMonitoring OBJECT-TYPE
+ SYNTAX JvmImplOptFeatureStateTC
+ MAX-ACCESS read-write
+ STATUS current
+ DESCRIPTION
+ "The state of the Thread Contention Monitoring feature.
+ This feature can be:
+
+ unsupported: The JVM does not support Thread Contention Monitoring.
+ enabled : The JVM supports Thread Contention Monitoring, and it
+ is enabled.
+ disabled : The JVM supports Thread Contention Monitoring, and it
+ is disabled.
+
+ Only enabled(3) and disabled(4) may be supplied as values to a
+ SET request. unsupported(1) can only be set internally by the
+ agent.
+
+ When the feature is unsupported(1), any attempt to change
+ that value will fail: trying to set this object to
+ enabled(3) or disabled(4) will result in an `inconsistentValue'
+ error. Trying to set it to any other value will result in an
+ `wrongValue' error.
+
+ See java.lang.management.ThreadMXBean.
+ isThreadContentionMonitoringSupported(),
+ java.lang.management.ThreadMXBean.
+ isThreadContentionMonitoringEnabled(),
+ java.lang.management.ThreadMXBean.
+ setThreadContentionMonitoringEnabled()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean"
+ ::= { jvmThreading 5 }
+
+jvmThreadCpuTimeMonitoring OBJECT-TYPE
+ SYNTAX JvmImplOptFeatureStateTC
+ MAX-ACCESS read-write
+ STATUS current
+ DESCRIPTION
+ "The state of the Thread CPU Time Monitoring feature.
+ This feature can be:
+
+ unsupported: The JVM does not support Thread CPU Time Monitoring.
+ enabled : The JVM supports Thread CPU Time Monitoring, and it
+ is enabled.
+ disabled : The JVM supports Thread CPU Time Monitoring, and it
+ is disabled.
+
+ Only enabled(3) and disabled(4) may be supplied as values to a
+ SET request. unsupported(1) can only be set internally by the
+ agent.
+
+ When the feature is unsupported(1), any attempt to change
+ that value will fail: trying to set this object to
+ enabled(3) or disabled(4) will result in an `inconsistentValue'
+ error. Trying to set it to any other value will result in an
+ `wrongValue' error.
+
+ See java.lang.management.ThreadMXBean.
+ isThreadCpuTimeSupported(),
+ java.lang.management.ThreadMXBean.
+ isThreadCpuTimeEnabled(),
+ java.lang.management.ThreadMXBean.
+ setThreadCpuTimeEnabled()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean"
+ ::= { jvmThreading 6 }
+
+jvmThreadPeakCountReset OBJECT-TYPE
+ SYNTAX JvmTimeMillis64TC
+ UNITS "milliseconds"
+ MAX-ACCESS read-write
+ STATUS current
+ DESCRIPTION
+ "
+ This object indicates the last time - in milliseconds - at which
+ the peak thread count was reset to the current thread count.
+ This corresponds to a time stamp as returned by
+ java.lang.System.currentTimeMillis().
+
+ Setting this object to a time earlier than its current time value
+ has no effect. Setting this object to a time later than its current
+ time value causes the peak thread count statistic to be reset to
+ the current thread count. The new value of this object will be
+ the time at which the reset operation is triggered.
+
+ There could be a delay between the time at which the reset operation
+ is triggered and the time at which the actual resetting happens, so
+ this value is only indicative.
+
+ See java.lang.management.ThreadMXBean.resetPeakThreadCount()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean"
+ ::= { jvmThreading 7 }
+
+
+-- Object identifiers in the range jvmThreading.[8-10] are reserved
+-- for future evolution of this MIB.
+--
+-----------------------------------------------------------------------
+-- The JVM Thread Instance Table
+--
+-- The jvmThreadInstanceTable represents the threads which are currently
+-- alive in the system. The representation of a thread is derived from the
+-- set of methods in the ThreadMXBean that return information about a
+-- given thread.
+--
+-- See J2SE 5.0 API Specification, java.lang.management.ThreadMXBean for
+-- a detailed description of the threading subsystem.
+-- See also J2SE 5.0 API Specification, java.lang.management.ThreadInfo,
+-- and java.lang.Thread
+--
+-----------------------------------------------------------------------
+
+jvmThreadInstanceTable OBJECT-TYPE
+ SYNTAX SEQUENCE OF JvmThreadInstanceEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "The Thread Instance Table is built from all the methods of
+ ThreadMXBean that take a ThreadID as parameter.
+
+ See java.lang.management.ThreadMXBean.getAllThreadIds()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean"
+ ::= { jvmThreading 10 }
+
+jvmThreadInstanceEntry OBJECT-TYPE
+ SYNTAX JvmThreadInstanceEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "A row in this table represents a live thread.
+ Attributes in this row are built from all the methods of
+ ThreadMXBean that take a ThreadID as parameter.
+
+ See java.lang.management.ThreadMXBean
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean"
+ INDEX { jvmThreadInstIndex }
+ ::= { jvmThreadInstanceTable 1 }
+
+JvmThreadInstanceEntry ::= SEQUENCE {
+ jvmThreadInstIndex JvmIndex64TC,
+ jvmThreadInstId JvmUnsigned64TC,
+ jvmThreadInstState JvmThreadStateTC,
+ jvmThreadInstBlockCount Counter64,
+ jvmThreadInstBlockTimeMs JvmTimeMillis64TC,
+ jvmThreadInstWaitCount Counter64,
+ jvmThreadInstWaitTimeMs JvmTimeMillis64TC,
+ jvmThreadInstCpuTimeNs JvmTimeNanos64TC,
+ jvmThreadInstLockName JvmJavaObjectNameTC,
+ jvmThreadInstLockOwnerPtr RowPointer,
+ jvmThreadInstName JvmJavaObjectNameTC
+}
+
+jvmThreadInstIndex OBJECT-TYPE
+ SYNTAX JvmIndex64TC
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "An index uniquely identifying a live thread, and directly
+ derived from the value of jvmThreadInstId. The jvmThreadInstId
+ cannot be used directly as index in the table, because integer
+ indexes cannot exceed an unsigned 32 int.
+
+ The jvmThreadInstIndex index is an 8 byte octet string as
+ defined by the JvmIndex64TC TEXTUAL-CONVENTION. Its value is
+ directly derived from the value of the corresponding ThreadID
+ returned by jvmThreadInstId.
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean, java.lang.Thread"
+ ::= { jvmThreadInstanceEntry 1 }
+
+jvmThreadInstId OBJECT-TYPE
+ SYNTAX JvmUnsigned64TC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The thread ID, as returned by Thread.getId().
+
+ See java.lang.management.ThreadMXBean.getThreadInfo(long,boolean).
+ getThreadId()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean, java.lang.Thread"
+ ::= { jvmThreadInstanceEntry 2 }
+
+jvmThreadInstState OBJECT-TYPE
+ SYNTAX JvmThreadStateTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The state of this thread instance.
+
+ See java.lang.management.ThreadMXBean.getThreadInfo(long,boolean).
+ getThreadState()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean"
+ ::= { jvmThreadInstanceEntry 3 }
+
+jvmThreadInstBlockCount OBJECT-TYPE
+ SYNTAX Counter64
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The total number of times that this thread has blocked to enter
+ or re-enter a monitor..
+
+ See java.lang.management.ThreadMXBean.getThreadInfo(long,boolean).
+ getBlockedCount()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean"
+ ::= { jvmThreadInstanceEntry 4 }
+
+jvmThreadInstBlockTimeMs OBJECT-TYPE
+ SYNTAX JvmTimeMillis64TC
+ UNITS "milliseconds"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The approximate accumulated elapsed time (in millisecond)
+ that a thread has blocked to enter or re-enter a monitor since
+ it has started - or since thread contention monitoring was
+ enabled.
+
+ This object is always set to 0 if thread contention monitoring
+ is disabled or not supported.
+
+ See java.lang.management.ThreadMXBean.getThreadInfo(long,boolean).
+ getBlockedTime()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean"
+ ::= { jvmThreadInstanceEntry 5 }
+
+jvmThreadInstWaitCount OBJECT-TYPE
+ SYNTAX Counter64
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The total number of times that this thread has waited for
+ notification.
+
+ See java.lang.management.ThreadMXBean.getThreadInfo(long,boolean).
+ getWaitedCount()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean"
+ ::= { jvmThreadInstanceEntry 6 }
+
+jvmThreadInstWaitTimeMs OBJECT-TYPE
+ SYNTAX JvmTimeMillis64TC
+ UNITS "milliseconds"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The approximate accumulated elapsed time (in millisecond)
+ that a thread has waited on a monitor through a
+ java.lang.Object.wait method since it has started - or since
+ thread contention monitoring wasenabled.
+
+ This object is always set to 0 if thread contention monitoring
+ is disabled or not supported.
+
+ See java.lang.management.ThreadMXBean.getThreadInfo(long,boolean).
+ getWaitedTime()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean"
+ ::= { jvmThreadInstanceEntry 7 }
+
+jvmThreadInstCpuTimeNs OBJECT-TYPE
+ SYNTAX JvmTimeNanos64TC
+ UNITS "nanoseconds"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The approximate accumulated CPU time (in nanosecond) for a thread
+ since it has started - or since thread CPU time monitoring was
+ enabled.
+
+ If the thread of the specified ID is not alive or does not exist,
+ or the CPU time measurement is disabled or not supported,
+ this object is set to 0.
+
+ See java.lang.management.ThreadMXBean.getThreadCpuTime(long),
+ java.lang.management.ThreadMXBean.isThreadCpuTimeSupported(),
+ java.lang.management.ThreadMXBean.isThreadCpuTimeEnabled()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean"
+ ::= { jvmThreadInstanceEntry 8 }
+
+jvmThreadInstName OBJECT-TYPE
+ SYNTAX JvmJavaObjectNameTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "This thread name - as returned by Thread.getThreadName().
+
+ See java.lang.management.ThreadInfo.getThreadName()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean,
+ java.lang.management.ThreadInfo"
+ ::= { jvmThreadInstanceEntry 9 }
+
+jvmThreadInstLockName OBJECT-TYPE
+ SYNTAX JvmJavaObjectNameTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The string representation of the monitor lock that this thread
+ is blocked to enter or waiting to be notified through the
+ Object.wait method.
+
+ See J2SE 5.0 API Specification,
+ java.lang.management.ThreadInfo.getLockName()
+ for more information on the format of this string.
+
+ If this thread is not blocked then a zero-length string is returned.
+
+ Note that the SNMP agent may have to truncate the string returned
+ by the underlying API if it does not fit in the JvmJavaObjectNameTC
+ (1023 bytes max).
+
+ See java.lang.management.ThreadInfo.getLockName()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean,
+ java.lang.management.ThreadInfo"
+ ::= { jvmThreadInstanceEntry 10 }
+
+jvmThreadInstLockOwnerPtr OBJECT-TYPE
+ SYNTAX RowPointer
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "A pointer to the thread which owns the monitor of the
+ object on which this thread instance is blocked.
+ This object will point to jvmThreadInstId of the
+ lock owner thread.
+
+ If this thread is not blocked then 0.0 is returned.
+
+ See java.lang.management.ThreadInfo.getLockOwnerId()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.ThreadMXBean,
+ java.lang.management.ThreadInfo"
+ ::= { jvmThreadInstanceEntry 11 }
+
+-----------------------------------------------------------------------
+--
+-- The JVM Runtime group
+--
+-- A collection of objects used to monitor the Java Virtual Machine
+-- Runtime. These objects define the SNMP management interface for the
+-- runtime system of the Java virtual machine.
+--
+-- The JVM Runtime group defines object mapped from the
+-- java.lang.management.RuntimeMXBean interface.
+--
+-- See J2SE 5.0 API Specification, java.lang.management.RuntimeMXBean for
+-- a detailed description of the runtime system.
+--
+-----------------------------------------------------------------------
+
+jvmRuntime OBJECT IDENTIFIER ::= { jvmMgtMIBObjects 4 }
+
+-- The following objects are mapped from the RuntimeMXBean interface.
+-----------------------------------------------------------------------
+
+jvmRTName OBJECT-TYPE
+ SYNTAX DisplayString
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The name representing the running Java virtual machine.
+
+ Note that the SNMP agent may have to truncate the name returned
+ by the underlying API if it does not fit in the DisplayString
+ (255 bytes max).
+
+ See java.lang.management.RuntimeMXBean.getName()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRuntime 1 }
+
+jvmRTVMName OBJECT-TYPE
+ SYNTAX JvmJavaObjectNameTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The Java virtual machine implementation name.
+
+ See java.lang.management.RuntimeMXBean.getVmName()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRuntime 2 }
+
+jvmRTVMVendor OBJECT-TYPE
+ SYNTAX DisplayString
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The Java virtual machine implementation vendor.
+
+ Note that the SNMP agent may have to truncate the string returned
+ by the underlying API if it does not fit in the DisplayString
+ (255 bytes max).
+
+ See java.lang.management.RuntimeMXBean.getVmVendor()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRuntime 3 }
+
+jvmRTVMVersion OBJECT-TYPE
+ SYNTAX DisplayString
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The Java virtual machine implementation version.
+
+ Note that the SNMP agent may have to truncate the string returned
+ by the underlying API if it does not fit in the DisplayString
+ (255 bytes max).
+
+ See java.lang.management.RuntimeMXBean.getVmVersion()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRuntime 4 }
+
+jvmRTSpecName OBJECT-TYPE
+ SYNTAX DisplayString
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The Java virtual machine specification name.
+
+ Note that the SNMP agent may have to truncate the string returned
+ by the underlying API if it does not fit in the DisplayString
+ (255 bytes max).
+
+ See java.lang.management.RuntimeMXBean.getSpecName()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRuntime 5 }
+
+jvmRTSpecVendor OBJECT-TYPE
+ SYNTAX DisplayString
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The Java virtual machine specification vendor.
+
+ Note that the SNMP agent may have to truncate the string returned
+ by the underlying API if it does not fit in the DisplayString
+ (255 bytes max).
+
+ See java.lang.management.RuntimeMXBean.getSpecVendor()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRuntime 6 }
+
+jvmRTSpecVersion OBJECT-TYPE
+ SYNTAX DisplayString
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The Java virtual machine specification version.
+
+ Note that the SNMP agent may have to truncate the string returned
+ by the underlying API if it does not fit in the DisplayString
+ (255 bytes max).
+
+ See java.lang.management.RuntimeMXBean.getSpecVersion()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRuntime 7 }
+
+jvmRTManagementSpecVersion OBJECT-TYPE
+ SYNTAX DisplayString
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The version of the management specification for the Java virtual
+ machine implementation.
+
+ Note that the SNMP agent may have to truncate the string returned
+ by the underlying API if it does not fit in the DisplayString
+ (255 bytes max).
+
+ See java.lang.management.RuntimeMXBean.getManagementSpecVersion()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRuntime 8 }
+
+jvmRTBootClassPathSupport OBJECT-TYPE
+ SYNTAX JvmImplSupportStateTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "Indicates whether the Java virtual machine supports the
+ boot class path mechanism used by the bootstrap class loader
+ to search for class files.
+
+ See java.lang.management.RuntimeMXBean.isBootClassPathSupported()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRuntime 9 }
+
+jvmRTInputArgsCount OBJECT-TYPE
+ SYNTAX JvmPositive32TC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The number of input arguments passed to the Java Virtual Machine.
+
+ See java.lang.management.RuntimeMXBean.getInputArguments()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRuntime 10 }
+
+jvmRTUptimeMs OBJECT-TYPE
+ SYNTAX JvmTimeMillis64TC
+ UNITS "milliseconds"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "Uptime of the Java virtual machine, in milliseconds. This is
+ equivalent to ( System.currentTimeMillis() - jvmStartTimeMs ).
+
+ See also jvmRTStartTimeMs.
+
+ See java.lang.management.RuntimeMXBean.getUptime()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRuntime 11 }
+
+jvmRTStartTimeMs OBJECT-TYPE
+ SYNTAX JvmTimeMillis64TC
+ UNITS "milliseconds"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The approximate time when the Java virtual machine started, in
+ milliseconds. This is a time stamp as returned by
+ System.currentTimeMillis(). This time will not change unless
+ the Java Virtual Machine is restarted.
+
+ See also jvmRTUptimeMs.
+
+ See java.lang.management.RuntimeMXBean.getStartTime()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRuntime 12 }
+
+
+-- Object identifiers in the range jvmRuntime.[13-19] are reserved
+-- for future evolution of this MIB.
+--
+-----------------------------------------------------------------------
+--
+-- The JVM Input Argument Table
+--
+-- The jvmRTInputArgsTable contains one row per input argument given on
+-- the Java command line.
+--
+-- See J2SE 5.0 API Specification,
+-- java.lang.management.RuntimeMXBean.getInputArguments()
+-- for more information.
+-----------------------------------------------------------------------
+
+jvmRTInputArgsTable OBJECT-TYPE
+ SYNTAX SEQUENCE OF JvmRTInputArgsEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "The Input Argument Table lists the input arguments passed
+ to the Java Virtual Machine.
+
+ The jvmRTInputArgsIndex is the index of the argument in
+ the array returned by RuntimeMXBean.getInputArguments().
+
+ See java.lang.management.RuntimeMXBean.getInputArguments()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRuntime 20 }
+
+jvmRTInputArgsEntry OBJECT-TYPE
+ SYNTAX JvmRTInputArgsEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "Represent an input argument passed to the Java Virtual Machine.
+
+ See java.lang.management.RuntimeMXBean.getInputArguments()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ INDEX { jvmRTInputArgsIndex }
+ ::= { jvmRTInputArgsTable 1 }
+
+JvmRTInputArgsEntry ::= SEQUENCE {
+ jvmRTInputArgsIndex JvmPositive32TC,
+ jvmRTInputArgsItem JvmArgValueTC
+}
+
+jvmRTInputArgsIndex OBJECT-TYPE
+ SYNTAX JvmPositive32TC
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "The index of the input argument, as in the array returned
+ by RuntimeMXBean.getInputArguments().
+
+ See java.lang.management.RuntimeMXBean.getInputArguments()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRTInputArgsEntry 1 }
+
+jvmRTInputArgsItem OBJECT-TYPE
+ SYNTAX JvmArgValueTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "An input argument at index jvmRTInputArgsIndex, as in the array
+ returned by RuntimeMXBean.getInputArguments().
+
+ Note that the SNMP agent may have to truncate the string returned
+ by the underlying API if it does not fit in the JvmArgValueTC
+ (1023 bytes max).
+
+ See java.lang.management.RuntimeMXBean.getInputArguments()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRTInputArgsEntry 2 }
+
+
+-----------------------------------------------------------------------
+--
+-- The JVM Boot Class Path Table
+--
+-- The jvmRTBootClassPathTable contains one row per path element in the
+-- bootclasspath. This table may not be implemented (or may be empty) if
+-- the bootclasspath feature is not supported by the underlying
+-- implementation.
+--
+-- See J2SE 5.0 API Specification,
+-- java.lang.management.RuntimeMXBean.getBootClassPath()
+-- java.lang.management.RuntimeMXBean.isBootClassPathSupported()
+-- for more information.
+-----------------------------------------------------------------------
+
+jvmRTBootClassPathTable OBJECT-TYPE
+ SYNTAX SEQUENCE OF JvmRTBootClassPathEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "The boot class path that is used by the bootstrap class loader
+ to search for a class file for loading.
+
+ Note that the SNMP agent may have to truncate the bootclasspath
+ elements contained in the string returned by the underlying API
+ if it does not fit in the JvmPathElementTC (1023 bytes max).
+
+ This table is not implemented (or empty) if jvmRTBootClassPathSupport
+ is unsupported(1).
+
+ See java.lang.management.RuntimeMXBean.getBootClassPath()
+ java.lang.management.RuntimeMXBean.isBootClassPathSupported()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRuntime 21 }
+
+jvmRTBootClassPathEntry OBJECT-TYPE
+ SYNTAX JvmRTBootClassPathEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "Represent a path element in the Java Virtual Machine bootclasspath.
+
+ See java.lang.management.RuntimeMXBean.getBootClassPath()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ INDEX { jvmRTBootClassPathIndex }
+ ::= { jvmRTBootClassPathTable 1 }
+
+JvmRTBootClassPathEntry ::= SEQUENCE {
+ jvmRTBootClassPathIndex JvmPositive32TC,
+ jvmRTBootClassPathItem JvmPathElementTC
+}
+
+jvmRTBootClassPathIndex OBJECT-TYPE
+ SYNTAX JvmPositive32TC
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "The index of the path element, as in the array obtained
+ by splitting RuntimeMXBean.getBootClassPath() in its elementary path
+ constituents.
+
+ See java.lang.management.RuntimeMXBean.getBootClassPath()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRTBootClassPathEntry 1 }
+
+jvmRTBootClassPathItem OBJECT-TYPE
+ SYNTAX JvmPathElementTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "An path element at index jvmRTBootClassPathIndex, as in the
+ array obtained by splitting RuntimeMXBean.getBootClassPath() in
+ its elementary path constituents.
+
+ Note that the SNMP agent may have to truncate the string returned
+ by the underlying API if it does not fit in the JvmPathElementTC
+ (1023 bytes max).
+
+ See java.lang.management.RuntimeMXBean.getBootClassPath()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRTBootClassPathEntry 2 }
+
+-----------------------------------------------------------------------
+--
+-- The JVM Class Path Table
+--
+-- The jvmRTClassPathTable contains one row per path element in the
+-- classpath.
+--
+-- See J2SE 5.0 API Specification,
+-- java.lang.management.RuntimeMXBean.getClassPath()
+-- for more information.
+-----------------------------------------------------------------------
+
+jvmRTClassPathTable OBJECT-TYPE
+ SYNTAX SEQUENCE OF JvmRTClassPathEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "The class path that is used by the system class loader
+ to search for a class file.
+
+ Note that the SNMP agent may have to truncate the classpath
+ elements contained in the string returned by the underlying API
+ if it does not fit in the JvmPathElementTC (1023 bytes max).
+
+ See java.lang.management.RuntimeMXBean.getClassPath()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRuntime 22 }
+
+jvmRTClassPathEntry OBJECT-TYPE
+ SYNTAX JvmRTClassPathEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "Represent a path element in the Java Virtual Machine classpath.
+
+ See java.lang.management.RuntimeMXBean.getClassPath()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ INDEX { jvmRTClassPathIndex }
+ ::= { jvmRTClassPathTable 1 }
+
+JvmRTClassPathEntry ::= SEQUENCE {
+ jvmRTClassPathIndex JvmPositive32TC,
+ jvmRTClassPathItem JvmPathElementTC
+}
+
+jvmRTClassPathIndex OBJECT-TYPE
+ SYNTAX JvmPositive32TC
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "The index of the path element, as in the array obtained
+ by splitting RuntimeMXBean.getClassPath() in its elementary
+ path constituents.
+
+ See java.lang.management.RuntimeMXBean.getClassPath()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRTClassPathEntry 1 }
+
+jvmRTClassPathItem OBJECT-TYPE
+ SYNTAX JvmPathElementTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "An path element at index jvmRTClassPathIndex, as in the array
+ obtained by splitting RuntimeMXBean.getClassPath() in its elementary
+ path constituents.
+
+ Note that the SNMP agent may have to truncate the string returned
+ by the underlying API if it does not fit in the JvmPathElementTC
+ (1023 bytes max).
+
+ See java.lang.management.RuntimeMXBean.getClassPath()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRTClassPathEntry 2 }
+
+-----------------------------------------------------------------------
+--
+-- The JVM Library Path Table
+--
+-- The jvmRTLibraryPathTable contains one row per path element in the
+-- librarypath.
+--
+-- See J2SE 5.0 API Specification,
+-- java.lang.management.RuntimeMXBean.getLibraryPath()
+-- for more information.
+-----------------------------------------------------------------------
+
+jvmRTLibraryPathTable OBJECT-TYPE
+ SYNTAX SEQUENCE OF JvmRTLibraryPathEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "The library path.
+
+ Note that the SNMP agent may have to truncate the librarypath
+ elements contained in the string returned by the underlying API
+ if it does not fit in the JvmPathElementTC (1023 bytes max).
+
+ See java.lang.management.RuntimeMXBean.getLibraryPath()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRuntime 23 }
+
+jvmRTLibraryPathEntry OBJECT-TYPE
+ SYNTAX JvmRTLibraryPathEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "Represent a path element in the Java Virtual Machine librarypath.
+
+ See java.lang.management.RuntimeMXBean.getLibraryPath()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ INDEX { jvmRTLibraryPathIndex }
+ ::= { jvmRTLibraryPathTable 1 }
+
+JvmRTLibraryPathEntry ::= SEQUENCE {
+ jvmRTLibraryPathIndex JvmPositive32TC,
+ jvmRTLibraryPathItem JvmPathElementTC
+}
+
+jvmRTLibraryPathIndex OBJECT-TYPE
+ SYNTAX JvmPositive32TC
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "The index of the path element, as in the array obtained
+ by splitting RuntimeMXBean.getLibraryPath() in its elementary
+ constituents.
+
+ See java.lang.management.RuntimeMXBean.getLibraryPath()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRTLibraryPathEntry 1 }
+
+jvmRTLibraryPathItem OBJECT-TYPE
+ SYNTAX JvmPathElementTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "An path element at index jvmRTLibraryPathIndex, as in the array
+ obtained by splitting RuntimeMXBean.getLibraryPath() in its elementary
+ path constituents.
+
+ Note that the SNMP agent may have to truncate the string returned
+ by the underlying API if it does not fit in the JvmPathElementTC
+ (1023 bytes max).
+
+ See java.lang.management.RuntimeMXBean.getLibraryPath()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.RuntimeMXBean"
+ ::= { jvmRTLibraryPathEntry 2 }
+
+-----------------------------------------------------------------------
+--
+-- The JVM Compilation group
+--
+-- A collection of objects used to monitor the Java Virtual Machine
+-- Runtime Compiler (JIT). These objects define the SNMP management
+-- interface for the compilation system of the Java virtual machine.
+--
+-- The JVM Compilation group defines object mapped from the
+-- java.lang.management.CompilationMXBean interface.
+--
+-- See J2SE 5.0 API Specification, java.lang.management.CompilationMXBean for
+-- a detailed description of the runtime system.
+--
+-----------------------------------------------------------------------
+
+jvmCompilation OBJECT IDENTIFIER ::= { jvmMgtMIBObjects 5 }
+
+-- The following objects are mapped from the CompilationMXBean interface.
+-----------------------------------------------------------------------
+
+jvmJITCompilerName OBJECT-TYPE
+ SYNTAX JvmJavaObjectNameTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The name of the Just-in-time (JIT) compiler.
+
+ See java.lang.management.CompilationMXBean.getName()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.CompilationMXBean"
+ ::= { jvmCompilation 1 }
+
+jvmJITCompilerTimeMs OBJECT-TYPE
+ SYNTAX JvmTimeMillis64TC
+ UNITS "milliseconds"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "Gets the approximate accumulated elapsed time (in milliseconds)
+ spent in compilation since the Java virtual machine has started.
+ If multiple threads are used for compilation, this value is
+ the summation of the approximate time that each thread
+ spent in compilation.
+
+ If compiler time monitoring is not supported, then this object
+ remains set to 0.
+
+ See java.lang.management.CompilationMXBean.getTotalCompilationTime()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.CompilationMXBean"
+ ::= { jvmCompilation 2 }
+
+
+jvmJITCompilerTimeMonitoring OBJECT-TYPE
+ SYNTAX JvmImplSupportStateTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "Indicates whether the Java virtual machine supports
+ compilation time monitoring.
+
+ See java.lang.management.CompilationMXBean.
+ isCompilationTimeMonitoringSupported()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.CompilationMXBean"
+ ::= { jvmCompilation 3 }
+
+-----------------------------------------------------------------------
+--
+-- The JVM Operating System group
+--
+-- A collection of objects used to monitor some resource of the
+-- Operating System the Java Virtual Machine is running on. These objects
+-- define the SNMP management interface offered by the Java virtual machine
+-- for the operating system on which it is running.
+--
+-- The JVM Operating System group defines object mapped from the
+-- java.lang.management.OperatingSystemMXBean interface.
+--
+-- See J2SE 5.0 API Specification, java.lang.management.OperatingSystemMXBean
+-- for a detailed description of the operating system.
+--
+-----------------------------------------------------------------------
+
+jvmOS OBJECT IDENTIFIER ::= { jvmMgtMIBObjects 6 }
+
+-- The following objects are mapped from the OperatingSystemMXBean interface.
+-----------------------------------------------------------------------
+
+jvmOSName OBJECT-TYPE
+ SYNTAX JvmJavaObjectNameTC
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The operating system name.
+
+ See java.lang.management.OperatingSystemMXBean.getName()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.OperatingSystemMXBean"
+ ::= { jvmOS 1 }
+
+jvmOSArch OBJECT-TYPE
+ SYNTAX DisplayString
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The operating system architecture.
+
+ Note that the SNMP agent may have to truncate the string returned
+ by the underlying API if it does not fit in the DisplayString
+ (255 bytes max).
+
+ See java.lang.management.OperatingSystemMXBean.getArch()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.OperatingSystemMXBean"
+ ::= { jvmOS 2 }
+
+jvmOSVersion OBJECT-TYPE
+ SYNTAX DisplayString
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The operating system version.
+
+ Note that the SNMP agent may have to truncate the string returned
+ by the underlying API if it does not fit in the DisplayString
+ (255 bytes max).
+
+ See java.lang.management.OperatingSystemMXBean.getVersion()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.OperatingSystemMXBean"
+ ::= { jvmOS 3 }
+
+jvmOSProcessorCount OBJECT-TYPE
+
+ SYNTAX Integer32
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The number of processors available to the Java virtual machine.
+
+ See java.lang.management.OperatingSystemMXBean.getAvailableProcessors()
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.OperatingSystemMXBean"
+ ::= { jvmOS 4 }
+
+--
+-- NOTIFICATIONS
+--
+-----------------------------------------------------------------------
+
+--
+-- Low Memory Notifications
+--
+
+jvmMgtMIBMemoryNotifs OBJECT IDENTIFIER ::= { jvmMgtMIBNotifications 2 }
+jvmMgtMIBLowMemoryNotifs OBJECT IDENTIFIER ::= { jvmMgtMIBMemoryNotifs 1 }
+
+jvmLowMemoryPrefix OBJECT IDENTIFIER
+ ::= { jvmMgtMIBLowMemoryNotifs 0 }
+
+-- Not used at this time, but reserved for future evolution of this MIB:
+--
+-- jvmLowMemoryData OBJECT IDENTIFIER
+-- ::= { jvmMgtMIBLowMemoryNotifs 1 }
+--
+
+jvmLowMemoryPoolUsageNotif NOTIFICATION-TYPE
+ OBJECTS { jvmMemPoolName, jvmMemPoolUsed, jvmMemPoolThreshdCount }
+ STATUS current
+ DESCRIPTION
+ "This notification is sent when the memory usage threshold of
+ a memory pool is exceeded.
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryNotification,
+ java.lang.management.MemoryPoolMXBean"
+ ::= { jvmLowMemoryPrefix 1 }
+
+jvmLowMemoryPoolCollectNotif NOTIFICATION-TYPE
+ OBJECTS { jvmMemPoolName, jvmMemPoolCollectUsed,
+ jvmMemPoolCollectThreshdCount }
+ STATUS current
+ DESCRIPTION
+ "This notification is sent when the collection memory usage
+ threshold of a memory pool is exceeded.
+ "
+ REFERENCE "J2SE 5.0 API Specification,
+ java.lang.management.MemoryNotification,
+ java.lang.management.MemoryPoolMXBean"
+ ::= { jvmLowMemoryPrefix 2 }
+
+--
+-- Conformance Section
+--
+-----------------------------------------------------------------------
+
+-- conformance information
+
+jvmMgtMIBCompliances
+ OBJECT IDENTIFIER ::= { jvmMgtMIBConformance 1 }
+jvmMgtMIBGroups
+ OBJECT IDENTIFIER ::= { jvmMgtMIBConformance 2 }
+
+
+-- compliance statements
+
+jvmManagementCompliance MODULE-COMPLIANCE
+ STATUS current
+ DESCRIPTION
+ "The compliance statement for SNMP entities which
+ implement this MIB."
+ MODULE -- this module
+ MANDATORY-GROUPS {
+ jvmClassLoadingBasicGroup,
+ jvmClassLoadingSetGroup,
+ jvmMemoryBasicGroup,
+ jvmMemoryHeapUsageGroup,
+ jvmMemoryNonHeapUsageGroup,
+ jvmMemorySetGroup,
+ jvmMemManagerGroup,
+ jvmMemGCGroup,
+ jvmMemPoolBasicGroup,
+ jvmMemPoolUsageGroup,
+ jvmMemPoolPeakUsageGroup,
+ jvmMemPoolCollectUsageGroup,
+ jvmMemMgrPoolRelationGroup,
+ jvmThreadBasicGroup,
+ jvmThreadInstanceBasicGroup,
+ jvmRuntimeBasicGroup,
+ jvmOSGroup
+ }
+
+ -- optional/conditional groups
+ GROUP jvmMemPoolMonitoringGroup
+ DESCRIPTION
+ "This group may not be implemented if the Java virtual
+ machine does not support low memory detection in memory usage.
+ "
+ GROUP jvmMemPoolCollectMonitoringGroup
+ DESCRIPTION
+ "This group may not be implemented if the Java virtual
+ machine does not support low memory detection in collection
+ memory usage.
+ "
+ GROUP jvmLowMemoryUsageNotifGroup
+ DESCRIPTION
+ "This group may not be implemented if the Java virtual
+ machine does not support low memory usage detection.
+ "
+ GROUP jvmLowMemoryCollectNotifGroup
+ DESCRIPTION
+ "This group may not be implemented if the Java virtual
+ machine does not support low collection memory usage detection.
+ "
+ GROUP jvmThreadInstanceCpuGroup
+ DESCRIPTION
+ "This group may not be implemented if the Java virtual
+ machine does not support CPU time measurement for other threads.
+ "
+ GROUP jvmThreadInstanceBlockGroup
+ DESCRIPTION
+ "This group may not be implemented if the Java virtual
+ machine does not support thread contention monitoring.
+ "
+ GROUP jvmRuntimeBootCPGroup
+ DESCRIPTION
+ "This group may not be implemented if the underlying
+ implementation does not support the bootclasspath feature.
+ "
+ GROUP jvmJITCompilerBasicGroup
+ DESCRIPTION
+ "This group may not be implemented if the Java virtual
+ machine has no compilation system.
+ "
+ GROUP jvmJITCompilerTimeStatGroup
+ DESCRIPTION
+ "This group may not be implemented if the Java virtual
+ machine has no compilation system, or does not support
+ JIT Compiler time statistics.
+ "
+ ::= { jvmMgtMIBCompliances 1 }
+
+
+-- units of conformance
+
+jvmClassLoadingGroups OBJECT IDENTIFIER ::= { jvmMgtMIBGroups 1 }
+
+jvmClassLoadingBasicGroup OBJECT-GROUP
+ OBJECTS {
+ jvmClassesLoadedCount,
+ jvmClassesTotalLoadedCount,
+ jvmClassesUnloadedCount
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of objects that are mapped from JSR 163
+ java.lang.management.ClassLoadingMXBean interface.
+ "
+ ::= { jvmClassLoadingGroups 1 }
+
+jvmClassLoadingSetGroup OBJECT-GROUP
+ OBJECTS {
+ jvmClassesVerboseLevel
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of writable scalar objects that are mapped from JSR 163
+ java.lang.management.ClassLoadingMXBean interface, and make it possible
+ to act on class loading. Accessing these objects may
+ require special permissions - the agent implementation is
+ responsible for puting in place the appropriate access control
+ if needed.
+ "
+ ::= { jvmClassLoadingGroups 2 }
+
+jvmMemoryGroups OBJECT IDENTIFIER ::= { jvmMgtMIBGroups 2 }
+
+jvmMemoryBasicGroup OBJECT-GROUP
+ OBJECTS {
+ jvmMemoryPendingFinalCount
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of columnar objects that are mapped from JSR 163
+ java.lang.management.MemoryManagerMXBean interface.
+ "
+ ::= { jvmMemoryGroups 1 }
+
+jvmMemoryHeapUsageGroup OBJECT-GROUP
+ OBJECTS {
+ jvmMemoryHeapInitSize,
+ jvmMemoryHeapUsed,
+ jvmMemoryHeapCommitted,
+ jvmMemoryHeapMaxSize
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of objects that are mapped from JSR 163
+ java.lang.management.MemoryMXBean.getHeapMemoryUsage().
+ When several of these objects are requested within a single
+ SNMP request, the agent must ensure that
+ java.lang.management.MemoryPoolMXBean.getHeapMemoryUsage() is
+ called only once, in order to guarantee that the set of
+ values returned for these objects remain coherent and give
+ a consistent snapshot of the heap memory usage made by
+ Heap Memory Pools.
+ "
+ ::= { jvmMemoryGroups 2 }
+
+jvmMemoryNonHeapUsageGroup OBJECT-GROUP
+ OBJECTS {
+ jvmMemoryNonHeapInitSize,
+ jvmMemoryNonHeapUsed,
+ jvmMemoryNonHeapCommitted,
+ jvmMemoryNonHeapMaxSize
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of objects that are mapped from JSR 163
+ java.lang.management.MemoryMXBean.getNonHeapMemoryUsage().
+ When several of these objects are requested within a single
+ SNMP request, the agent must ensure that
+ java.lang.management.MemoryPoolMXBean.getNonHeapMemoryUsage() is
+ called only once, in order to guarantee that the set of
+ values returned for these objects remain coherent and give
+ a consistent snapshot of the non heap memory usage made by
+ Non Heap Memory Pools.
+ "
+ ::= { jvmMemoryGroups 3 }
+
+jvmMemorySetGroup OBJECT-GROUP
+ OBJECTS {
+ jvmMemoryGCVerboseLevel,
+ jvmMemoryGCCall
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of writable scalar objects that are mapped from JSR 163
+ java.lang.management.MemoryMXBean interface, and make it possible
+ to act on the Garbage Collector. Accessing these objects may
+ require special permissions - the agent implementation is
+ responsible for puting in place the appropriate access control
+ if needed.
+ "
+ ::= { jvmMemoryGroups 4 }
+
+jvmMemManagerGroup OBJECT-GROUP
+ OBJECTS {
+ jvmMemManagerName,
+ jvmMemManagerState
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of columnar objects that are mapped from JSR 163
+ java.lang.management.MemoryManagerMXBean interface.
+ "
+ ::= { jvmMemoryGroups 5 }
+
+jvmMemGCGroup OBJECT-GROUP
+ OBJECTS {
+ jvmMemGCCount,
+ jvmMemGCTimeMs
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of columnar objects that are mapped from JSR 163
+ java.lang.management.GarbageCollectorMXBean interface, and are
+ specific to GarbageCollector MXBeans.
+ These objects are used to model the inheritence link between
+ GarbageCollectorMXBean and its super interface - MemoryManagerMXBean.
+ "
+ ::= { jvmMemoryGroups 6 }
+
+jvmMemPoolGroups OBJECT IDENTIFIER ::= { jvmMemoryGroups 7 }
+
+jvmMemPoolBasicGroup OBJECT-GROUP
+ OBJECTS {
+ jvmMemPoolName,
+ jvmMemPoolType,
+ jvmMemPoolState,
+ jvmMemPoolPeakReset,
+ jvmMemPoolThreshdSupport,
+ jvmMemPoolCollectThreshdSupport
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of columnar objects that are mapped from JSR 163
+ java.lang.management.MemoryPoolMXBean interface.
+ "
+ ::= { jvmMemPoolGroups 1 }
+
+jvmMemPoolMonitoringGroup OBJECT-GROUP
+ OBJECTS {
+ jvmMemPoolThreshold,
+ jvmMemPoolThreshdCount
+ }
+ STATUS current
+ DESCRIPTION
+ "Memory usage threshold objects mapped from
+ JSR 163 java.lang.management.MemoryPoolMXBean interface, which makes
+ it possible to configure low memory detection.
+ Accessing this object may require special permissions - the agent
+ implementation is responsible for puting in place the appropriate
+ access control if needed.
+ "
+ ::= { jvmMemPoolGroups 2 }
+
+jvmMemPoolUsageGroup OBJECT-GROUP
+ OBJECTS {
+ jvmMemPoolInitSize,
+ jvmMemPoolUsed,
+ jvmMemPoolCommitted,
+ jvmMemPoolMaxSize
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of objects that are mapped from JSR 163
+ java.lang.management.MemoryPoolMXBean.getUsage().
+ When several of these objects are requested within a single
+ SNMP request, the agent must ensure that
+ java.lang.management.MemoryPoolMXBean.getUsage() is
+ called only once, in order to guarantee that the set of
+ values returned for these objects remain coherent and give
+ a consistent snapshot of the memory used by this Memory
+ Pool.
+ "
+ ::= { jvmMemPoolGroups 3 }
+
+jvmMemPoolPeakUsageGroup OBJECT-GROUP
+ OBJECTS {
+ jvmMemPoolPeakUsed,
+ jvmMemPoolPeakCommitted,
+ jvmMemPoolPeakMaxSize
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of objects that are mapped from JSR 163
+ java.lang.management.MemoryPoolMXBean.getPeakUsage().
+ When several of these objects are requested within a single
+ SNMP request, the agent must ensure that
+ java.lang.management.MemoryPoolMXBean.getPeakUsage() is
+ called only once, in order to guarantee that the set of
+ values returned for these objects remain coherent and give
+ a consistent snapshot of the peak memory usage made by
+ this Memory Pool.
+ "
+ ::= { jvmMemPoolGroups 4 }
+
+jvmMemPoolCollectUsageGroup OBJECT-GROUP
+ OBJECTS {
+ jvmMemPoolCollectUsed,
+ jvmMemPoolCollectCommitted,
+ jvmMemPoolCollectMaxSize
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of objects that are mapped from JSR 163
+ java.lang.management.MemoryPoolMXBean.getCollectionUsage().
+ When several of these objects are requested within a single
+ SNMP request, the agent must ensure that
+ java.lang.management.MemoryPoolMXBean.getCollectionUsage() is
+ called only once, in order to guarantee that the set of
+ values returned for these objects remain coherent and give
+ a consistent snapshot of the collection memory usage made by
+ this Memory Pool.
+ "
+ ::= { jvmMemPoolGroups 5 }
+
+jvmMemPoolCollectMonitoringGroup OBJECT-GROUP
+ OBJECTS {
+ jvmMemPoolCollectThreshold,
+ jvmMemPoolCollectThreshdCount
+ }
+ STATUS current
+ DESCRIPTION
+ "Memory collection usage threshold objects mapped from JSR 163
+ java.lang.management.MemoryPoolMXBean interface, which makes
+ it possible to configure low memory detection.
+ Accessing this object may require special permissions - the agent
+ implementation is responsible for putting in place the appropriate
+ access control if needed.
+ "
+ ::= { jvmMemPoolGroups 6 }
+
+
+jvmMemMgrPoolRelationGroup OBJECT-GROUP
+ OBJECTS {
+ jvmMemMgrRelManagerName,
+ jvmMemMgrRelPoolName
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of columnar objects that are mapped from JSR 163
+ java.lang.management.MemoryPoolMXBean and
+ java.lang.management.MemoryManagerMXBean interface, and show the
+ relationship between Memory Managers and Memory Pools.
+ "
+ ::= { jvmMemoryGroups 8 }
+
+jvmThreadGroups OBJECT IDENTIFIER ::= { jvmMgtMIBGroups 3 }
+
+jvmThreadBasicGroup OBJECT-GROUP
+ OBJECTS {
+ jvmThreadCount,
+ jvmThreadDaemonCount,
+ jvmThreadPeakCount,
+ jvmThreadTotalStartedCount,
+ jvmThreadContentionMonitoring,
+ jvmThreadCpuTimeMonitoring,
+ jvmThreadPeakCountReset
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of scalar objects that are mapped from JSR 163
+ java.lang.management.ThreadMXBean interface.
+ "
+ ::= { jvmThreadGroups 1 }
+
+jvmThreadInstanceGroups OBJECT IDENTIFIER ::= { jvmThreadGroups 2 }
+
+jvmThreadInstanceBasicGroup OBJECT-GROUP
+ OBJECTS {
+ jvmThreadInstId,
+ jvmThreadInstState,
+ jvmThreadInstName,
+ jvmThreadInstLockName,
+ jvmThreadInstLockOwnerPtr
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of columnar objects that are mapped from JSR 163
+ java.lang.management.ThreadMXBean interface, and are
+ relative to an instance of java.lang.Thread.
+ "
+ ::= { jvmThreadInstanceGroups 1}
+
+jvmThreadInstanceCpuGroup OBJECT-GROUP
+ OBJECTS {
+ jvmThreadInstCpuTimeNs
+ }
+ STATUS current
+ DESCRIPTION
+ "A columnar object mapped from JSR 163
+ java.lang.management.ThreadMXBean interface which provides CPU
+ time statistics about an instance of java.lang.Thread.
+ "
+ ::= { jvmThreadInstanceGroups 2 }
+
+
+jvmThreadInstanceBlockGroup OBJECT-GROUP
+ OBJECTS {
+ jvmThreadInstBlockCount,
+ jvmThreadInstBlockTimeMs,
+ jvmThreadInstWaitCount,
+ jvmThreadInstWaitTimeMs
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of columnar objects that are mapped from JSR 163
+ java.lang.management.ThreadMXBean interface, and which provide
+ synchronization statistics about an instance of java.lang.Thread.
+ "
+ ::= { jvmThreadInstanceGroups 3 }
+
+
+jvmRuntimeGroups OBJECT IDENTIFIER ::= { jvmMgtMIBGroups 4 }
+
+jvmRuntimeBasicGroup OBJECT-GROUP
+ OBJECTS {
+ jvmRTName,
+ jvmRTVMName,
+ jvmRTVMVendor,
+ jvmRTVMVersion,
+ jvmRTSpecName,
+ jvmRTSpecVendor,
+ jvmRTSpecVersion,
+ jvmRTManagementSpecVersion,
+ jvmRTUptimeMs,
+ jvmRTStartTimeMs,
+ jvmRTBootClassPathSupport,
+ jvmRTInputArgsCount,
+ jvmRTInputArgsItem,
+ jvmRTClassPathItem,
+ jvmRTLibraryPathItem
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of objects that are mapped from JSR 163
+ java.lang.management.RuntimeMXBean interface.
+ "
+ ::= { jvmRuntimeGroups 1 }
+
+
+jvmRuntimeBootCPGroup OBJECT-GROUP
+ OBJECTS {
+ jvmRTBootClassPathItem
+ }
+ STATUS current
+ DESCRIPTION
+ "A columnar object that is mapped from JSR 163
+ java.lang.management.RuntimeMXBean.getBootClassPath() interface,
+ and provide information about bootclasspath elements.
+ "
+ ::= { jvmRuntimeGroups 2 }
+
+jvmJITCompilerGroups OBJECT IDENTIFIER ::= { jvmMgtMIBGroups 5 }
+
+jvmJITCompilerBasicGroup OBJECT-GROUP
+ OBJECTS {
+ jvmJITCompilerName,
+ jvmJITCompilerTimeMonitoring
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of objects that are mapped from JSR 163
+ java.lang.management.CompilationMXBean interface.
+ "
+ ::= { jvmJITCompilerGroups 1 }
+
+jvmJITCompilerTimeStatGroup OBJECT-GROUP
+ OBJECTS {
+ jvmJITCompilerTimeMs
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of objects that are mapped from JSR 163
+ java.lang.management.CompilationMXBean interface and provide
+ time statistic about the JIT Compiler.
+ "
+ ::= { jvmJITCompilerGroups 2 }
+
+jvmOSGroup OBJECT-GROUP
+ OBJECTS {
+ jvmOSName,
+ jvmOSArch,
+ jvmOSVersion,
+ jvmOSProcessorCount
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of objects that are mapped from JSR 163
+ java.lang.management.OperatingSystemMXBean interface.
+ "
+ ::= { jvmMgtMIBGroups 6 }
+
+jvmLowMemoryUsageNotifGroup NOTIFICATION-GROUP
+ NOTIFICATIONS {
+ jvmLowMemoryPoolUsageNotif
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of notifications emitted when low
+ memory usage conditions are detected.
+ "
+ ::= { jvmMgtMIBGroups 7 }
+
+jvmLowMemoryCollectNotifGroup NOTIFICATION-GROUP
+ NOTIFICATIONS {
+ jvmLowMemoryPoolCollectNotif
+ }
+ STATUS current
+ DESCRIPTION
+ "A collection of notifications emitted when low
+ collection memory usage conditions are detected.
+ "
+ ::= { jvmMgtMIBGroups 8 }
+
+END
--- a/jdk/src/java.security.jgss/share/classes/jgss-overview.html Mon Apr 24 07:10:37 2017 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,9 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
-<html>
- <head>
- <title>Java(tm) Authentication and Authorization Classes </title>
- </head>
- <body>
- This package contains GSS-API utilities for using in conjunction with Sun Microsystem's implementation of Java GSS-API.
- </body>
-</html>
--- a/jdk/src/jdk.jdi/share/classes/jdi-overview.html Mon Apr 24 07:10:37 2017 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,86 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
-<html>
- <head>
- <title>Java™ Debug Interface</title>
- </head>
- <body>
- The Java™ Debug Interface (JDI) is a high level Java
-API providing information useful for debuggers and similar
-systems needing access to the running state of a (usually remote)
-virtual machine.
-<p>
- The JDI provides introspective
-access to a running virtual machine's state, Class, Array,
-Interface, and primitive types, and instances of those
-types.
-<P>
-The JDI also provides explicit control over
-a virtual machine's execution. The ability to suspend
-and resume threads, and to set breakpoints, watchpoints, ...
-Notification
-of exceptions, class loading, thread creation...
-The ability to inspect a suspended thread's state,
-local variables, stack backtrace...
-<p>
-JDI is the highest-layer of the Java Platform Debugger Architecture (JPDA).
-For more information on the Java Platform Debugger Architecture, see the
-<a href="{@docRoot}/../../../../technotes/guides/jpda/index.html">
-Java Platform Debugger Architecture documentation</a>
-for this release and the
-<a href="http://java.sun.com/products/jpda">Java Platform Debugger Architecture website</a>.
-<p>
-<font size="+1"><b>Global Exceptions:</b></font>
-<p>
-This section documents exceptions which apply to the entire API and are thus
-not documented on individual methods.
-
- <blockquote>
- <p>
- <b>{@link com.sun.jdi.VMMismatchException}</b>
- <p>
- Any method on a {@link com.sun.jdi.Mirror} that takes a <code>Mirror</code> as an
- parameter directly or indirectly (e.g., as a element in a <code>List</code>) will
- throw {@link com.sun.jdi.VMMismatchException} if the mirrors are from different
- virtual machines.
- <p>
- <b>{@link java.lang.NullPointerException}</b>
- <p>
- Any method which takes a {@link java.lang.Object} as an parameter will throw
- {@link java.lang.NullPointerException} if null is passed directly or indirectly
- -- unless null is explicitly mentioned as a valid parameter.
- </blockquote>
- NOTE: The exceptions below may be thrown whenever the specified
- conditions are met but a guarantee that they are thrown only
- exists when a valid result cannot be returned.
- <blockquote>
- <p>
- <b>{@link com.sun.jdi.VMDisconnectedException}</b>
- <p>
- Any method on {@link com.sun.jdi.ObjectReference}, {@link com.sun.jdi.ReferenceType},
- {@link com.sun.jdi.request.EventRequest}, {@link com.sun.jdi.StackFrame}, or
- {@link com.sun.jdi.VirtualMachine} or which takes one of these directly or indirectly
- as an parameter may throw {@link com.sun.jdi.VMDisconnectedException} if the target VM
- is disconnected and the {@link com.sun.jdi.event.VMDisconnectEvent} has been or is available
- to be read from the {@link com.sun.jdi.event.EventQueue}.
- <p>
- <b>{@link com.sun.jdi.VMOutOfMemoryException}</b>
- <p>
- Any method on {@link com.sun.jdi.ObjectReference}, {@link com.sun.jdi.ReferenceType},
- {@link com.sun.jdi.request.EventRequest}, {@link com.sun.jdi.StackFrame}, or
- {@link com.sun.jdi.VirtualMachine} or which takes one of these directly or indirectly
- as an parameter may throw {@link com.sun.jdi.VMOutOfMemoryException} if the target
- VM has run out of memory.
- <p>
- <b>{@link com.sun.jdi.ObjectCollectedException}</b>
- <p>
- Any method on {@link com.sun.jdi.ObjectReference} or which directly or indirectly takes
- <code>ObjectReference</code> as parameter may throw {@link com.sun.jdi.ObjectCollectedException}
- if the mirrored object has been garbage collected.
- <p>
- Any method on {@link com.sun.jdi.ReferenceType} or which directly or indirectly takes
- <code>ReferenceType</code> as parameter may throw {@link com.sun.jdi.ObjectCollectedException}
- if the mirrored type has been unloaded.
-
- </blockquote>
- </body>
-</html>
--- a/jdk/src/jdk.jdi/share/classes/module-info.java Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/src/jdk.jdi/share/classes/module-info.java Mon Apr 24 10:49:43 2017 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 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
@@ -24,7 +24,84 @@
*/
/**
- * Defines the Java Debugger Interface.
+ * Defines the Java Debug Interface.
+ * <p>
+ * The Java™ Debug Interface (JDI) is a high level Java API providing
+ * information useful for debuggers and similar systems needing access to the
+ * running state of a (usually remote) virtual machine.
+ * <p>
+ * JDI provides introspective access to a running virtual machine's state,
+ * Class, Array, Interface, and primitive types, and instances of those types.
+ * <p>
+ * JDI also provides explicit control over a virtual machine's execution.
+ * The ability to suspend and resume threads, and to set breakpoints,
+ * watchpoints, etc. Notification of exceptions, class loading, thread
+ * creation, etc. The ability to inspect a suspended thread's state, local
+ * variables, stack backtrace, etc.
+ * <p>
+ * JDI is the highest-layer of the Java Platform Debugger Architecture (JPDA).
+ * For more information on the Java Platform Debugger Architecture, see the <a
+ * href="{@docRoot}/../../../../technotes/guides/jpda/index.html"> Java
+ * Platform Debugger Architecture documentation</a> for this release and the <a
+ * href="http://java.sun.com/products/jpda">Java Platform Debugger Architecture
+ * website</a>.
+ * <p>
+ * <font size="+1"><b>Global Exceptions:</b></font>
+ * <p>
+ * This section documents exceptions which apply to the entire API and are thus
+ * not documented on individual methods.
+ * <blockquote>
+ * <p>
+ * <b>{@link com.sun.jdi.VMMismatchException}</b>
+ * <p>
+ * Any method on a {@link com.sun.jdi.Mirror} that takes a
+ * {@code Mirror} as an parameter directly or indirectly (e.g., as a
+ * element in a {@code List}) will throw {@link
+ * com.sun.jdi.VMMismatchException} if the mirrors are from different virtual
+ * machines.
+ * <p>
+ * <b>{@link java.lang.NullPointerException}</b>
+ * <p>
+ * Any method which takes a {@link java.lang.Object} as an parameter will
+ * throw {@link java.lang.NullPointerException} if null is passed directly or
+ * indirectly -- unless null is explicitly mentioned as a valid parameter.
+ * </blockquote>
+ * NOTE: The exceptions below may be thrown whenever the specified conditions
+ * are met but a guarantee that they are thrown only exists when a valid result
+ * cannot be returned.
+ * <blockquote>
+ * <p>
+ * <b>{@link com.sun.jdi.VMDisconnectedException}</b>
+ * <p>
+ * Any method on {@link com.sun.jdi.ObjectReference}, {@link
+ * com.sun.jdi.ReferenceType}, {@link com.sun.jdi.request.EventRequest},
+ * {@link com.sun.jdi.StackFrame}, or {@link com.sun.jdi.VirtualMachine} or
+ * which takes one of these directly or indirectly as an parameter may throw
+ * {@link com.sun.jdi.VMDisconnectedException} if the target VM is
+ * disconnected and the {@link com.sun.jdi.event.VMDisconnectEvent} has been
+ * or is available to be read from the {@link com.sun.jdi.event.EventQueue}.
+ * <p>
+ * <b>{@link com.sun.jdi.VMOutOfMemoryException}</b>
+ * <p>
+ * Any method on {@link com.sun.jdi.ObjectReference}, {@link
+ * com.sun.jdi.ReferenceType}, {@link com.sun.jdi.request.EventRequest},
+ * {@link com.sun.jdi.StackFrame}, or {@link com.sun.jdi.VirtualMachine} or
+ * which takes one of these directly or indirectly as an parameter may throw
+ * {@link com.sun.jdi.VMOutOfMemoryException} if the target VM has run out of
+ * memory.
+ * <p>
+ * <b>{@link com.sun.jdi.ObjectCollectedException}</b>
+ * <p>
+ * Any method on {@link com.sun.jdi.ObjectReference} or which directly or
+ * indirectly takes {@code ObjectReference} as parameter may throw
+ * {@link com.sun.jdi.ObjectCollectedException} if the mirrored object has
+ * been garbage collected.
+ * <p>
+ * Any method on {@link com.sun.jdi.ReferenceType} or which directly or
+ * indirectly takes {@code ReferenceType} as parameter may throw {@link
+ * com.sun.jdi.ObjectCollectedException} if the mirrored type has been
+ * unloaded.
+ * </blockquote>
*
* @moduleGraph
* @since 9
--- a/jdk/src/jdk.pack/share/classes/module-info.java Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/src/jdk.pack/share/classes/module-info.java Mon Apr 24 10:49:43 2017 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 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
@@ -23,6 +23,13 @@
* questions.
*/
+/**
+ * Defines tools for transforming a JAR file into a compressed pack200 file
+ * and transforming a packed file into a JAR file, including the pack200,
+ * and unpack200 tools.
+ *
+ * @moduleGraph
+ * @since 9
+ */
module jdk.pack {
}
-
--- a/jdk/src/jdk.rmic/share/classes/module-info.java Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/src/jdk.rmic/share/classes/module-info.java Mon Apr 24 10:49:43 2017 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 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
@@ -23,9 +23,16 @@
* questions.
*/
+/**
+ * Defines the rmic compiler for generating stubs and skeletons using
+ * the Java Remote Method Protocol (JRMP) and
+ * stubs and tie class files (IIOP protocol) for remote objects.
+ *
+ * @moduleGraph
+ * @since 9
+ */
module jdk.rmic {
requires java.corba;
requires jdk.compiler;
requires jdk.javadoc;
}
-
--- a/jdk/src/jdk.security.auth/share/classes/jaas-overview.html Mon Apr 24 07:10:37 2017 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,9 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
-<html>
-<head>
- <title>Java(tm) Authentication and Authorization Classes </title>
- </head>
- <body>
- This package contains Sun's implementation of the javax.security.auth.* interfaces and authentication modules.
- </body>
-</html>
--- a/jdk/test/ProblemList.txt Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/test/ProblemList.txt Mon Apr 24 10:49:43 2017 -0700
@@ -280,8 +280,6 @@
# jdk_util
-java/util/BitSet/BitSetStreamTest.java 8079538 generic-all
-
############################################################################
# jdk_instrument
--- a/jdk/test/TEST.ROOT Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/test/TEST.ROOT Mon Apr 24 10:49:43 2017 -0700
@@ -18,7 +18,7 @@
othervm.dirs=java/awt java/beans javax/accessibility javax/imageio javax/sound javax/print javax/management com/sun/awt sun/awt sun/java2d sun/pisces javax/xml/jaxp/testng/validation java/lang/ProcessHandle
# Tests that cannot run concurrently
-exclusiveAccess.dirs=java/rmi/Naming java/util/prefs sun/management/jmxremote sun/tools/jstatd sun/security/mscapi java/util/stream javax/rmi com/sun/corba/cachedSocket
+exclusiveAccess.dirs=java/rmi/Naming java/util/prefs sun/management/jmxremote sun/tools/jstatd sun/security/mscapi java/util/stream java/util/BitSet/stream javax/rmi com/sun/corba/cachedSocket
# Group definitions
groups=TEST.groups [closed/TEST.groups]
--- a/jdk/test/TEST.groups Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/test/TEST.groups Mon Apr 24 10:49:43 2017 -0700
@@ -714,7 +714,7 @@
java/security/BasicPermission/Wildcard.java \
java/util/Arrays/ParallelPrefix.java \
java/util/Arrays/SetAllTest.java \
- java/util/BitSet/BitSetStreamTest.java \
+ java/util/BitSet/stream/BitSetStreamTest.java \
java/util/Collection/CollectionDefaults.java \
java/util/Collections/CheckedIdentityMap.java \
java/util/Collections/CheckedMapBash.java \
--- a/jdk/test/java/lang/Runtime/Version/Basic.java Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/test/java/lang/Runtime/Version/Basic.java Mon Apr 24 10:49:43 2017 -0700
@@ -23,19 +23,17 @@
/*
* @test
- * @summary Unit test for java.lang.Runtime.Version.
+ * @summary Unit test for java.lang.Runtime.Version
* @bug 8072379 8144062 8161236 8160956
*/
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
import java.lang.Runtime.Version;
import java.math.BigInteger;
-import java.util.stream.Collectors;
+import java.util.ArrayList;
import java.util.Arrays;
-import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
+import java.util.stream.Collectors;
import static java.lang.System.out;
@@ -46,7 +44,6 @@
= NullPointerException.class;
private static final Class<? extends Throwable> NFE
= NumberFormatException.class;
- private static final Class<?> VERSION = Version.class;
private static final BigInteger TOO_BIG
= (BigInteger.valueOf(Integer.MAX_VALUE)).add(BigInteger.ONE);
@@ -232,7 +229,7 @@
String [] ver = jv[0].split("-");
List<Integer> javaVerVNum
= Arrays.stream(ver[0].split("\\."))
- .map(v -> Integer.parseInt(v))
+ .map(Integer::parseInt)
.collect(Collectors.toList());
if (!javaVerVNum.equals(current.version())) {
fail("Runtime.version()", javaVerVNum.toString(),
@@ -256,7 +253,7 @@
}
private static void testVersion(List<Integer> vnum, String s) {
- List<Integer> svnum = new ArrayList<Integer>();
+ List<Integer> svnum = new ArrayList<>();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
Character c = s.charAt(i);
@@ -297,21 +294,20 @@
}
private static void testEqualsNO(Version v0, Version v1, boolean eq) {
- if ((eq && !v0.equalsIgnoreOptional(v1))
- || (!eq && v0.equalsIgnoreOptional(v1))) {
+ if (eq == v0.equalsIgnoreOptional(v1)) {
+ pass();
+ } else {
fail("equalsIgnoreOptional() " + Boolean.toString(eq),
v0.toString(), v1.toString());
- } else {
- pass();
}
}
private static void testEquals(Version v0, Version v1, boolean eq) {
- if ((eq && !v0.equals(v1)) || (!eq && v0.equals(v1))) {
+ if (eq == v0.equals(v1)) {
+ pass();
+ } else {
fail("equals() " + Boolean.toString(eq),
v0.toString(), v1.toString());
- } else {
- pass();
}
}
@@ -329,41 +325,24 @@
}
}
- private static void testCompareNO(Version v0, Version v1, int compare)
- {
- try {
- Method m = VERSION.getMethod("compareToIgnoreOptional", VERSION);
- int cmp = (int) m.invoke(v0, v1);
- checkCompare(v0, v1, compare, cmp);
- } catch (IllegalAccessException | InvocationTargetException |
- NoSuchMethodException ex) {
- fail(String.format("compareToIgnoreOptional() invocation: %s",
- ex.getClass()),
- null);
- }
+ private static void testCompareNO(Version v0, Version v1, int compare) {
+ int cmp = v0.compareToIgnoreOptional(v1);
+ checkCompare(v0, v1, compare, cmp);
}
private static void testCompare(Version v0, Version v1, int compare) {
- try {
- Method m = VERSION.getMethod("compareTo", VERSION);
- int cmp = (int) m.invoke(v0, v1);
- checkCompare(v0, v1, compare, cmp);
- } catch (IllegalAccessException | InvocationTargetException |
- NoSuchMethodException ex) {
- fail(String.format("compareTo() invocation: %s", ex.getClass()),
- null);
- }
+ int cmp = v0.compareTo(v1);
+ checkCompare(v0, v1, compare, cmp);
}
private static void checkCompare(Version v0, Version v1,
- int compare, int cmp)
+ int expected, int actual)
{
- if (((cmp == 0) && (compare == 0))
- || (compare == (cmp / Math.abs(cmp == 0 ? 1 : cmp)))) {
+ if (Integer.signum(expected) == Integer.signum(actual)) {
pass();
} else {
- fail(String.format("compare() (cmp = %s) (compare = %s)",
- cmp, compare),
+ fail(String.format("compare() (actual = %s) (expected = %s)",
+ actual, expected),
v0.toString(), v1.toString());
}
}
--- a/jdk/test/java/time/TEST.properties Mon Apr 24 07:10:37 2017 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,5 +0,0 @@
-# java.time tests use TestNG
-TestNG.dirs = .
-othervm.dirs = tck/java/time/chrono test/java/time/chrono test/java/time/format
-lib.dirs = ../../lib/testlibrary
-lib.build = jdk.testlibrary.RandomFactory
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/time/nontestng/java/time/chrono/Bug8178823.java Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 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.
+ *
+ * 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 nontestng.java.time.chrono;
+
+import java.time.chrono.HijrahChronology;
+
+/* @test
+ * @bug 8178823
+ * @build Bug8178823
+ * @run main/othervm/policy=bug8178823.policy -Djava.security.manager nontestng.java.time.chrono.Bug8178823
+ * @summary Test Hijrah calendar is initialized with the security manager.
+ */
+public class Bug8178823 {
+ public static void main(String[] args) {
+ HijrahChronology.INSTANCE.isLeapYear(2017);
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/time/nontestng/java/time/chrono/bug8178823.policy Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,1 @@
+// Empty policy file for Bug8178823
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/time/tck/TEST.properties Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,5 @@
+# java.time tests use TestNG
+TestNG.dirs = ..
+othervm.dirs = java/time/chrono
+lib.dirs = ../../../lib/testlibrary
+lib.build = jdk.testlibrary.RandomFactory
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/time/test/TEST.properties Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,5 @@
+# java.time tests use TestNG
+TestNG.dirs = ..
+othervm.dirs = java/time/chrono java/time/format
+lib.dirs = ../../../lib/testlibrary
+lib.build = jdk.testlibrary.RandomFactory
--- a/jdk/test/java/util/BitSet/BitSetStreamTest.java Mon Apr 24 07:10:37 2017 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,147 +0,0 @@
-/*
- * Copyright (c) 2012, 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.
- *
- * 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.
- */
-
-import org.testng.annotations.DataProvider;
-import org.testng.annotations.Test;
-
-import java.lang.Integer;
-import java.lang.Object;
-import java.lang.System;
-import java.util.BitSet;
-import java.util.OptionalInt;
-import java.util.PrimitiveIterator;
-import java.util.Random;
-import java.util.function.IntSupplier;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-
-import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.assertFalse;
-import static org.testng.Assert.assertTrue;
-import static org.testng.Assert.fail;
-
-/**
- * @test
- * @summary test BitSet stream
- * @bug 8012645 8076442
- * @run testng BitSetStreamTest
- */
-public class BitSetStreamTest {
- static class Fibs implements IntSupplier {
- private int n1 = 0;
- private int n2 = 1;
-
- static int fibs(int n) {
- Fibs f = new Fibs();
- while (n-- > 0) f.getAsInt();
- return f.getAsInt();
- }
-
- public int getAsInt() { int s = n1; n1 = n2; n2 = s + n1; return s; }
- }
-
- @Test
- public void testFibs() {
- Fibs f = new Fibs();
- assertEquals(0, f.getAsInt());
- assertEquals(1, f.getAsInt());
- assertEquals(1, f.getAsInt());
- assertEquals(2, f.getAsInt());
- assertEquals(3, f.getAsInt());
- assertEquals(5, f.getAsInt());
- assertEquals(8, f.getAsInt());
- assertEquals(13, f.getAsInt());
- assertEquals(987, Fibs.fibs(16));
- }
-
-
- @DataProvider(name = "cases")
- public static Object[][] produceCases() {
- return new Object[][] {
- { "none", IntStream.empty() },
- { "index 0", IntStream.of(0) },
- { "index 255", IntStream.of(255) },
- { "index 0 and 255", IntStream.of(0, 255) },
- { "index Integer.MAX_VALUE", IntStream.of(Integer.MAX_VALUE) },
- { "index Integer.MAX_VALUE - 1", IntStream.of(Integer.MAX_VALUE - 1) },
- { "index 0 and Integer.MAX_VALUE", IntStream.of(0, Integer.MAX_VALUE) },
- { "every bit", IntStream.range(0, 255) },
- { "step 2", IntStream.range(0, 255).map(f -> f * 2) },
- { "step 3", IntStream.range(0, 255).map(f -> f * 3) },
- { "step 5", IntStream.range(0, 255).map(f -> f * 5) },
- { "step 7", IntStream.range(0, 255).map(f -> f * 7) },
- { "1, 10, 100, 1000", IntStream.of(1, 10, 100, 1000) },
- { "25 fibs", IntStream.generate(new Fibs()).limit(25) }
- };
- }
-
- @Test(dataProvider = "cases")
- public void testBitsetStream(String name, IntStream data) {
- BitSet bs = data.collect(BitSet::new, BitSet::set, BitSet::or);
-
- assertEquals(bs.cardinality(), bs.stream().count());
-
- int[] indexHolder = new int[] { -1 };
- bs.stream().forEach(i -> {
- int ei = indexHolder[0];
- indexHolder[0] = bs.nextSetBit(ei + 1);
- assertEquals(i, indexHolder[0]);
- });
-
- PrimitiveIterator.OfInt it = bs.stream().iterator();
- for (int i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i + 1)) {
- assertTrue(it.hasNext());
- assertEquals(it.nextInt(), i);
- if (i == Integer.MAX_VALUE)
- break; // or (i + 1) would overflow
- }
- assertFalse(it.hasNext());
- }
-
- @Test
- public void testRandomStream() {
- final int size = 1024 * 1024;
- final int[] seeds = {
- 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
- 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
- final byte[] bytes = new byte[size];
- for (int seed : seeds) {
- final Random random = new Random(seed);
- random.nextBytes(bytes);
-
- BitSet bitSet = BitSet.valueOf(bytes);
- testBitSetContents(bitSet, bitSet.stream().toArray());
- testBitSetContents(bitSet, bitSet.stream().parallel().toArray());
- }
- }
-
- void testBitSetContents(BitSet bitSet, int[] array) {
- int cardinality = bitSet.cardinality();
- assertEquals(array.length, cardinality);
- int nextSetBit = -1;
- for (int i = 0; i < cardinality; i++) {
- nextSetBit = bitSet.nextSetBit(nextSetBit + 1);
- assertEquals(array[i], nextSetBit);
- }
- }
-}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/util/BitSet/stream/BitSetStreamTest.java Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) 2012, 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.
+ *
+ * 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.
+ */
+
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.Collection;
+import java.util.List;
+import java.util.PrimitiveIterator;
+import java.util.Random;
+import java.util.Spliterator;
+import java.util.SpliteratorOfIntDataBuilder;
+import java.util.SpliteratorTestHelper;
+import java.util.function.IntConsumer;
+import java.util.function.IntSupplier;
+import java.util.function.Supplier;
+import java.util.stream.IntStream;
+
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import static java.util.stream.Collectors.toList;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
+
+/**
+ * @test
+ * @summary test BitSet stream
+ * @bug 8012645 8076442
+ * @requires os.maxMemory >= 2g
+ * @library ../../stream/bootlib
+ * @build java.base/java.util.SpliteratorTestHelper
+ * java.base/java.util.SpliteratorOfIntDataBuilder
+ * @run testng/othervm -Xms512m -Xmx1024m BitSetStreamTest
+ */
+public class BitSetStreamTest extends SpliteratorTestHelper {
+ static class Fibs implements IntSupplier {
+ private int n1 = 0;
+ private int n2 = 1;
+
+ static int fibs(int n) {
+ Fibs f = new Fibs();
+ while (n-- > 0) f.getAsInt();
+ return f.getAsInt();
+ }
+
+ public int getAsInt() { int s = n1; n1 = n2; n2 = s + n1; return s; }
+ }
+
+ @Test
+ public void testFibs() {
+ Fibs f = new Fibs();
+ assertEquals(0, f.getAsInt());
+ assertEquals(1, f.getAsInt());
+ assertEquals(1, f.getAsInt());
+ assertEquals(2, f.getAsInt());
+ assertEquals(3, f.getAsInt());
+ assertEquals(5, f.getAsInt());
+ assertEquals(8, f.getAsInt());
+ assertEquals(13, f.getAsInt());
+ assertEquals(987, Fibs.fibs(16));
+ }
+
+
+ @DataProvider(name = "cases")
+ public static Object[][] produceCases() {
+ return new Object[][] {
+ { "none", IntStream.empty() },
+ { "index 0", IntStream.of(0) },
+ { "index 255", IntStream.of(255) },
+ { "index 0 and 255", IntStream.of(0, 255) },
+ { "index Integer.MAX_VALUE", IntStream.of(Integer.MAX_VALUE) },
+ { "index Integer.MAX_VALUE - 1", IntStream.of(Integer.MAX_VALUE - 1) },
+ { "index 0 and Integer.MAX_VALUE", IntStream.of(0, Integer.MAX_VALUE) },
+ { "every bit", IntStream.range(0, 255) },
+ { "step 2", IntStream.range(0, 255).map(f -> f * 2) },
+ { "step 3", IntStream.range(0, 255).map(f -> f * 3) },
+ { "step 5", IntStream.range(0, 255).map(f -> f * 5) },
+ { "step 7", IntStream.range(0, 255).map(f -> f * 7) },
+ { "1, 10, 100, 1000", IntStream.of(1, 10, 100, 1000) },
+ { "25 fibs", IntStream.generate(new Fibs()).limit(25) }
+ };
+ }
+
+ @Test(dataProvider = "cases")
+ public void testBitsetStream(String name, IntStream data) {
+ BitSet bs = data.collect(BitSet::new, BitSet::set, BitSet::or);
+
+ assertEquals(bs.cardinality(), bs.stream().count());
+
+ int[] indexHolder = new int[] { -1 };
+ bs.stream().forEach(i -> {
+ int ei = indexHolder[0];
+ indexHolder[0] = bs.nextSetBit(ei + 1);
+ assertEquals(i, indexHolder[0]);
+ });
+
+ PrimitiveIterator.OfInt it = bs.stream().iterator();
+ for (int i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i + 1)) {
+ assertTrue(it.hasNext());
+ assertEquals(it.nextInt(), i);
+ if (i == Integer.MAX_VALUE)
+ break; // or (i + 1) would overflow
+ }
+ assertFalse(it.hasNext());
+ }
+
+ static Object[][] spliteratorOfIntDataProvider;
+
+ @DataProvider(name = "BitSet.stream.spliterator")
+ public static Object[][] spliteratorOfIntDataProvider() {
+ if (spliteratorOfIntDataProvider != null) {
+ return spliteratorOfIntDataProvider;
+ }
+
+ List<Object[]> data = new ArrayList<>();
+
+ Object[][] bitStreamTestcases = new Object[][] {
+ { "none", IntStream.empty().toArray() },
+ { "index 0", IntStream.of(0).toArray() },
+ { "index 255", IntStream.of(255).toArray() },
+ { "index 0 and 255", IntStream.of(0, 255).toArray() },
+ { "index Integer.MAX_VALUE", IntStream.of(Integer.MAX_VALUE).toArray() },
+ { "index Integer.MAX_VALUE - 1", IntStream.of(Integer.MAX_VALUE - 1).toArray() },
+ { "index 0 and Integer.MAX_VALUE", IntStream.of(0, Integer.MAX_VALUE).toArray() },
+ { "every bit", IntStream.range(0, 255).toArray() },
+ { "step 2", IntStream.range(0, 255).map(f -> f * 2).toArray() },
+ { "step 3", IntStream.range(0, 255).map(f -> f * 3).toArray() },
+ { "step 5", IntStream.range(0, 255).map(f -> f * 5).toArray() },
+ { "step 7", IntStream.range(0, 255).map(f -> f * 7).toArray() },
+ { "1, 10, 100, 1000", IntStream.of(1, 10, 100, 1000).toArray() },
+ };
+ for (Object[] tc : bitStreamTestcases) {
+ String description = (String)tc[0];
+ int[] exp = (int[])tc[1];
+ SpliteratorOfIntDataBuilder db = new SpliteratorOfIntDataBuilder(
+ data, IntStream.of(exp).boxed().collect(toList()));
+
+ db.add("BitSet.stream.spliterator() {" + description + "}", () ->
+ IntStream.of(exp).collect(BitSet::new, BitSet::set, BitSet::or).
+ stream().spliterator()
+ );
+ }
+ return spliteratorOfIntDataProvider = data.toArray(new Object[0][]);
+ }
+
+ @Test(dataProvider = "BitSet.stream.spliterator")
+ public void testIntNullPointerException(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
+ executeAndCatch(NullPointerException.class, () -> s.get().forEachRemaining((IntConsumer) null));
+ executeAndCatch(NullPointerException.class, () -> s.get().tryAdvance((IntConsumer) null));
+ }
+
+ @Test(dataProvider = "BitSet.stream.spliterator")
+ public void testIntForEach(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
+ testForEach(exp, s, intBoxingConsumer());
+ }
+
+ @Test(dataProvider = "BitSet.stream.spliterator")
+ public void testIntTryAdvance(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
+ testTryAdvance(exp, s, intBoxingConsumer());
+ }
+
+ @Test(dataProvider = "BitSet.stream.spliterator")
+ public void testIntMixedTryAdvanceForEach(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
+ testMixedTryAdvanceForEach(exp, s, intBoxingConsumer());
+ }
+
+ @Test(dataProvider = "BitSet.stream.spliterator")
+ public void testIntMixedTraverseAndSplit(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
+ testMixedTraverseAndSplit(exp, s, intBoxingConsumer());
+ }
+
+ @Test(dataProvider = "BitSet.stream.spliterator")
+ public void testIntSplitAfterFullTraversal(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
+ testSplitAfterFullTraversal(s, intBoxingConsumer());
+ }
+
+ @Test(dataProvider = "BitSet.stream.spliterator")
+ public void testIntSplitOnce(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
+ testSplitOnce(exp, s, intBoxingConsumer());
+ }
+
+ @Test(dataProvider = "BitSet.stream.spliterator")
+ public void testIntSplitSixDeep(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
+ testSplitSixDeep(exp, s, intBoxingConsumer());
+ }
+
+ @Test(dataProvider = "BitSet.stream.spliterator")
+ public void testIntSplitUntilNull(String description, Collection<Integer> exp, Supplier<Spliterator.OfInt> s) {
+ testSplitUntilNull(exp, s, intBoxingConsumer());
+ }
+
+ @Test
+ public void testRandomStream() {
+ final int size = 1024 * 1024;
+ final int[] seeds = {
+ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
+ 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
+ final byte[] bytes = new byte[size];
+ for (int seed : seeds) {
+ final Random random = new Random(seed);
+ random.nextBytes(bytes);
+
+ BitSet bitSet = BitSet.valueOf(bytes);
+ testBitSetContents(bitSet, bitSet.stream().toArray());
+ testBitSetContents(bitSet, bitSet.stream().parallel().toArray());
+ }
+ }
+
+ void testBitSetContents(BitSet bitSet, int[] array) {
+ int cardinality = bitSet.cardinality();
+ assertEquals(array.length, cardinality);
+ int nextSetBit = -1;
+ for (int i = 0; i < cardinality; i++) {
+ nextSetBit = bitSet.nextSetBit(nextSetBit + 1);
+ assertEquals(array[i], nextSetBit);
+ }
+ }
+}
--- a/jdk/test/java/util/Spliterator/SpliteratorTraversingAndSplittingTest.java Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/test/java/util/Spliterator/SpliteratorTraversingAndSplittingTest.java Mon Apr 24 10:49:43 2017 -0700
@@ -25,7 +25,8 @@
* @test
* @summary Spliterator traversing and splitting tests
* @library ../stream/bootlib
- * @build java.base/java.util.SpliteratorTestHelper
+ * @build java.base/java.util.SpliteratorOfIntDataBuilder
+ * java.base/java.util.SpliteratorTestHelper
* @run testng SpliteratorTraversingAndSplittingTest
* @bug 8020016 8071477 8072784 8169838
*/
@@ -40,7 +41,6 @@
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.BitSet;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
@@ -59,6 +59,7 @@
import java.util.Set;
import java.util.SortedSet;
import java.util.Spliterator;
+import java.util.SpliteratorOfIntDataBuilder;
import java.util.SpliteratorTestHelper;
import java.util.Spliterators;
import java.util.Stack;
@@ -84,9 +85,6 @@
import java.util.function.LongConsumer;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
-import java.util.stream.IntStream;
-
-import static java.util.stream.Collectors.toList;
public class SpliteratorTraversingAndSplittingTest extends SpliteratorTestHelper {
@@ -713,34 +711,6 @@
}
//
-
- private static class SpliteratorOfIntDataBuilder {
- List<Object[]> data;
-
- List<Integer> exp;
-
- SpliteratorOfIntDataBuilder(List<Object[]> data, List<Integer> exp) {
- this.data = data;
- this.exp = exp;
- }
-
- void add(String description, List<Integer> expected, Supplier<Spliterator.OfInt> s) {
- description = joiner(description).toString();
- data.add(new Object[]{description, expected, s});
- }
-
- void add(String description, Supplier<Spliterator.OfInt> s) {
- add(description, exp, s);
- }
-
- StringBuilder joiner(String description) {
- return new StringBuilder(description).
- append(" {").
- append("size=").append(exp.size()).
- append("}");
- }
- }
-
private static class SpliteratorOfIntCharDataBuilder {
List<Object[]> data;
@@ -884,30 +854,6 @@
cdb.add("CharBuffer.wrap(\"%s\".toCharArray())", s -> CharBuffer.wrap(s.toCharArray()));
}
-
- Object[][] bitStreamTestcases = new Object[][] {
- { "none", IntStream.empty().toArray() },
- { "index 0", IntStream.of(0).toArray() },
- { "index 255", IntStream.of(255).toArray() },
- { "index 0 and 255", IntStream.of(0, 255).toArray() },
- { "every bit", IntStream.range(0, 255).toArray() },
- { "step 2", IntStream.range(0, 255).map(f -> f * 2).toArray() },
- { "step 3", IntStream.range(0, 255).map(f -> f * 3).toArray() },
- { "step 5", IntStream.range(0, 255).map(f -> f * 5).toArray() },
- { "step 7", IntStream.range(0, 255).map(f -> f * 7).toArray() },
- { "1, 10, 100, 1000", IntStream.of(1, 10, 100, 1000).toArray() },
- };
- for (Object[] tc : bitStreamTestcases) {
- String description = (String)tc[0];
- int[] exp = (int[])tc[1];
- SpliteratorOfIntDataBuilder db = new SpliteratorOfIntDataBuilder(
- data, IntStream.of(exp).boxed().collect(toList()));
-
- db.add("BitSet.stream.spliterator() {" + description + "}", () ->
- IntStream.of(exp).collect(BitSet::new, BitSet::set, BitSet::or).
- stream().spliterator()
- );
- }
return spliteratorOfIntDataProvider = data.toArray(new Object[0][]);
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/util/stream/bootlib/java.base/java/util/SpliteratorOfIntDataBuilder.java Mon Apr 24 10:49:43 2017 -0700
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 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.
+ *
+ * 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 java.util.function.Supplier;
+
+public class SpliteratorOfIntDataBuilder {
+ List<Object[]> data;
+
+ List<Integer> exp;
+
+ public SpliteratorOfIntDataBuilder(List<Object[]> data, List<Integer> exp) {
+ this.data = data;
+ this.exp = exp;
+ }
+
+ public void add(String description, List<Integer> expected, Supplier<Spliterator.OfInt> s) {
+ description = joiner(description).toString();
+ data.add(new Object[]{description, expected, s});
+ }
+
+ public void add(String description, Supplier<Spliterator.OfInt> s) {
+ add(description, exp, s);
+ }
+
+ StringBuilder joiner(String description) {
+ return new StringBuilder(description).
+ append(" {").
+ append("size=").append(exp.size()).
+ append("}");
+ }
+ }
+
--- a/jdk/test/tools/jlink/bindservices/BindServices.java Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/test/tools/jlink/bindservices/BindServices.java Mon Apr 24 10:49:43 2017 -0700
@@ -149,6 +149,23 @@
testImage(dir, "m1", "m2", "m3");
}
+ @Test
+ public void testVerboseAndNoBindServices() throws Throwable {
+ if (!hasJmods()) return;
+
+ Path dir = Paths.get("verboseNoBind");
+
+ List<String> output =
+ JLink.run("--output", dir.toString(),
+ "--module-path", MODULE_PATH,
+ "--verbose",
+ "--add-modules", "m1").output();
+
+ assertTrue(output.contains("m1 provides p1.S used by m1"));
+
+ testImage(dir, "m1");
+ }
+
/*
* Tests the given ${java.home} to only contain the specified modules
*/
--- a/jdk/test/tools/jlink/bindservices/SuggestProviders.java Mon Apr 24 07:10:37 2017 -0700
+++ b/jdk/test/tools/jlink/bindservices/SuggestProviders.java Mon Apr 24 10:49:43 2017 -0700
@@ -247,6 +247,42 @@
}
+ @Test
+ public void suggestTypeNotRealProvider() throws Throwable {
+ if (!hasJmods()) return;
+
+ List<String> output =
+ JLink.run("--module-path", MODULE_PATH,
+ "--add-modules", "m1",
+ "--suggest-providers",
+ "java.util.List").output();
+
+ System.out.println(output);
+ List<String> expected = List.of(
+ "No provider found for service specified to --suggest-providers: java.util.List"
+ );
+
+ assertTrue(output.containsAll(expected));
+ }
+
+ @Test
+ public void addNonObservableModule() throws Throwable {
+ if (!hasJmods()) return;
+
+ List<String> output =
+ JLink.run("--module-path", MODULE_PATH,
+ "--add-modules", "nonExistentModule",
+ "--suggest-providers",
+ "java.nio.charset.spi.CharsetProvider").output();
+
+ System.out.println(output);
+ List<String> expected = List.of(
+ "jdk.charsets provides java.nio.charset.spi.CharsetProvider used by java.base"
+ );
+
+ assertTrue(output.containsAll(expected));
+ }
+
static class JLink {
static final ToolProvider JLINK_TOOL = ToolProvider.findFirst("jlink")
.orElseThrow(() ->