--- old/src/share/classes/java/security/cert/CertPath.java 2013-06-21 17:28:21.705838558 -0700 +++ new/src/share/classes/java/security/cert/CertPath.java 2013-06-21 17:28:21.545838561 -0700 @@ -36,56 +36,56 @@ * An immutable sequence of certificates (a certification path). *
* This is an abstract class that defines the methods common to all
- * CertPath
s. Subclasses can handle different kinds of
+ * {@code CertPath}s. Subclasses can handle different kinds of
* certificates (X.509, PGP, etc.).
*
- * All CertPath
objects have a type, a list of
- * Certificate
s, and one or more supported encodings. Because the
- * CertPath
class is immutable, a CertPath
cannot
+ * All {@code CertPath} objects have a type, a list of
+ * {@code Certificate}s, and one or more supported encodings. Because the
+ * {@code CertPath} class is immutable, a {@code CertPath} cannot
* change in any externally visible way after being constructed. This
* stipulation applies to all public fields and methods of this class and any
* added or overridden by subclasses.
*
- * The type is a String
that identifies the type of
- * Certificate
s in the certification path. For each
- * certificate cert
in a certification path certPath
,
- * cert.getType().equals(certPath.getType())
must be
- * true
.
- *
- * The list of Certificate
s is an ordered List
of
- * zero or more Certificate
s. This List
and all
- * of the Certificate
s contained in it must be immutable.
+ * The type is a {@code String} that identifies the type of
+ * {@code Certificate}s in the certification path. For each
+ * certificate {@code cert} in a certification path {@code certPath},
+ * {@code cert.getType().equals(certPath.getType())} must be
+ * {@code true}.
+ *
+ * The list of {@code Certificate}s is an ordered {@code List} of + * zero or more {@code Certificate}s. This {@code List} and all + * of the {@code Certificate}s contained in it must be immutable. *
- * Each CertPath
object must support one or more encodings
+ * Each {@code CertPath} object must support one or more encodings
* so that the object can be translated into a byte array for storage or
* transmission to other parties. Preferably, these encodings should be
* well-documented standards (such as PKCS#7). One of the encodings supported
- * by a CertPath
is considered the default encoding. This
+ * by a {@code CertPath} is considered the default encoding. This
* encoding is used if no encoding is explicitly requested (for the
* {@link #getEncoded() getEncoded()} method, for instance).
*
- * All CertPath
objects are also Serializable
.
- * CertPath
objects are resolved into an alternate
+ * All {@code CertPath} objects are also {@code Serializable}.
+ * {@code CertPath} objects are resolved into an alternate
* {@link CertPathRep CertPathRep} object during serialization. This allows
- * a CertPath
object to be serialized into an equivalent
+ * a {@code CertPath} object to be serialized into an equivalent
* representation regardless of its underlying implementation.
*
- * CertPath
objects can be created with a
- * CertificateFactory
or they can be returned by other classes,
- * such as a CertPathBuilder
.
+ * {@code CertPath} objects can be created with a
+ * {@code CertificateFactory} or they can be returned by other classes,
+ * such as a {@code CertPathBuilder}.
*
- * By convention, X.509 CertPath
s (consisting of
- * X509Certificate
s), are ordered starting with the target
+ * By convention, X.509 {@code CertPath}s (consisting of
+ * {@code X509Certificate}s), are ordered starting with the target
* certificate and ending with a certificate issued by the trust anchor. That
* is, the issuer of one certificate is the subject of the following one. The
* certificate representing the {@link TrustAnchor TrustAnchor} should not be
- * included in the certification path. Unvalidated X.509 CertPath
s
- * may not follow these conventions. PKIX CertPathValidator
s will
+ * included in the certification path. Unvalidated X.509 {@code CertPath}s
+ * may not follow these conventions. PKIX {@code CertPathValidator}s will
* detect any departure from these conventions that cause the certification
- * path to be invalid and throw a CertPathValidatorException
.
+ * path to be invalid and throw a {@code CertPathValidatorException}.
*
*
Every implementation of the Java platform is required to support the
- * following standard CertPath
encodings:
+ * following standard {@code CertPath} encodings:
*
* Concurrent Access *
- * All CertPath
objects must be thread-safe. That is, multiple
+ * All {@code CertPath} objects must be thread-safe. That is, multiple
* threads may concurrently invoke the methods defined in this class on a
- * single CertPath
object (or more than one) with no
- * ill effects. This is also true for the List
returned by
- * CertPath.getCertificates
.
+ * single {@code CertPath} object (or more than one) with no
+ * ill effects. This is also true for the {@code List} returned by
+ * {@code CertPath.getCertificates}.
*
- * Requiring CertPath
objects to be immutable and thread-safe
+ * Requiring {@code CertPath} objects to be immutable and thread-safe
* allows them to be passed around to various pieces of code without worrying
* about coordinating access. Providing this thread-safety is
- * generally not difficult, since the CertPath
and
- * List
objects in question are immutable.
+ * generally not difficult, since the {@code CertPath} and
+ * {@code List} objects in question are immutable.
*
* @see CertificateFactory
* @see CertPathBuilder
@@ -124,25 +124,25 @@
private String type; // the type of certificates in this chain
/**
- * Creates a CertPath
of the specified type.
+ * Creates a {@code CertPath} of the specified type.
*
* This constructor is protected because most users should use a
- *
* This algorithm is implemented by this method. If it is overridden,
* the behavior specified here must be maintained.
@@ -199,10 +199,10 @@
* hashCode = path.getType().hashCode();
* hashCode = 31*hashCode + path.getCertificates().hashCode();
*
- * This ensures that CertificateFactory
to create CertPath
s.
+ * {@code CertificateFactory} to create {@code CertPath}s.
*
* @param type the standard name of the type of
- * Certificate
s in this path
+ * {@code Certificate}s in this path
*/
protected CertPath(String type) {
this.type = type;
}
/**
- * Returns the type of Certificate
s in this certification
+ * Returns the type of {@code Certificate}s in this certification
* path. This is the same string that would be returned by
* {@link java.security.cert.Certificate#getType() cert.getType()}
- * for all Certificate
s in the certification path.
+ * for all {@code Certificate}s in the certification path.
*
- * @return the type of Certificate
s in this certification
+ * @return the type of {@code Certificate}s in this certification
* path (never null)
*/
public String getType() {
@@ -152,21 +152,21 @@
/**
* Returns an iteration of the encodings supported by this certification
* path, with the default encoding first. Attempts to modify the returned
- * Iterator
via its remove
method result in an
- * UnsupportedOperationException
.
+ * {@code Iterator} via its {@code remove} method result in an
+ * {@code UnsupportedOperationException}.
*
- * @return an Iterator
over the names of the supported
+ * @return an {@code Iterator} over the names of the supported
* encodings (as Strings)
*/
public abstract IteratorCertPath
s are equal if and only if their
- * types are equal and their certificate List
s (and by
- * implication the Certificate
s in those List
s)
- * are equal. A CertPath
is never equal to an object that is
- * not a CertPath
.
+ * object. Two {@code CertPath}s are equal if and only if their
+ * types are equal and their certificate {@code List}s (and by
+ * implication the {@code Certificate}s in those {@code List}s)
+ * are equal. A {@code CertPath} is never equal to an object that is
+ * not a {@code CertPath}.
* path1.equals(path2)
implies that
- * path1.hashCode()==path2.hashCode()
for any two certification
- * paths, path1
and path2
, as required by the
- * general contract of Object.hashCode
.
+ * This ensures that {@code path1.equals(path2)} implies that
+ * {@code path1.hashCode()==path2.hashCode()} for any two certification
+ * paths, {@code path1} and {@code path2}, as required by the
+ * general contract of {@code Object.hashCode}.
*
* @return the hashcode value for this certification path
*/
@@ -214,8 +214,8 @@
/**
* Returns a string representation of this certification path.
- * This calls the toString
method on each of the
- * Certificate
s in the path.
+ * This calls the {@code toString} method on each of the
+ * {@code Certificate}s in the path.
*
* @return a string representation of this certification path
*/
@@ -266,20 +266,20 @@
/**
* Returns the list of certificates in this certification path.
- * The List
returned must be immutable and thread-safe.
+ * The {@code List} returned must be immutable and thread-safe.
*
- * @return an immutable List
of Certificate
s
+ * @return an immutable {@code List} of {@code Certificate}s
* (may be empty, but not null)
*/
public abstract List extends Certificate> getCertificates();
/**
- * Replaces the CertPath
to be serialized with a
- * CertPathRep
object.
+ * Replaces the {@code CertPath} to be serialized with a
+ * {@code CertPathRep} object.
*
- * @return the CertPathRep
to be serialized
+ * @return the {@code CertPathRep} to be serialized
*
- * @throws ObjectStreamException if a CertPathRep
object
+ * @throws ObjectStreamException if a {@code CertPathRep} object
* representing this certification path could not be created
*/
protected Object writeReplace() throws ObjectStreamException {
@@ -295,7 +295,7 @@
}
/**
- * Alternate CertPath
class for serialization.
+ * Alternate {@code CertPath} class for serialization.
* @since 1.4
*/
protected static class CertPathRep implements Serializable {
@@ -308,10 +308,10 @@
private byte[] data;
/**
- * Creates a CertPathRep
with the specified
+ * Creates a {@code CertPathRep} with the specified
* type and encoded form of a certification path.
*
- * @param type the standard name of a CertPath
type
+ * @param type the standard name of a {@code CertPath} type
* @param data the encoded form of the certification path
*/
protected CertPathRep(String type, byte[] data) {
@@ -320,11 +320,11 @@
}
/**
- * Returns a CertPath
constructed from the type and data.
+ * Returns a {@code CertPath} constructed from the type and data.
*
- * @return the resolved CertPath
object
+ * @return the resolved {@code CertPath} object
*
- * @throws ObjectStreamException if a CertPath
could not
+ * @throws ObjectStreamException if a {@code CertPath} could not
* be constructed
*/
protected Object readResolve() throws ObjectStreamException {