/** * Resolve to context named by 'name'. Returns true if at named context (i.e. 'name' is empty * name). Returns false otherwise, and sets Continuation on parts of 'name' not yet resolved. */ protected boolean resolve_to_context(Name name, Continuation cont) throws NamingException { String target = name.toString(); StringHeadTail ht = c_parseComponent(target, cont); String tail = ht.getTail(); String head = ht.getHead(); if (debug > 0) System.out.println("RESOLVE TO CONTEXT(" + target + ") = {" + head + ", " + tail + "}"); if (head == null) { // something is wrong; no name at all InvalidNameException e = new InvalidNameException(); throw cont.fillInException(e); } if (!isEmpty(head)) { // if there is head is a non-empty name // this means more resolution to be done try { Object headCtx = a_lookup(head, cont); // System.out.println("answer " + headCtx); if (headCtx != null) cont.setContinue(headCtx, head, this, (tail == null ? "" : tail)); else if (cont.isContinue()) cont.appendRemainingComponent(tail); } catch (NamingException e) { e.appendRemainingComponent(tail); throw e; } } else { cont.setSuccess(); // clear return true; } return false; }
/** * Resolves to penultimate context named by 'name'. Returns true if penultimate context has been * reached (i.e. name only has one atomic component left). Returns false otherwise, and sets * Continuation to parts of name not yet resolved. */ protected boolean resolve_to_penultimate_context(Name name, Continuation cont) throws NamingException { String target = name.toString(); if (debug > 0) System.out.println("RESOLVE TO PENULTIMATE" + target); StringHeadTail ht = c_parseComponent(target, cont); String tail = ht.getTail(); String head = ht.getHead(); if (head == null) { // something is wrong; no name at all InvalidNameException e = new InvalidNameException(); throw cont.fillInException(e); } if (!isEmpty(tail)) { // more components; hence not at penultimate context yet try { Object headCtx = a_lookup(head, cont); if (headCtx != null) cont.setContinue(headCtx, head, this, tail); else if (cont.isContinue()) cont.appendRemainingComponent(tail); } catch (NamingException e) { e.appendRemainingComponent(tail); throw e; } } else { // already at penultimate context cont.setSuccess(); // clear return true; } return false; }
/** * This function is used when implementing a naming system that supports junctions. For example, * when the a_bind_nns(name, newobj) method is invoked, that means the caller is attempting to * bind the object 'newobj' to the nns of 'name'. For context that supports junctions, 'name' * names a junction and is pointing to the root of another naming system, which in turn might have * an nns. This means that a_bind_nns() should first resolve 'name' and attempt to continue the * operation in the context named by 'name'. (i.e. bind to the nns of the context named by * 'name'). If name is already empty, then throw NameNotFoundException because this context by * default does not have any nns. */ protected void a_processJunction_nns(String name, Continuation cont) throws NamingException { if (name.equals("")) { NameNotFoundException e = new NameNotFoundException(); cont.setErrorNNS(this, name); throw cont.fillInException(e); } try { // lookup name to continue operation in nns Object target = a_lookup(name, cont); if (cont.isContinue()) cont.appendRemainingComponent(""); // add nns back else { cont.setContinueNNS(target, name, this); } } catch (NamingException e) { e.appendRemainingComponent(""); // add nns back throw e; } }
/** * This function is similar to resolve_to_penultimate_context() except it should only be called by * the nns() functions. This function fixes any exception or continuations so that it will have * the proper nns name. */ protected boolean resolve_to_penultimate_context_nns(Name name, Continuation cont) throws NamingException { try { if (debug > 0) System.out.println("RESOLVE TO PENULTIMATE NNS" + name.toString()); boolean answer = resolve_to_penultimate_context(name, cont); // resolve_to_penultimate_context() only calls a_lookup(). // Any continuation it sets is lacking the nns, so // we need to add it back if (cont.isContinue()) cont.appendRemainingComponent(""); return answer; } catch (NamingException e) { // resolve_to_penultimate_context() only calls a_lookup(). // Any exceptions it throws is lacking the nns, so // we need to add it back. e.appendRemainingComponent(""); throw e; } }