< prev index next >
src/java.desktop/share/classes/java/beans/Encoder.java
Print this page
@@ -29,16 +29,16 @@
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Map;
/**
- * An <code>Encoder</code> is a class which can be used to create
+ * An {@code Encoder} is a class which can be used to create
* files or streams that encode the state of a collection of
- * JavaBeans in terms of their public APIs. The <code>Encoder</code>,
+ * JavaBeans in terms of their public APIs. The {@code Encoder},
* in conjunction with its persistence delegates, is responsible for
- * breaking the object graph down into a series of <code>Statements</code>s
- * and <code>Expression</code>s which can be used to create it.
+ * breaking the object graph down into a series of {@code Statement}s
+ * and {@code Expression}s which can be used to create it.
* A subclass typically provides a syntax for these expressions
* using some human readable form - like Java source code or XML.
*
* @since 1.4
*
@@ -73,16 +73,16 @@
PersistenceDelegate info = getPersistenceDelegate(o == null ? null : o.getClass());
info.writeObject(o, this);
}
/**
- * Sets the exception handler for this stream to <code>exceptionListener</code>.
+ * Sets the exception handler for this stream to {@code exceptionListener}.
* The exception handler is notified when this stream catches recoverable
* exceptions.
*
* @param exceptionListener The exception handler for this stream;
- * if <code>null</code> the default exception listener will be used.
+ * if {@code null} the default exception listener will be used.
*
* @see #getExceptionListener
*/
public void setExceptionListener(ExceptionListener exceptionListener) {
this.exceptionListener = exceptionListener;
@@ -230,13 +230,13 @@
Expression exp = bindings.remove(oldInstance);
return getValue(exp);
}
/**
- * Returns a tentative value for <code>oldInstance</code> in
+ * Returns a tentative value for {@code oldInstance} in
* the environment created by this stream. A persistence
- * delegate can use its <code>mutatesTo</code> method to
+ * delegate can use its {@code mutatesTo} method to
* determine whether this value may be initialized to
* form the equivalent object at the output or whether
* a new object must be instantiated afresh. If the
* stream has not yet seen this value, null is returned.
*
@@ -276,23 +276,23 @@
newExp.loader = oldExp.loader;
return newExp;
}
/**
- * Writes statement <code>oldStm</code> to the stream.
- * The <code>oldStm</code> should be written entirely
+ * Writes statement {@code oldStm} to the stream.
+ * The {@code oldStm} should be written entirely
* in terms of the callers environment, i.e. the
* target and all arguments should be part of the
* object graph being written. These expressions
* represent a series of "what happened" expressions
* which tell the output stream how to produce an
* object graph like the original.
* <p>
* The implementation of this method will produce
* a second expression to represent the same expression in
* an environment that will exist when the stream is read.
- * This is achieved simply by calling <code>writeObject</code>
+ * This is achieved simply by calling {@code writeObject}
* on the target and all the arguments and building a new
* expression with the results.
*
* @param oldStm The expression to be written to the stream.
*/
@@ -311,14 +311,14 @@
/**
* The implementation first checks to see if an
* expression with this value has already been written.
* If not, the expression is cloned, using
- * the same procedure as <code>writeStatement</code>,
+ * the same procedure as {@code writeStatement},
* and the value of this expression is reconciled
* with the value of the cloned expression
- * by calling <code>writeObject</code>.
+ * by calling {@code writeObject}.
*
* @param oldExp The expression to be written to the stream.
*/
public void writeExpression(Expression oldExp) {
// System.out.println("Encoder::writeExpression: " + oldExp);
< prev index next >