operator.java

SHOP2 一个人工智能里面关于任务分解和任务规划的系统。JSHOP2是其java版本。

package JSHOP2;

import java.util.Vector;

/** Each operator at run time is represented as a class derived from this
 *  abstract class.
 *
 *  @author Okhtay Ilghami
 *  @author <a href="http://www.cs.umd.edu/~okhtay">http://www.cs.umd.edu/~okhtay</a>
 *  @version 1.0.3
*/
public abstract class Operator extends DomainElement
{
  /** Represents the add list in case it is a real list and not a variable.
  */
  private DelAddElement[] add;

  /** Represents the add list in case it is a variable (The integer value
   *  represents variable's index), otherwise it is -1.
  */
  private int addVarIdx;

  /** Cost of this operator.
  */
  private Term cost;

  /** Represents the delete list in case it is a real list and not a variable.
  */
  private DelAddElement[] del;

  /** Represents the delete list in case it is a variable (The integer value
   *  represents variable's index), otherwise it is -1.
  */
  private int delVarIdx;

  /** To initialize the operator.
   *
   *  @param head
   *          head of the operator.
   *  @param delVarIdxIn
   *          the index of the delete list as a variable, -1 if the delete list
   *          is not a variable.
   *  @param addVarIdxIn
   *          the index of the add list as a variable, -1 if the add list is
   *          not a variable.
   *  @param costIn
   *          the cost of the operator.
  */
  public Operator(Predicate head, int delVarIdxIn, int addVarIdxIn,
                  Term costIn)
  {
    super(head);

    delVarIdx = delVarIdxIn;
    addVarIdx = addVarIdxIn;
    cost = costIn;
  }

  /** This function is used to apply this operator to a given state.
   *
   *  @param binding
   *          the current binding.
   *  @param s
   *          current state of the world.
   *  @param delAdd
   *          a 4-member array of type <code>Vector</code> used to keep track
   *          of the atoms and protections deleted from and added to the
   *          current state of the world as the result of applying this
   *          operator. This data can be used later in case of a backtrack to
   *          undo these changes.
   *  @return
   *          <code>true</code> if the operator was applicable,
   *          <code>false</code> otherwise. An operator is not applicable when
   *          at least one of the atoms it tries to delete is protected.
  */
  public boolean apply(Term[] binding, State s, Vector[] delAdd)
  {
    //-- Initialze the 'delAdd' array.
    delAdd[0] = new Vector();
    delAdd[1] = new Vector();
    delAdd[2] = new Vector();
    delAdd[3] = new Vector();

    //-- If the delete list is a variable,
    if (delVarIdx != -1)
    {
      //-- Find what that variable is bound to.
      List l = ((TermList)binding[delVarIdx]).getList();

      //-- Iterate over the elements of the delete list.
      while (l != null)
      {
        //-- Each element of the list should be a Predicate. Make that
        //-- Predicate.
        Predicate p = ((TermList)l.getHead()).toPredicate(0);

        //-- If this atom is protected in the current state of the world, it
        //-- can not be deleted, and therefore this operator can not be
        //-- applied. Therefore, return false.
        if (s.isProtected(p))
          return false;

        //-- To store the index of the deleted atom.
        int index;

        //-- Try to delete the atom from the current state of the world.
        if ((index = s.del(p)) != -1)
          //-- If the atom was really deleted from the current state of the
          //-- world (i.e., it was there before), add it to the list of deleted
          //-- atoms so that in case of a backtrack it can be added back. Also
          //-- keep track of where the atom was, so that it can be added back
          //-- exactly where it was. This is important because new bindings are
          //-- calculated as they are needed (as opposed to calculating all of
          //-- them in advance and returning them one-by-one), and therefore if a
          //-- backtrack happens, the data strucutures should look exactly as
          //-- they were before the backtracked decision to apply this operator
          //-- was made.
          delAdd[0].add(new NumberedPredicate(p, index));

        l = l.getRest();
      }
    }
    //-- If the delete list is a real list,
    else
    {
      //-- For each delete/add element in the delete list,
      for (int i = 0; i < del.length; i++)
        //-- Try to delete the atom from the current state of the world.
        if (!del[i].del(s, binding, delAdd))
          //-- If the atom can not be deleted (i.e., it is protected), return
          //-- false because this operator can not be applied.
          return false;
    }

    //-- If the add list is a variable,
    if (addVarIdx != -1)
    {
      //-- Find what that variable is bound to.
      List l = ((TermList)binding[addVarIdx]).getList();

      //-- Iterate over the elements of the add list.
      while (l != null)
      {
        //-- Each element of the list should be a Predicate. Make that
        //-- Predicate.
        Predicate p = ((TermList)l.getHead()).toPredicate(0);

        //-- Try to add the resulting (presumably ground) atom to the current
        //-- state of the world.
        if (s.add(p))
          //-- If the atom was really added to the current state of the world
          //-- (i.e., it wasn't there before), add it to the list of the added
          //-- atoms so that in case of a backtrack it can be retracted.
          delAdd[1].add(p);

        l = l.getRest();
      }
    }
    //-- If the add list is a real list,
    else
    {
      //-- For each delete/add element in the add list,
      for (int i = 0; i < add.length; i++)
        //-- Add it to the current state of the world.
        add[i].add(s, binding, delAdd);
    }

    return true;
  }

  /** To get the cost of this operator.
   *
   *  @param binding
   *          the binding to be applied to the cost term.
   *  @return
   *          the cost of applying this operator.
  */
  public double getCost(Term[] binding)
  {
    return ((TermNumber)cost.bind(binding)).getNumber();
  }

  /** To set the add list.
   *
   *  @param addIn
   *          the add list.
  */
  public void setAdd(DelAddElement[] addIn)
  {
    add = addIn;
  }

  /** To set the delete list.
   *
   *  @param delIn
   *          the delete list.
  */
  public void setDel(DelAddElement[] delIn)
  {
    del = delIn;
  }
}