jars/icu4j-4_4_2-src/tools/misc/src/com/ibm/icu/dev/tool/layout/DecompTable.java

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