home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1995 November / PCWK1195.iso / inne / win95 / sieciowe / hotja32.lzh / hotjava / classsrc / net / www / html / meteredstream.java < prev    next >
Text File  |  1995-08-11  |  3KB  |  137 lines
  1. /*
  2.  * @(#)MeteredStream.java    1.13 95/02/07 Chris Warth
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. package net.www.html;
  21.  
  22. import java.util.*;
  23. import java.io.*;
  24. import net.ProgressData;
  25.  
  26. public 
  27. class MeteredStream extends FilterInputStream 
  28. {
  29.     // Class variables.
  30.     private static int    total_need;    
  31.     private static int    total_read;    
  32.     private static int    total_connections = 0;
  33.  
  34.     // Instance variables.
  35.     int expected;
  36.     int    count = 0;
  37.     public URL url = null;
  38.    
  39.     private synchronized static void globalJustRead(int n) {
  40.     total_read += n;
  41.     }
  42.  
  43.     private synchronized static void updateExpected(int est) {
  44.     total_need += est;
  45.     }
  46.  
  47.     private synchronized static void addConnection(MeteredStream s) {
  48.     total_connections += 1;
  49.     }
  50.  
  51.     private synchronized static void removeConnection(MeteredStream s) {
  52.     total_connections -= 1;
  53.     total_read -= s.expected;
  54.     total_need -= s.expected;
  55.     }
  56.  
  57.     /*
  58.      * Provide read-only access the static variables of interest to
  59.      * observers.  It is expected that these methods are accessed
  60.      * with the static monitor locked.  This is usually the case
  61.      * because the notification to observers happens through the
  62.      * synchronized method checkUpdate().
  63.      */
  64.     public static synchronized 
  65.     ProgressReport checkProgress(ProgressReport pr) {
  66.     return pr.set(total_read, total_need, total_connections);
  67.     }
  68.  
  69.     public MeteredStream(InputStream is, int estimate, URL u) {
  70.     this(is, estimate);
  71.     this.url = u;
  72.     }
  73.  
  74.     public MeteredStream(InputStream is, int estimate) {
  75.     super(is);
  76.     updateExpected(estimate);
  77.     expected = estimate;
  78.     addConnection(this);
  79.     }
  80.  
  81.     private final void justRead(int n) {
  82.     if (count + n > expected) {
  83.         n = expected - count;
  84.     }
  85.     count += n;
  86.     globalJustRead(n);
  87.     ProgressData.pdata.update(url, count, expected);
  88.     }
  89.  
  90.  
  91.     public int read() {
  92.     int c = super.read();
  93.     if (c != -1) {
  94.         justRead(1);
  95.     }
  96.     return c;
  97.     }
  98.  
  99.     /*
  100.     public int read(byte b[]) 
  101.     This routine is implemented in terms of read(byte b[], int off, int len)
  102.     so we don't need to override it here.
  103.     */
  104.  
  105.     public int read(byte b[], int off, int len) {
  106.     int n = super.read(b, off, len);
  107.     if (n != -1) {
  108.         justRead(n);
  109.     }
  110.     return n;
  111.     }
  112.     
  113.     public int skip(int n) {
  114.     n = super.skip(n);
  115.     if (n != -1) {
  116.         justRead(n);
  117.     }
  118.     return n;
  119.     }
  120.  
  121.     boolean closed = false;
  122.  
  123.     public void close() {
  124.     super.close();
  125.     if (!closed) {
  126.         closed = true;
  127.         justRead(expected - count);
  128.         removeConnection(this);
  129.     }
  130.     ProgressData.pdata.unregister(url);
  131.     }
  132.  
  133.     protected void finalize() {
  134.     close();
  135.     }
  136. }
  137.