---

CyclopsSimulator.java

Go to the documentation of this file.

/* Cyclops
 * FER - SPVP
 * Fakultet elektrotehnike i racunarstva (http://www.fer.hr/)
 * Unska 3, 10000 Zagreb, Hrvatska
 * (c) 2001 FER, Zagreb.
 */


package hr.fer.zesoi.cyclops;

import java.util.*;
import java.awt.*;


public class CyclopsSimulator extends Thread
{

    protected Vector node_list = new Vector();

    protected Vector line_list = new Vector();

    protected Node start_node = null;

    protected String start_node_name = null;

    protected Node end_node = null;

    protected String end_node_name = null;

    protected boolean trace_flag = false;

    protected boolean running = false;

    protected boolean destroy = false;

    public void run()
    {
        while (true)
            {
                if (running)
                    {
                        simulate();
                        if (trace_flag)
                            {
                                sendPacket();
                            }
                        try
                            {
                                Thread.sleep(100);
                            }
                        catch (InterruptedException exception)
                            {
                            }
                    }
                else
                    {
                        try
                            {
                                Thread.sleep(100);
                            }
                        catch (InterruptedException exception)
                            {
                            }
                    }
                if (destroy)
                    {
                        return;
                    }
            }
    }
    /* run */

    public CyclopsSimulator ()
    {
    }
    /* CyclopsSimulator */

    public synchronized void simulate ()
    {
        int i;
        Line current_line;
        Node current_node;

        for (i=0; i<line_list.size(); i++)
            {
                current_line = (Line)line_list.elementAt(i);
                current_line.transmitAll();
            }
        for (i=0; i<node_list.size(); i++)
            {
                current_node = (Node)node_list.elementAt(i);
                current_node.transmitAll();
            }
        for (i=0; i<node_list.size(); i++)
            {
                current_node = (Node)node_list.elementAt(i);
                current_node.updateRoutingTable();
            }
    }
    /* simulate */

    public synchronized void topologyUpdate ()
    {
        int i;
        Node current_node;

        for (i=0; i<node_list.size(); i++)
            {
                current_node = (Node)node_list.elementAt(i);
                current_node.updateRoutingTable();
            }
    }
    /* topologyUpdate */

    public void startSimulation ()
    {
        running = true;
    }
    /* startSimulation */

    public void tracePackets (String start_name, String end_name)
    {
        Node start_temp;
        Node end_temp;

        start_temp = findNode(start_name);
        if (start_temp == null)
            {
                return;
            }
        end_temp = findNode(end_name);
        if (end_temp == null)
            {
                return;
            }
        start_node = start_temp;
        start_node_name = start_name;
        end_node = end_temp;
        end_node_name = end_name;
        trace_flag = true;
    }
    /* tracePackets */

    public void sendPacket()
    {
        Node temp;

        temp = findNode(start_node_name);
        if (temp != null)
            {
                temp = findNode(end_node_name);
                if (temp != null)
                    {
                        Packet traced = new Packet(120, start_node, end_node, 14);
                        traced.setDrawingFlag(true);
                        start_node.receive(traced);
                    }
            }
    }
    /* sendPacket */

    public void addDummyPackets(int number, int time_to_live)
    {
        int i;
        int j;
        Node current_node;
        Packet packet;
        boolean running_flag;

        running_flag = running;
        running = false;
        /* Add dummy packets. */
        for (i=0, j=0; i<number; i++)
            {
                packet = new Packet();
                current_node = (Node)node_list.elementAt(j);
                j++;
                if (j >= node_list.size())
                    {
                        j = 0;
                    }
                packet.setTimeToLive(time_to_live);
                current_node.receive(packet);
            }
        running = running_flag;
    }
    /* addDummyPackets */

    public void stopSimulation ()
    {
        running = false;
    }
    /* stopSimulation */

    public void endSimulation ()
    {
        destroy = true;
    }
    /* endSimulation */

    public void addNode (Node new_node)
    {
        node_list.addElement(new_node);
    }
    /* addNode */

    public Node findNode (String node_name)
    {
        int i;
        String current_name;
        Node current_node;

        for (i=0; i!=node_list.size(); i++)
            {
                current_node = (Node)node_list.elementAt(i);
                current_name = current_node.getName();
                if (current_name.equals(node_name))
                    {
                        return current_node;
                    }
            }
        return null;
    }
    /* findNode*/

    public Node deleteNode (String node_name)
    {
        int i;
        String current_name;
        Node current_node = null;
        Line current_line;

        for (i=0; i!=node_list.size(); i++)
            {
                current_node = (Node)node_list.elementAt(i);
                current_name = current_node.getName();
                if (current_name.equals(node_name))
                    {
                        current_node.delete();
                        node_list.removeElementAt(i);
                        break;
                    }
            }
        for (i=0; i!=line_list.size(); i++)
            {
                current_line = (Line)line_list.elementAt(i);
                if (current_line.isDisconnected())
                    {
                        line_list.removeElementAt(i);
                        /* Next element becomes current element, so i-- is required. */
                        i--;
                    }
            }
        return current_node;
    }
    /* deleteNode*/

    public int numberOfNodes ()
    {
        return node_list.size();
    }
    /* numberOfNodes */

    public Node nodeAt(int index)
    {
        return (Node)node_list.elementAt(index);
    }
    /* nodeAt */

    public Line lineAt(int index)
    {
        return (Line)line_list.elementAt(index);
    }
    /* lineAt */

    public int numberOfLines ()
    {
        return line_list.size();
    }
    /* numberOfLines */

    public void addLine (Line new_line)
    {
        line_list.addElement(new_line);
    }
    /* addLine */

    public Line deleteLine (String first_node, String second_node)
    {
        Node first;
        Node second;
        Line current_line;
        int i;

        first = findNode(first_node);
        second = findNode(second_node);
        if (null == first) return null;
        if (null == second) return null;
        current_line = null;
        for (i=0; i!=line_list.size(); i++)
            {
                current_line = (Line)line_list.elementAt(i);
                if (current_line.areEndingNodes(first, second))
                    {
                        current_line.delete();
                        line_list.removeElementAt(i);
                        break;
                    }
            }
        return current_line;
    }
    /* deleteLine */

    public synchronized void paint (Graphics g, FontMetrics metrics,
                                    Color node_color, Color line_color,
                                    Color left_packet_color, Color right_packet_color,
                                    Color traced_packet_color,
                                    boolean show_line_capacity, boolean show_all_packets
                                    )
    {
        int i;
        Line current_line;
        Node current_node;

        for (i=0; i!=line_list.size(); i++)
            {
                current_line = (Line)line_list.elementAt(i);
                current_line.paint(g, metrics,
                                   line_color, left_packet_color, right_packet_color,
                                   traced_packet_color,
                                   show_line_capacity, show_all_packets);
            }
        for (i=0; i!=node_list.size(); i++)
            {
                current_node = (Node)node_list.elementAt(i);
                current_node.paint(g, metrics, node_color);
            }

    }
    /* paint */

}
/* CyclopsSimulator */

---