home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / applets / collectn / incrset.jav < prev    next >
Encoding:
Text File  |  1995-12-14  |  4.4 KB  |  169 lines
  1. /*
  2.   File: IncrSet.java
  3.  
  4.   Originally written by Doug Lea and released into the public domain. 
  5.   Thanks for the assistance and support of Sun Microsystems Labs, Agorics 
  6.   Inc, Loral, and everyone contributing, testing, and using this code.
  7.  
  8.   History:
  9.   Date     Who                What
  10.   24Sep95  dl@cs.oswego.edu   Create from collections.java  working file
  11.   13Oct95  dl                 Changed to use accessOnly
  12.  
  13. */
  14.   
  15. package collections;
  16.  
  17. import java.util.Enumeration;
  18. import java.util.NoSuchElementException;
  19.  
  20. /**
  21.  *
  22.  *
  23.  * Implementation of pure set
  24.  * @author Doug Lea
  25.  * @version 0.93
  26.  *
  27.  * <P> For an introduction to this package see <A HREF="index.html"> Overview </A>.
  28. **/
  29.  
  30. public final class IncrSet extends IncrImpl implements Set {
  31.  
  32. /**
  33.  * Make a new pure set using the default underlying Set implementation
  34. **/
  35.   public IncrSet() { this(DefaultImplementations.set()); }
  36.  
  37. /**
  38.  * Make a pure set managing the given updatable set s.
  39.  * Warning: Do not modify s during the the lifetime of the constructed pure set!
  40. **/
  41.   public IncrSet(UpdatableSet s) { super(s); }
  42.  
  43.  
  44. /**
  45.  * Make a copy. Uses lazy update.
  46. **/
  47.  
  48.   protected Object clone() throws CloneNotSupportedException {
  49.     undelta();
  50.     IncrSet s = new IncrSet((UpdatableSet)(updatable_));
  51.     nextVersion_ = s;
  52.     updatable_ = null;
  53.     op_ = NO_EDIT;
  54.     return s;
  55.   }
  56.  
  57. /**
  58.  * Implements collections.Set.including
  59.  * @see collections.Set#including
  60. **/
  61.   public synchronized /* IncrSet */ Set including(Object element) 
  62.   throws IllegalElementException {
  63.     undelta(); 
  64.     UpdatableSet u = (UpdatableSet)updatable_;
  65.     boolean has = u.includes(element);
  66.     if (has) 
  67.       return this;
  68.     else {
  69.       u.include(element);
  70.       IncrSet s = new IncrSet(u);
  71.       nextVersion_ = s;
  72.       updatable_ = null;
  73.       firstObjectArg_ = element;
  74.       op_ = REMOVE_EDIT;
  75.       return s;
  76.     }
  77.   }
  78.  
  79.  
  80. /**
  81.  * Implements collections.Collection.removingOneOf
  82.  * @see collections.Collection#removingOneOf
  83. **/
  84.   public synchronized /* IncrSet */ Collection removingOneOf(Object element) {
  85.     undelta(); 
  86.     UpdatableSet u = (UpdatableSet)updatable_;
  87.     boolean has = u.includes(element);
  88.     if (!has)
  89.       return this;
  90.     else {
  91.       u.exclude(element);
  92.       IncrSet s = new IncrSet(u);
  93.       nextVersion_ = s;
  94.       updatable_ = null;
  95.       firstObjectArg_ = element;
  96.       op_ = ADD_EDIT;
  97.       return s;
  98.     }
  99.   }
  100.  
  101. /**
  102.  * Implements collections.Collection.excluding.
  103.  * @see collections.Collection#excluding
  104. **/
  105.   public synchronized /* IncrSet */ Collection excluding(Object element) {
  106.     return this.removingOneOf(element);
  107.   }
  108.  
  109.  
  110. /**
  111.  * Implements collections.Collection.replacingOneOf
  112.  * @see collections.Collection#replacingOneOf
  113. **/
  114.   public synchronized /* IncrSet */ Collection replacingOneOf(Object oldElement,
  115.                                                     Object newElement) 
  116.   throws IllegalElementException {
  117.     undelta(); 
  118.     UpdatableSet u = (UpdatableSet)updatable_;
  119.     boolean hasOld = u.includes(oldElement);
  120.     if (!hasOld)
  121.       return this;
  122.     else {
  123.       boolean hasNew = u.includes(newElement);
  124.       if (hasNew) 
  125.         return this.excluding(oldElement);
  126.       else {
  127.         u.replaceAllOf(oldElement, newElement);
  128.         IncrSet s = new IncrSet(u);
  129.         nextVersion_ = s;
  130.         updatable_ = null;
  131.         firstObjectArg_ = newElement;
  132.         secondObjectArg_ = oldElement;
  133.         op_ = REPLACE_EDIT;
  134.         return s;
  135.       }
  136.     }
  137.   }
  138.  
  139. /**
  140.  * Implements collections.Collection.replacingAllOf
  141.  * @see collections.Collection#replacingAllOf
  142. **/
  143.   public synchronized /* IncrSet */ Collection replacingAllOf(Object oldElement,
  144.                                                         Object newElement) 
  145.   throws IllegalElementException {
  146.     return this.replacingOneOf(oldElement, newElement);
  147.   }
  148.  
  149.  
  150. /**
  151.  * Perform updates within an edit chain
  152. **/
  153.   protected synchronized UpdatableCollection doEdit(UpdatableCollection c) { 
  154.     UpdatableSet u = (UpdatableSet)c;
  155.     try { 
  156.       if (op_ == ADD_EDIT) 
  157.         u.include(firstObjectArg_);
  158.       else if (op_ == REMOVE_EDIT)
  159.         u.exclude(firstObjectArg_);
  160.       else if (op_ == REPLACE_EDIT)
  161.         u.replaceOneOf(firstObjectArg_, secondObjectArg_);
  162.     }
  163.     catch (IllegalElementException ex) {} // we've screened for all possible
  164.     return u;
  165.   }
  166.  
  167. }
  168.  
  169.