home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / applets / collectn / checkedb.jav < prev    next >
Encoding:
Text File  |  1995-12-14  |  4.8 KB  |  195 lines
  1. /*
  2.   File: CheckedBag.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                 Misc clean up
  12.   19Oct95  dl                 More misc clean up
  13.  
  14. */
  15.   
  16. package collections;
  17.  
  18. import java.util.Enumeration;
  19. import java.util.NoSuchElementException;
  20.  
  21. /**
  22.  *
  23.  * @author Doug Lea
  24.  * @version 0.94
  25.  *
  26.  * <P> For an introduction to this package see <A HREF="index.html"> Overview </A>.
  27. **/
  28.  
  29. public class CheckedBag extends CheckedCollection implements UpdatableBag  {
  30.  
  31. /**
  32.  * Wrap Bag b inside a checker
  33. **/
  34.   public CheckedBag(UpdatableBag b) { super(b); }
  35.  
  36. /**
  37.  * Make a Checked clone of underlying collection
  38. **/
  39.  
  40.   protected Object clone() throws CloneNotSupportedException { 
  41.     return new CheckedBag((UpdatableBag)(thys.duplicate()));
  42.   }
  43.  
  44. /**
  45.  * return casted version of CheckedCollection.thys.
  46. **/
  47.   public UpdatableBag thys() { return (UpdatableBag)thys; }
  48.  
  49. /**
  50.  * return casted version of CheckedCollection.prev.
  51. **/
  52.  
  53.   public UpdatableBag prev() { return (UpdatableBag)prev; }
  54.  
  55. /**
  56.  * Checks collections.UpdatableBag.addIfAbsent according to its specification
  57.  * @see collections.UpdatableBag#addIfAbsent
  58. **/
  59.  
  60.   public synchronized void addIfAbsent(Object element) 
  61.   throws IllegalElementException {
  62.     preCheck();
  63.     try {
  64.       thys().addIfAbsent(element);
  65.       checkAdd(thys, prev, element, true, true);
  66.       postCheck();
  67.     }
  68.     catch (IllegalElementException ex) {
  69.       assert(!prev.canInclude(element));
  70.     assert(thys.sameStructure(prev));
  71.       assert(thys.sameStructure(prev));
  72.       postCheck();
  73.       throw ex;
  74.     }
  75.   }
  76.  
  77. /**
  78.  * Checks collections.Bag.addingIfAbsent
  79.  * @see collections.Bag#addingIfAbsent
  80. **/
  81.   public synchronized Bag addingIfAbsent(Object element) 
  82.   throws IllegalElementException {
  83.     preCheck();
  84.     try {
  85.       Bag nc = thys().addingIfAbsent(element);
  86.       checkAdd(nc, thys, element, true, false);
  87.       assert(thys.sameStructure(prev));
  88.       postCheck();
  89.       return nc;
  90.     }
  91.     catch (IllegalElementException ex) {
  92.       assert(!prev.canInclude(element));
  93.       assert(thys.sameStructure(prev));
  94.       postCheck();
  95.       throw ex;
  96.     }
  97.  
  98.   }
  99.  
  100. /**
  101.  * Checks collections.UpdatableBag.add according to its specification
  102.  * @see collections.UpdatableBag#add
  103. **/
  104.   public synchronized void add(Object element) throws IllegalElementException {
  105.     preCheck();
  106.     try {
  107.       thys().add(element);
  108.       checkAdd(thys, prev, element, false, true);
  109.       postCheck();
  110.     }
  111.     catch (IllegalElementException ex) {
  112.       assert(!prev.canInclude(element));
  113.       assert(thys.sameStructure(prev));
  114.       postCheck();
  115.       throw ex;
  116.     }
  117.   }
  118.  
  119.  
  120. /**
  121.  * Checks collections.Bag.adding
  122.  * @see collections.Bag#adding
  123. **/
  124.  
  125.   public synchronized  Bag adding(Object element) 
  126.   throws IllegalElementException {
  127.     preCheck();
  128.     try {
  129.       Bag nc = thys().adding(element);
  130.       checkAdd(nc, thys, element, false, false);
  131.       assert(thys.sameStructure(prev));
  132.       postCheck();
  133.       return nc;
  134.     }
  135.     catch (IllegalElementException ex) {
  136.       assert(!prev.canInclude(element));
  137.       assert(thys.sameStructure(prev));
  138.       postCheck();
  139.       throw ex;
  140.     }
  141.  
  142.   }
  143.  
  144. /**
  145.  * Checks collections.UpdatableBag.addElements
  146.  * @see collections.UpdatableBag#addElements
  147. **/
  148.  
  149.   public synchronized  void addElements(Enumeration e) 
  150.    throws IllegalElementException, CorruptedEnumerationException {
  151.     preCheck();
  152.     thys().addElements(e);
  153.     // can't check for elements because e is exhausted
  154.     postCheck();
  155.   }
  156.  
  157. /**
  158.  * Helper for checking add*
  159. **/
  160.  
  161.   protected void checkAdd(Collection nc, Collection oc,
  162.                           Object element, boolean ifAbsent,
  163.                           boolean verchk) {
  164.  
  165.     assert(nc.canInclude(element));
  166.  
  167.     int oOcc = oc.occurrencesOf(element);
  168.     int reqOcc = oOcc + 1;
  169.     if (ifAbsent && oOcc != 0) reqOcc = oOcc;
  170.  
  171.     int nOcc = nc.occurrencesOf(element);
  172.  
  173.     assert(nOcc == reqOcc);
  174.     assert(nc.size() == oc.size() + (reqOcc - oOcc));
  175.  
  176.     if (verchk) {
  177.       int nv = ((UpdatableCollection)nc).version();
  178.       assert((nv == prevVersion) == (nOcc == oOcc));
  179.     }
  180.  
  181.     // all other elements the same
  182.     CollectionEnumeration os = oc.elements();
  183.     while (os.hasMoreElements()) {
  184.       Object v = os.nextElement();
  185.       assert((v.equals(element) || 
  186.               (nc.occurrencesOf(v) == oc.occurrencesOf(v))));
  187.     }
  188.  
  189.     nc.checkImplementation();
  190.  
  191.   }
  192.  
  193. }
  194.  
  195.