/*
* 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.
*/
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.
* @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.
* @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.
*/
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
*/
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;
};