home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / applets / collectn / llpair.jav < prev    next >
Encoding:
Text File  |  1995-12-14  |  3.3 KB  |  139 lines
  1. /*
  2.   File: LLPair.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.  
  12. */
  13.   
  14. package collections;
  15.  
  16. import java.util.Enumeration;
  17. import java.util.NoSuchElementException;
  18.  
  19. /**
  20.  *
  21.  *
  22.  * LLPairs are LLCells with keys, and operations that deal with them.
  23.  * As with LLCells, the are pure implementation tools.
  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 class LLPair extends LLCell implements Pair {
  31.  
  32. // instance variables
  33.  
  34.   private Object   key_;
  35.  
  36. /**
  37.  * Make a cell with given key, elment, and next link
  38. **/
  39.  
  40.   public LLPair(Object k, Object v, LLPair n) { super(v, n); key_ = k; }
  41.  
  42. /**
  43.  * Make a pair with given key and element, and null next link
  44. **/
  45.  
  46.   public LLPair(Object k, Object v)           { super(v, null); key_ = k; }
  47.  
  48. /**
  49.  * Make a pair with null key, elment, and next link
  50. **/
  51.  
  52.   public LLPair()                             { super(null, null); key_ = null;}
  53.  
  54. /**
  55.  * return the key
  56. **/
  57.  
  58.   public final Object key()           { return key_; }
  59.  
  60. /**
  61.  * set the key
  62. **/
  63.  
  64.   public final void   key(Object k)   { key_ = k; }
  65.  
  66.  
  67. /**
  68.  * return a cell with key() key or null if no such
  69. **/
  70.  
  71.   public final LLPair findKey(Object key) {
  72.     for (LLPair p = this; p != null; p = (LLPair)(p.next()))
  73.       if (p.key().equals(key)) return p;
  74.     return null;
  75.   }
  76.  
  77. /**
  78.  * return a cell holding the indicated pair or null if no such
  79. **/
  80.  
  81.   public final LLPair find(Object key, Object element) {
  82.     for (LLPair p = this; p != null; p = (LLPair)(p.next()))
  83.       if (p.key().equals(key) && p.element().equals(element)) return p;
  84.     return null;
  85.   }
  86.  
  87. /**
  88.  * Return the number of cells traversed to find a cell with key() key,
  89.  * or -1 if not present
  90. **/
  91.  
  92.   public final int indexKey(Object key) {
  93.     int i = 0;
  94.     for (LLPair p = this; p != null; p = (LLPair)(p.next())) {
  95.       if (p.key().equals(key)) return i;
  96.       else ++i;
  97.     }
  98.     return -1;
  99.   }
  100.  
  101. /**
  102.  * Return the number of cells traversed to find a cell with indicated pair
  103.  * or -1 if not present
  104. **/
  105.   public final int index(Object key, Object element) {
  106.     int i = 0;
  107.     for (LLPair p = this; p != null; p = (LLPair)(p.next())) {
  108.       if (p.key().equals(key) && p.element().equals(element)) return i;
  109.       else ++i;
  110.     }
  111.     return -1;
  112.   }
  113.  
  114. /**
  115.  * Return the number of cells with key() key.
  116. **/
  117.   public final int countKey(Object key) {
  118.     int c = 0;
  119.     for (LLPair p = this; p != null; p = (LLPair)(p.next())) 
  120.       if (p.key().equals(key)) ++c;
  121.     return c;
  122.   }
  123.  
  124. /**
  125.  * Return the number of cells with indicated pair
  126. **/
  127.   public final int count(Object key, Object element) {
  128.     int c = 0;
  129.     for (LLPair p = this; p != null; p = (LLPair)(p.next())) 
  130.       if (p.key().equals(key) && p.element().equals(element)) ++c;
  131.     return c;
  132.   }
  133.  
  134.   protected Object clone()  throws CloneNotSupportedException { 
  135.     return new LLPair(key(), element(), (LLPair)(next())); 
  136.   }
  137.  
  138. }
  139.