attributemodel.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
*/



/*****************************************************************************
* AttributeModel.java
*
* The underlying model for the Attribute Table
*****************************************************************************/

package zeus.generator.util;

import java.util.*;
import javax.swing.table.*;
import javax.swing.event.*;

import zeus.util.*;
import zeus.concepts.*;
import zeus.concepts.fn.*;
import zeus.gui.editors.*;
import zeus.generator.event.*;

public class AttributeModel extends AbstractTableModel
                            implements ChangeListener,
			    ValidatingModel,
                            RenameListener  {

  public static final int ATTRIBUTE = 0;
  public static final int VALUE = 1;
  public static final int RESTRICTION = 2;

  protected EventListenerList  changeListeners = new EventListenerList();
  protected String[]           columnNames = { "Attribute", "Value",
					       "Restriction" };
  protected String[][]         data;
  protected Fact               fact;

  protected int                columns;
  protected boolean            restrictions;
  protected boolean[]          permissions;

  public AttributeModel() {
    columns = 2;
    data = new String[0][columns];
    permissions = new boolean[] {false, true, true};
  }

  public void reset(Fact fact) {
     this.fact = fact;
     if ( fact == null )
        data = new String[0][columns];
     else {
        String[] attributes = fact.listAttributes();
        ValueFunction[] values = fact.listValues();
        data = new String[values.length][columns];
        for(int i = 0; i < data.length; i++ ) {
           data[i][ATTRIBUTE] = attributes[i];
           // alteration for 1.2.2 suggested by Matthieu Gomez [[e-mail]]
           // implemented by Simon Thompson
          /* if ( values[i].getID() == ValueFunction.LVAR )
              data[i][VALUE] = null;
           else*/
              data[i][VALUE] = values[i].toString();
        }
     }
     fireTableDataChanged();
  }

  public Fact getData()        { return fact; }
  public int  getColumnCount() { return columnNames.length; }
  public int  getRowCount()    { return data.length; }

  public boolean isCellEditable(int row, int col) {
    return permissions[col];
  }

  public String  getColumnName(int col)           { return columnNames[col]; }
  public Object  getValueAt(int row, int col)     { return data[row][col]; }

  public boolean isValidEntry(int row, int column) {
     switch(column) {
        case VALUE:
             if ( data[row][column] == null )
                return true;
             else if ( data[row][column].equals("") )
                return true;
             else
                return ZeusParser.Expression(data[row][column]) != null;
        case ATTRIBUTE:
             return true;
        case RESTRICTION:
	  return true;
     }
     return false; // sh never get here
  }

  public void setRestriction(String value, int row) {

    if(value != null) {
      data[row][RESTRICTION] = value;
    }
  }

  public void setValueAt(Object aValue, int row, int column)   {

     if(column == RESTRICTION) {
       if(aValue != null) {
	 data[row][RESTRICTION] = aValue.toString();
	 fireChanged();
	 fireTableCellUpdated(row,column);
       }
       return;
     }

     Core.ERROR(column == VALUE, 1, this);

     String value = (aValue == null) ? null : ((String)aValue).trim();
     if ( value.equals("") ) value = null;

     if ( value == null ) {
        if ( data[row][VALUE] == null )
           return;
        else {
           data[row][VALUE] = value;
           fact.setValue(data[row][ATTRIBUTE],fact.newVar());
        }
     }
     else {
        // always use this keyword for self reference!
        value = Misc.substitute(value,fact.getId(),Fact.THIS);
        if ( data[row][VALUE] != null && data[row][VALUE].equals(value) )
           return;
        else {
           data[row][VALUE] = value;
           ValueFunction fn = ZeusParser.Expression(data[row][VALUE]);
           if ( fn != null )
              fact.setValue(data[row][ATTRIBUTE],fn);
        }
     }
     fireChanged();
     fireTableCellUpdated(row,column);
  }

  public void nameChanged(RenameEvent e) {
     String prev = (String)e.getOriginal();
     String curr = (String)e.getCurrent();
     String s;
     for(int i = 0; i < data.length; i++ ) {
       if ( data[i][VALUE] != null ) {
          s = Misc.substitute(data[i][VALUE],prev,curr);
          if ( !s.equals(data[i][VALUE]) )
             setValueAt(s,i,VALUE);
       }
     }
  }
  public void stateChanged(ChangeEvent e) {
     reset(fact);
  }
  
  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);
        }
     }
  }

  public void enableRestrictions() {
    if(restrictions == false) {
      columns++;
      restrictions = true;
      reset(fact);
    }
  }

  public void disableRestrictions() {
    if(restrictions == true) {
      columns--;
      restrictions = false;
      reset(fact);
    }
  }

  public void setReadOnly(int column) {
    permissions[column] = false;
  }

  public void setWriteable(int column) {
    permissions[column] = true;
  }

}