/*
 * Copyright (c) 1999, 2002, 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 javax.naming;

import java.util.Vector;
import java.util.Enumeration;
import java.util.Properties;
import java.util.NoSuchElementException;

The implementation class for CompoundName and CompositeName. This class is package private.
Author:Rosanna Lee, Scott Seligman, Aravindan Ranganathan
Since:1.3
/** * The implementation class for CompoundName and CompositeName. * This class is package private. * * @author Rosanna Lee * @author Scott Seligman * @author Aravindan Ranganathan * @since 1.3 */
class NameImpl { private static final byte LEFT_TO_RIGHT = 1; private static final byte RIGHT_TO_LEFT = 2; private static final byte FLAT = 0; private Vector components; private byte syntaxDirection = LEFT_TO_RIGHT; private String syntaxSeparator = "/"; private String syntaxSeparator2 = null; private boolean syntaxCaseInsensitive = false; private boolean syntaxTrimBlanks = false; private String syntaxEscape = "\\"; private String syntaxBeginQuote1 = "\""; private String syntaxEndQuote1 = "\""; private String syntaxBeginQuote2 = "'"; private String syntaxEndQuote2 = "'"; private String syntaxAvaSeparator = null; private String syntaxTypevalSeparator = null; // escapingStyle gives the method used at creation time for // quoting or escaping characters in the name. It is set to the // first style of quote or escape encountered if and when the name // is parsed. private static final int STYLE_NONE = 0; private static final int STYLE_QUOTE1 = 1; private static final int STYLE_QUOTE2 = 2; private static final int STYLE_ESCAPE = 3; private int escapingStyle = STYLE_NONE; // Returns true if "match" is not null, and n contains "match" at // position i. private final boolean isA(String n, int i, String match) { return (match != null && n.startsWith(match, i)); } private final boolean isMeta(String n, int i) { return (isA(n, i, syntaxEscape) || isA(n, i, syntaxBeginQuote1) || isA(n, i, syntaxBeginQuote2) || isSeparator(n, i)); } private final boolean isSeparator(String n, int i) { return (isA(n, i, syntaxSeparator) || isA(n, i, syntaxSeparator2)); } private final int skipSeparator(String name, int i) { if (isA(name, i, syntaxSeparator)) { i += syntaxSeparator.length(); } else if (isA(name, i, syntaxSeparator2)) { i += syntaxSeparator2.length(); } return (i); } private final int extractComp(String name, int i, int len, Vector comps) throws InvalidNameException { String beginQuote; String endQuote; boolean start = true; boolean one = false; StringBuffer answer = new StringBuffer(len); while (i < len) { // handle quoted strings if (start && ((one = isA(name, i, syntaxBeginQuote1)) || isA(name, i, syntaxBeginQuote2))) { // record choice of quote chars being used beginQuote = one ? syntaxBeginQuote1 : syntaxBeginQuote2; endQuote = one ? syntaxEndQuote1 : syntaxEndQuote2; if (escapingStyle == STYLE_NONE) { escapingStyle = one ? STYLE_QUOTE1 : STYLE_QUOTE2; } // consume string until matching quote for (i += beginQuote.length(); ((i < len) && !name.startsWith(endQuote, i)); i++) { // skip escape character if it is escaping ending quote // otherwise leave as is. if (isA(name, i, syntaxEscape) && isA(name, i + syntaxEscape.length(), endQuote)) { i += syntaxEscape.length(); } answer.append(name.charAt(i)); // copy char } // no ending quote found if (i >= len) throw new InvalidNameException(name + ": no close quote"); // new Exception("no close quote"); i += endQuote.length(); // verify that end-quote occurs at separator or end of string if (i == len || isSeparator(name, i)) { break; } // throw (new Exception( throw (new InvalidNameException(name + ": close quote appears before end of component")); } else if (isSeparator(name, i)) { break; } else if (isA(name, i, syntaxEscape)) { if (isMeta(name, i + syntaxEscape.length())) { // if escape precedes meta, consume escape and let // meta through i += syntaxEscape.length(); if (escapingStyle == STYLE_NONE) { escapingStyle = STYLE_ESCAPE; } } else if (i + syntaxEscape.length() >= len) { throw (new InvalidNameException(name + ": unescaped " + syntaxEscape + " at end of component")); } } else if (isA(name, i, syntaxTypevalSeparator) && ((one = isA(name, i+syntaxTypevalSeparator.length(), syntaxBeginQuote1)) || isA(name, i+syntaxTypevalSeparator.length(), syntaxBeginQuote2))) { // Handle quote occurring after typeval separator beginQuote = one ? syntaxBeginQuote1 : syntaxBeginQuote2; endQuote = one ? syntaxEndQuote1 : syntaxEndQuote2; i += syntaxTypevalSeparator.length(); answer.append(syntaxTypevalSeparator+beginQuote); // add back // consume string until matching quote for (i += beginQuote.length(); ((i < len) && !name.startsWith(endQuote, i)); i++) { // skip escape character if it is escaping ending quote // otherwise leave as is. if (isA(name, i, syntaxEscape) && isA(name, i + syntaxEscape.length(), endQuote)) { i += syntaxEscape.length(); } answer.append(name.charAt(i)); // copy char } // no ending quote found if (i >= len) throw new InvalidNameException(name + ": typeval no close quote"); i += endQuote.length(); answer.append(endQuote); // add back // verify that end-quote occurs at separator or end of string if (i == len || isSeparator(name, i)) { break; } throw (new InvalidNameException(name.substring(i) + ": typeval close quote appears before end of component")); } answer.append(name.charAt(i++)); start = false; } if (syntaxDirection == RIGHT_TO_LEFT) comps.insertElementAt(answer.toString(), 0); else comps.addElement(answer.toString()); return i; } private static boolean getBoolean(Properties p, String name) { return toBoolean(p.getProperty(name)); } private static boolean toBoolean(String name) { return ((name != null) && name.toLowerCase().equals("true")); } private final void recordNamingConvention(Properties p) { String syntaxDirectionStr = p.getProperty("jndi.syntax.direction", "flat"); if (syntaxDirectionStr.equals("left_to_right")) { syntaxDirection = LEFT_TO_RIGHT; } else if (syntaxDirectionStr.equals("right_to_left")) { syntaxDirection = RIGHT_TO_LEFT; } else if (syntaxDirectionStr.equals("flat")) { syntaxDirection = FLAT; } else { throw new IllegalArgumentException(syntaxDirectionStr + "is not a valid value for the jndi.syntax.direction property"); } if (syntaxDirection != FLAT) { syntaxSeparator = p.getProperty("jndi.syntax.separator"); syntaxSeparator2 = p.getProperty("jndi.syntax.separator2"); if (syntaxSeparator == null) { throw new IllegalArgumentException( "jndi.syntax.separator property required for non-flat syntax"); } } else { syntaxSeparator = null; } syntaxEscape = p.getProperty("jndi.syntax.escape"); syntaxCaseInsensitive = getBoolean(p, "jndi.syntax.ignorecase"); syntaxTrimBlanks = getBoolean(p, "jndi.syntax.trimblanks"); syntaxBeginQuote1 = p.getProperty("jndi.syntax.beginquote"); syntaxEndQuote1 = p.getProperty("jndi.syntax.endquote"); if (syntaxEndQuote1 == null && syntaxBeginQuote1 != null) syntaxEndQuote1 = syntaxBeginQuote1; else if (syntaxBeginQuote1 == null && syntaxEndQuote1 != null) syntaxBeginQuote1 = syntaxEndQuote1; syntaxBeginQuote2 = p.getProperty("jndi.syntax.beginquote2"); syntaxEndQuote2 = p.getProperty("jndi.syntax.endquote2"); if (syntaxEndQuote2 == null && syntaxBeginQuote2 != null) syntaxEndQuote2 = syntaxBeginQuote2; else if (syntaxBeginQuote2 == null && syntaxEndQuote2 != null) syntaxBeginQuote2 = syntaxEndQuote2; syntaxAvaSeparator = p.getProperty("jndi.syntax.separator.ava"); syntaxTypevalSeparator = p.getProperty("jndi.syntax.separator.typeval"); } NameImpl(Properties syntax) { if (syntax != null) { recordNamingConvention(syntax); } components = new Vector(); } NameImpl(Properties syntax, String n) throws InvalidNameException { this(syntax); boolean rToL = (syntaxDirection == RIGHT_TO_LEFT); boolean compsAllEmpty = true; int len = n.length(); for (int i = 0; i < len; ) { i = extractComp(n, i, len, components); String comp = rToL ? (String)components.firstElement() : (String)components.lastElement(); if (comp.length() >= 1) { compsAllEmpty = false; } if (i < len) { i = skipSeparator(n, i); if ((i == len) && !compsAllEmpty) { // Trailing separator found. Add an empty component. if (rToL) { components.insertElementAt("", 0); } else { components.addElement(""); } } } } } NameImpl(Properties syntax, Enumeration comps) { this(syntax); // %% comps could shrink in the middle. while (comps.hasMoreElements()) components.addElement(comps.nextElement()); } /* // Determines whether this component needs any escaping. private final boolean escapingNeeded(String comp) { int len = comp.length(); for (int i = 0; i < len; i++) { if (i == 0) { if (isA(comp, 0, syntaxBeginQuote1) || isA(comp, 0, syntaxBeginQuote2)) { return (true); } } if (isSeparator(comp, i)) { return (true); } if (isA(comp, i, syntaxEscape)) { i += syntaxEscape.length(); if (i >= len || isMeta(comp, i)) { return (true); } } } return (false); } */ private final String stringifyComp(String comp) { int len = comp.length(); boolean escapeSeparator = false, escapeSeparator2 = false; String beginQuote = null, endQuote = null; StringBuffer strbuf = new StringBuffer(len); // determine whether there are any separators; if so escape // or quote them if (syntaxSeparator != null && comp.indexOf(syntaxSeparator) >= 0) { if (syntaxBeginQuote1 != null) { beginQuote = syntaxBeginQuote1; endQuote = syntaxEndQuote1; } else if (syntaxBeginQuote2 != null) { beginQuote = syntaxBeginQuote2; endQuote = syntaxEndQuote2; } else if (syntaxEscape != null) escapeSeparator = true; } if (syntaxSeparator2 != null && comp.indexOf(syntaxSeparator2) >= 0) { if (syntaxBeginQuote1 != null) { if (beginQuote == null) { beginQuote = syntaxBeginQuote1; endQuote = syntaxEndQuote1; } } else if (syntaxBeginQuote2 != null) { if (beginQuote == null) { beginQuote = syntaxBeginQuote2; endQuote = syntaxEndQuote2; } } else if (syntaxEscape != null) escapeSeparator2 = true; } // if quoting component, if (beginQuote != null) { // start string off with opening quote strbuf = strbuf.append(beginQuote); // component is being quoted, so we only need to worry about // escaping end quotes that occur in component for (int i = 0; i < len; ) { if (comp.startsWith(endQuote, i)) { // end-quotes must be escaped when inside a quoted string strbuf.append(syntaxEscape).append(endQuote); i += endQuote.length(); } else { // no special treatment required strbuf.append(comp.charAt(i++)); } } // end with closing quote strbuf.append(endQuote); } else { // When component is not quoted, add escape for: // 1. leading quote // 2. an escape preceding any meta char // 3. an escape at the end of a component // 4. separator // go through characters in component and escape where necessary boolean start = true; for (int i = 0; i < len; ) { // leading quote must be escaped if (start && isA(comp, i, syntaxBeginQuote1)) { strbuf.append(syntaxEscape).append(syntaxBeginQuote1); i += syntaxBeginQuote1.length(); } else if (start && isA(comp, i, syntaxBeginQuote2)) { strbuf.append(syntaxEscape).append(syntaxBeginQuote2); i += syntaxBeginQuote2.length(); } else // Escape an escape preceding meta characters, or at end. // Other escapes pass through. if (isA(comp, i, syntaxEscape)) { if (i + syntaxEscape.length() >= len) { // escape an ending escape strbuf.append(syntaxEscape); } else if (isMeta(comp, i + syntaxEscape.length())) { // escape meta strings strbuf.append(syntaxEscape); } strbuf.append(syntaxEscape); i += syntaxEscape.length(); } else // escape unescaped separator if (escapeSeparator && comp.startsWith(syntaxSeparator, i)) { // escape separator strbuf.append(syntaxEscape).append(syntaxSeparator); i += syntaxSeparator.length(); } else if (escapeSeparator2 && comp.startsWith(syntaxSeparator2, i)) { // escape separator2 strbuf.append(syntaxEscape).append(syntaxSeparator2); i += syntaxSeparator2.length(); } else { // no special treatment required strbuf.append(comp.charAt(i++)); } start = false; } } return (strbuf.toString()); } public String toString() { StringBuffer answer = new StringBuffer(); String comp; boolean compsAllEmpty = true; int size = components.size(); for (int i = 0; i < size; i++) { if (syntaxDirection == RIGHT_TO_LEFT) { comp = stringifyComp((String) components.elementAt(size - 1 - i)); } else { comp = stringifyComp((String) components.elementAt(i)); } if ((i != 0) && (syntaxSeparator != null)) answer.append(syntaxSeparator); if (comp.length() >= 1) compsAllEmpty = false; answer = answer.append(comp); } if (compsAllEmpty && (size >= 1) && (syntaxSeparator != null)) answer = answer.append(syntaxSeparator); return (answer.toString()); } public boolean equals(Object obj) { if ((obj != null) && (obj instanceof NameImpl)) { NameImpl target = (NameImpl)obj; if (target.size() == this.size()) { Enumeration mycomps = getAll(); Enumeration comps = target.getAll(); while (mycomps.hasMoreElements()) { // %% comps could shrink in the middle. String my = (String)mycomps.nextElement(); String his = (String)comps.nextElement(); if (syntaxTrimBlanks) { my = my.trim(); his = his.trim(); } if (syntaxCaseInsensitive) { if (!(my.equalsIgnoreCase(his))) return false; } else { if (!(my.equals(his))) return false; } } return true; } } return false; }
Compares obj to this NameImpl to determine ordering. Takes into account syntactic properties such as elimination of blanks, case-ignore, etc, if relevant. Note: using syntax of this NameImpl and ignoring that of comparison target.
/** * Compares obj to this NameImpl to determine ordering. * Takes into account syntactic properties such as * elimination of blanks, case-ignore, etc, if relevant. * * Note: using syntax of this NameImpl and ignoring * that of comparison target. */
public int compareTo(NameImpl obj) { if (this == obj) { return 0; } int len1 = size(); int len2 = obj.size(); int n = Math.min(len1, len2); int index1 = 0, index2 = 0; while (n-- != 0) { String comp1 = get(index1++); String comp2 = obj.get(index2++); // normalize according to syntax if (syntaxTrimBlanks) { comp1 = comp1.trim(); comp2 = comp2.trim(); } if (syntaxCaseInsensitive) { comp1 = comp1.toLowerCase(); comp2 = comp2.toLowerCase(); } int local = comp1.compareTo(comp2); if (local != 0) { return local; } } return len1 - len2; } public int size() { return (components.size()); } public Enumeration getAll() { return components.elements(); } public String get(int posn) { return ((String) components.elementAt(posn)); } public Enumeration getPrefix(int posn) { if (posn < 0 || posn > size()) { throw new ArrayIndexOutOfBoundsException(posn); } return new NameImplEnumerator(components, 0, posn); } public Enumeration getSuffix(int posn) { int cnt = size(); if (posn < 0 || posn > cnt) { throw new ArrayIndexOutOfBoundsException(posn); } return new NameImplEnumerator(components, posn, cnt); } public boolean isEmpty() { return (components.isEmpty()); } public boolean startsWith(int posn, Enumeration prefix) { if (posn < 0 || posn > size()) { return false; } try { Enumeration mycomps = getPrefix(posn); while (mycomps.hasMoreElements()) { String my = (String)mycomps.nextElement(); String his = (String)prefix.nextElement(); if (syntaxTrimBlanks) { my = my.trim(); his = his.trim(); } if (syntaxCaseInsensitive) { if (!(my.equalsIgnoreCase(his))) return false; } else { if (!(my.equals(his))) return false; } } } catch (NoSuchElementException e) { return false; } return true; } public boolean endsWith(int posn, Enumeration suffix) { // posn is number of elements in suffix // startIndex is the starting position in this name // at which to start the comparison. It is calculated by // subtracting 'posn' from size() int startIndex = size() - posn; if (startIndex < 0 || startIndex > size()) { return false; } try { Enumeration mycomps = getSuffix(startIndex); while (mycomps.hasMoreElements()) { String my = (String)mycomps.nextElement(); String his = (String)suffix.nextElement(); if (syntaxTrimBlanks) { my = my.trim(); his = his.trim(); } if (syntaxCaseInsensitive) { if (!(my.equalsIgnoreCase(his))) return false; } else { if (!(my.equals(his))) return false; } } } catch (NoSuchElementException e) { return false; } return true; } public boolean addAll(Enumeration comps) throws InvalidNameException { boolean added = false; while (comps.hasMoreElements()) { try { Object comp = comps.nextElement(); if (size() > 0 && syntaxDirection == FLAT) { throw new InvalidNameException( "A flat name can only have a single component"); } components.addElement(comp); added = true; } catch (NoSuchElementException e) { break; // "comps" has shrunk. } } return added; } public boolean addAll(int posn, Enumeration comps) throws InvalidNameException { boolean added = false; for (int i = posn; comps.hasMoreElements(); i++) { try { Object comp = comps.nextElement(); if (size() > 0 && syntaxDirection == FLAT) { throw new InvalidNameException( "A flat name can only have a single component"); } components.insertElementAt(comp, i); added = true; } catch (NoSuchElementException e) { break; // "comps" has shrunk. } } return added; } public void add(String comp) throws InvalidNameException { if (size() > 0 && syntaxDirection == FLAT) { throw new InvalidNameException( "A flat name can only have a single component"); } components.addElement(comp); } public void add(int posn, String comp) throws InvalidNameException { if (size() > 0 && syntaxDirection == FLAT) { throw new InvalidNameException( "A flat name can only zero or one component"); } components.insertElementAt(comp, posn); } public Object remove(int posn) { Object r = components.elementAt(posn); components.removeElementAt(posn); return r; } public int hashCode() { int hash = 0; for (Enumeration e = getAll(); e.hasMoreElements();) { String comp = (String)e.nextElement(); if (syntaxTrimBlanks) { comp = comp.trim(); } if (syntaxCaseInsensitive) { comp = comp.toLowerCase(); } hash += comp.hashCode(); } return hash; } } final class NameImplEnumerator implements Enumeration { Vector vector; int count; int limit; NameImplEnumerator(Vector v, int start, int lim) { vector = v; count = start; limit = lim; } public boolean hasMoreElements() { return count < limit; } public Object nextElement() { if (count < limit) { return vector.elementAt(count++); } throw new NoSuchElementException("NameImplEnumerator"); } }