XOM API for Processing XML with Java

[norwoods <norwoods AT gbronline.com>]

here is another attempt at a cache.  this uses an LRUCache.  it can 
return a QName object with the methods qName=QName3.newQName(name, uri); 
or qName=QName3.newQName(QName3.qualifyName(prefix, localName), uri);

norwood sisson
****************************
package nu.xom;

final class QName4 {
   static LRUCache cache = new LRUCache(128);

   static QName4 target = new QName4();

   private String localName;

   private String name;

   private String prefix;

   private String uri;

   private QName4() {
   }

   private QName4(String name, String uri) {
       this.name = name.intern();
       this.uri = uri.intern();
   }

   public static synchronized QName4 newQName(String name, String uri) {
       if (name == null) {
           throw new NullPointerException();
       }
       target.name = name;
       if (uri == null)
           uri = "";
       target.uri = uri;
       QName4 value = (QName4) cache.get(target);
       if (value == null) {
           value = new QName4(name, uri);
           cache.put(value, value);
       }
       return value;
   }

   public boolean equals(Object o) {
       QName4 qName = (QName4) o;
       if (this == qName)
           return true;
       return (name.equals(qName.getQualifiedName()) && (uri.equals(qName
               .getNamespaceURI())));
   }

   public String getLocalName() {
       if (localName == null)
           splitQualifiedName();
       return localName;
   }

   public String getNamespacePrefix() {
       if (prefix == null)
           splitQualifiedName();
       return prefix;
   }

   public String getNamespaceURI() {
       return uri;
   }

   public String getQualifiedName() {
       return name;
   }

   public int hashCode() {
       return uri.hashCode() ^ name.hashCode();
   }

   public static String qualifyName(String prefix, String localName) {
       if (prefix == null || prefix == "")
           return localName;
       return prefix + ":" + localName;
   }

   private void splitQualifiedName() {
       int i = name.indexOf(':');
       if (i < 0) {
           prefix = "".intern();
           localName = name.intern();
       } else {
           prefix = name.substring(0, i).intern();
           localName = name.substring(i + 1).intern();
       }
   }
}
**************************************************
package nu.xom;

import java.util.LinkedHashMap;
import java.util.Collection;
import java.util.Map;
import java.util.ArrayList;

/**
* An LRU cache, based on <code>LinkedHashMap</code>.<br>
* This cache has a fixed maximum number of elements 
(<code>cacheSize</code>).
* If the cache is full and another entry is added, the LRU (least recently
* used) entry is dropped.
* <p>
* This class is thread-safe. All methods of this class are 
synchronized. <br>
* Author: Christian d'Heureuse ( <a
* href="http://www.source-code.biz";>www.source-code.biz </a>) <br>
* License: <a href="http://www.gnu.org/licenses/lgpl.html";>LGPL </a>.
*/
public class LRUCache<K,V> {

   private final float          hashTableLoadFactor = 0.75f;

   private LinkedHashMap<K,V>   map;
   private int                  cacheSize;

   /**
    * Creates a new LRU cache.
    *
    * @param cacheSize
    *            the maximum number of entries that will be kept in 
this cache.
    */
   public LRUCache (int cacheSize) {
      this.cacheSize = cacheSize;
      int hashTableCapacity = (int)Math.ceil(cacheSize / 
hashTableLoadFactor) + 1;
      map = new LinkedHashMap<K,V>(hashTableCapacity, 
hashTableLoadFactor, true) {
         // (an anonymous inner class)
         private static final long serialVersionUID = 1;
         @Override protected boolean removeEldestEntry (Map.Entry<K,V> 
eldest) {
            return size() > LRUCache.this.cacheSize; }}; }

   /**
    * Retrieves an entry from the cache. <br>
    * The retrieved entry becomes the MRU (most recently used) entry.
    *
    * @param key
    *            the key whose associated value is to be returned.
    * @return the value associated to this key, or null if no value 
with this
    *         key exists in the cache.
    */
   public synchronized V get (K key) {
      return map.get(key); }

   /**
    * Adds an entry to this cache. If the cache is full, the LRU (least
    * recently used) entry is dropped.
    *
    * @param key
    *            the key with which the specified value is to be 
associated.
    * @param value
    *            a value to be associated with the specified key.
    */
   public synchronized void put (K key, V value) {
      map.put (key,value); }

   /**
    * Clears the cache.
    */
   public synchronized void clear() {
      map.clear(); }

   /**
    * Returns the number of used entries in the cache.
    *
    * @return the number of entries currently in the cache.
    */
   public synchronized int size() {
      return map.size(); }

   /**
    * Returns a <code>Collection</code> that contains a copy of all cache
    * entries.
    *
    * @return a <code>Collection</code> with a copy of the cache content.
    */
   public synchronized Collection<Map.Entry<K,V>> getAll() {
      return new ArrayList<Map.Entry<K,V>>(map.entrySet()); }
}