/*

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

};