generationplan.java

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

     fireChanged();
  }


  public synchronized void createVisualiser() {
     VisualiserInfo info = new VisualiserInfo(getOntologyFilename());
     visualiserTable.put(info.id,info);
     fireChanged();
  }


  public synchronized DbProxyInfo[] getDbProxys() {
     DbProxyInfo[] out = new DbProxyInfo[dbProxyTable.size()];
     Enumeration enum = dbProxyTable.elements();
     for(int i = 0; i < out.length; i++ )
        out[i] = (DbProxyInfo)enum.nextElement();
     return out;
  }


  public synchronized void setDbProxy(DbProxyInfo info) {
     dbProxyTable.put(info.id,info);
     fireChanged();
  }


  public synchronized void removeDbProxy(String id) {
     dbProxyTable.remove(id);
     fireChanged();
  }


  public synchronized void createDbProxy() {
     DbProxyInfo info = new DbProxyInfo();
     dbProxyTable.put(info.id,info);
     fireChanged();
  }


  public synchronized String[][] summarizeNameservers() {
     String[][] out = new String[nameserverTable.size()][4];
     Enumeration enum = nameserverTable.elements();
     for(int i = 0; i < out.length; i++ )
        out[i] = ((GenerationInfo)enum.nextElement()).summarize();
     return out;
  }
  
  
  public synchronized String[][] summarizeVisualisers() {
     String[][] out = new String[visualiserTable.size()][4];
     Enumeration enum = visualiserTable.elements();
     for(int i = 0; i < out.length; i++ )
        out[i] = ((GenerationInfo)enum.nextElement()).summarize();
     return out;
  }
  
  
  public synchronized String[][] summarizeFacilitators() {
     String[][] out = new String[facilitatorTable.size()][4];
     Enumeration enum = facilitatorTable.elements();
     for(int i = 0; i < out.length; i++ )
        out[i] = ((GenerationInfo)enum.nextElement()).summarize();
     return out;
  }
  
  
  public synchronized String[][] summarizeDbProxys() {
     String[][] out = new String[dbProxyTable.size()][4];
     Enumeration enum = dbProxyTable.elements();
     for(int i = 0; i < out.length; i++ )
        out[i] = ((GenerationInfo)enum.nextElement()).summarize();
     return out;
  }
  
  
  public synchronized String[][] summarizeSelectedTasks() {
     // show only tasks the are marked for generation;
     Enumeration enum = taskTable.elements();
     Vector results = new Vector();
     TaskInfo info;
     while( enum.hasMoreElements() ) {
        info = (TaskInfo)enum.nextElement();
	if ( info.generate ) results.addElement(info);
     }
     String[][] out = new String[results.size()][4];
     for(int i = 0; i < out.length; i++ )
        out[i] = ((TaskInfo)results.elementAt(i)).summarize();
     return out;
  }
  
  
  public synchronized String[][] summarizeSelectedAgents() {
     // show only tasks the are marked for generation;
     Enumeration enum = agentTable.elements();
     Vector results = new Vector();
     AgentInfo info;
     while( enum.hasMoreElements() ) {
        info = (AgentInfo)enum.nextElement();
	if ( info.generate ) results.addElement(info);
     }
     String[][] out = new String[results.size()][4];
     for(int i = 0; i < out.length; i++ )
        out[i] = ((AgentInfo)results.elementAt(i)).summarize();
     return out;
  }
  
  
  public synchronized String[][] summarizeTasks() {
     String[][] out = new String[taskTable.size()][4];
     Enumeration enum = taskTable.elements();
     for(int i = 0; i < out.length; i++ )
        out[i] = ((GenerationInfo)enum.nextElement()).summarize();
     return out;
  }
  
  
  public synchronized String[][] summarizeAgents() {
     String[][] out = new String[agentTable.size()][4];
     Enumeration enum = agentTable.elements();
     for(int i = 0; i < out.length; i++ )
        out[i] = ((GenerationInfo)enum.nextElement()).summarize();
     return out;
  }
  

  public synchronized void removeEntry(String type, String id) {
     if ( type.equals(GenerationInfo.NAMESERVER) ) {
        removeNameserver(id);
        return;
     }
     else if ( type.equals(GenerationInfo.VISUALISER) ) {
        removeVisualiser(id);
        return;
     }
     else if ( type.equals(GenerationInfo.FACILITATOR) ) {
        removeFacilitator(id);
        return;
     }
     else if ( type.equals(GenerationInfo.DBPROXY) ) {
        removeDbProxy(id);
        return;
     }
     else if ( type.equals(GenerationInfo.AGENT) ) {
        AgentInfo agentInfo = (AgentInfo)agentTable.get(id);
        agentInfo.generate = false;
        fireChanged();
     }
     else if ( type.equals(GenerationInfo.TASK) ) {
        TaskInfo taskInfo = (TaskInfo)taskTable.get(id);
        taskInfo.generate = false;
        fireChanged();
     }
  }


  public synchronized String getOntologyFilename() {
     String file = ontology.getFilename();
     file = Misc.relativePath(directory,file);
     if ( platform.equals(WINDOWS) )
        file = Writer.updateFilename(file,Writer.WINDOWS);
     else if ( platform.equals(UNIX) )
        file = Writer.updateFilename(file,Writer.UNIX);
     return file;
  }
  
  
  public synchronized void purge() {
     agentTable.clear();
     taskTable.clear();
     nameserverTable.clear();
     visualiserTable.clear();
     facilitatorTable.clear();
     dbProxyTable.clear();
     fireChanged();
  }


  public synchronized void reset() {
     purge();
     // create defaults: 1-nameserver, 1-facilitator & 1-visualiser
     createNameserver();
     createFacilitator();
     createVisualiser();

     String file = getOntologyFilename();
     AgentInfo agentInfo;
     AgentDescription[] agents = genmodel.getAgents();
     for(int i = 0; i < agents.length; i++ ) {
        agentInfo = new AgentInfo(agents[i].getName(),
           genmodel.getAgentName(agents[i].getName()),file);
        agentInfo.icon_file = genmodel.getAgentIcon(agents[i].getName());
        agentTable.put(agentInfo.id,agentInfo);
     }

     TaskInfo taskInfo;
     AbstractTask[] tasks = genmodel.getTasks();
     for(int i = 0; i < tasks.length; i++ ) {
        switch( tasks[i].getType() ) {
           case AbstractTask.PRIMITIVE:
           case AbstractTask.BEHAVIOUR:
                taskInfo = new TaskInfo(tasks[i].getName(),
                genmodel.getTaskName(tasks[i].getName()));
                taskTable.put(taskInfo.id,taskInfo);
                break;
        }
     }

     fireChanged();
  }
  

  public void stateChanged(ChangeEvent e) {
     if ( e.getSource() == ontology ) {
        recomputeOntologyFilePath();
        fireChanged();
     }
  }

// mabey there needs to be something about agent_external here?
  public void agentStateChanged(AgentChangeEvent e) {
     AgentDescription agent = e.getAgent();
     int mode = e.getEventType();
     AgentInfo agentInfo;
     switch(mode) {
        case AgentChangeEvent.ADD:
             agentInfo = new AgentInfo(agent.getName(),
                genmodel.getAgentName(agent.getName()),
		getOntologyFilename());
             agentInfo.icon_file = genmodel.getAgentIcon(agent.getName());
             agentTable.put(agentInfo.id,agentInfo);
             break;

        case AgentChangeEvent.MODIFY:
             agentInfo = (AgentInfo)agentTable.get(agent.getName());
             agentInfo.name = genmodel.getAgentName(agent.getName());
             agentInfo.icon_file = genmodel.getAgentIcon(agent.getName());
             agentInfo.status = SAVE_NEEDED;
             agentInfo.generate = true;
             break;

        case AgentChangeEvent.DELETE:
             agentTable.remove(agent.getName());
             break;
     }
     fireChanged();
  }


  public void taskStateChanged(TaskChangeEvent e) {
     AbstractTask task = e.getTask();
     if ( !task.isPrimitive() && !task.isBehaviour() ) return;

     int mode = e.getEventType();
     TaskInfo taskInfo;
     switch(mode) {
        case TaskChangeEvent.ADD:
             taskInfo = new TaskInfo(task.getName(),
                genmodel.getTaskName(task.getName()));
             taskTable.put(taskInfo.id,taskInfo);
             break;

        case TaskChangeEvent.MODIFY:
             taskInfo = (TaskInfo)taskTable.get(task.getName());
             taskInfo.name = genmodel.getTaskName(task.getName());
             taskInfo.status = SAVE_NEEDED;
             taskInfo.generate = true;
         
             AgentDescription[] agent = genmodel.getAgents();
             AgentInfo agentInfo;
             for(int i = 0; i < agent.length; i++ ) {
                if ( agent[i].containsTask(task.getName()) ) {
                   agentInfo = (AgentInfo)agentTable.get(agent[i].getName());
                   agentInfo.generate = true;
                   agentInfo.status = SAVE_NEEDED;
                }
             }
             break;

        case TaskChangeEvent.DELETE:
             taskTable.remove(task.getName());
             break;
     }
     fireChanged();
  }


  public void addChangeListener(ChangeListener x) {
    changeListeners.add(ChangeListener.class, x);
  }
  
  
  public void removeChangeListener(ChangeListener x) {
    changeListeners.remove(ChangeListener.class, x);
  }
  
  
  protected void fireChanged() {
    ChangeEvent c = new ChangeEvent(this);
    Object[] listeners = changeListeners.getListenerList();
    for(int i= listeners.length-2; i >= 0; i -=2) {
       if (listeners[i] == ChangeListener.class) {
          ChangeListener cl = (ChangeListener)listeners[i+1];
          cl.stateChanged(c);
       }
    }
  }
  
  
}