0N/A/*
2362N/A * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved.
0N/A * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
0N/A *
0N/A * This code is free software; you can redistribute it and/or modify it
0N/A * under the terms of the GNU General Public License version 2 only, as
2362N/A * published by the Free Software Foundation. Oracle designates this
0N/A * particular file as subject to the "Classpath" exception as provided
2362N/A * by Oracle in the LICENSE file that accompanied this code.
0N/A *
0N/A * This code is distributed in the hope that it will be useful, but WITHOUT
0N/A * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
0N/A * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
0N/A * version 2 for more details (a copy is included in the LICENSE file that
0N/A * accompanied this code).
0N/A *
0N/A * You should have received a copy of the GNU General Public License version
0N/A * 2 along with this work; if not, write to the Free Software Foundation,
0N/A * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
0N/A *
2362N/A * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
2362N/A * or visit www.oracle.com if you need additional information or have any
2362N/A * questions.
0N/A */
0N/A
0N/Apackage sun.text;
0N/A
0N/Apublic final class UCompactIntArray implements Cloneable {
0N/A /**
0N/A * Default constructor for UCompactIntArray, the default value of the
0N/A * compact array is 0.
0N/A */
0N/A public UCompactIntArray() {
0N/A values = new int[16][];
0N/A indices = new short[16][];
0N/A blockTouched = new boolean[16][];
0N/A planeTouched = new boolean[16];
0N/A }
0N/A
0N/A public UCompactIntArray(int defaultValue) {
0N/A this();
0N/A this.defaultValue = defaultValue;
0N/A }
0N/A
0N/A /**
0N/A * Get the mapped value of a Unicode character.
0N/A * @param index the character to get the mapped value with
0N/A * @return the mapped value of the given character
0N/A */
0N/A public int elementAt(int index) {
0N/A int plane = (index & PLANEMASK) >> PLANESHIFT;
0N/A if (!planeTouched[plane]) {
0N/A return defaultValue;
0N/A }
0N/A index &= CODEPOINTMASK;
0N/A return values[plane][(indices[plane][index >> BLOCKSHIFT] & 0xFFFF)
0N/A + (index & BLOCKMASK)];
0N/A }
0N/A
0N/A
0N/A /**
0N/A * Set a new value for a Unicode character.
0N/A * Set automatically expands the array if it is compacted.
0N/A * @param index the character to set the mapped value with
0N/A * @param value the new mapped value
0N/A */
0N/A public void setElementAt(int index, int value) {
0N/A if (isCompact) {
0N/A expand();
0N/A }
0N/A int plane = (index & PLANEMASK) >> PLANESHIFT;
0N/A if (!planeTouched[plane]) {
0N/A initPlane(plane);
0N/A }
0N/A index &= CODEPOINTMASK;
0N/A values[plane][index] = value;
0N/A blockTouched[plane][index >> BLOCKSHIFT] = true;
0N/A }
0N/A
0N/A
0N/A /**
0N/A * Compact the array.
0N/A */
0N/A public void compact() {
0N/A if (isCompact) {
0N/A return;
0N/A }
0N/A for (int plane = 0; plane < PLANECOUNT; plane++) {
0N/A if (!planeTouched[plane]) {
0N/A continue;
0N/A }
0N/A int limitCompacted = 0;
0N/A int iBlockStart = 0;
0N/A short iUntouched = -1;
0N/A
0N/A for (int i = 0; i < indices[plane].length; ++i, iBlockStart += BLOCKCOUNT) {
0N/A indices[plane][i] = -1;
0N/A if (!blockTouched[plane][i] && iUntouched != -1) {
0N/A // If no values in this block were set, we can just set its
0N/A // index to be the same as some other block with no values
0N/A // set, assuming we've seen one yet.
0N/A indices[plane][i] = iUntouched;
0N/A } else {
0N/A int jBlockStart = limitCompacted * BLOCKCOUNT;
0N/A if (i > limitCompacted) {
0N/A System.arraycopy(values[plane], iBlockStart,
0N/A values[plane], jBlockStart, BLOCKCOUNT);
0N/A }
0N/A if (!blockTouched[plane][i]) {
0N/A // If this is the first untouched block we've seen, remember it.
0N/A iUntouched = (short)jBlockStart;
0N/A }
0N/A indices[plane][i] = (short)jBlockStart;
0N/A limitCompacted++;
0N/A }
0N/A }
0N/A
0N/A // we are done compacting, so now make the array shorter
0N/A int newSize = limitCompacted * BLOCKCOUNT;
0N/A int[] result = new int[newSize];
0N/A System.arraycopy(values[plane], 0, result, 0, newSize);
0N/A values[plane] = result;
0N/A blockTouched[plane] = null;
0N/A }
0N/A isCompact = true;
0N/A }
0N/A
0N/A
0N/A // --------------------------------------------------------------
0N/A // private
0N/A // --------------------------------------------------------------
0N/A /**
0N/A * Expanded takes the array back to a 0x10ffff element array
0N/A */
0N/A private void expand() {
0N/A int i;
0N/A if (isCompact) {
0N/A int[] tempArray;
0N/A for (int plane = 0; plane < PLANECOUNT; plane++) {
0N/A if (!planeTouched[plane]) {
0N/A continue;
0N/A }
0N/A blockTouched[plane] = new boolean[INDEXCOUNT];
0N/A tempArray = new int[UNICODECOUNT];
0N/A for (i = 0; i < UNICODECOUNT; ++i) {
0N/A tempArray[i] = values[plane][indices[plane][i >> BLOCKSHIFT]
0N/A & 0xffff + (i & BLOCKMASK)];
0N/A blockTouched[plane][i >> BLOCKSHIFT] = true;
0N/A }
0N/A for (i = 0; i < INDEXCOUNT; ++i) {
0N/A indices[plane][i] = (short)(i<<BLOCKSHIFT);
0N/A }
0N/A values[plane] = tempArray;
0N/A }
0N/A isCompact = false;
0N/A }
0N/A }
0N/A
0N/A private void initPlane(int plane) {
0N/A values[plane] = new int[UNICODECOUNT];
0N/A indices[plane] = new short[INDEXCOUNT];
0N/A blockTouched[plane] = new boolean[INDEXCOUNT];
0N/A planeTouched[plane] = true;
0N/A
0N/A if (planeTouched[0] && plane != 0) {
0N/A System.arraycopy(indices[0], 0, indices[plane], 0, INDEXCOUNT);
0N/A } else {
0N/A for (int i = 0; i < INDEXCOUNT; ++i) {
0N/A indices[plane][i] = (short)(i<<BLOCKSHIFT);
0N/A }
0N/A }
0N/A for (int i = 0; i < UNICODECOUNT; ++i) {
0N/A values[plane][i] = defaultValue;
0N/A }
0N/A }
0N/A
0N/A public int getKSize() {
0N/A int size = 0;
0N/A for (int plane = 0; plane < PLANECOUNT; plane++) {
0N/A if (planeTouched[plane]) {
0N/A size += (values[plane].length * 4 + indices[plane].length * 2);
0N/A }
0N/A }
0N/A return size / 1024;
0N/A }
0N/A
0N/A private static final int PLANEMASK = 0x30000;
0N/A private static final int PLANESHIFT = 16;
0N/A private static final int PLANECOUNT = 0x10;
0N/A private static final int CODEPOINTMASK = 0xffff;
0N/A
0N/A private static final int UNICODECOUNT = 0x10000;
0N/A private static final int BLOCKSHIFT = 7;
0N/A private static final int BLOCKCOUNT = (1<<BLOCKSHIFT);
0N/A private static final int INDEXSHIFT = (16-BLOCKSHIFT);
0N/A private static final int INDEXCOUNT = (1<<INDEXSHIFT);
0N/A private static final int BLOCKMASK = BLOCKCOUNT - 1;
0N/A
0N/A private int defaultValue;
0N/A private int values[][];
0N/A private short indices[][];
0N/A private boolean isCompact;
0N/A private boolean[][] blockTouched;
0N/A private boolean[] planeTouched;
0N/A};