engine.java

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

         gs.key = ds.key;
         gs.agent = context.whoami();
         gs.ignore_agents.addElement(ds.agent);

         double t = Double.MAX_VALUE;
         Goal g;
         for(int i = 0; i < gs.goal.size(); i++ ) {
            g = (Goal)gs.goal.elementAt(i);
            t = Math.min(t,g.getConfirmTime().getTime());
         }

         /* Timeout heuristic */
         gs.timeout = (t-context.now())/(gs.goal.size()+0.5);

         gs.any = new Integer(type);
         g2 graph = new g2();
         notifyGraphMonitors(graph,GRAPH_CREATE);
         graph.run(this,gs);
      }
      else if ( ds.msg_type.equals("cancel") ) {
         auditTable.cancel(ds);
      }
      else if ( ds.msg_type.equals("enact") ) {
         auditTable.enact(ds);
      }
      else {
         msgQueue.addElement(ds);
         msgWaitTable.wakeup(ds.key);
      }
   }


    //synchronized 
   public void addItemForSale(String sellers_key, Fact fact) {
      Core.ERROR(itemsForSale.put(sellers_key,fact) == null, 1, this);
   }
   
   
   //synchronized
   public  void removeItemForSale(String sellers_key) {
      itemsForSale.remove(sellers_key);
      keyTable.remove(sellers_key);
   }
   
   //synchronized 
   public String getBuyersKey(String sellers_key) {
      return (String)keyTable.get(sellers_key);
   }


   protected String waitingToSell(Fact fact) {
      Enumeration keys = itemsForSale.keys();
      String key;
      Fact f;
      Bindings b = new Bindings(context.whoami());
      while( keys.hasMoreElements() ) {
         b.clear();
         key = (String)keys.nextElement();
         f = (Fact)itemsForSale.get(key);
         if ( f.unifiesWith(fact,b) )
            return key;
      }
      return null;
   }


    //synchronized
   public synchronized void wakeup(String key) {
      msgWaitTable.wakeup(key);
   }


    //synchronized 
   public synchronized void replan(PlannerQueryStruct struct, String key) {
      GraphStruct gs = new GraphStruct();

      gs.goal = struct.goals;
      gs.internal = struct.internal;
      gs.external = struct.external;
      gs.agent = context.whoami();
      gs.key = key;

      Goal g;
      double t = Double.MAX_VALUE;
      for(int i = 0; i < gs.goal.size(); i++ ) {
         g = (Goal)gs.goal.elementAt(i);
         t = Math.min(t,g.getConfirmTime().getTime());
      }
      gs.timeout = (t-context.now())/(gs.goal.size()+0.5);
      g1 graph = new g1();
      notifyGraphMonitors(graph,GRAPH_CREATE);
      graph.run(this,gs);
   }
   
   //synchronized 
   public void agentWithAbilityFound(Performative msg) {
      String key = msg.getInReplyTo();
      String content = msg.getContent();
      if ( context.OrganisationDb() != null ) {
         Vector v = ZeusParser.abilityDbItemList(context.OntologyDb(),content);
         context.OrganisationDb().add(v);
         msgWaitTable.wakeup(key);
      }
   }
   
   // synchronized 
  synchronized void  waitForMsg(Node node) {
      msgWaitTable.add(node);
   }
   
   // synchronized
   public synchronized DelegationStruct replyReceived(String key) {
      DelegationStruct ds;
      for( int i = 0; i < msgQueue.size(); i++ ) {
         ds = (DelegationStruct)msgQueue.elementAt(i);
         if ( ds.key.equals(key) ) {
            msgQueue.removeElementAt(i--);
            return ds;
         }
      }
      return null;
   }
   
   //synchronized
   public synchronized DelegationStruct replyReceived(String key,
                                                      String type) {
      DelegationStruct ds;
      for( int i = 0; i < msgQueue.size(); i++ ) {
         ds = (DelegationStruct)msgQueue.elementAt(i);
         if ( ds.key.equals(key) && ds.msg_type.equals(type) ) {
            msgQueue.removeElementAt(i--);
            return ds;
         }
      }
      return null;
   }


    //synchronized 
   public synchronized void replaceReply(Vector replies) {
      if ( replies == null || replies.isEmpty() ) return;
      for(int i = 0; i < replies.size(); i++ )
         msgQueue.addElement(replies.elementAt(i));
   }


 //synchronized
   public Vector repliesReceived(String key) {
      Vector items = new Vector();
      DelegationStruct ds;
      for( int i = 0; i < msgQueue.size(); i++ ) {
         ds = (DelegationStruct)msgQueue.elementAt(i);
         if ( ds.key.equals(key) ) {
            items.addElement(ds);
            msgQueue.removeElementAt(i--);
         }
      }
      return items;
   }
   
   //synchronized
   public synchronized Vector repliesReceived(String key, String type) {
      Vector items = new Vector();
      DelegationStruct ds;
      for( int i = 0; i < msgQueue.size(); i++ ) {
         ds = (DelegationStruct)msgQueue.elementAt(i);
         if ( ds.key.equals(key) && ds.msg_type.equals(type) ) {
            items.addElement(ds);
            msgQueue.removeElementAt(i--);
         }
      }
      return items;
   }

   // ---- Event Monitoring ----
   public void addConversationMonitor(ConversationMonitor monitor,
                                      long event_mask) {
      if ( (event_mask & ConversationEvent.INITIATE_MASK) != 0 )
         conversationMonitors[INITATE_CONVERSATION].add(monitor);
      if ( (event_mask & ConversationEvent.CONTINUE_MASK) != 0 )
         conversationMonitors[CONTINUE_CONVERSATION].add(monitor);
   }
   public void removeConversationMonitor(ConversationMonitor monitor, 
                                         long event_mask) {
      if ( (event_mask & ConversationEvent.INITIATE_MASK) != 0 )
         conversationMonitors[INITATE_CONVERSATION].remove(monitor);
      if ( (event_mask & ConversationEvent.CONTINUE_MASK) != 0 )
         conversationMonitors[CONTINUE_CONVERSATION].remove(monitor);
   }

   public void addNodeMonitor(NodeMonitor monitor, long event_mask) {
      if ( (event_mask & NodeEvent.CREATE_MASK) != 0 )
         nodeMonitors[NODE_CREATE].add(monitor);
      if ( (event_mask & NodeEvent.STATE_CHANGE_MASK) != 0 )
         nodeMonitors[NODE_STATE_CHANGE].add(monitor);
      if ( (event_mask & NodeEvent.DISPOSE_MASK) != 0 )
         nodeMonitors[NODE_DISPOSE].add(monitor);
   }
   public void removeNodeMonitor(NodeMonitor monitor, long event_mask) {
      if ( (event_mask & NodeEvent.CREATE_MASK) != 0 )
         nodeMonitors[NODE_CREATE].remove(monitor);
      if ( (event_mask & NodeEvent.STATE_CHANGE_MASK) != 0 )
         nodeMonitors[NODE_STATE_CHANGE].remove(monitor);
      if ( (event_mask & NodeEvent.DISPOSE_MASK) != 0 )
         nodeMonitors[NODE_DISPOSE].remove(monitor);
   }

   public void addGraphMonitor(GraphMonitor monitor, long event_mask) {
      if ( (event_mask & GraphEvent.CREATE_MASK) != 0 )
         graphMonitors[GRAPH_CREATE].add(monitor);
      if ( (event_mask & GraphEvent.STATE_CHANGE_MASK) != 0 )
         graphMonitors[GRAPH_STATE_CHANGE].add(monitor);
      if ( (event_mask & GraphEvent.DISPOSE_MASK) != 0 )
         graphMonitors[GRAPH_DISPOSE].add(monitor);
   }
   public void removeGraphMonitor(GraphMonitor monitor, long event_mask) {
      if ( (event_mask & GraphEvent.CREATE_MASK) != 0 )
         graphMonitors[GRAPH_CREATE].remove(monitor);
      if ( (event_mask & GraphEvent.STATE_CHANGE_MASK) != 0 )
         graphMonitors[GRAPH_STATE_CHANGE].remove(monitor);
      if ( (event_mask & GraphEvent.DISPOSE_MASK) != 0 )
         graphMonitors[GRAPH_DISPOSE].remove(monitor);
   }

   public void addArcMonitor(ArcMonitor monitor, long event_mask) {
      if ( (event_mask & ArcEvent.CREATE_MASK) != 0 )
         arcMonitors[ARC_CREATE].add(monitor);
      if ( (event_mask & ArcEvent.SUCCEED_MASK) != 0 )
         arcMonitors[ARC_SUCCEED].add(monitor);
      if ( (event_mask & ArcEvent.FAIL_MASK) != 0 )
         arcMonitors[ARC_FAIL].add(monitor);
      if ( (event_mask & ArcEvent.DISPOSE_MASK) != 0 )
         arcMonitors[ARC_DISPOSE].add(monitor);
   }
   public void removeArcMonitor(ArcMonitor monitor, long event_mask) {
      if ( (event_mask & ArcEvent.CREATE_MASK) != 0 )
         arcMonitors[ARC_CREATE].remove(monitor);
      if ( (event_mask & ArcEvent.SUCCEED_MASK) != 0 )
         arcMonitors[ARC_SUCCEED].remove(monitor);
      if ( (event_mask & ArcEvent.FAIL_MASK) != 0 )
         arcMonitors[ARC_FAIL].remove(monitor);
      if ( (event_mask & ArcEvent.DISPOSE_MASK) != 0 )
         arcMonitors[ARC_DISPOSE].remove(monitor);
   }

   void notifyConversationMonitors(String comms_key, String sender, 
                                   String receiver, String msg_type, 
			           Vector data, int type) {
      if ( conversationMonitors[type].isEmpty() ) return;

      ConversationMonitor monitor;
      ConversationEvent event;
      Enumeration enum = conversationMonitors[type].elements();

      switch(type) {
         case INITATE_CONVERSATION:
              event = new ConversationEvent(this,this,comms_key,sender, 
                                            receiver,msg_type,data,
                                            ConversationEvent.INITIATE_MASK);
              while( enum.hasMoreElements() ) {
                 monitor = (ConversationMonitor)enum.nextElement();
                 monitor.conversationInitiatedEvent(event);
              }
              break;
         case CONTINUE_CONVERSATION:
              event = new ConversationEvent(this,this,comms_key,sender, 
                                            receiver,msg_type,data,
                                            ConversationEvent.CONTINUE_MASK);
              while( enum.hasMoreElements() ) {
                 monitor = (ConversationMonitor)enum.nextElement();
                 monitor.conversationContinuedEvent(event);
              }
              break;
      }
   }

   void notifyConversationMonitors(String comms_key, String sender, 
                                   String receiver, String msg_type, 
			           String data_type, String data_key,
                                   Vector data, int type) {
      if ( conversationMonitors[type].isEmpty() ) return;

      ConversationMonitor monitor;
      ConversationEvent event;
      Enumeration enum = conversationMonitors[type].elements();

      switch(type) {
         case INITATE_CONVERSATION:
              event = new ConversationEvent(this,this,comms_key,sender, 
                                            receiver,msg_type,
                                            data_type, data_key, data,
                                            ConversationEvent.INITIATE_MASK);
              while( enum.hasMoreElements() ) {
                 monitor = (ConversationMonitor)enum.nextElement();
                 monitor.conversationInitiatedEvent(event);
              }
              break;
         case CONTINUE_CONVERSATION:
              event = new ConversationEvent(this,this,comms_key,sender, 
                                            receiver,msg_type,
                                            data_type, data_key, data,
                                            ConversationEvent.CONTINUE_MASK);
              while( enum.hasMoreElements() ) {
                 monitor = (ConversationMonitor)enum.nextElement();
                 monitor.conversationContinuedEvent(event);
              }
              break;
      }
   }

   void notifyNodeMonitors(Node node, int type) {
      if ( nodeMonitors[type].isEmpty() ) return;

      NodeMonitor monitor;
      NodeEvent event;
      Enumeration enum = nodeMonitors[type].elements();

      switch(type) {
         case NODE_CREATE:
              event = new NodeEvent(this,node,NodeEvent.CREATE_MASK);
              while( enum.hasMoreElements() ) {
                 monitor = (NodeMonitor)enum.nextElement();
                 monitor.nodeCreatedEvent(event);
              }
              break;
         case NODE_DISPOSE:
              event = new NodeEvent(this,node,NodeEvent.DISPOSE_MASK);
              while( enum.hasMoreElements() ) {
                 monitor = (NodeMonitor)enum.nextElement();
                 monitor.nodeDisposedEvent(event);
              }
              break;
         case NODE_STATE_CHANGE:
              event = new NodeEvent(this,node,NodeEvent.STATE_CHANGE_MASK);
              while( enum.hasMoreElements() ) {
                 monitor = (NodeMonitor)enum.nextElement();
                 monitor.nodeStateChangedEvent(event);
              }
              break;
      }
   }

   void notifyGraphMonitors(Graph graph, int type) {
      if ( graphMonitors[type].isEmpty() ) return;

      GraphMonitor monitor;
      GraphEvent event;
      Enumeration enum = graphMonitors[type].elements();

      switch(type) {
         case GRAPH_CREATE:
              event = new GraphEvent(this,graph,GraphEvent.CREATE_MASK);
              while( enum.hasMoreElements() ) {
                 monitor = (GraphMonitor)enum.nextElement();
                 monitor.graphCreatedEvent(event);
              }
              break;
         case GRAPH_DISPOSE:
              event = new GraphEvent(this,graph,GraphEvent.DISPOSE_MASK);
              while( enum.hasMoreElements() ) {
                 monitor = (GraphMonitor)enum.nextElement();
                 monitor.graphDisposedEvent(event);
              }
              break;
         case GRAPH_STATE_CHANGE:
              event = new GraphEvent(this,graph,GraphEvent.STATE_CHANGE_MASK);
              while( enum.hasMoreElements() ) {
                 monitor = (GraphMonitor)enum.nextElement();
                 monitor.graphStateChangedEvent(event);
              }
              break;
      }
   }

   void notifyArcMonitors(Arc arc, Node node, int type) {
      if ( arcMonitors[type].isEmpty() ) return;

      ArcMonitor monitor;
      ArcEvent event;
      Enumeration enum = arcMonitors[type].elements();

      switch(type) {
         case ARC_CREATE:
              event = new ArcEvent(this,arc,node,ArcEvent.CREATE_MASK);
              while( enum.hasMoreElements() ) {
                 monitor = (ArcMonitor)enum.nextElement();
                 monitor.arcCreatedEvent(event);
              }
              break;
         case ARC_DISPOSE:
              event = new ArcEvent(this,arc,node,ArcEvent.DISPOSE_MASK);
              while( enum.hasMoreElements() ) {
                 monitor = (ArcMonitor)enum.nextElement();
                 monitor.arcDisposedEvent(event);
              }
              break;
         case ARC_SUCCEED:
              event = new ArcEvent(this,arc,node,ArcEvent.SUCCEED_MASK);
              while( enum.hasMoreElements() ) {
                 monitor = (ArcMonitor)enum.nextElement();
                 monitor.arcSucceededEvent(event);
              }
              break;
         case ARC_FAIL:
              event = new ArcEvent(this,arc,node,ArcEvent.FAIL_MASK);
              while( enum.hasMoreElements() ) {
                 monitor = (ArcMonitor)enum.nextElement();
                 monitor.arcFailedEvent(event);
              }
              break;
      }
   }
}