jdk8-mips64-public/jaxws: comparison src/share/jaxws_classes/com/sun/xml/internal/ws/util/QNameMap.java

--1:000000000000
+:373ffda63c9a
+/*
+* Copyright (c) 1997, 2012, 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.xml.internal.ws.util;
+import com.sun.istack.internal.NotNull;
+import javax.xml.namespace.QName;
+import java.util.AbstractSet;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+/**
+* Map keyed by {@link QName}.
+*
+* This specialized map allows a look up operation without constructing
+* a new QName instance, for a performance reason. This {@link Map} assumes
+* that both namespace URI and local name are {@link String#intern() intern}ed.
+*
+* @since JAXB 2.0
+*/
+public final class QNameMap<V> {
+/**
+* The default initial capacity - MUST be a power of two.
+*/
+private static final int DEFAULT_INITIAL_CAPACITY = 16;
+/**
+* The maximum capacity, used if a higher value is implicitly specified
+* by either of the constructors with arguments.
+* MUST be a power of two <= 1<<30.
+*/
+private static final int MAXIMUM_CAPACITY = 1 << 30;
+/**
+* The table, resized as necessary. Length MUST Always be a power of two.
+*/
+transient Entry<V>[] table = new Entry[DEFAULT_INITIAL_CAPACITY];
+/**
+* The number of key-value mappings contained in this identity hash map.
+*/
+transient int size;
+/**
+* The next size value at which to resize . Taking it as
+* MAXIMUM_CAPACITY
+* @serial
+*/
+private int threshold;
+/**
+* The load factor used when none specified in constructor.
+**/
+private static final float DEFAULT_LOAD_FACTOR = 0.75f;
+/**
+* Gives an entrySet view of this map
+*/
+private Set<Entry<V>> entrySet = null;
+public QNameMap() {
+threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
+table = new Entry[DEFAULT_INITIAL_CAPACITY];
+}
+/**
+* Associates the specified value with the specified keys in this map.
+* If the map previously contained a mapping for this key, the old
+* value is replaced.
+*
+* @param namespaceUri First key with which the specified value is to be associated.
+* @param localname Second key with which the specified value is to be associated.
+* @param value value to be associated with the specified key.
+*
+*/
+public void put(String namespaceUri,String localname, V value ) {
+//keys cannot be null
+assert localname !=null;
+assert namespaceUri !=null;
+int hash = hash(localname);
+int i = indexFor(hash, table.length);
+for (Entry<V> e = table[i]; e != null; e = e.next) {
+if (e.hash == hash && localname.equals(e.localName) && namespaceUri.equals(e.nsUri)) {
+e.value = value;
+return;
+}
+}
+addEntry(hash, namespaceUri,localname, value, i);
+}
+public void put(QName name, V value ) {
+put(name.getNamespaceURI(),name.getLocalPart(),value);
+}
+/**
+* Returns the value to which the specified keys are mapped in this QNameMap,
+* or <tt>null</tt> if the map contains no mapping for this key.
+*
+* @param   nsUri the namespaceUri key whose associated value is to be returned.
+* @param   localPart the localPart key whose associated value is to be returned.
+* @return  the value to which this map maps the specified set of keya, or
+*          <tt>null</tt> if the map contains no mapping for this set of keys.
+* @see #put(String,String, Object)
+*/
+public V get( @NotNull String nsUri, String localPart ) {
+Entry<V> e = getEntry(nsUri,localPart);
+if(e==null) return null;
+else        return e.value;
+}
+public V get( QName name ) {
+return get(name.getNamespaceURI(),name.getLocalPart());
+}
+/**
+* Returns the number of keys-value mappings in this map.
+*
+* @return the number of keys-value mappings in this map.
+*/
+public int size() {
+return size;
+}
+/**
+* Copies all of the mappings from the specified map to this map
+* These mappings will replace any mappings that
+* this map had for any of the keys currently in the specified map.
+*
+* @param map mappings to be stored in this map.
+*
+*/
+public QNameMap<V> putAll(QNameMap<? extends V> map) {
+int numKeysToBeAdded = map.size();
+if (numKeysToBeAdded == 0)
+return this;
+if (numKeysToBeAdded > threshold) {
+int targetCapacity = numKeysToBeAdded;
+if (targetCapacity > MAXIMUM_CAPACITY)
+targetCapacity = MAXIMUM_CAPACITY;
+int newCapacity = table.length;
+while (newCapacity < targetCapacity)
+newCapacity <<= 1;
+if (newCapacity > table.length)
+resize(newCapacity);
+}
+for( Entry<? extends V> e : map.entrySet() )
+put(e.nsUri,e.localName,e.getValue());
+return this;
+}
+public QNameMap<V> putAll(Map<QName,? extends V> map) {
+for (Map.Entry<QName, ? extends V> e : map.entrySet()) {
+QName qn = e.getKey();
+put(qn.getNamespaceURI(),qn.getLocalPart(),e.getValue());
+}
+return this;
+}
+/**
+* Returns a hash value for the specified object.The hash value is computed
+* for the localName.
+*/
+private static int hash(String x) {
+int h = x.hashCode();
+h += ~(h << 9);
+h ^=  (h >>> 14);
+h +=  (h << 4);
+h ^=  (h >>> 10);
+return h;
+}
+/**
+* Returns index for hash code h.
+*/
+private static int indexFor(int h, int length) {
+return h & (length-1);
+}
+/**
+* Add a new entry with the specified keys, value and hash code to
+* the specified bucket.  It is the responsibility of this
+* method to resize the table if appropriate.
+*
+*/
+private void addEntry(int hash, String nsUri, String localName, V value, int bucketIndex) {
+Entry<V> e = table[bucketIndex];
+table[bucketIndex] = new Entry<V>(hash, nsUri, localName, value, e);
+if (size++ >= threshold)
+resize(2 * table.length);
+}
+/**
+* Rehashes the contents of this map into a new array with a
+* larger capacity.  This method is called automatically when the
+* number of keys in this map reaches its threshold.
+*/
+private void resize(int newCapacity) {
+Entry[] oldTable = table;
+int oldCapacity = oldTable.length;
+if (oldCapacity == MAXIMUM_CAPACITY) {
+threshold = Integer.MAX_VALUE;
+return;
+}
+Entry[] newTable = new Entry[newCapacity];
+transfer(newTable);
+table = newTable;
+threshold = newCapacity;
+}
+/**
+* Transfer all entries from current table to newTable.
+*/
+private void transfer(Entry<V>[] newTable) {
+Entry<V>[] src = table;
+int newCapacity = newTable.length;
+for (int j = 0; j < src.length; j++) {
+Entry<V> e = src[j];
+if (e != null) {
+src[j] = null;
+do {
+Entry<V> next = e.next;
+int i = indexFor(e.hash, newCapacity);
+e.next = newTable[i];
+newTable[i] = e;
+e = next;
+} while (e != null);
+}
+}
+}
+/**
+* Returns one random item in the map.
+* If this map is empty, return null.
+*
+* <p>
+* This method is useful to obtain the value from a map that only contains one element.
+*/
+public Entry<V> getOne() {
+for( Entry<V> e : table ) {
+if(e!=null)
+return e;
+}
+return null;
+}
+public Collection<QName> keySet() {
+Set<QName> r = new HashSet<QName>();
+for (Entry<V> e : entrySet()) {
+r.add(e.createQName());
+}
+return r;
+}
+public Iterable<V> values() {
+return views;
+}
+private transient Iterable<V> views = new Iterable<V>() {
+public Iterator<V> iterator() {
+return new ValueIterator();
+}
+};
+private abstract class HashIterator<E> implements Iterator<E> {
+Entry<V> next;  // next entry to return
+int index;              // current slot
+HashIterator() {
+Entry<V>[] t = table;
+int i = t.length;
+Entry<V> n = null;
+if (size != 0) { // advance to first entry
+while (i > 0 && (n = t[--i]) == null)
+;
+}
+next = n;
+index = i;
+}
+public boolean hasNext() {
+return next != null;
+}
+Entry<V> nextEntry() {
+Entry<V> e = next;
+if (e == null)
+throw new NoSuchElementException();
+Entry<V> n = e.next;
+Entry<V>[] t = table;
+int i = index;
+while (n == null && i > 0)
+n = t[--i];
+index = i;
+next = n;
+return e;
+}
+public void remove() {
+throw new UnsupportedOperationException();
+}
+}
+private class ValueIterator extends HashIterator<V> {
+public V next() {
+return nextEntry().value;
+}
+}
+public boolean containsKey(@NotNull String nsUri,String localName) {
+return getEntry(nsUri,localName)!=null;
+}
+/**
+* Returns true if this map is empty.
+*/
+public boolean isEmpty() {
+return size == 0;
+}
+public static final class Entry<V>  {
+/** The namespace URI. */
+public final String nsUri;
+/** The localPart. */
+public final String localName;
+V value;
+final int hash;
+Entry<V> next;
+/**
+* Create new entry.
+*/
+Entry(int h, String nsUri, String localName, V v, Entry<V> n) {
+value = v;
+next = n;
+this.nsUri = nsUri;
+this.localName = localName;
+hash = h;
+}
+/**
+* Creates a new QName object from {@link #nsUri} and {@link #localName}.
+*/
+public QName createQName() {
+return new QName(nsUri,localName);
+}
+public V getValue() {
+return value;
+}
+public V setValue(V newValue) {
+V oldValue = value;
+value = newValue;
+return oldValue;
+}
+public boolean equals(Object o) {
+if (!(o instanceof Entry))
+return false;
+Entry e = (Entry)o;
+String k1 = nsUri;
+String k2 = e.nsUri;
+String k3 = localName;
+String k4 = e.localName;
+if (k1.equals(k2) && k3.equals(k4)) {
+Object v1 = getValue();
+Object v2 = e.getValue();
+if (v1 == v2 || (v1 != null && v1.equals(v2)))
+return true;
+}
+return false;
+}
+public int hashCode() {
+return ( localName.hashCode()) ^
+(value==null   ? 0 : value.hashCode());
+}
+public String toString() {
+return '"'+nsUri +"\",\"" +localName + "\"=" + getValue();
+}
+}
+public Set<Entry<V>> entrySet() {
+Set<Entry<V>> es = entrySet;
+return es != null ? es : (entrySet = new EntrySet());
+}
+private Iterator<Entry<V>> newEntryIterator() {
+return new EntryIterator();
+}
+private class EntryIterator extends HashIterator<Entry<V>> {
+public Entry<V> next() {
+return nextEntry();
+}
+}
+private class EntrySet extends AbstractSet<Entry<V>> {
+public Iterator<Entry<V>> iterator() {
+return newEntryIterator();
+}
+public boolean contains(Object o) {
+if (!(o instanceof Entry))
+return false;
+Entry<V> e = (Entry<V>) o;
+Entry<V> candidate = getEntry(e.nsUri,e.localName);
+return candidate != null && candidate.equals(e);
+}
+public boolean remove(Object o) {
+throw new UnsupportedOperationException();
+}
+public int size() {
+return size;
+}
+}
+private Entry<V> getEntry(@NotNull String nsUri,String localName) {
+int hash = hash(localName);
+int i = indexFor(hash, table.length);
+Entry<V> e = table[i];
+while (e != null && !(localName.equals(e.localName) && nsUri.equals(e.nsUri)))
+e = e.next;
+return e;
+}
+public String toString() {
+StringBuilder buf = new StringBuilder();
+buf.append('{');
+for( Entry<V> e : entrySet() ) {
+if(buf.length()>1)
+buf.append(',');
+buf.append('[');
+buf.append(e);
+buf.append(']');
+}
+buf.append('}');
+return buf.toString();
+}
+}

Mercurial > jdk8-mips64-public > jaxws / file comparison

comparison: src/share/jaxws_classes/com/sun/xml/internal/ws/util/QNameMap.java

src/share/jaxws_classes/com/sun/xml/internal/ws/util/QNameMap.java