symbol_set.java

package java_cup ;


import java.util.Enumeration ;
import java.util.Hashtable ;


/**
 * This class represents a set of symbols and provides a series of set
 * operations to manipulate them.
 * 
 * @see java_cup.symbol
 * @version last updated: 11/25/95
 * @author Scott Hudson
 */
public class symbol_set
{
  /*-----------------------------------------------------------*/
  /*--- Constructor(s) ----------------------------------------*/
  /*-----------------------------------------------------------*/
  /** Constructor for an empty set. */
  public symbol_set ( )
  {
  }


  /**
   * Constructor for cloning from another set.
   * 
   * @param other the set we are cloning from.
   */
  public symbol_set ( symbol_set other ) throws internal_error
  {
    not_null ( other ) ;
    _all = ( Hashtable ) other._all.clone ( ) ;
  }


  /*-----------------------------------------------------------*/
  /*--- (Access to) Instance Variables ------------------------*/
  /*-----------------------------------------------------------*/
  /**
   * A hash table to hold the set. Symbols are keyed using their name string.
   */
  protected Hashtable _all = new Hashtable ( 11 ) ;


  /** Access to all elements of the set. */
  public Enumeration all ( )
  {
    return _all.elements ( ) ;
  }


  /** size of the set */
  public int size ( )
  {
    return _all.size ( ) ;
  }


  /*-----------------------------------------------------------*/
  /*--- (Access to) Instance Variables ------------------------*/
  /*-----------------------------------------------------------*/
  /**
   * Helper function to test for a null object and throw an exception if one is
   * found.
   * 
   * @param obj the object we are testing.
   */
  protected void not_null ( Object obj ) throws internal_error
  {
    if ( obj == null )
      throw new internal_error ( "Null object used in set operation" ) ;
  }


  /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
  /**
   * Determine if the set contains a particular symbol.
   * 
   * @param sym the symbol we are looking for.
   */
  public boolean contains ( symbol sym )
  {
    return _all.containsKey ( sym.name ( ) ) ;
  }


  /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
  /**
   * Determine if this set is an (improper) subset of another.
   * 
   * @param other the set we are testing against.
   */
  public boolean is_subset_of ( symbol_set other ) throws internal_error
  {
    not_null ( other ) ;
    /* walk down our set and make sure every element is in the other */
    for ( Enumeration e = all ( ) ; e.hasMoreElements ( ) ; )
      if ( ! other.contains ( ( symbol ) e.nextElement ( ) ) ) return false ;
    /* they were all there */
    return true ;
  }


  /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
  /**
   * Determine if this set is an (improper) superset of another.
   * 
   * @param other the set we are are testing against.
   */
  public boolean is_superset_of ( symbol_set other ) throws internal_error
  {
    not_null ( other ) ;
    return other.is_subset_of ( this ) ;
  }


  /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
  /**
   * Add a single symbol to the set.
   * 
   * @param sym the symbol we are adding.
   * @return true if this changes the set.
   */
  public boolean add ( symbol sym ) throws internal_error
  {
    Object previous ;
    not_null ( sym ) ;
    /* put the object in */
    previous = _all.put ( sym.name ( ) , sym ) ;
    /* if we had a previous, this is no change */
    return previous == null ;
  }


  /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
  /**
   * Remove a single symbol if it is in the set.
   * 
   * @param sym the symbol we are removing.
   */
  public void remove ( symbol sym ) throws internal_error
  {
    not_null ( sym ) ;
    _all.remove ( sym.name ( ) ) ;
  }


  /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
  /**
   * Add (union) in a complete set.
   * 
   * @param other the set we are adding in.
   * @return true if this changes the set.
   */
  public boolean add ( symbol_set other ) throws internal_error
  {
    boolean result = false ;
    not_null ( other ) ;
    /* walk down the other set and do the adds individually */
    for ( Enumeration e = other.all ( ) ; e.hasMoreElements ( ) ; )
      result = add ( ( symbol ) e.nextElement ( ) ) || result ;
    return result ;
  }


  /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
  /**
   * Remove (set subtract) a complete set.
   * 
   * @param other the set we are removing.
   */
  public void remove ( symbol_set other ) throws internal_error
  {
    not_null ( other ) ;
    /* walk down the other set and do the removes individually */
    for ( Enumeration e = other.all ( ) ; e.hasMoreElements ( ) ; )
      remove ( ( symbol ) e.nextElement ( ) ) ;
  }


  /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
  /** Equality comparison. */
  public boolean equals ( symbol_set other )
  {
    if ( other == null || other.size ( ) != size ( ) ) return false ;
    /* once we know they are the same size, then improper subset does test */
    try
    {
      return is_subset_of ( other ) ;
    }
    catch ( internal_error e )
    {
      /* can't throw the error (because super class doesn't), so we crash */
      e.crash ( ) ;
      return false ;
    }
  }


  /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
  /** Generic equality comparison. */
  public boolean equals ( Object other )
  {
    if ( ! ( other instanceof symbol_set ) )
      return false ;
    else return equals ( ( symbol_set ) other ) ;
  }


  /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
  /** Compute a hash code. */
  public int hashCode ( )
  {
    int result = 0 ;
    int cnt ;
    Enumeration e ;
    /* hash together codes from at most first 5 elements */
    for ( e = all ( ) , cnt = 0 ; e.hasMoreElements ( ) && cnt < 5 ; cnt ++ )
      result ^= ( ( symbol ) e.nextElement ( ) ).hashCode ( ) ;
    return result ;
  }


  /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
  /** Convert to a string. */
  public String toString ( )
  {
    String result ;
    boolean comma_flag ;
    result = "{" ;
    comma_flag = false ;
    for ( Enumeration e = all ( ) ; e.hasMoreElements ( ) ; )
    {
      if ( comma_flag )
        result += ", " ;
      else comma_flag = true ;
      result += ( ( symbol ) e.nextElement ( ) ).name ( ) ;
    }
    result += "}" ;
    return result ;
  }
  /*-----------------------------------------------------------*/
}