jdk8-mips64-public/jaxws: src/share/jaxws_classes/com/sun/xml/internal/dtdparser/SimpleHashtable.java@9c07ef4934dd (annotated)

src/share/jaxws_classes/com/sun/xml/internal/dtdparser/SimpleHashtable.java@9c07ef4934dd (annotated)

src/share/jaxws_classes/com/sun/xml/internal/dtdparser/SimpleHashtable.java

Thu, 31 Aug 2017 15:18:52 +0800

author: aoqi
date: Thu, 31 Aug 2017 15:18:52 +0800
changeset 637: 9c07ef4934dd
parent 397: b99d7e355d4b
parent 0: 373ffda63c9a
permissions: -rw-r--r--

merge

 /*
  * Copyright (c) 2009, 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.dtdparser;
 import java.util.Enumeration;
 // This could be replaced by Collections class unless we want
 // to be able to run on JDK 1.1
 /**
  * This class implements a special purpose hashtable.  It works like a
  * normal <code>java.util.Hashtable</code> except that: <OL>
  * <p/>
  * <LI> Keys to "get" are strings which are known to be interned,
  * so that "==" is used instead of "String.equals".  (Interning
  * could be document-relative instead of global.)
  * <p/>
  * <LI> It's not synchronized, since it's to be used only by
  * one thread at a time.
  * <p/>
  * <LI> The keys () enumerator allocates no memory, with live
  * updates to the data disallowed.
  * <p/>
  * <LI> It's got fewer bells and whistles:  fixed threshold and
  * load factor, no JDK 1.2 collection support, only keys can be
  * enumerated, things can't be removed, simpler inheritance; more.
  * <p/>
  * </OL>
  * <p/>
  * <P> The overall result is that it's less expensive to use these in
  * performance-critical locations, in terms both of CPU and memory,
  * than <code>java.util.Hashtable</code> instances.  In this package
  * it makes a significant difference when normalizing attributes,
  * which is done for each start-element construct.
  *
  * @version $Revision: 1.2 $
  */
 final class SimpleHashtable implements Enumeration {
     // entries ...
     private Entry table[];
     // currently enumerated key
     private Entry current = null;
     private int currentBucket = 0;
     private int count;
     private int threshold;
     private static final float loadFactor = 0.75f;
     /**
      * Constructs a new, empty hashtable with the specified initial
      * capacity.
      *
      * @param initialCapacity the initial capacity of the hashtable.
      */
     public SimpleHashtable(int initialCapacity) {
         if (initialCapacity < 0)
             throw new IllegalArgumentException("Illegal Capacity: " +
                     initialCapacity);
         if (initialCapacity == 0)
             initialCapacity = 1;
         table = new Entry[initialCapacity];
         threshold = (int) (initialCapacity * loadFactor);
     }
     /**
      * Constructs a new, empty hashtable with a default capacity.
      */
     public SimpleHashtable() {
         this(11);
     }
     /**
      */
     public void clear() {
         count = 0;
         currentBucket = 0;
         current = null;
         for (int i = 0; i < table.length; i++)
             table[i] = null;
     }
     /**
      * Returns the number of keys in this hashtable.
      *
      * @return the number of keys in this hashtable.
      */
     public int size() {
         return count;
     }
     /**
      * Returns an enumeration of the keys in this hashtable.
      *
      * @return an enumeration of the keys in this hashtable.
      * @see Enumeration
      */
     public Enumeration keys() {
         currentBucket = 0;
         current = null;
         return this;
     }
     /**
      * Used to view this as an enumeration; returns true if there
      * are more keys to be enumerated.
      */
     public boolean hasMoreElements() {
         if (current != null)
             return true;
         while (currentBucket < table.length) {
             current = table[currentBucket++];
             if (current != null)
                 return true;
         }
         return false;
     }
     /**
      * Used to view this as an enumeration; returns the next key
      * in the enumeration.
      */
     public Object nextElement() {
         Object retval;
         if (current == null)
             throw new IllegalStateException();
         retval = current.key;
         current = current.next;
         return retval;
     }
     /**
      * Returns the value to which the specified key is mapped in this hashtable.
      */
     public Object get(String key) {
         Entry tab[] = table;
         int hash = key.hashCode();
         int index = (hash & 0x7FFFFFFF) % tab.length;
         for (Entry e = tab[index]; e != null; e = e.next) {
             if ((e.hash == hash) && (e.key == key))
                 return e.value;
         }
         return null;
     }
     /**
      * Returns the value to which the specified key is mapped in this
      * hashtable ... the key isn't necessarily interned, though.
      */
     public Object getNonInterned(String key) {
         Entry tab[] = table;
         int hash = key.hashCode();
         int index = (hash & 0x7FFFFFFF) % tab.length;
         for (Entry e = tab[index]; e != null; e = e.next) {
             if ((e.hash == hash) && e.key.equals(key))
                 return e.value;
         }
         return null;
     }
     /**
      * Increases the capacity of and internally reorganizes this
      * hashtable, in order to accommodate and access its entries more
      * efficiently.  This method is called automatically when the
      * number of keys in the hashtable exceeds this hashtable's capacity
      * and load factor.
      */
     private void rehash() {
         int oldCapacity = table.length;
         Entry oldMap[] = table;
         int newCapacity = oldCapacity * 2 + 1;
         Entry newMap[] = new Entry[newCapacity];
         threshold = (int) (newCapacity * loadFactor);
         table = newMap;
         /*
         System.out.println("rehash old=" + oldCapacity
             + ", new=" + newCapacity
             + ", thresh=" + threshold
             + ", count=" + count);
         */
         for (int i = oldCapacity; i-- > 0;) {
             for (Entry old = oldMap[i]; old != null;) {
                 Entry e = old;
                 old = old.next;
                 int index = (e.hash & 0x7FFFFFFF) % newCapacity;
                 e.next = newMap[index];
                 newMap[index] = e;
             }
         }
     }
     /**
      * Maps the specified <code>key</code> to the specified
      * <code>value</code> in this hashtable. Neither the key nor the
      * value can be <code>null</code>.
      * <p/>
      * <P>The value can be retrieved by calling the <code>get</code> method
      * with a key that is equal to the original key.
      */
     public Object put(Object key, Object value) {
         // Make sure the value is not null
         if (value == null) {
             throw new NullPointerException();
         }
         // Makes sure the key is not already in the hashtable.
         Entry tab[] = table;
         int hash = key.hashCode();
         int index = (hash & 0x7FFFFFFF) % tab.length;
         for (Entry e = tab[index]; e != null; e = e.next) {
             // if ((e.hash == hash) && e.key.equals(key)) {
             if ((e.hash == hash) && (e.key == key)) {
                 Object old = e.value;
                 e.value = value;
                 return old;
             }
         }
         if (count >= threshold) {
             // Rehash the table if the threshold is exceeded
             rehash();
             tab = table;
             index = (hash & 0x7FFFFFFF) % tab.length;
         }
         // Creates the new entry.
         Entry e = new Entry(hash, key, value, tab[index]);
         tab[index] = e;
         count++;
         return null;
     }
     /**
      * Hashtable collision list.
      */
     private static class Entry {
         int hash;
         Object key;
         Object value;
         Entry next;
         protected Entry(int hash, Object key, Object value, Entry next) {
             this.hash = hash;
             this.key = key;
             this.value = value;
             this.next = next;
         }
     }
 }

Mercurial > jdk8-mips64-public > jaxws / annotate

src/share/jaxws_classes/com/sun/xml/internal/dtdparser/SimpleHashtable.java@9c07ef4934dd (annotated)

src/share/jaxws_classes/com/sun/xml/internal/dtdparser/SimpleHashtable.java