/*
* Copyright 2008 biaoping.yin
*
* Licensed 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.
*
* http://blog.csdn.net/yin_bp
* http://yin-bp.javaeye.com/
*/
package com.frameworkset.common.poolman.jndi;
import java.util.HashMap;
import java.util.Hashtable;
import javax.naming.Binding;
import javax.naming.CompoundName;
import javax.naming.Context;
import javax.naming.ContextNotEmptyException;
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.directory.Attributes;
import javax.naming.directory.DirContext;
import javax.naming.directory.InvalidAttributesException;
/**
*
* <p>Title: DummyContext.java</p>
*
* <p>Description: </p>
*
* <p>Copyright: Copyright (c) 2007</p>
* @Date 2009-4-2 下午04:03:20
* @author biaoping.yin
* @version 1.0
*/
public class DummyContext implements Context
{
HashMap bindings = new HashMap();
/**
* Retrieves the named object.
* If <tt>name</tt> 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 <tt>name</tt>
* @throws NamingException if a naming exception is encountered
* @see #lookup(String)
* @see #lookupLink(Name)
*/
public Object lookup(Name name) throws NamingException
{
return null;
}
/**
* Retrieves the named object.
* See {@link #lookup(Name)} for details.
*
* @param name the name of the object to look up
* @return the object bound to <tt>name</tt>
* @throws NamingException if a naming exception is encountered
*/
public Object lookup(String name) throws NamingException
{
return bindings.get(name);
}
/**
* 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
* @throws NameAlreadyBoundException if name is already bound
* @throws InvalidAttributesException if object did not supply all mandatory attributes
* @throws NamingException if a naming exception is encountered
* @see #bind(String,Object)
* @see #rebind(Name,Object)
* @see DirContext#bind(Name,Object,
*Attributes)
*/
public void bind(Name name, Object obj) throws NamingException
{
}
/**
* Binds a name to an object.
* See {@link #bind(Name,Object)} for details.
*
* @param name the name to bind; may not be empty
* @param obj the object to bind; possibly null
* @throws NameAlreadyBoundException if name is already bound
* @throws InvalidAttributesException if object did not supply all mandatory attributes
* @throws NamingException if a naming exception is encountered
*/
public void bind(String name, Object obj) throws NamingException
{
bindings.put(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.
* <p/>
* <p> If the object is a <tt>DirContext</tt>, 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
* @throws InvalidAttributesException if object did not supply all mandatory attributes
* @throws NamingException if a naming exception is encountered
* @see #rebind(String,Object)
* @see #bind(Name,Object)
* @see DirContext#rebind(Name,Object,
*Attributes)
* @see DirContext
*/
public void rebind(Name name, Object obj) throws NamingException
{
}
/**
* Binds a name to an object, overwriting any existing binding.
* See {@link #rebind(Name,Object)} for details.
*
* @param name the name to bind; may not be empty
* @param obj the object to bind; possibly null
* @throws InvalidAttributesException if object did not supply all mandatory attributes
* @throws NamingException if a naming exception is encountered
*/
public void rebind(String name, Object obj) throws NamingException
{
bindings.put(name, obj);
}
/**
* Unbinds the named object.
* Removes the terminal atomic name in <code>name</code>
* from the target context--that named by all but the terminal
* atomic part of <code>name</code>.
* <p/>
* <p> This method is idempotent.
* It succeeds even if the terminal atomic name
* is not bound in the target context, but throws
* <tt>NameNotFoundException</tt>
* if any of the intermediate contexts do not exist.
* <p/>
* <p> Any attributes associated with the name are removed.
* Intermediate contexts are not changed.
*
* @param name the name to unbind; may not be empty
* @throws NameNotFoundException if an intermediate context does not exist
* @throws NamingException if a naming exception is encountered
* @see #unbind(String)
*/
public void unbind(Name name) throws NamingException
{
}
/**
* Unbinds the named object.
* See {@link #unbind(Name)} for details.
*
* @param name the name to unbind; may not be empty
* @throws NameNotFoundException if an intermediate context does not exist
* @throws NamingException if a naming exception is encountered
*/
public void unbind(String name) throws NamingException
{
bindings.remove(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.
*
* @param oldName the name of the existing binding; may not be empty
* @param newName the name of the new binding; may not be empty
* @throws NameAlreadyBoundException if <tt>newName</tt> is already bound
* @throws NamingException if a naming exception is encountered
* @see #rename(String,String)
* @see #bind(Name,Object)
* @see #rebind(Name,Object)
*/
public void rename(Name oldName, Name newName) throws NamingException
{
}
/**
* Binds a new name to the object bound to an old name, and unbinds
* the old name.
* See {@link #rename(Name,Name)} for details.
*
* @param oldName the name of the existing binding; may not be empty
* @param newName the name of the new binding; may not be empty
* @throws NameAlreadyBoundException if <tt>newName</tt> is already bound
* @throws NamingException if a naming exception is encountered
*/
public void rename(String oldName, String newName) throws NamingException
{
}
/**
* 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/>
* <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 <tt>NameClassPair</tt>.
* @throws NamingException if a naming exception is encountered
* @see #list(String)
* @see #listBindings(Name)
* @see NameClassPair
*/
public NamingEnumeration list(Name name) throws NamingException
{
return null;
}
/**
* Enumerates the names bound in the named context, along with the
* class names of objects bound to them.
* See {@link #list(Name)} for details.
*
* @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 <tt>NameClassPair</tt>.
* @throws NamingException if a naming exception is encountered
*/
public NamingEnumeration list(String name) throws NamingException
{
return null;
}
/**
* Enumerates the names bound in the named context, along with the
* objects bound to them.
* The contents of any subcontexts are not included.
* <p/>
* <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
* <tt>Binding</tt>.
* @throws NamingException if a naming exception is encountered
* @see #listBindings(String)
* @see #list(Name)
* @see Binding
*/
public NamingEnumeration listBindings(Name name) throws NamingException
{
return null;
}
/**
* Enumerates the names bound in the named context, along with the
* objects bound to them.
* See {@link #listBindings(Name)} for details.
*
* @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
* <tt>Binding</tt>.
* @throws NamingException if a naming exception is encountered
*/
public NamingEnumeration listBindings(String name) throws NamingException
{
return null;
}
/**
* 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/>
* <p> This method is idempotent.
* It succeeds even if the terminal atomic name
* is not bound in the target context, but throws
* <tt>NameNotFoundException</tt>
* if any of the intermediate contexts do not exist.
* <p/>
* <p> 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
* <tt>NotContextException</tt>, because the foreign context is not
* a "subcontext" of the context in which it is bound.
* Instead, use <tt>unbind()</tt> to remove the
* binding of the foreign context. Destroying the foreign context
* requires that the <tt>destroySubcontext()</tt> 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
* @throws NameNotFoundException if an intermediate context does not exist
* @throws NotContextException if the name is bound but does not name a
* context, or does not name a context of the appropriate type
* @throws ContextNotEmptyException if the named context is not empty
* @throws NamingException if a naming exception is encountered
* @see #destroySubcontext(String)
*/
public void destroySubcontext(Name name) throws NamingException
{
}
/**
* Destroys the named context and removes it from the namespace.
* See {@link #destroySubcontext(Name)} for details.
*
* @param name the name of the context to be destroyed; may not be empty
* @throws NameNotFoundException if an intermediate context does not exist
* @throws NotContextException if the name is bound but does not name a
* context, or does not name a context of the appropriate type
* @throws ContextNotEmptyException if the named context is not empty
* @throws NamingException if a naming exception is encountered
*/
public void destroySubcontext(String name) throws NamingException
{
}
/**
* 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
* @throws NameAlreadyBoundException if name is already bound
* @throws InvalidAttributesException if creation of the subcontext requires specification of
* mandatory attributes
* @throws NamingException if a naming exception is encountered
* @see #createSubcontext(String)
* @see DirContext#createSubcontext
*/
public Context createSubcontext(Name name) throws NamingException
{
return null;
}
/**
* Creates and binds a new context.
* See {@link #createSubcontext(Name)} for details.
*
* @param name the name of the context to create; may not be empty
* @return the newly created context
* @throws NameAlreadyBoundException if name is already bound
* @throws InvalidAttributesException if creation of the subcontext requires specification of
* mandatory attributes
* @throws NamingException if a naming exception is encountered
*/
public Context createSubcontext(String name) throws NamingException
{
return null;
}
/**
* Retrieves the named object, following links except
* for the terminal atomic component of the name.
* If the object bound to <tt>name</tt> is not a link,
* returns the object itself.
*
* @param name the name of the object to look up
* @return the object bound to <tt>name</tt>, not following the
* terminal link (if any).
* @throws NamingException if a naming exception is encountered
* @see #lookupLink(String)
*/
public Object lookupLink(Name name) throws NamingException
{
return null;
}
/**
* Retrieves the named object, following links except
* for the terminal atomic component of the name.
* See {@link #lookupLink(Name)} for details.
*
* @param name the name of the object to look up
* @return the object bound to <tt>name</tt>, not following the
* terminal link (if any)
* @throws NamingException if a naming exception is encountered
*/
public Object lookupLink(String name) throws NamingException
{
return null;
}
/**
* 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, <tt>NameParser</tt> objects
* returned by this method must be equal (using the <tt>equals()</tt>
* 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
* @throws NamingException if a naming exception is encountered
* @see #getNameParser(String)
* @see CompoundName
*/
public NameParser getNameParser(Name name) throws NamingException
{
return null;
}
/**
* Retrieves the parser associated with the named context.
* See {@link #getNameParser(Name)} for details.
*
* @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
* @throws NamingException if a naming exception is encountered
*/
public NameParser getNameParser(String name) throws NamingException
{
return null;
}
/**
* Composes the name of this context with a name relative to
* this context.
* Given a name (<code>name</code>) relative to this context, and
* the name (<code>prefix</code>) 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 <code>name</code> 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.
* <p/>
* For example, if this context is named "wiz.com" relative
* to the initial context, then
* <pre>
* composeName("east", "wiz.com") </pre>
* might return <code>"east.wiz.com"</code>.
* If instead this context is named "org/research", then
* <pre>
* composeName("user/jane", "org/research") </pre>
* might return <code>"org/research/user/jane"</code> while
* <pre>
* composeName("user/jane", "research") </pre>
* returns <code>"research/user/jane"</code>.
*
* @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 <code>prefix</code> and <code>name</code>
* @throws NamingException if a naming exception is encountered
* @see #composeName(String,String)
*/
public Name composeName(Name name, Name prefix) throws NamingException
{
return null;
}
/**
* Composes the name of this context with a name relative to
* this context.
* See {@link #composeName(Name,Name)} for details.
*
* @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 <code>prefix</code> and <code>name</code>
* @throws NamingException if a naming exception is encountered
*/
public String composeName(String name, String prefix)
throws NamingException
{
return null;
}
/**
* Adds a new environment property to the environment of this
* context. If the property already exists, its value is overwritten.
* See class description for more details on environment properties.
*
* @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
* @return the previous value of the property, or null if the property was
* not in the environment before
* @throws NamingException if a naming exception is encountered
* @see #getEnvironment()
* @see #removeFromEnvironment(String)
*/
public Object addToEnvironment(String propName, Object propVal)
throws NamingException
{
return null;
}
/**
* Removes an environment property from the environment of this
* context. See class description for more details on environment
* properties.
*
* @param propName the name of the environment property to remove; may not be null
* @return the previous value of the property, or null if the property was
* not in the environment
* @throws NamingException if a naming exception is encountered
* @see #getEnvironment()
* @see #addToEnvironment(String,Object)
*/
public Object removeFromEnvironment(String propName)
throws NamingException
{
return null;
}
/**
* Retrieves the environment in effect for this context.
* See class description for more details on environment properties.
* <p/>
* <p> 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
* <tt>addToEnvironment()</tt> and <tt>removeFromEnvironment()</tt>.
*
* @return the environment of this context; never null
* @throws NamingException if a naming exception is encountered
* @see #addToEnvironment(String,Object)
* @see #removeFromEnvironment(String)
*/
public Hashtable getEnvironment() throws NamingException
{
return null;
}
/**
* Closes this context.
* This method releases this context's resources immediately, instead of
* waiting for them to be released automatically by the garbage collector.
* <p/>
* <p> 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
*/
public void close() throws NamingException
{
}
/**
* Retrieves the full name of this context within its own namespace.
* <p/>
* <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, <tt>OperationNotSupportedException</tt> is thrown.
*
* @return this context's name in its own namespace; never null
* @throws OperationNotSupportedException if the naming system does
* not have the notion of a full name
* @throws NamingException if a naming exception is encountered
* @since 1.3
*/
public String getNameInNamespace() throws NamingException
{
return null;
}
}