Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* $Id$ */ package org.apache.fop.complexscripts.fonts; import java.util.ArrayList; import java.util.Arrays; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.LinkedList; import java.util.List; import java.util.ListIterator; import java.util.Map; import java.util.Set; import java.util.TreeSet; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.fop.complexscripts.util.GlyphSequence; import org.apache.fop.complexscripts.util.ScriptContextTester; // CSOFF: EmptyForIteratorPadCheck // CSOFF: InnerAssignmentCheck // CSOFF: LineLengthCheck // CSOFF: NoWhitespaceAfterCheck // CSOFF: ParameterNumberCheck // CSOFF: SimplifyBooleanReturnCheck /** * <p>Base class for all advanced typographic glyph tables.</p> * * <p>This work was originally authored by Glenn Adams (gadams@apache.org).</p> */ public class GlyphTable { /** logging instance */ private static final Log log = LogFactory.getLog(GlyphTable.class); // CSOK: ConstantNameCheck /** substitution glyph table type */ public static final int GLYPH_TABLE_TYPE_SUBSTITUTION = 1; /** positioning glyph table type */ public static final int GLYPH_TABLE_TYPE_POSITIONING = 2; /** justification glyph table type */ public static final int GLYPH_TABLE_TYPE_JUSTIFICATION = 3; /** baseline glyph table type */ public static final int GLYPH_TABLE_TYPE_BASELINE = 4; /** definition glyph table type */ public static final int GLYPH_TABLE_TYPE_DEFINITION = 5; // (optional) glyph definition table in table types other than glyph definition table private GlyphTable gdef; // map from lookup specs to lists of strings, each of which identifies a lookup table (consisting of one or more subtables) private Map/*<LookupSpec,List<String>>*/ lookups; // map from lookup identifiers to lookup tables private Map/*<String,LookupTable>*/ lookupTables; // if true, then prevent further subtable addition private boolean frozen; /** * Instantiate glyph table with specified lookups. * @param gdef glyph definition table that applies * @param lookups map from lookup specs to lookup tables */ public GlyphTable(GlyphTable gdef, Map/*<LookupSpec,List<String>>*/ lookups) { if ((gdef != null) && !(gdef instanceof GlyphDefinitionTable)) { throw new AdvancedTypographicTableFormatException("bad glyph definition table"); } else if (lookups == null) { throw new AdvancedTypographicTableFormatException("lookups must be non-null map"); } else { this.gdef = gdef; this.lookups = lookups; this.lookupTables = new LinkedHashMap/*<String,List<LookupTable>>*/(); } } /** * Obtain glyph definition table. * @return (possibly null) glyph definition table */ public GlyphDefinitionTable getGlyphDefinitions() { return (GlyphDefinitionTable) gdef; } /** * Obtain list of all lookup specifications. * @return (possibly empty) list of all lookup specifications */ public List/*<LookupSpec>*/ getLookups() { return matchLookupSpecs("*", "*", "*"); } /** * Obtain ordered list of all lookup tables, where order is by lookup identifier, which * lexicographic ordering follows the lookup list order. * @return (possibly empty) ordered list of all lookup tables */ public List/*<LookupTable>*/ getLookupTables() { TreeSet/*<String>*/ lids = new TreeSet/*<String>*/ (lookupTables.keySet()); List/*<LookupTable>*/ ltl = new ArrayList/*<LookupTable>*/ (lids.size()); for (Iterator it = lids.iterator(); it.hasNext();) { String lid = (String) it.next(); ltl.add(lookupTables.get(lid)); } return ltl; } /** * Obtain lookup table by lookup id. This method is used by test code, and provides * access to embedded lookups not normally accessed by {script, language, feature} lookup spec. * @param lid lookup id * @return table associated with lookup id or null if none */ public LookupTable getLookupTable(String lid) { return (LookupTable) lookupTables.get(lid); } /** * Add a subtable. * @param subtable a (non-null) glyph subtable */ protected void addSubtable(GlyphSubtable subtable) { // ensure table is not frozen if (frozen) { throw new IllegalStateException("glyph table is frozen, subtable addition prohibited"); } // set subtable's table reference to this table subtable.setTable(this); // add subtable to this table's subtable collection String lid = subtable.getLookupId(); if (lookupTables.containsKey(lid)) { LookupTable lt = (LookupTable) lookupTables.get(lid); lt.addSubtable(subtable); } else { LookupTable lt = new LookupTable(lid, subtable); lookupTables.put(lid, lt); } } /** * Freeze subtables, i.e., do not allow further subtable addition, and * create resulting cached state. */ protected void freezeSubtables() { if (!frozen) { for (Iterator it = lookupTables.values().iterator(); it.hasNext();) { LookupTable lt = (LookupTable) it.next(); lt.freezeSubtables(lookupTables); } frozen = true; } } /** * Match lookup specifications according to <script,language,feature> tuple, where * '*' is a wildcard for a tuple component. * @param script a script identifier * @param language a language identifier * @param feature a feature identifier * @return a (possibly empty) array of matching lookup specifications */ public List/*<LookupSpec>*/ matchLookupSpecs(String script, String language, String feature) { Set/*<LookupSpec>*/ keys = lookups.keySet(); List/*<LookupSpec>*/ matches = new ArrayList/*<LookupSpec>*/(); for (Iterator it = keys.iterator(); it.hasNext();) { LookupSpec ls = (LookupSpec) it.next(); if (!"*".equals(script)) { if (!ls.getScript().equals(script)) { continue; } } if (!"*".equals(language)) { if (!ls.getLanguage().equals(language)) { continue; } } if (!"*".equals(feature)) { if (!ls.getFeature().equals(feature)) { continue; } } matches.add(ls); } return matches; } /** * Match lookup specifications according to <script,language,feature> tuple, where * '*' is a wildcard for a tuple component. * @param script a script identifier * @param language a language identifier * @param feature a feature identifier * @return a (possibly empty) map from matching lookup specifications to lists of corresponding lookup tables */ public Map/*<LookupSpec,List<LookupTable>>*/ matchLookups(String script, String language, String feature) { List/*<LookupSpec>*/ lsl = matchLookupSpecs(script, language, feature); Map lm = new LinkedHashMap(); for (Iterator it = lsl.iterator(); it.hasNext();) { LookupSpec ls = (LookupSpec) it.next(); lm.put(ls, findLookupTables(ls)); } return lm; } /** * Obtain ordered list of glyph lookup tables that match a specific lookup specification. * @param ls a (non-null) lookup specification * @return a (possibly empty) ordered list of lookup tables whose corresponding lookup specifications match the specified lookup spec */ public List/*<LookupTable>*/ findLookupTables(LookupSpec ls) { TreeSet/*<LookupTable>*/ lts = new TreeSet/*<LookupTable>*/(); List/*<String>*/ ids; if ((ids = (List/*<String>*/) lookups.get(ls)) != null) { for (Iterator it = ids.iterator(); it.hasNext();) { String lid = (String) it.next(); LookupTable lt; if ((lt = (LookupTable) lookupTables.get(lid)) != null) { lts.add(lt); } } } return new ArrayList/*<LookupTable>*/ (lts); } /** * Assemble ordered array of lookup table use specifications according to the specified features and candidate lookups, * where the order of the array is in accordance to the order of the applicable lookup list. * @param features array of feature identifiers to apply * @param lookups a mapping from lookup specifications to lists of look tables from which to select lookup tables according to the specified features * @return ordered array of assembled lookup table use specifications */ public UseSpec[] assembleLookups(String[] features, Map/*<LookupSpec,List<LookupTable>>*/ lookups) { TreeSet/*<UseSpec>*/ uss = new TreeSet/*<UseSpec>*/(); for (int i = 0, n = features.length; i < n; i++) { String feature = features[i]; for (Iterator it = lookups.entrySet().iterator(); it.hasNext();) { Map.Entry/*<LookupSpec,List<LookupTable>>*/ e = (Map.Entry/*<LookupSpec,List<LookupTable>>*/) it .next(); LookupSpec ls = (LookupSpec) e.getKey(); if (ls.getFeature().equals(feature)) { List/*<LookupTable>*/ ltl = (List/*<LookupTable>*/) e.getValue(); if (ltl != null) { for (Iterator ltit = ltl.iterator(); ltit.hasNext();) { LookupTable lt = (LookupTable) ltit.next(); uss.add(new UseSpec(lt, feature)); } } } } } return (UseSpec[]) uss.toArray(new UseSpec[uss.size()]); } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(super.toString()); sb.append("{"); sb.append("lookups={"); sb.append(lookups.toString()); sb.append("},lookupTables={"); sb.append(lookupTables.toString()); sb.append("}}"); return sb.toString(); } /** * Obtain glyph table type from name. * @param name of table type to map to type value * @return glyph table type (as an integer constant) */ public static int getTableTypeFromName(String name) { int t; String s = name.toLowerCase(); if ("gsub".equals(s)) { t = GLYPH_TABLE_TYPE_SUBSTITUTION; } else if ("gpos".equals(s)) { t = GLYPH_TABLE_TYPE_POSITIONING; } else if ("jstf".equals(s)) { t = GLYPH_TABLE_TYPE_JUSTIFICATION; } else if ("base".equals(s)) { t = GLYPH_TABLE_TYPE_BASELINE; } else if ("gdef".equals(s)) { t = GLYPH_TABLE_TYPE_DEFINITION; } else { t = -1; } return t; } /** * Resolve references to lookup tables in a collection of rules sets. * @param rsa array of rule sets * @param lookupTables map from lookup table identifers, e.g. "lu4", to lookup tables */ public static void resolveLookupReferences(RuleSet[] rsa, Map/*<String,LookupTable>*/ lookupTables) { if ((rsa != null) && (lookupTables != null)) { for (int i = 0, n = rsa.length; i < n; i++) { RuleSet rs = rsa[i]; if (rs != null) { rs.resolveLookupReferences(lookupTables); } } } } /** * A structure class encapsulating a lookup specification as a <script,language,feature> tuple. */ public static class LookupSpec implements Comparable { private final String script; private final String language; private final String feature; /** * Instantiate lookup spec. * @param script a script identifier * @param language a language identifier * @param feature a feature identifier */ public LookupSpec(String script, String language, String feature) { if ((script == null) || (script.length() == 0)) { throw new AdvancedTypographicTableFormatException("script must be non-empty string"); } else if ((language == null) || (language.length() == 0)) { throw new AdvancedTypographicTableFormatException("language must be non-empty string"); } else if ((feature == null) || (feature.length() == 0)) { throw new AdvancedTypographicTableFormatException("feature must be non-empty string"); } else if (script.equals("*")) { throw new AdvancedTypographicTableFormatException("script must not be wildcard"); } else if (language.equals("*")) { throw new AdvancedTypographicTableFormatException("language must not be wildcard"); } else if (feature.equals("*")) { throw new AdvancedTypographicTableFormatException("feature must not be wildcard"); } else { this.script = script.trim(); this.language = language.trim(); this.feature = feature.trim(); } } /** @return script identifier */ public String getScript() { return script; } /** @return language identifier */ public String getLanguage() { return language; } /** @return feature identifier */ public String getFeature() { return feature; } /** {@inheritDoc} */ public int hashCode() { int hc = 0; hc = 7 * hc + (hc ^ script.hashCode()); hc = 11 * hc + (hc ^ language.hashCode()); hc = 17 * hc + (hc ^ feature.hashCode()); return hc; } /** {@inheritDoc} */ public boolean equals(Object o) { if (o instanceof LookupSpec) { LookupSpec l = (LookupSpec) o; if (!l.script.equals(script)) { return false; } else if (!l.language.equals(language)) { return false; } else if (!l.feature.equals(feature)) { return false; } else { return true; } } else { return false; } } /** {@inheritDoc} */ public int compareTo(Object o) { int d; if (o instanceof LookupSpec) { LookupSpec ls = (LookupSpec) o; if ((d = script.compareTo(ls.script)) == 0) { if ((d = language.compareTo(ls.language)) == 0) { if ((d = feature.compareTo(ls.feature)) == 0) { d = 0; } } } } else { d = -1; } return d; } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(super.toString()); sb.append("{"); sb.append("<'" + script + "'"); sb.append(",'" + language + "'"); sb.append(",'" + feature + "'"); sb.append(">}"); return sb.toString(); } } /** * The <code>LookupTable</code> class comprising an identifier and an ordered list * of glyph subtables, each of which employ the same lookup identifier. */ public static class LookupTable implements Comparable { private final String id; // lookup identifiers private final List/*<GlyphSubtable>*/ subtables; // list of subtables private boolean doesSub; // performs substitutions private boolean doesPos; // performs positioning private boolean frozen; // if true, then don't permit further subtable additions // frozen state private GlyphSubtable[] subtablesArray; private static GlyphSubtable[] subtablesArrayEmpty = new GlyphSubtable[0]; /** * Instantiate a LookupTable. * @param id the lookup table's identifier * @param subtable an initial subtable (or null) */ public LookupTable(String id, GlyphSubtable subtable) { this(id, makeSingleton(subtable)); } /** * Instantiate a LookupTable. * @param id the lookup table's identifier * @param subtables a pre-poplated list of subtables or null */ public LookupTable(String id, List/*<GlyphSubtable>*/ subtables) { assert id != null; assert id.length() != 0; this.id = id; this.subtables = new LinkedList/*<GlyphSubtable>*/(); if (subtables != null) { for (Iterator it = subtables.iterator(); it.hasNext();) { GlyphSubtable st = (GlyphSubtable) it.next(); addSubtable(st); } } } /** @return the identifier */ public String getId() { return id; } /** @return the subtables as an array */ public GlyphSubtable[] getSubtables() { if (frozen) { return (subtablesArray != null) ? subtablesArray : subtablesArrayEmpty; } else { if (doesSub) { return (GlyphSubtable[]) subtables.toArray(new GlyphSubstitutionSubtable[subtables.size()]); } else if (doesPos) { return (GlyphSubtable[]) subtables.toArray(new GlyphPositioningSubtable[subtables.size()]); } else { return null; } } } /** * Add a subtable into this lookup table's collecion of subtables according to its * natural order. * @param subtable to add * @return true if subtable was not already present, otherwise false */ public boolean addSubtable(GlyphSubtable subtable) { boolean added = false; // ensure table is not frozen if (frozen) { throw new IllegalStateException("glyph table is frozen, subtable addition prohibited"); } // validate subtable to ensure consistency with current subtables validateSubtable(subtable); // insert subtable into ordered list for (ListIterator /*<GlyphSubtable>*/ lit = subtables.listIterator(0); lit.hasNext();) { GlyphSubtable st = (GlyphSubtable) lit.next(); int d; if ((d = subtable.compareTo(st)) < 0) { // insert within list lit.set(subtable); lit.add(st); added = true; } else if (d == 0) { // duplicate entry is ignored added = false; subtable = null; } } // append at end of list if (!added && (subtable != null)) { subtables.add(subtable); added = true; } return added; } private void validateSubtable(GlyphSubtable subtable) { if (subtable == null) { throw new AdvancedTypographicTableFormatException("subtable must be non-null"); } if (subtable instanceof GlyphSubstitutionSubtable) { if (doesPos) { throw new AdvancedTypographicTableFormatException( "subtable must be positioning subtable, but is: " + subtable); } else { doesSub = true; } } if (subtable instanceof GlyphPositioningSubtable) { if (doesSub) { throw new AdvancedTypographicTableFormatException( "subtable must be substitution subtable, but is: " + subtable); } else { doesPos = true; } } if (subtables.size() > 0) { GlyphSubtable st = (GlyphSubtable) subtables.get(0); if (!st.isCompatible(subtable)) { throw new AdvancedTypographicTableFormatException( "subtable " + subtable + " is not compatible with subtable " + st); } } } /** * Freeze subtables, i.e., do not allow further subtable addition, and * create resulting cached state. In addition, resolve any references to * lookup tables that appear in this lookup table's subtables. * @param lookupTables map from lookup table identifers, e.g. "lu4", to lookup tables */ public void freezeSubtables(Map/*<String,LookupTable>*/ lookupTables) { if (!frozen) { GlyphSubtable[] sta = getSubtables(); resolveLookupReferences(sta, lookupTables); this.subtablesArray = sta; this.frozen = true; } } private void resolveLookupReferences(GlyphSubtable[] subtables, Map/*<String,LookupTable>*/ lookupTables) { if (subtables != null) { for (int i = 0, n = subtables.length; i < n; i++) { GlyphSubtable st = subtables[i]; if (st != null) { st.resolveLookupReferences(lookupTables); } } } } /** * Determine if this glyph table performs substitution. * @return true if it performs substitution */ public boolean performsSubstitution() { return doesSub; } /** * Perform substitution processing using this lookup table's subtables. * @param gs an input glyph sequence * @param script a script identifier * @param language a language identifier * @param feature a feature identifier * @param sct a script specific context tester (or null) * @return the substituted (output) glyph sequence */ public GlyphSequence substitute(GlyphSequence gs, String script, String language, String feature, ScriptContextTester sct) { if (performsSubstitution()) { return GlyphSubstitutionSubtable.substitute(gs, script, language, feature, (GlyphSubstitutionSubtable[]) subtablesArray, sct); } else { return gs; } } /** * Perform substitution processing on an existing glyph substitution state object using this lookup table's subtables. * @param ss a glyph substitution state object * @param sequenceIndex if non negative, then apply subtables only at specified sequence index * @return the substituted (output) glyph sequence */ public GlyphSequence substitute(GlyphSubstitutionState ss, int sequenceIndex) { if (performsSubstitution()) { return GlyphSubstitutionSubtable.substitute(ss, (GlyphSubstitutionSubtable[]) subtablesArray, sequenceIndex); } else { return ss.getInput(); } } /** * Determine if this glyph table performs positioning. * @return true if it performs positioning */ public boolean performsPositioning() { return doesPos; } /** * Perform positioning processing using this lookup table's subtables. * @param gs an input glyph sequence * @param script a script identifier * @param language a language identifier * @param feature a feature identifier * @param fontSize size in device units * @param widths array of default advancements for each glyph in font * @param adjustments accumulated adjustments array (sequence) of 4-tuples of placement [PX,PY] and advance [AX,AY] adjustments, in that order, * with one 4-tuple for each element of glyph sequence * @param sct a script specific context tester (or null) * @return true if some adjustment is not zero; otherwise, false */ public boolean position(GlyphSequence gs, String script, String language, String feature, int fontSize, int[] widths, int[][] adjustments, ScriptContextTester sct) { if (performsPositioning()) { return GlyphPositioningSubtable.position(gs, script, language, feature, fontSize, (GlyphPositioningSubtable[]) subtablesArray, widths, adjustments, sct); } else { return false; } } /** * Perform positioning processing on an existing glyph positioning state object using this lookup table's subtables. * @param ps a glyph positioning state object * @param sequenceIndex if non negative, then apply subtables only at specified sequence index * @return true if some adjustment is not zero; otherwise, false */ public boolean position(GlyphPositioningState ps, int sequenceIndex) { if (performsPositioning()) { return GlyphPositioningSubtable.position(ps, (GlyphPositioningSubtable[]) subtablesArray, sequenceIndex); } else { return false; } } /** {@inheritDoc} */ public int hashCode() { return id.hashCode(); } /** * {@inheritDoc} * @return true if identifier of the specified lookup table is the same * as the identifier of this lookup table */ public boolean equals(Object o) { if (o instanceof LookupTable) { LookupTable lt = (LookupTable) o; return id.equals(lt.id); } else { return false; } } /** * {@inheritDoc} * @return the result of comparing the identifier of the specified lookup table with * the identifier of this lookup table; lookup table identifiers take the form * "lu(DIGIT)+", with comparison based on numerical ordering of numbers expressed by * (DIGIT)+. */ public int compareTo(Object o) { if (o instanceof LookupTable) { LookupTable lt = (LookupTable) o; assert id.startsWith("lu"); int i = Integer.parseInt(id.substring(2)); assert lt.id.startsWith("lu"); int j = Integer.parseInt(lt.id.substring(2)); if (i < j) { return -1; } else if (i > j) { return 1; } else { return 0; } } else { return -1; } } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(); sb.append("{ "); sb.append("id = " + id); sb.append(", subtables = " + subtables); sb.append(" }"); return sb.toString(); } private static List/*<GlyphSubtable>*/ makeSingleton(GlyphSubtable subtable) { if (subtable == null) { return null; } else { List/*<GlyphSubtable>*/ stl = new ArrayList/*<GlyphSubtable>*/ (1); stl.add(subtable); return stl; } } } /** * The <code>UseSpec</code> class comprises a lookup table reference * and the feature that selected the lookup table. */ public static class UseSpec implements Comparable { /** lookup table to apply */ private final LookupTable lookupTable; /** feature that caused selection of the lookup table */ private final String feature; /** * Construct a glyph lookup table use specification. * @param lookupTable a glyph lookup table * @param feature a feature that caused lookup table selection */ public UseSpec(LookupTable lookupTable, String feature) { this.lookupTable = lookupTable; this.feature = feature; } /** @return the lookup table */ public LookupTable getLookupTable() { return lookupTable; } /** @return the feature that selected this lookup table */ public String getFeature() { return feature; } /** * Perform substitution processing using this use specification's lookup table. * @param gs an input glyph sequence * @param script a script identifier * @param language a language identifier * @param sct a script specific context tester (or null) * @return the substituted (output) glyph sequence */ public GlyphSequence substitute(GlyphSequence gs, String script, String language, ScriptContextTester sct) { return lookupTable.substitute(gs, script, language, feature, sct); } /** * Perform positioning processing using this use specification's lookup table. * @param gs an input glyph sequence * @param script a script identifier * @param language a language identifier * @param fontSize size in device units * @param widths array of default advancements for each glyph in font * @param adjustments accumulated adjustments array (sequence) of 4-tuples of placement [PX,PY] and advance [AX,AY] adjustments, in that order, * with one 4-tuple for each element of glyph sequence * @param sct a script specific context tester (or null) * @return true if some adjustment is not zero; otherwise, false */ public boolean position(GlyphSequence gs, String script, String language, int fontSize, int[] widths, int[][] adjustments, ScriptContextTester sct) { return lookupTable.position(gs, script, language, feature, fontSize, widths, adjustments, sct); } /** {@inheritDoc} */ public int hashCode() { return lookupTable.hashCode(); } /** {@inheritDoc} */ public boolean equals(Object o) { if (o instanceof UseSpec) { UseSpec u = (UseSpec) o; return lookupTable.equals(u.lookupTable); } else { return false; } } /** {@inheritDoc} */ public int compareTo(Object o) { if (o instanceof UseSpec) { UseSpec u = (UseSpec) o; return lookupTable.compareTo(u.lookupTable); } else { return -1; } } } /** * The <code>RuleLookup</code> class implements a rule lookup record, comprising * a glyph sequence index and a lookup table index (in an applicable lookup list). */ public static class RuleLookup { private final int sequenceIndex; // index into input glyph sequence private final int lookupIndex; // lookup list index private LookupTable lookup; // resolved lookup table /** * Instantiate a RuleLookup. * @param sequenceIndex the index into the input sequence * @param lookupIndex the lookup table index */ public RuleLookup(int sequenceIndex, int lookupIndex) { this.sequenceIndex = sequenceIndex; this.lookupIndex = lookupIndex; this.lookup = null; } /** @return the sequence index */ public int getSequenceIndex() { return sequenceIndex; } /** @return the lookup index */ public int getLookupIndex() { return lookupIndex; } /** @return the lookup table */ public LookupTable getLookup() { return lookup; } /** * Resolve references to lookup tables. * @param lookupTables map from lookup table identifers, e.g. "lu4", to lookup tables */ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) { if (lookupTables != null) { String lid = "lu" + Integer.toString(lookupIndex); LookupTable lt = (LookupTable) lookupTables.get(lid); if (lt != null) { this.lookup = lt; } else { log.warn("unable to resolve glyph lookup table reference '" + lid + "' amongst lookup tables: " + lookupTables.values()); } } } /** {@inheritDoc} */ public String toString() { return "{ sequenceIndex = " + sequenceIndex + ", lookupIndex = " + lookupIndex + " }"; } } /** * The <code>Rule</code> class implements an array of rule lookup records. */ public abstract static class Rule { private final RuleLookup[] lookups; // rule lookups private final int inputSequenceLength; // input sequence length /** * Instantiate a Rule. * @param lookups the rule's lookups * @param inputSequenceLength the number of glyphs in the input sequence for this rule */ protected Rule(RuleLookup[] lookups, int inputSequenceLength) { assert lookups != null; this.lookups = lookups; this.inputSequenceLength = inputSequenceLength; } /** @return the lookups */ public RuleLookup[] getLookups() { return lookups; } /** @return the input sequence length */ public int getInputSequenceLength() { return inputSequenceLength; } /** * Resolve references to lookup tables, e.g., in RuleLookup, to the lookup tables themselves. * @param lookupTables map from lookup table identifers, e.g. "lu4", to lookup tables */ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) { if (lookups != null) { for (int i = 0, n = lookups.length; i < n; i++) { RuleLookup l = lookups[i]; if (l != null) { l.resolveLookupReferences(lookupTables); } } } } /** {@inheritDoc} */ public String toString() { return "{ lookups = " + Arrays.toString(lookups) + ", inputSequenceLength = " + inputSequenceLength + " }"; } } /** * The <code>GlyphSequenceRule</code> class implements a subclass of <code>Rule</code> * that supports matching on a specific glyph sequence. */ public static class GlyphSequenceRule extends Rule { private final int[] glyphs; // glyphs /** * Instantiate a GlyphSequenceRule. * @param lookups the rule's lookups * @param inputSequenceLength number of glyphs constituting input sequence (to be consumed) * @param glyphs the rule's glyph sequence to match, starting with second glyph in sequence */ public GlyphSequenceRule(RuleLookup[] lookups, int inputSequenceLength, int[] glyphs) { super(lookups, inputSequenceLength); assert glyphs != null; this.glyphs = glyphs; } /** * Obtain glyphs. N.B. that this array starts with the second * glyph of the input sequence. * @return the glyphs */ public int[] getGlyphs() { return glyphs; } /** * Obtain glyphs augmented by specified first glyph entry. * @param firstGlyph to fill in first glyph entry * @return the glyphs augmented by first glyph */ public int[] getGlyphs(int firstGlyph) { int[] ga = new int[glyphs.length + 1]; ga[0] = firstGlyph; System.arraycopy(glyphs, 0, ga, 1, glyphs.length); return ga; } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(); sb.append("{ "); sb.append("lookups = " + Arrays.toString(getLookups())); sb.append(", glyphs = " + Arrays.toString(glyphs)); sb.append(" }"); return sb.toString(); } } /** * The <code>ClassSequenceRule</code> class implements a subclass of <code>Rule</code> * that supports matching on a specific glyph class sequence. */ public static class ClassSequenceRule extends Rule { private final int[] classes; // glyph classes /** * Instantiate a ClassSequenceRule. * @param lookups the rule's lookups * @param inputSequenceLength number of glyphs constituting input sequence (to be consumed) * @param classes the rule's glyph class sequence to match, starting with second glyph in sequence */ public ClassSequenceRule(RuleLookup[] lookups, int inputSequenceLength, int[] classes) { super(lookups, inputSequenceLength); assert classes != null; this.classes = classes; } /** * Obtain glyph classes. N.B. that this array starts with the class of the second * glyph of the input sequence. * @return the classes */ public int[] getClasses() { return classes; } /** * Obtain glyph classes augmented by specified first class entry. * @param firstClass to fill in first class entry * @return the classes augmented by first class */ public int[] getClasses(int firstClass) { int[] ca = new int[classes.length + 1]; ca[0] = firstClass; System.arraycopy(classes, 0, ca, 1, classes.length); return ca; } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(); sb.append("{ "); sb.append("lookups = " + Arrays.toString(getLookups())); sb.append(", classes = " + Arrays.toString(classes)); sb.append(" }"); return sb.toString(); } } /** * The <code>CoverageSequenceRule</code> class implements a subclass of <code>Rule</code> * that supports matching on a specific glyph coverage sequence. */ public static class CoverageSequenceRule extends Rule { private final GlyphCoverageTable[] coverages; // glyph coverages /** * Instantiate a ClassSequenceRule. * @param lookups the rule's lookups * @param inputSequenceLength number of glyphs constituting input sequence (to be consumed) * @param coverages the rule's glyph coverage sequence to match, starting with first glyph in sequence */ public CoverageSequenceRule(RuleLookup[] lookups, int inputSequenceLength, GlyphCoverageTable[] coverages) { super(lookups, inputSequenceLength); assert coverages != null; this.coverages = coverages; } /** @return the coverages */ public GlyphCoverageTable[] getCoverages() { return coverages; } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(); sb.append("{ "); sb.append("lookups = " + Arrays.toString(getLookups())); sb.append(", coverages = " + Arrays.toString(coverages)); sb.append(" }"); return sb.toString(); } } /** * The <code>ChainedGlyphSequenceRule</code> class implements a subclass of <code>GlyphSequenceRule</code> * that supports matching on a specific glyph sequence in a specific chained contextual. */ public static class ChainedGlyphSequenceRule extends GlyphSequenceRule { private final int[] backtrackGlyphs; // backtrack glyphs private final int[] lookaheadGlyphs; // lookahead glyphs /** * Instantiate a ChainedGlyphSequenceRule. * @param lookups the rule's lookups * @param inputSequenceLength number of glyphs constituting input sequence (to be consumed) * @param glyphs the rule's input glyph sequence to match, starting with second glyph in sequence * @param backtrackGlyphs the rule's backtrack glyph sequence to match, starting with first glyph in sequence * @param lookaheadGlyphs the rule's lookahead glyph sequence to match, starting with first glyph in sequence */ public ChainedGlyphSequenceRule(RuleLookup[] lookups, int inputSequenceLength, int[] glyphs, int[] backtrackGlyphs, int[] lookaheadGlyphs) { super(lookups, inputSequenceLength, glyphs); assert backtrackGlyphs != null; assert lookaheadGlyphs != null; this.backtrackGlyphs = backtrackGlyphs; this.lookaheadGlyphs = lookaheadGlyphs; } /** @return the backtrack glyphs */ public int[] getBacktrackGlyphs() { return backtrackGlyphs; } /** @return the lookahead glyphs */ public int[] getLookaheadGlyphs() { return lookaheadGlyphs; } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(); sb.append("{ "); sb.append("lookups = " + Arrays.toString(getLookups())); sb.append(", glyphs = " + Arrays.toString(getGlyphs())); sb.append(", backtrackGlyphs = " + Arrays.toString(backtrackGlyphs)); sb.append(", lookaheadGlyphs = " + Arrays.toString(lookaheadGlyphs)); sb.append(" }"); return sb.toString(); } } /** * The <code>ChainedClassSequenceRule</code> class implements a subclass of <code>ClassSequenceRule</code> * that supports matching on a specific glyph class sequence in a specific chained contextual. */ public static class ChainedClassSequenceRule extends ClassSequenceRule { private final int[] backtrackClasses; // backtrack classes private final int[] lookaheadClasses; // lookahead classes /** * Instantiate a ChainedClassSequenceRule. * @param lookups the rule's lookups * @param inputSequenceLength number of glyphs constituting input sequence (to be consumed) * @param classes the rule's input glyph class sequence to match, starting with second glyph in sequence * @param backtrackClasses the rule's backtrack glyph class sequence to match, starting with first glyph in sequence * @param lookaheadClasses the rule's lookahead glyph class sequence to match, starting with first glyph in sequence */ public ChainedClassSequenceRule(RuleLookup[] lookups, int inputSequenceLength, int[] classes, int[] backtrackClasses, int[] lookaheadClasses) { super(lookups, inputSequenceLength, classes); assert backtrackClasses != null; assert lookaheadClasses != null; this.backtrackClasses = backtrackClasses; this.lookaheadClasses = lookaheadClasses; } /** @return the backtrack classes */ public int[] getBacktrackClasses() { return backtrackClasses; } /** @return the lookahead classes */ public int[] getLookaheadClasses() { return lookaheadClasses; } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(); sb.append("{ "); sb.append("lookups = " + Arrays.toString(getLookups())); sb.append(", classes = " + Arrays.toString(getClasses())); sb.append(", backtrackClasses = " + Arrays.toString(backtrackClasses)); sb.append(", lookaheadClasses = " + Arrays.toString(lookaheadClasses)); sb.append(" }"); return sb.toString(); } } /** * The <code>ChainedCoverageSequenceRule</code> class implements a subclass of <code>CoverageSequenceRule</code> * that supports matching on a specific glyph class sequence in a specific chained contextual. */ public static class ChainedCoverageSequenceRule extends CoverageSequenceRule { private final GlyphCoverageTable[] backtrackCoverages; // backtrack coverages private final GlyphCoverageTable[] lookaheadCoverages; // lookahead coverages /** * Instantiate a ChainedCoverageSequenceRule. * @param lookups the rule's lookups * @param inputSequenceLength number of glyphs constituting input sequence (to be consumed) * @param coverages the rule's input glyph class sequence to match, starting with first glyph in sequence * @param backtrackCoverages the rule's backtrack glyph class sequence to match, starting with first glyph in sequence * @param lookaheadCoverages the rule's lookahead glyph class sequence to match, starting with first glyph in sequence */ public ChainedCoverageSequenceRule(RuleLookup[] lookups, int inputSequenceLength, GlyphCoverageTable[] coverages, GlyphCoverageTable[] backtrackCoverages, GlyphCoverageTable[] lookaheadCoverages) { super(lookups, inputSequenceLength, coverages); assert backtrackCoverages != null; assert lookaheadCoverages != null; this.backtrackCoverages = backtrackCoverages; this.lookaheadCoverages = lookaheadCoverages; } /** @return the backtrack coverages */ public GlyphCoverageTable[] getBacktrackCoverages() { return backtrackCoverages; } /** @return the lookahead coverages */ public GlyphCoverageTable[] getLookaheadCoverages() { return lookaheadCoverages; } /** {@inheritDoc} */ public String toString() { StringBuffer sb = new StringBuffer(); sb.append("{ "); sb.append("lookups = " + Arrays.toString(getLookups())); sb.append(", coverages = " + Arrays.toString(getCoverages())); sb.append(", backtrackCoverages = " + Arrays.toString(backtrackCoverages)); sb.append(", lookaheadCoverages = " + Arrays.toString(lookaheadCoverages)); sb.append(" }"); return sb.toString(); } } /** * The <code>RuleSet</code> class implements a collection of rules, which * may or may not be the same rule type. */ public static class RuleSet { private final Rule[] rules; // set of rules /** * Instantiate a Rule Set. * @param rules the rules * @throws AdvancedTypographicTableFormatException if rules or some element of rules is null */ public RuleSet(Rule[] rules) throws AdvancedTypographicTableFormatException { // enforce rules array instance if (rules == null) { throw new AdvancedTypographicTableFormatException("rules[] is null"); } this.rules = rules; } /** @return the rules */ public Rule[] getRules() { return rules; } /** * Resolve references to lookup tables, e.g., in RuleLookup, to the lookup tables themselves. * @param lookupTables map from lookup table identifers, e.g. "lu4", to lookup tables */ public void resolveLookupReferences(Map/*<String,LookupTable>*/ lookupTables) { if (rules != null) { for (int i = 0, n = rules.length; i < n; i++) { Rule r = rules[i]; if (r != null) { r.resolveLookupReferences(lookupTables); } } } } /** {@inheritDoc} */ public String toString() { return "{ rules = " + Arrays.toString(rules) + " }"; } } /** * The <code>HomogenousRuleSet</code> class implements a collection of rules, which * must be the same rule type (i.e., same concrete rule class) or null. */ public static class HomogeneousRuleSet extends RuleSet { /** * Instantiate a Homogeneous Rule Set. * @param rules the rules * @throws AdvancedTypographicTableFormatException if some rule[i] is not an instance of rule[0] */ public HomogeneousRuleSet(Rule[] rules) throws AdvancedTypographicTableFormatException { super(rules); // find first non-null rule Rule r0 = null; for (int i = 1, n = rules.length; (r0 == null) && (i < n); i++) { if (rules[i] != null) { r0 = rules[i]; } } // enforce rule instance homogeneity if (r0 != null) { Class c = r0.getClass(); for (int i = 1, n = rules.length; i < n; i++) { Rule r = rules[i]; if ((r != null) && !c.isInstance(r)) { throw new AdvancedTypographicTableFormatException( "rules[" + i + "] is not an instance of " + c.getName()); } } } } } }