/*
 * Copyright (c) 2003, 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 sun.text;

public final class UCompactIntArray implements Cloneable {
    
Default constructor for UCompactIntArray, the default value of the compact array is 0.
/** * Default constructor for UCompactIntArray, the default value of the * compact array is 0. */
public UCompactIntArray() { values = new int[16][]; indices = new short[16][]; blockTouched = new boolean[16][]; planeTouched = new boolean[16]; } public UCompactIntArray(int defaultValue) { this(); this.defaultValue = defaultValue; }
Get the mapped value of a Unicode character.
Params:
  • index – the character to get the mapped value with
Returns:the mapped value of the given character
/** * Get the mapped value of a Unicode character. * @param index the character to get the mapped value with * @return the mapped value of the given character */
public int elementAt(int index) { int plane = (index & PLANEMASK) >> PLANESHIFT; if (!planeTouched[plane]) { return defaultValue; } index &= CODEPOINTMASK; return values[plane][(indices[plane][index >> BLOCKSHIFT] & 0xFFFF) + (index & BLOCKMASK)]; }
Set a new value for a Unicode character. Set automatically expands the array if it is compacted.
Params:
  • index – the character to set the mapped value with
  • value – the new mapped value
/** * Set a new value for a Unicode character. * Set automatically expands the array if it is compacted. * @param index the character to set the mapped value with * @param value the new mapped value */
public void setElementAt(int index, int value) { if (isCompact) { expand(); } int plane = (index & PLANEMASK) >> PLANESHIFT; if (!planeTouched[plane]) { initPlane(plane); } index &= CODEPOINTMASK; values[plane][index] = value; blockTouched[plane][index >> BLOCKSHIFT] = true; }
Compact the array.
/** * Compact the array. */
public void compact() { if (isCompact) { return; } for (int plane = 0; plane < PLANECOUNT; plane++) { if (!planeTouched[plane]) { continue; } int limitCompacted = 0; int iBlockStart = 0; short iUntouched = -1; for (int i = 0; i < indices[plane].length; ++i, iBlockStart += BLOCKCOUNT) { indices[plane][i] = -1; if (!blockTouched[plane][i] && iUntouched != -1) { // If no values in this block were set, we can just set its // index to be the same as some other block with no values // set, assuming we've seen one yet. indices[plane][i] = iUntouched; } else { int jBlockStart = limitCompacted * BLOCKCOUNT; if (i > limitCompacted) { System.arraycopy(values[plane], iBlockStart, values[plane], jBlockStart, BLOCKCOUNT); } if (!blockTouched[plane][i]) { // If this is the first untouched block we've seen, remember it. iUntouched = (short)jBlockStart; } indices[plane][i] = (short)jBlockStart; limitCompacted++; } } // we are done compacting, so now make the array shorter int newSize = limitCompacted * BLOCKCOUNT; int[] result = new int[newSize]; System.arraycopy(values[plane], 0, result, 0, newSize); values[plane] = result; blockTouched[plane] = null; } isCompact = true; } // -------------------------------------------------------------- // private // --------------------------------------------------------------
Expanded takes the array back to a 0x10ffff element array
/** * Expanded takes the array back to a 0x10ffff element array */
private void expand() { int i; if (isCompact) { int[] tempArray; for (int plane = 0; plane < PLANECOUNT; plane++) { if (!planeTouched[plane]) { continue; } blockTouched[plane] = new boolean[INDEXCOUNT]; tempArray = new int[UNICODECOUNT]; for (i = 0; i < UNICODECOUNT; ++i) { tempArray[i] = values[plane][indices[plane][i >> BLOCKSHIFT] & 0xffff + (i & BLOCKMASK)]; blockTouched[plane][i >> BLOCKSHIFT] = true; } for (i = 0; i < INDEXCOUNT; ++i) { indices[plane][i] = (short)(i<<BLOCKSHIFT); } values[plane] = tempArray; } isCompact = false; } } private void initPlane(int plane) { values[plane] = new int[UNICODECOUNT]; indices[plane] = new short[INDEXCOUNT]; blockTouched[plane] = new boolean[INDEXCOUNT]; planeTouched[plane] = true; if (planeTouched[0] && plane != 0) { System.arraycopy(indices[0], 0, indices[plane], 0, INDEXCOUNT); } else { for (int i = 0; i < INDEXCOUNT; ++i) { indices[plane][i] = (short)(i<<BLOCKSHIFT); } } for (int i = 0; i < UNICODECOUNT; ++i) { values[plane][i] = defaultValue; } } public int getKSize() { int size = 0; for (int plane = 0; plane < PLANECOUNT; plane++) { if (planeTouched[plane]) { size += (values[plane].length * 4 + indices[plane].length * 2); } } return size / 1024; } private static final int PLANEMASK = 0x30000; private static final int PLANESHIFT = 16; private static final int PLANECOUNT = 0x10; private static final int CODEPOINTMASK = 0xffff; private static final int UNICODECOUNT = 0x10000; private static final int BLOCKSHIFT = 7; private static final int BLOCKCOUNT = (1<<BLOCKSHIFT); private static final int INDEXSHIFT = (16-BLOCKSHIFT); private static final int INDEXCOUNT = (1<<INDEXSHIFT); private static final int BLOCKMASK = BLOCKCOUNT - 1; private int defaultValue; private int values[][]; private short indices[][]; private boolean isCompact; private boolean[][] blockTouched; private boolean[] planeTouched; };