Robust/src/Util/UtilAlgorithms.java

   1 package Util;
   2 import java.util.*;
   3
   4 // this class has static methods that implement useful,
   5 // non-trivially algorithms to prevent code duplication
   6 // and reduce bugs
   7
   8 public class UtilAlgorithms {
   9
  10   // This method merge hashtable b into a, where the
  11   // tables both have HashSets as the values.  If both
  12   // tables have a common key, the new value is the
  13   // union of the sets the key mapped to in each one.
  14   // Note: the reason it must be a HashSet instead of
  15   // a Set is that we want to clone sets of table b, so
  16   // only a is modified.  Set does not provide clone().
  17   static public void mergeHashtablesWithHashSetValues( Hashtable a,
  18                                                        Hashtable b ) {
  19     Iterator itr = b.entrySet().iterator();
  20     while( itr.hasNext() ) {
  21       Map.Entry me  = (Map.Entry) itr.next();
  22       Object    key = (Object)    me.getKey();
  23       HashSet   s1  = (HashSet)   me.getValue();
  24       HashSet   s2  = (HashSet)   a.get( key );
  25
  26       if( s2 == null ) {
  27         a.put( key, s1.clone() );
  28       } else {
  29         s2.addAll( s1 );
  30       }
  31     }
  32   }
  33
  34
  35   // This method makes hashtable a the intersection of
  36   // itself and hashtable b, where the new key set is the
  37   // intersection.  The values are sets, so if a key is
  38   // common its new value should be the intersection of
  39   // the existing values in a and b.  If a new value is
  40   // the empty set, then also remove that key.
  41   static public void intersectHashtablesWithSetValues( Hashtable a,
  42                                                        Hashtable b ) {
  43     Set keysToRemove = new HashSet();
  44
  45     Iterator mapItr = a.entrySet().iterator();
  46     while( mapItr.hasNext() ) {
  47       Map.Entry me    = (Map.Entry) mapItr.next();
  48       Object    akey  = (Object)    me.getKey();
  49       Set       avals = (Set)       me.getValue();
  50       Set       bvals = (Set)       b.get( akey );
  51
  52       if( bvals == null ) {
  53         // if b doesn't have the key, mark it for
  54         // safe removal after we traverse the map
  55         keysToRemove.add( akey );
  56
  57       } else {
  58         // otherwise we have the key, but pare
  59         // down the value set, if needed, and if
  60         // nothing is left, remove the key, too
  61         avals.retainAll( bvals );
  62         if( avals.isEmpty() ) {
  63           keysToRemove.add( akey );
  64         }
  65       }
  66     }
  67
  68     // then safely remove keys
  69     Iterator keyItr = keysToRemove.iterator();
  70     while( keyItr.hasNext() ) {
  71       Object key = keyItr.next();
  72       a.remove( key );
  73     }
  74   }
  75
  76 }