home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / io / ObjectOutputStream$BlockDataOutputStream.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  5.4 KB  |  444 lines
  1. package java.io;
  2.  
  3. class ObjectOutputStream$BlockDataOutputStream extends OutputStream implements DataOutput {
  4.    private static final int MAX_BLOCK_SIZE = 1024;
  5.    private static final int MAX_HEADER_SIZE = 5;
  6.    private static final int CHAR_BUF_SIZE = 256;
  7.    private final byte[] buf = new byte[1024];
  8.    private final byte[] hbuf = new byte[5];
  9.    private final char[] cbuf = new char[256];
  10.    private boolean blkmode = false;
  11.    private int pos = 0;
  12.    private final OutputStream out;
  13.    private final DataOutputStream dout;
  14.  
  15.    ObjectOutputStream$BlockDataOutputStream(OutputStream var1) {
  16.       this.out = var1;
  17.       this.dout = new DataOutputStream(this);
  18.    }
  19.  
  20.    boolean setBlockDataMode(boolean var1) throws IOException {
  21.       if (this.blkmode == var1) {
  22.          return this.blkmode;
  23.       } else {
  24.          this.drain();
  25.          this.blkmode = var1;
  26.          return !this.blkmode;
  27.       }
  28.    }
  29.  
  30.    boolean getBlockDataMode() {
  31.       return this.blkmode;
  32.    }
  33.  
  34.    public void write(int var1) throws IOException {
  35.       if (this.pos >= 1024) {
  36.          this.drain();
  37.       }
  38.  
  39.       this.buf[this.pos++] = (byte)var1;
  40.    }
  41.  
  42.    public void write(byte[] var1) throws IOException {
  43.       this.write(var1, 0, var1.length, false);
  44.    }
  45.  
  46.    public void write(byte[] var1, int var2, int var3) throws IOException {
  47.       this.write(var1, var2, var3, false);
  48.    }
  49.  
  50.    public void flush() throws IOException {
  51.       this.drain();
  52.       this.out.flush();
  53.    }
  54.  
  55.    public void close() throws IOException {
  56.       this.flush();
  57.       this.out.close();
  58.    }
  59.  
  60.    void write(byte[] var1, int var2, int var3, boolean var4) throws IOException {
  61.       if (!var4 && !this.blkmode) {
  62.          this.drain();
  63.          this.out.write(var1, var2, var3);
  64.       } else {
  65.          while(var3 > 0) {
  66.             if (this.pos >= 1024) {
  67.                this.drain();
  68.             }
  69.  
  70.             if (var3 >= 1024 && !var4 && this.pos == 0) {
  71.                this.writeBlockHeader(1024);
  72.                this.out.write(var1, var2, 1024);
  73.                var2 += 1024;
  74.                var3 -= 1024;
  75.             } else {
  76.                int var5 = Math.min(var3, 1024 - this.pos);
  77.                System.arraycopy(var1, var2, this.buf, this.pos, var5);
  78.                this.pos += var5;
  79.                var2 += var5;
  80.                var3 -= var5;
  81.             }
  82.          }
  83.  
  84.       }
  85.    }
  86.  
  87.    void drain() throws IOException {
  88.       if (this.pos != 0) {
  89.          if (this.blkmode) {
  90.             this.writeBlockHeader(this.pos);
  91.          }
  92.  
  93.          this.out.write(this.buf, 0, this.pos);
  94.          this.pos = 0;
  95.       }
  96.    }
  97.  
  98.    private void writeBlockHeader(int var1) throws IOException {
  99.       if (var1 <= 255) {
  100.          this.hbuf[0] = 119;
  101.          this.hbuf[1] = (byte)var1;
  102.          this.out.write(this.hbuf, 0, 2);
  103.       } else {
  104.          this.hbuf[0] = 122;
  105.          Bits.putInt(this.hbuf, 1, var1);
  106.          this.out.write(this.hbuf, 0, 5);
  107.       }
  108.  
  109.    }
  110.  
  111.    public void writeBoolean(boolean var1) throws IOException {
  112.       if (this.pos >= 1024) {
  113.          this.drain();
  114.       }
  115.  
  116.       Bits.putBoolean(this.buf, this.pos++, var1);
  117.    }
  118.  
  119.    public void writeByte(int var1) throws IOException {
  120.       if (this.pos >= 1024) {
  121.          this.drain();
  122.       }
  123.  
  124.       this.buf[this.pos++] = (byte)var1;
  125.    }
  126.  
  127.    public void writeChar(int var1) throws IOException {
  128.       if (this.pos + 2 <= 1024) {
  129.          Bits.putChar(this.buf, this.pos, (char)var1);
  130.          this.pos += 2;
  131.       } else {
  132.          this.dout.writeChar(var1);
  133.       }
  134.  
  135.    }
  136.  
  137.    public void writeShort(int var1) throws IOException {
  138.       if (this.pos + 2 <= 1024) {
  139.          Bits.putShort(this.buf, this.pos, (short)var1);
  140.          this.pos += 2;
  141.       } else {
  142.          this.dout.writeShort(var1);
  143.       }
  144.  
  145.    }
  146.  
  147.    public void writeInt(int var1) throws IOException {
  148.       if (this.pos + 4 <= 1024) {
  149.          Bits.putInt(this.buf, this.pos, var1);
  150.          this.pos += 4;
  151.       } else {
  152.          this.dout.writeInt(var1);
  153.       }
  154.  
  155.    }
  156.  
  157.    public void writeFloat(float var1) throws IOException {
  158.       if (this.pos + 4 <= 1024) {
  159.          Bits.putFloat(this.buf, this.pos, var1);
  160.          this.pos += 4;
  161.       } else {
  162.          this.dout.writeFloat(var1);
  163.       }
  164.  
  165.    }
  166.  
  167.    public void writeLong(long var1) throws IOException {
  168.       if (this.pos + 8 <= 1024) {
  169.          Bits.putLong(this.buf, this.pos, var1);
  170.          this.pos += 8;
  171.       } else {
  172.          this.dout.writeLong(var1);
  173.       }
  174.  
  175.    }
  176.  
  177.    public void writeDouble(double var1) throws IOException {
  178.       if (this.pos + 8 <= 1024) {
  179.          Bits.putDouble(this.buf, this.pos, var1);
  180.          this.pos += 8;
  181.       } else {
  182.          this.dout.writeDouble(var1);
  183.       }
  184.  
  185.    }
  186.  
  187.    public void writeBytes(String var1) throws IOException {
  188.       int var2 = var1.length();
  189.       int var3 = 0;
  190.       int var4 = 0;
  191.  
  192.       int var6;
  193.       for(int var5 = 0; var5 < var2; var5 += var6) {
  194.          if (var3 >= var4) {
  195.             var3 = 0;
  196.             var4 = Math.min(var2 - var5, 256);
  197.             var1.getChars(var5, var5 + var4, this.cbuf, 0);
  198.          }
  199.  
  200.          if (this.pos >= 1024) {
  201.             this.drain();
  202.          }
  203.  
  204.          var6 = Math.min(var4 - var3, 1024 - this.pos);
  205.  
  206.          for(int var7 = this.pos + var6; this.pos < var7; this.buf[this.pos++] = (byte)this.cbuf[var3++]) {
  207.          }
  208.       }
  209.  
  210.    }
  211.  
  212.    public void writeChars(String var1) throws IOException {
  213.       int var2 = var1.length();
  214.  
  215.       int var4;
  216.       for(int var3 = 0; var3 < var2; var3 += var4) {
  217.          var4 = Math.min(var2 - var3, 256);
  218.          var1.getChars(var3, var3 + var4, this.cbuf, 0);
  219.          this.writeChars(this.cbuf, 0, var4);
  220.       }
  221.  
  222.    }
  223.  
  224.    public void writeUTF(String var1) throws IOException {
  225.       this.writeUTF(var1, this.getUTFLength(var1));
  226.    }
  227.  
  228.    void writeBooleans(boolean[] var1, int var2, int var3) throws IOException {
  229.       int var4 = var2 + var3;
  230.  
  231.       while(var2 < var4) {
  232.          if (this.pos >= 1024) {
  233.             this.drain();
  234.          }
  235.  
  236.          int var5 = Math.min(var4, var2 + (1024 - this.pos));
  237.  
  238.          while(var2 < var5) {
  239.             Bits.putBoolean(this.buf, this.pos++, var1[var2++]);
  240.          }
  241.       }
  242.  
  243.    }
  244.  
  245.    void writeChars(char[] var1, int var2, int var3) throws IOException {
  246.       short var4 = 1022;
  247.       int var5 = var2 + var3;
  248.  
  249.       while(var2 < var5) {
  250.          if (this.pos <= var4) {
  251.             int var6 = 1024 - this.pos >> 1;
  252.  
  253.             for(int var7 = Math.min(var5, var2 + var6); var2 < var7; this.pos += 2) {
  254.                Bits.putChar(this.buf, this.pos, var1[var2++]);
  255.             }
  256.          } else {
  257.             this.dout.writeChar(var1[var2++]);
  258.          }
  259.       }
  260.  
  261.    }
  262.  
  263.    void writeShorts(short[] var1, int var2, int var3) throws IOException {
  264.       short var4 = 1022;
  265.       int var5 = var2 + var3;
  266.  
  267.       while(var2 < var5) {
  268.          if (this.pos <= var4) {
  269.             int var6 = 1024 - this.pos >> 1;
  270.  
  271.             for(int var7 = Math.min(var5, var2 + var6); var2 < var7; this.pos += 2) {
  272.                Bits.putShort(this.buf, this.pos, var1[var2++]);
  273.             }
  274.          } else {
  275.             this.dout.writeShort(var1[var2++]);
  276.          }
  277.       }
  278.  
  279.    }
  280.  
  281.    void writeInts(int[] var1, int var2, int var3) throws IOException {
  282.       short var4 = 1020;
  283.       int var5 = var2 + var3;
  284.  
  285.       while(var2 < var5) {
  286.          if (this.pos <= var4) {
  287.             int var6 = 1024 - this.pos >> 2;
  288.  
  289.             for(int var7 = Math.min(var5, var2 + var6); var2 < var7; this.pos += 4) {
  290.                Bits.putInt(this.buf, this.pos, var1[var2++]);
  291.             }
  292.          } else {
  293.             this.dout.writeInt(var1[var2++]);
  294.          }
  295.       }
  296.  
  297.    }
  298.  
  299.    void writeFloats(float[] var1, int var2, int var3) throws IOException {
  300.       short var4 = 1020;
  301.       int var5 = var2 + var3;
  302.  
  303.       while(var2 < var5) {
  304.          if (this.pos <= var4) {
  305.             int var6 = 1024 - this.pos >> 2;
  306.             int var7 = Math.min(var5 - var2, var6);
  307.             ObjectOutputStream.access$400(var1, var2, this.buf, this.pos, var7);
  308.             var2 += var7;
  309.             this.pos += var7 << 2;
  310.          } else {
  311.             this.dout.writeFloat(var1[var2++]);
  312.          }
  313.       }
  314.  
  315.    }
  316.  
  317.    void writeLongs(long[] var1, int var2, int var3) throws IOException {
  318.       short var4 = 1016;
  319.       int var5 = var2 + var3;
  320.  
  321.       while(var2 < var5) {
  322.          if (this.pos <= var4) {
  323.             int var6 = 1024 - this.pos >> 3;
  324.  
  325.             for(int var7 = Math.min(var5, var2 + var6); var2 < var7; this.pos += 8) {
  326.                Bits.putLong(this.buf, this.pos, var1[var2++]);
  327.             }
  328.          } else {
  329.             this.dout.writeLong(var1[var2++]);
  330.          }
  331.       }
  332.  
  333.    }
  334.  
  335.    void writeDoubles(double[] var1, int var2, int var3) throws IOException {
  336.       short var4 = 1016;
  337.       int var5 = var2 + var3;
  338.  
  339.       while(var2 < var5) {
  340.          if (this.pos <= var4) {
  341.             int var6 = 1024 - this.pos >> 3;
  342.             int var7 = Math.min(var5 - var2, var6);
  343.             ObjectOutputStream.access$500(var1, var2, this.buf, this.pos, var7);
  344.             var2 += var7;
  345.             this.pos += var7 << 3;
  346.          } else {
  347.             this.dout.writeDouble(var1[var2++]);
  348.          }
  349.       }
  350.  
  351.    }
  352.  
  353.    long getUTFLength(String var1) {
  354.       int var2 = var1.length();
  355.       long var3 = 0L;
  356.  
  357.       int var6;
  358.       for(int var5 = 0; var5 < var2; var5 += var6) {
  359.          var6 = Math.min(var2 - var5, 256);
  360.          var1.getChars(var5, var5 + var6, this.cbuf, 0);
  361.  
  362.          for(int var7 = 0; var7 < var6; ++var7) {
  363.             char var8 = this.cbuf[var7];
  364.             if (var8 >= 1 && var8 <= 127) {
  365.                ++var3;
  366.             } else if (var8 > 2047) {
  367.                var3 += 3L;
  368.             } else {
  369.                var3 += 2L;
  370.             }
  371.          }
  372.       }
  373.  
  374.       return var3;
  375.    }
  376.  
  377.    void writeUTF(String var1, long var2) throws IOException {
  378.       if (var2 > 65535L) {
  379.          throw new UTFDataFormatException();
  380.       } else {
  381.          this.writeShort((int)var2);
  382.          if (var2 == (long)var1.length()) {
  383.             this.writeBytes(var1);
  384.          } else {
  385.             this.writeUTFBody(var1);
  386.          }
  387.  
  388.       }
  389.    }
  390.  
  391.    void writeLongUTF(String var1) throws IOException {
  392.       this.writeLongUTF(var1, this.getUTFLength(var1));
  393.    }
  394.  
  395.    void writeLongUTF(String var1, long var2) throws IOException {
  396.       this.writeLong(var2);
  397.       if (var2 == (long)var1.length()) {
  398.          this.writeBytes(var1);
  399.       } else {
  400.          this.writeUTFBody(var1);
  401.       }
  402.  
  403.    }
  404.  
  405.    private void writeUTFBody(String var1) throws IOException {
  406.       short var2 = 1021;
  407.       int var3 = var1.length();
  408.  
  409.       int var5;
  410.       for(int var4 = 0; var4 < var3; var4 += var5) {
  411.          var5 = Math.min(var3 - var4, 256);
  412.          var1.getChars(var4, var4 + var5, this.cbuf, 0);
  413.  
  414.          for(int var6 = 0; var6 < var5; ++var6) {
  415.             char var7 = this.cbuf[var6];
  416.             if (this.pos <= var2) {
  417.                if (var7 <= 127 && var7 != 0) {
  418.                   this.buf[this.pos++] = (byte)var7;
  419.                } else if (var7 > 2047) {
  420.                   this.buf[this.pos + 2] = (byte)(128 | var7 >> 0 & 63);
  421.                   this.buf[this.pos + 1] = (byte)(128 | var7 >> 6 & 63);
  422.                   this.buf[this.pos + 0] = (byte)(224 | var7 >> 12 & 15);
  423.                   this.pos += 3;
  424.                } else {
  425.                   this.buf[this.pos + 1] = (byte)(128 | var7 >> 0 & 63);
  426.                   this.buf[this.pos + 0] = (byte)(192 | var7 >> 6 & 31);
  427.                   this.pos += 2;
  428.                }
  429.             } else if (var7 <= 127 && var7 != 0) {
  430.                this.write(var7);
  431.             } else if (var7 > 2047) {
  432.                this.write(224 | var7 >> 12 & 15);
  433.                this.write(128 | var7 >> 6 & 63);
  434.                this.write(128 | var7 >> 0 & 63);
  435.             } else {
  436.                this.write(192 | var7 >> 6 & 31);
  437.                this.write(128 | var7 >> 0 & 63);
  438.             }
  439.          }
  440.       }
  441.  
  442.    }
  443. }
  444.