pgraph.java

人工智能中Agent开发包。多 Agent 系统是处理自治 Agent 之间知识层的协作问题

/*
* The contents of this file are subject to the BT "ZEUS" Open Source 
* Licence (L77741), Version 1.0 (the "Licence"); you may not use this file 
* except in compliance with the Licence. You may obtain a copy of the Licence
* from $ZEUS_INSTALL/licence.html or alternatively from
* http://www.labs.bt.com/projects/agents/zeus/licence.htm
* 
* Except as stated in Clause 7 of the Licence, software distributed under the
* Licence is distributed WITHOUT WARRANTY OF ANY KIND, either express or 
* implied. See the Licence for the specific language governing rights and 
* limitations under the Licence.
* 
* The Original Code is within the package zeus.*.
* The Initial Developer of the Original Code is British Telecommunications
* public limited company, whose registered office is at 81 Newgate Street, 
* London, EC1A 7AJ, England. Portions created by British Telecommunications 
* public limited company are Copyright 1996-9. All Rights Reserved.
* 
* THIS NOTICE MUST BE INCLUDED ON ANY COPY OF THIS FILE
*/



package zeus.actors.rtn;

import java.util.*;
import zeus.util.*;

public class PGraph extends Graph {
   protected Vector  done_nodes = new Vector();
   protected Vector  failed_nodes = new Vector();
   protected Node[]  start_nodes = null;
   protected boolean first = true;
   protected int     min_done = -1;
   protected int     max_fail = 0;

   public PGraph(String description, String[][] nodes, String start_node) {
      super(description,nodes,start_node);
   }
   public PGraph(String description, String[][] nodes, String start_node,
                 int min_done) {
      super(description,nodes,start_node);
      this.min_done = min_done;
   }
   protected void start(Engine engine, Object input) {
      state = RUNNING;
      Object[] local_input = (Object[]) input;
      start_nodes = new Node[local_input.length];
      if ( min_done != -1 )
         max_fail = local_input.length - min_done;

      for(int i = 0; i < local_input.length; i++ ) {
         start_nodes[i] = newNode(engine,start_node,previous_node);
         if ( start_nodes[i] == null ) {
            fail(engine,"Start node not found");
            return;
         }
      }
      for(int i = 0; i < local_input.length; i++ ) {
         start_nodes[i].setInput(engine,local_input[i]);
         engine.add(start_nodes[i]);
      }
   }
   void done(Engine engine, Node node) {
      done_nodes.addElement(node);
      Core.DEBUG(3,description + " no: " + done_nodes.size() + " done");
      if ( done_nodes.size() + failed_nodes.size() == start_nodes.length )
         doSucceed(engine);
   }

   protected void doSucceed(Engine engine) {
      setState(engine,DONE);
      if ( graph != null ) {
	 Node next = graph.newNode(engine,next_node,previous_node,getTerminalNodes());
         if ( next == null ) {
            fail(engine,"next_node - " + next_node + " - not found");
            return;
         }
         Object[] local_input = new Object[done_nodes.size()];
         for(int i = 0; i < done_nodes.size(); i++ )
            local_input[i] = ((Node)done_nodes.elementAt(i)).getOutput();
         next.setInput(engine,local_input);
         engine.add(next);
      }
      else if ( node_wakeup_key != null )
         engine.wakeup(node_wakeup_key);
   }

   void failed(Engine engine, Node node) {
      if ( state != FAILED ) {
         for(int i = 0; i < start_nodes.length; i++ ) {
            if ( start_nodes[i] == node ) {
               failed_nodes.addElement(node);
               if ( failed_nodes.size() > max_fail )
	          setState(engine,FAILED);
               break;
            }
         }
         if ( state == FAILED ) {
            for(int i = 0; i < done_nodes.size(); i++ )
               ((Node)done_nodes.elementAt(i)).fail(engine,true,"Parallel branch failed");
         }
      }
      else {
         for(int i = 0; i < start_nodes.length; i++ ) {
            if ( start_nodes[i] == node ) {
               failed_nodes.addElement(node);
               break;
            }
         }
      }
      if ( first && failed_nodes.size() == start_nodes.length ) {
         first = false;
         fail(engine,"Parallel graph failed");
      }
      else if ( failed_nodes.size() + done_nodes.size() == start_nodes.length )
         doSucceed(engine);
   }
   Node newNode(Engine engine, String name, Node previous) {
      if ( state == FAILED ) return null;
      else return super.newNode(engine,name,previous);
   }

   Vector getTerminalNodes() {
      Vector out = new Vector();
      Node node;
      Vector local;

      Core.DEBUG(3,"PGraph: getTerminalNodes for: " + description);
      for(int i = 0; i < done_nodes.size(); i++ ) {
         node = (Node)done_nodes.elementAt(i);
         Core.DEBUG(3,"\tConsidering done_node: " + node);
         if ( (local = node.getParentsOfNextNode()) != null )
 	    out = Misc.union(out,local);
         else
            out.addElement(node);
         Core.DEBUG(3,"\tCurrent terminals: " + out);
      }
      for(int i = 0; i < failed_nodes.size(); i++ ) {
         node = (Node)failed_nodes.elementAt(i);
         Core.DEBUG(3,"\tConsidering failed_node: " + node);
         if ( (local = node.getParentsOfNextNode()) != null )
 	    out = Misc.union(out,local);
         else
            out.addElement(node);
         Core.DEBUG(3,"\tCurrent terminals: " + out);
      }
      Core.DEBUG(3,"\tFinal terminals: " + out);
      return out;
   }
   boolean allow_backtrack(Node node) {
      for(int i = 0; i < start_nodes.length; i++ )
         if ( start_nodes[i] == node )
            return false;
      return true;
   }
}