home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / hotjava3 / hotjava3.exe / hotjava / classsrc / java / lang / Ref.java < prev    next >
Encoding:
Java Source  |  1995-08-11  |  3.0 KB  |  97 lines
  1. /*
  2.  * @(#)Ref.java    1.5 95/02/16
  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 java.lang;
  21.  
  22. /**
  23.  * A "Ref" is an indirect reference to an object that the garbage collector
  24.  * knows about.  The application overrides the reconstitute() method with one
  25.  * that will construct the object based on information in the Ref, often by
  26.  * reading from a file.  The get() method retains a cache of the last call to
  27.  * reconstitute() in the Ref.  When space gets tight, the garbage collector
  28.  * will clear old Ref cache entries when there are no other pointers to the
  29.  * object.
  30.  * @version     1.5, 16 Feb 1995
  31.  */
  32.  
  33. public class Ref {
  34.     static int        lruclock;
  35.     private Object  thing;
  36.     private long    priority;
  37.  
  38.     /**
  39.      * Returns a pointer to the object referenced by this Ref.  If the object
  40.      * has been thrown away by the garbage collector, it will be
  41.      * reconstituted. Does everything necessary to ensure that the garbage
  42.      * collector throws things away in LRU order.  Applications should never
  43.      * need to override this method. get() effectively caches calls to
  44.      * reconstitute().
  45.      */
  46.     public Object get() {
  47.     Object p = thing;
  48.     if (p == null) {
  49.         /* synchronize if thing is null, but then check again
  50.            in case somebody else beat us to it */
  51.         synchronize (this) {
  52.         if (thing == null) {
  53.             p = reconstitute();
  54.             thing = p;
  55.         }
  56.         }
  57.     }
  58.     priority = ++lruclock;
  59.     return thing;
  60.     }
  61.  
  62.     /**
  63.      * Returns a pointer to the object referenced by this ref by 
  64.      * reconstituting it from some external source.  It shouldn't bother with
  65.      * caching since get() will deal with that.
  66.      *
  67.      * In normal usage, Ref will always be subclassed.  The subclass will add
  68.      * the instance variables necessary for reconstitute() to work.  It will
  69.      * also add a constructor to set them up, and write a version of
  70.      * reconstitute().
  71.      */
  72.     public abstract Object reconstitute();
  73.  
  74.     /**
  75.      * Flushes the cached object.  Forces the next invocation of get() to
  76.      * invoke reconstitute().
  77.      */
  78.     public void flush() {
  79.     thing = null;
  80.     }
  81.  
  82.     public void setThing(Object thing) {
  83.     this.thing = thing;
  84.     }
  85.  
  86.     public Object check() {
  87.     return thing;
  88.     }
  89.  
  90.     /**
  91.      * Constructs a new Ref.
  92.      */
  93.     public Ref() {
  94.     priority = ++lruclock;
  95.     }
  96. }
  97.