J. Duke | 319a3b9 | 2007-12-01 00:00:00 +0000 | [diff] [blame^] | 1 | /* |
| 2 | * Copyright 1999-2006 Sun Microsystems, Inc. All Rights Reserved. |
| 3 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 | * |
| 5 | * This code is free software; you can redistribute it and/or modify it |
| 6 | * under the terms of the GNU General Public License version 2 only, as |
| 7 | * published by the Free Software Foundation. Sun designates this |
| 8 | * particular file as subject to the "Classpath" exception as provided |
| 9 | * by Sun in the LICENSE file that accompanied this code. |
| 10 | * |
| 11 | * This code is distributed in the hope that it will be useful, but WITHOUT |
| 12 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| 13 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| 14 | * version 2 for more details (a copy is included in the LICENSE file that |
| 15 | * accompanied this code). |
| 16 | * |
| 17 | * You should have received a copy of the GNU General Public License version |
| 18 | * 2 along with this work; if not, write to the Free Software Foundation, |
| 19 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| 20 | * |
| 21 | * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
| 22 | * CA 95054 USA or visit www.sun.com if you need additional information or |
| 23 | * have any questions. |
| 24 | */ |
| 25 | |
| 26 | package javax.naming; |
| 27 | |
| 28 | import java.util.Hashtable; |
| 29 | |
| 30 | /** |
| 31 | * This interface represents a naming context, which |
| 32 | * consists of a set of name-to-object bindings. |
| 33 | * It contains methods for examining and updating these bindings. |
| 34 | * <p> |
| 35 | * <h4>Names</h4> |
| 36 | * Each name passed as an argument to a <tt>Context</tt> method is relative |
| 37 | * to that context. The empty name is used to name the context itself. |
| 38 | * A name parameter may never be null. |
| 39 | * <p> |
| 40 | * Most of the methods have overloaded versions with one taking a |
| 41 | * <code>Name</code> parameter and one taking a <code>String</code>. |
| 42 | * These overloaded versions are equivalent in that if |
| 43 | * the <code>Name</code> and <code>String</code> parameters are just |
| 44 | * different representations of the same name, then the overloaded |
| 45 | * versions of the same methods behave the same. |
| 46 | * In the method descriptions below, only one version is fully documented. |
| 47 | * The second version instead has a link to the first: the same |
| 48 | * documentation applies to both. |
| 49 | * <p> |
| 50 | * For systems that support federation, <tt>String</tt> name arguments to |
| 51 | * <tt>Context</tt> methods are composite names. Name arguments that are |
| 52 | * instances of <tt>CompositeName</tt> are treated as composite names, |
| 53 | * while <tt>Name</tt> arguments that are not instances of |
| 54 | * <tt>CompositeName</tt> are treated as compound names (which might be |
| 55 | * instances of <tt>CompoundName</tt> or other implementations of compound |
| 56 | * names). This allows the results of <tt>NameParser.parse()</tt> to be used as |
| 57 | * arguments to the <tt>Context</tt> methods. |
| 58 | * Prior to JNDI 1.2, all name arguments were treated as composite names. |
| 59 | *<p> |
| 60 | * Furthermore, for systems that support federation, all names returned |
| 61 | * in a <tt>NamingEnumeration</tt> |
| 62 | * from <tt>list()</tt> and <tt>listBindings()</tt> are composite names |
| 63 | * represented as strings. |
| 64 | * See <tt>CompositeName</tt> for the string syntax of names. |
| 65 | *<p> |
| 66 | * For systems that do not support federation, the name arguments (in |
| 67 | * either <tt>Name</tt> or <tt>String</tt> forms) and the names returned in |
| 68 | * <tt>NamingEnumeration</tt> may be names in their own namespace rather than |
| 69 | * names in a composite namespace, at the discretion of the service |
| 70 | * provider. |
| 71 | *<p> |
| 72 | *<h4>Exceptions</h4> |
| 73 | * All the methods in this interface can throw a <tt>NamingException</tt> or |
| 74 | * any of its subclasses. See <tt>NamingException</tt> and their subclasses |
| 75 | * for details on each exception. |
| 76 | *<p> |
| 77 | *<h4>Concurrent Access</h4> |
| 78 | * A Context instance is not guaranteed to be synchronized against |
| 79 | * concurrent access by multiple threads. Threads that need to access |
| 80 | * a single Context instance concurrently should synchronize amongst |
| 81 | * themselves and provide the necessary locking. Multiple threads |
| 82 | * each manipulating a different Context instance need not |
| 83 | * synchronize. Note that the {@link #lookup(Name) <tt>lookup</tt>} |
| 84 | * method, when passed an empty name, will return a new Context instance |
| 85 | * representing the same naming context. |
| 86 | *<p> |
| 87 | * For purposes of concurrency control, |
| 88 | * a Context operation that returns a <tt>NamingEnumeration</tt> is |
| 89 | * not considered to have completed while the enumeration is still in |
| 90 | * use, or while any referrals generated by that operation are still |
| 91 | * being followed. |
| 92 | * |
| 93 | *<p> |
| 94 | *<h4>Parameters</h4> |
| 95 | * A <tt>Name</tt> parameter passed to any method of the |
| 96 | * <tt>Context</tt> interface or one of its subinterfaces |
| 97 | * will not be modified by the service provider. |
| 98 | * The service provider may keep a reference to it |
| 99 | * for the duration of the operation, including any enumeration of the |
| 100 | * method's results and the processing of any referrals generated. |
| 101 | * The caller should not modify the object during this time. |
| 102 | * A <tt>Name</tt> returned by any such method is owned by the caller. |
| 103 | * The caller may subsequently modify it; the service provider may not. |
| 104 | * |
| 105 | *<p> |
| 106 | *<h4>Environment Properties</h4> |
| 107 | *<p> |
| 108 | * JNDI applications need a way to communicate various preferences |
| 109 | * and properties that define the environment in which naming and |
| 110 | * directory services are accessed. For example, a context might |
| 111 | * require specification of security credentials in order to access |
| 112 | * the service. Another context might require that server configuration |
| 113 | * information be supplied. These are referred to as the <em>environment</em> |
| 114 | * of a context. The <tt>Context</tt> interface provides methods for |
| 115 | * retrieving and updating this environment. |
| 116 | *<p> |
| 117 | * The environment is inherited from the parent context as |
| 118 | * context methods proceed from one context to the next. Changes to |
| 119 | * the environment of one context do not directly affect those |
| 120 | * of other contexts. |
| 121 | *<p> |
| 122 | * It is implementation-dependent when environment properties are used |
| 123 | * and/or verified for validity. For example, some of the |
| 124 | * security-related properties are used by service providers to "log in" |
| 125 | * to the directory. This login process might occur at the time the |
| 126 | * context is created, or the first time a method is invoked on the |
| 127 | * context. When, and whether this occurs at all, is |
| 128 | * implementation-dependent. When environment properties are added or |
| 129 | * removed from the context, verifying the validity of the changes is again |
| 130 | * implementation-dependent. For example, verification of some properties |
| 131 | * might occur at the time the change is made, or at the time the next |
| 132 | * operation is performed on the context, or not at all. |
| 133 | *<p> |
| 134 | * Any object with a reference to a context may examine that context's |
| 135 | * environment. Sensitive information such as clear-text |
| 136 | * passwords should not be stored there unless the implementation is |
| 137 | * known to protect it. |
| 138 | * |
| 139 | *<p> |
| 140 | *<a name=RESOURCEFILES></a> |
| 141 | *<h4>Resource Files</h4> |
| 142 | *<p> |
| 143 | * To simplify the task of setting up the environment |
| 144 | * required by a JNDI application, |
| 145 | * application components and service providers may be distributed |
| 146 | * along with <em>resource files.</em> |
| 147 | * A JNDI resource file is a file in the properties file format (see |
| 148 | * {@link java.util.Properties#load <tt>java.util.Properties</tt>}), |
| 149 | * containing a list of key/value pairs. |
| 150 | * The key is the name of the property (e.g. "java.naming.factory.object") |
| 151 | * and the value is a string in the format defined |
| 152 | * for that property. Here is an example of a JNDI resource file: |
| 153 | * |
| 154 | * <blockquote><tt><pre> |
| 155 | * java.naming.factory.object=com.sun.jndi.ldap.AttrsToCorba:com.wiz.from.Person |
| 156 | * java.naming.factory.state=com.sun.jndi.ldap.CorbaToAttrs:com.wiz.from.Person |
| 157 | * java.naming.factory.control=com.sun.jndi.ldap.ResponseControlFactory |
| 158 | * </pre></tt></blockquote> |
| 159 | * |
| 160 | * The JNDI class library reads the resource files and makes the property |
| 161 | * values freely available. Thus JNDI resource files should be considered |
| 162 | * to be "world readable", and sensitive information such as clear-text |
| 163 | * passwords should not be stored there. |
| 164 | *<p> |
| 165 | * There are two kinds of JNDI resource files: |
| 166 | * <em>provider</em> and <em>application</em>. |
| 167 | * |
| 168 | * <h5>Provider Resource Files</h5> |
| 169 | * |
| 170 | * Each service provider has an optional resource that lists properties |
| 171 | * specific to that provider. The name of this resource is: |
| 172 | * <blockquote> |
| 173 | * [<em>prefix</em>/]<tt>jndiprovider.properties</tt> |
| 174 | * </blockquote> |
| 175 | * where <em>prefix</em> is |
| 176 | * the package name of the provider's context implementation(s), |
| 177 | * with each period (".") converted to a slash ("/"). |
| 178 | * |
| 179 | * For example, suppose a service provider defines a context |
| 180 | * implementation with class name <tt>com.sun.jndi.ldap.LdapCtx</tt>. |
| 181 | * The provider resource for this provider is named |
| 182 | * <tt>com/sun/jndi/ldap/jndiprovider.properties</tt>. If the class is |
| 183 | * not in a package, the resource's name is simply |
| 184 | * <tt>jndiprovider.properties</tt>. |
| 185 | * |
| 186 | * <p> |
| 187 | * <a name=LISTPROPS></a> |
| 188 | * Certain methods in the JNDI class library make use of the standard |
| 189 | * JNDI properties that specify lists of JNDI factories: |
| 190 | * <ul> |
| 191 | * <li>java.naming.factory.object |
| 192 | * <li>java.naming.factory.state |
| 193 | * <li>java.naming.factory.control |
| 194 | * <li>java.naming.factory.url.pkgs |
| 195 | * </ul> |
| 196 | * The JNDI library will consult the provider resource file |
| 197 | * when determining the values of these properties. |
| 198 | * Properties other than these may be set in the provider |
| 199 | * resource file at the discretion of the service provider. |
| 200 | * The service provider's documentation should clearly state which |
| 201 | * properties are allowed; other properties in the file will be ignored. |
| 202 | * |
| 203 | * <h5>Application Resource Files</h5> |
| 204 | * |
| 205 | * When an application is deployed, it will generally have several |
| 206 | * codebase directories and JARs in its classpath. Similarly, when an |
| 207 | * applet is deployed, it will have a codebase and archives specifying |
| 208 | * where to find the applet's classes. JNDI locates (using |
| 209 | * {@link ClassLoader#getResources <tt>ClassLoader.getResources()</tt>}) |
| 210 | * all <em>application resource files</em> named <tt>jndi.properties</tt> |
| 211 | * in the classpath. |
| 212 | * In addition, if the file <i>java.home</i><tt>/lib/jndi.properties</tt> |
| 213 | * exists and is readable, |
| 214 | * JNDI treats it as an additional application resource file. |
| 215 | * (<i>java.home</i> indicates the |
| 216 | * directory named by the <tt>java.home</tt> system property.) |
| 217 | * All of the properties contained in these files are placed |
| 218 | * into the environment of the initial context. This environment |
| 219 | * is then inherited by other contexts. |
| 220 | * |
| 221 | * <p> |
| 222 | * For each property found in more than one application resource file, |
| 223 | * JNDI uses the first value found or, in a few cases where it makes |
| 224 | * sense to do so, it concatenates all of the values (details are given |
| 225 | * below). |
| 226 | * For example, if the "java.naming.factory.object" property is found in |
| 227 | * three <tt>jndi.properties</tt> resource files, the |
| 228 | * list of object factories is a concatenation of the property |
| 229 | * values from all three files. |
| 230 | * Using this scheme, each deployable component is responsible for |
| 231 | * listing the factories that it exports. JNDI automatically |
| 232 | * collects and uses all of these export lists when searching for factory |
| 233 | * classes. |
| 234 | * |
| 235 | * <h5>Search Algorithm for Properties</h5> |
| 236 | * |
| 237 | * When JNDI constructs an initial context, the context's environment |
| 238 | * is initialized with properties defined in the environment parameter |
| 239 | * passed to the constructor, the system properties, the applet parameters, |
| 240 | * and the application resource files. See |
| 241 | * <a href=InitialContext.html#ENVIRONMENT><tt>InitialContext</tt></a> |
| 242 | * for details. |
| 243 | * This initial environment is then inherited by other context instances. |
| 244 | * |
| 245 | * <p> |
| 246 | * When the JNDI class library needs to determine |
| 247 | * the value of a property, it does so by merging |
| 248 | * the values from the following two sources, in order: |
| 249 | * <ol> |
| 250 | * <li>The environment of the context being operated on. |
| 251 | * <li>The provider resource file (<tt>jndiprovider.properties</tt>) |
| 252 | * for the context being operated on. |
| 253 | * </ol> |
| 254 | * For each property found in both of these two sources, |
| 255 | * JNDI determines the property's value as follows. If the property is |
| 256 | * one of the standard JNDI properties that specify a list of JNDI |
| 257 | * factories (listed <a href=#LISTPROPS>above</a>), the values are |
| 258 | * concatenated into a single colon-separated list. For other |
| 259 | * properties, only the first value found is used. |
| 260 | * |
| 261 | * <p> |
| 262 | * When a service provider needs to determine the value of a property, |
| 263 | * it will generally take that value directly from the environment. |
| 264 | * A service provider may define provider-specific properties |
| 265 | * to be placed in its own provider resource file. In that |
| 266 | * case it should merge values as described in the previous paragraph. |
| 267 | * |
| 268 | * <p> |
| 269 | * In this way, each service provider developer can specify a list of |
| 270 | * factories to use with that service provider. These can be modified by |
| 271 | * the application resources specified by the deployer of the application |
| 272 | * or applet, which in turn can be modified by the user. |
| 273 | * |
| 274 | * @author Rosanna Lee |
| 275 | * @author Scott Seligman |
| 276 | * @author R. Vasudevan |
| 277 | * |
| 278 | * @since 1.3 |
| 279 | */ |
| 280 | |
| 281 | public interface Context { |
| 282 | |
| 283 | /** |
| 284 | * Retrieves the named object. |
| 285 | * If <tt>name</tt> is empty, returns a new instance of this context |
| 286 | * (which represents the same naming context as this context, but its |
| 287 | * environment may be modified independently and it may be accessed |
| 288 | * concurrently). |
| 289 | * |
| 290 | * @param name |
| 291 | * the name of the object to look up |
| 292 | * @return the object bound to <tt>name</tt> |
| 293 | * @throws NamingException if a naming exception is encountered |
| 294 | * |
| 295 | * @see #lookup(String) |
| 296 | * @see #lookupLink(Name) |
| 297 | */ |
| 298 | public Object lookup(Name name) throws NamingException; |
| 299 | |
| 300 | /** |
| 301 | * Retrieves the named object. |
| 302 | * See {@link #lookup(Name)} for details. |
| 303 | * @param name |
| 304 | * the name of the object to look up |
| 305 | * @return the object bound to <tt>name</tt> |
| 306 | * @throws NamingException if a naming exception is encountered |
| 307 | */ |
| 308 | public Object lookup(String name) throws NamingException; |
| 309 | |
| 310 | /** |
| 311 | * Binds a name to an object. |
| 312 | * All intermediate contexts and the target context (that named by all |
| 313 | * but terminal atomic component of the name) must already exist. |
| 314 | * |
| 315 | * @param name |
| 316 | * the name to bind; may not be empty |
| 317 | * @param obj |
| 318 | * the object to bind; possibly null |
| 319 | * @throws NameAlreadyBoundException if name is already bound |
| 320 | * @throws javax.naming.directory.InvalidAttributesException |
| 321 | * if object did not supply all mandatory attributes |
| 322 | * @throws NamingException if a naming exception is encountered |
| 323 | * |
| 324 | * @see #bind(String, Object) |
| 325 | * @see #rebind(Name, Object) |
| 326 | * @see javax.naming.directory.DirContext#bind(Name, Object, |
| 327 | * javax.naming.directory.Attributes) |
| 328 | */ |
| 329 | public void bind(Name name, Object obj) throws NamingException; |
| 330 | |
| 331 | /** |
| 332 | * Binds a name to an object. |
| 333 | * See {@link #bind(Name, Object)} for details. |
| 334 | * |
| 335 | * @param name |
| 336 | * the name to bind; may not be empty |
| 337 | * @param obj |
| 338 | * the object to bind; possibly null |
| 339 | * @throws NameAlreadyBoundException if name is already bound |
| 340 | * @throws javax.naming.directory.InvalidAttributesException |
| 341 | * if object did not supply all mandatory attributes |
| 342 | * @throws NamingException if a naming exception is encountered |
| 343 | */ |
| 344 | public void bind(String name, Object obj) throws NamingException; |
| 345 | |
| 346 | /** |
| 347 | * Binds a name to an object, overwriting any existing binding. |
| 348 | * All intermediate contexts and the target context (that named by all |
| 349 | * but terminal atomic component of the name) must already exist. |
| 350 | * |
| 351 | * <p> If the object is a <tt>DirContext</tt>, any existing attributes |
| 352 | * associated with the name are replaced with those of the object. |
| 353 | * Otherwise, any existing attributes associated with the name remain |
| 354 | * unchanged. |
| 355 | * |
| 356 | * @param name |
| 357 | * the name to bind; may not be empty |
| 358 | * @param obj |
| 359 | * the object to bind; possibly null |
| 360 | * @throws javax.naming.directory.InvalidAttributesException |
| 361 | * if object did not supply all mandatory attributes |
| 362 | * @throws NamingException if a naming exception is encountered |
| 363 | * |
| 364 | * @see #rebind(String, Object) |
| 365 | * @see #bind(Name, Object) |
| 366 | * @see javax.naming.directory.DirContext#rebind(Name, Object, |
| 367 | * javax.naming.directory.Attributes) |
| 368 | * @see javax.naming.directory.DirContext |
| 369 | */ |
| 370 | public void rebind(Name name, Object obj) throws NamingException; |
| 371 | |
| 372 | /** |
| 373 | * Binds a name to an object, overwriting any existing binding. |
| 374 | * See {@link #rebind(Name, Object)} for details. |
| 375 | * |
| 376 | * @param name |
| 377 | * the name to bind; may not be empty |
| 378 | * @param obj |
| 379 | * the object to bind; possibly null |
| 380 | * @throws javax.naming.directory.InvalidAttributesException |
| 381 | * if object did not supply all mandatory attributes |
| 382 | * @throws NamingException if a naming exception is encountered |
| 383 | */ |
| 384 | public void rebind(String name, Object obj) throws NamingException; |
| 385 | |
| 386 | /** |
| 387 | * Unbinds the named object. |
| 388 | * Removes the terminal atomic name in <code>name</code> |
| 389 | * from the target context--that named by all but the terminal |
| 390 | * atomic part of <code>name</code>. |
| 391 | * |
| 392 | * <p> This method is idempotent. |
| 393 | * It succeeds even if the terminal atomic name |
| 394 | * is not bound in the target context, but throws |
| 395 | * <tt>NameNotFoundException</tt> |
| 396 | * if any of the intermediate contexts do not exist. |
| 397 | * |
| 398 | * <p> Any attributes associated with the name are removed. |
| 399 | * Intermediate contexts are not changed. |
| 400 | * |
| 401 | * @param name |
| 402 | * the name to unbind; may not be empty |
| 403 | * @throws NameNotFoundException if an intermediate context does not exist |
| 404 | * @throws NamingException if a naming exception is encountered |
| 405 | * @see #unbind(String) |
| 406 | */ |
| 407 | public void unbind(Name name) throws NamingException; |
| 408 | |
| 409 | /** |
| 410 | * Unbinds the named object. |
| 411 | * See {@link #unbind(Name)} for details. |
| 412 | * |
| 413 | * @param name |
| 414 | * the name to unbind; may not be empty |
| 415 | * @throws NameNotFoundException if an intermediate context does not exist |
| 416 | * @throws NamingException if a naming exception is encountered |
| 417 | */ |
| 418 | public void unbind(String name) throws NamingException; |
| 419 | |
| 420 | /** |
| 421 | * Binds a new name to the object bound to an old name, and unbinds |
| 422 | * the old name. Both names are relative to this context. |
| 423 | * Any attributes associated with the old name become associated |
| 424 | * with the new name. |
| 425 | * Intermediate contexts of the old name are not changed. |
| 426 | * |
| 427 | * @param oldName |
| 428 | * the name of the existing binding; may not be empty |
| 429 | * @param newName |
| 430 | * the name of the new binding; may not be empty |
| 431 | * @throws NameAlreadyBoundException if <tt>newName</tt> is already bound |
| 432 | * @throws NamingException if a naming exception is encountered |
| 433 | * |
| 434 | * @see #rename(String, String) |
| 435 | * @see #bind(Name, Object) |
| 436 | * @see #rebind(Name, Object) |
| 437 | */ |
| 438 | public void rename(Name oldName, Name newName) throws NamingException; |
| 439 | |
| 440 | /** |
| 441 | * Binds a new name to the object bound to an old name, and unbinds |
| 442 | * the old name. |
| 443 | * See {@link #rename(Name, Name)} for details. |
| 444 | * |
| 445 | * @param oldName |
| 446 | * the name of the existing binding; may not be empty |
| 447 | * @param newName |
| 448 | * the name of the new binding; may not be empty |
| 449 | * @throws NameAlreadyBoundException if <tt>newName</tt> is already bound |
| 450 | * @throws NamingException if a naming exception is encountered |
| 451 | */ |
| 452 | public void rename(String oldName, String newName) throws NamingException; |
| 453 | |
| 454 | /** |
| 455 | * Enumerates the names bound in the named context, along with the |
| 456 | * class names of objects bound to them. |
| 457 | * The contents of any subcontexts are not included. |
| 458 | * |
| 459 | * <p> If a binding is added to or removed from this context, |
| 460 | * its effect on an enumeration previously returned is undefined. |
| 461 | * |
| 462 | * @param name |
| 463 | * the name of the context to list |
| 464 | * @return an enumeration of the names and class names of the |
| 465 | * bindings in this context. Each element of the |
| 466 | * enumeration is of type <tt>NameClassPair</tt>. |
| 467 | * @throws NamingException if a naming exception is encountered |
| 468 | * |
| 469 | * @see #list(String) |
| 470 | * @see #listBindings(Name) |
| 471 | * @see NameClassPair |
| 472 | */ |
| 473 | public NamingEnumeration<NameClassPair> list(Name name) |
| 474 | throws NamingException; |
| 475 | |
| 476 | /** |
| 477 | * Enumerates the names bound in the named context, along with the |
| 478 | * class names of objects bound to them. |
| 479 | * See {@link #list(Name)} for details. |
| 480 | * |
| 481 | * @param name |
| 482 | * the name of the context to list |
| 483 | * @return an enumeration of the names and class names of the |
| 484 | * bindings in this context. Each element of the |
| 485 | * enumeration is of type <tt>NameClassPair</tt>. |
| 486 | * @throws NamingException if a naming exception is encountered |
| 487 | */ |
| 488 | public NamingEnumeration<NameClassPair> list(String name) |
| 489 | throws NamingException; |
| 490 | |
| 491 | /** |
| 492 | * Enumerates the names bound in the named context, along with the |
| 493 | * objects bound to them. |
| 494 | * The contents of any subcontexts are not included. |
| 495 | * |
| 496 | * <p> If a binding is added to or removed from this context, |
| 497 | * its effect on an enumeration previously returned is undefined. |
| 498 | * |
| 499 | * @param name |
| 500 | * the name of the context to list |
| 501 | * @return an enumeration of the bindings in this context. |
| 502 | * Each element of the enumeration is of type |
| 503 | * <tt>Binding</tt>. |
| 504 | * @throws NamingException if a naming exception is encountered |
| 505 | * |
| 506 | * @see #listBindings(String) |
| 507 | * @see #list(Name) |
| 508 | * @see Binding |
| 509 | */ |
| 510 | public NamingEnumeration<Binding> listBindings(Name name) |
| 511 | throws NamingException; |
| 512 | |
| 513 | /** |
| 514 | * Enumerates the names bound in the named context, along with the |
| 515 | * objects bound to them. |
| 516 | * See {@link #listBindings(Name)} for details. |
| 517 | * |
| 518 | * @param name |
| 519 | * the name of the context to list |
| 520 | * @return an enumeration of the bindings in this context. |
| 521 | * Each element of the enumeration is of type |
| 522 | * <tt>Binding</tt>. |
| 523 | * @throws NamingException if a naming exception is encountered |
| 524 | */ |
| 525 | public NamingEnumeration<Binding> listBindings(String name) |
| 526 | throws NamingException; |
| 527 | |
| 528 | /** |
| 529 | * Destroys the named context and removes it from the namespace. |
| 530 | * Any attributes associated with the name are also removed. |
| 531 | * Intermediate contexts are not destroyed. |
| 532 | * |
| 533 | * <p> This method is idempotent. |
| 534 | * It succeeds even if the terminal atomic name |
| 535 | * is not bound in the target context, but throws |
| 536 | * <tt>NameNotFoundException</tt> |
| 537 | * if any of the intermediate contexts do not exist. |
| 538 | * |
| 539 | * <p> In a federated naming system, a context from one naming system |
| 540 | * may be bound to a name in another. One can subsequently |
| 541 | * look up and perform operations on the foreign context using a |
| 542 | * composite name. However, an attempt destroy the context using |
| 543 | * this composite name will fail with |
| 544 | * <tt>NotContextException</tt>, because the foreign context is not |
| 545 | * a "subcontext" of the context in which it is bound. |
| 546 | * Instead, use <tt>unbind()</tt> to remove the |
| 547 | * binding of the foreign context. Destroying the foreign context |
| 548 | * requires that the <tt>destroySubcontext()</tt> be performed |
| 549 | * on a context from the foreign context's "native" naming system. |
| 550 | * |
| 551 | * @param name |
| 552 | * the name of the context to be destroyed; may not be empty |
| 553 | * @throws NameNotFoundException if an intermediate context does not exist |
| 554 | * @throws NotContextException if the name is bound but does not name a |
| 555 | * context, or does not name a context of the appropriate type |
| 556 | * @throws ContextNotEmptyException if the named context is not empty |
| 557 | * @throws NamingException if a naming exception is encountered |
| 558 | * |
| 559 | * @see #destroySubcontext(String) |
| 560 | */ |
| 561 | public void destroySubcontext(Name name) throws NamingException; |
| 562 | |
| 563 | /** |
| 564 | * Destroys the named context and removes it from the namespace. |
| 565 | * See {@link #destroySubcontext(Name)} for details. |
| 566 | * |
| 567 | * @param name |
| 568 | * the name of the context to be destroyed; may not be empty |
| 569 | * @throws NameNotFoundException if an intermediate context does not exist |
| 570 | * @throws NotContextException if the name is bound but does not name a |
| 571 | * context, or does not name a context of the appropriate type |
| 572 | * @throws ContextNotEmptyException if the named context is not empty |
| 573 | * @throws NamingException if a naming exception is encountered |
| 574 | */ |
| 575 | public void destroySubcontext(String name) throws NamingException; |
| 576 | |
| 577 | /** |
| 578 | * Creates and binds a new context. |
| 579 | * Creates a new context with the given name and binds it in |
| 580 | * the target context (that named by all but terminal atomic |
| 581 | * component of the name). All intermediate contexts and the |
| 582 | * target context must already exist. |
| 583 | * |
| 584 | * @param name |
| 585 | * the name of the context to create; may not be empty |
| 586 | * @return the newly created context |
| 587 | * |
| 588 | * @throws NameAlreadyBoundException if name is already bound |
| 589 | * @throws javax.naming.directory.InvalidAttributesException |
| 590 | * if creation of the subcontext requires specification of |
| 591 | * mandatory attributes |
| 592 | * @throws NamingException if a naming exception is encountered |
| 593 | * |
| 594 | * @see #createSubcontext(String) |
| 595 | * @see javax.naming.directory.DirContext#createSubcontext |
| 596 | */ |
| 597 | public Context createSubcontext(Name name) throws NamingException; |
| 598 | |
| 599 | /** |
| 600 | * Creates and binds a new context. |
| 601 | * See {@link #createSubcontext(Name)} for details. |
| 602 | * |
| 603 | * @param name |
| 604 | * the name of the context to create; may not be empty |
| 605 | * @return the newly created context |
| 606 | * |
| 607 | * @throws NameAlreadyBoundException if name is already bound |
| 608 | * @throws javax.naming.directory.InvalidAttributesException |
| 609 | * if creation of the subcontext requires specification of |
| 610 | * mandatory attributes |
| 611 | * @throws NamingException if a naming exception is encountered |
| 612 | */ |
| 613 | public Context createSubcontext(String name) throws NamingException; |
| 614 | |
| 615 | /** |
| 616 | * Retrieves the named object, following links except |
| 617 | * for the terminal atomic component of the name. |
| 618 | * If the object bound to <tt>name</tt> is not a link, |
| 619 | * returns the object itself. |
| 620 | * |
| 621 | * @param name |
| 622 | * the name of the object to look up |
| 623 | * @return the object bound to <tt>name</tt>, not following the |
| 624 | * terminal link (if any). |
| 625 | * @throws NamingException if a naming exception is encountered |
| 626 | * |
| 627 | * @see #lookupLink(String) |
| 628 | */ |
| 629 | public Object lookupLink(Name name) throws NamingException; |
| 630 | |
| 631 | /** |
| 632 | * Retrieves the named object, following links except |
| 633 | * for the terminal atomic component of the name. |
| 634 | * See {@link #lookupLink(Name)} for details. |
| 635 | * |
| 636 | * @param name |
| 637 | * the name of the object to look up |
| 638 | * @return the object bound to <tt>name</tt>, not following the |
| 639 | * terminal link (if any) |
| 640 | * @throws NamingException if a naming exception is encountered |
| 641 | */ |
| 642 | public Object lookupLink(String name) throws NamingException; |
| 643 | |
| 644 | /** |
| 645 | * Retrieves the parser associated with the named context. |
| 646 | * In a federation of namespaces, different naming systems will |
| 647 | * parse names differently. This method allows an application |
| 648 | * to get a parser for parsing names into their atomic components |
| 649 | * using the naming convention of a particular naming system. |
| 650 | * Within any single naming system, <tt>NameParser</tt> objects |
| 651 | * returned by this method must be equal (using the <tt>equals()</tt> |
| 652 | * test). |
| 653 | * |
| 654 | * @param name |
| 655 | * the name of the context from which to get the parser |
| 656 | * @return a name parser that can parse compound names into their atomic |
| 657 | * components |
| 658 | * @throws NamingException if a naming exception is encountered |
| 659 | * |
| 660 | * @see #getNameParser(String) |
| 661 | * @see CompoundName |
| 662 | */ |
| 663 | public NameParser getNameParser(Name name) throws NamingException; |
| 664 | |
| 665 | /** |
| 666 | * Retrieves the parser associated with the named context. |
| 667 | * See {@link #getNameParser(Name)} for details. |
| 668 | * |
| 669 | * @param name |
| 670 | * the name of the context from which to get the parser |
| 671 | * @return a name parser that can parse compound names into their atomic |
| 672 | * components |
| 673 | * @throws NamingException if a naming exception is encountered |
| 674 | */ |
| 675 | public NameParser getNameParser(String name) throws NamingException; |
| 676 | |
| 677 | /** |
| 678 | * Composes the name of this context with a name relative to |
| 679 | * this context. |
| 680 | * Given a name (<code>name</code>) relative to this context, and |
| 681 | * the name (<code>prefix</code>) of this context relative to one |
| 682 | * of its ancestors, this method returns the composition of the |
| 683 | * two names using the syntax appropriate for the naming |
| 684 | * system(s) involved. That is, if <code>name</code> names an |
| 685 | * object relative to this context, the result is the name of the |
| 686 | * same object, but relative to the ancestor context. None of the |
| 687 | * names may be null. |
| 688 | * <p> |
| 689 | * For example, if this context is named "wiz.com" relative |
| 690 | * to the initial context, then |
| 691 | * <pre> |
| 692 | * composeName("east", "wiz.com") </pre> |
| 693 | * might return <code>"east.wiz.com"</code>. |
| 694 | * If instead this context is named "org/research", then |
| 695 | * <pre> |
| 696 | * composeName("user/jane", "org/research") </pre> |
| 697 | * might return <code>"org/research/user/jane"</code> while |
| 698 | * <pre> |
| 699 | * composeName("user/jane", "research") </pre> |
| 700 | * returns <code>"research/user/jane"</code>. |
| 701 | * |
| 702 | * @param name |
| 703 | * a name relative to this context |
| 704 | * @param prefix |
| 705 | * the name of this context relative to one of its ancestors |
| 706 | * @return the composition of <code>prefix</code> and <code>name</code> |
| 707 | * @throws NamingException if a naming exception is encountered |
| 708 | * |
| 709 | * @see #composeName(String, String) |
| 710 | */ |
| 711 | public Name composeName(Name name, Name prefix) |
| 712 | throws NamingException; |
| 713 | |
| 714 | /** |
| 715 | * Composes the name of this context with a name relative to |
| 716 | * this context. |
| 717 | * See {@link #composeName(Name, Name)} for details. |
| 718 | * |
| 719 | * @param name |
| 720 | * a name relative to this context |
| 721 | * @param prefix |
| 722 | * the name of this context relative to one of its ancestors |
| 723 | * @return the composition of <code>prefix</code> and <code>name</code> |
| 724 | * @throws NamingException if a naming exception is encountered |
| 725 | */ |
| 726 | public String composeName(String name, String prefix) |
| 727 | throws NamingException; |
| 728 | |
| 729 | /** |
| 730 | * Adds a new environment property to the environment of this |
| 731 | * context. If the property already exists, its value is overwritten. |
| 732 | * See class description for more details on environment properties. |
| 733 | * |
| 734 | * @param propName |
| 735 | * the name of the environment property to add; may not be null |
| 736 | * @param propVal |
| 737 | * the value of the property to add; may not be null |
| 738 | * @return the previous value of the property, or null if the property was |
| 739 | * not in the environment before |
| 740 | * @throws NamingException if a naming exception is encountered |
| 741 | * |
| 742 | * @see #getEnvironment() |
| 743 | * @see #removeFromEnvironment(String) |
| 744 | */ |
| 745 | public Object addToEnvironment(String propName, Object propVal) |
| 746 | throws NamingException; |
| 747 | |
| 748 | /** |
| 749 | * Removes an environment property from the environment of this |
| 750 | * context. See class description for more details on environment |
| 751 | * properties. |
| 752 | * |
| 753 | * @param propName |
| 754 | * the name of the environment property to remove; may not be null |
| 755 | * @return the previous value of the property, or null if the property was |
| 756 | * not in the environment |
| 757 | * @throws NamingException if a naming exception is encountered |
| 758 | * |
| 759 | * @see #getEnvironment() |
| 760 | * @see #addToEnvironment(String, Object) |
| 761 | */ |
| 762 | public Object removeFromEnvironment(String propName) |
| 763 | throws NamingException; |
| 764 | |
| 765 | /** |
| 766 | * Retrieves the environment in effect for this context. |
| 767 | * See class description for more details on environment properties. |
| 768 | * |
| 769 | * <p> The caller should not make any changes to the object returned: |
| 770 | * their effect on the context is undefined. |
| 771 | * The environment of this context may be changed using |
| 772 | * <tt>addToEnvironment()</tt> and <tt>removeFromEnvironment()</tt>. |
| 773 | * |
| 774 | * @return the environment of this context; never null |
| 775 | * @throws NamingException if a naming exception is encountered |
| 776 | * |
| 777 | * @see #addToEnvironment(String, Object) |
| 778 | * @see #removeFromEnvironment(String) |
| 779 | */ |
| 780 | public Hashtable<?,?> getEnvironment() throws NamingException; |
| 781 | |
| 782 | /** |
| 783 | * Closes this context. |
| 784 | * This method releases this context's resources immediately, instead of |
| 785 | * waiting for them to be released automatically by the garbage collector. |
| 786 | * |
| 787 | * <p> This method is idempotent: invoking it on a context that has |
| 788 | * already been closed has no effect. Invoking any other method |
| 789 | * on a closed context is not allowed, and results in undefined behaviour. |
| 790 | * |
| 791 | * @throws NamingException if a naming exception is encountered |
| 792 | */ |
| 793 | public void close() throws NamingException; |
| 794 | |
| 795 | /** |
| 796 | * Retrieves the full name of this context within its own namespace. |
| 797 | * |
| 798 | * <p> Many naming services have a notion of a "full name" for objects |
| 799 | * in their respective namespaces. For example, an LDAP entry has |
| 800 | * a distinguished name, and a DNS record has a fully qualified name. |
| 801 | * This method allows the client application to retrieve this name. |
| 802 | * The string returned by this method is not a JNDI composite name |
| 803 | * and should not be passed directly to context methods. |
| 804 | * In naming systems for which the notion of full name does not |
| 805 | * make sense, <tt>OperationNotSupportedException</tt> is thrown. |
| 806 | * |
| 807 | * @return this context's name in its own namespace; never null |
| 808 | * @throws OperationNotSupportedException if the naming system does |
| 809 | * not have the notion of a full name |
| 810 | * @throws NamingException if a naming exception is encountered |
| 811 | * |
| 812 | * @since 1.3 |
| 813 | */ |
| 814 | public String getNameInNamespace() throws NamingException; |
| 815 | |
| 816 | // public static final: JLS says recommended style is to omit these modifiers |
| 817 | // because they are the default |
| 818 | |
| 819 | /** |
| 820 | * Constant that holds the name of the environment property |
| 821 | * for specifying the initial context factory to use. The value |
| 822 | * of the property should be the fully qualified class name |
| 823 | * of the factory class that will create an initial context. |
| 824 | * This property may be specified in the environment parameter |
| 825 | * passed to the initial context constructor, an applet parameter, |
| 826 | * a system property, or an application resource file. |
| 827 | * If it is not specified in any of these sources, |
| 828 | * <tt>NoInitialContextException</tt> is thrown when an initial |
| 829 | * context is required to complete an operation. |
| 830 | * |
| 831 | * <p> The value of this constant is "java.naming.factory.initial". |
| 832 | * |
| 833 | * @see InitialContext |
| 834 | * @see javax.naming.directory.InitialDirContext |
| 835 | * @see javax.naming.spi.NamingManager#getInitialContext |
| 836 | * @see javax.naming.spi.InitialContextFactory |
| 837 | * @see NoInitialContextException |
| 838 | * @see #addToEnvironment(String, Object) |
| 839 | * @see #removeFromEnvironment(String) |
| 840 | * @see #APPLET |
| 841 | */ |
| 842 | String INITIAL_CONTEXT_FACTORY = "java.naming.factory.initial"; |
| 843 | |
| 844 | /** |
| 845 | * Constant that holds the name of the environment property |
| 846 | * for specifying the list of object factories to use. The value |
| 847 | * of the property should be a colon-separated list of the fully |
| 848 | * qualified class names of factory classes that will create an object |
| 849 | * given information about the object. |
| 850 | * This property may be specified in the environment, an applet |
| 851 | * parameter, a system property, or one or more resource files. |
| 852 | * |
| 853 | * <p> The value of this constant is "java.naming.factory.object". |
| 854 | * |
| 855 | * @see javax.naming.spi.NamingManager#getObjectInstance |
| 856 | * @see javax.naming.spi.ObjectFactory |
| 857 | * @see #addToEnvironment(String, Object) |
| 858 | * @see #removeFromEnvironment(String) |
| 859 | * @see #APPLET |
| 860 | */ |
| 861 | String OBJECT_FACTORIES = "java.naming.factory.object"; |
| 862 | |
| 863 | /** |
| 864 | * Constant that holds the name of the environment property |
| 865 | * for specifying the list of state factories to use. The value |
| 866 | * of the property should be a colon-separated list of the fully |
| 867 | * qualified class names of state factory classes that will be used |
| 868 | * to get an object's state given the object itself. |
| 869 | * This property may be specified in the environment, an applet |
| 870 | * parameter, a system property, or one or more resource files. |
| 871 | * |
| 872 | * <p> The value of this constant is "java.naming.factory.state". |
| 873 | * |
| 874 | * @see javax.naming.spi.NamingManager#getStateToBind |
| 875 | * @see javax.naming.spi.StateFactory |
| 876 | * @see #addToEnvironment(String, Object) |
| 877 | * @see #removeFromEnvironment(String) |
| 878 | * @see #APPLET |
| 879 | * @since 1.3 |
| 880 | */ |
| 881 | String STATE_FACTORIES = "java.naming.factory.state"; |
| 882 | |
| 883 | /** |
| 884 | * Constant that holds the name of the environment property |
| 885 | * for specifying the list of package prefixes to use when |
| 886 | * loading in URL context factories. The value |
| 887 | * of the property should be a colon-separated list of package |
| 888 | * prefixes for the class name of the factory class that will create |
| 889 | * a URL context factory. |
| 890 | * This property may be specified in the environment, |
| 891 | * an applet parameter, a system property, or one or more |
| 892 | * resource files. |
| 893 | * The prefix <tt>com.sun.jndi.url</tt> is always appended to |
| 894 | * the possibly empty list of package prefixes. |
| 895 | * |
| 896 | * <p> The value of this constant is "java.naming.factory.url.pkgs". |
| 897 | * |
| 898 | * @see javax.naming.spi.NamingManager#getObjectInstance |
| 899 | * @see javax.naming.spi.NamingManager#getURLContext |
| 900 | * @see javax.naming.spi.ObjectFactory |
| 901 | * @see #addToEnvironment(String, Object) |
| 902 | * @see #removeFromEnvironment(String) |
| 903 | * @see #APPLET |
| 904 | */ |
| 905 | String URL_PKG_PREFIXES = "java.naming.factory.url.pkgs"; |
| 906 | |
| 907 | /** |
| 908 | * Constant that holds the name of the environment property |
| 909 | * for specifying configuration information for the service provider |
| 910 | * to use. The value of the property should contain a URL string |
| 911 | * (e.g. "ldap://somehost:389"). |
| 912 | * This property may be specified in the environment, |
| 913 | * an applet parameter, a system property, or a resource file. |
| 914 | * If it is not specified in any of these sources, |
| 915 | * the default configuration is determined by the service provider. |
| 916 | * |
| 917 | * <p> The value of this constant is "java.naming.provider.url". |
| 918 | * |
| 919 | * @see #addToEnvironment(String, Object) |
| 920 | * @see #removeFromEnvironment(String) |
| 921 | * @see #APPLET |
| 922 | */ |
| 923 | String PROVIDER_URL = "java.naming.provider.url"; |
| 924 | |
| 925 | /** |
| 926 | * Constant that holds the name of the environment property |
| 927 | * for specifying the DNS host and domain names to use for the |
| 928 | * JNDI URL context (for example, "dns://somehost/wiz.com"). |
| 929 | * This property may be specified in the environment, |
| 930 | * an applet parameter, a system property, or a resource file. |
| 931 | * If it is not specified in any of these sources |
| 932 | * and the program attempts to use a JNDI URL containing a DNS name, |
| 933 | * a <tt>ConfigurationException</tt> will be thrown. |
| 934 | * |
| 935 | * <p> The value of this constant is "java.naming.dns.url". |
| 936 | * |
| 937 | * @see #addToEnvironment(String, Object) |
| 938 | * @see #removeFromEnvironment(String) |
| 939 | */ |
| 940 | String DNS_URL = "java.naming.dns.url"; |
| 941 | |
| 942 | /** |
| 943 | * Constant that holds the name of the environment property for |
| 944 | * specifying the authoritativeness of the service requested. |
| 945 | * If the value of the property is the string "true", it means |
| 946 | * that the access is to the most authoritative source (i.e. bypass |
| 947 | * any cache or replicas). If the value is anything else, |
| 948 | * the source need not be (but may be) authoritative. |
| 949 | * If unspecified, the value defaults to "false". |
| 950 | * |
| 951 | * <p> The value of this constant is "java.naming.authoritative". |
| 952 | * |
| 953 | * @see #addToEnvironment(String, Object) |
| 954 | * @see #removeFromEnvironment(String) |
| 955 | */ |
| 956 | String AUTHORITATIVE = "java.naming.authoritative"; |
| 957 | |
| 958 | /** |
| 959 | * Constant that holds the name of the environment property for |
| 960 | * specifying the batch size to use when returning data via the |
| 961 | * service's protocol. This is a hint to the provider to return |
| 962 | * the results of operations in batches of the specified size, so |
| 963 | * the provider can optimize its performance and usage of resources. |
| 964 | * The value of the property is the string representation of an |
| 965 | * integer. |
| 966 | * If unspecified, the batch size is determined by the service |
| 967 | * provider. |
| 968 | * |
| 969 | * <p> The value of this constant is "java.naming.batchsize". |
| 970 | * |
| 971 | * @see #addToEnvironment(String, Object) |
| 972 | * @see #removeFromEnvironment(String) |
| 973 | */ |
| 974 | String BATCHSIZE = "java.naming.batchsize"; |
| 975 | |
| 976 | /** |
| 977 | * Constant that holds the name of the environment property for |
| 978 | * specifying how referrals encountered by the service provider |
| 979 | * are to be processed. The value of the property is one of the |
| 980 | * following strings: |
| 981 | * <dl> |
| 982 | * <dt>"follow" |
| 983 | * <dd>follow referrals automatically |
| 984 | * <dt>"ignore" |
| 985 | * <dd>ignore referrals |
| 986 | * <dt>"throw" |
| 987 | * <dd>throw <tt>ReferralException</tt> when a referral is encountered. |
| 988 | * </dl> |
| 989 | * If this property is not specified, the default is |
| 990 | * determined by the provider. |
| 991 | * |
| 992 | * <p> The value of this constant is "java.naming.referral". |
| 993 | * |
| 994 | * @see #addToEnvironment(String, Object) |
| 995 | * @see #removeFromEnvironment(String) |
| 996 | */ |
| 997 | String REFERRAL = "java.naming.referral"; |
| 998 | |
| 999 | /** |
| 1000 | * Constant that holds the name of the environment property for |
| 1001 | * specifying the security protocol to use. |
| 1002 | * Its value is a string determined by the service provider |
| 1003 | * (e.g. "ssl"). |
| 1004 | * If this property is unspecified, |
| 1005 | * the behaviour is determined by the service provider. |
| 1006 | * |
| 1007 | * <p> The value of this constant is "java.naming.security.protocol". |
| 1008 | * |
| 1009 | * @see #addToEnvironment(String, Object) |
| 1010 | * @see #removeFromEnvironment(String) |
| 1011 | */ |
| 1012 | String SECURITY_PROTOCOL = "java.naming.security.protocol"; |
| 1013 | |
| 1014 | /** |
| 1015 | * Constant that holds the name of the environment property for |
| 1016 | * specifying the security level to use. |
| 1017 | * Its value is one of the following strings: |
| 1018 | * "none", "simple", "strong". |
| 1019 | * If this property is unspecified, |
| 1020 | * the behaviour is determined by the service provider. |
| 1021 | * |
| 1022 | * <p> The value of this constant is "java.naming.security.authentication". |
| 1023 | * |
| 1024 | * @see #addToEnvironment(String, Object) |
| 1025 | * @see #removeFromEnvironment(String) |
| 1026 | */ |
| 1027 | String SECURITY_AUTHENTICATION = "java.naming.security.authentication"; |
| 1028 | |
| 1029 | /** |
| 1030 | * Constant that holds the name of the environment property for |
| 1031 | * specifying the identity of the principal for authenticating |
| 1032 | * the caller to the service. The format of the principal |
| 1033 | * depends on the authentication scheme. |
| 1034 | * If this property is unspecified, |
| 1035 | * the behaviour is determined by the service provider. |
| 1036 | * |
| 1037 | * <p> The value of this constant is "java.naming.security.principal". |
| 1038 | * |
| 1039 | * @see #addToEnvironment(String, Object) |
| 1040 | * @see #removeFromEnvironment(String) |
| 1041 | */ |
| 1042 | String SECURITY_PRINCIPAL = "java.naming.security.principal"; |
| 1043 | |
| 1044 | /** |
| 1045 | * Constant that holds the name of the environment property for |
| 1046 | * specifying the credentials of the principal for authenticating |
| 1047 | * the caller to the service. The value of the property depends |
| 1048 | * on the authentication scheme. For example, it could be a hashed |
| 1049 | * password, clear-text password, key, certificate, and so on. |
| 1050 | * If this property is unspecified, |
| 1051 | * the behaviour is determined by the service provider. |
| 1052 | * |
| 1053 | * <p> The value of this constant is "java.naming.security.credentials". |
| 1054 | * |
| 1055 | * @see #addToEnvironment(String, Object) |
| 1056 | * @see #removeFromEnvironment(String) |
| 1057 | */ |
| 1058 | |
| 1059 | String SECURITY_CREDENTIALS = "java.naming.security.credentials"; |
| 1060 | /** |
| 1061 | * Constant that holds the name of the environment property for |
| 1062 | * specifying the preferred language to use with the service. |
| 1063 | * The value of the property is a colon-separated list of language |
| 1064 | * tags as defined in RFC 1766. |
| 1065 | * If this property is unspecified, |
| 1066 | * the language preference is determined by the service provider. |
| 1067 | * |
| 1068 | * <p> The value of this constant is "java.naming.language". |
| 1069 | * |
| 1070 | * @see #addToEnvironment(String, Object) |
| 1071 | * @see #removeFromEnvironment(String) |
| 1072 | */ |
| 1073 | String LANGUAGE = "java.naming.language"; |
| 1074 | |
| 1075 | /** |
| 1076 | * Constant that holds the name of the environment property for |
| 1077 | * specifying an applet for the initial context constructor to use |
| 1078 | * when searching for other properties. |
| 1079 | * The value of this property is the |
| 1080 | * <tt>java.applet.Applet</tt> instance that is being executed. |
| 1081 | * This property may be specified in the environment parameter |
| 1082 | * passed to the initial context constructor. |
| 1083 | * When this property is set, each property that the initial context |
| 1084 | * constructor looks for in the system properties is first looked for |
| 1085 | * in the applet's parameter list. |
| 1086 | * If this property is unspecified, the initial context constructor |
| 1087 | * will search for properties only in the environment parameter |
| 1088 | * passed to it, the system properties, and application resource files. |
| 1089 | * |
| 1090 | * <p> The value of this constant is "java.naming.applet". |
| 1091 | * |
| 1092 | * @see #addToEnvironment(String, Object) |
| 1093 | * @see #removeFromEnvironment(String) |
| 1094 | * @see InitialContext |
| 1095 | * |
| 1096 | * @since 1.3 |
| 1097 | */ |
| 1098 | String APPLET = "java.naming.applet"; |
| 1099 | }; |