Back to index...

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

Back to index...