Maximum CD 2001 February/maximum-cd-2001-02.iso/PowerWare/Opera/Opera5_final_java.exe/OPERA.JAR/opera/OperaInputStream.class

Java Class File | 2000-08-08 | 3.2 KB | 217 lines

package opera;

import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.util.Hashtable;

public class OperaInputStream extends InputStream {
   private static final int BUFFER_SIZE = 32768;
   private static Hashtable stream_map = new Hashtable();
   private static int next_stream_id = 0;
   private int protocol_response;
   private byte[] buffer = new byte['ΦÇÇ'];
   private int next_read = 0;
   private int last_avail = -1;
   private int available = 0;
   private int total_input = 0;
   private int content_len = 0;
   private int stream_id = -1;
   private boolean eof_state = false;
   private OperaURLConnection connection = null;

   protected OperaInputStream(OperaURLConnection var1) {
      this.connection = var1;
   }

   public int addInput(byte[] var1) {
      int var2 = 0;
      int var3 = 0;
      synchronized(this){}

      try {
         try {
            if (this.eof_state) {
               byte var12 = -1;
               return var12;
            }

            if (var1.length > 0) {
               if (this.available < 32768) {
                  int var7 = 'ΦÇÇ' - this.available;
                  if (this.last_avail < 32767) {
                     if (var1.length < 'ΦÇÇ' - this.last_avail) {
                        var2 = var1.length;
                     } else {
                        var2 = 'ΦÇÇ' - this.last_avail - 1;
                     }

                     if (var2 > var7) {
                        var2 = var7;
                     }

                     System.arraycopy(var1, 0, this.buffer, this.last_avail + 1, var2);
                  }

                  var7 -= var2;
                  if (var7 > 0) {
                     if (var1.length - var2 > var7) {
                        var3 = var7;
                     } else {
                        var3 = var1.length - var2;
                     }

                     System.arraycopy(var1, var2, this.buffer, 0, var3);
                  }

                  this.last_avail = (this.last_avail + var2 + var3) % 'ΦÇÇ';
               }

               this.notifyAll();
            }
         } catch (ArrayIndexOutOfBoundsException var10) {
            ((Throwable)var10).printStackTrace(System.err);
         }

         this.available += var2 + var3;
         this.total_input += var2 + var3;
         int var4 = var2 + var3;
         return var4;
      } catch (Throwable var11) {
         throw var11;
      }
   }

   protected static int addStream(OperaInputStream var0) {
      Hashtable var1 = stream_map;
      synchronized(var1){}

      try {
         stream_map.put(new Integer(next_stream_id), var0);
         var0.stream_id = next_stream_id++;
      } catch (Throwable var3) {
         throw var3;
      }

      return var0.stream_id;
   }

   public int available() {
      return this.available;
   }

   public int getContentLength() {
      return this.content_len;
   }

   public int getResponse() {
      return this.protocol_response;
   }

   protected static OperaInputStream getStream(int var0) {
      Hashtable var2 = stream_map;
      synchronized(var2){}

      OperaInputStream var1;
      try {
         var1 = (OperaInputStream)stream_map.get(new Integer(var0));
      } catch (Throwable var5) {
         throw var5;
      }

      return var1;
   }

   public void headerLoaded(int var1, int var2) {
      synchronized(this){}

      try {
         if (var1 == 0) {
            var1 = -1;
         }

         this.content_len = var1;
         this.protocol_response = var2;
         this.notifyAll();
      } catch (Throwable var5) {
         throw var5;
      }

   }

   public int read() throws IOException {
      if (this.available() == 0 && this.eof_state) {
         this.buffer = null;
         return -1;
      } else {
         while(this.available() == 0 && !this.eof_state) {
            this.starving();

            try {
               synchronized(this){}

               try {
                  this.wait();
               } catch (Throwable var10) {
                  throw var10;
               }
            } catch (InterruptedException var11) {
               this.eof_state = true;
               this.available = 0;
               Thread.currentThread().interrupt();
               throw new InterruptedIOException();
            }
         }

         synchronized(this){}

         int var1;
         try {
            if (this.available() != 0 || !this.eof_state) {
               --this.available;
               if (this.next_read == 32768) {
                  this.next_read = 0;
               }

               var1 = 255 & this.buffer[this.next_read++];
               return var1;
            }

            this.connection = null;
            this.buffer = null;
            var1 = -1;
         } catch (Throwable var12) {
            throw var12;
         }

         return var1;
      }
   }

   protected static void removeStream(int var0) {
      Hashtable var1 = stream_map;
      synchronized(var1){}

      try {
         stream_map.remove(new Integer(var0));
      } catch (Throwable var3) {
         throw var3;
      }

   }

   public void setEOF() {
      synchronized(this){}

      try {
         this.eof_state = true;
         this.notifyAll();
      } catch (Throwable var3) {
         throw var3;
      }

   }

   private native void starving();
}