org.apache.xml.dtm.ref.DTMStringPool Maven / Gradle / Ivy

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the  "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/*
 * $Id: DTMStringPool.java 468653 2006-10-28 07:07:05Z minchau $
 */

package org.apache.xml.dtm.ref;

import java.util.Vector;

import org.apache.xml.utils.IntVector;

/** DTMStringPool is an "interning" mechanism for strings. It will
 * create a stable 1:1 mapping between a set of string values and a set of
 * integer index values, so the integers can be used to reliably and
 * uniquely identify (and when necessary retrieve) the strings.
 *
 * Design Priorities:
 * 

 * String-to-index lookup speed is critical.
 * Index-to-String lookup speed is slightly less so.
 * Threadsafety is not guaranteed at this level.
 * Enforce that in the application if needed.
 * Storage efficiency is an issue but not a huge one.
 * It is expected that string pools won't exceed about 2000 entries.
 * 
 * 
 *
 * Implementation detail: A standard Hashtable is relatively
 * inefficient when looking up primitive int values, especially when
 * we're already maintaining an int-to-string vector.  So I'm
 * maintaining a simple hash chain within this class.
 *
 * NOTE: There is nothing in the code that has a real dependency upon
 * String. It would work with any object type that implements reliable
 * .hashCode() and .equals() operations. The API enforces Strings because
 * it's safer that way, but this could trivially be turned into a general
 * ObjectPool if one was needed.
 *
 * Status: Passed basic test in main().
 * */
public class DTMStringPool
{
  Vector m_intToString;
  static final int HASHPRIME=101;
  int[] m_hashStart=new int[HASHPRIME];
  IntVector m_hashChain;
  public static final int NULL=-1;

  /**
   * Create a DTMStringPool using the given chain size
   * 
   * @param chainSize The size of the hash chain vector
   */
  public DTMStringPool(int chainSize)
    {
      m_intToString=new Vector();
      m_hashChain=new IntVector(chainSize);
      removeAllElements();
      
      // -sb Add this to force empty strings to be index 0.
      stringToIndex("");
    }
  
  public DTMStringPool()
    {
      this(512);	
    }
    
  public void removeAllElements()
    {
      m_intToString.removeAllElements();
      for(int i=0;i