jars/icu4j-4_2_1-src/src/com/ibm/icu/dev/tool/layout/DecompTable.java

   1 /**\r
   2  *******************************************************************************\r
   3  * Copyright (C) 2002-2005, International Business Machines Corporation and    *\r
   4  * others. All Rights Reserved.                                                *\r
   5  *******************************************************************************\r
   6  */\r
   7 \r
   8 package com.ibm.icu.dev.tool.layout;\r
   9 \r
  10 import com.ibm.icu.text.UTF16;\r
  11 import java.util.Vector;\r
  12 \r
  13 /**\r
  14  * @author Owner\r
  15  *\r
  16  * To change the template for this generated type comment go to\r
  17  * Window>Preferences>Java>Code Generation>Code and Comments\r
  18  */\r
  19 public class DecompTable implements LookupSubtable\r
  20 {\r
  21     static class DecompEntry\r
  22     {\r
  23         private int composed;\r
  24         private int[] decomp;\r
  25         \r
  26         DecompEntry(int composedChar, String decomposition)\r
  27         {\r
  28             int decompCount = UTF16.countCodePoint(decomposition);\r
  29             \r
  30             composed = composedChar;\r
  31             decomp = new int[decompCount];\r
  32             \r
  33             int out = 0, cp;\r
  34             \r
  35             for (int in = 0; in < decomposition.length(); in += UTF16.getCharCount(cp)) {\r
  36                 cp = UTF16.charAt(decomposition, in);\r
  37                 decomp[out++] = cp;\r
  38             }\r
  39         }\r
  40         \r
  41         public int getComposedCharacter()\r
  42         {\r
  43             return composed;\r
  44         }\r
  45         \r
  46         public int[] getDecomposition()\r
  47         {\r
  48             return decomp;\r
  49         }\r
  50         \r
  51         public int getDecompositionCount()\r
  52         {\r
  53             return decomp.length;\r
  54         }\r
  55         \r
  56         public int getDecomposedCharacter(int i)\r
  57         {\r
  58             if (i >= 0 && i < decomp.length) {\r
  59                 return decomp[i];\r
  60             }\r
  61             \r
  62             return -1;\r
  63         }\r
  64         \r
  65         public int compareTo(DecompEntry that)\r
  66         {\r
  67             return this.composed - that.composed;\r
  68         }\r
  69         \r
  70         //\r
  71         // Straight insertion sort from Knuth vol. III, pg. 81\r
  72         //\r
  73         public static void sort(DecompEntry[] table, Vector decompVector)\r
  74         {\r
  75             for (int j = 0; j < table.length; j += 1) {\r
  76                 int i;\r
  77                 DecompEntry v = (DecompEntry) decompVector.elementAt(j);\r
  78 \r
  79                 for (i = j - 1; i >= 0; i -= 1) {\r
  80                     if (v.compareTo(table[i]) >= 0) {\r
  81                       break;\r
  82                     }\r
  83 \r
  84                     table[i + 1] = table[i];\r
  85                 }\r
  86 \r
  87                 table[i + 1] = v;\r
  88             }\r
  89         }\r
  90     }\r
  91     \r
  92     private Vector decompVector;\r
  93     private DecompEntry[] decompEntries;\r
  94     private int snapshotSize;\r
  95     \r
  96     public DecompTable()\r
  97     {\r
  98         decompVector = new Vector();\r
  99         decompEntries = null;\r
 100         snapshotSize = -1;\r
 101     }\r
 102     \r
 103     public void add(int composed, String decomposition)\r
 104     {\r
 105         DecompEntry entry = new DecompEntry(composed, decomposition);\r
 106         \r
 107         decompVector.addElement(entry);\r
 108     }\r
 109     \r
 110     public int getComposedCharacter(int i)\r
 111     {\r
 112         if (i < 0 || i > decompEntries.length) {\r
 113             return -1;\r
 114         }\r
 115         \r
 116         return decompEntries[i].getComposedCharacter();\r
 117     }\r
 118     \r
 119     public int getDecompositionCount(int i)\r
 120     {\r
 121         if (i < 0 || i > decompEntries.length) {\r
 122             return -1;\r
 123         }\r
 124         \r
 125         return decompEntries[i].getDecompositionCount();\r
 126     }\r
 127     \r
 128     public boolean hasEntries()\r
 129     {\r
 130         return decompVector.size() > 0;\r
 131     }\r
 132     \r
 133     private void snapshot()\r
 134     {\r
 135         if (snapshotSize != decompVector.size()) {\r
 136             snapshotSize = decompVector.size();\r
 137             decompEntries = new DecompEntry[snapshotSize];\r
 138             DecompEntry.sort(decompEntries, decompVector);\r
 139         }\r
 140     }\r
 141 \r
 142     public void writeLookupSubtable(OpenTypeTableWriter writer)\r
 143     {\r
 144         snapshot();\r
 145         \r
 146         int multipleSubstitutionsBase = writer.getOutputIndex();\r
 147         int coverageTableIndex, sequenceOffsetIndex;\r
 148         int sequenceCount = decompEntries.length;\r
 149         \r
 150         writer.writeData(1); // format = 1\r
 151         \r
 152         coverageTableIndex = writer.getOutputIndex();\r
 153         writer.writeData(0); // coverage table offset (fixed later)\r
 154         \r
 155         writer.writeData(sequenceCount);\r
 156         \r
 157         sequenceOffsetIndex = writer.getOutputIndex();\r
 158         for (int s = 0; s < sequenceCount; s += 1) {\r
 159             writer.writeData(0); // offset to sequence table (fixed later);\r
 160         }\r
 161         \r
 162         for (int s = 0; s < sequenceCount; s += 1) {\r
 163             DecompEntry entry = decompEntries[s];\r
 164             int decompCount = entry.getDecompositionCount();\r
 165             \r
 166             writer.fixOffset(sequenceOffsetIndex++, multipleSubstitutionsBase);\r
 167             \r
 168             writer.writeData(decompCount); // glyphCount\r
 169             \r
 170             for (int g = 0; g < decompCount; g += 1) {\r
 171                 writer.writeData(entry.getDecomposedCharacter(g));\r
 172             }\r
 173         }\r
 174         \r
 175         // write a format 1 coverage table\r
 176         writer.fixOffset(coverageTableIndex, multipleSubstitutionsBase);\r
 177         writer.writeData(1); // format = 1\r
 178         writer.writeData(sequenceCount);  // glyphCount\r
 179         \r
 180         for (int i = 0; i < sequenceCount; i += 1) {\r
 181             writer.writeData(decompEntries[i].getComposedCharacter());\r
 182         }\r
 183     }\r
 184 }\r