package aima.logic;
/**
 * The Variable class provides a class of objects to represent variables
 * inside expressions that are to be unified.
 *
 * @author Michael S. Braverman
 * @see Unify
 */
public class Variable {
  /**
   * Creates a new variable with the given name.  The implementation
   * guarantees that two variables created with the same name will
   * be equal according to the <code>equals</code> predicate.
   *
   * @param baseName the name to give the variable.
   * @see #equals
   */
  public Variable(String baseName) {
    name  = baseName;
    count = 0;
  }

  /** 
   * Creates a new variable based on the name of the given existing
   * variable, but which is not equal to that variable in any way.
   * This constructor method is useful in renaming variables inside
   * expressions, where you want the resulting renamed expression to
   * contain similar looking variables that are actually unique from
   * the variables in the original expression.
   *
   * @param oldVar the variable whose name is to be used as a basis
   * for the name of the newly created <code>Variable</code>.
   */
  public Variable(Variable oldVar) {
    name  = oldVar.name;
    count = newVariableCounter++;
  }

  /** 
   * Calculates hashCode of this <code>Variable</code>.
   * Needed so that one can successfully hash a <code>Variable</code> object
   * in a <code>java.util.Hashtable</code>
   *
   * @return The hash code.
   * @see java.util.Hashtable
   */
  public int hashCode() {
     return (int) (count+name.hashCode());
  }

  /** 
   * Determine if this <code>Variable</code> object is equal to the
   * <code>other</code> passed Object. 
   *
   * <p>
   * Note: the signature of the passed parameter is in terms of an 
   * <code>Object</code> as opposed to simply a <code>Variable</code>
   * because we want this method to match the signature of the 
   * <code>equals</code> predicate in used to <code>put</code> and 
   * <code>get</code> entries in a <code>java.util.Hashtable</code>.
   * 
   * @return If <code>other</code> is equal to this <code>Variable</code>.
   * @param other The <code>Object</code> to compare with.
   * @see java.util.Hashtable
   */
  public boolean equals(Object other) {
    if (this == other) {
      return true;
    } else if (other instanceof Variable) {
      Variable otherVar = (Variable) other;
      return ((count==otherVar.count) && name.equals(otherVar.name));
    } else {
      return false;
    }
  }

  /** 
   * Return the prefix character that should be used in the printed
   * representation of all <code>Variable</code> objects and is used
   * on input to flag an atom as one that should be converted to a
   * <code> Variable </code> object.
   *
   * @return The prefix character denoting a <code>Variable</code>.
   */
  final static public char getPrefix() {
    return prefix;
  }


  /** 
   * Creates a <code>String</code> representation of this 
   * <code>Variable</code>.
   *
   * @return The <code>String</code> representation of this 
   * <code>Variable</code>.
   */
  public String toString() {
    if (count != 0) 
      return prefix + name + "." + count;
    else 
      return prefix + name;
  }

  /**
   * The <code>Variable</code> name.
   */
  private String name;

  /**
   * A unique number to distinguish two <code>Variable</code>s that
   * may have the same name.
   *
   * @see #name
   */
  private long   count;

  /**
   * A counter to generate unique identity counts.
   *
   * @see #equals
   */
  private static long newVariableCounter = 1;

  /**
   * The character prefix used to denote a variable.
   *
   * @see getPrefix()
   */
  final private static char prefix = '?';
}