pn.java

来自「petrinets小程序」· Java 代码 · 共 461 行

import java.awt.Polygon;
import java.util.Vector;


public class pn implements Cloneable{
	
	protected Vector places;
	protected Vector transitions;
	protected Vector edges;
	protected String name;
	protected int stepCount;
	
	protected weight weights; 

	protected String statusStr = "";
	
	protected Vector RTNodes;
	protected Vector RGNodes;

	
	public pn() {
	    this.places = new Vector();
	    this.transitions = new Vector();
	    this.edges = new Vector();
	    this.name = "Petri Net";
	    this.stepCount = 0;
	    
	    weights = new weight(this);	    
	}
	
	public pn(pn PN){
		this.places = PN.places;
		this.transitions = PN.transitions;
		this.edges = PN.edges;
		this.name = PN.name;
		this.stepCount = PN.stepCount;	
		
		weights = new weight(PN);
	}
	
	public pn(Editor f){
		new pn(f.returnPNet());
	}
	
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	
	public int getIndexOf(place n) {
		return places.indexOf(n);
	}
	public int getIndexOf(transition t) {
		return transitions.indexOf(t);
	}
	public int getIndexOf(edge e) {
		return edges.indexOf(e);
	}
	
	public boolean equal(pn p1, pn p2){
		if(p1 == null || p2 == null)
			return false;
		else if(p1.numberOfPlaces() != p2.numberOfPlaces()||
				p1.numberOfTransitions() != p2.numberOfTransitions()|
				p1.numberOfEdges() != p2.numberOfEdges())
			return false;
		else{
			for(int i = 0; i < p1.numberOfPlaces(); i++)
				if(!equal(p1.getPlace(i), p2.getPlace(i))) return false;
			for(int k = 0; k < p1.numberOfTransitions(); k++)
				if(!equal(p1.getTransition(k), p2.getTransition(k))) return false;
			for(int j = 0; j < p1.numberOfEdges(); j++)
				if(!equal(p1.getEdge(j), p2.getEdge(j))) return false;
		}
		return true;
		
	}
	public boolean equal(place n1, place n2) {
		if (n1 == null || n2 == null)
			return false;
		if (places.indexOf(n1) == places.indexOf(n2))
			return true;
		return false;
	}
	public boolean equal(transition t1, transition t2) {
		if (t1 == null || t2 == null)
			return false;
		if(transitions.indexOf(t1) == transitions.indexOf(t2))
			return true;
		return false;
	}
	public boolean equal(edge e1, edge e2) {
		if (e1 == null || e2 == null)
			return false;
		if(edges.indexOf(e1) == edges.indexOf(e2))
			return true;
		return false;
	}
	
	public int numberOfPlaces() {
		return places.size();
	}
	public int numberOfTransitions() {
		return transitions.size();
	}
	public int numberOfEdges() {
		return edges.size();
	}
	
	public place getPlace(int i) {
		place n;
		n = (place) places.elementAt(i);
		return n;
	}
	public transition getTransition(int i) {
		transition t;
		t = (transition) transitions.elementAt(i);
		return t;
	}
	public edge getEdge(int i) {
		edge e;
		e = (edge) edges.elementAt(i);
		return e;
	}
	
	public int getPlaceIndex(place n){
		int i;
		int ret = -1;
		
		for (i=0; i< numberOfPlaces(); i++){
			if ( (place) places.elementAt(i) == n){
				ret = i;
				break;
			}
		}
		return ret;
	}
	public int getTransIndex(transition n){
		int i;
		int ret = -1;
		
		for (i=0; i< numberOfTransitions(); i++){
			if ( (transition) transitions.elementAt(i) == n){
				ret = i;
				break;
			}
		}
		return ret;
	}
	
	public static int getX(Object o){
		if (o instanceof place){
			place n = (place) o;
			return n.getX();
		}
		if (o instanceof transition){
			transition t = (transition) o;
			return t.getX();
		}
		return 0;
	}
	public static int getY(Object o){
		if (o instanceof place){
			place n = (place) o;
			return n.getY();
		}
		if (o instanceof transition){
			transition t = (transition) o;
			return t.getY();
		}
		return 0;
	}
	
	public void unhighlightAllTransitions(){////////////////vt.
		for (int i = 0; i < numberOfTransitions(); i++){
			getTransition(i).highlight = false;
		}
	}
	
	public void addPlace(){
		place n = new place("p" + (this.numberOfPlaces()+1));
		places.addElement( n );
	}
	public boolean addPlace(int x, int y){
		place n = new place("p" + (this.numberOfPlaces()+1));
		n.setX(x);
		n.setY(y);
		places.addElement(n);
		return true;
	}
	public boolean addPlace(place n){
		places.addElement(n);
		return true;
	}
	
	public void addTransition(){
		transition t = new transition("t" + (this.numberOfTransitions()+1));
		transitions.addElement(t);
	}
	public boolean addTransition(int x, int y){
		transition t = new transition("t" + (this.numberOfTransitions()+1));
		t.setX(x);
		t.setY(y);
		transitions.addElement(t);
		return true;
	}
	public boolean addTransition(transition t){
		transitions.addElement(t);
		return true;
	}
	
	public void addEdgeProtocol(edge e){
	    }
	public edge addEdge(edge e){
		edges.addElement(e);
		addEdgeProtocol(e);
		return e;
	}
	public edge addEdge(int tFrom, int iFrom, int tTo, int iTo, Polygon points){
		edge e = new edge(tFrom, iFrom, tTo, iTo, points);
		edges.addElement(e);
		addEdgeProtocol(e);
		return e;
	}
	
	public void removePlace(place n){
	    int index = places.indexOf(n);
	    int i;
	    int k = 0;
	    int todelete[] = new int[places.size()];

	    this.places.removeElement(n);

	    for (i = 0; i < edges.size(); i++){
	    	edge e = (edge) edges.elementAt(i);
	    	if (e.adjust(this, index, edge.PLACE))
	    	{todelete[k] = i; k++;}
	    }

	    for (i = k; i > 0; i--){
	    	edge d = (edge) edges.elementAt(todelete[i-1]);
	    	edges.removeElement(d);
	    }
	}
	
	public void removeTransition(transition t){
		int i;
	    int k = 0;
	    int todelete[] = new int[edges.size()];
	    int index = transitions.indexOf(t);

	    for (i = 0; i < edges.size(); i++){
	    	edge e = (edge) edges.elementAt(i);
	    	if (e.adjust(this, index, edge.TRANSITION))
	    	{todelete[k] = i; k++;}
	    }

	    for (i = k; i > 0; i--){
	    	edge d = (edge) edges.elementAt(todelete[i-1]);
	    	edges.removeElement(d);
	    }
	    this.transitions.removeElement(t);
	}
	
	public void removeEdgeProtocol(edge e){
		
	}
	public boolean removeEdge(edge e){
		removeEdgeProtocol(e);
        edges.removeElement(e);
        return true;
	}
	
	public boolean isDead(boolean priorEnabled){
		boolean isdead = true;
		int i;
		for (i=0; i<transitions.size(); i++){
			isdead = ! (((transition) transitions.elementAt(i)).canFire(this, priorEnabled));
			if (isdead == false) break;
		}
		return isdead;
	}
	
	public void setStepCount(int s){
		stepCount = s;
	}
	public int getStepCount(){
		return stepCount;          
	}
	
	public Vector getAllConnectedTrans(transition t){
		int i,j;
		int ind = 0;
		
		edge e,f;

		Vector connected = new Vector();

		for (i=0; i < numberOfEdges(); i++){
			e = (edge) edges.elementAt(i);
			if ((e.getTTo() == edge.TRANSITION) && (e.getITo() == getTransIndex(t)))
			{ind = e.getIFrom();
			for (j=0; j< numberOfEdges(); j++){
				f = getEdge(j);
				if (( f.getTFrom() == edge.PLACE) && (f.getIFrom() == ind)){
					if (! connected.contains(getTransition(f.getITo())))
						connected.addElement(getTransition(f.getITo()));
				}
			}
			}
		}
		return connected;
	}
	
	public Vector getAllConnectedFireableTrans(transition t, boolean prior){
		Vector vec = getAllConnectedTrans(t);
		for (int i = 0; i < vec.size(); i++){
			if (! ((transition)vec.elementAt(i)).canFire(this, prior)){
				vec.removeElementAt(i);
			}
		}
		return vec;
	}
	
	public Vector getAllConnectedPlaces(place p){
		int i,j;
		int ind = 0;
		
		edge e,f;

		Vector connected = new Vector();

		for (i=0; i < numberOfEdges(); i++){
			e = (edge) edges.elementAt(i);
			if ((e.getTTo() == edge.TRANSITION) && (e.getIFrom() == this.getPlaceIndex(p)))
			{ind = e.getITo();
			for (j=0; j< numberOfEdges(); j++){
				f = getEdge(j);
				if (( f.getTFrom() == edge.PLACE) && (f.getITo() == ind)){
					if (! connected.contains(this.getPlace(f.getIFrom())))
						connected.addElement(this.getPlace(f.getIFrom()));
				}
			}
			}
		}
		return connected;
	}
	
	public boolean connectedWith(place n, transition t){
		int i;
	    edge e;
	    boolean ret = false;

	    for (i=0; i<numberOfEdges(); i++){
	    	e = (edge) edges.elementAt(i);
	    	if (e.pointingTo(this,t)){
	    		if (getPlaceIndex(n) == e.getIFrom()) ret = true;
	    	}
	    }
	    return ret;
	}
	
	public int getAllWeights(Vector v){
		int i,j;
		edge e;
		transition t = new transition();
		int weights = 0;

		for (i=0; i< v.size(); i++){
			t = (transition) v.elementAt(i);
			for (j=0; j< numberOfEdges(); j++){//////////////////////////iSco  maybe repeat for different transition
				e = (edge) getEdge(j);
				if (e.pointingTo(this,t)) weights = weights + e.getWeight();
			}
		}
		return weights;
	}
	
	public int getConnectedTokens(Vector v){//////////////iSco how many tokens in each transition for all input Places
		  int i,j;
		  int tokens = 0;
		  transition t = new transition();
		  place n = new place();
		  for (i=0; i< v.size(); i++){
			  t = (transition) v.elementAt(i);
			  for (j=0; j<numberOfPlaces(); j++){
				  n = (place) places.elementAt(j);
				  if (connectedWith(n,t)) tokens += n.getTokens();//////iSco  connectedWith(n,t) stand for has edge between them
			  }
		  }
		  return tokens;
	}
	
	public Vector multipleCanFire(Vector v, boolean priorEnabled){
		int i,j,size;
	    transition s,t;
	    boolean b;
	    Vector w = new Vector();
	    Vector z = new Vector();

	    pn q = (pn) this.clone();

	    size = v.size();

	    for (i=0; i < size; i++){
	    	t = (transition) v.elementAt(i);
	    	for (j=0; j < q.numberOfTransitions(); j++){
	    		s = q.getTransition(j);
	    		if (s.equals(t)) z.addElement(s);
	    	}
	    }

	    size = z.size();

	    for (i=0; i < size; i++){
	    	t = (transition) z.elementAt(i);
	    	b = t.fire(q, false); 
	    	if (b){
	    		w.addElement(t);
	    	}
	    }
	    v.removeAllElements();

	    for (i=0; i < w.size(); i++){
	    	t = (transition) w.elementAt(i);
	    	for (j=0; j < numberOfTransitions(); j++){
	    		s = getTransition(j);
	    		if (s.equals(t)) v.addElement(s);
	    	}
	    }
	    return v;
	}
	
	public static void subVectorOfVector(Vector sub,Vector vec){////vector - subvector
		for (int i = 0; i < sub.size(); i++){
			vec.removeElement(sub.elementAt(i));
		}
	}
	
	public synchronized Object clone(){
		pn p = new pn();
	    p.setName(name);
	    p.setStepCount(stepCount);
	    for (int i = 0; i < places.size(); i++){
	    	p.addPlace((place)((place)places.elementAt(i)).clone());
	    }
	    for (int i = 0; i < transitions.size(); i++){
	    	p.addTransition((transition)((transition)transitions.elementAt(i)).clone());
	    }
	    for (int i = 0; i < edges.size(); i++){
	        p.addEdge((edge)((edge)edges.elementAt(i)).clone());
	    }
	    return p;
	}

	
	
}