1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
/* * @(#)NameClassPair.java 1.11 05/11/17 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package javax.naming; /** * This class represents the object name and class name pair of a binding * found in a context. *<p> * A context consists of name-to-object bindings. * The NameClassPair class represents the name and the * class of the bound object. It consists * of a name and a string representing the * package-qualified class name. *<p> * Use subclassing for naming systems that generate contents of * a name/class pair dynamically. *<p> * A NameClassPair instance is not synchronized against concurrent * access by multiple threads. Threads that need to access a NameClassPair * concurrently should synchronize amongst themselves and provide * the necessary locking. * * @author Rosanna Lee * @author Scott Seligman * @version 1.11 05/11/17 * * @see Context#list * @since 1.3 */ /* * <p> * The serialized form of a NameClassPair object consists of the name (a * String), class name (a String), and isRelative flag (a boolean). */ public class NameClassPair implements java.io.Serializable { /** * Contains the name of this NameClassPair. * It is initialized by the constructor and can be updated using * <tt>setName()</tt>. * @serial * @see #getName * @see #setName */ private String name; /** *Contains the class name contained in this NameClassPair. * It is initialized by the constructor and can be updated using * <tt>setClassName()</tt>. * @serial * @see #getClassName * @see #setClassName */ private String className; /** * Contains the full name of this NameClassPair within its * own namespace. * It is initialized using <tt>setNameInNamespace()</tt> * @serial * @see #getNameInNamespace * @see #setNameInNamespace */ private String fullName = null; /** * Records whether the name of this <tt>NameClassPair</tt> * is relative to the target context. * It is initialized by the constructor and can be updated using * <tt>setRelative()</tt>. * @serial * @see #isRelative * @see #setRelative * @see #getName * @see #setName */ private boolean isRel = true; /** * Constructs an instance of a NameClassPair given its * name and class name. * * @param name The non-null name of the object. It is relative * to the <em>target context</em> (which is * named by the first parameter of the <code>list()</code> method) * @param className The possibly null class name of the object * bound to name. It is null if the object bound is null. * @see #getClassName * @see #setClassName * @see #getName * @see #setName */ public NameClassPair(String name, String className) { this.name = name; this.className = className; } /** * Constructs an instance of a NameClassPair given its * name, class name, and whether it is relative to the listing context. * * @param name The non-null name of the object. * @param className The possibly null class name of the object * bound to name. It is null if the object bound is null. * @param isRelative true if <code>name</code> is a name relative * to the target context (which is named by the first parameter * of the <code>list()</code> method); false if <code>name</code> * is a URL string. * @see #getClassName * @see #setClassName * @see #getName * @see #setName * @see #isRelative * @see #setRelative */ public NameClassPair(String name, String className, boolean isRelative) { this.name = name; this.className = className; this.isRel = isRelative; } /** * Retrieves the class name of the object bound to the name of this binding. * If a reference or some other indirect information is bound, * retrieves the class name of the eventual object that * will be returned by <tt>Binding.getObject()</tt>. * * @return The possibly null class name of object bound. * It is null if the object bound is null. * @see Binding#getObject * @see Binding#getClassName * @see #setClassName */ public String getClassName() { return className; } /** * Retrieves the name of this binding. * If <tt>isRelative()</tt> is true, this name is relative to the * target context (which is named by the first parameter of the * <tt>list()</tt>). * If <tt>isRelative()</tt> is false, this name is a URL string. * * @return The non-null name of this binding. * @see #isRelative * @see #setName */ public String getName() { return name; } /** * Sets the name of this binding. * * @param name the non-null string to use as the name. * @see #getName * @see #setRelative */ public void setName(String name) { this.name = name; } /** * Sets the class name of this binding. * * @param name the possibly null string to use as the class name. * If null, <tt>Binding.getClassName()</tt> will return * the actual class name of the object in the binding. * The class name will be null if the object bound is null. * @see #getClassName * @see Binding#getClassName */ public void setClassName(String name) { this.className = name; } /** * Determines whether the name of this binding is * relative to the target context (which is named by * the first parameter of the <code>list()</code> method). * * @return true if the name of this binding is relative to the * target context; * false if the name of this binding is a URL string. * @see #setRelative * @see #getName */ public boolean isRelative() { return isRel; } /** * Sets whether the name of this binding is relative to the target * context (which is named by the first parameter of the <code>list()</code> * method). * * @param r If true, the name of binding is relative to the target context; * if false, the name of binding is a URL string. * @see #isRelative * @see #setName */ public void setRelative(boolean r) { isRel = r; } /** * Retrieves the full name of this binding. * The full name is the absolute name of this binding within * its own namespace. See {@link Context#getNameInNamespace()}. * <p> * * In naming systems for which the notion of full name does not * apply to this binding an <tt>UnsupportedOperationException</tt> * is thrown. * This exception is also thrown when a service provider written before * the introduction of the method is in use. * <p> * The string returned by this method is not a JNDI composite name and * should not be passed directly to context methods. * * @return The full name of this binding. * @throws UnsupportedOperationException if the notion of full name * does not apply to this binding in the naming system. * @since 1.5 * @see #setNameInNamespace * @see #getName */ public String getNameInNamespace() { if (fullName == null) { throw new UnsupportedOperationException(); } return fullName; } /** * Sets the full name of this binding. * This method must be called to set the full name whenever a * <tt>NameClassPair</tt> is created and a full name is * applicable to this binding. * <p> * Setting the full name to null, or not setting it at all, will * cause <tt>getNameInNamespace()</tt> to throw an exception. * * @param fullName The full name to use. * @since 1.5 * @see #getNameInNamespace * @see #setName */ public void setNameInNamespace(String fullName) { this.fullName = fullName; } /** * Generates the string representation of this name/class pair. * The string representation consists of the name and class name separated * by a colon (':'). * The contents of this string is useful * for debugging and is not meant to be interpreted programmatically. * * @return The string representation of this name/class pair. */ public String toString() { return (isRelative() ? "" : "(not relative)") + getName() + ": " + getClassName(); } /** * Use serialVersionUID from JNDI 1.1.1 for interoperability */ private static final long serialVersionUID = 5620776610160863339L; }