home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 1999 April / DPPCPRO0499.ISO / April / Notes / 50b2wic.exe / DATA1.CAB / NotesProgramFilesJavaSupport / rt.jar / java / text / CompactStringArray.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-04-23  |  5.5 KB  |  320 lines
  1. package java.text;
  2.  
  3. final class CompactStringArray implements Cloneable {
  4.    public static final int UNICODECOUNT = 65536;
  5.    private static final int DEBUGSHOWOVERLAPLIMIT = 100;
  6.    private static final boolean DEBUGTRACE = false;
  7.    private static final boolean DEBUGSMALL = false;
  8.    private static final boolean DEBUGOVERLAP = false;
  9.    private static final int DEBUGSMALLLIMIT = 30000;
  10.    private static final int BLOCKSHIFT = 7;
  11.    private static final int BLOCKCOUNT = 128;
  12.    private static final int INDEXSHIFT = 9;
  13.    private static final int INDEXCOUNT = 512;
  14.    private static final int BLOCKMASK = 127;
  15.    private char[] values;
  16.    private short[] indices;
  17.    private StringBuffer exceptions;
  18.    private boolean isCompact;
  19.  
  20.    public CompactStringArray() {
  21.       this("");
  22.    }
  23.  
  24.    public CompactStringArray(String var1) {
  25.       this.exceptions = new StringBuffer();
  26.       this.values = new char[65536];
  27.       this.indices = new short[512];
  28.       this.setElementAt('\u0000', '\uffff', var1);
  29.  
  30.       for(int var2 = 0; var2 < 512; ++var2) {
  31.          this.indices[var2] = (short)(var2 << 7);
  32.       }
  33.  
  34.       this.isCompact = false;
  35.    }
  36.  
  37.    public CompactStringArray(short[] var1, char[] var2, String var3) {
  38.       this.exceptions = new StringBuffer();
  39.       if (var1.length != 512) {
  40.          throw new IllegalArgumentException("Index out of bounds.");
  41.       } else {
  42.          for(int var4 = 0; var4 < 512; ++var4) {
  43.             short var5 = var1[var4];
  44.             if (var5 < 0 || var5 >= var2.length + 128) {
  45.                throw new IllegalArgumentException("Index out of bounds.");
  46.             }
  47.          }
  48.  
  49.          this.indices = var1;
  50.          this.values = var2;
  51.       }
  52.    }
  53.  
  54.    public void elementAt(char var1, StringBuffer var2) {
  55.       char var3 = this.values[(this.indices[var1 >> 7] & '\uffff') + (var1 & 127)];
  56.       if (var3 >= '\ue000' && var3 <= '\uf800') {
  57.          int var4 = var3 - '\ue000';
  58.  
  59.          while(true) {
  60.             var3 = this.exceptions.charAt(var4);
  61.             if (var3 == '\uffff') {
  62.                return;
  63.             }
  64.  
  65.             var2.append(var3);
  66.             ++var4;
  67.          }
  68.       } else {
  69.          var2.append(var3);
  70.       }
  71.    }
  72.  
  73.    public String elementAt(char var1) {
  74.       StringBuffer var2 = new StringBuffer();
  75.       this.elementAt(var1, var2);
  76.       return var2.toString();
  77.    }
  78.  
  79.    public void setElementAt(char var1, String var2) {
  80.       if (this.isCompact) {
  81.          this.expand();
  82.       }
  83.  
  84.       if (var2.length() == 1) {
  85.          char var3 = var2.charAt(0);
  86.          if (var3 < '\ue000' || var3 >= '\uf800') {
  87.             this.values[var1] = var3;
  88.             return;
  89.          }
  90.       }
  91.  
  92.       String var6 = var2 + '\uffff';
  93.       int var4 = this.exceptions.toString().indexOf(var6);
  94.       if (var4 != -1) {
  95.          this.values[var1] = (char)('\ue000' + var4);
  96.       } else {
  97.          this.values[var1] = (char)('\ue000' + this.exceptions.length());
  98.  
  99.          for(int var5 = 0; var5 < var2.length(); ++var5) {
  100.             this.exceptions.append(var2.charAt(var5));
  101.          }
  102.  
  103.          this.exceptions.append('\uffff');
  104.       }
  105.    }
  106.  
  107.    public void setElementAt(char var1, char var2, String var3) {
  108.       if (var1 < var2) {
  109.          this.setElementAt(var1, var3);
  110.          char var4 = this.values[var1];
  111.  
  112.          for(int var5 = var1 + 1; var5 <= var2; ++var5) {
  113.             this.values[var5] = var4;
  114.          }
  115.  
  116.       }
  117.    }
  118.  
  119.    public void compact() {
  120.       if (!this.isCompact) {
  121.          char[] var1 = new char[65536];
  122.          int var2 = 128;
  123.  
  124.          for(short var5 = 0; var5 < 128; ++var5) {
  125.             var1[var5] = (char)var5;
  126.          }
  127.  
  128.          this.indices[0] = 0;
  129.  
  130.          for(short var4 = 1; var4 < 512; ++var4) {
  131.             int var8 = var4 << 7;
  132.             int var7 = this.FindOverlappingPosition(var8, var1, var2);
  133.             int var6 = var7 + 128;
  134.             if (var6 > var2) {
  135.                for(short var9 = (short)var2; var9 < var6; ++var9) {
  136.                   var1[var9] = (char)(var9 - var7 + var8);
  137.                }
  138.  
  139.                var2 = var6;
  140.             }
  141.  
  142.             this.indices[var4] = (short)var7;
  143.          }
  144.  
  145.          char[] var3 = new char[var2];
  146.  
  147.          for(short var10 = 0; var10 < var2; ++var10) {
  148.             var3[var10] = this.values[var1[var10]];
  149.          }
  150.  
  151.          this.values = null;
  152.          this.values = var3;
  153.          this.isCompact = true;
  154.       }
  155.  
  156.    }
  157.  
  158.    public short[] getIndexArray() {
  159.       return this.indices;
  160.    }
  161.  
  162.    public char[] getStringArray() {
  163.       return this.values;
  164.    }
  165.  
  166.    public Object clone() {
  167.       try {
  168.          CompactStringArray var1 = (CompactStringArray)super.clone();
  169.          var1.values = (char[])this.values.clone();
  170.          var1.indices = (short[])this.indices.clone();
  171.          var1.exceptions = new StringBuffer(this.exceptions.toString());
  172.          return var1;
  173.       } catch (CloneNotSupportedException var2) {
  174.          throw new InternalError();
  175.       }
  176.    }
  177.  
  178.    public boolean equals(Object var1) {
  179.       if (var1 == null) {
  180.          return false;
  181.       } else if (this == var1) {
  182.          return true;
  183.       } else if (this.getClass() != var1.getClass()) {
  184.          return false;
  185.       } else {
  186.          CompactStringArray var2 = (CompactStringArray)var1;
  187.  
  188.          for(int var3 = 0; var3 < 65536; ++var3) {
  189.             if (this.elementAt((char)var3) != var2.elementAt((char)var3)) {
  190.                return false;
  191.             }
  192.          }
  193.  
  194.          return true;
  195.       }
  196.    }
  197.  
  198.    public int hashCode() {
  199.       int var1 = 0;
  200.       int var2 = Math.min(3, this.values.length / 16);
  201.  
  202.       for(int var3 = 0; var3 < this.values.length; var3 += var2) {
  203.          var1 = var1 * 37 + this.values[var3];
  204.       }
  205.  
  206.       return var1;
  207.    }
  208.  
  209.    void writeArrays() {
  210.       int var2 = 0;
  211.       if (this.values.length > 0) {
  212.          var2 = this.values.length;
  213.       } else {
  214.          var2 = this.values.length + 65536;
  215.       }
  216.  
  217.       System.out.println("{");
  218.  
  219.       int var1;
  220.       for(var1 = 0; var1 < 511; ++var1) {
  221.          System.out.print("(short)" + (this.getIndexArrayValue(var1) >= 0 ? this.getIndexArrayValue(var1) : this.getIndexArrayValue(var1) + 65536) + ", ");
  222.          if (var1 != 0 && var1 % 10 == 0) {
  223.             System.out.println();
  224.          }
  225.       }
  226.  
  227.       System.out.println("(char)" + (this.getIndexArrayValue(511) >= 0 ? this.getIndexArrayValue(var1) : this.getIndexArrayValue(var1) + 65536) + " }");
  228.       System.out.println("{");
  229.  
  230.       for(int var4 = 0; var4 < var2 - 1; ++var4) {
  231.          char var3 = this.getArrayValue(var4);
  232.          if (var3 >= ' ' && (var3 <= '~' || var3 >= 160) && var3 <= 256) {
  233.             System.out.print("'" + var3 + "',");
  234.          } else {
  235.             System.out.print("(char)0x" + Integer.toString(var3, 16).toUpperCase() + ",");
  236.          }
  237.  
  238.          if (var4 != 0 && var4 % 10 == 0) {
  239.             System.out.println();
  240.          }
  241.       }
  242.  
  243.       System.out.println("(char)" + this.getArrayValue(var2 - 1) + " }");
  244.       System.out.println("\"" + this.exceptions.toString() + "\"");
  245.    }
  246.  
  247.    void printIndex(char var1, short var2) {
  248.       for(int var3 = var1; var3 < var2; ++var3) {
  249.          System.out.println(var3 + " -> : " + (this.indices[var3] >= 0 ? this.indices[var3] : this.indices[var3] + 65536));
  250.       }
  251.  
  252.       System.out.println();
  253.    }
  254.  
  255.    void printPlainArray(int var1, int var2, char[] var3) {
  256.       if (var3 != null) {
  257.          for(int var4 = var1; var4 < var1 + var2; ++var4) {
  258.             System.out.print(" " + this.getArrayValue(var3[var4]));
  259.          }
  260.       } else {
  261.          for(int var5 = var1; var5 < var1 + var2; ++var5) {
  262.             System.out.print(" " + this.getArrayValue(var5));
  263.          }
  264.       }
  265.  
  266.       System.out.println("    Range: start " + var1 + " , count " + var2);
  267.    }
  268.  
  269.    private void expand() {
  270.       if (this.isCompact) {
  271.          char[] var2 = new char[65536];
  272.  
  273.          for(int var1 = 0; var1 < 65536; ++var1) {
  274.             var2[var1] = this.values[(this.indices[var1 >> 7] & '\uffff') + (var1 & 127)];
  275.          }
  276.  
  277.          for(int var3 = 0; var3 < 512; ++var3) {
  278.             this.indices[var3] = (short)(var3 << 7);
  279.          }
  280.  
  281.          this.values = null;
  282.          this.values = var2;
  283.          this.isCompact = false;
  284.       }
  285.  
  286.    }
  287.  
  288.    private short capacity() {
  289.       return (short)this.values.length;
  290.    }
  291.  
  292.    private char getArrayValue(int var1) {
  293.       return this.values[var1];
  294.    }
  295.  
  296.    private short getIndexArrayValue(int var1) {
  297.       return this.indices[var1];
  298.    }
  299.  
  300.    private int FindOverlappingPosition(int var1, char[] var2, int var3) {
  301.       int var4;
  302.       for(var4 = 0; var4 < var3; var4 += 128) {
  303.          short var6 = 128;
  304.          if (var4 + 128 > var3) {
  305.             var6 = (short)(var3 - var4);
  306.          }
  307.  
  308.          short var5;
  309.          for(var5 = 0; var5 < var6 && this.values[var1 + var5] == this.values[var2[var4 + var5]]; ++var5) {
  310.          }
  311.  
  312.          if (var5 == var6) {
  313.             break;
  314.          }
  315.       }
  316.  
  317.       return var4;
  318.    }
  319. }
  320.