src/GraphNode.java

   1 /*
   2  * @(#)GraphNode.java
   3  * Time-stamp: "2008-10-13 16:55:16 anton"
   4  */
   5
   6 import java.util.Vector;
   7 import java.util.Hashtable;
   8 import java.util.Enumeration;
   9
  10 /**
  11  * GraphNode, used by Graph to keep track of the nodes
  12  * in a network and to make a routing table.
  13  *
  14  * @author "Anton Johansson" <anton.johansson@gmail.com>
  15  * @author "Victor Zamanian-Abasy" <zamanian87@gmail.com>
  16  */
  17 public class GraphNode implements Comparable {
  18    private int maxNeighbours;
  19    private Hashtable neighbours;
  20    private String name;
  21    private int x;
  22    private int y;
  23    private double distanceToGoal;
  24    private boolean visited;
  25    private int distance;
  26    private GraphNode parent;
  27
  28    /**
  29     * Creates a new GraphNode instance.
  30     *
  31     * @param name The name of the node.
  32     * @param maxNeighbours The maximum amount of
  33     * neighbours the node can have.
  34     */
  35    public GraphNode(String name, int x, int y, int maxNeighbours) {
  36       this.name = name;
  37       this.x = x;
  38       this.y = y;
  39       this.visited = false;
  40       this.maxNeighbours = maxNeighbours;
  41       neighbours = new Hashtable(maxNeighbours);
  42    }
  43
  44    /**
  45     * Adds a neighbour to this node.
  46     *
  47     * @param node The neighbour node to be added.
  48     * @param weight The weight of the potential edge between
  49     * this node and the new neighbour.
  50     */
  51    public void addNeighbour(GraphNode node, Integer weight) {
  52       neighbours.put(node, /*(Integer)*/ weight);
  53    }
  54
  55    public void deleteNeighbour(GraphNode node) {
  56       neighbours.remove(node);
  57    }
  58
  59    /**
  60     * Inspects the weight of the potential edge between this
  61     * node and one of its neighbours.
  62     *
  63     * @param node The neighbour of this node.
  64     * @return The weight of the potential edge.
  65     */
  66    public int getWeight(GraphNode node) {
  67       return (Integer) neighbours.get(node);
  68    }
  69
  70    /**
  71     * Visists this node--sets its visited attribute to true.
  72     */
  73    public void visit() {
  74       this.visited = true;
  75    }
  76
  77    /**
  78     * Inspects whether this node has been visited or not.
  79     *
  80     * @return true if this node has been visited, else false.
  81     */
  82    public boolean isVisited() {
  83       return this.visited;
  84    }
  85
  86    /**
  87     * Inspects all the neighbours (nodes) of this node.
  88     *
  89     * @return A Vector with all neighbours.
  90     */
  91    public Enumeration getNeighbours() {
  92       return neighbours.keys();
  93    }
  94
  95    /**
  96     * Inspects the NAME address of this node.
  97     *
  98     * @return The NAME address of this node.
  99     */
 100    public String getName() {
 101       return this.name;
 102    }
 103
 104    /**
 105     * Sets the distance to this node from the root node in
 106     * the process of Dijkstras shortest-path algorithm.
 107     *
 108     * @param distance The distance to this node.
 109     */
 110    public void setDistance(int distance) {
 111       this.distance = distance;
 112    }
 113
 114    /**
 115     * Inspects the distance from this node to the root node. See "setDistance."
 116     *
 117     * @return The distance from this node to the root node.
 118     */
 119    public int getDistance() {
 120       return this.distance;
 121    }
 122
 123    /**
 124     * Sets this node's parent node. Used in Dijkstras algorithm.
 125     *
 126     * @param parent The parent to be set.
 127     */
 128    public void setParent(GraphNode parent) {
 129       this.parent = parent;
 130    }
 131
 132    /**
 133     * Inspects this node's parent.
 134     *
 135     * @return The parent node of this parent.
 136     */
 137    public GraphNode getParent() {
 138       return this.parent;
 139    }
 140
 141    /**
 142     * Access to this nodes x-coordinate.
 143     *
 144     * @return the x-coordinate of this node.
 145     */
 146    public int getX() {
 147       return this.x;
 148    }
 149
 150    /**
 151     * Access to this nodes y-coordinate.
 152     *
 153     * @return the y-coordinate of this node.
 154     */
 155    public int getY() {
 156       return this.y;
 157    }
 158
 159    /**
 160     * Calculate and return the distance to x- y-coordinates
 161     *
 162     * @param x the x value to calculate the distance to.
 163     * @param y the y value to calculate the distance to.
 164     */
 165    public void setDistanceToGoal(GraphNode goal) {
 166       this.distanceToGoal = Math.hypot((this.x - goal.getX()), (this.y - goal.getY()));
 167    }
 168
 169    /**
 170     * Retun the distance to Goal.
 171     *
 172     * @return the distance to goal.
 173     */
 174    public double getDistanceToGoal() {
 175       return this.distanceToGoal;
 176    }
 177
 178    /**
 179     * Compares this node to another graph node.
 180     *
 181     * @param node The node to compare this node to.
 182     * @return 0 if the addresses match, a positive integer if
 183     * this node has a higher NAME address than the other node,
 184     * and a negative integer if this node has a lower NAME address
 185     * than the other node.
 186     */
 187    public int compareTo(Object node) {
 188       return name.compareTo(((GraphNode) node).getName());
 189    }
 190 }