* The JNDI framework allows for object implementations to - * be loaded in dynamically via object factories. + * be loaded in dynamically via {@code object factories}. *
- * A DirStateFactory extends StateFactory - * by allowing an Attributes instance - * to be supplied to and be returned by the getStateToBind() method. - * DirStateFactory implementations are intended to be used by - * DirContext service providers. - * When a caller binds an object using DirContext.bind(), + * A {@code DirStateFactory} extends {@code StateFactory} + * by allowing an {@code Attributes} instance + * to be supplied to and be returned by the {@code getStateToBind()} method. + * {@code DirStateFactory} implementations are intended to be used by + * {@code DirContext} service providers. + * When a caller binds an object using {@code DirContext.bind()}, * he might also specify a set of attributes to be bound with the object. * The object and attributes to be bound are passed to - * the getStateToBind() method of a factory. + * the {@code getStateToBind()} method of a factory. * If the factory processes the object and attributes, it returns * a corresponding pair of object and attributes to be bound. * If the factory does not process the object, it must return null. @@ -53,23 +53,23 @@ *
* ctx.rebind("inky", printer, printerAttrs);
*Since DirStateFactory extends StateFactory, it - * has two getStateToBind() methods, where one + *
Since {@code DirStateFactory} extends {@code StateFactory}, it + * has two {@code getStateToBind()} methods, where one * differs from the other by the attributes - * argument. DirectoryManager.getStateToBind() will only use + * argument. {@code DirectoryManager.getStateToBind()} will only use * the form that accepts the attributes argument, while - * NamingManager.getStateToBind() will only use the form that + * {@code NamingManager.getStateToBind()} will only use the form that * does not accept the attributes argument. * - *
Either form of the getStateToBind() method of a + *
Either form of the {@code getStateToBind()} method of a * DirStateFactory may be invoked multiple times, possibly using different * parameters. The implementation is thread-safe. * @@ -85,15 +85,15 @@ * Retrieves the state of an object for binding given the object and attributes * to be transformed. *
- * DirectoryManager.getStateToBind() + * {@code DirectoryManager.getStateToBind()} * successively loads in state factories. If a factory implements - * DirStateFactory, DirectoryManager invokes this method; - * otherwise, it invokes StateFactory.getStateToBind(). + * {@code DirStateFactory}, {@code DirectoryManager} invokes this method; + * otherwise, it invokes {@code StateFactory.getStateToBind()}. * It does this until a factory produces a non-null answer. *
* When an exception is thrown by a factory, * the exception is passed on to the caller - * of DirectoryManager.getStateToBind(). The search for other factories + * of {@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 @@ -101,36 +101,36 @@ * If this factory cannot create an object using the arguments supplied, * it should return null. *
- * The name and nameCtx parameters may
+ * The {@code name} and {@code nameCtx} parameters may
* optionally be used to specify the name of the object being created.
* See the description of "Name and Context Parameters" in
* {@link ObjectFactory#getObjectInstance ObjectFactory.getObjectInstance()}
* for details.
- * If a factory uses nameCtx it should synchronize its use
+ * If a factory uses {@code nameCtx} it should synchronize its use
* against concurrent access, since context implementations are not
* guaranteed to be thread-safe.
*
- * The name, inAttrs, and environment parameters
+ * The {@code name}, {@code inAttrs}, 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.
* The object returned by this method is owned by the caller.
* The implementation will not subsequently modify it.
- * It will contain either a new Attributes object that is
+ * It will contain either a new {@code Attributes} object that is
* likewise owned by the caller, or a reference to the original
- * inAttrs parameter.
+ * {@code inAttrs} parameter.
*
* @param obj A possibly null object whose state is to be retrieved.
- * @param name The name of this object relative to nameCtx,
+ * @param name The name of this object relative to {@code nameCtx},
* or null if no name is specified.
- * @param nameCtx The context relative to which the name
- * parameter is specified, or null if name is
+ * @param nameCtx The context relative to which the {@code name}
+ * parameter is specified, or null if {@code name} is
* relative to the default initial context.
* @param environment The possibly null environment to
* be used in the creation of the object's state.
* @param inAttrs The possibly null attributes to be bound with the object.
- * The factory must not modify inAttrs.
- * @return A Result containing the object's state for binding
+ * The factory must not modify {@code inAttrs}.
+ * @return A {@code Result} containing the object's state for binding
* and the corresponding
* attributes to be bound; null if the object don't use this factory.
* @exception NamingException If this factory encountered an exception