controller.java

P2P模拟器P2Psim的程序源码

package graph;

import gui.GUIEventManager;

import org.jgraph.graph.*;
import org.jgraph.graph.DefaultGraphModel;
import java.util.*;
import java.awt.*;

import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;

import javax.swing.Timer;

public class Controller implements ActionListener
{
	private Timer timer;
	private int queryProbability = 0;
	private int internalTime = 0;
	
	private DefaultGraphModel model;
	
	private FileManager fileManager;

	public void start()
	{
		fileManager = new FileManager();
		
		model = new DefaultGraphModel();
		
		timer = new Timer(2000, this);
		
		addVertex("P2P-sim", 100, 100);
		
		GraphEventManager.getReference().setMyController(this);
		
		GUIEventManager.getReference().eventUpdateModel(model);
	}
	
	public void startTimer()
	{
		timer.start();
	}
	
	public void stopTimer()
	{
		timer.stop();
	}
	
	private void changeDelay(int newDelay)
	{
		timer.setDelay(newDelay);
	}
	
	public void decreaseDelay()
	{
		if (timer.getDelay() > 600)
		{
			timer.setDelay(timer.getDelay()-200);
		}
	}
	
	public void increaseDelay()
	{
		if (timer.getDelay() < 3000)
		{
			timer.setDelay(timer.getDelay()+200);
		}
	}
	
	public void setQueryProbability(int newProbability)
	{
		queryProbability = newProbability;
	}
	
	public void actionPerformed(ActionEvent e)
	{
		internalTime++;
		//System.out.println(Integer.MAX_VALUE);
		//System.out.println("Action Performed !");
		
		for (int i = 0; i < model.getRootCount(); i++)
		{
			//System.out.println("nr " + i + " / " + model.getRootCount());
			//System.out.println((DefaultGraphCell)model.getRootAt(i));
			//System.out.println();
			if ((DefaultGraphCell)model.getRootAt(i) == null)
			{
				System.out.println("Null op positie: " + i);
			}
			Properties properties = GraphEventManager.getReference().getProperties((DefaultGraphCell)model.getRootAt(i));
			if (properties != null && properties.getListInformation("Agents") != null)
			{
				LinkedList ll = (LinkedList)properties.getListInformation("Agents").clone();
				
				for (int j=0; j < ll.size(); j++)
				{
					//System.out.println("------Run ant " + j + " / " + ll.size() + " nl. " + ((Ant)ll.get(j)));
					((Agent)ll.get(j)).run((DefaultGraphCell)model.getRootAt(i));
					//System.out.println("------End run of " + ((Ant)ll.get(j)));
				}	
			}
			if (properties != null && properties.getListInformation("Query") != null)
			{
				LinkedList ll = (LinkedList)properties.getListInformation("Query");
				
				for (int j=0; j < ll.size(); j++)
				{
					((ResourceQuery)ll.get(j)).increaseWaitingTime();
				}	
			}
			
			
		if (queryProbability != 0)
		{
			if (!(model.getRootAt(i) instanceof DefaultEdge))
			{
				int number = (int) (Math.random() * queryProbability);
				if (number == 1)
				{
					GraphEventManager.getReference().eventSearchForResource( ((DefaultGraphCell)model.getRootAt(i)), ((Resource)GraphEventManager.getReference().eventGetRandomResources(1).next()).getName());
				}
			}
		}
		
		}
		
		GUIEventManager.getReference().eventRedrawGraph();
	}
	
	public void saveModel(String filename)
	{
		fileManager.save(filename, getModel());
	}
	
	public void openModel(String filename)
	{
		DefaultGraphModel newModel = fileManager.open(filename);
		if (newModel != null)
		{
			setModel(newModel);
		}
	}
	
	/*
	public void loadRandomGraph()
	{
		double[] edgeprobs = {0.6, 0.6};
		int[] nbnodes = {4, 4};
		int[] organisation = {0, 0};
		int[] capacities = {10, 5};
		setModel(NetworkBuilder.getGraph(1, nbnodes, organisation, edgeprobs, capacities));	
	}
	*/
	
	public void loadRandomGraph(int[] nbNodes, int[] organisation, double[] edgeProbs, int[] capacities)
	{
		setModel(NetworkBuilder.getGraph(1, nbNodes, organisation, edgeProbs, capacities));		
	}
	
	public void loadExistingGraph(String pathToFile)
	{
		setModel(NetworkBuilder.getExistingGraph(pathToFile));
	}
	
	
	public DefaultGraphModel getModel()
	{
		return model;
	}

	public void setModel(DefaultGraphModel myModel)
	{
		this.model = myModel;
		GUIEventManager.getReference().eventUpdateModel(myModel);
	}

	public void addVertex(String label, int xpos, int ypos)
	{
		Map attributes = new Hashtable();
		
		DefaultGraphCell jc = new DefaultGraphCell(label);
		attributes.put(jc, createBounds(xpos, ypos, Color.pink, label));
		jc.add(new DefaultPort("JComponent/Center"));
		
		
		Object[] cells = new Object[] {jc};
		model.insert(cells, attributes, null, null, null);
		
		GUIEventManager.getReference().eventUpdateModel(model);	
	}
	
	public Map createBounds(int x, int y, Color c, String label) 
	{
		Map map = GraphConstants.createMap();
		GraphConstants.setBounds(map, new Rectangle(x, y, 100, 50));
		
		Properties p = new Properties(label);
		
		GraphConstants.setValue(map, p);
		
		GraphConstants.setBackground(map, c.darker());
		GraphConstants.setForeground(map, Color.white);
		GraphConstants.setFont(map, GraphConstants.defaultFont.deriveFont(Font.BOLD, 12));
		GraphConstants.setOpaque(map, true);
		return map;
	}
	
	public void addEdge(DefaultGraphCell dgc1, DefaultGraphCell dgc2)
	{
		if(! (dgc1 instanceof DefaultEdge) && ! (dgc2 instanceof DefaultEdge))
		{
			ConnectionSet cs = new ConnectionSet();
			Map attributes = new Hashtable();
	
			// Styles For Implement/Extend/Aggregation
			Map implementStyle = GraphConstants.createMap();
			GraphConstants.setLineBegin(implementStyle,	GraphConstants.ARROW_NONE);
			GraphConstants.setBeginSize(implementStyle, 10);
			GraphConstants.setDashPattern(implementStyle, new float[] { 3, 3 });
			GraphConstants.setFont(implementStyle, GraphConstants.defaultFont.deriveFont(10));
			GraphConstants.setValue(implementStyle, new EdgeProperties("new",5));
			
			DefaultEdge edge = new DefaultEdge("new");
			
			cs.connect(edge, dgc1.getChildAt(0), dgc2.getChildAt(0));
			attributes.put(edge, implementStyle);
						
			Object[] cells = new Object[] {edge};
			getModel().insert(cells, attributes, cs, null, null);
		
			GUIEventManager.getReference().eventUpdateModel(model);	
			
			LinkedList ll = GraphEventManager.getReference().getProperties(dgc1).getListInformation("Gradient");
			if (ll != null)
			{
				for (int i=ll.size()-1; i>-1; i--)
				{
					Gradient gradient = (Gradient)ll.get(i);
					//System.out.println("Gradient found: " + gradient.getSource());
					Gradient sourceGradient = null;
					ListIterator li = GraphEventManager.getReference().getProperties(gradient.getSource()).getInformation("Gradient");
					boolean found = false;
					while(!found && li.hasNext())
					{
						sourceGradient = (Gradient)li.next();
						//System.out.println("Source = " + sourceGradient.getSource());
						//System.out.println("Backpointer = " + sourceGradient.getBackPointer());
						//System.out.println("gradient.getSource = " + gradient.getSource());
						if(gradient.getSource() == sourceGradient.getSource())
						{
							found = true;		
						}
					}
					if (found)
					{
						constructGradientField(gradient.getSource(), gradient.getSource(), sourceGradient.getDistance());
					}
				}
			}
			
			ll = GraphEventManager.getReference().getProperties(dgc2).getListInformation("Gradient");
			if (ll != null)
			{
				for (int i=ll.size()-1; i>-1; i--)
				{
					Gradient gradient = (Gradient)ll.get(i);
					//System.out.println("Gradient found: " + gradient.getSource());
					Gradient sourceGradient = null;
					ListIterator li = GraphEventManager.getReference().getProperties(gradient.getSource()).getInformation("Gradient");
					boolean found = false;
					while(!found && li.hasNext())
					{
						sourceGradient = (Gradient)li.next();
						//System.out.println("Source = " + sourceGradient.getSource());
						//System.out.println("Backpointer = " + sourceGradient.getBackPointer());
						//System.out.println("gradient.getSource = " + gradient.getSource());
						if(gradient.getSource() == sourceGradient.getSource())
						{
							found = true;		
						}
					}
					if (found)
					{
						constructGradientField(gradient.getSource(), gradient.getSource(), sourceGradient.getDistance());
					}
				}	
			}	
		}
	}

	
	public void removeVertex(DefaultGraphCell dgc)
	{
		
		LinkedList connectedNodes = GraphEventManager.getReference().getConnectedNodes(dgc);
		DefaultEdge edge;
		LinkedList ll = new LinkedList();
		
		// Verwijder alle edges die in dgc toekomen.
		if (connectedNodes.size() != 0)
		{
			Object cells[] = new Object[connectedNodes.size()];
			
			int i=0;
			
			for (i=0; i<connectedNodes.size(); i++)
			{
				edge = GraphEventManager.getReference().getConnectingEdge(dgc, ((DefaultGraphCell)connectedNodes.get(i)) );
			//	cells[i] = edge;
				ll.add(edge);
				
			}
			
			//model.remove(cells);
		}
		
		for (int i=ll.size()-1; i>-1; i--)
		{
			removeEdge((DefaultEdge)ll.get(i));
		}	
		
		// Verwijder de vertex op zich.
		dgc.removeAllChildren();
		Object cells[] = {dgc};
		model.remove(cells);
		
		GUIEventManager.getReference().eventUpdateModel(model);	
	}
	
	public void removeEdge(DefaultEdge de)
	{
				
		DefaultGraphCell dgc1, dgc2;
		dgc1 = (DefaultGraphCell)((DefaultPort)de.getSource()).getParent();
		dgc2 = (DefaultGraphCell)((DefaultPort)de.getTarget()).getParent();
	
		Object cells[] = {de};
		model.remove(cells);

		GUIEventManager.getReference().eventUpdateModel(model);
		
		Properties p1, p2;
		p1 = GraphEventManager.getReference().getProperties(dgc1);
		p2 = GraphEventManager.getReference().getProperties(dgc2);

		
		// for each gradient:
		//Iterator iterator1; // = p1.getInformation("Gradient");
		
		int skip=0;
		
		LinkedList list1 = p1.getListInformation("Gradient");
		
		if (list1 != null)
		{
			while(list1.size() > skip)
			{
				System.out.println(list1.size());
				Gradient gradient = (Gradient)list1.get(skip);
				if (dgc1 == gradient.getBackPointer() || GraphEventManager.getReference().getConnectingEdge(dgc1, gradient.getBackPointer()) != null)
				{
					skip++;
				}
				if (dgc1 != gradient.getBackPointer() && GraphEventManager.getReference().getConnectingEdge(dgc1, gradient.getBackPointer()) == null )
				{
					// Het gradient-veld is ongeldig, want de knoop waarlangs de sterkte werd doorgegeven, is niet
					// meer bereikbaar.
					removeGradientField(gradient.getSource(), dgc1, false);
				}
			}
		}

		skip = 0;