/*
 * The Apache Software License, Version 1.1
 *
 *
 * Copyright (c) 1999 The Apache Software Foundation.  All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.apache.org/)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Xerces" and "Apache Software Foundation" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact apache@apache.org.
 *
 * 5. Products derived from this software may not be called "Apache",
 *    nor may "Apache" appear in their name, without prior written
 *    permission of the Apache Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation and was
 * originally based on software copyright (c) 1999, International
 * Business Machines, Inc., http://www.apache.org.  For more
 * information on the Apache Software Foundation, please see
 * <http://www.apache.org/>.
 */

package org.apache.xerces.utils;

/**
 *
 * @version
 */
public final class StringPool {
    //
    // Debugging
    //
    private static final boolean DEBUG_ADDITIONS = false;
    /**
     * Constants
     */
    public static final int NULL_STRING = -1;   // null
    public static final int EMPTY_STRING = 0;   // ""
    /**
     *
     */
    public interface StringProducer {
        /**
         *
         */
        public String toString(int offset, int length);
        /**
         *
         */
        public void releaseString(int offset, int length);
        /**
         *
         */
        public boolean equalsString(int offset, int length, char[] strChars, int strOffset, int strLength);
    };
    //
    // Chunk size constants
    //
    private static final int INITIAL_CHUNK_SHIFT = 8;    // 2^8 = 256
    private static final int INITIAL_CHUNK_SIZE = (1 << INITIAL_CHUNK_SHIFT);
    private static final int CHUNK_SHIFT = 13;           // 2^13 = 8k
    private static final int CHUNK_SIZE = (1 << CHUNK_SHIFT);
    private static final int CHUNK_MASK = CHUNK_SIZE - 1;
    private static final int INITIAL_CHUNK_COUNT = (1 << (16 - CHUNK_SHIFT));   // 2^16 = 64k
    //
    // Instance variables
    //
    //
    // String and Symbol arrays
    //
    private int fStringCount = 0;
    private int fStringFreeList = -1;
    private String[][] fString = new String[INITIAL_CHUNK_COUNT][];
    private StringPool.StringProducer[][] fStringProducer = new StringPool.StringProducer[INITIAL_CHUNK_COUNT][];
    private int[][] fOffset = new int[INITIAL_CHUNK_COUNT][];
    private int[][] fLength = new int[INITIAL_CHUNK_COUNT][];
    private int[][] fCharsOffset = new int[INITIAL_CHUNK_COUNT][];
    //
    // String Lists
    //
    private int fStringListCount = 0;
    private int fActiveStringList = -1;
    private int[][] fStringList = new int[INITIAL_CHUNK_COUNT][];
    //
    // Symbol Hashtable
    //
    private static final int INITIAL_BUCKET_SIZE = 4;
    private static final int HASHTABLE_SIZE = 128;
    private int[][] fSymbolTable = new int[HASHTABLE_SIZE][];
    //
    // Symbol Cache
    //
    private SymbolCache fSymbolCache = null;
    //
    //
    //
    public StringPool() {
        fSymbolCache = new SymbolCache();
        if (addSymbol("") != EMPTY_STRING)
            throw new RuntimeException("UTL002 cannot happen");
    }
    //
    //
    //
    public void reset() {
        int chunk = 0;
        int index = 0;
        for (int i = 0; i < fStringCount; i++) {
            fString[chunk][index] = null;
            if (fStringProducer[chunk][index] != null)
                fStringProducer[chunk][index].releaseString(fOffset[chunk][index], fLength[chunk][index]);
            fStringProducer[chunk][index] = null;
            if (++index == CHUNK_SIZE) {
                chunk++;
                index = 0;
            }
        }
        for (int i = 0; i < HASHTABLE_SIZE; i++)
            fSymbolTable[i] = null;
        fStringCount = 0;
        fStringFreeList = -1;
        fStringListCount = 0;
        fActiveStringList = -1;
        fSymbolCache.reset();
        fShuffleCount = 0;
        if (addSymbol("") != EMPTY_STRING)
            throw new RuntimeException("UTL002 cannot happen");
    }
    //
    // String interfaces
    //
    private boolean ensureCapacity(int chunk, int index) {
        try {
            return fOffset[chunk][index] == 0;
        } catch (ArrayIndexOutOfBoundsException ex) {
            if (index == 0) {
                String[][] newString = new String[chunk * 2][];
                System.arraycopy(fString, 0, newString, 0, chunk);
                fString = newString;
                StringPool.StringProducer[][] newProducer = new StringPool.StringProducer[chunk * 2][];
                System.arraycopy(fStringProducer, 0, newProducer, 0, chunk);
                fStringProducer = newProducer;
                int[][] newInt = new int[chunk * 2][];
                System.arraycopy(fOffset, 0, newInt, 0, chunk);
                fOffset = newInt;
                newInt = new int[chunk * 2][];
                System.arraycopy(fLength, 0, newInt, 0, chunk);
                fLength = newInt;
                newInt = new int[chunk * 2][];
                System.arraycopy(fCharsOffset, 0, newInt, 0, chunk);
                fCharsOffset = newInt;
            } else {
                String[] newString = new String[index * 2];
                System.arraycopy(fString[chunk], 0, newString, 0, index);
                fString[chunk] = newString;
                StringPool.StringProducer[] newProducer = new StringPool.StringProducer[index * 2];
                System.arraycopy(fStringProducer[chunk], 0, newProducer, 0, index);
                fStringProducer[chunk] = newProducer;
                int[] newInt = new int[index * 2];
                System.arraycopy(fOffset[chunk], 0, newInt, 0, index);
                fOffset[chunk] = newInt;
                newInt = new int[index * 2];
                System.arraycopy(fLength[chunk], 0, newInt, 0, index);
                fLength[chunk] = newInt;
                newInt = new int[index * 2];
                System.arraycopy(fCharsOffset[chunk], 0, newInt, 0, index);
                fCharsOffset[chunk] = newInt;
                return true;
            }
        } catch (NullPointerException ex) {
        }
        fString[chunk] = new String[INITIAL_CHUNK_SIZE];
        fStringProducer[chunk] = new StringPool.StringProducer[INITIAL_CHUNK_SIZE];
        fOffset[chunk] = new int[INITIAL_CHUNK_SIZE];
        fLength[chunk] = new int[INITIAL_CHUNK_SIZE];
        fCharsOffset[chunk] = new int[INITIAL_CHUNK_SIZE];
        return true;
    }
    public int addString(String str) {
        int chunk;
        int index;
        int stringIndex;
        if (fStringFreeList != -1) {
            stringIndex = fStringFreeList;
            chunk = stringIndex >> CHUNK_SHIFT;
            index = stringIndex & CHUNK_MASK;
            fStringFreeList = fOffset[chunk][index];
        } else {
            stringIndex = fStringCount++;
            chunk = stringIndex >> CHUNK_SHIFT;
            index = stringIndex & CHUNK_MASK;
            ensureCapacity(chunk, index);
        }
        fString[chunk][index] = str;
        fStringProducer[chunk][index] = null;
        fOffset[chunk][index] = 0;
        fLength[chunk][index] = str.length();
        fCharsOffset[chunk][index] = -1;
        if (DEBUG_ADDITIONS)
            System.err.println("addString(" + str + ") " + stringIndex);
        return stringIndex;
    }
    public int addString(StringPool.StringProducer stringProducer, int offset, int length)
    {
        int chunk;
        int index;
        int stringIndex;
        if (fStringFreeList != -1) {
            stringIndex = fStringFreeList;
            chunk = stringIndex >> CHUNK_SHIFT;
            index = stringIndex & CHUNK_MASK;
            fStringFreeList = fOffset[chunk][index];
        } else {
            stringIndex = fStringCount++;
            chunk = stringIndex >> CHUNK_SHIFT;
            index = stringIndex & CHUNK_MASK;
            ensureCapacity(chunk, index);
        }
        fString[chunk][index] = null;
        fStringProducer[chunk][index] = stringProducer;
        fOffset[chunk][index] = offset;
        fLength[chunk][index] = length;
        fCharsOffset[chunk][index] = -1;
        if (DEBUG_ADDITIONS)
            System.err.println("addString(" + stringProducer.toString(offset, length) + ") " + stringIndex);
        return stringIndex;
    }
    //
    // Symbol interfaces
    //
    public SymbolCache getSymbolCache() {
        return fSymbolCache;
    }
    //private static int fShuffleCount = 0;
    private int fShuffleCount = 0;
    public void resetShuffleCount() {
        fShuffleCount = 0;
    }
    public void updateCacheLine(int symbolIndex, int totalMisses, int length) {
//System.err.println("found symbol " + toString(symbolIndex) + " after " + totalMisses + " total misses (" + (totalMisses/length) + " misses per character).");
        if (++fShuffleCount > 200) {
//            if (fShuffleCount == 201) System.out.println("Stopped shuffling...");
            return;
        }
//        if ((fShuffleCount % 10) == 0) System.out.println("Shuffling pass " + fShuffleCount + " ...");
        int chunk = symbolIndex >> CHUNK_SHIFT;
        int index = symbolIndex & CHUNK_MASK;
        int charsOffset = fCharsOffset[chunk][index];
        fSymbolCache.updateCacheLine(charsOffset, totalMisses, length);
    }
    public int createNonMatchingSymbol(int startOffset,
                                       int entry,
                                       int[] entries,
                                       int offset) throws Exception
    {
        int chunk;
        int index;
        int stringIndex;
        if (fStringFreeList != -1) {
            stringIndex = fStringFreeList;
            chunk = stringIndex >> CHUNK_SHIFT;
            index = stringIndex & CHUNK_MASK;
            fStringFreeList = fOffset[chunk][index];
        } else {
            stringIndex = fStringCount++;
            chunk = stringIndex >> CHUNK_SHIFT;
            index = stringIndex & CHUNK_MASK;
            ensureCapacity(chunk, index);
        }
        String str = fSymbolCache.createSymbol(stringIndex, startOffset, entry, entries, offset);
        int slen = str.length();
        fString[chunk][index] = str;
        fStringProducer[chunk][index] = null;
        fOffset[chunk][index] = -1;
        fLength[chunk][index] = slen;
        fCharsOffset[chunk][index] = startOffset;

        int hashcode = StringHasher.hashString(str, slen);
        int hc = hashcode % HASHTABLE_SIZE;
        int[] bucket = fSymbolTable[hc];
        hashSymbol(bucket, hashcode, chunk, index);
        if (DEBUG_ADDITIONS)
            System.err.println("addSymbolNew(" + str + ") " + stringIndex);
        return stringIndex;
    }
    private void hashSymbol(int[] bucket, int hashcode, int chunk, int index) {
        if (bucket == null) {
            bucket = new int[1 + (INITIAL_BUCKET_SIZE * 3)];
            bucket[0] = 1;
            bucket[1] = hashcode;
            bucket[2] = chunk;
            bucket[3] = index;
            int hc = hashcode % HASHTABLE_SIZE;
            fSymbolTable[hc] = bucket;
        } else {
            int count = bucket[0];
            int offset = 1 + (count * 3);
            if (offset == bucket.length) {
                int newSize = count + INITIAL_BUCKET_SIZE;
                int[] newBucket = new int[1 + (newSize * 3)];
                System.arraycopy(bucket, 0, newBucket, 0, offset);
                bucket = newBucket;
                int hc = hashcode % HASHTABLE_SIZE;
                fSymbolTable[hc] = bucket;
            }
            bucket[offset++] = hashcode;
            bucket[offset++] = chunk;
            bucket[offset++] = index;
            bucket[0] = ++count;
        }
    }
    public int addSymbol(String str) {
        int slen = str.length();
        int hashcode = StringHasher.hashString(str, slen);
        int hc = hashcode % HASHTABLE_SIZE;
        int[] bucket = fSymbolTable[hc];
        if (bucket != null) {
            int j = 1;
            for (int i = 0; i < bucket[0]; i++) {
                if (bucket[j] == hashcode) {
                    int chunk = bucket[j+1];
                    int index = bucket[j+2];
                    if (slen == fLength[chunk][index]) {
                        int symoff = fCharsOffset[chunk][index];
                        boolean match = true;
                        char[] symbolChars = fSymbolCache.getSymbolChars();
                        for (int k = 0; k < slen; k++) {
                            if (symbolChars[symoff++] != str.charAt(k)) {
                                match = false;
                                break;
                            }
                        }
                        if (match) {
                            return (chunk << CHUNK_SHIFT) + index;
                        }
                    }
                }
                j += 3;
            }
        }
        int chunk;
        int index;
        int stringIndex;
        if (fStringFreeList != -1) {
            stringIndex = fStringFreeList;
            chunk = stringIndex >> CHUNK_SHIFT;
            index = stringIndex & CHUNK_MASK;
            fStringFreeList = fOffset[chunk][index];
        } else {
            stringIndex = fStringCount++;
            chunk = stringIndex >> CHUNK_SHIFT;
            index = stringIndex & CHUNK_MASK;
            ensureCapacity(chunk, index);
        }
        fString[chunk][index] = str;
        fStringProducer[chunk][index] = null;
        fOffset[chunk][index] = -1;
        fLength[chunk][index] = slen;
        fCharsOffset[chunk][index] = fSymbolCache.addSymbolToCache(str, slen, stringIndex);

        hashSymbol(bucket, hashcode, chunk, index);
        if (DEBUG_ADDITIONS)
            System.err.println("addSymbolNew(" + str + ") " + stringIndex);
        return stringIndex;
    }
    public int addSymbol(StringPool.StringProducer stringProducer, int offset, int length, int hashcode) {
        int hc = hashcode % HASHTABLE_SIZE;
        int[] bucket = fSymbolTable[hc];
        if (bucket != null) {
            int j = 1;
            for (int i = 0; i < bucket[0]; i++) {
                if (bucket[j] == hashcode) {
                    int chunk = bucket[j+1];
                    int index = bucket[j+2];
                    char[] symbolChars = fSymbolCache.getSymbolChars();
                    if (stringProducer.equalsString(offset, length, symbolChars, fCharsOffset[chunk][index], fLength[chunk][index])) {
                        stringProducer.releaseString(offset, length);
                        return (chunk << CHUNK_SHIFT) + index;
                    }
                }
                j += 3;
            }
        }
        int chunk;
        int index;
        int stringIndex;
        if (fStringFreeList != -1) {
            stringIndex = fStringFreeList;
            chunk = stringIndex >> CHUNK_SHIFT;
            index = stringIndex & CHUNK_MASK;
            fStringFreeList = fOffset[chunk][index];
        } else {
            stringIndex = fStringCount++;
            chunk = stringIndex >> CHUNK_SHIFT;
            index = stringIndex & CHUNK_MASK;
            ensureCapacity(chunk, index);
        }
        String str = stringProducer.toString(offset, length);
        stringProducer.releaseString(offset, length);
        int slen = str.length();
        fString[chunk][index] = str;
        fStringProducer[chunk][index] = null;
        fOffset[chunk][index] = -1;
        fLength[chunk][index] = slen;
        fCharsOffset[chunk][index] = fSymbolCache.addSymbolToCache(str, slen, stringIndex);

        hashSymbol(bucket, hashcode, chunk, index);
        if (DEBUG_ADDITIONS)
            System.err.println("addSymbol(" + str + ") " + stringIndex);
        return stringIndex;
    }
    public int lookupSymbol(StringPool.StringProducer stringProducer, int offset, int length, int hashcode) {
        int hc = hashcode % HASHTABLE_SIZE;
        int[] bucket = fSymbolTable[hc];
        if (bucket != null) {
            int j = 1;
            for (int i = 0; i < bucket[0]; i++) {
                if (bucket[j] == hashcode) {
                    int chunk = bucket[j+1];
                    int index = bucket[j+2];
                    char[] symbolChars = fSymbolCache.getSymbolChars();
                    if (stringProducer.equalsString(offset, length, symbolChars, fCharsOffset[chunk][index], fLength[chunk][index])) {
                        return (chunk << CHUNK_SHIFT) + index;
                    }
                }
                j += 3;
            }
        }
        return -1;
    }
    public int addNewSymbol(String str, int hashcode) {
        int hc = hashcode % HASHTABLE_SIZE;
        int[] bucket = fSymbolTable[hc];
        int chunk;
        int index;
        int stringIndex;
        if (fStringFreeList != -1) {
            stringIndex = fStringFreeList;
            chunk = stringIndex >> CHUNK_SHIFT;
            index = stringIndex & CHUNK_MASK;
            fStringFreeList = fOffset[chunk][index];
        } else {
            stringIndex = fStringCount++;
            chunk = stringIndex >> CHUNK_SHIFT;
            index = stringIndex & CHUNK_MASK;
            ensureCapacity(chunk, index);
        }
        int slen = str.length();
        fString[chunk][index] = str;
        fStringProducer[chunk][index] = null;
        fOffset[chunk][index] = -1;
        fLength[chunk][index] = slen;
        fCharsOffset[chunk][index] = fSymbolCache.addSymbolToCache(str, slen, stringIndex);

        hashSymbol(bucket, hashcode, chunk, index);
        if (DEBUG_ADDITIONS)
            System.err.println("addSymbolNew(" + str + ") " + stringIndex);
        return stringIndex;
    }
    public int addSymbol(int stringIndex) {
        if (stringIndex < 0 || stringIndex >= fStringCount)
            return -1;
        int chunk = stringIndex >> CHUNK_SHIFT;
        int index = stringIndex & CHUNK_MASK;
        if (fOffset[chunk][index] == -1)
            return stringIndex;
        String s = fString[chunk][index];
        if (s == null) {
            s = fStringProducer[chunk][index].toString(fOffset[chunk][index], fLength[chunk][index]);
            fStringProducer[chunk][index].releaseString(fOffset[chunk][index], fLength[chunk][index]);
            fString[chunk][index] = s;
            fStringProducer[chunk][index] = null;
        }
        return addSymbol(s);
    }
    //
    // Get characters for defined symbols
    //
    public class CharArrayRange {
        public char[] chars;
        public int offset;
        public int length;
    }
    public CharArrayRange createCharArrayRange() {
        return new CharArrayRange();
    }
    public void getCharArrayRange(int symbolIndex, CharArrayRange r) {
        if (symbolIndex < 0 || symbolIndex >= fStringCount) {
            r.chars = null;
            r.offset = -1;
            r.length = -1;
            return;
        }
        int chunk = symbolIndex >> CHUNK_SHIFT;
        int index = symbolIndex & CHUNK_MASK;
        r.chars = fSymbolCache.getSymbolChars();
        r.offset = fCharsOffset[chunk][index];
        r.length = fLength[chunk][index];
    }
    public boolean equalNames(int stringIndex1, int stringIndex2) {
        if (stringIndex1 == stringIndex2)
            return true;
        return false;
    }
    //
    // String list support
    //
    private boolean ensureListCapacity(int chunk, int index) {
        try {
            return fStringList[chunk][index] == 0;
        } catch (ArrayIndexOutOfBoundsException ex) {
            if (index == 0) {
                int[][] newInt = new int[chunk * 2][];
                System.arraycopy(fStringList, 0, newInt, 0, chunk);
                fStringList = newInt;
            } else {
                int[] newInt = new int[index * 2];
                System.arraycopy(fStringList[chunk], 0, newInt, 0, index);
                fStringList[chunk] = newInt;
                return true;
            }
        } catch (NullPointerException ex) {
        }
        fStringList[chunk] = new int[INITIAL_CHUNK_SIZE];
        return true;
    }
    public int startStringList() {
        fActiveStringList = fStringListCount;
        return fStringListCount;
    }
    public boolean addStringToList(int stringListIndex, int stringIndex) {
        if (stringIndex == -1 || stringListIndex != fActiveStringList)
            return false;
        int chunk = fStringListCount >> CHUNK_SHIFT;
        int index = fStringListCount & CHUNK_MASK;
        ensureListCapacity(chunk, index);
        fStringList[chunk][index] = stringIndex;
        fStringListCount++;
        return true;
    }
    public void finishStringList(int stringListIndex) {
        if (stringListIndex != fActiveStringList)
            return;
        int chunk = fStringListCount >> CHUNK_SHIFT;
        int index = fStringListCount & CHUNK_MASK;
        ensureListCapacity(chunk, index);
        fStringList[chunk][index] = -1;
        fActiveStringList = -1;
        fStringListCount++;
    }
    public int stringListLength(int stringListIndex) {
        int chunk = stringListIndex >> CHUNK_SHIFT;
        int index = stringListIndex & CHUNK_MASK;
        int count = 0;
        while (true) {
            if (fStringList[chunk][index] == -1)
                return count;
            count++;
            if (++index == CHUNK_SIZE) {
                chunk++;
                index = 0;
            }
        }
    }
    public boolean stringInList(int stringListIndex, int stringIndex) {
        int chunk = stringListIndex >> CHUNK_SHIFT;
        int index = stringListIndex & CHUNK_MASK;
        while (true) {
            if (fStringList[chunk][index] == stringIndex)
                return true;
            if (fStringList[chunk][index] == -1)
                return false;
            if (++index == CHUNK_SIZE) {
                chunk++;
                index = 0;
            }
        }
    }
    public String stringListAsString(int stringListIndex) {
        int chunk = stringListIndex >> CHUNK_SHIFT;
        int index = stringListIndex & CHUNK_MASK;
        StringBuffer sb = new StringBuffer();
        char sep = '(';
        while (fStringList[chunk][index] != -1) {
            sb.append(sep);
            sep = '|';
            sb.append(toString(fStringList[chunk][index]));
            if (++index == CHUNK_SIZE) {
                chunk++;
                index = 0;
            }
        }
        if (sep == '|')
            sb.append(')');
        return sb.toString();
    }
    public int[] stringListAsIntArray(int stringListIndex) {
        int chunk = stringListIndex >> CHUNK_SHIFT;
        int index = stringListIndex & CHUNK_MASK;
        int len = stringListLength(stringListIndex);

        int[] ia = new int[len];
        for (int i=0; i<len; i++) {
            ia[i] = fStringList[chunk][index];
            if (++index == CHUNK_SIZE) {
                chunk++;
                index = 0;
            }
        }
        return ia;
    }
    //
    //
    //
    private void releaseStringInternal(int chunk, int index) {
        fString[chunk][index] = null;
        fStringProducer[chunk][index] = null;
        fLength[chunk][index] = 0;
        //
        // REVISIT - not synchronized.
        //
        fOffset[chunk][index] = fStringFreeList;
        int offset = (chunk << CHUNK_SHIFT) + index;
        fStringFreeList = offset;
    }
    //
    //
    //
    public void releaseString(int stringIndex) {
        if (stringIndex < 0 || stringIndex >= fStringCount)
            return;
        int chunk = stringIndex >> CHUNK_SHIFT;
        int index = stringIndex & CHUNK_MASK;
        if (fOffset[chunk][index] != -1) {
            if (fStringProducer[chunk][index] != null)
                fStringProducer[chunk][index].releaseString(fOffset[chunk][index], fLength[chunk][index]);
            releaseStringInternal(chunk, index);
        }
    }
    //
    // Get String value.  Cache the result.
    //
    public String toString(int stringIndex) {
        if (stringIndex >= 0 && stringIndex < fString[0].length) {
            String result = fString[0][stringIndex];
            if (result != null) {
                return result;
            }
        }

        if (stringIndex < 0 || stringIndex >= fStringCount)
            return null;
        int chunk = stringIndex >> CHUNK_SHIFT;
        int index = stringIndex & CHUNK_MASK;
        String s = fString[chunk][index];
        if (s != null)
            return s;
        s = fStringProducer[chunk][index].toString(fOffset[chunk][index], fLength[chunk][index]);
        fStringProducer[chunk][index].releaseString(fOffset[chunk][index], fLength[chunk][index]);
        fString[chunk][index] = s;
        fStringProducer[chunk][index] = null;
        return s;
    }
    //
    //
    //
    public String orphanString(int stringIndex) {
        if (stringIndex < 0 || stringIndex >= fStringCount)
            return null;
        int chunk = stringIndex >> CHUNK_SHIFT;
        int index = stringIndex & CHUNK_MASK;
        String s = fString[chunk][index];
        if (s == null) {
            s = fStringProducer[chunk][index].toString(fOffset[chunk][index], fLength[chunk][index]);
            fStringProducer[chunk][index].releaseString(fOffset[chunk][index], fLength[chunk][index]);
            releaseStringInternal(chunk, index);
        } else if (fOffset[chunk][index] != -1) {
            releaseStringInternal(chunk, index);
        }
        return s;
    }
}