Back to index...

	/*
	* 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.dir;

	import javax.naming.*;
	import javax.naming.directory.*;
	import javax.naming.spi.*;
	import java.util.*;

	/**
	* A sample service provider that implements a hierarchical directory in memory.
	* Every operation begins by doing a lookup on the name passed to it and then
	* calls a corresponding "do<OperationName>" on the result of the lookup. The
	* "do<OperationName>" does the work without any further resolution (it assumes
	* that it is the target context).
	*/

	public class HierMemDirCtx implements DirContext {

	static private final boolean debug = false;
	private static final NameParser defaultParser = new HierarchicalNameParser();

	protected Hashtable<String, Object> myEnv;
	protected Hashtable<Name, Object> bindings;
	protected Attributes attrs;
	protected boolean ignoreCase = false;
	protected NamingException readOnlyEx = null;
	protected NameParser myParser = defaultParser;

	private boolean alwaysUseFactory;

	public void close() throws NamingException {
	myEnv = null;
	bindings = null;
	attrs = null;
	}

	public String getNameInNamespace() throws NamingException {
	throw new OperationNotSupportedException(
	"Cannot determine full name");
	}

	public HierMemDirCtx() {
	this(null, false, false);
	}

	public HierMemDirCtx(boolean ignoreCase) {
	this(null, ignoreCase, false);
	}

	public HierMemDirCtx(Hashtable<String, Object> environment, boolean ignoreCase) {
	this(environment, ignoreCase, false);
	}

	protected HierMemDirCtx(Hashtable<String, Object> environment,
	boolean ignoreCase, boolean useFac) {
	myEnv = environment;
	this.ignoreCase = ignoreCase;
	init();
	this.alwaysUseFactory = useFac;
	}

	private void init() {
	attrs = new BasicAttributes(ignoreCase);
	bindings = new Hashtable<>(11, 0.75f);
	}

	public Object lookup(String name) throws NamingException {
	return lookup(myParser.parse(name));
	}

	public Object lookup(Name name) throws NamingException {
	return doLookup(name, alwaysUseFactory);
	}

	public Object doLookup(Name name, boolean useFactory)
	throws NamingException {

	Object target = null;
	name = canonizeName(name);

	switch(name.size()) {
	case 0:
	// name is empty, caller wants this object
	target = this;
	break;

	case 1:
	// name is atomic, caller wants one of this object's bindings
	target = bindings.get(name);
	break;

	default:
	// name is compound, delegate to child context
	HierMemDirCtx ctx = (HierMemDirCtx)bindings.get(name.getPrefix(1));
	if(ctx == null) {
	target = null;
	} else {
	target = ctx.doLookup(name.getSuffix(1), false);
	}
	break;
	}

	if(target == null) {
	throw new NameNotFoundException(name.toString());
	}

	if (useFactory) {
	try {
	return DirectoryManager.getObjectInstance(target,
	name, this, myEnv,
	(target instanceof HierMemDirCtx) ?
	((HierMemDirCtx)target).attrs : null);
	} catch (NamingException e) {
	throw e;
	} catch (Exception e) {
	NamingException e2 = new NamingException(
	"Problem calling getObjectInstance");
	e2.setRootCause(e);
	throw e2;
	}
	} else {
	return target;
	}
	}

	public void bind(String name, Object obj) throws NamingException {
	bind(myParser.parse(name), obj);
	}

	public void bind(Name name, Object obj) throws NamingException {
	doBind(name, obj, null, alwaysUseFactory);
	}

	public void bind(String name, Object obj, Attributes attrs)
	throws NamingException {
	bind(myParser.parse(name), obj, attrs);
	}

	public void bind(Name name, Object obj, Attributes attrs)
	throws NamingException {
	doBind(name, obj, attrs, alwaysUseFactory);
	}

	protected void doBind(Name name, Object obj, Attributes attrs,
	boolean useFactory) throws NamingException {
	if (name.isEmpty()) {
	throw new InvalidNameException("Cannot bind empty name");
	}

	if (useFactory) {
	DirStateFactory.Result res = DirectoryManager.getStateToBind(
	obj, name, this, myEnv, attrs);
	obj = res.getObject();
	attrs = res.getAttributes();
	}

	HierMemDirCtx ctx= (HierMemDirCtx) doLookup(getInternalName(name), false);
	ctx.doBindAux(getLeafName(name), obj);

	if (attrs != null && attrs.size() > 0) {
	modifyAttributes(name, ADD_ATTRIBUTE, attrs);
	}
	}

	protected void doBindAux(Name name, Object obj) throws NamingException {
	if (readOnlyEx != null) {
	throw (NamingException) readOnlyEx.fillInStackTrace();
	}

	if (bindings.get(name) != null) {
	throw new NameAlreadyBoundException(name.toString());
	}
	if(obj instanceof HierMemDirCtx) {
	bindings.put(name, obj);
	} else {
	throw new SchemaViolationException(
	"This context only supports binding objects of it's own kind");
	}
	}

	public void rebind(String name, Object obj) throws NamingException {
	rebind(myParser.parse(name), obj);
	}

	public void rebind(Name name, Object obj) throws NamingException {
	doRebind(name, obj, null, alwaysUseFactory);
	}

	public void rebind(String name, Object obj, Attributes attrs)
	throws NamingException {
	rebind(myParser.parse(name), obj, attrs);
	}

	public void rebind(Name name, Object obj, Attributes attrs)
	throws NamingException {
	doRebind(name, obj, attrs, alwaysUseFactory);
	}

	protected void doRebind(Name name, Object obj, Attributes attrs,
	boolean useFactory) throws NamingException {
	if (name.isEmpty()) {
	throw new InvalidNameException("Cannot rebind empty name");
	}

	if (useFactory) {
	DirStateFactory.Result res = DirectoryManager.getStateToBind(
	obj, name, this, myEnv, attrs);
	obj = res.getObject();
	attrs = res.getAttributes();
	}

	HierMemDirCtx ctx= (HierMemDirCtx) doLookup(getInternalName(name), false);
	ctx.doRebindAux(getLeafName(name), obj);

	//
	// attrs == null -> use attrs from obj
	// attrs != null -> use attrs
	//
	// %%% Strictly speaking, when attrs is non-null, we should
	// take the explicit step of removing obj's attrs.
	// We don't do that currently.

	if (attrs != null && attrs.size() > 0) {
	modifyAttributes(name, ADD_ATTRIBUTE, attrs);
	}
	}

	protected void doRebindAux(Name name, Object obj) throws NamingException {
	if (readOnlyEx != null) {
	throw (NamingException) readOnlyEx.fillInStackTrace();
	}
	if(obj instanceof HierMemDirCtx) {
	bindings.put(name, obj);

	} else {
	throw new SchemaViolationException(
	"This context only supports binding objects of it's own kind");
	}
	}

	public void unbind(String name) throws NamingException {
	unbind(myParser.parse(name));
	}

	public void unbind(Name name) throws NamingException {
	if (name.isEmpty()) {
	throw new InvalidNameException("Cannot unbind empty name");
	} else {
	HierMemDirCtx ctx=
	(HierMemDirCtx) doLookup(getInternalName(name), false);
	ctx.doUnbind(getLeafName(name));
	}
	}

	protected void doUnbind(Name name) throws NamingException {
	if (readOnlyEx != null) {
	throw (NamingException) readOnlyEx.fillInStackTrace();
	}

	bindings.remove(name); // attrs will also be removed along with ctx
	}

	public void rename(String oldname, String newname)
	throws NamingException {
	rename(myParser.parse(oldname), myParser.parse(newname));
	}

	public void rename(Name oldname, Name newname)
	throws NamingException {

	if(newname.isEmpty() \|\| oldname.isEmpty()) {
	throw new InvalidNameException("Cannot rename empty name");
	}

	if (!getInternalName(newname).equals(getInternalName(oldname))) {
	throw new InvalidNameException("Cannot rename across contexts");
	}

	HierMemDirCtx ctx =
	(HierMemDirCtx) doLookup(getInternalName(newname), false);
	ctx.doRename(getLeafName(oldname), getLeafName(newname));
	}

	protected void doRename(Name oldname, Name newname) throws NamingException {
	if (readOnlyEx != null) {
	throw (NamingException) readOnlyEx.fillInStackTrace();
	}

	oldname = canonizeName(oldname);
	newname = canonizeName(newname);

	// Check if new name exists
	if (bindings.get(newname) != null) {
	throw new NameAlreadyBoundException(newname.toString());
	}

	// Check if old name is bound
	Object oldBinding = bindings.remove(oldname);
	if (oldBinding == null) {
	throw new NameNotFoundException(oldname.toString());
	}

	bindings.put(newname, oldBinding);
	}

	public NamingEnumeration<NameClassPair> list(String name) throws NamingException {
	return list(myParser.parse(name));
	}

	public NamingEnumeration<NameClassPair> list(Name name) throws NamingException {
	HierMemDirCtx ctx = (HierMemDirCtx) doLookup(name, false);
	return ctx.doList();
	}

	protected NamingEnumeration<NameClassPair> doList () throws NamingException {
	return new FlatNames(bindings.keys());
	}


	public NamingEnumeration<Binding> listBindings(String name) throws NamingException {
	return listBindings(myParser.parse(name));
	}

	public NamingEnumeration<Binding> listBindings(Name name) throws NamingException {
	HierMemDirCtx ctx = (HierMemDirCtx)doLookup(name, false);
	return ctx.doListBindings(alwaysUseFactory);
	}

	protected NamingEnumeration<Binding> doListBindings(boolean useFactory)
	throws NamingException {
	return new FlatBindings(bindings, myEnv, useFactory);
	}

	public void destroySubcontext(String name) throws NamingException {
	destroySubcontext(myParser.parse(name));
	}

	public void destroySubcontext(Name name) throws NamingException {
	HierMemDirCtx ctx =
	(HierMemDirCtx) doLookup(getInternalName(name), false);
	ctx.doDestroySubcontext(getLeafName(name));
	}

	protected void doDestroySubcontext(Name name) throws NamingException {

	if (readOnlyEx != null) {
	throw (NamingException) readOnlyEx.fillInStackTrace();
	}
	name = canonizeName(name);
	bindings.remove(name);
	}

	public Context createSubcontext(String name) throws NamingException {
	return createSubcontext(myParser.parse(name));
	}

	public Context createSubcontext(Name name) throws NamingException {
	return createSubcontext(name, null);
	}

	public DirContext createSubcontext(String name, Attributes attrs)
	throws NamingException {
	return createSubcontext(myParser.parse(name), attrs);
	}

	public DirContext createSubcontext(Name name, Attributes attrs)
	throws NamingException {
	HierMemDirCtx ctx =
	(HierMemDirCtx) doLookup(getInternalName(name), false);
	return ctx.doCreateSubcontext(getLeafName(name), attrs);
	}

	protected DirContext doCreateSubcontext(Name name, Attributes attrs)
	throws NamingException {
	if (readOnlyEx != null) {
	throw (NamingException) readOnlyEx.fillInStackTrace();
	}

	name = canonizeName(name);

	if (bindings.get(name) != null) {
	throw new NameAlreadyBoundException(name.toString());
	}
	HierMemDirCtx newCtx = createNewCtx();
	bindings.put(name, newCtx);
	if(attrs != null) {
	newCtx.modifyAttributes("", ADD_ATTRIBUTE, attrs);
	}
	return newCtx;
	}


	public Object lookupLink(String name) throws NamingException {
	// This context does not treat links specially
	return lookupLink(myParser.parse(name));
	}

	public Object lookupLink(Name name) throws NamingException {
	// Flat namespace; no federation; just call string version
	return lookup(name);
	}

	public NameParser getNameParser(String name) throws NamingException {
	return myParser;
	}

	public NameParser getNameParser(Name name) throws NamingException {
	return myParser;
	}

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

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

	@SuppressWarnings("unchecked") // clone()
	public Object addToEnvironment(String propName, Object propVal)
	throws NamingException {
	myEnv = (myEnv == null)
	? new Hashtable<String, Object>(11, 0.75f)
	: (Hashtable<String, Object>)myEnv.clone();

	return myEnv.put(propName, propVal);
	}

	@SuppressWarnings("unchecked") // clone()
	public Object removeFromEnvironment(String propName)
	throws NamingException {
	if (myEnv == null)
	return null;

	myEnv = (Hashtable<String, Object>)myEnv.clone();
	return myEnv.remove(propName);
	}

	@SuppressWarnings("unchecked") // clone()
	public Hashtable<String, Object> getEnvironment() throws NamingException {
	if (myEnv == null) {
	return new Hashtable<>(5, 0.75f);
	} else {
	return (Hashtable<String, Object>)myEnv.clone();
	}
	}

	public Attributes getAttributes(String name)
	throws NamingException {
	return getAttributes(myParser.parse(name));
	}

	public Attributes getAttributes(Name name)
	throws NamingException {
	HierMemDirCtx ctx = (HierMemDirCtx) doLookup(name, false);
	return ctx.doGetAttributes();
	}

	protected Attributes doGetAttributes() throws NamingException {
	return (Attributes)attrs.clone();
	}

	public Attributes getAttributes(String name, String[] attrIds)
	throws NamingException {
	return getAttributes(myParser.parse(name), attrIds);
	}

	public Attributes getAttributes(Name name, String[] attrIds)
	throws NamingException {
	HierMemDirCtx ctx = (HierMemDirCtx) doLookup(name, false);
	return ctx.doGetAttributes(attrIds);
	}

	protected Attributes doGetAttributes(String[] attrIds)
	throws NamingException {

	if (attrIds == null) {
	return doGetAttributes();
	}
	Attributes attrs = new BasicAttributes(ignoreCase);
	Attribute attr = null;
	for(int i=0; i<attrIds.length; i++) {
	attr = this.attrs.get(attrIds[i]);
	if (attr != null) {
	attrs.put(attr);
	}
	}
	return attrs;
	}

	public void modifyAttributes(String name, int mod_op, Attributes attrs)
	throws NamingException {
	modifyAttributes(myParser.parse(name), mod_op, attrs);
	}

	public void modifyAttributes(Name name, int mod_op, Attributes attrs)
	throws NamingException {

	if (attrs == null \|\| attrs.size() == 0) {
	throw new IllegalArgumentException(
	"Cannot modify without an attribute");
	}

	// turn it into a modification Enumeration and pass it on
	NamingEnumeration<? extends Attribute> attrEnum = attrs.getAll();
	ModificationItem[] mods = new ModificationItem[attrs.size()];
	for (int i = 0; i < mods.length && attrEnum.hasMoreElements(); i++) {
	mods[i] = new ModificationItem(mod_op, attrEnum.next());
	}

	modifyAttributes(name, mods);
	}

	public void modifyAttributes(String name, ModificationItem[] mods)
	throws NamingException {
	modifyAttributes(myParser.parse(name), mods);
	}

	public void modifyAttributes(Name name, ModificationItem[] mods)
	throws NamingException {
	HierMemDirCtx ctx = (HierMemDirCtx) doLookup(name, false);
	ctx.doModifyAttributes(mods);
	}

	protected void doModifyAttributes(ModificationItem[] mods)
	throws NamingException {

	if (readOnlyEx != null) {
	throw (NamingException) readOnlyEx.fillInStackTrace();
	}

	applyMods(mods, attrs);
	}

	protected static Attributes applyMods(ModificationItem[] mods,
	Attributes orig) throws NamingException {

	ModificationItem mod;
	Attribute existingAttr, modAttr;
	NamingEnumeration<?> modVals;

	for (int i = 0; i < mods.length; i++) {
	mod = mods[i];
	modAttr = mod.getAttribute();

	switch(mod.getModificationOp()) {
	case ADD_ATTRIBUTE:
	if (debug) {
	System.out.println("HierMemDSCtx: adding " +
	mod.getAttribute().toString());
	}
	existingAttr = orig.get(modAttr.getID());
	if (existingAttr == null) {
	orig.put((Attribute)modAttr.clone());
	} else {
	// Add new attribute values to existing attribute
	modVals = modAttr.getAll();
	while (modVals.hasMore()) {
	existingAttr.add(modVals.next());
	}
	}
	break;
	case REPLACE_ATTRIBUTE:
	if (modAttr.size() == 0) {
	orig.remove(modAttr.getID());
	} else {
	orig.put((Attribute)modAttr.clone());
	}
	break;
	case REMOVE_ATTRIBUTE:
	existingAttr = orig.get(modAttr.getID());
	if (existingAttr != null) {
	if (modAttr.size() == 0) {
	orig.remove(modAttr.getID());
	} else {
	// Remove attribute values from existing attribute
	modVals = modAttr.getAll();
	while (modVals.hasMore()) {
	existingAttr.remove(modVals.next());
	}
	if (existingAttr.size() == 0) {
	orig.remove(modAttr.getID());
	}
	}
	}
	break;
	default:
	throw new AttributeModificationException("Unknown mod_op");
	}
	}

	return orig;
	}

	public NamingEnumeration<SearchResult> search(String name,
	Attributes matchingAttributes)
	throws NamingException {
	return search(name, matchingAttributes, null);
	}

	public NamingEnumeration<SearchResult> search(Name name,
	Attributes matchingAttributes)
	throws NamingException {
	return search(name, matchingAttributes, null);
	}

	public NamingEnumeration<SearchResult> search(String name,
	Attributes matchingAttributes,
	String[] attributesToReturn)
	throws NamingException {
	return search(myParser.parse(name), matchingAttributes,
	attributesToReturn);
	}

	public NamingEnumeration<SearchResult> search(Name name,
	Attributes matchingAttributes,
	String[] attributesToReturn)
	throws NamingException {

	HierMemDirCtx target = (HierMemDirCtx) doLookup(name, false);

	SearchControls cons = new SearchControls();
	cons.setReturningAttributes(attributesToReturn);

	return new LazySearchEnumerationImpl(
	target.doListBindings(false),
	new ContainmentFilter(matchingAttributes),
	cons, this, myEnv,
	false); // alwaysUseFactory ignored because objReturnFlag == false
	}

	public NamingEnumeration<SearchResult> search(Name name,
	String filter,
	SearchControls cons)
	throws NamingException {
	DirContext target = (DirContext) doLookup(name, false);

	SearchFilter stringfilter = new SearchFilter(filter);
	return new LazySearchEnumerationImpl(
	new HierContextEnumerator(target,
	(cons != null) ? cons.getSearchScope() :
	SearchControls.ONELEVEL_SCOPE),
	stringfilter,
	cons, this, myEnv, alwaysUseFactory);
	}

	public NamingEnumeration<SearchResult> search(Name name,
	String filterExpr,
	Object[] filterArgs,
	SearchControls cons)
	throws NamingException {

	String strfilter = SearchFilter.format(filterExpr, filterArgs);
	return search(name, strfilter, cons);
	}

	public NamingEnumeration<SearchResult> search(String name,
	String filter,
	SearchControls cons)
	throws NamingException {
	return search(myParser.parse(name), filter, cons);
	}

	public NamingEnumeration<SearchResult> search(String name,
	String filterExpr,
	Object[] filterArgs,
	SearchControls cons)
	throws NamingException {
	return search(myParser.parse(name), filterExpr, filterArgs, cons);
	}

	// This function is called whenever a new object needs to be created.
	// this is used so that if anyone subclasses us, they can override this
	// and return object of their own kind.
	protected HierMemDirCtx createNewCtx() throws NamingException {
	return new HierMemDirCtx(myEnv, ignoreCase);
	}

	// If the supplied name is a composite name, return the name that
	// is its first component.
	protected Name canonizeName(Name name) throws NamingException {
	Name canonicalName = name;

	if(!(name instanceof HierarchicalName)) {
	// If name is not of the correct type, make copy
	canonicalName = new HierarchicalName();
	int n = name.size();
	for(int i = 0; i < n; i++) {
	canonicalName.add(i, name.get(i));
	}
	}

	return canonicalName;
	}

	protected Name getInternalName(Name name) throws NamingException {
	return (name.getPrefix(name.size() - 1));
	}

	protected Name getLeafName(Name name) throws NamingException {
	return (name.getSuffix(name.size() - 1));
	}


	public DirContext getSchema(String name) throws NamingException {
	throw new OperationNotSupportedException();
	}

	public DirContext getSchema(Name name) throws NamingException {
	throw new OperationNotSupportedException();
	}

	public DirContext getSchemaClassDefinition(String name)
	throws NamingException {
	throw new OperationNotSupportedException();
	}

	public DirContext getSchemaClassDefinition(Name name)
	throws NamingException {
	throw new OperationNotSupportedException();
	}

	// Set context in readonly mode; throw e when update operation attempted.
	public void setReadOnly(NamingException e) {
	readOnlyEx = e;
	}

	// Set context to support case-insensitive names
	public void setIgnoreCase(boolean ignoreCase) {
	this.ignoreCase = ignoreCase;
	}

	public void setNameParser(NameParser parser) {
	myParser = parser;
	}

	/*
	* Common base class for FlatNames and FlatBindings.
	*/
	private abstract class BaseFlatNames<T> implements NamingEnumeration<T> {
	Enumeration<Name> names;

	BaseFlatNames (Enumeration<Name> names) {
	this.names = names;
	}

	public final boolean hasMoreElements() {
	try {
	return hasMore();
	} catch (NamingException e) {
	return false;
	}
	}

	public final boolean hasMore() throws NamingException {
	return names.hasMoreElements();
	}

	public final T nextElement() {
	try {
	return next();
	} catch (NamingException e) {
	throw new NoSuchElementException(e.toString());
	}
	}

	public abstract T next() throws NamingException;

	public final void close() {
	names = null;
	}
	}

	// Class for enumerating name/class pairs
	private final class FlatNames extends BaseFlatNames<NameClassPair> {
	FlatNames (Enumeration<Name> names) {
	super(names);
	}

	@Override
	public NameClassPair next() throws NamingException {
	Name name = names.nextElement();
	String className = bindings.get(name).getClass().getName();
	return new NameClassPair(name.toString(), className);
	}
	}

	// Class for enumerating bindings
	private final class FlatBindings extends BaseFlatNames<Binding> {
	private Hashtable<Name, Object> bds;
	private Hashtable<String, Object> env;
	private boolean useFactory;

	FlatBindings(Hashtable<Name, Object> bindings,
	Hashtable<String, Object> env,
	boolean useFactory) {
	super(bindings.keys());
	this.env = env;
	this.bds = bindings;
	this.useFactory = useFactory;
	}

	@Override
	public Binding next() throws NamingException {
	Name name = names.nextElement();

	HierMemDirCtx obj = (HierMemDirCtx)bds.get(name);

	Object answer = obj;
	if (useFactory) {
	Attributes attrs = obj.getAttributes(""); // only method available
	try {
	answer = DirectoryManager.getObjectInstance(obj,
	name, HierMemDirCtx.this, env, attrs);
	} catch (NamingException e) {
	throw e;
	} catch (Exception e) {
	NamingException e2 = new NamingException(
	"Problem calling getObjectInstance");
	e2.setRootCause(e);
	throw e2;
	}
	}

	return new Binding(name.toString(), answer);
	}
	}

	public class HierContextEnumerator extends ContextEnumerator {
	public HierContextEnumerator(Context context, int scope)
	throws NamingException {
	super(context, scope);
	}

	protected HierContextEnumerator(Context context, int scope,
	String contextName, boolean returnSelf) throws NamingException {
	super(context, scope, contextName, returnSelf);
	}

	protected NamingEnumeration<Binding> getImmediateChildren(Context ctx)
	throws NamingException {
	return ((HierMemDirCtx)ctx).doListBindings(false);
	}

	protected ContextEnumerator newEnumerator(Context ctx, int scope,
	String contextName, boolean returnSelf) throws NamingException {
	return new HierContextEnumerator(ctx, scope, contextName,
	returnSelf);
	}
	}
	}

	// CompundNames's HashCode() method isn't good enough for many string.
	// The only prupose of this subclass is to have a more discerning
	// hash function. We'll make up for the performance hit by caching
	// the hash value.

	final class HierarchicalName extends CompoundName {
	private int hashValue = -1;

	// Creates an empty name
	HierarchicalName() {
	super(new Enumeration<String>() {
	public boolean hasMoreElements() {return false;}
	public String nextElement() {throw new NoSuchElementException();}
	},
	HierarchicalNameParser.mySyntax);
	}

	HierarchicalName(Enumeration<String> comps, Properties syntax) {
	super(comps, syntax);
	}

	HierarchicalName(String n, Properties syntax) throws InvalidNameException {
	super(n, syntax);
	}

	// just like String.hashCode, only it pays no attention to length
	public int hashCode() {
	if (hashValue == -1) {

	String name = toString().toUpperCase(Locale.ENGLISH);
	int len = name.length();
	int off = 0;
	char val[] = new char[len];

	name.getChars(0, len, val, 0);

	for (int i = len; i > 0; i--) {
	hashValue = (hashValue * 37) + val[off++];
	}
	}

	return hashValue;
	}

	public Name getPrefix(int posn) {
	Enumeration<String> comps = super.getPrefix(posn).getAll();
	return (new HierarchicalName(comps, mySyntax));
	}

	public Name getSuffix(int posn) {
	Enumeration<String> comps = super.getSuffix(posn).getAll();
	return (new HierarchicalName(comps, mySyntax));
	}

	public Object clone() {
	return (new HierarchicalName(getAll(), mySyntax));
	}

	private static final long serialVersionUID = -6717336834584573168L;
	}

	// This is the default name parser (used if setNameParser is not called)
	final class HierarchicalNameParser implements NameParser {
	static final Properties mySyntax = new Properties();
	static {
	mySyntax.put("jndi.syntax.direction", "left_to_right");
	mySyntax.put("jndi.syntax.separator", "/");
	mySyntax.put("jndi.syntax.ignorecase", "true");
	mySyntax.put("jndi.syntax.escape", "\\");
	mySyntax.put("jndi.syntax.beginquote", "\"");
	//mySyntax.put("jndi.syntax.separator.ava", "+");
	//mySyntax.put("jndi.syntax.separator.typeval", "=");
	mySyntax.put("jndi.syntax.trimblanks", "false");
	};

	public Name parse(String name) throws NamingException {
	return new HierarchicalName(name, mySyntax);
	}
	}

Back to index...