806 lines
28 KiB
Java
806 lines
28 KiB
Java
/*
|
|
* Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package com.sun.jndi.toolkit.ctx;
|
|
|
|
import javax.naming.*;
|
|
import javax.naming.spi.ResolveResult;
|
|
|
|
/**
|
|
* Provides implementation of p_* operations using
|
|
* c_* operations provided by subclasses.
|
|
*
|
|
* Clients: deal only with names for its own naming service. Must
|
|
* provide implementations for c_* methods, and for p_parseComponent()
|
|
* and the c_*_nns methods if the defaults are not appropriate.
|
|
*
|
|
* @author Rosanna Lee
|
|
* @author Scott Seligman
|
|
*/
|
|
|
|
public abstract class ComponentContext extends PartialCompositeContext {
|
|
private static int debug = 0;
|
|
|
|
protected ComponentContext() {
|
|
_contextType = _COMPONENT;
|
|
}
|
|
|
|
// ------ Abstract methods whose implementation are provided by subclass
|
|
|
|
/* Equivalent methods in Context interface */
|
|
protected abstract Object c_lookup(Name name, Continuation cont)
|
|
throws NamingException;
|
|
protected abstract Object c_lookupLink(Name name, Continuation cont)
|
|
throws NamingException;
|
|
|
|
protected abstract NamingEnumeration<NameClassPair> c_list(Name name,
|
|
Continuation cont) throws NamingException;
|
|
protected abstract NamingEnumeration<Binding> c_listBindings(Name name,
|
|
Continuation cont) throws NamingException;
|
|
protected abstract void c_bind(Name name, Object obj, Continuation cont)
|
|
throws NamingException;
|
|
protected abstract void c_rebind(Name name, Object obj, Continuation cont)
|
|
throws NamingException;
|
|
protected abstract void c_unbind(Name name, Continuation cont)
|
|
throws NamingException;
|
|
protected abstract void c_destroySubcontext(Name name, Continuation cont)
|
|
throws NamingException;
|
|
protected abstract Context c_createSubcontext(Name name,
|
|
Continuation cont) throws NamingException;
|
|
protected abstract void c_rename(Name oldname, Name newname,
|
|
Continuation cont) throws NamingException;
|
|
protected abstract NameParser c_getNameParser(Name name, Continuation cont)
|
|
throws NamingException;
|
|
|
|
// ------ Methods that may need to be overridden by subclass
|
|
|
|
/* Parsing method */
|
|
/**
|
|
* 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.
|
|
*/
|
|
protected HeadTail p_parseComponent(Name name, Continuation cont)
|
|
throws NamingException {
|
|
int separator;
|
|
// if no name to parse, or if we're already at boundary
|
|
if (name.isEmpty() || name.get(0).equals("")) {
|
|
separator = 0;
|
|
} else {
|
|
separator = 1;
|
|
}
|
|
Name head, tail;
|
|
|
|
if (name instanceof CompositeName) {
|
|
head = name.getPrefix(separator);
|
|
tail = name.getSuffix(separator);
|
|
} else {
|
|
// treat like compound name
|
|
head = new CompositeName().add(name.toString());
|
|
tail = null;
|
|
}
|
|
|
|
if (debug > 2) {
|
|
System.err.println("ORIG: " + name);
|
|
System.err.println("PREFIX: " + name);
|
|
System.err.println("SUFFIX: " + null);
|
|
}
|
|
return new HeadTail(head, tail);
|
|
}
|
|
|
|
|
|
/* Resolution method for supporting federation */
|
|
|
|
/**
|
|
* 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
|
|
* equilvalent 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.
|
|
*/
|
|
protected Object c_resolveIntermediate_nns(Name name, Continuation cont)
|
|
throws NamingException {
|
|
try {
|
|
final Object obj = c_lookup(name, cont);
|
|
|
|
// Do not append "" to Continuation 'cont' even if set
|
|
// because the intention is to ignore the nns
|
|
|
|
if (obj != null && getClass().isInstance(obj)) {
|
|
// If "obj" is in the same type as this object, it must
|
|
// not be a junction. Continue the lookup with "/".
|
|
|
|
cont.setContinueNNS(obj, name, this);
|
|
return null;
|
|
|
|
} else if (obj != null && !(obj instanceof Context)) {
|
|
// obj is not even a context, so try to find its nns
|
|
// dynamically by constructing a Reference containing obj.
|
|
RefAddr addr = new RefAddr("nns") {
|
|
public Object getContent() {
|
|
return obj;
|
|
}
|
|
private static final long serialVersionUID =
|
|
-8831204798861786362L;
|
|
};
|
|
Reference ref = new Reference("java.lang.Object", addr);
|
|
|
|
// Resolved name has trailing slash to indicate nns
|
|
CompositeName resName = (CompositeName)name.clone();
|
|
resName.add(""); // add trailing slash
|
|
|
|
// Set continuation leave it to
|
|
// PartialCompositeContext.getPCContext() to throw CPE.
|
|
// Do not use setContinueNNS() because we've already
|
|
// consumed "/" (i.e., moved it to resName).
|
|
|
|
cont.setContinue(ref, resName, this);
|
|
return null;
|
|
} else {
|
|
// Consume "/" and continue
|
|
return obj;
|
|
}
|
|
|
|
} catch (NamingException e) {
|
|
e.appendRemainingComponent(""); // add nns back
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/* Equivalent of Context Methods for supporting nns */
|
|
|
|
// The following methods are called when the Context methods
|
|
// are invoked with a name that has a trailing slash.
|
|
// For naming systems that support implicit nns,
|
|
// the trailing slash signifies the implicit nns.
|
|
// For such naming systems, override these c_*_nns methods.
|
|
//
|
|
// For naming systems that do not support implicit nns, the
|
|
// default implementations here throw an exception. See
|
|
// c_processJunction_nns() for details.
|
|
|
|
protected Object c_lookup_nns(Name name, Continuation cont)
|
|
throws NamingException {
|
|
c_processJunction_nns(name, cont);
|
|
return null;
|
|
}
|
|
|
|
protected Object c_lookupLink_nns(Name name, Continuation cont)
|
|
throws NamingException {
|
|
c_processJunction_nns(name, cont);
|
|
return null;
|
|
}
|
|
|
|
protected NamingEnumeration<NameClassPair> c_list_nns(Name name,
|
|
Continuation cont) throws NamingException {
|
|
c_processJunction_nns(name, cont);
|
|
return null;
|
|
}
|
|
|
|
protected NamingEnumeration<Binding> c_listBindings_nns(Name name,
|
|
Continuation cont) throws NamingException {
|
|
c_processJunction_nns(name, cont);
|
|
return null;
|
|
}
|
|
|
|
protected void c_bind_nns(Name name, Object obj, Continuation cont)
|
|
throws NamingException {
|
|
c_processJunction_nns(name, cont);
|
|
}
|
|
|
|
protected void c_rebind_nns(Name name, Object obj, Continuation cont)
|
|
throws NamingException {
|
|
c_processJunction_nns(name, cont);
|
|
}
|
|
|
|
protected void c_unbind_nns(Name name, Continuation cont)
|
|
throws NamingException {
|
|
c_processJunction_nns(name, cont);
|
|
}
|
|
|
|
protected Context c_createSubcontext_nns(Name name,
|
|
Continuation cont) throws NamingException {
|
|
c_processJunction_nns(name, cont);
|
|
return null;
|
|
}
|
|
|
|
protected void c_destroySubcontext_nns(Name name, Continuation cont)
|
|
throws NamingException {
|
|
c_processJunction_nns(name, cont);
|
|
}
|
|
|
|
|
|
protected void c_rename_nns(Name oldname, Name newname, Continuation cont)
|
|
throws NamingException {
|
|
c_processJunction_nns(oldname, cont);
|
|
}
|
|
|
|
protected NameParser c_getNameParser_nns(Name name, Continuation cont)
|
|
throws NamingException {
|
|
c_processJunction_nns(name, cont);
|
|
return null;
|
|
}
|
|
|
|
// ------ internal method used by ComponentContext
|
|
|
|
/**
|
|
* 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).
|
|
*/
|
|
protected void c_processJunction_nns(Name name, Continuation cont)
|
|
throws NamingException
|
|
{
|
|
if (name.isEmpty()) {
|
|
// Construct a new Reference that contains this context.
|
|
RefAddr addr = new RefAddr("nns") {
|
|
public Object getContent() {
|
|
return ComponentContext.this;
|
|
}
|
|
private static final long serialVersionUID =
|
|
-1389472957988053402L;
|
|
};
|
|
Reference ref = new Reference("java.lang.Object", addr);
|
|
|
|
// Set continuation leave it to PartialCompositeContext.getPCContext()
|
|
// to throw the exception.
|
|
// Do not use setContinueNNS() because we've are
|
|
// setting relativeResolvedName to "/".
|
|
cont.setContinue(ref, _NNS_NAME, this);
|
|
return;
|
|
}
|
|
|
|
try {
|
|
// lookup name to continue operation in nns
|
|
Object target = c_lookup(name, cont);
|
|
if (cont.isContinue())
|
|
cont.appendRemainingComponent("");
|
|
else {
|
|
cont.setContinueNNS(target, name, this);
|
|
}
|
|
} catch (NamingException e) {
|
|
e.appendRemainingComponent(""); // add nns back
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
protected static final byte USE_CONTINUATION = 1;
|
|
protected static final byte TERMINAL_COMPONENT = 2;
|
|
protected static final byte TERMINAL_NNS_COMPONENT = 3;
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
|
|
protected HeadTail p_resolveIntermediate(Name name, Continuation cont)
|
|
throws NamingException {
|
|
int ret = USE_CONTINUATION;
|
|
cont.setSuccess(); // initialize
|
|
HeadTail p = p_parseComponent(name, cont);
|
|
Name tail = p.getTail();
|
|
Name head = p.getHead();
|
|
|
|
if (tail == null || tail.isEmpty()) {
|
|
//System.out.println("terminal : " + head);
|
|
ret = TERMINAL_COMPONENT;
|
|
} else if (!tail.get(0).equals("")) {
|
|
// tail does not begin with "/"
|
|
/*
|
|
if (head.isEmpty()) {
|
|
// Context could not find name that it can use
|
|
// illegal syntax error or name not found
|
|
//System.out.println("nnf exception : " + head);
|
|
NamingException e = new NameNotFoundException();
|
|
cont.setError(this, name);
|
|
throw cont.fillInException(e);
|
|
} else {
|
|
*/
|
|
// head is being used as intermediate context,
|
|
// resolve head and set Continuation with tail
|
|
try {
|
|
Object obj = c_resolveIntermediate_nns(head, cont);
|
|
//System.out.println("resInter : " + head + "=" + obj);
|
|
if (obj != null)
|
|
cont.setContinue(obj, head, this, tail);
|
|
else if (cont.isContinue()) {
|
|
checkAndAdjustRemainingName(cont.getRemainingName());
|
|
cont.appendRemainingName(tail);
|
|
}
|
|
} catch (NamingException e) {
|
|
checkAndAdjustRemainingName(e.getRemainingName());
|
|
e.appendRemainingName(tail);
|
|
throw e;
|
|
}
|
|
/*
|
|
}
|
|
*/
|
|
} else {
|
|
// tail begins with "/"
|
|
if (tail.size() == 1) {
|
|
ret = TERMINAL_NNS_COMPONENT;
|
|
//System.out.println("terminal_nns : " + head);
|
|
} else if (head.isEmpty() || isAllEmpty(tail)) {
|
|
// resolve nns of head and continue with tail.getSuffix(1)
|
|
Name newTail = tail.getSuffix(1);
|
|
try {
|
|
Object obj = c_lookup_nns(head, cont);
|
|
//System.out.println("lookup_nns : " + head + "=" + obj);
|
|
if (obj != null)
|
|
cont.setContinue(obj, head, this, newTail);
|
|
else if (cont.isContinue()) {
|
|
cont.appendRemainingName(newTail);
|
|
// Name rname = cont.getRemainingName();
|
|
//System.out.println("cont.rname" + rname);
|
|
}
|
|
} catch (NamingException e) {
|
|
e.appendRemainingName(newTail);
|
|
throw e;
|
|
}
|
|
} else {
|
|
// head is being used as intermediate context
|
|
// resolve and set continuation to tail
|
|
try {
|
|
Object obj = c_resolveIntermediate_nns(head, cont);
|
|
//System.out.println("resInter2 : " + head + "=" + obj);
|
|
if (obj != null)
|
|
cont.setContinue(obj, head, this, tail);
|
|
else if (cont.isContinue()) {
|
|
checkAndAdjustRemainingName(cont.getRemainingName());
|
|
cont.appendRemainingName(tail);
|
|
}
|
|
} catch (NamingException e) {
|
|
checkAndAdjustRemainingName(e.getRemainingName());
|
|
e.appendRemainingName(tail);
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
|
|
p.setStatus(ret);
|
|
return p;
|
|
}
|
|
|
|
// When c_resolveIntermediate_nns() or c_lookup_nns() sets up
|
|
// its continuation, to indicate "nns", it appends an empty
|
|
// component to the remaining name (e.g. "eng/"). If last
|
|
// component of remaining name is empty; delete empty component
|
|
// before appending tail so that composition of the names work
|
|
// correctly. For example, when merging "eng/" and "c.b.a", we want
|
|
// the result to be "eng/c.b.a" because the trailing slash in eng
|
|
// is extraneous. When merging "" and "c.b.a", we want the result
|
|
// to be "/c.b.a" and so must keep the trailing slash (empty name).
|
|
void checkAndAdjustRemainingName(Name rname) throws InvalidNameException {
|
|
int count;
|
|
if (rname != null && (count=rname.size()) > 1 &&
|
|
rname.get(count-1).equals("")) {
|
|
rname.remove(count-1);
|
|
}
|
|
}
|
|
|
|
// Returns true if n contains only empty components
|
|
protected boolean isAllEmpty(Name n) {
|
|
int count = n.size();
|
|
for (int i =0; i < count; i++ ) {
|
|
if (!n.get(i).equals("")) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
// ------ implementations of p_ Resolver and Context methods using
|
|
// ------ corresponding c_ and c_*_nns methods
|
|
|
|
|
|
/* implementation for Resolver method */
|
|
|
|
protected ResolveResult p_resolveToClass(Name name,
|
|
Class<?> contextType,
|
|
Continuation cont)
|
|
throws NamingException {
|
|
|
|
if (contextType.isInstance(this)) {
|
|
cont.setSuccess();
|
|
return (new ResolveResult(this, name));
|
|
}
|
|
|
|
ResolveResult ret = null;
|
|
HeadTail res = p_resolveIntermediate(name, cont);
|
|
switch (res.getStatus()) {
|
|
case TERMINAL_NNS_COMPONENT:
|
|
Object obj = p_lookup(name, cont);
|
|
if (!cont.isContinue() && contextType.isInstance(obj)) {
|
|
ret = new ResolveResult(obj, _EMPTY_NAME);
|
|
}
|
|
break;
|
|
|
|
case TERMINAL_COMPONENT:
|
|
cont.setSuccess(); // no contextType found; return null
|
|
break;
|
|
|
|
default:
|
|
/* USE_CONTINUATION */
|
|
/* pcont already set or exception thrown */
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* implementations of p_ Context methods */
|
|
|
|
protected Object p_lookup(Name name, Continuation cont) throws NamingException {
|
|
Object ret = null;
|
|
HeadTail res = p_resolveIntermediate(name, cont);
|
|
switch (res.getStatus()) {
|
|
case TERMINAL_NNS_COMPONENT:
|
|
ret = c_lookup_nns(res.getHead(), cont);
|
|
if (ret instanceof LinkRef) {
|
|
cont.setContinue(ret, res.getHead(), this);
|
|
ret = null;
|
|
}
|
|
break;
|
|
|
|
case TERMINAL_COMPONENT:
|
|
ret = c_lookup(res.getHead(), cont);
|
|
if (ret instanceof LinkRef) {
|
|
cont.setContinue(ret, res.getHead(), this);
|
|
ret = null;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
/* USE_CONTINUATION */
|
|
/* pcont already set or exception thrown */
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
protected NamingEnumeration<NameClassPair> p_list(Name name, Continuation cont)
|
|
throws NamingException {
|
|
NamingEnumeration<NameClassPair> ret = null;
|
|
HeadTail res = p_resolveIntermediate(name, cont);
|
|
switch (res.getStatus()) {
|
|
case TERMINAL_NNS_COMPONENT:
|
|
if (debug > 0)
|
|
System.out.println("c_list_nns(" + res.getHead() + ")");
|
|
ret = c_list_nns(res.getHead(), cont);
|
|
break;
|
|
|
|
case TERMINAL_COMPONENT:
|
|
if (debug > 0)
|
|
System.out.println("c_list(" + res.getHead() + ")");
|
|
ret = c_list(res.getHead(), cont);
|
|
break;
|
|
|
|
default:
|
|
/* USE_CONTINUATION */
|
|
/* cont already set or exception thrown */
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
protected NamingEnumeration<Binding> p_listBindings(Name name, Continuation cont) throws
|
|
NamingException {
|
|
NamingEnumeration<Binding> ret = null;
|
|
HeadTail res = p_resolveIntermediate(name, cont);
|
|
switch (res.getStatus()) {
|
|
case TERMINAL_NNS_COMPONENT:
|
|
ret = c_listBindings_nns(res.getHead(), cont);
|
|
break;
|
|
|
|
case TERMINAL_COMPONENT:
|
|
ret = c_listBindings(res.getHead(), cont);
|
|
break;
|
|
|
|
default:
|
|
/* USE_CONTINUATION */
|
|
/* cont already set or exception thrown */
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
protected void p_bind(Name name, Object obj, Continuation cont) throws
|
|
NamingException {
|
|
HeadTail res = p_resolveIntermediate(name, cont);
|
|
switch (res.getStatus()) {
|
|
case TERMINAL_NNS_COMPONENT:
|
|
c_bind_nns(res.getHead(), obj, cont);
|
|
break;
|
|
|
|
case TERMINAL_COMPONENT:
|
|
c_bind(res.getHead(), obj, cont);
|
|
break;
|
|
|
|
default:
|
|
/* USE_CONTINUATION */
|
|
/* cont already set or exception thrown */
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected void p_rebind(Name name, Object obj, Continuation cont) throws
|
|
NamingException {
|
|
HeadTail res = p_resolveIntermediate(name, cont);
|
|
switch (res.getStatus()) {
|
|
case TERMINAL_NNS_COMPONENT:
|
|
c_rebind_nns(res.getHead(), obj, cont);
|
|
break;
|
|
|
|
case TERMINAL_COMPONENT:
|
|
c_rebind(res.getHead(), obj, cont);
|
|
break;
|
|
|
|
default:
|
|
/* USE_CONTINUATION */
|
|
/* cont already set or exception thrown */
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected void p_unbind(Name name, Continuation cont) throws
|
|
NamingException {
|
|
HeadTail res = p_resolveIntermediate(name, cont);
|
|
switch (res.getStatus()) {
|
|
case TERMINAL_NNS_COMPONENT:
|
|
c_unbind_nns(res.getHead(), cont);
|
|
break;
|
|
|
|
case TERMINAL_COMPONENT:
|
|
c_unbind(res.getHead(), cont);
|
|
break;
|
|
|
|
default:
|
|
/* USE_CONTINUATION */
|
|
/* cont already set or exception thrown */
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected void p_destroySubcontext(Name name, Continuation cont) throws
|
|
NamingException {
|
|
HeadTail res = p_resolveIntermediate(name, cont);
|
|
switch (res.getStatus()) {
|
|
case TERMINAL_NNS_COMPONENT:
|
|
c_destroySubcontext_nns(res.getHead(), cont);
|
|
break;
|
|
|
|
case TERMINAL_COMPONENT:
|
|
c_destroySubcontext(res.getHead(), cont);
|
|
break;
|
|
|
|
default:
|
|
/* USE_CONTINUATION */
|
|
/* cont already set or exception thrown */
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected Context p_createSubcontext(Name name, Continuation cont) throws
|
|
NamingException {
|
|
Context ret = null;
|
|
HeadTail res = p_resolveIntermediate(name, cont);
|
|
switch (res.getStatus()) {
|
|
case TERMINAL_NNS_COMPONENT:
|
|
ret = c_createSubcontext_nns(res.getHead(), cont);
|
|
break;
|
|
|
|
case TERMINAL_COMPONENT:
|
|
ret = c_createSubcontext(res.getHead(), cont);
|
|
break;
|
|
|
|
default:
|
|
/* USE_CONTINUATION */
|
|
/* cont already set or exception thrown */
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
protected void p_rename(Name oldName, Name newName, Continuation cont) throws
|
|
NamingException {
|
|
HeadTail res = p_resolveIntermediate(oldName, cont);
|
|
switch (res.getStatus()) {
|
|
case TERMINAL_NNS_COMPONENT:
|
|
c_rename_nns(res.getHead(), newName, cont);
|
|
break;
|
|
|
|
case TERMINAL_COMPONENT:
|
|
c_rename(res.getHead(), newName, cont);
|
|
break;
|
|
|
|
default:
|
|
/* USE_CONTINUATION */
|
|
/* cont already set or exception thrown */
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected NameParser p_getNameParser(Name name, Continuation cont) throws
|
|
NamingException {
|
|
NameParser ret = null;
|
|
HeadTail res = p_resolveIntermediate(name, cont);
|
|
switch (res.getStatus()) {
|
|
case TERMINAL_NNS_COMPONENT:
|
|
ret = c_getNameParser_nns(res.getHead(), cont);
|
|
break;
|
|
|
|
case TERMINAL_COMPONENT:
|
|
ret = c_getNameParser(res.getHead(), cont);
|
|
break;
|
|
|
|
default:
|
|
/* USE_CONTINUATION */
|
|
/* cont already set or exception thrown */
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
protected Object p_lookupLink(Name name, Continuation cont)
|
|
throws NamingException {
|
|
Object ret = null;
|
|
HeadTail res = p_resolveIntermediate(name, cont);
|
|
switch (res.getStatus()) {
|
|
case TERMINAL_NNS_COMPONENT:
|
|
ret = c_lookupLink_nns(res.getHead(), cont);
|
|
break;
|
|
|
|
case TERMINAL_COMPONENT:
|
|
ret = c_lookupLink(res.getHead(), cont);
|
|
break;
|
|
|
|
default:
|
|
/* USE_CONTINUATION */
|
|
/* cont already set or exception thrown */
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* How p_resolveIntermediate() should behave for various test cases
|
|
|
|
a.b/x {a.b, x}
|
|
c_resolveIntermediate_nns(a.b)
|
|
continue(x)
|
|
{x,}
|
|
terminal(x)
|
|
|
|
a.b/ {a.b, ""}
|
|
terminal_nns(a.b);
|
|
|
|
a.b//
|
|
{a.b, ("", "")}
|
|
c_lookup_nns(a.b)
|
|
continue({""})
|
|
{,""}
|
|
terminal_nns({})
|
|
|
|
/x {{}, {"", x}}
|
|
c_lookup_nns({})
|
|
continue(x)
|
|
{x,}
|
|
terminal(x)
|
|
|
|
//y {{}, {"", "", y}}
|
|
c_lookup_nns({})
|
|
continue({"", y})
|
|
{{}, {"", y}}
|
|
c_lookup_nns({})
|
|
continue(y)
|
|
{y,}
|
|
terminal(y)
|
|
|
|
a.b//y {a.b, {"", y}}
|
|
c_resolveIntermediate_nns(a.b)
|
|
continue({"", y})
|
|
{{}, {"",y}}
|
|
c_lookup_nns({});
|
|
continue(y)
|
|
{y,}
|
|
terminal(y);
|
|
*
|
|
*/
|