/*
* Copyright (c) 1996, 2012, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
/*
* (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
* (C) Copyright IBM Corp. 1996, 1997 - All Rights Reserved
*
* The original version of this source code and documentation is copyrighted
* and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
* materials are provided under terms of a License Agreement between Taligent
* and Sun. This technology is protected by multiple US and International
* patents. This notice and attribution to Taligent may not be removed.
* Taligent is a registered trademark of Taligent, Inc.
*
*/
package java.text;
import java.util.
ArrayList;
/**
* Utility class for normalizing and merging patterns for collation.
* Patterns are strings of the form <entry>*, where <entry> has the
* form:
* <pattern> := <entry>*
* <entry> := <separator><chars>{"/"<extension>}
* <separator> := "=", ",", ";", "<", "&"
* <chars>, and <extension> are both arbitrary strings.
* unquoted whitespaces are ignored.
* 'xxx' can be used to quote characters
* One difference from Collator is that & is used to reset to a current
* point. Or, in other words, it introduces a new sequence which is to
* be added to the old.
* That is: "a < b < c < d" is the same as "a < b & b < c & c < d" OR
* "a < b < d & b < c"
* XXX: make '' be a single quote.
* @see PatternEntry
* @author Mark Davis, Helena Shih
*/
final class
MergeCollation {
/**
* Creates from a pattern
* @exception ParseException If the input pattern is incorrect.
*/
public
MergeCollation(
String pattern) throws
ParseException
{
for (int
i = 0;
i <
statusArray.length;
i++)
statusArray[
i] = 0;
setPattern(
pattern);
}
/**
* recovers current pattern
*/
public
String getPattern() {
return
getPattern(true);
}
/**
* recovers current pattern.
* @param withWhiteSpace puts spacing around the entries, and \n
* before & and <
*/
public
String getPattern(boolean
withWhiteSpace) {
StringBuffer result = new
StringBuffer();
PatternEntry tmp = null;
ArrayList<
PatternEntry>
extList = null;
int
i;
for (
i = 0;
i <
patterns.
size(); ++
i) {
PatternEntry entry =
patterns.
get(
i);
if (
entry.
extension.
length() != 0) {
if (
extList == null)
extList = new
ArrayList<>();
extList.
add(
entry);
} else {
if (
extList != null) {
PatternEntry last =
findLastWithNoExtension(
i-1);
for (int
j =
extList.
size() - 1;
j >= 0 ;
j--) {
tmp =
extList.
get(
j);
tmp.
addToBuffer(
result, false,
withWhiteSpace,
last);
}
extList = null;
}
entry.
addToBuffer(
result, false,
withWhiteSpace, null);
}
}
if (
extList != null) {
PatternEntry last =
findLastWithNoExtension(
i-1);
for (int
j =
extList.
size() - 1;
j >= 0 ;
j--) {
tmp =
extList.
get(
j);
tmp.
addToBuffer(
result, false,
withWhiteSpace,
last);
}
extList = null;
}
return
result.
toString();
}
private final
PatternEntry findLastWithNoExtension(int
i) {
for (--
i;
i >= 0; --
i) {
PatternEntry entry =
patterns.
get(
i);
if (
entry.
extension.
length() == 0) {
return
entry;
}
}
return null;
}
/**
* emits the pattern for collation builder.
* @return emits the string in the format understable to the collation
* builder.
*/
public
String emitPattern() {
return
emitPattern(true);
}
/**
* emits the pattern for collation builder.
* @param withWhiteSpace puts spacing around the entries, and \n
* before & and <
* @return emits the string in the format understable to the collation
* builder.
*/
public
String emitPattern(boolean
withWhiteSpace) {
StringBuffer result = new
StringBuffer();
for (int
i = 0;
i <
patterns.
size(); ++
i)
{
PatternEntry entry =
patterns.
get(
i);
if (
entry != null) {
entry.
addToBuffer(
result, true,
withWhiteSpace, null);
}
}
return
result.
toString();
}
/**
* sets the pattern.
*/
public void
setPattern(
String pattern) throws
ParseException
{
patterns.
clear();
addPattern(
pattern);
}
/**
* adds a pattern to the current one.
* @param pattern the new pattern to be added
*/
public void
addPattern(
String pattern) throws
ParseException
{
if (
pattern == null)
return;
PatternEntry.
Parser parser = new
PatternEntry.
Parser(
pattern);
PatternEntry entry =
parser.
next();
while (
entry != null) {
fixEntry(
entry);
entry =
parser.
next();
}
}
/**
* gets count of separate entries
* @return the size of pattern entries
*/
public int
getCount() {
return
patterns.
size();
}
/**
* gets count of separate entries
* @param index the offset of the desired pattern entry
* @return the requested pattern entry
*/
public
PatternEntry getItemAt(int
index) {
return
patterns.
get(
index);
}
//============================================================
// privates
//============================================================
ArrayList<
PatternEntry>
patterns = new
ArrayList<>(); // a list of PatternEntries
private transient
PatternEntry saveEntry = null;
private transient
PatternEntry lastEntry = null;
// This is really used as a local variable inside fixEntry, but we cache
// it here to avoid newing it up every time the method is called.
private transient
StringBuffer excess = new
StringBuffer();
//
// When building a MergeCollation, we need to do lots of searches to see
// whether a given entry is already in the table. Since we're using an
// array, this would make the algorithm O(N*N). To speed things up, we
// use this bit array to remember whether the array contains any entries
// starting with each Unicode character. If not, we can avoid the search.
// Using BitSet would make this easier, but it's significantly slower.
//
private transient byte[]
statusArray = new byte[8192];
private final byte
BITARRAYMASK = (byte)0x1;
private final int
BYTEPOWER = 3;
private final int
BYTEMASK = (1 <<
BYTEPOWER) - 1;
/*
If the strength is RESET, then just change the lastEntry to
be the current. (If the current is not in patterns, signal an error).
If not, then remove the current entry, and add it after lastEntry
(which is usually at the end).
*/
private final void
fixEntry(
PatternEntry newEntry) throws
ParseException
{
// check to see whether the new entry has the same characters as the previous
// entry did (this can happen when a pattern declaring a difference between two
// strings that are canonically equivalent is normalized). If so, and the strength
// is anything other than IDENTICAL or RESET, throw an exception (you can't
// declare a string to be unequal to itself). --rtg 5/24/99
if (
lastEntry != null &&
newEntry.
chars.
equals(
lastEntry.
chars)
&&
newEntry.
extension.
equals(
lastEntry.
extension)) {
if (
newEntry.
strength !=
Collator.
IDENTICAL
&&
newEntry.
strength !=
PatternEntry.
RESET) {
throw new
ParseException("The entries " +
lastEntry + " and "
+
newEntry + " are adjacent in the rules, but have conflicting "
+ "strengths: A character can't be unequal to itself.", -1);
} else {
// otherwise, just skip this entry and behave as though you never saw it
return;
}
}
boolean
changeLastEntry = true;
if (
newEntry.
strength !=
PatternEntry.
RESET) {
int
oldIndex = -1;
if ((
newEntry.
chars.
length() == 1)) {
char
c =
newEntry.
chars.
charAt(0);
int
statusIndex =
c >>
BYTEPOWER;
byte
bitClump =
statusArray[
statusIndex];
byte
setBit = (byte)(
BITARRAYMASK << (
c &
BYTEMASK));
if (
bitClump != 0 && (
bitClump &
setBit) != 0) {
oldIndex =
patterns.
lastIndexOf(
newEntry);
} else {
// We're going to add an element that starts with this
// character, so go ahead and set its bit.
statusArray[
statusIndex] = (byte)(
bitClump |
setBit);
}
} else {
oldIndex =
patterns.
lastIndexOf(
newEntry);
}
if (
oldIndex != -1) {
patterns.
remove(
oldIndex);
}
excess.
setLength(0);
int
lastIndex =
findLastEntry(
lastEntry,
excess);
if (
excess.
length() != 0) {
newEntry.
extension =
excess +
newEntry.
extension;
if (
lastIndex !=
patterns.
size()) {
lastEntry =
saveEntry;
changeLastEntry = false;
}
}
if (
lastIndex ==
patterns.
size()) {
patterns.
add(
newEntry);
saveEntry =
newEntry;
} else {
patterns.
add(
lastIndex,
newEntry);
}
}
if (
changeLastEntry) {
lastEntry =
newEntry;
}
}
private final int
findLastEntry(
PatternEntry entry,
StringBuffer excessChars) throws
ParseException
{
if (
entry == null)
return 0;
if (
entry.
strength !=
PatternEntry.
RESET) {
// Search backwards for string that contains this one;
// most likely entry is last one
int
oldIndex = -1;
if ((
entry.
chars.
length() == 1)) {
int
index =
entry.
chars.
charAt(0) >>
BYTEPOWER;
if ((
statusArray[
index] &
(
BITARRAYMASK << (
entry.
chars.
charAt(0) &
BYTEMASK))) != 0) {
oldIndex =
patterns.
lastIndexOf(
entry);
}
} else {
oldIndex =
patterns.
lastIndexOf(
entry);
}
if ((
oldIndex == -1))
throw new
ParseException("couldn't find last entry: "
+
entry,
oldIndex);
return
oldIndex + 1;
} else {
int
i;
for (
i =
patterns.
size() - 1;
i >= 0; --
i) {
PatternEntry e =
patterns.
get(
i);
if (
e.
chars.
regionMatches(0,
entry.
chars,0,
e.
chars.
length())) {
excessChars.
append(
entry.
chars.
substring(
e.
chars.
length(),
entry.
chars.
length()));
break;
}
}
if (
i == -1)
throw new
ParseException("couldn't find: " +
entry,
i);
return
i + 1;
}
}
}