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