| Modifier and Type | Field and Description |
|---|---|
| private static int | |
| protected static final byte | |
| protected static final byte | |
| protected static final byte |
| Access | Constructor and Description |
|---|---|
| protected |
| debug | back to summary |
|---|---|
| private static int debug | |
| TERMINAL_COMPONENT | back to summary |
|---|---|
| protected static final byte TERMINAL_COMPONENT | |
| TERMINAL_NNS_COMPONENT | back to summary |
|---|---|
| protected static final byte TERMINAL_NNS_COMPONENT | |
| USE_CONTINUATION | back to summary |
|---|---|
| protected static final byte USE_CONTINUATION | |
| ComponentContext | back to summary |
|---|---|
| protected ComponentContext() | |
| c_bind | back to summary |
|---|---|
| protected abstract void c_bind(Name name, Object obj, Continuation cont) throws NamingException | |
| c_bind_nns | back to summary |
|---|---|
| protected void c_bind_nns(Name name, Object obj, Continuation cont) throws NamingException | |
| c_createSubcontext | back to summary |
|---|---|
| protected abstract Context c_createSubcontext(Name name, Continuation cont) throws NamingException | |
| c_createSubcontext_nns | back to summary |
|---|---|
| protected Context c_createSubcontext_nns(Name name, Continuation cont) throws NamingException | |
| c_destroySubcontext | back to summary |
|---|---|
| protected abstract void c_destroySubcontext(Name name, Continuation cont) throws NamingException | |
| c_destroySubcontext_nns | back to summary |
|---|---|
| protected void c_destroySubcontext_nns(Name name, Continuation cont) throws NamingException | |
| c_getNameParser | back to summary |
|---|---|
| protected abstract NameParser c_getNameParser(Name name, Continuation cont) throws NamingException | |
| c_getNameParser_nns | back to summary |
|---|---|
| protected NameParser c_getNameParser_nns(Name name, Continuation cont) throws NamingException | |
| c_list | back to summary |
|---|---|
| protected abstract NamingEnumeration | |
| c_list_nns | back to summary |
|---|---|
| protected NamingEnumeration | |
| c_listBindings | back to summary |
|---|---|
| protected abstract NamingEnumeration | |
| c_listBindings_nns | back to summary |
|---|---|
| protected NamingEnumeration | |
| c_lookup | back to summary |
|---|---|
| protected abstract Object c_lookup(Name name, Continuation cont) throws NamingException | |
| c_lookup_nns | back to summary |
|---|---|
| protected Object c_lookup_nns(Name name, Continuation cont) throws NamingException | |
| c_lookupLink | back to summary |
|---|---|
| protected abstract Object c_lookupLink(Name name, Continuation cont) throws NamingException | |
| c_lookupLink_nns | back to summary |
|---|---|
| protected Object c_lookupLink_nns(Name name, Continuation cont) throws NamingException | |
| c_processJunction_nns | back to summary |
|---|---|
| protected void c_processJunction_nns(Name name, Continuation cont) throws NamingException Locates the nns using the default policy. This policy fully handles junctions, but otherwise throws an exception when an attempt is made to resolve an implicit nns. The default policy is as follows: If there is a junction in the namespace, then resolve to the junction and continue the operation there (thus deferring to that context to find its own nns). Otherwise, resolve as far as possible and then throw CannotProceedException with the resolved object being a reference: the address type is "nns", and the address contents is this context. For example, when c_bind_nns(name, obj, ...) is invoked, the caller is attempting to bind the object "obj" to the nns of "name". If "name" is a junction, it names an object in another naming system that (presumably) has an nns. c_bind_nns() will first resolve "name" to a context and then attempt to continue the bind operation there, (thus binding to the nns of the context named by "name"). If "name" is empty then throw an exception, since this context does not by default support an implicit nns. To implement a context that does support an implicit nns, it is necessary to override this default policy. This is done by overriding the c_*_nns() methods (which each call this method by default). | |
| c_rebind | back to summary |
|---|---|
| protected abstract void c_rebind(Name name, Object obj, Continuation cont) throws NamingException | |
| c_rebind_nns | back to summary |
|---|---|
| protected void c_rebind_nns(Name name, Object obj, Continuation cont) throws NamingException | |
| c_rename | back to summary |
|---|---|
| protected abstract void c_rename(Name oldname, Name newname, Continuation cont) throws NamingException | |
| c_rename_nns | back to summary |
|---|---|
| protected void c_rename_nns(Name oldname, Name newname, Continuation cont) throws NamingException | |
| c_resolveIntermediate_nns | back to summary |
|---|---|
| protected Object c_resolveIntermediate_nns(Name name, Continuation cont) throws NamingException Resolves the nns for 'name' when the named context is acting as an intermediate context. For a system that supports only junctions, this would be equivalent to c_lookup(name, cont); because for junctions, an intermediate slash simply signifies a syntactic separator. For a system that supports only implicit nns, this would be equivalent to c_lookup_nns(name, cont); because for implicit nns, a slash always signifies the implicit nns, regardless of whether it is intermediate or trailing. By default this method supports junctions, and also allows for an implicit nns to be dynamically determined through the use of the "nns" reference (see c_processJunction_nns()). Contexts that implement implicit nns directly should provide an appropriate override. A junction, by definition, is a binding of a name in one namespace to an object in another. The default implementation of this method detects the crossover into another namespace using the following heuristic: there is a junction when "name" resolves to a context that is not an instance of this.getClass(). Contexts supporting junctions for which this heuristic is inappropriate should override this method. | |
| c_unbind | back to summary |
|---|---|
| protected abstract void c_unbind(Name name, Continuation cont) throws NamingException | |
| c_unbind_nns | back to summary |
|---|---|
| protected void c_unbind_nns(Name name, Continuation cont) throws NamingException | |
| checkAndAdjustRemainingName | back to summary |
|---|---|
| pack-priv void checkAndAdjustRemainingName(Name rname) throws InvalidNameException | |
| isAllEmpty | back to summary |
|---|---|
| protected boolean isAllEmpty(Name n) | |
| p_bind | back to summary |
|---|---|
| protected void p_bind(Name name, Object obj, Continuation cont) throws NamingException Implements abstract com. | |
| p_createSubcontext | back to summary |
|---|---|
| protected Context p_createSubcontext(Name name, Continuation cont) throws NamingException Implements abstract com. | |
| p_destroySubcontext | back to summary |
|---|---|
| protected void p_destroySubcontext(Name name, Continuation cont) throws NamingException Implements abstract com. | |
| p_getNameParser | back to summary |
|---|---|
| protected NameParser p_getNameParser(Name name, Continuation cont) throws NamingException Implements abstract com. | |
| p_list | back to summary |
|---|---|
| protected NamingEnumeration Implements abstract com. | |
| p_listBindings | back to summary |
|---|---|
| protected NamingEnumeration Implements abstract com. | |
| p_lookup | back to summary |
|---|---|
| protected Object p_lookup(Name name, Continuation cont) throws NamingException Implements abstract com. | |
| p_lookupLink | back to summary |
|---|---|
| protected Object p_lookupLink(Name name, Continuation cont) throws NamingException Implements abstract com. | |
| p_parseComponent | back to summary |
|---|---|
| protected HeadTail p_parseComponent(Name name, Continuation cont) throws NamingException Determines which of the first components of 'name' belong to this naming system. If no components belong to this naming system, return the empty name (new CompositeName()) as the head, and the entire name as the tail. The default implementation supports strong separation. If the name is empty or if the first component is empty, head is the empty name and tail is the entire name. (This means that this context does not have any name to work with). Otherwise, it returns the first component as head, and the rest of the components as tail. Subclass should override this method according its own policies. For example, a weakly separated system with dynamic boundary determination would simply return as head 'name'. A weakly separated with static boundary determination would select the components in the front of 'name' that conform to some syntax rules. (e.g. in X.500 syntax, perhaps select front components that have a equal sign). If none conforms, return an empty name. | |
| p_rebind | back to summary |
|---|---|
| protected void p_rebind(Name name, Object obj, Continuation cont) throws NamingException Implements abstract com. | |
| p_rename | back to summary |
|---|---|
| protected void p_rename(Name oldName, Name newName, Continuation cont) throws NamingException Implements abstract com. | |
| p_resolveIntermediate | back to summary |
|---|---|
| protected HeadTail p_resolveIntermediate(Name name, Continuation cont) throws NamingException Determine whether 'name' is a terminal component in this naming system. If so, return status indicating so, so that caller can perform context operation on this name. If not, then the first component(s) of 'name' names an intermediate context. In that case, resolve these components and set Continuation to be the object named. see test cases at bottom of file. | |
| p_resolveToClass | back to summary |
|---|---|
| protected ResolveResult p_resolveToClass(Name name, Class<?> contextType, Continuation cont) throws NamingException Implements abstract com. | |
| p_unbind | back to summary |
|---|---|
| protected void p_unbind(Name name, Continuation cont) throws NamingException Implements abstract com. | |