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