src/java.naming/share/classes/javax/naming/spi/StateFactory.java

@@ -32,43 +32,43 @@
   * object for binding.
   *<p>
   * The JNDI framework allows for object implementations to
   * be loaded in dynamically via <em>object factories</em>.
   * For example, when looking up a printer bound in the name space,
-  * if the print service binds printer names to <tt>Reference</tt>s, the printer
-  * <tt>Reference</tt> could be used to create a printer object, so that
+  * if the print service binds printer names to {@code Reference}s, the printer
+  * {@code Reference} could be used to create a printer object, so that
   * the caller of lookup can directly operate on the printer object
   * after the lookup.
-  * <p>An <tt>ObjectFactory</tt> is responsible
+  * <p>An {@code ObjectFactory} is responsible
   * for creating objects of a specific type.  In the above example,
-  * you may have a <tt>PrinterObjectFactory</tt> for creating
-  * <tt>Printer</tt> objects.
+  * you may have a {@code PrinterObjectFactory} for creating
+  * {@code Printer} objects.
   * <p>
   * For the reverse process, when an object is bound into the namespace,
   * JNDI provides <em>state factories</em>.
   * Continuing with the printer example, suppose the printer object is
   * updated and rebound:
   * <blockquote><pre>
   * ctx.rebind("inky", printer);
   * </pre></blockquote>
-  * The service provider for <tt>ctx</tt> uses a state factory
-  * to obtain the state of <tt>printer</tt> for binding into its namespace.
-  * A state factory for the <tt>Printer</tt> type object might return
+  * The service provider for {@code ctx} uses a state factory
+  * to obtain the state of {@code printer} for binding into its namespace.
+  * A state factory for the {@code Printer} type object might return
   * a more compact object for storage in the naming system.
   *<p>
-  * A state factory must implement the <tt>StateFactory</tt> interface.
+  * A state factory must implement the {@code StateFactory} interface.
   * In addition, the factory class must be public and must have a
   * public constructor that accepts no parameters.
   *<p>
-  * The <tt>getStateToBind()</tt> method of a state factory may
+  * The {@code getStateToBind()} method of a state factory may
   * be invoked multiple times, possibly using different parameters.
   * The implementation is thread-safe.
   *<p>
-  * <tt>StateFactory</tt> is intended for use with service providers
-  * that implement only the <tt>Context</tt> interface.
-  * <tt>DirStateFactory</tt> is intended for use with service providers
-  * that implement the <tt>DirContext</tt> interface.
+  * {@code StateFactory} is intended for use with service providers
+  * that implement only the {@code Context} interface.
+  * {@code DirStateFactory} is intended for use with service providers
+  * that implement the {@code DirContext} interface.
   *
   * @author Rosanna Lee
   * @author Scott Seligman
   *
   * @see NamingManager#getStateToBind

@@ -79,22 +79,22 @@
   */
 public interface StateFactory {
 /**
  * Retrieves the state of an object for binding.
  *<p>
- * <tt>NamingManager.getStateToBind()</tt>
+ * {@code NamingManager.getStateToBind()}
  * successively loads in state factories and invokes this method
  * on them until one produces a non-null answer.
- * <tt>DirectoryManager.getStateToBind()</tt>
+ * {@code DirectoryManager.getStateToBind()}
  * successively loads in state factories.  If a factory implements
- * <tt>DirStateFactory</tt>, then <tt>DirectoryManager</tt>
- * invokes <tt>DirStateFactory.getStateToBind()</tt>; otherwise
- * it invokes <tt>StateFactory.getStateToBind()</tt>.
+ * {@code DirStateFactory}, then {@code DirectoryManager}
+ * invokes {@code DirStateFactory.getStateToBind()}; otherwise
+ * it invokes {@code StateFactory.getStateToBind()}.
  *<p> When an exception
  * is thrown by a factory, the exception is passed on to the caller
- * of <tt>NamingManager.getStateToBind()</tt> and
- * <tt>DirectoryManager.getStateToBind()</tt>.
+ * of {@code NamingManager.getStateToBind()} and
+ * {@code DirectoryManager.getStateToBind()}.
  * The search for other factories
  * that may produce a non-null answer is halted.
  * A factory should only throw an exception if it is sure that
  * it is the only intended factory and that no other factories
  * should be tried.

@@ -108,11 +108,11 @@
  * for details.
  * If a factory uses <code>nameCtx</code> it should synchronize its use
  * against concurrent access, since context implementations are not
  * guaranteed to be thread-safe.
  * <p>
- * The <tt>name</tt> and <tt>environment</tt> parameters
+ * The {@code name} and {@code environment} parameters
  * are owned by the caller.
  * The implementation will not modify these objects or keep references
  * to them, although it may keep references to clones or copies.
  *
  * @param obj A non-null object whose state is to be retrieved.