home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 1999 April / DPPCPRO0499.ISO / April / Notes / 50b2wic.exe / DATA1.CAB / NotesProgramFilesJavaSupport / rt.jar / java / text / CompactCharArray.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-04-23  |  4.5 KB  |  264 lines
  1. package java.text;
  2.  
  3. final class CompactCharArray 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 boolean isCompact;
  18.  
  19.    public CompactCharArray() {
  20.       this('\u0000');
  21.    }
  22.  
  23.    public CompactCharArray(char var1) {
  24.       this.values = new char[65536];
  25.       this.indices = new short[512];
  26.  
  27.       for(int var2 = 0; var2 < 65536; ++var2) {
  28.          this.values[var2] = var1;
  29.       }
  30.  
  31.       for(int var3 = 0; var3 < 512; ++var3) {
  32.          this.indices[var3] = (short)(var3 << 7);
  33.       }
  34.  
  35.       this.isCompact = false;
  36.    }
  37.  
  38.    public CompactCharArray(short[] var1, char[] var2) {
  39.       if (var1.length != 512) {
  40.          throw new IllegalArgumentException("Index out of bounds.");
  41.       } else {
  42.          for(int var3 = 0; var3 < 512; ++var3) {
  43.             short var4 = var1[var3];
  44.             if (var4 < 0 || var4 >= 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 char elementAt(char var1) {
  55.       return this.values[(this.indices[var1 >> 7] & '\uffff') + (var1 & 127)];
  56.    }
  57.  
  58.    public void setElementAt(char var1, char var2) {
  59.       if (this.isCompact) {
  60.          this.expand();
  61.       }
  62.  
  63.       this.values[var1] = var2;
  64.    }
  65.  
  66.    public void setElementAt(char var1, char var2, char var3) {
  67.       if (this.isCompact) {
  68.          this.expand();
  69.       }
  70.  
  71.       for(int var4 = var1; var4 <= var2; ++var4) {
  72.          this.values[var4] = var3;
  73.       }
  74.  
  75.    }
  76.  
  77.    public void compact() {
  78.       if (!this.isCompact) {
  79.          char[] var1 = new char[65536];
  80.          int var2 = 128;
  81.  
  82.          for(short var5 = 0; var5 < 128; ++var5) {
  83.             var1[var5] = (char)var5;
  84.          }
  85.  
  86.          this.indices[0] = 0;
  87.  
  88.          for(short var4 = 1; var4 < 512; ++var4) {
  89.             int var8 = var4 << 7;
  90.             int var7 = this.FindOverlappingPosition(var8, var1, var2);
  91.             int var6 = var7 + 128;
  92.             if (var6 > var2) {
  93.                for(short var9 = (short)var2; var9 < var6; ++var9) {
  94.                   var1[var9] = (char)(var9 - var7 + var8);
  95.                }
  96.  
  97.                var2 = var6;
  98.             }
  99.  
  100.             this.indices[var4] = (short)var7;
  101.          }
  102.  
  103.          char[] var3 = new char[var2];
  104.  
  105.          for(short var10 = 0; var10 < var2; ++var10) {
  106.             var3[var10] = this.values[var1[var10]];
  107.          }
  108.  
  109.          this.values = null;
  110.          this.values = var3;
  111.          this.isCompact = true;
  112.       }
  113.  
  114.    }
  115.  
  116.    public short[] getIndexArray() {
  117.       return this.indices;
  118.    }
  119.  
  120.    public char[] getStringArray() {
  121.       return this.values;
  122.    }
  123.  
  124.    public Object clone() {
  125.       try {
  126.          CompactCharArray var1 = (CompactCharArray)super.clone();
  127.          var1.values = (char[])this.values.clone();
  128.          var1.indices = (short[])this.indices.clone();
  129.          return var1;
  130.       } catch (CloneNotSupportedException var2) {
  131.          throw new InternalError();
  132.       }
  133.    }
  134.  
  135.    public boolean equals(Object var1) {
  136.       if (var1 == null) {
  137.          return false;
  138.       } else if (this == var1) {
  139.          return true;
  140.       } else if (this.getClass() != var1.getClass()) {
  141.          return false;
  142.       } else {
  143.          CompactCharArray var2 = (CompactCharArray)var1;
  144.  
  145.          for(int var3 = 0; var3 < 65536; ++var3) {
  146.             if (this.elementAt((char)var3) != var2.elementAt((char)var3)) {
  147.                return false;
  148.             }
  149.          }
  150.  
  151.          return true;
  152.       }
  153.    }
  154.  
  155.    public int hashCode() {
  156.       int var1 = 0;
  157.       int var2 = Math.min(3, this.values.length / 16);
  158.  
  159.       for(int var3 = 0; var3 < this.values.length; var3 += var2) {
  160.          var1 = var1 * 37 + this.values[var3];
  161.       }
  162.  
  163.       return var1;
  164.    }
  165.  
  166.    public void writeArrays() {
  167.       int var2 = this.values.length > 0 ? this.values.length : this.values.length + 65536;
  168.       System.out.println("{");
  169.  
  170.       int var1;
  171.       for(var1 = 0; var1 < 511; ++var1) {
  172.          System.out.print("(short)" + (this.getIndexArrayValue(var1) >= 0 ? this.getIndexArrayValue(var1) : this.getIndexArrayValue(var1) + 65536) + ", ");
  173.          if (var1 != 0 && var1 % 10 == 0) {
  174.             System.out.println();
  175.          }
  176.       }
  177.  
  178.       System.out.println("(short)" + (this.getIndexArrayValue(511) >= 0 ? this.getIndexArrayValue(var1) : this.getIndexArrayValue(var1) + 65536) + " }");
  179.       System.out.println("{");
  180.  
  181.       for(int var3 = 0; var3 < var2 - 1; ++var3) {
  182.          System.out.print("(char)" + this.getArrayValue(var3) + ", ");
  183.          if (var3 != 0 && var3 % 10 == 0) {
  184.             System.out.println();
  185.          }
  186.       }
  187.  
  188.       System.out.println("(char)" + this.getArrayValue(var2 - 1) + " }");
  189.    }
  190.  
  191.    public void printIndex(short var1, short var2) {
  192.       for(int var3 = var1; var3 < var2; ++var3) {
  193.          System.out.println(var3 + " -> : " + (this.indices[var3] >= 0 ? this.indices[var3] : this.indices[var3] + 65536));
  194.       }
  195.  
  196.       System.out.println();
  197.    }
  198.  
  199.    public void printPlainArray(int var1, int var2, char[] var3) {
  200.       if (var3 != null) {
  201.          for(int var4 = var1; var4 < var1 + var2; ++var4) {
  202.             System.out.print(" " + this.getArrayValue(var3[var4]));
  203.          }
  204.       } else {
  205.          for(int var5 = var1; var5 < var1 + var2; ++var5) {
  206.             System.out.print(" " + this.getArrayValue(var5));
  207.          }
  208.       }
  209.  
  210.       System.out.println("    Range: start " + var1 + " , count " + var2);
  211.    }
  212.  
  213.    private void expand() {
  214.       if (this.isCompact) {
  215.          char[] var2 = new char[65536];
  216.  
  217.          for(int var1 = 0; var1 < 65536; ++var1) {
  218.             var2[var1] = this.elementAt((char)var1);
  219.          }
  220.  
  221.          for(int var3 = 0; var3 < 512; ++var3) {
  222.             this.indices[var3] = (short)(var3 << 7);
  223.          }
  224.  
  225.          this.values = null;
  226.          this.values = var2;
  227.          this.isCompact = false;
  228.       }
  229.  
  230.    }
  231.  
  232.    private short capacity() {
  233.       return (short)this.values.length;
  234.    }
  235.  
  236.    private char getArrayValue(int var1) {
  237.       return this.values[var1];
  238.    }
  239.  
  240.    private short getIndexArrayValue(int var1) {
  241.       return this.indices[var1];
  242.    }
  243.  
  244.    private int FindOverlappingPosition(int var1, char[] var2, int var3) {
  245.       int var4;
  246.       for(var4 = 0; var4 < var3; var4 += 128) {
  247.          short var6 = 128;
  248.          if (var4 + 128 > var3) {
  249.             var6 = (short)(var3 - var4);
  250.          }
  251.  
  252.          short var5;
  253.          for(var5 = 0; var5 < var6 && this.values[var1 + var5] == this.values[var2[var4 + var5]]; ++var5) {
  254.          }
  255.  
  256.          if (var5 == var6) {
  257.             break;
  258.          }
  259.       }
  260.  
  261.       return var4;
  262.    }
  263. }
  264.