();
+ private String collationURI;
+
+ public ZhCnAwareCollator(String collationURI) {
+ this.collationURI = collationURI;
+ this.locale = Locale.getDefault();
+ this.isZhCn = Locale.SIMPLIFIED_CHINESE == locale;
+ this.delegate = getConfiguredICUCollator(locale);
+ }
+
+
+ public ZhCnAwareCollator(Locale locale) {
+ this.delegate = getConfiguredICUCollator(locale);
+
+ this.locale = locale;
+ this.isZhCn = Locale.SIMPLIFIED_CHINESE == locale;
+ }
+
+ private RuleBasedCollator getConfiguredICUCollator(Locale locale) {
+ // FIXME: This reflects the original API design implemented by me (Eliot)
+ // many years ago. This is obviously not the best design but don't have time
+ // to refactor it now.
+
+ // FIXME: This is a hack to avoid having to work out a better configuration mechanism at
+ // this time. The better implementation should expect a URI and should use the configured
+ // resolution catalog to resolve it.
+ final File myJarFile = new File(ZhCnAwareCollator.class.getProtectionDomain().getCodeSource().getLocation().getPath());
+ final File configFile =
+ new File(myJarFile.getParent(),
+ CONF_GROUPING_AND_SORTING_GROUPING_AND_SORTING_RULES_XML);
+ RuleBasedCollator collator;
+ GroupingAndSortingHelper helper = null;
+ try {
+ helper = new GroupingAndSortingHelper(configFile.getAbsolutePath());
+ collator = helper.getComparator(locale);
+ } catch (Exception e) {
+ e.printStackTrace();
+ collator = (RuleBasedCollator)RuleBasedCollator.getInstance(locale);
+ }
+ return collator;
+ }
+
+ @Override
+ public int compareStrings(String source, String target) {
+ return this.compare(source, target);
+ }
+
+ @Override
+ public synchronized CollationKey getCollationKey(String source) {
+ if (this.colKeyCache.containsKey(source)) {
+ return this.colKeyCache.get(source);
+ }
+ ZhCnAwareCollationKey colKey = new ZhCnAwareCollationKey(delegate, source);
+ this.colKeyCache.put(source, colKey);
+ return colKey;
+ }
+
+ @Override
+ public int hashCode() {
+ return delegate.hashCode();
+ }
+
+ /**
+ * Gets the Collator for the desired locale. Always returns a
+ * ZhCnAwareCollator.
+ *
+ * @param desiredLocale the desired locale.
+ * @return the Collator for the desired locale.
+ * @see java.util.Locale
+ * @see java.util.ResourceBundle
+ */
+ public static synchronized Collator getInstance(Locale desiredLocale) {
+ System.out.print("getInstance(): desiredLocale=" + desiredLocale);
+ Collator collator = new ZhCnAwareCollator(desiredLocale);
+ return collator;
+
+ }
+
+ @Override
+ public int compare(String source, String target) {
+ int result;
+ if (isZhCn) {
+ try {
+ result = zhCnCompare(source, target);
+ } catch (Exception e) {
+ System.out.println(" + [ERROR] ZhCnAwareCollator.compare(): " + e.getClass().getSimpleName());
+ e.printStackTrace();
+ result = delegate.compare(source, target);
+ }
+ } else {
+ result = delegate.compare(source, target);
+ }
+ return result;
+ }
+
+ /**
+ * Use the Simplified Chinese sort keys to do the comparison. The sort keys
+ * are then passed to the base ICU collator so that its normal rule-based
+ * configuration rules are then applied. For Simplified Chinese the sort key
+ * is the pinyin transliteration of the Chinese word, so the base part of the sort
+ * key is always in latin script.
+ * @param source Source string
+ * @param target Target string
+ * @return Comparison value.
+ */
+ private int zhCnCompare(String source, String target) {
+
+ String sourceSortKey = getZhCnSortKey(source);
+ String targetSortKey = getZhCnSortKey(target);
+
+ return delegate.compare(sourceSortKey, targetSortKey);
+ }
+
+ /**
+ * Given a string that may contain Simplified Chinese ideographs, return
+ * the appropiate sort key, which is the pinyin transliteration as the
+ * primary key and the original text as the secondary key.
+ * @param source Source string.
+ * @return Sort key for use by the RuleBasedCollator.compare() method.
+ */
+ protected String getZhCnSortKey(String source) {
+
+ if (this.colKeyCache.containsKey(source)) {
+ return colKeyCache.get(source).getSortKey();
+ }
+
+
+ String pinyin = ZhCnDictionary.getPinYin(source);
+ // FIXME: Construct proper primary/secondary ICU sort key.
+ return pinyin + source;
+ }
+
+ @Override
+ public int compare(Object o1, Object o2) {
+ return delegate.compare(o1, o2);
+ }
+
+ public void setCollationURI(String collationURI) {
+ this.collationURI = collationURI;
+ }
+
+ /**
+ * Get the ICU RuleBasedCollator that backs this collator. Useful mostly for testing
+ * and debugging.
+ * @return The backing collator.
+ */
+ public RuleBasedCollator getBackingCollator() {
+ return this.delegate;
+ }
+}
diff --git a/src/main/java/org/ditacommunity/i18n/collation/ZhCnDictionary.java b/src/main/java/org/ditacommunity/i18n/collation/ZhCnDictionary.java
new file mode 100644
index 0000000..4839219
--- /dev/null
+++ b/src/main/java/org/ditacommunity/i18n/collation/ZhCnDictionary.java
@@ -0,0 +1,95 @@
+package org.ditacommunity.i18n.collation;
+
+import java.io.*;
+import java.net.URI;
+import java.net.URL;
+import java.text.ParseException;
+import java.util.TreeMap;
+
+/**
+ * Provides a mapping of Simplified Chinese (zh-CN) words to their pinyin
+ * transliterations.
+ * The dictionary data is derived from the open-source CC-CEDICT dictionary.
+ *
+ */
+public class ZhCnDictionary {
+
+ private static final TreeMap pinyinByWord = new TreeMap();
+
+ static {
+ loadDictionaryFromCSV();
+ }
+
+ private static void loadDictionaryFromCSV() {
+ String resourceUri = "resources/lookup-zh-cn.csv";
+ URL resource = ZhCnDictionary.class.getResource(resourceUri);
+ if (resource == null) {
+ throw new RuntimeException("Failed to load zh-CN data set \"" + resourceUri + "\"");
+ }
+ try {
+ InputStream inStream = resource.openStream();
+ BufferedReader reader = new BufferedReader(new InputStreamReader(inStream));
+ String line;
+ while((line = reader.readLine()) != null) {
+ if (line.startsWith("#")) continue;;
+ String[] parts = line.split("\t");
+ if (parts.length >= 2) {
+ pinyinByWord.put(parts[0], parts[1]);
+ } else {
+ // Only 1 part, nothing we can do.
+ }
+ }
+
+
+ } catch (Exception e) {
+ throw new RuntimeException(e.getClass().getSimpleName() + " loading zh-CN data set \"" + resourceUri + "\"");
+ }
+ }
+
+ /**
+ * Get the pinyin transliteration for the specified Simplified Chinese string.
+ * @param source Word to get transliteration for.
+ * @return The transliteration or the input string if no transliteration was found.
+ */
+ public static String getPinYin(String source) {
+ String pinyin = lookupPinYin(source);
+ if (pinyin == null) {
+ return source;
+ }
+ return pinyin;
+ }
+
+ /**
+ * Look up the pinyin transliteration. Finds the longest
+ * entry that matches the start of the source.
+ * @param source Source to look up.
+ * @return The pinyin transliteration, if found, or null if not found.
+ */
+ protected static String lookupPinYin(String source) {
+ String result = findLongestMatch(source);
+ if (result == null) {
+ return source;
+ } else {
+ return result;
+ }
+ }
+
+ /**
+ * Recursive function to find the pinyin value for the
+ * longest zh-CN key that matches the start of the source.
+ * @param source The text to find the pinyin for
+ * @return The pinyin or null if no matching key is found.
+ */
+ private static String findLongestMatch(String source) {
+ String pinyin = pinyinByWord.get(source);
+ if (null != pinyin) {
+ return pinyin;
+ } else {
+ if (source.length() <= 1) {
+ return null; // No possible match
+ } else {
+ return findLongestMatch(source.substring(0, source.length() - 1));
+ }
+ }
+ }
+}
diff --git a/src/main/java/org/ditacommunity/i18n/collation/configuration/ComparatorException.java b/src/main/java/org/ditacommunity/i18n/collation/configuration/ComparatorException.java
new file mode 100755
index 0000000..da8c7bf
--- /dev/null
+++ b/src/main/java/org/ditacommunity/i18n/collation/configuration/ComparatorException.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2016 DITA Community
+ *
+ * Adapted from ISOGEN I18N utilities project
+ * (https://www.antennahouse.com/antenna1/i18n-support-library-2/) originally
+ * developed by Eliot Kimber and enhanced by Antenna House.
+ *
+ * This code has been generalized to any need for grouping, and collation,
+ * not just indexes, and removes features not needed in the context of the
+ * DITA Open Toolkit. Updated to work with current ICU4J libraries.
+ */
+
+/*--------------------------------------------------------------------------------
+Copyright (C) 2004 ISOGEN International
+
+http://www.isogen.com
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation.
+
+This program 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 for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+--------------------------------------------------------------------------------*/
+package org.ditacommunity.i18n.collation.configuration;
+
+public class ComparatorException extends Exception {
+
+ private static final long serialVersionUID = 6958751071064252240L;
+
+ /**
+ * @param msg Message for this exception instance.
+ * @param e Exception to be chained to this one.
+ */
+ public ComparatorException(String msg, Exception e) {
+ super(msg, e);
+
+ }
+
+}
diff --git a/src/main/java/org/ditacommunity/i18n/collation/configuration/Group.java b/src/main/java/org/ditacommunity/i18n/collation/configuration/Group.java
new file mode 100755
index 0000000..d85cc53
--- /dev/null
+++ b/src/main/java/org/ditacommunity/i18n/collation/configuration/Group.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2016 DITA Community
+ *
+ * Adapted from ISOGEN I18N utilities project
+ * (https://www.antennahouse.com/antenna1/i18n-support-library-2/) originally
+ * developed by Eliot Kimber and enhanced by Antenna House.
+ *
+ * This code has been generalized to any need for grouping, and collation,
+ * not just indexes, and removes features not needed in the context of the
+ * DITA Open Toolkit. Updated to work with current ICU4J libraries.
+ */
+package org.ditacommunity.i18n.collation.configuration;
+
+import org.ditacommunity.i18n.util.I18nUtil;
+import org.ditacommunity.i18n.util.I18nUtilError;
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+
+import java.util.Vector;
+
+/**
+ * Represents a single index group within a language-specific index configuration.
+ *
+ */
+class Group {
+ // Sort strategy defines how membership in a group is determined, either by
+ // sorting between the group keys (e.g., for Traditional Chinese) or by
+ // explicit group membership. The default is by membership.
+ public String key; // The string key for this index group
+ public String label; // The display label for this index group
+ public String groupSortKey; // The key by which the group is sorted in the presented index
+ public Vector members = new Vector(); // The character set members of the group
+ public GroupingAndSortingRuleSet indexConfiguration; // The index configuration we're a part of
+ public String lastMember = null; // Used for last group when doing between-key sorting.
+
+
+ public Group(GroupingAndSortingRuleSet parent, Element igElem) throws GroupingAndSortingHelperException {
+ indexConfiguration = parent;
+ try {
+ Element gkElem = I18nUtil.getElement(igElem, "group_key");
+ key = I18nUtil.getElementContent(gkElem);
+ if (key.equals("")) {
+ throw new GroupingAndSortingHelperException("Null value for element in element in element in with key '" + key + "', language '" + parent.getLanguage() + "'");
+ }
+ }
+ } else {
+ // Sort by keys
+ try {
+ Element charSetElem = I18nUtil.getElement(igElem, "char_or_seq");
+ lastMember = I18nUtil.getElementContent(charSetElem);
+ if (lastMember.equals("")) {
+ throw new GroupingAndSortingHelperException("Null value for element in for language '" + parent.getLanguage() + "'");
+ }
+ } catch (I18nUtilError e) {
+ // Nothing to do.
+ }
+ }
+ } catch (I18nUtilError e) {
+ throw new GroupingAndSortingHelperException(e.getMessage());
+ }
+
+ }
+
+ public String toString() {
+ String outStr = "";
+ outStr = outStr + "\n\t\tKey: '" + I18nUtil.escapeUnicodeString(key) + "'";
+ outStr = outStr + "\n\t\tLabel: '" + I18nUtil.escapeUnicodeString(label) + "'";
+ outStr = outStr + "\n\t\tMembers:";
+ if (this.lastMember != null) {
+ outStr = outStr + "\n\t\t\t LastMember='" +
+ I18nUtil.escapeUnicodeString(this.lastMember) +
+ "'";
+ } else {
+ for (int i = 0; i < members.size(); i++) {
+ outStr = outStr + "\n\t\t\t'" +
+ I18nUtil.escapeUnicodeString((String)members.elementAt(i)) +
+ "'";
+ }
+ }
+ return outStr;
+ }
+}
diff --git a/src/main/java/org/ditacommunity/i18n/collation/configuration/GroupingAndSortingHelper.java b/src/main/java/org/ditacommunity/i18n/collation/configuration/GroupingAndSortingHelper.java
new file mode 100755
index 0000000..1268cc8
--- /dev/null
+++ b/src/main/java/org/ditacommunity/i18n/collation/configuration/GroupingAndSortingHelper.java
@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) 2016 DITA Community
+ *
+ * Adapted from ISOGEN I18N utilities project
+ * (https://www.antennahouse.com/antenna1/i18n-support-library-2/) originally
+ * developed by Eliot Kimber and enhanced by Antenna House.
+ *
+ * This code has been generalized to any need for grouping, and collation,
+ * not just indexes, and removes features not needed in the context of the
+ * DITA Open Toolkit. Updated to work with current ICU4J libraries.
+ */
+
+/*--------------------------------------------------------------------------------
+ Copyright (C) 2003 ISOGEN International
+
+ http://www.isogen.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ --------------------------------------------------------------------------------*/
+package org.ditacommunity.i18n.collation.configuration;
+
+import com.ibm.icu.text.RuleBasedCollator;
+import org.ditacommunity.i18n.util.I18nUtil;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import java.util.Comparator;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.Locale;
+
+/* Correction comment-1(a)
+ * May 31, 2005 Antenna House, Inc.
+ */
+// Correction comment-1(a)
+
+/**
+ *
+ * Provides services that support the generation of back-of-the-book
+ * indexes.
+ *
+ * FIXME: Make the methods static.
+ */
+public class GroupingAndSortingHelper {
+ // SORT_ENGLISH_MIXED is used for zh-CN index only.
+ // SORT_ENGLISH_BEFORE is default.
+ // SORT_ENGLISH_AFTER is not implemented from beginning.
+ // Added 2009/03/24 Antenna House, Inc. t.makita
+ public static final int SORT_ENGLISH_BEFORE = GroupingAndSortingRuleSet.SORT_ENGLISH_BEFORE;
+ public static final int SORT_ENGLISH_AFTER = GroupingAndSortingRuleSet.SORT_ENGLISH_AFTER;
+ public static final int SORT_ENGLISH_MIXED = GroupingAndSortingRuleSet.SORT_ENGLISH_MIXED;
+
+ public static final String ELEMENT_INDEX_CONFIG = "index_config";
+ public static final String ELEMENT_NATIONAL_LANGUAGE = "national_language";
+ public static final String LANGUAGE_EN = "en";
+ public static final String GROUP_KEY_NUMERIC = "#NUMERIC";
+
+ private Document configDom;
+ private Element rootElem=null;
+ private NodeList nlIndexConfig=null;
+
+ java.io.File configFile;
+ java.util.Hashtable configs = new java.util.Hashtable();
+
+ java.util.Vector missingLangCode = new java.util.Vector();
+
+ /**
+ *
+ * Construct new groupingAndSortingHelper with configuration.
+ *
+ * @parm configFilename Filename of index configuration XML document.
+ */
+ public GroupingAndSortingHelper(String configFilename) throws GroupingAndSortingHelperException {
+ configFile = new java.io.File(configFilename);
+ loadRuleSetDom(configFilename);
+ }
+
+ public GroupingAndSortingHelper() {
+ configFile = null;
+ }
+
+ /**
+ * Loads the specified index configuration file.
+ *
+ * @param configFilename Filename of the index configuration file.
+ * @throws GroupingAndSortingHelperException
+ */
+ public void loadRuleSetDoc(String configFilename)
+ throws GroupingAndSortingHelperException {
+ configFile = new java.io.File(configFilename);
+ if (!configFile.exists()) {
+ throw new GroupingAndSortingHelperException("loadRuleSetDoc(): Cannot find index configuration file '" + configFile.getAbsolutePath() + "'");
+ }
+ loadRuleSetDom(configFile.getAbsolutePath());
+ }
+
+ /**
+ * Loads the DOM for the index configuration doc. Doesn't do anything with
+ * the doc at this point--that is done when a request is actually made.
+ */
+ void loadRuleSetDom(String configFilename) throws GroupingAndSortingHelperException {
+ try {
+ DocumentBuilderFactory factory
+ = DocumentBuilderFactory.newInstance();
+ DocumentBuilder parser = factory.newDocumentBuilder();
+ configDom = parser.parse(configFilename);
+ } catch (Throwable e) {
+ throw new GroupingAndSortingHelperException("Error constructing DOM from docid '" +
+ configFilename + ": " +
+ e.getMessage());
+ }
+
+ this.rootElem = configDom.getDocumentElement();
+ if (this.rootElem == null) {
+ throw new GroupingAndSortingHelperException("Failed to find root element of index configuration document " +
+ configFilename);
+ }
+ this.nlIndexConfig = this.rootElem.getElementsByTagName(ELEMENT_INDEX_CONFIG);
+ if (this.nlIndexConfig.getLength() == 0) {
+ throw new GroupingAndSortingHelperException("Failed to find any '" + ELEMENT_INDEX_CONFIG + "' elements");
+ }
+ }
+
+ /**
+ * Loads the index configuration information for the parent language of the specified language.
+ * Raises an exception if the language's configuration information can't be found.
+ *
+ * @param locale The locale to get the rule set for.
+ */
+
+ GroupingAndSortingRuleSet getRuleSet(Locale locale) throws GroupingAndSortingHelperException {
+ String langCode = locale.toLanguageTag();
+ String parentLangCode=getParentLangCode(langCode);
+ if (configs.containsKey(parentLangCode)) {
+ return configs.get(parentLangCode);
+ }
+
+ // System.err.println("*** getRuleSet(): loading index config for language " + langCode);
+ GroupingAndSortingRuleSet ic = loadRuleSet(locale);
+ configs.put(langCode, ic);
+ // System.err.println("*** getRuleSet(): returning config for language " + langCode);
+ return ic;
+ }
+
+ GroupingAndSortingRuleSet loadRuleSet(Locale locale) throws GroupingAndSortingHelperException {
+ final String methodName="[loadRuleSet] ";
+
+ String langCode = locale.toLanguageTag();
+
+ Element indexConfigElement = null;
+ String parentLangCode="";
+ for (int i = 0; i < nlIndexConfig.getLength(); i++) {
+ Element candIndexConfigElem = (Element)(nlIndexConfig.item(i));
+ NodeList nl = candIndexConfigElem.getElementsByTagName(ELEMENT_NATIONAL_LANGUAGE);
+ if (nl.getLength() == 0) {
+ throw new GroupingAndSortingHelperException(methodName + "Missing required " + ELEMENT_NATIONAL_LANGUAGE + " element within " + ELEMENT_INDEX_CONFIG + " element");
+ }
+ parentLangCode="";
+ for (int j=0;j < nl.getLength(); j++){
+ String candLangCode = I18nUtil.getElementContent((Element)nl.item(j));
+ if (candLangCode.equals("")) {
+ System.err.println(methodName + "WARNING: GroupingAndSortingRuleSet - Null value for <" + ELEMENT_NATIONAL_LANGUAGE + "> element in <" + ELEMENT_INDEX_CONFIG + ">");
+ continue;
+ }
+ Boolean isParentLangCode=(j==0)?true:false;
+ if (isParentLangCode){
+ parentLangCode = candLangCode;
+ }
+ if (candLangCode.equalsIgnoreCase(langCode)){
+ indexConfigElement = candIndexConfigElem;
+ break;
+ }
+ }
+ if (indexConfigElement != null){
+ break;
+ }
+ }
+ if (indexConfigElement == null & langCode.equals(LANGUAGE_EN)) {
+ throw new GroupingAndSortingHelperException(methodName + "Failed to find index configuration for language '" + langCode + "'");
+ }
+ if (indexConfigElement == null & !langCode.equals(LANGUAGE_EN)) {
+ System.err.println(methodName + "Failed to find index configuration for language '" + langCode + "', trying " + locale.getDefault().toLanguageTag());
+ return this.getRuleSet(Locale.getDefault());
+ }
+ /**
+ * Generate GroupingAndSortingRuleSet using parent language code.
+ * 2011-11-22 Antenna House, Inc. t.makita
+ */
+ //System.err.println("*** loadRuleSet: loading index rule set for " + langCode);
+ //GroupingAndSortingRuleSet ic = new GroupingAndSortingRuleSet(this, langCode, indexConfigElement, configFile);
+ GroupingAndSortingRuleSet ic =
+ new GroupingAndSortingRuleSet(this, locale, indexConfigElement, configFile);
+
+ return ic;
+ }
+
+ public Iterator getIndexGroupKeysIterator(Locale locale) throws GroupingAndSortingHelperException {
+ String langCode = locale.toLanguageTag();
+ String parentLangCode = getParentLangCode(langCode);
+ GroupingAndSortingRuleSet ic = getRuleSet(locale);
+ return ic.getGroupKeysIterator();
+ }
+
+ /* Correction comment-1(b)
+ * May 31, 2005 Antenna House, Inc.
+ */
+ public RuleBasedCollator getComparator(Locale locale) throws GroupingAndSortingHelperException {
+ String langCode = locale.toLanguageTag();
+ String parentLangCode=getParentLangCode(langCode);
+ GroupingAndSortingRuleSet ic = getRuleSet(locale);
+ RuleBasedCollator co = ic.getComparator();
+ return co;
+ }
+ // Correction comment-1(b)
+
+ /**
+ * Given a dialect language code, returns the parent language code.
+ * The parent language code must be placed as the first child
+ * of element.
+ * @param langCode The input language code.
+ * @return Parent language code. (LANGUAGE_EN if not found.)
+ * @author 2012-01-11 Antenna House, Inc. t.makita
+ */
+ private String getParentLangCode(String langCode){
+ final String methodName="[getParentLangCode] ";
+ for (int i = 0; i < nlIndexConfig.getLength(); i++) {
+ Element indexConfigElem = (Element)(nlIndexConfig.item(i));
+ NodeList nl = indexConfigElem.getElementsByTagName(ELEMENT_NATIONAL_LANGUAGE);
+ String parentLangCode = "";
+ for (int j=0;j < nl.getLength(); j++){
+ Element elmNationalLanguage=(Element)nl.item(j);
+ String candLangCode = I18nUtil.getElementContent(elmNationalLanguage);
+ Boolean isParentLangCode=(j==0)?true:false;
+ if (isParentLangCode){
+ parentLangCode = candLangCode;
+ }
+ if (candLangCode.equalsIgnoreCase(langCode)){
+ return parentLangCode;
+ }
+ }
+ }
+ if (!missingLangCode.contains(langCode)){
+ System.err.println(methodName + "WARNING! Failed to find language code entry for '" + langCode + "'. Using English instead.");
+ missingLangCode.add(langCode);
+ }
+ return LANGUAGE_EN;
+ }
+
+ public String printRuleSet(Locale locale,
+ boolean includeCollationRules)
+ throws GroupingAndSortingHelperException {
+ String langCode = locale.toLanguageTag();
+ String parentLangCode=getParentLangCode(langCode);
+ GroupingAndSortingRuleSet ic = getRuleSet(locale);
+ return ic.toString(includeCollationRules);
+ }
+
+ public String printRuleSet(Locale locale)
+ throws GroupingAndSortingHelperException {
+ String langCode = locale.toLanguageTag();
+ String parentLangCode=getParentLangCode(langCode);
+ return printRuleSet(locale, false);
+ }
+
+ public String toString() {
+ return toString(true);
+ }
+
+ public String toString(boolean includeCollationRules) {
+ String outStr = "";
+ Enumeration configs = this.configs.elements();
+ while (configs.hasMoreElements()) {
+ GroupingAndSortingRuleSet ic = configs.nextElement();
+ outStr = outStr + ic.toString(includeCollationRules);
+ }
+ return outStr;
+ }
+}
diff --git a/src/main/java/org/ditacommunity/i18n/collation/configuration/GroupingAndSortingHelperException.java b/src/main/java/org/ditacommunity/i18n/collation/configuration/GroupingAndSortingHelperException.java
new file mode 100755
index 0000000..126b94a
--- /dev/null
+++ b/src/main/java/org/ditacommunity/i18n/collation/configuration/GroupingAndSortingHelperException.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2016 DITA Community
+ *
+ * Adapted from ISOGEN I18N utilities project
+ * (https://www.antennahouse.com/antenna1/i18n-support-library-2/) originally
+ * developed by Eliot Kimber and enhanced by Antenna House.
+ *
+ * This code has been generalized to any need for grouping, and collation,
+ * not just indexes, and removes features not needed in the context of the
+ * DITA Open Toolkit. Updated to work with current ICU4J libraries.
+ */
+
+/*--------------------------------------------------------------------------------
+ Copyright (C) 2002 ISOGEN International
+
+ http://www.isogen.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program 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 for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ --------------------------------------------------------------------------------*/
+package org.ditacommunity.i18n.collation.configuration;
+
+/**
+ *
+ */
+public class GroupingAndSortingHelperException extends Exception {
+
+ private static final long serialVersionUID = -8716641887130439334L;
+
+ public GroupingAndSortingHelperException() {
+ }
+
+ public GroupingAndSortingHelperException(String msg) {
+ super(msg);
+ }
+
+ /**
+ * @param e
+ */
+ public GroupingAndSortingHelperException(Throwable e) {
+ super(e);
+ }
+}
+
+
diff --git a/src/main/java/org/ditacommunity/i18n/collation/configuration/GroupingAndSortingRuleSet.java b/src/main/java/org/ditacommunity/i18n/collation/configuration/GroupingAndSortingRuleSet.java
new file mode 100755
index 0000000..c74df45
--- /dev/null
+++ b/src/main/java/org/ditacommunity/i18n/collation/configuration/GroupingAndSortingRuleSet.java
@@ -0,0 +1,481 @@
+/*
+ * Copyright (c) 2016 DITA Community
+ *
+ * Adapted from ISOGEN I18N utilities project
+ * (https://www.antennahouse.com/antenna1/i18n-support-library-2/) originally
+ * developed by Eliot Kimber and enhanced by Antenna House.
+ *
+ * This code has been generalized to any need for grouping, and collation,
+ * not just indexes, and removes features not needed in the context of the
+ * DITA Open Toolkit. Updated to work with current ICU4J libraries.
+ */
+
+/*
+ * Created on Jul 26, 2004
+ *
+ */
+package org.ditacommunity.i18n.collation.configuration;
+
+import com.ibm.icu.text.Collator;
+import com.ibm.icu.text.RuleBasedCollator;
+import org.ditacommunity.i18n.util.I18nUtil;
+import org.ditacommunity.i18n.util.I18nUtilError;
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+
+import java.io.File;
+import java.util.*;
+
+/**
+*
+* @author eliot
+* @version
+*
+* Holds the index configuration data for a single national language.
+*/
+public class GroupingAndSortingRuleSet {
+
+ public static final int SORT_METHOD_BETWEEN_KEYS = 0;
+ public static final int SORT_METHOD_BY_MEMBERS = 1;
+ public static final int SORT_ENGLISH_BEFORE = 0;
+ public static final int SORT_ENGLISH_AFTER = 1;
+ public static final int SORT_ENGLISH_MIXED = 2; // Added for use zh-CN index only. 2009/03/24 t.makita
+ public static final int SORT_GROUPS_BY_KEYS = 0;
+ public static final int SORT_GROUPS_BY_LABELS = 1;
+
+
+ String langCode = null; // The language code for the locale(s) this configuration applies to
+ Locale locale = null;
+ String collationRuleSpec = null;
+
+ TreeMap indexGroups; // Index group definitions by group key. Keys are sorted in ascending collation order
+ ArrayList threeCharMembers = new ArrayList(); // List of members that are 3 characters
+ ArrayList twoCharMembers = new ArrayList(); // List of members that are 2 characters
+ Hashtable members2keys = new Hashtable(); // Reverse index of group keys by member
+ RuleBasedCollator comparator = null; // Comparator used for this language to sort stuff within the index
+ Element configElem = null; // The DOM node that is the index_config element for this configuration.
+ public int sortStrategy = SORT_METHOD_BY_MEMBERS; // Default
+ public int sortEnglish = SORT_ENGLISH_BEFORE; // Default
+ public int sortGroups = SORT_GROUPS_BY_KEYS; // Default
+ GroupingAndSortingHelper groupingAndSortingHelper = null;
+
+ boolean ignoreEnglish = false; // Ignore English group key. 2013/10/31 t.makita
+
+ public GroupingAndSortingRuleSet(GroupingAndSortingHelper inGroupingAndSortingHelper,
+ Locale locale,
+ Element indexConfigElement,
+ File configFile)
+ throws GroupingAndSortingHelperException {
+ // NOTE: configFile is intended to allow us to find resources relative to the
+ // the configuration file, but that's not implemented yet.
+
+ /* Correction comment-2(1)
+ * May 23, 2006 Antenna House, Inc.
+ */
+ int use_java_collator = 0;
+ int replace_rules = 0;
+ langCode = locale.toLanguageTag();
+ groupingAndSortingHelper = inGroupingAndSortingHelper;
+ configElem = indexConfigElement;
+ Element colSpecElem = null;
+ try {
+ colSpecElem = I18nUtil.getElement(configElem, "collation_spec");
+ if (I18nUtil.hasElementChildren(colSpecElem)) {
+ Element collatorSpecElem = I18nUtil.getElement(colSpecElem, "java_collation_spec");
+ /* Correction comment-2(2)
+ * May 23, 2006 Antenna House, Inc.
+ */
+ NodeList node_use_java_collator = colSpecElem.getElementsByTagName("use_java_collator");
+ if (node_use_java_collator.getLength() != 0) {
+ use_java_collator = 1;
+ }
+ NodeList node_replace_rules = colSpecElem.getElementsByTagName("replace_rules");
+ if (node_replace_rules.getLength() != 0) {
+ replace_rules = 1;
+ }
+ NodeList nl = colSpecElem.getElementsByTagName("include_collation_spec");
+ if (nl.getLength() == 0) {
+ collationRuleSpec = I18nUtil.getElementContent(collatorSpecElem);
+ } else {
+ // FIXME: For now we're just processing the first rule spec file we get.
+ Element ecsElem = (Element)nl.item(0);
+ String collationRuleFileName = I18nUtil.getElementContent(ecsElem);
+ File collationRuleFile = new File(configFile.getParentFile(), collationRuleFileName);
+
+ if (!collationRuleFile.exists()) {
+ System.err.println("*** Cannot find comparator rule spec file " + collationRuleFile.getAbsolutePath());
+
+ }
+ /* Correction comment-2(3)
+ * May 23, 2006 Antenna House, Inc.
+ */
+ collationRuleSpec = I18nUtil.readUnicodeFile(collationRuleFile, "UTF-8");
+ }
+
+ }
+ } catch (Throwable e) {
+ throw new GroupingAndSortingHelperException(e.getMessage());
+ }
+
+ // System.err.println("collationRuleSpec=" + collationRuleSpec);
+ // See if there are any custom sort rules for this language code:
+
+ /* Correction comment-2(4)
+ * May 23, 2006 Antenna House, Inc.
+ */
+ try {
+ comparator = IcuComparatorFactoryImpl.getComparatorForLocale(locale, collationRuleSpec, replace_rules);
+ } catch (Exception e) {
+ throw new GroupingAndSortingHelperException(e);
+ }
+
+ try {
+ @SuppressWarnings("unused")
+ Element sbkElem = I18nUtil.getElement(configElem, "sort_between_keys");
+ this.sortStrategy = GroupingAndSortingRuleSet.SORT_METHOD_BETWEEN_KEYS;
+ } catch (I18nUtilError e) {
+ // Nothing to do
+ }
+
+ try {
+ @SuppressWarnings("unused")
+ Element sgbkElem = I18nUtil.getElement(configElem, "sort_by_members");
+ this.sortGroups = GroupingAndSortingRuleSet.SORT_GROUPS_BY_LABELS;
+ } catch (I18nUtilError e) {
+ // Nothing to do
+ }
+
+ /*
+ * Added to support GroupingAndSortingRuleSet.SORT_ENGLISH_MIXED for zh-CN.
+ * 2009/03/24 t.makita Antenna House, Inc.
+ */
+ boolean getEnglishOption=false;
+
+ try {
+ @SuppressWarnings("unused") Element seElem=I18nUtil.getElement(configElem, "sort_english_before");
+ this.sortEnglish= GroupingAndSortingRuleSet.SORT_ENGLISH_BEFORE;
+ getEnglishOption=true;
+ } catch (I18nUtilError e) {
+ // Nothing to do
+ }
+ if (!getEnglishOption){
+ try {
+ @SuppressWarnings("unused") Element seElem=I18nUtil.getElement(configElem, "sort_english_after");
+ this.sortEnglish= GroupingAndSortingRuleSet.SORT_ENGLISH_AFTER;
+ getEnglishOption=true;
+ } catch (I18nUtilError e) {
+ // Nothing to do
+ }
+ }
+ if (!getEnglishOption){
+ try {
+ @SuppressWarnings("unused") Element seElem=I18nUtil.getElement(configElem, "sort_english_mixed");
+ this.sortEnglish= GroupingAndSortingRuleSet.SORT_ENGLISH_MIXED;
+ getEnglishOption=true;
+ } catch (I18nUtilError e) {
+ // Nothing to do
+ }
+ }
+ if (!getEnglishOption){
+ if (this.langCode.compareToIgnoreCase("zh-cn")==0){
+ this.sortEnglish= GroupingAndSortingRuleSet.SORT_ENGLISH_MIXED;
+ }else{
+ this.sortEnglish= GroupingAndSortingRuleSet.SORT_ENGLISH_BEFORE;
+ }
+ }
+
+ // English group key treatment. 2013/10/31 t.makita
+ try {
+ @SuppressWarnings("unused") Element seElem=I18nUtil.getElement(configElem, "ignore_english");
+ this.ignoreEnglish=true;
+ } catch (I18nUtilError e) {
+ // Nothing to do
+ }
+
+ indexGroups = new TreeMap(comparator);
+
+ Element igsElem = null;
+ try {
+ igsElem = I18nUtil.getElement(indexConfigElement, "group_definitions");
+ } catch (I18nUtilError e) {
+ throw new GroupingAndSortingHelperException(e.getMessage());
+ }
+ if (igsElem == null) {
+ throw new GroupingAndSortingHelperException("No group_definitions element within index_config element");
+ }
+ NodeList nl = igsElem.getElementsByTagName("term_group");
+ if (nl.getLength() == 0) {
+ throw new GroupingAndSortingHelperException("No term_group elements within group_definitions element");
+ }
+ // System.err.println("found " + nl.getLength() + " term_group elements");
+ for (int i = 0; i < nl.getLength(); i++) {
+ Element igElem = (Element)nl.item(i);
+ Group ig = new Group(this, igElem);
+
+ //System.err.println("key=" +
+ // I18nUtil.escapeUnicodeString(ig.key));
+
+ /* Correction comment-3
+ * May 31, 2005 Antenna House, Inc.
+ *
+ String lastKey = "\u0002";
+ if (comparator.compare(ig.key, lastKey) < 0) {
+ throw new GroupingAndSortingHelperException("Key '" + I18nUtil.escapeUnicodeString(ig.key) +
+ "' sorts below previous key '" +
+ I18nUtil.escapeUnicodeString(lastKey) + "'");
+ }
+ * Correction comment-3 */
+
+ //String lastKey = ig.key;
+ indexGroups.put(ig.key, ig);
+ // System.err.println("indexGroups.size()=" + indexGroups.size());
+ for (int j = 0; j < ig.members.size(); j++) {
+ String mem = (String)ig.members.get(j);
+ if (mem.length() == 3) {
+ threeCharMembers.add(mem);
+ } else if (mem.length() == 2) {
+ twoCharMembers.add(mem);
+ }
+ members2keys.put(mem, ig.key);
+ }
+ }
+ }
+
+ // Added GroupingAndSortingRuleSet.SORT_ENGLISH_MIXED for zh-CN.
+ // 2009/03/24 t.makita AntennaHouse, Inc.
+ public int getEnglishIndexPosition(){
+ return this.sortEnglish;
+ }
+
+ public String getLanguage() {
+ return langCode;
+ }
+
+ public Locale getLocale() {
+ return locale;
+ }
+
+ public Iterator getGroupKeysIterator() throws GroupingAndSortingHelperException {
+ // Need to get English keySet iterator and append or prepend it to
+ // the main language iterator.
+ ArrayList al = new ArrayList(indexGroups.keySet());
+ // Get the second key list
+ GroupingAndSortingRuleSet engConfig = this.groupingAndSortingHelper.getRuleSet(Locale.ENGLISH);
+ if (this.sortEnglish == GroupingAndSortingRuleSet.SORT_ENGLISH_AFTER) {
+ al.addAll(al.size(),engConfig.indexGroups.keySet());
+ } else {
+ al.addAll(0,engConfig.indexGroups.keySet());
+ }
+ return al.iterator();
+ }
+
+ public String getGroupKey(String indexEntry) throws GroupingAndSortingHelperException {
+ if (indexEntry.equals("")) {
+ return null;
+ }
+ if (this.sortStrategy == GroupingAndSortingRuleSet.SORT_METHOD_BETWEEN_KEYS) {
+ return this.getSortKeyByKeys(indexEntry);
+ }
+ if (this.sortStrategy == GroupingAndSortingRuleSet.SORT_METHOD_BY_MEMBERS) {
+ return this.getSortKeyByMembers(indexEntry);
+ }
+ throw new GroupingAndSortingHelperException("Unrecognized sort method value '" +
+ String.valueOf(this.sortStrategy) + "'");
+ }
+
+
+ String getSortKeyByMembers(String textToBeGrouped) throws GroupingAndSortingHelperException {
+ // Check for 3- and 2-character sequences then lookup the sort key
+ String candMember = null;
+ if (textToBeGrouped.length() > 2) {
+ if (threeCharMembers.contains(textToBeGrouped.substring(0,3))) {
+ candMember = textToBeGrouped.substring(0,3);
+ }
+ }
+ if (candMember == null & (textToBeGrouped.length() > 1)) {
+ if (twoCharMembers.contains(textToBeGrouped.substring(0,2))) {
+ candMember = textToBeGrouped.substring(0,2);
+ }
+ }
+ if (candMember == null) {
+ candMember = textToBeGrouped.substring(0,1);
+ }
+ if (members2keys.containsKey(candMember)) {
+ return (String)members2keys.get(candMember);
+ }
+ // Try to get English group key if this configuration is not English and is not specified. 2013/11/01 t.makita
+ if (!this.ignoreEnglish && !this.langCode.equals("en")){
+ GroupingAndSortingRuleSet engConfig = this.groupingAndSortingHelper.getRuleSet(Locale.ENGLISH);
+ return engConfig.getGroupKey(textToBeGrouped);
+ }else{
+ return "#NUMERIC";
+ }
+ }
+
+ /**
+ * Returns the index group sort key for the specified index entry string,
+ * using the group keys as the sort boundaries.
+ *
+ * Return "#NUMERIC" if the entry does not map to an index key in the configuration
+ * (i.e., the string is a numeric or other special character).
+ *
+ * @param indexEntry the index entry string for which a sort key is requested.
+ */
+ String getSortKeyByKeys(String indexEntry) throws GroupingAndSortingHelperException {
+ // Iterate over the indexGroups key list and compare
+ Object[] keys = this.indexGroups.keySet().toArray();
+ // If indexEntry is less than the first key entry, get group key form English rule set.
+ // Added condition for 2013/11/01 t.makita
+ if ((this.comparator.compare(indexEntry,(String)keys[0]) < 0) && (!this.ignoreEnglish)) {
+ GroupingAndSortingRuleSet engConfig = this.groupingAndSortingHelper.getRuleSet(Locale.ENGLISH);
+ return engConfig.getGroupKey(indexEntry);
+ }
+ //String c = indexEntry.substring(0,1);
+ //System.err.println("Index entry=" + I18nUtil.escapeUnicodeString(indexEntry));
+ for (int i = 0; i < (keys.length); i++) {
+ String secondKey = null;
+ if (i == (keys.length - 1)) {
+ secondKey = ((Group)this.indexGroups.get(this.indexGroups.lastKey())).lastMember;
+ // Added 2006-12-22 t.makita
+ if ((this.comparator.compare(indexEntry,(String)keys[i]) >= 0) &&
+ (this.comparator.compare(indexEntry, secondKey) <= 0)) {
+ return (String)keys[i];
+ }
+
+ } else {
+ secondKey = (String)keys[i+1];
+ // Added 2006-12-22 t.makita
+ if ((this.comparator.compare(indexEntry,(String)keys[i]) >= 0) &&
+ (this.comparator.compare(indexEntry, secondKey) < 0)) {
+ return (String)keys[i];
+ }
+ }
+ // Deleted 2006-12-22 t.makita
+ //if ((this.comparator.compare(indexEntry,(String)keys[i]) >= 0) &&
+ // (this.comparator.compare(indexEntry, secondKey) < 0)) {
+ // return (String)keys[i];
+ //}
+ }
+ return "#NUMERIC";
+ }
+
+ public Group getIndexGroup(String groupKey) throws GroupingAndSortingHelperException {
+ if (indexGroups.containsKey(groupKey)) {
+ return (Group)indexGroups.get(groupKey);
+ }
+ if (!this.langCode.equals("en")) {
+ GroupingAndSortingRuleSet engConfig = this.groupingAndSortingHelper.getRuleSet(Locale.ENGLISH);
+ return engConfig.getIndexGroup(groupKey);
+ }
+ throw new GroupingAndSortingHelperException("GroupingAndSortingHelper.getIndexGroup(): No group with key '" +
+ I18nUtil.escapeUnicodeString(groupKey) +
+ "' for language '" + langCode + "'");
+ }
+
+ public String getGroupSortKey(String groupKey) throws GroupingAndSortingHelperException {
+ if (indexGroups.containsKey(groupKey)) {
+ return ((Group)indexGroups.get(groupKey)).groupSortKey;
+ }
+ throw new GroupingAndSortingHelperException("GroupingAndSortingHelper.getGroupSortKey(): No group with key '" +
+ I18nUtil.escapeUnicodeString(groupKey) +
+ "' for language '" + langCode + "'");
+ }
+
+ /**
+ * Returns the Collator object for this index configuration.
+ *
+ */
+ public RuleBasedCollator getComparator() {
+ return comparator;
+ }
+
+ /**
+ * Produces a string representation of the index configuration rules.
+ * @param includeCollationRules
+ * @return
+ */
+ public String toString(boolean includeCollationRules) {
+ String outStr = "\nIndex Configuration\n";
+ outStr = outStr + "\n\tLanguage: " + this.langCode;
+ // FIXME: Get the description
+ if (includeCollationRules) {
+ if (collationRuleSpec != null) {
+ outStr = outStr + "\n\tCollation spec: " + this.collationRuleSpec;
+ } else {
+ outStr = outStr + "\n\tCollation spec: Use Java rules";
+ }
+ } else {
+ outStr = outStr + "\n\tCollation spec: {not shown}";
+ }
+ outStr = outStr + "\n\tIndex Groups:";
+ Iterator gi = this.indexGroups.values().iterator();
+ while (gi.hasNext()) {
+ outStr = outStr + ((Group)gi.next()).toString();
+ }
+ return outStr + "\n";
+ }
+
+ public String toString() {
+ return toString(true);
+ }
+
+ void findAlphaStarts(Collator col) {
+ // This is a one-time-use thing but it seemed useful to keep the code around in
+ // case we need it again at some point.
+ // Given the Unicode-to-pinyin mapping from the Unihan database, figures out
+ // which character actually starts each letter group.
+
+ String[] letters = { "A", "B", "C", "D", "E", "F", "G", "H", "I",
+ "J", "K", "L", "M", "N", "O", "P", "Q", "R",
+ "S", "T", "U", "V", "W", "X", "Y", "Z" };
+
+ try {
+ String uhPY = I18nUtil.readUnicodeFile("mandarin.txt", "UTF8");
+ java.io.Reader sr = new java.io.StringReader(uhPY);
+ java.io.LineNumberReader lnr = new java.io.LineNumberReader(sr);
+ String inline = null;
+ inline = "";
+ int i = 0; // Index into letters[]
+ String candChar = "\uFFF0"; // Candidate for start of a letter group
+ String alphaCode = "";
+ alphaCode = letters[0];
+ while (inline != null) {
+ try {
+ inline = lnr.readLine();
+ } catch (java.io.IOException e) {
+ System.err.println(alphaCode + "=" +
+ I18nUtil.escapeUnicodeString(candChar));
+ break;
+ }
+ if (inline == null) {
+ System.err.println(alphaCode + "=" +
+ I18nUtil.escapeUnicodeString(candChar));
+ break;
+ }
+ int p = inline.indexOf(" ");
+ if (p <= 0) {
+ continue;
+ }
+ //System.err.println("inline='" + inline + "'");
+ String charCode = inline.substring(0,p);
+ String pinyin = inline.substring(p+2);
+ String firstChar = pinyin.substring(0,1);
+ if (firstChar.compareTo(alphaCode) > 0) {
+ // We've scanned to the next letter group, go to the
+ // next entry in letters[]
+ i++;
+ System.err.println(alphaCode + "=" +
+ I18nUtil.escapeUnicodeString(candChar));
+ alphaCode = letters[i];
+ candChar = "\uFFF0";
+ }
+ //
+ if (col.compare(candChar, charCode) > 0) {
+ candChar = charCode;
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+}
diff --git a/src/main/java/org/ditacommunity/i18n/collation/configuration/IcuComparatorFactoryImpl.java b/src/main/java/org/ditacommunity/i18n/collation/configuration/IcuComparatorFactoryImpl.java
new file mode 100755
index 0000000..7de5cf3
--- /dev/null
+++ b/src/main/java/org/ditacommunity/i18n/collation/configuration/IcuComparatorFactoryImpl.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2016 DITA Community
+ *
+ * Adapted from ISOGEN I18N utilities project
+ * (https://www.antennahouse.com/antenna1/i18n-support-library-2/) originally
+ * developed by Eliot Kimber and enhanced by Antenna House.
+ *
+ * This code has been generalized to any need for grouping, and collation,
+ * not just indexes, and removes features not needed in the context of the
+ * DITA Open Toolkit. Updated to work with current ICU4J libraries.
+ */
+
+/*
+ * Created on Sep 29, 2004
+ *
+ */
+package org.ditacommunity.i18n.collation.configuration;
+
+import java.util.Comparator;
+import java.util.Locale;
+
+import com.ibm.icu.text.RuleBasedCollator;
+
+/**
+ * Constructs ICU rule-based collators.
+ */
+public class IcuComparatorFactoryImpl {
+
+ /* Correction comment-2(5)
+ * May 23, 2006 Antenna House, Inc.
+ */
+ public static RuleBasedCollator getComparatorForLocale(
+ Locale locale, String collationRuleSpec, int replace_rules) throws ComparatorException {
+ // TODO: Use comparator/index configuration to get any local collation rules.
+ RuleBasedCollator col = null;
+ if (collationRuleSpec != null) {
+ try {
+ if (replace_rules == 0) {
+ String baseRules = ((RuleBasedCollator)com.ibm.icu.text.Collator.getInstance(locale)).getRules();
+ String addRules = collationRuleSpec;
+ collationRuleSpec = baseRules + addRules;
+ }
+ col = new RuleBasedCollator(collationRuleSpec);
+ } catch (Exception e) {
+ // e.printStackTrace();
+ String msg = IcuComparatorFactoryImpl.class.getSimpleName() + ".getComparatorForLocale(): Exception constructing a RuleBasedCollator";
+ throw new ComparatorException(msg, e);
+ }
+ } else {
+ col = (RuleBasedCollator) RuleBasedCollator.getInstance(locale);
+ }
+ return col;
+ }
+
+}
diff --git a/src/main/java/org/ditacommunity/i18n/saxon/DCI18nCollationUriResolver91.java b/src/main/java/org/ditacommunity/i18n/saxon/DCI18nCollationUriResolver91.java
new file mode 100644
index 0000000..309417d
--- /dev/null
+++ b/src/main/java/org/ditacommunity/i18n/saxon/DCI18nCollationUriResolver91.java
@@ -0,0 +1,34 @@
+package org.ditacommunity.i18n.saxon;
+
+import net.sf.saxon.Configuration;
+import net.sf.saxon.sort.CollationURIResolver;
+import net.sf.saxon.sort.StandardCollationURIResolver;
+import net.sf.saxon.sort.StringCollator;
+import org.ditacommunity.i18n.collation.ZhCnAwareCollator;
+
+/**
+ * Resolves references to the DITA Community zh-CN URI resolver, setting the
+ * properties specified on the URI.
+ * This version matches the Saxon 9.1 API
+ */
+public class DCI18nCollationUriResolver91 extends DCI18nCollationUriResolverBase implements CollationURIResolver {
+
+ private final StandardCollationURIResolver defaultResolver;
+
+ public DCI18nCollationUriResolver91() {
+ super();
+ defaultResolver = StandardCollationURIResolver.getInstance();
+ }
+
+ public StringCollator resolve(String uri, String base, Configuration configuration) {
+ System.out.println("+ [DEBUG] DCI18nCollationUriResolver91.resolve(): Collation URI=\"" + uri + "\"");
+ ZhCnAwareCollator collator = resolveToZhCnAwareCollator(uri);
+ if (null == collator) {
+ System.out.println("+ [DEBUG] DCI18nCollationUriResolver91.resolve(): Failed to construct a ZhCnAwareCollator, delegating to default resolver.");
+ return defaultResolver.resolve(uri, base, configuration);
+ }
+ System.out.println("+ [DEBUG] DCI18nCollationUriResolver91.resolve(): Returning ZhCnAwareCollator");
+ return (StringCollator)collator;
+ }
+
+}
diff --git a/src/main/java/org/ditacommunity/i18n/saxon/DCI18nCollationUriResolverBase.java b/src/main/java/org/ditacommunity/i18n/saxon/DCI18nCollationUriResolverBase.java
new file mode 100644
index 0000000..a1ffcf0
--- /dev/null
+++ b/src/main/java/org/ditacommunity/i18n/saxon/DCI18nCollationUriResolverBase.java
@@ -0,0 +1,72 @@
+package org.ditacommunity.i18n.saxon;
+
+import org.ditacommunity.i18n.collation.ZhCnAwareCollator;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URL;
+import java.net.URLDecoder;
+import java.util.*;
+
+/**
+ * Base for Saxon-version-specific collation URI resolver.
+ */
+public class DCI18nCollationUriResolverBase {
+
+ public static final String DITA_COMMUNITY_I18N_ZH_CNAWARE_COLLATOR =
+ "http://org.dita-community.i18n.zhCNawareCollator";
+ public static final String LANG_URI_PARAM = "lang";
+
+ protected DCI18nCollationUriResolverBase() {
+ }
+
+ // From http://stackoverflow.com/questions/13592236/parse-a-uri-string-into-name-value-collection
+ public static Map> splitQuery(URL url) throws UnsupportedEncodingException {
+ final Map> query_pairs = new LinkedHashMap>();
+ final String[] pairs = url.getQuery().split("&");
+ if (null != pairs) {
+ for (String pair : pairs) {
+ final int idx = pair.indexOf("=");
+ final String key = idx > 0 ? URLDecoder.decode(pair.substring(0, idx), "UTF-8") : pair;
+ if (!query_pairs.containsKey(key)) {
+ query_pairs.put(key, new LinkedList());
+ }
+ final String value = idx > 0 && pair.length() > idx + 1 ? URLDecoder.decode(pair.substring(idx + 1), "UTF-8") : null;
+ query_pairs.get(key).add(value);
+ }
+ }
+ return query_pairs;
+ }
+
+ /**
+ * Get a ZhCnAwareCollator or, if this fails for some very unlikely reason, return null.
+ * It's up to the caller to provide a default resolver if this method returns null;
+ * @param uri The URI of the collator
+ * @return A ZhCnAwareCollator instance or null (should never happen).
+ */
+ protected ZhCnAwareCollator resolveToZhCnAwareCollator(String uri) {
+
+ if (uri.startsWith(DITA_COMMUNITY_I18N_ZH_CNAWARE_COLLATOR)) {
+ URL url = null;
+ Map> params;
+ try {
+ url = new URL(uri);
+ params = splitQuery(url);
+ } catch (Exception e) {
+ // Should never happen.
+ return null;
+ }
+ String locale = Locale.getDefault().toString();
+ // "lang" is the parameter defined by Saxon for Saxon collation URIs, so using
+ // that convention.
+ if (params.containsKey(LANG_URI_PARAM)) {
+ locale = params.get(LANG_URI_PARAM).get(0);
+ }
+ ZhCnAwareCollator collator = (ZhCnAwareCollator)ZhCnAwareCollator.getInstance(Locale.forLanguageTag(locale));
+ // System.out.println("DCI18nCollationUriResolver.resolveToZhCnAwareCollator(): " +
+ // "Constructing ZhCnAwareCollator for language \"" + locale + "\"");
+ collator.setCollationURI(uri);
+ return collator;
+ }
+ return null;
+ }
+}
diff --git a/src/main/java/org/ditacommunity/i18n/saxon/DCI18nSaxonTransformerFactoryImpl91.java b/src/main/java/org/ditacommunity/i18n/saxon/DCI18nSaxonTransformerFactoryImpl91.java
new file mode 100644
index 0000000..8d0915c
--- /dev/null
+++ b/src/main/java/org/ditacommunity/i18n/saxon/DCI18nSaxonTransformerFactoryImpl91.java
@@ -0,0 +1,20 @@
+package org.ditacommunity.i18n.saxon;
+
+import net.sf.saxon.FeatureKeys;
+import net.sf.saxon.TransformerFactoryImpl;
+
+/**
+ * Replacement for the base Saxon transformer factory so we can set
+ * our own features, in particular, the collation URI resolver.
+ * Provides a Saxon 9.1 collation resolver.
+ */
+public class DCI18nSaxonTransformerFactoryImpl91 extends TransformerFactoryImpl {
+
+ public DCI18nSaxonTransformerFactoryImpl91() {
+ super();
+ System.out.println("DCI18nSaxonTransformerFactoryImpl: Setting collation URI resolver to DCI18nCollationUriResolver91");
+ this.setAttribute(FeatureKeys.COLLATION_URI_RESOLVER, new DCI18nCollationUriResolver91());
+ }
+
+
+}
diff --git a/src/main/java/org/ditacommunity/i18n/util/I18nUtil.java b/src/main/java/org/ditacommunity/i18n/util/I18nUtil.java
new file mode 100755
index 0000000..341d8b3
--- /dev/null
+++ b/src/main/java/org/ditacommunity/i18n/util/I18nUtil.java
@@ -0,0 +1,497 @@
+/*
+ * Copyright (c) 2016 DITA Community
+ *
+ * Adapted from ISOGEN I18N utilities project
+ * (https://www.antennahouse.com/antenna1/i18n-support-library-2/) originally
+ * developed by Eliot Kimber and enhanced by Antenna House.
+ *
+ */
+/*--------------------------------------------------------------------------------
+ Copyright (C) 2002, 2004 ISOGEN International
+
+ http://www.isogen.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation.
+
+ This program 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 for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ --------------------------------------------------------------------------------*/
+package org.ditacommunity.i18n.util;
+
+import java.util.Locale;
+import java.util.HashMap;
+import java.io.*;
+import java.net.URL;
+
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.w3c.dom.Element;
+import org.w3c.dom.Text;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Attr;
+
+
+/**
+ *
+ * @version $Revision: 1.1.1.1 $
+ *
+ * Provides utility functions needed by other i18n support classes.
+ *
+ * If your documents to be processed use an attribute other than xml:lang= to
+ * indicate their national language, use the System property "com.isogen.i18n.langAttName" to
+ * specify the name of the attribute to use. This approach assumes that for a given run all
+ * the elements use the same attribute name, which would almost always be the case.
+ *
+ */
+ public class I18nUtil {
+
+ static String langAttName = "language"; // Name of DTD-specific attribute that holds language value.
+ // Used by the isTargetLanguage() method. No need to set this
+ // to "xml:lang" as that is always used as a fallback.
+
+ static {
+
+ }
+
+ private static HashMap hexMap;
+ private static char[] hexCharsLC = {
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c',
+ 'd', 'e', 'f'
+ };
+ private static char[] hexCharsUC = {
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C',
+ 'D', 'E', 'F'
+ };
+
+ static {
+ if (System.getProperty("com.isogen.i18n.langAttName") != null) {
+ langAttName = System.getProperty("com.isogen.i18n.langAttName");
+ }
+
+ hexMap = new HashMap();
+ for( int index = 0; index < hexCharsLC.length; index++ ) {
+ hexMap.put( new Character( hexCharsLC[ index ] ),
+ new Integer( index ) );
+ if( hexCharsLC[ index ] != hexCharsUC[ index ] )
+ hexMap.put( new Character( hexCharsUC[ index ] ),
+ new Integer( index ) );
+ }
+ }
+
+
+ /**
+ * Removes leading and trailing angle brackets from a string.
+ * @param toStrip The string to be stripped.
+ * @return The string with the angle brackets removed.
+ */
+ public static String stripAngleBrackets(String toStrip) {
+ return toStrip.substring(1, toStrip.length()-1);
+ }
+
+ /**
+ * Given a hex string ("A012EBCD"), returns the bytes it represents.
+ * @param hexString A sequence of hex digit pairs.
+ * @return An array of the bytes specified by the hex string.
+ */
+ public static byte[] hexToBytes(String hexString){
+ byte[] result = new byte[ hexString.length() / 2 ];
+ char[] chars = hexString.toCharArray();
+ int byteIndex = 0;
+ int firstHalf;
+ int secondHalf;
+
+ for( int i = 0; i < chars.length; i +=2 )
+ {
+ firstHalf = getIntForHexChar( chars[ i ] );
+ secondHalf = getIntForHexChar( chars[ i + 1 ] );
+ result[ byteIndex++ ] = (byte) ( ( firstHalf << 4 ) | secondHalf );
+ }
+
+ return result;
+ }
+
+
+ /**
+ * Given an element, returns the start tag as a string, including any attributes.
+ *
+ * Used to generate markup strings from elements.
+ *
+ * NOTE: This implementation does not account for '"' characters within attribute
+ * values.
+ * @param elem The element node to be echoed.
+ * @return XML start tag.
+ */
+ public static String echoStartTag(Element elem) {
+ String resultStr = "<" + elem.getTagName();
+ String attstr = "";
+ NamedNodeMap atts = elem.getAttributes();
+ for (int j = 0; j < atts.getLength(); j++) {
+ Attr att = (Attr)(atts.item(j));
+ // FIXME: doesn't account for '"' within attribute value.
+ attstr = attstr + " " + att.getNodeName() + "=\"" + att.getNodeValue() + "\"";
+ }
+ resultStr = resultStr + attstr + ">";
+ return resultStr;
+ }
+
+ /**
+ * Given an element, returns the end tag as a string.
+ *
+ * Used to generate markup strings from elements.
+ *
+ * @param elem The element node to be echoed.
+ * @return XML end tag.
+ */
+ public static String echoEndTag(Element elem) {
+ return "";
+ }
+
+ /**
+ * Returns element that exhibits the specified attribute, walking up
+ * the element hierarchy.
+ *
+ * @param startNode The node to check first. It's ancestors will be interogated until
+ * the attribute is found or the root is reached.
+ * @param attName The name of the attribute to find.
+ * @return Returns the element or null if not found.
+ * @throws I18nUtilError
+ */
+ public static Element getAttHolder(Element startNode, String attName) throws I18nUtilError{
+ Node attHolderNode = startNode;
+ while ((attHolderNode.getNodeType() != Node.DOCUMENT_NODE) &&
+ (!((Element)attHolderNode).hasAttribute(attName))) {
+ attHolderNode = attHolderNode.getParentNode();
+ }
+ if (attHolderNode.getNodeType() == Node.DOCUMENT_NODE) {
+ return null;
+ } else {
+ return (Element)attHolderNode;
+ }
+ }
+
+ /**
+ * Returns the first element node within the children of the specified element.
+ *
+ * @param elemNode The element whose first element child is to be returned.
+ */
+ public static Element getFirstElementChild(Element elemNode) {
+ NodeList nl = elemNode.getChildNodes();
+ for (int i = 0; i < nl.getLength(); i++) {
+ Node cand = nl.item(i);
+ if (cand.getNodeType() == Node.ELEMENT_NODE) {
+ return (Element)cand;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Returns true if the input element has element children.
+ *
+ * @param elemNode
+ *
+ */
+ public static boolean hasElementChildren(Element elemNode) {
+ NodeList nl = elemNode.getChildNodes();
+ for (int i = 0; i < nl.getLength(); i++) {
+ Node cand = nl.item(i);
+ if (cand.getNodeType() == Node.ELEMENT_NODE) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Returns the string content of an element (e.g., xsl:value-of()).
+ * @param elem Element to get the value of.
+ */
+ public static String getElementContent(Element elem) {
+ String resultStr = "";
+ if (elem != null) {
+ NodeList childs = elem.getChildNodes();
+ for (int i = 0; i < childs.getLength(); i++) {
+ Node child = childs.item(i);
+ if (child.getNodeType() == Node.ELEMENT_NODE) {
+ resultStr = resultStr + echoStartTag((Element)child);
+ resultStr = resultStr + getElementContent((Element)child);
+ resultStr = resultStr + echoEndTag((Element)child);
+ } else if (child.getNodeType() == Node.TEXT_NODE) {
+ resultStr = resultStr + ((Text)child).getData();
+ } // Else: ignore other node types
+ }
+ }
+ return resultStr;
+ }
+
+ /**
+ * Returns the string content of an element with newlines normalized to
+ * single space characters.
+ *
+ * @param elem Element to get the value of.
+ * @return The normalized string value of the element.
+ */
+ public static String getElementContentNormalized(Element elem) {
+ String contStr = getElementContent(elem);
+ String resultStr = contStr.trim().replace('\n', ' ');
+ resultStr = contStr.trim().replace('\r', ' '); // In case carriage return gets through
+ return resultStr;
+ }
+
+ /**
+ * Returns the language code associated with the specified element.
+ *
+ * @param elemNode The whose language value is to be returned.
+ * @param defaultLangCode The default language code to return if
+ * there is no explicit language code.
+ */
+ public static String getElementLanguage(Element elemNode,
+ String defaultLangCode) {
+ String langCode = defaultLangCode;
+ if (elemNode.hasAttribute(langAttName)) {
+ langCode = elemNode.getAttribute(langAttName);
+ } else if (elemNode.hasAttributeNS("xml", "lang")) {
+ langCode = elemNode.getAttributeNS("xml", "lang");
+ }
+ return langCode;
+ }
+
+ /**
+ * Returns the element with the specified tag name.
+ *
+ * Throws an exception if element not found or if more than one found.
+ */
+ public static Element getElement(Element parentElem, String tagName) throws I18nUtilError {
+ NodeList nl = parentElem.getElementsByTagName(tagName);
+ if (nl.getLength() == 0) {
+ throw new I18nUtilError("No " + tagName + " element found");
+ }
+ if (nl.getLength() > 1) {
+ throw new I18nUtilError("Found more than one " + tagName + " elements");
+ }
+ Element result = (Element)nl.item(0);
+ return result;
+ }
+
+ /**
+ * Returns the int value of a character that is a hex digit
+ * @param hexChar The character to be processed, one of 0-9, A-F
+ * @return The int value. E.g., for "A" return 10.
+ */
+ public static int getIntForHexChar( char hexChar )
+ {
+ return ( (Integer) hexMap.get( new Character( hexChar ) ) ).intValue();
+ }
+
+ /**
+ * Given a string containing non-ASCII Unicode characters, returns the
+ * same string will all non-ASCII characters replaced with "\\uxxxx" reflecting
+ * their Unicode code points.
+ *
+ * This method is useful for echoing arbitrary Unicode strings to ASCII-only
+ * environments or environments where not all characters may be accounted for
+ * by the font(s) in use.
+ *
+ * @param inString String to be processed.
+ * @return Escaped string.
+ */
+ public static String escapeUnicodeString(String inString) {
+ int l = inString.length();
+ byte[] bytes = new byte[l];
+ try {
+ bytes = inString.getBytes("UTF16");
+ } catch (Exception e) {
+ System.err.println(e.getMessage());
+ }
+ String outString = "";
+ byte zeroByte = new Byte("0").byteValue();
+ byte lastByte = new Byte("127").byteValue();
+ for (int i = 2; i < bytes.length; i = i + 2) {
+ if ((bytes[i] == zeroByte) &&
+ (bytes[i+1] <= lastByte)) {
+
+ try {
+ String newString = new String(bytes, i + 1, 1);
+ outString = outString + newString;
+ } catch (Exception e) {
+ System.err.println("escapeUnicodeString(): " + e.getMessage());
+ }
+ } else {
+ outString = outString + "\\u";
+ outString = outString + byteToHex(bytes[i]) + byteToHex(bytes[i+1]);
+ }
+ }
+ return outString;
+ }
+
+ /**
+ * Converts a byte to the string representation of its hex value.
+ * @param b The byte to process.
+ * @return A string consisting of hex digits.
+ */
+ static public String byteToHex(byte b) {
+ // Returns hex String representation of byte b
+ char hexDigit[] = {
+ '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
+ };
+ char[] array = { hexDigit[(b >> 4) & 0x0f], hexDigit[b & 0x0f] };
+ return new String(array);
+ }
+
+ /**
+ * Returns hex String representation of char c, that is, the hex
+ * digits of the Unicode code point for the character.
+ * @param c Character to process.
+ * @return Hex string of the character's code point.
+ */
+ static public String charToHex(char c) {
+ // Returns hex String representation of char c
+ byte hi = (byte) (c >>> 8);
+ byte lo = (byte) (c & 0xff);
+ return byteToHex(hi) + byteToHex(lo);
+ }
+
+ /**
+ * Given the URl to a file in the specified encoding, returns a single string
+ * with the contents of that file.
+ *
+ * @param fileUrl The URL of the file
+ *
+ * @param encoding The encoding name: UTF-8, UTF-16, etc.
+ */
+ static public String readUnicodeFile(URL fileUrl, String encoding)
+ throws I18nUtilError {
+
+ InputStream is = null;
+ try {
+ is = fileUrl.openStream();
+ } catch (IOException e) {
+ e.printStackTrace();
+ throw new I18nUtilError("IOException: " +
+ e.getMessage() + " for URL '" + fileUrl.toExternalForm() + "'" );
+ }
+ return readUnicodeStream(is, encoding);
+ }
+
+ /**
+ * Reads the file at the specified path as a Unicode string in the specified encoding.
+ * @param filePath Path to file to read.
+ * @param encoding Encoding name (e.g. "UTF-16")
+ * @return String containing the file's contents.
+ * @throws I18nUtilError
+ */
+ static public String readUnicodeFile(String filePath, String encoding)
+ throws I18nUtilError {
+ return readUnicodeFile(new File(filePath), encoding);
+ }
+
+ /**
+ * Reads the specified file as a Unicode string in the specified encoding.
+ * @param file File to be read.
+ * @param encoding Encoding name (e.g., "UTF-16")
+ * @return String containing the file's contents.
+ * @throws I18nUtilError
+ */
+ static public String readUnicodeFile(File file, String encoding)
+ throws I18nUtilError {
+ FileInputStream fis;
+ try {
+ fis = new FileInputStream(file.getAbsolutePath());
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ throw new I18nUtilError("IOException: " +
+ e.getMessage() + " for file '" + file.getAbsolutePath() + "'" );
+ }
+ return readUnicodeStream(fis, encoding);
+ }
+
+ /**
+ * Reads an InputStream as a Unicode string in the specified encoding.
+ * @param is InputStream to be read.
+ * @param encoding Encoding name (e.g., "UTF-16")
+ * @return String containing the stream's contents.
+ * @throws I18nUtilError
+ */
+ static public String readUnicodeStream(InputStream is, String encoding)
+ throws I18nUtilError {
+ // This code copied directly from the Java tutorial
+ StringBuffer buffer = new StringBuffer();
+ try {
+ InputStreamReader isr = new InputStreamReader(is, encoding);
+ Reader in = new BufferedReader(isr);
+ int ch;
+ while ((ch = in.read()) > -1) {
+ /*
+ * 2011/06/24 t.makita
+ */
+ char c=(char)ch;
+ buffer.append(c);
+ //String stChar=String.valueOf(ch);
+ //buffer.append(stChar);
+ }
+ in.close();
+ String result=buffer.toString();
+ return result;
+ } catch (IOException e) {
+ e.printStackTrace();
+ throw new I18nUtilError("IOException: " + e.getMessage());
+ }
+ }
+
+ /**
+ * Writes a string to a file in the specified encoding.
+ * @param outString String to be written.
+ * @param filePath Path of file to write to.
+ * @param encoding Encoding name (e.g., "UTF-16")
+ * @throws I18nUtilError
+ */
+ static public void writeUnicodeFile(String outString, String filePath, String encoding)
+ throws I18nUtilError {
+ try {
+ FileOutputStream fos = new FileOutputStream(filePath);
+ Writer out = new OutputStreamWriter(fos, encoding);
+ out.write(outString);
+ out.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ throw new I18nUtilError("writeUnicodeFile: " + e.getMessage() +
+ " for file '" + filePath + "'");
+ }
+ }
+
+ /**
+ * Given a Java Locale object, constructs a RuleBasedCollator for the Locale, gets
+ * the collation rules, and writes them to a file.
+ * @param locale The Locale to get the rules for.
+ * @param outFilePath File to write the rules to.
+ * @throws I18nUtilError
+ */
+ /*
+ static public void writeCollationRulesForLocale(Locale locale,
+ String outFilePath)
+ throws I18nUtilError {
+ String sortRules = null;
+ myjava.text.RuleBasedCollator col = (java.text.RuleBasedCollator)java.text.Collator.getInstance(locale);
+ sortRules = col.getRules();
+ I18nUtil.writeUnicodeFile(sortRules, outFilePath, "UTF8");
+ }
+ */
+
+ /**
+ * Returns the value of the langAttName property.
+ * @return language attribute name.
+ */
+ public static String getLangAttName() {
+ return langAttName;
+ }
+}
diff --git a/src/main/java/org/ditacommunity/i18n/util/I18nUtilError.java b/src/main/java/org/ditacommunity/i18n/util/I18nUtilError.java
new file mode 100755
index 0000000..4ac127a
--- /dev/null
+++ b/src/main/java/org/ditacommunity/i18n/util/I18nUtilError.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2016 DITA Community
+ *
+ * Adapted from ISOGEN I18N utilities project
+ * (https://www.antennahouse.com/antenna1/i18n-support-library-2/) originally
+ * developed by Eliot Kimber and enhanced by Antenna House.
+ *
+ * This code has been generalized to any need for grouping, and collation,
+ * not just indexes, and removes features not needed in the context of the
+ * DITA Open Toolkit. Updated to work with current ICU4J libraries.
+ */
+
+/*--------------------------------------------------------------------------------
+ Copyright (C) 2002 ISOGEN International
+
+ http://www.isogen.com
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation.
+
+ This program 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 for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ --------------------------------------------------------------------------------*/
+package org.ditacommunity.i18n.util;
+
+/**
+ *
+ * @version $Revision: 1.1.1.1 $
+ */
+public class I18nUtilError extends java.lang.Exception {
+
+ private static final long serialVersionUID = 4994931351803946209L;
+
+
+ public I18nUtilError() {
+ }
+
+
+ public I18nUtilError(String msg) {
+ super(msg);
+ }
+}
+
+
diff --git a/src/main/resources/lookup-zh-cn.xml b/src/main/resources/lookup-zh-cn.xml
new file mode 100644
index 0000000..7b06e0e
--- /dev/null
+++ b/src/main/resources/lookup-zh-cn.xml
@@ -0,0 +1,115087 @@
+
+
+ Simplified Chinese to Pin-Yin lookup
+
+
+
+
+ | |
+ Word |
+ Expected Position |
+ Expected Sort Key |
+
+
+
+
+
+
+
+
+
+ |
+ |
+ |
+ |
+
+
+
+
+
+
+ []
+
+
+
+
+
+ - [WARN] #default: Fallback handling
+
+
+
+
+
+
+
+
+ <xsl:apply-templates/>
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/version.properties b/version.properties
new file mode 100644
index 0000000..a646c94
--- /dev/null
+++ b/version.properties
@@ -0,0 +1 @@
+version=0.1.1
\ No newline at end of file