Java tutorial
/* * Copyright (c) 1999, 2017, 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.directory; import java.util.Hashtable; import java.util.Enumeration; import java.util.Locale; import javax.naming.NamingException; import javax.naming.NamingEnumeration; /** * This class provides a basic implementation * of the Attributes interface. *<p> * BasicAttributes is either case-sensitive or case-insensitive (case-ignore). * This property is determined at the time the BasicAttributes constructor * is called. * In a case-insensitive BasicAttributes, the case of its attribute identifiers * is ignored when searching for an attribute, or adding attributes. * In a case-sensitive BasicAttributes, the case is significant. *<p> * When the BasicAttributes class needs to create an Attribute, it * uses BasicAttribute. There is no other dependency on BasicAttribute. *<p> * Note that updates to BasicAttributes (such as adding or removing an attribute) * does not affect the corresponding representation in the directory. * Updates to the directory can only be effected * using operations in the DirContext interface. *<p> * A BasicAttributes instance is not synchronized against concurrent * multithreaded access. Multiple threads trying to access and modify * a single BasicAttributes instance should lock the object. * * @author Rosanna Lee * @author Scott Seligman * * @see DirContext#getAttributes * @see DirContext#modifyAttributes * @see DirContext#bind * @see DirContext#rebind * @see DirContext#createSubcontext * @see DirContext#search * @since 1.3 */ public class BasicAttributes implements Attributes { /** * Indicates whether case of attribute ids is ignored. * @serial */ private boolean ignoreCase = false; // The 'key' in attrs is stored in the 'right case'. // If ignoreCase is true, key is aways lowercase. // If ignoreCase is false, key is stored as supplied by put(). // %%% Not declared "private" due to bug 4064984. transient Hashtable<String, Attribute> attrs = new Hashtable<>(11); /** * Constructs a new instance of Attributes. * The character case of attribute identifiers * is significant when subsequently retrieving or adding attributes. */ public BasicAttributes() { } /** * Constructs a new instance of Attributes. * If <code>ignoreCase</code> is true, the character case of attribute * identifiers is ignored; otherwise the case is significant. * @param ignoreCase true means this attribute set will ignore * the case of its attribute identifiers * when retrieving or adding attributes; * false means case is respected. */ public BasicAttributes(boolean ignoreCase) { this.ignoreCase = ignoreCase; } /** * Constructs a new instance of Attributes with one attribute. * The attribute specified by attrID and val are added to the newly * created attribute. * The character case of attribute identifiers * is significant when subsequently retrieving or adding attributes. * @param attrID non-null The id of the attribute to add. * @param val The value of the attribute to add. If null, a null * value is added to the attribute. */ public BasicAttributes(String attrID, Object val) { this(); this.put(new BasicAttribute(attrID, val)); } /** * Constructs a new instance of Attributes with one attribute. * The attribute specified by attrID and val are added to the newly * created attribute. * If <code>ignoreCase</code> is true, the character case of attribute * identifiers is ignored; otherwise the case is significant. * @param attrID non-null The id of the attribute to add. * If this attribute set ignores the character * case of its attribute ids, the case of attrID * is ignored. * @param val The value of the attribute to add. If null, a null * value is added to the attribute. * @param ignoreCase true means this attribute set will ignore * the case of its attribute identifiers * when retrieving or adding attributes; * false means case is respected. */ public BasicAttributes(String attrID, Object val, boolean ignoreCase) { this(ignoreCase); this.put(new BasicAttribute(attrID, val)); } @SuppressWarnings("unchecked") public Object clone() { BasicAttributes attrset; try { attrset = (BasicAttributes) super.clone(); } catch (CloneNotSupportedException e) { attrset = new BasicAttributes(ignoreCase); } attrset.attrs = (Hashtable<String, Attribute>) attrs.clone(); return attrset; } public boolean isCaseIgnored() { return ignoreCase; } public int size() { return attrs.size(); } public Attribute get(String attrID) { Attribute attr = attrs.get(ignoreCase ? attrID.toLowerCase(Locale.ENGLISH) : attrID); return (attr); } public NamingEnumeration<Attribute> getAll() { return new AttrEnumImpl(); } public NamingEnumeration<String> getIDs() { return new IDEnumImpl(); } public Attribute put(String attrID, Object val) { return this.put(new BasicAttribute(attrID, val)); } public Attribute put(Attribute attr) { String id = attr.getID(); if (ignoreCase) { id = id.toLowerCase(Locale.ENGLISH); } return attrs.put(id, attr); } public Attribute remove(String attrID) { String id = (ignoreCase ? attrID.toLowerCase(Locale.ENGLISH) : attrID); return attrs.remove(id); } /** * Generates the string representation of this attribute set. * The string consists of each attribute identifier and the contents * of each attribute. The contents of this string is useful * for debugging and is not meant to be interpreted programmatically. * * @return A non-null string listing the contents of this attribute set. */ public String toString() { if (attrs.size() == 0) { return ("No attributes"); } else { return attrs.toString(); } } /** * Determines whether this {@code BasicAttributes} is equal to another * {@code Attributes} * Two {@code Attributes} are equal if they are both instances of * {@code Attributes}, * treat the case of attribute IDs the same way, and contain the * same attributes. Each {@code Attribute} in this {@code BasicAttributes} * is checked for equality using {@code Object.equals()}, which may have * be overridden by implementations of {@code Attribute}). * If a subclass overrides {@code equals()}, * it should override {@code hashCode()} * as well so that two {@code Attributes} instances that are equal * have the same hash code. * @param obj the possibly null object to compare against. * * @return true If obj is equal to this BasicAttributes. * @see #hashCode */ public boolean equals(Object obj) { if ((obj != null) && (obj instanceof Attributes)) { Attributes target = (Attributes) obj; // Check case first if (ignoreCase != target.isCaseIgnored()) { return false; } if (size() == target.size()) { Attribute their, mine; try { NamingEnumeration<?> theirs = target.getAll(); while (theirs.hasMore()) { their = (Attribute) theirs.next(); mine = get(their.getID()); if (!their.equals(mine)) { return false; } } } catch (NamingException e) { return false; } return true; } } return false; } /** * Calculates the hash code of this BasicAttributes. *<p> * The hash code is computed by adding the hash code of * the attributes of this object. If this BasicAttributes * ignores case of its attribute IDs, one is added to the hash code. * If a subclass overrides {@code hashCode()}, * it should override {@code equals()} * as well so that two {@code Attributes} instances that are equal * have the same hash code. * * @return an int representing the hash code of this BasicAttributes instance. * @see #equals */ public int hashCode() { int hash = (ignoreCase ? 1 : 0); try { NamingEnumeration<?> all = getAll(); while (all.hasMore()) { hash += all.next().hashCode(); } } catch (NamingException e) { } return hash; } /** * Overridden to avoid exposing implementation details. * @serialData Default field (ignoreCase flag -- a boolean), followed by * the number of attributes in the set * (an int), and then the individual Attribute objects. */ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException { s.defaultWriteObject(); // write out the ignoreCase flag s.writeInt(attrs.size()); Enumeration<Attribute> attrEnum = attrs.elements(); while (attrEnum.hasMoreElements()) { s.writeObject(attrEnum.nextElement()); } } /** * Overridden to avoid exposing implementation details. */ private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { s.defaultReadObject(); // read in the ignoreCase flag int n = s.readInt(); // number of attributes attrs = (n >= 1) ? new Hashtable<>(1 + (int) (Math.min(768, n) / .75f)) : new Hashtable<>(2); // can't have initial size of 0 (grrr...) while (--n >= 0) { put((Attribute) s.readObject()); } } class AttrEnumImpl implements NamingEnumeration<Attribute> { Enumeration<Attribute> elements; public AttrEnumImpl() { this.elements = attrs.elements(); } public boolean hasMoreElements() { return elements.hasMoreElements(); } public Attribute nextElement() { return elements.nextElement(); } public boolean hasMore() throws NamingException { return hasMoreElements(); } public Attribute next() throws NamingException { return nextElement(); } public void close() throws NamingException { elements = null; } } class IDEnumImpl implements NamingEnumeration<String> { Enumeration<Attribute> elements; public IDEnumImpl() { // Walking through the elements, rather than the keys, gives // us attribute IDs that have not been converted to lowercase. this.elements = attrs.elements(); } public boolean hasMoreElements() { return elements.hasMoreElements(); } public String nextElement() { Attribute attr = elements.nextElement(); return attr.getID(); } public boolean hasMore() throws NamingException { return hasMoreElements(); } public String next() throws NamingException { return nextElement(); } public void close() throws NamingException { elements = null; } } /** * Use serialVersionUID from JNDI 1.1.1 for interoperability. */ private static final long serialVersionUID = 4980164073184639448L; }