/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


package org.apache.naming;

import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;

import javax.naming.Binding;
import javax.naming.CompositeName;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.LinkRef;
import javax.naming.Name;
import javax.naming.NameAlreadyBoundException;
import javax.naming.NameClassPair;
import javax.naming.NameNotFoundException;
import javax.naming.NameParser;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.NotContextException;
import javax.naming.OperationNotSupportedException;
import javax.naming.Reference;
import javax.naming.Referenceable;
import javax.naming.spi.NamingManager;
import javax.naming.spi.ObjectFactory;

import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;

Catalina JNDI Context implementation.
Author:
Remy Maucherat/**
 * Catalina JNDI Context implementation.
 *
 * @author Remy Maucherat
 */
public class NamingContext implements Context {


    // -------------------------------------------------------------- Constants


    
Name parser for this context.
/**
     * Name parser for this context.
     */
    protected static final NameParser nameParser = new NameParserImpl();


    private static final Log log = LogFactory.getLog(NamingContext.class);


    // ----------------------------------------------------------- Constructors


    
Builds a naming context.
Params:
env – The environment to use to construct the naming context
name – The name of the associated Catalina Context/**
     * Builds a naming context.
     *
     * @param env The environment to use to construct the naming context
     * @param name The name of the associated Catalina Context
     */
    public NamingContext(Hashtable<String,Object> env, String name) {
        this(env, name, new HashMap<String,NamingEntry>());
    }


    
Builds a naming context.
Params:
env – The environment to use to construct the naming context
name – The name of the associated Catalina Context
bindings – The initial bindings for the naming context/**
     * Builds a naming context.
     *
     * @param env The environment to use to construct the naming context
     * @param name The name of the associated Catalina Context
     * @param bindings The initial bindings for the naming context
     */
    public NamingContext(Hashtable<String,Object> env, String name,
            HashMap<String,NamingEntry> bindings) {

        this.env = new Hashtable<>();
        this.name = name;
        // Populating the environment hashtable
        if (env != null ) {
            Enumeration<String> envEntries = env.keys();
            while (envEntries.hasMoreElements()) {
                String entryName = envEntries.nextElement();
                addToEnvironment(entryName, env.get(entryName));
            }
        }
        this.bindings = bindings;
    }


    // ----------------------------------------------------- Instance Variables


    
Environment.
/**
     * Environment.
     */
    protected final Hashtable<String,Object> env;


    
The string manager for this package.
/**
     * The string manager for this package.
     */
    protected static final StringManager sm = StringManager.getManager(NamingContext.class);


    
Bindings in this Context.
/**
     * Bindings in this Context.
     */
    protected final HashMap<String,NamingEntry> bindings;


    
Name of the associated Catalina Context.
/**
     * Name of the associated Catalina Context.
     */
    protected final String name;


    
Determines if an attempt to write to a read-only context results in an
exception or if the request is ignored.
/**
     * Determines if an attempt to write to a read-only context results in an
     * exception or if the request is ignored.
     */
    private boolean exceptionOnFailedWrite = true;
    public boolean getExceptionOnFailedWrite() {
        return exceptionOnFailedWrite;
    }
    public void setExceptionOnFailedWrite(boolean exceptionOnFailedWrite) {
        this.exceptionOnFailedWrite = exceptionOnFailedWrite;
    }


    // -------------------------------------------------------- Context Methods

    
Retrieves the named object. If name is empty, returns a new instance
of this context (which represents the same naming context as this
context, but its environment may be modified independently and it may
be accessed concurrently).
Params:
name – the name of the object to look up
Throws:
NamingException – if a naming exception is encountered
Returns:
the object bound to name/**
     * Retrieves the named object. If name is empty, returns a new instance
     * of this context (which represents the same naming context as this
     * context, but its environment may be modified independently and it may
     * be accessed concurrently).
     *
     * @param name the name of the object to look up
     * @return the object bound to name
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public Object lookup(Name name)
        throws NamingException {
        return lookup(name, true);
    }


    
Retrieves the named object.
Params:
name – the name of the object to look up
Throws:
NamingException – if a naming exception is encountered
Returns:
the object bound to name/**
     * Retrieves the named object.
     *
     * @param name the name of the object to look up
     * @return the object bound to name
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public Object lookup(String name)
        throws NamingException {
        return lookup(new CompositeName(name), true);
    }


    
Binds a name to an object. All intermediate contexts and the target
context (that named by all but terminal atomic component of the name)
must already exist.
Params:
name – the name to bind; may not be empty
obj – the object to bind; possibly null
Throws:
NameAlreadyBoundException – if name is already bound
InvalidAttributesException – if object
did not supply all mandatory attributes
NamingException – if a naming exception is encountered/**
     * Binds a name to an object. All intermediate contexts and the target
     * context (that named by all but terminal atomic component of the name)
     * must already exist.
     *
     * @param name the name to bind; may not be empty
     * @param obj the object to bind; possibly null
     * @exception NameAlreadyBoundException if name is already bound
     * @exception javax.naming.directory.InvalidAttributesException if object
     * did not supply all mandatory attributes
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public void bind(Name name, Object obj)
        throws NamingException {
        bind(name, obj, false);
    }


    
Binds a name to an object.
Params:
name – the name to bind; may not be empty
obj – the object to bind; possibly null
Throws:
NameAlreadyBoundException – if name is already bound
InvalidAttributesException – if object
did not supply all mandatory attributes
NamingException – if a naming exception is encountered/**
     * Binds a name to an object.
     *
     * @param name the name to bind; may not be empty
     * @param obj the object to bind; possibly null
     * @exception NameAlreadyBoundException if name is already bound
     * @exception javax.naming.directory.InvalidAttributesException if object
     * did not supply all mandatory attributes
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public void bind(String name, Object obj)
        throws NamingException {
        bind(new CompositeName(name), obj);
    }


    
Binds a name to an object, overwriting any existing binding. All
intermediate contexts and the target context (that named by all but
terminal atomic component of the name) must already exist.

If the object is a DirContext, any existing attributes associated with
the name are replaced with those of the object. Otherwise, any
existing attributes associated with the name remain unchanged.
Params:
name – the name to bind; may not be empty
obj – the object to bind; possibly null
Throws:
InvalidAttributesException – if object
did not supply all mandatory attributes
NamingException – if a naming exception is encountered/**
     * Binds a name to an object, overwriting any existing binding. All
     * intermediate contexts and the target context (that named by all but
     * terminal atomic component of the name) must already exist.
     * <p>
     * If the object is a DirContext, any existing attributes associated with
     * the name are replaced with those of the object. Otherwise, any
     * existing attributes associated with the name remain unchanged.
     *
     * @param name the name to bind; may not be empty
     * @param obj the object to bind; possibly null
     * @exception javax.naming.directory.InvalidAttributesException if object
     * did not supply all mandatory attributes
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public void rebind(Name name, Object obj)
        throws NamingException {
        bind(name, obj, true);
    }


    
Binds a name to an object, overwriting any existing binding.
Params:
name – the name to bind; may not be empty
obj – the object to bind; possibly null
Throws:
InvalidAttributesException – if object
did not supply all mandatory attributes
NamingException – if a naming exception is encountered/**
     * Binds a name to an object, overwriting any existing binding.
     *
     * @param name the name to bind; may not be empty
     * @param obj the object to bind; possibly null
     * @exception javax.naming.directory.InvalidAttributesException if object
     * did not supply all mandatory attributes
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public void rebind(String name, Object obj)
        throws NamingException {
        rebind(new CompositeName(name), obj);
    }


    
Unbinds the named object. Removes the terminal atomic name in name
from the target context--that named by all but the terminal atomic
part of name.

This method is idempotent. It succeeds even if the terminal atomic
name is not bound in the target context, but throws
NameNotFoundException if any of the intermediate contexts do not exist.
Params:
name – the name to bind; may not be empty
Throws:
NameNotFoundException – if an intermediate context does not
exist
NamingException – if a naming exception is encountered/**
     * Unbinds the named object. Removes the terminal atomic name in name
     * from the target context--that named by all but the terminal atomic
     * part of name.
     * <p>
     * This method is idempotent. It succeeds even if the terminal atomic
     * name is not bound in the target context, but throws
     * NameNotFoundException if any of the intermediate contexts do not exist.
     *
     * @param name the name to bind; may not be empty
     * @exception NameNotFoundException if an intermediate context does not
     * exist
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public void unbind(Name name) throws NamingException {

        if (!checkWritable()) {
            return;
        }

        while ((!name.isEmpty()) && (name.get(0).length() == 0))
            name = name.getSuffix(1);
        if (name.isEmpty())
            throw new NamingException
                (sm.getString("namingContext.invalidName"));

        NamingEntry entry = bindings.get(name.get(0));

        if (entry == null) {
            throw new NameNotFoundException
                (sm.getString("namingContext.nameNotBound", name, name.get(0)));
        }

        if (name.size() > 1) {
            if (entry.type == NamingEntry.CONTEXT) {
                ((Context) entry.value).unbind(name.getSuffix(1));
            } else {
                throw new NamingException
                    (sm.getString("namingContext.contextExpected"));
            }
        } else {
            bindings.remove(name.get(0));
        }

    }


    
Unbinds the named object.
Params:
name – the name to bind; may not be empty
Throws:
NameNotFoundException – if an intermediate context does not
exist
NamingException – if a naming exception is encountered/**
     * Unbinds the named object.
     *
     * @param name the name to bind; may not be empty
     * @exception NameNotFoundException if an intermediate context does not
     * exist
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public void unbind(String name)
        throws NamingException {
        unbind(new CompositeName(name));
    }


    
Binds a new name to the object bound to an old name, and unbinds the
old name. Both names are relative to this context. Any attributes
associated with the old name become associated with the new name.
Intermediate contexts of the old name are not changed.
Params:
oldName – the name of the existing binding; may not be empty
newName – the name of the new binding; may not be empty
Throws:
NameAlreadyBoundException – if newName is already bound
NamingException – if a naming exception is encountered/**
     * Binds a new name to the object bound to an old name, and unbinds the
     * old name. Both names are relative to this context. Any attributes
     * associated with the old name become associated with the new name.
     * Intermediate contexts of the old name are not changed.
     *
     * @param oldName the name of the existing binding; may not be empty
     * @param newName the name of the new binding; may not be empty
     * @exception NameAlreadyBoundException if newName is already bound
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public void rename(Name oldName, Name newName)
        throws NamingException {
        Object value = lookup(oldName);
        bind(newName, value);
        unbind(oldName);
    }


    
Binds a new name to the object bound to an old name, and unbinds the
old name.
Params:
oldName – the name of the existing binding; may not be empty
newName – the name of the new binding; may not be empty
Throws:
NameAlreadyBoundException – if newName is already bound
NamingException – if a naming exception is encountered/**
     * Binds a new name to the object bound to an old name, and unbinds the
     * old name.
     *
     * @param oldName the name of the existing binding; may not be empty
     * @param newName the name of the new binding; may not be empty
     * @exception NameAlreadyBoundException if newName is already bound
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public void rename(String oldName, String newName)
        throws NamingException {
        rename(new CompositeName(oldName), new CompositeName(newName));
    }


    
Enumerates the names bound in the named context, along with the class
names of objects bound to them. The contents of any subcontexts are
not included.

If a binding is added to or removed from this context, its effect on
an enumeration previously returned is undefined.
Params:
name – the name of the context to list
Throws:
NamingException – if a naming exception is encountered
Returns:
an enumeration of the names and class names of the bindings in
this context. Each element of the enumeration is of type NameClassPair./**
     * Enumerates the names bound in the named context, along with the class
     * names of objects bound to them. The contents of any subcontexts are
     * not included.
     * <p>
     * If a binding is added to or removed from this context, its effect on
     * an enumeration previously returned is undefined.
     *
     * @param name the name of the context to list
     * @return an enumeration of the names and class names of the bindings in
     * this context. Each element of the enumeration is of type NameClassPair.
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public NamingEnumeration<NameClassPair> list(Name name)
        throws NamingException {
        // Removing empty parts
        while ((!name.isEmpty()) && (name.get(0).length() == 0))
            name = name.getSuffix(1);
        if (name.isEmpty()) {
            return new NamingContextEnumeration(bindings.values().iterator());
        }

        NamingEntry entry = bindings.get(name.get(0));

        if (entry == null) {
            throw new NameNotFoundException
                (sm.getString("namingContext.nameNotBound", name, name.get(0)));
        }

        if (entry.type != NamingEntry.CONTEXT) {
            throw new NamingException
                (sm.getString("namingContext.contextExpected"));
        }
        return ((Context) entry.value).list(name.getSuffix(1));
    }


    
Enumerates the names bound in the named context, along with the class
names of objects bound to them.
Params:
name – the name of the context to list
Throws:
NamingException – if a naming exception is encountered
Returns:
an enumeration of the names and class names of the bindings in
this context. Each element of the enumeration is of type NameClassPair./**
     * Enumerates the names bound in the named context, along with the class
     * names of objects bound to them.
     *
     * @param name the name of the context to list
     * @return an enumeration of the names and class names of the bindings in
     * this context. Each element of the enumeration is of type NameClassPair.
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public NamingEnumeration<NameClassPair> list(String name)
        throws NamingException {
        return list(new CompositeName(name));
    }


    
Enumerates the names bound in the named context, along with the
objects bound to them. The contents of any subcontexts are not
included.

If a binding is added to or removed from this context, its effect on
an enumeration previously returned is undefined.
Params:
name – the name of the context to list
Throws:
NamingException – if a naming exception is encountered
Returns:
an enumeration of the bindings in this context.
Each element of the enumeration is of type Binding./**
     * Enumerates the names bound in the named context, along with the
     * objects bound to them. The contents of any subcontexts are not
     * included.
     * <p>
     * If a binding is added to or removed from this context, its effect on
     * an enumeration previously returned is undefined.
     *
     * @param name the name of the context to list
     * @return an enumeration of the bindings in this context.
     * Each element of the enumeration is of type Binding.
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public NamingEnumeration<Binding> listBindings(Name name)
        throws NamingException {
        // Removing empty parts
        while ((!name.isEmpty()) && (name.get(0).length() == 0))
            name = name.getSuffix(1);
        if (name.isEmpty()) {
            return new NamingContextBindingsEnumeration(bindings.values().iterator(), this);
        }

        NamingEntry entry = bindings.get(name.get(0));

        if (entry == null) {
            throw new NameNotFoundException
                (sm.getString("namingContext.nameNotBound", name, name.get(0)));
        }

        if (entry.type != NamingEntry.CONTEXT) {
            throw new NamingException
                (sm.getString("namingContext.contextExpected"));
        }
        return ((Context) entry.value).listBindings(name.getSuffix(1));
    }


    
Enumerates the names bound in the named context, along with the
objects bound to them.
Params:
name – the name of the context to list
Throws:
NamingException – if a naming exception is encountered
Returns:
an enumeration of the bindings in this context.
Each element of the enumeration is of type Binding./**
     * Enumerates the names bound in the named context, along with the
     * objects bound to them.
     *
     * @param name the name of the context to list
     * @return an enumeration of the bindings in this context.
     * Each element of the enumeration is of type Binding.
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public NamingEnumeration<Binding> listBindings(String name)
        throws NamingException {
        return listBindings(new CompositeName(name));
    }


    
Destroys the named context and removes it from the namespace. Any
attributes associated with the name are also removed. Intermediate
contexts are not destroyed.

This method is idempotent. It succeeds even if the terminal atomic
name is not bound in the target context, but throws
NameNotFoundException if any of the intermediate contexts do not exist.
In a federated naming system, a context from one naming system may be
bound to a name in another. One can subsequently look up and perform
operations on the foreign context using a composite name. However, an
attempt destroy the context using this composite name will fail with
NotContextException, because the foreign context is not a "subcontext"
of the context in which it is bound. Instead, use unbind() to remove
the binding of the foreign context. Destroying the foreign context
requires that the destroySubcontext() be performed on a context from
the foreign context's "native" naming system.
Params:
name – the name of the context to be destroyed; may not be empty
Throws:
NameNotFoundException – if an intermediate context does not
exist
NotContextException – if the name is bound but does not name
a context, or does not name a context of the appropriate type/**
     * Destroys the named context and removes it from the namespace. Any
     * attributes associated with the name are also removed. Intermediate
     * contexts are not destroyed.
     * <p>
     * This method is idempotent. It succeeds even if the terminal atomic
     * name is not bound in the target context, but throws
     * NameNotFoundException if any of the intermediate contexts do not exist.
     *
     * In a federated naming system, a context from one naming system may be
     * bound to a name in another. One can subsequently look up and perform
     * operations on the foreign context using a composite name. However, an
     * attempt destroy the context using this composite name will fail with
     * NotContextException, because the foreign context is not a "subcontext"
     * of the context in which it is bound. Instead, use unbind() to remove
     * the binding of the foreign context. Destroying the foreign context
     * requires that the destroySubcontext() be performed on a context from
     * the foreign context's "native" naming system.
     *
     * @param name the name of the context to be destroyed; may not be empty
     * @exception NameNotFoundException if an intermediate context does not
     * exist
     * @exception NotContextException if the name is bound but does not name
     * a context, or does not name a context of the appropriate type
     */
    @Override
    public void destroySubcontext(Name name) throws NamingException {

        if (!checkWritable()) {
            return;
        }

        while ((!name.isEmpty()) && (name.get(0).length() == 0))
            name = name.getSuffix(1);
        if (name.isEmpty())
            throw new NamingException
                (sm.getString("namingContext.invalidName"));

        NamingEntry entry = bindings.get(name.get(0));

        if (entry == null) {
            throw new NameNotFoundException
                (sm.getString("namingContext.nameNotBound", name, name.get(0)));
        }

        if (name.size() > 1) {
            if (entry.type == NamingEntry.CONTEXT) {
                ((Context) entry.value).destroySubcontext(name.getSuffix(1));
            } else {
                throw new NamingException
                    (sm.getString("namingContext.contextExpected"));
            }
        } else {
            if (entry.type == NamingEntry.CONTEXT) {
                ((Context) entry.value).close();
                bindings.remove(name.get(0));
            } else {
                throw new NotContextException
                    (sm.getString("namingContext.contextExpected"));
            }
        }

    }


    
Destroys the named context and removes it from the namespace.
Params:
name – the name of the context to be destroyed; may not be empty
Throws:
NameNotFoundException – if an intermediate context does not
exist
NotContextException – if the name is bound but does not name
a context, or does not name a context of the appropriate type/**
     * Destroys the named context and removes it from the namespace.
     *
     * @param name the name of the context to be destroyed; may not be empty
     * @exception NameNotFoundException if an intermediate context does not
     * exist
     * @exception NotContextException if the name is bound but does not name
     * a context, or does not name a context of the appropriate type
     */
    @Override
    public void destroySubcontext(String name)
        throws NamingException {
        destroySubcontext(new CompositeName(name));
    }


    
Creates and binds a new context. Creates a new context with the given
name and binds it in the target context (that named by all but
terminal atomic component of the name). All intermediate contexts and
the target context must already exist.
Params:
name – the name of the context to create; may not be empty
Throws:
NameAlreadyBoundException – if name is already bound
InvalidAttributesException – if creation
of the sub-context requires specification of mandatory attributes
NamingException – if a naming exception is encountered
Returns:
the newly created context/**
     * Creates and binds a new context. Creates a new context with the given
     * name and binds it in the target context (that named by all but
     * terminal atomic component of the name). All intermediate contexts and
     * the target context must already exist.
     *
     * @param name the name of the context to create; may not be empty
     * @return the newly created context
     * @exception NameAlreadyBoundException if name is already bound
     * @exception javax.naming.directory.InvalidAttributesException if creation
     * of the sub-context requires specification of mandatory attributes
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public Context createSubcontext(Name name) throws NamingException {
        if (!checkWritable()) {
            return null;
        }

        NamingContext newContext = new NamingContext(env, this.name);
        bind(name, newContext);

        newContext.setExceptionOnFailedWrite(getExceptionOnFailedWrite());

        return newContext;
    }


    
Creates and binds a new context.
Params:
name – the name of the context to create; may not be empty
Throws:
NameAlreadyBoundException – if name is already bound
InvalidAttributesException – if creation
of the sub-context requires specification of mandatory attributes
NamingException – if a naming exception is encountered
Returns:
the newly created context/**
     * Creates and binds a new context.
     *
     * @param name the name of the context to create; may not be empty
     * @return the newly created context
     * @exception NameAlreadyBoundException if name is already bound
     * @exception javax.naming.directory.InvalidAttributesException if creation
     * of the sub-context requires specification of mandatory attributes
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public Context createSubcontext(String name)
        throws NamingException {
        return createSubcontext(new CompositeName(name));
    }


    
Retrieves the named object, following links except for the terminal
atomic component of the name. If the object bound to name is not a
link, returns the object itself.
Params:
name – the name of the object to look up
Throws:
NamingException – if a naming exception is encountered
Returns:
the object bound to name, not following the terminal link
(if any)./**
     * Retrieves the named object, following links except for the terminal
     * atomic component of the name. If the object bound to name is not a
     * link, returns the object itself.
     *
     * @param name the name of the object to look up
     * @return the object bound to name, not following the terminal link
     * (if any).
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public Object lookupLink(Name name)
        throws NamingException {
        return lookup(name, false);
    }


    
Retrieves the named object, following links except for the terminal
atomic component of the name.
Params:
name – the name of the object to look up
Throws:
NamingException – if a naming exception is encountered
Returns:
the object bound to name, not following the terminal link
(if any)./**
     * Retrieves the named object, following links except for the terminal
     * atomic component of the name.
     *
     * @param name the name of the object to look up
     * @return the object bound to name, not following the terminal link
     * (if any).
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public Object lookupLink(String name)
        throws NamingException {
        return lookup(new CompositeName(name), false);
    }


    
Retrieves the parser associated with the named context. In a
federation of namespaces, different naming systems will parse names
differently. This method allows an application to get a parser for
parsing names into their atomic components using the naming convention
of a particular naming system. Within any single naming system,
NameParser objects returned by this method must be equal (using the
equals() test).
Params:
name – the name of the context from which to get the parser
Throws:
NamingException – if a naming exception is encountered
Returns:
a name parser that can parse compound names into their atomic
components/**
     * Retrieves the parser associated with the named context. In a
     * federation of namespaces, different naming systems will parse names
     * differently. This method allows an application to get a parser for
     * parsing names into their atomic components using the naming convention
     * of a particular naming system. Within any single naming system,
     * NameParser objects returned by this method must be equal (using the
     * equals() test).
     *
     * @param name the name of the context from which to get the parser
     * @return a name parser that can parse compound names into their atomic
     * components
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public NameParser getNameParser(Name name)
        throws NamingException {

        while ((!name.isEmpty()) && (name.get(0).length() == 0))
            name = name.getSuffix(1);
        if (name.isEmpty())
            return nameParser;

        if (name.size() > 1) {
            Object obj = bindings.get(name.get(0));
            if (obj instanceof Context) {
                return ((Context) obj).getNameParser(name.getSuffix(1));
            } else {
                throw new NotContextException
                    (sm.getString("namingContext.contextExpected"));
            }
        }

        return nameParser;

    }


    
Retrieves the parser associated with the named context.
Params:
name – the name of the context from which to get the parser
Throws:
NamingException – if a naming exception is encountered
Returns:
a name parser that can parse compound names into their atomic
components/**
     * Retrieves the parser associated with the named context.
     *
     * @param name the name of the context from which to get the parser
     * @return a name parser that can parse compound names into their atomic
     * components
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public NameParser getNameParser(String name)
        throws NamingException {
        return getNameParser(new CompositeName(name));
    }


    
Composes the name of this context with a name relative to this context.

Given a name (name) relative to this context, and the name (prefix)
of this context relative to one of its ancestors, this method returns
the composition of the two names using the syntax appropriate for the
naming system(s) involved. That is, if name names an object relative
to this context, the result is the name of the same object, but
relative to the ancestor context. None of the names may be null.
Params:
name – a name relative to this context
prefix – the name of this context relative to one of its ancestors
Throws:
NamingException – if a naming exception is encountered
Returns:
the composition of prefix and name/**
     * Composes the name of this context with a name relative to this context.
     * <p>
     * Given a name (name) relative to this context, and the name (prefix)
     * of this context relative to one of its ancestors, this method returns
     * the composition of the two names using the syntax appropriate for the
     * naming system(s) involved. That is, if name names an object relative
     * to this context, the result is the name of the same object, but
     * relative to the ancestor context. None of the names may be null.
     *
     * @param name a name relative to this context
     * @param prefix the name of this context relative to one of its ancestors
     * @return the composition of prefix and name
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public Name composeName(Name name, Name prefix) throws NamingException {
        prefix = (Name) prefix.clone();
        return prefix.addAll(name);
    }


    
Composes the name of this context with a name relative to this context.
Params:
name – a name relative to this context
prefix – the name of this context relative to one of its ancestors
Returns:
the composition of prefix and name/**
     * Composes the name of this context with a name relative to this context.
     *
     * @param name a name relative to this context
     * @param prefix the name of this context relative to one of its ancestors
     * @return the composition of prefix and name
     */
    @Override
    public String composeName(String name, String prefix) {
        return prefix + "/" + name;
    }


    
Adds a new environment property to the environment of this context. If
the property already exists, its value is overwritten.
Params:
propName – the name of the environment property to add; may not
be null
propVal – the value of the property to add; may not be null/**
     * Adds a new environment property to the environment of this context. If
     * the property already exists, its value is overwritten.
     *
     * @param propName the name of the environment property to add; may not
     * be null
     * @param propVal the value of the property to add; may not be null
     */
    @Override
    public Object addToEnvironment(String propName, Object propVal) {
        return env.put(propName, propVal);
    }


    
Removes an environment property from the environment of this context.
Params:
propName – the name of the environment property to remove;
may not be null/**
     * Removes an environment property from the environment of this context.
     *
     * @param propName the name of the environment property to remove;
     * may not be null
     */
    @Override
    public Object removeFromEnvironment(String propName){
        return env.remove(propName);
    }


    
Retrieves the environment in effect for this context. See class
description for more details on environment properties.
The caller should not make any changes to the object returned: their
effect on the context is undefined. The environment of this context
may be changed using addToEnvironment() and removeFromEnvironment().
Returns:
the environment of this context; never null/**
     * Retrieves the environment in effect for this context. See class
     * description for more details on environment properties.
     * The caller should not make any changes to the object returned: their
     * effect on the context is undefined. The environment of this context
     * may be changed using addToEnvironment() and removeFromEnvironment().
     *
     * @return the environment of this context; never null
     */
    @Override
    public Hashtable<?,?> getEnvironment() {
        return env;
    }


    
Closes this context. This method releases this context's resources
immediately, instead of waiting for them to be released automatically
by the garbage collector.
This method is idempotent: invoking it on a context that has already
been closed has no effect. Invoking any other method on a closed
context is not allowed, and results in undefined behaviour.
Throws:
NamingException – if a naming exception is encountered/**
     * Closes this context. This method releases this context's resources
     * immediately, instead of waiting for them to be released automatically
     * by the garbage collector.
     * This method is idempotent: invoking it on a context that has already
     * been closed has no effect. Invoking any other method on a closed
     * context is not allowed, and results in undefined behaviour.
     *
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public void close() throws NamingException {
        if (!checkWritable()) {
            return;
        }
        env.clear();
    }


    
Retrieves the full name of this context within its own namespace.

Many naming services have a notion of a "full name" for objects in
their respective namespaces. For example, an LDAP entry has a
distinguished name, and a DNS record has a fully qualified name. This
method allows the client application to retrieve this name. The string
returned by this method is not a JNDI composite name and should not be
passed directly to context methods. In naming systems for which the
notion of full name does not make sense,
OperationNotSupportedException is thrown.
Throws:
OperationNotSupportedException – if the naming system does
not have the notion of a full name
NamingException – if a naming exception is encountered
Returns:
this context's name in its own namespace; never null/**
     * Retrieves the full name of this context within its own namespace.
     * <p>
     * Many naming services have a notion of a "full name" for objects in
     * their respective namespaces. For example, an LDAP entry has a
     * distinguished name, and a DNS record has a fully qualified name. This
     * method allows the client application to retrieve this name. The string
     * returned by this method is not a JNDI composite name and should not be
     * passed directly to context methods. In naming systems for which the
     * notion of full name does not make sense,
     * OperationNotSupportedException is thrown.
     *
     * @return this context's name in its own namespace; never null
     * @exception OperationNotSupportedException if the naming system does
     * not have the notion of a full name
     * @exception NamingException if a naming exception is encountered
     */
    @Override
    public String getNameInNamespace()
        throws NamingException {
        throw  new OperationNotSupportedException
            (sm.getString("namingContext.noAbsoluteName"));
        //FIXME ?
    }


    // ------------------------------------------------------ Protected Methods


    private static final boolean GRAAL;

    static {
        boolean result = false;
        try {
            Class<?> nativeImageClazz = Class.forName("org.graalvm.nativeimage.ImageInfo");
            result = Boolean.TRUE.equals(nativeImageClazz.getMethod("inImageCode").invoke(null));
        } catch (ClassNotFoundException e) {
            // Must be Graal
        } catch (ReflectiveOperationException | IllegalArgumentException e) {
            // Should never happen
        }
        GRAAL = result;
    }

    
Retrieves the named object.
Params:
name – the name of the object to look up
resolveLinks – If true, the links will be resolved
Throws:
NamingException – if a naming exception is encountered
Returns:
the object bound to name/**
     * Retrieves the named object.
     *
     * @param name the name of the object to look up
     * @param resolveLinks If true, the links will be resolved
     * @return the object bound to name
     * @exception NamingException if a naming exception is encountered
     */
    protected Object lookup(Name name, boolean resolveLinks)
        throws NamingException {

        // Removing empty parts
        while ((!name.isEmpty()) && (name.get(0).length() == 0))
            name = name.getSuffix(1);
        if (name.isEmpty()) {
            // If name is empty, a newly allocated naming context is returned
            return new NamingContext(env, this.name, bindings);
        }

        NamingEntry entry = bindings.get(name.get(0));

        if (entry == null) {
            throw new NameNotFoundException
                (sm.getString("namingContext.nameNotBound", name, name.get(0)));
        }

        if (name.size() > 1) {
            // If the size of the name is greater that 1, then we go through a
            // number of subcontexts.
            if (entry.type != NamingEntry.CONTEXT) {
                throw new NamingException
                    (sm.getString("namingContext.contextExpected"));
            }
            return ((Context) entry.value).lookup(name.getSuffix(1));
        } else {
            if ((resolveLinks) && (entry.type == NamingEntry.LINK_REF)) {
                String link = ((LinkRef) entry.value).getLinkName();
                if (link.startsWith(".")) {
                    // Link relative to this context
                    return lookup(link.substring(1));
                } else {
                    return new InitialContext(env).lookup(link);
                }
            } else if (entry.type == NamingEntry.REFERENCE) {
                try {
                    Object obj = null;
                    if (!GRAAL) {
                        obj = NamingManager.getObjectInstance(entry.value, name, this, env);
                    } else {
                        // NamingManager.getObjectInstance would simply return the reference here
                        // Use the configured object factory to resolve it directly if possible
                        // Note: This may need manual constructor reflection configuration
                        Reference reference = (Reference) entry.value;
                        Class<?> factoryClass = getClass().getClassLoader().loadClass(reference.getFactoryClassName());
                        ObjectFactory factory = (ObjectFactory) factoryClass.newInstance();
                        obj = factory.getObjectInstance(entry.value, name, this, env);
                    }
                    if (entry.value instanceof ResourceRef) {
                        boolean singleton = Boolean.parseBoolean(
                                    (String) ((ResourceRef) entry.value).get(
                                        "singleton").getContent());
                        if (singleton) {
                            entry.type = NamingEntry.ENTRY;
                            entry.value = obj;
                        }
                    }
                    return obj;
                } catch (NamingException e) {
                    throw e;
                } catch (Exception e) {
                    String msg = sm.getString("namingContext.failResolvingReference");
                    log.warn(msg, e);
                    NamingException ne = new NamingException(msg);
                    ne.initCause(e);
                    throw ne;
                }
            } else {
                return entry.value;
            }
        }

    }


    
Binds a name to an object. All intermediate contexts and the target
context (that named by all but terminal atomic component of the name)
must already exist.
Params:
name – the name to bind; may not be empty
obj – the object to bind; possibly null
rebind – if true, then perform a rebind (ie, overwrite)
Throws:
NameAlreadyBoundException – if name is already bound
InvalidAttributesException – if object
did not supply all mandatory attributes
NamingException – if a naming exception is encountered/**
     * Binds a name to an object. All intermediate contexts and the target
     * context (that named by all but terminal atomic component of the name)
     * must already exist.
     *
     * @param name the name to bind; may not be empty
     * @param obj the object to bind; possibly null
     * @param rebind if true, then perform a rebind (ie, overwrite)
     * @exception NameAlreadyBoundException if name is already bound
     * @exception javax.naming.directory.InvalidAttributesException if object
     * did not supply all mandatory attributes
     * @exception NamingException if a naming exception is encountered
     */
    protected void bind(Name name, Object obj, boolean rebind)
        throws NamingException {

        if (!checkWritable()) {
            return;
        }

        while ((!name.isEmpty()) && (name.get(0).length() == 0))
            name = name.getSuffix(1);
        if (name.isEmpty())
            throw new NamingException
                (sm.getString("namingContext.invalidName"));

        NamingEntry entry = bindings.get(name.get(0));

        if (name.size() > 1) {
            if (entry == null) {
                throw new NameNotFoundException(sm.getString(
                        "namingContext.nameNotBound", name, name.get(0)));
            }
            if (entry.type == NamingEntry.CONTEXT) {
                if (rebind) {
                    ((Context) entry.value).rebind(name.getSuffix(1), obj);
                } else {
                    ((Context) entry.value).bind(name.getSuffix(1), obj);
                }
            } else {
                throw new NamingException
                    (sm.getString("namingContext.contextExpected"));
            }
        } else {
            if ((!rebind) && (entry != null)) {
                throw new NameAlreadyBoundException
                    (sm.getString("namingContext.alreadyBound", name.get(0)));
            } else {
                // Getting the type of the object and wrapping it within a new
                // NamingEntry
                Object toBind =
                    NamingManager.getStateToBind(obj, name, this, env);
                if (toBind instanceof Context) {
                    entry = new NamingEntry(name.get(0), toBind,
                                            NamingEntry.CONTEXT);
                } else if (toBind instanceof LinkRef) {
                    entry = new NamingEntry(name.get(0), toBind,
                                            NamingEntry.LINK_REF);
                } else if (toBind instanceof Reference) {
                    entry = new NamingEntry(name.get(0), toBind,
                                            NamingEntry.REFERENCE);
                } else if (toBind instanceof Referenceable) {
                    toBind = ((Referenceable) toBind).getReference();
                    entry = new NamingEntry(name.get(0), toBind,
                                            NamingEntry.REFERENCE);
                } else {
                    entry = new NamingEntry(name.get(0), toBind,
                                            NamingEntry.ENTRY);
                }
                bindings.put(name.get(0), entry);
            }
        }

    }


    
Returns:
true if writing is allowed on this context./**
     * @return <code>true</code> if writing is allowed on this context.
     */
    protected boolean isWritable() {
        return ContextAccessController.isWritable(name);
    }


    
Throws a naming exception is Context is not writable.
Throws:
NamingException – if the Context is not writable and
 exceptionOnFailedWrite is true
Returns:
true if the Context is writable/**
     * Throws a naming exception is Context is not writable.
     * @return <code>true</code> if the Context is writable
     * @throws NamingException if the Context is not writable and
     *  <code>exceptionOnFailedWrite</code> is <code>true</code>
     */
    protected boolean checkWritable() throws NamingException {
        if (isWritable()) {
            return true;
        } else {
            if (exceptionOnFailedWrite) {
                throw new javax.naming.OperationNotSupportedException(
                        sm.getString("namingContext.readOnly"));
            }
        }
        return false;
    }
}