public ReadOnlyContext() 
{
        env = new Hashtable();
        bindings = new HashMap();
        treeBindings = new HashMap();
}

 ReadOnlyContext(Hashtable env) 
{
        if (env == null) {
            this.env = new Hashtable();
        } else {
            this.env = new Hashtable(env);
        }
        this.bindings = Collections.EMPTY_MAP;
        this.treeBindings = Collections.EMPTY_MAP;
}

 protected ReadOnlyContext(ReadOnlyContext clone,
    Hashtable env) 
{
        this.bindings = clone.bindings;
        this.treeBindings = clone.treeBindings;
        this.env = new Hashtable(env);
}

 public Object addToEnvironment(String propName,
    Object propVal) throws NamingException 
{
        return env.put(propName, propVal);
}

 public  void bind(Name name,
    Object obj) throws NamingException 
{
        throw new OperationNotSupportedException();
}

 public  void bind(String name,
    Object obj) throws NamingException 
{
        throw new OperationNotSupportedException();
}

 public  void close() throws NamingException 
{
        throw new OperationNotSupportedException();
}

 public Name composeName(Name name,
    Name prefix) throws NamingException 
{
        Name result = (Name) prefix.clone();
        result.addAll(name);
        return result;
}

 public String composeName(String name,
    String prefix) throws NamingException 
{
        CompositeName result = new CompositeName(prefix);
        result.addAll(new CompositeName(name));
        return result.toString();
}

 public Context createSubcontext(Name name) throws NamingException 
{
        throw new OperationNotSupportedException();
}

 public Context createSubcontext(String name) throws NamingException 
{
        throw new OperationNotSupportedException();
}

 public  void destroySubcontext(Name name) throws NamingException 
{
        throw new OperationNotSupportedException();
}

 public  void destroySubcontext(String name) throws NamingException 
{
        throw new OperationNotSupportedException();
}

 public  void freeze() 
{
        frozen = true;
}

 public Hashtable getEnvironment() throws NamingException 
{
        return (Hashtable) env.clone();
}

 public String getNameInNamespace() throws NamingException 
{
        throw new OperationNotSupportedException();
}

 public NameParser getNameParser(Name name) throws NamingException 
{
        throw new OperationNotSupportedException();
}

 public NameParser getNameParser(String name) throws NamingException 
{
        throw new OperationNotSupportedException();
}

 protected Map internalBind(String name,
    Object value) throws NamingException 
{
        assert name != null && name.length()  > 0;
        assert !frozen;
        Map newBindings = new HashMap();
        int pos = name.indexOf('/');
        if (pos == -1) {
            if (treeBindings.put(name, value) != null) {
                throw new NamingException("Something already bound at " + name);
            }
            bindings.put(name, value);
            newBindings.put(name, value);
        } else {
            String segment = name.substring(0, pos);
            assert segment != null;
            assert !segment.equals("");
            Object o = treeBindings.get(segment);
            if (o == null) {
                o = newContext();
                treeBindings.put(segment, o);
                bindings.put(segment, o);
                newBindings.put(segment, o);
            } else if (!(o instanceof ReadOnlyContext)) {
                throw new NamingException("Something already bound where a subcontext should go");
            }
            ReadOnlyContext readOnlyContext = (ReadOnlyContext)o;
            String remainder = name.substring(pos + 1);
            Map subBindings = readOnlyContext.internalBind(remainder, value);
            for (Iterator iterator = subBindings.entrySet().iterator(); iterator.hasNext();) {
                Map.Entry entry = (Map.Entry) iterator.next();
                String subName = segment + "/" + entry.getKey();
                Object bound = entry.getValue();
                treeBindings.put(subName, bound);
                newBindings.put(subName, bound);
            }
        }
        return newBindings;
}

internalBind is intended for use only during setup or possibly by suitably synchronized superclasses. It binds every possible lookup into a map in each context. To do this, each context strips off one name segment and if necessary creates a new context for it. Then it asks that context to bind the remaining name. It returns a map containing all the bindings from the next context, plus the context it just created (if it in fact created it). (the names are suitably extended by the segment originally lopped off).

 boolean isFrozen() 
{
        return frozen;
}

 public NamingEnumeration list(String name) throws NamingException 
{
        Object o = lookup(name);
        if (o == this) {
            return new ListEnumeration();
        } else if (o instanceof Context) {
            return ((Context) o).list("");
        } else {
            throw new NotContextException();
        }
}

 public NamingEnumeration list(Name name) throws NamingException 
{
        return list(name.toString());
}

 public NamingEnumeration listBindings(String name) throws NamingException 
{
        Object o = lookup(name);
        if (o == this) {
            return new ListBindingEnumeration();
        } else if (o instanceof Context) {
            return ((Context) o).listBindings("");
        } else {
            throw new NotContextException();
        }
}

 public NamingEnumeration listBindings(Name name) throws NamingException 
{
        return listBindings(name.toString());
}

 public Object lookup(String name) throws NamingException 
{
        if (name.length() == 0) {
            return this;
        }
        Object result = treeBindings.get(name);
        if (result == null) {
            if (name.indexOf(':')  > 0) {
                Context ctx = new InitialContext();
                return ctx.lookup(name);
            } else {
                // Split out the first name of the path
                // and look for it in the bindings map.
                CompositeName path = new CompositeName(name);
                if (path.size() == 0) {
                    return this;
                } else {
                    Object obj = bindings.get(path.get(0));
                    if (obj == null){
                        throw new NameNotFoundException(name);
                    } else if (obj instanceof Context && path.size()  > 1){
                        Context subContext = (Context) obj;
                        obj = subContext.lookup(path.getSuffix(1));
                    }
                    return obj;
                }
            }
        }
        if (result instanceof SimpleReference) {
            try {
                result = ((SimpleReference) result).getContent();
            } catch (Exception e) {
                throw (NamingException)new NamingException("could not look up : " + name).initCause(e);
            }
        }
        if (result instanceof LinkRef) {
            LinkRef ref = (LinkRef) result;
            result = lookup(ref.getLinkName());
        }
        if (result instanceof Reference) {
            try {
                result = NamingManager.getObjectInstance(result, null, null, this.env);
            } catch (NamingException e) {
                throw e;
            } catch (Exception e) {
                throw (NamingException)new NamingException("could not look up : " + name).initCause(e);
            }
        }
        return result;
}

 public Object lookup(Name name) throws NamingException 
{
        return lookup(name.toString());
}

 public Object lookupLink(String name) throws NamingException 
{
        return lookup(name);
}

 public Object lookupLink(Name name) throws NamingException 
{
        return lookupLink(name.toString());
}

 protected ReadOnlyContext newContext() 
{
        return new ReadOnlyContext();
}

 public  void rebind(Name name,
    Object obj) throws NamingException 
{
        throw new OperationNotSupportedException();
}

 public  void rebind(String name,
    Object obj) throws NamingException 
{
        throw new OperationNotSupportedException();
}

 public Object removeFromEnvironment(String propName) throws NamingException 
{
        return env.remove(propName);
}

 public  void rename(Name oldName,
    Name newName) throws NamingException 
{
        throw new OperationNotSupportedException();
}

 public  void rename(String oldName,
    String newName) throws NamingException 
{
        throw new OperationNotSupportedException();
}

 public  void setClassLoader(ClassLoader classLoader) 
{
        for (Iterator iterator = treeBindings.values().iterator(); iterator.hasNext();) {
            Object o = iterator.next();
            if (o instanceof ClassLoaderAwareReference) {
                ((ClassLoaderAwareReference) o).setClassLoader(classLoader);
            }
        }
}

 public  void setKernel(Kernel kernel) 
{
        for (Iterator iterator = treeBindings.values().iterator(); iterator.hasNext();) {
            Object o = iterator.next();
            if (o instanceof KernelAwareReference) {
                ((KernelAwareReference) o).setKernel(kernel);
            }
        }
}

 public  void unbind(Name name) throws NamingException 
{
        throw new OperationNotSupportedException();
}

 public  void unbind(String name) throws NamingException 
{
        throw new OperationNotSupportedException();
}