root/trunk/Edge.java

// Edge.java
//
// This stores all the information a search algorithm will use to manipulate
// edges.  it has no position information.

import java.io.*;

public abstract class Edge implements Serializable {
        static final long serialVersionUID = 2843536174507280704L;
        
        public Edge(int a, int b) {
                aID = a;
                bID = b;
        }

        // return the Node with id id
        public Node getNode(int id) {
                if(aID == id) return a;
                else if(bID == id) return b;
                throw new IllegalArgumentException(this + " doesn't have node " + id);
        }


        // return the other endpoint of the edge
        public int getOtherID(Node n) {
                if(a == n) return bID;
                else if(b == n) return aID;
                throw new IllegalArgumentException(this + " doesn't have node " + n.id);
        }

        // return the other endpoint of the edge
        public int getOtherID(int id) {
                if(aID == id) return bID;
                else if(bID == id) return aID;
                throw new IllegalArgumentException(this + " doesn't have node " + id);
        }

        // return the Node opposite the one with id n
        public Node getOtherNode(int id) {
                if(aID == id) return b;
                else if(bID == id) return a;
                throw new IllegalArgumentException(this + " doesn't have node " + id);
        }

        // return the Node opposite n
        public Node getOtherNode(Node n) {
                if(a == n) return b;
                else if(b == n) return a;
                throw new IllegalArgumentException(this + " doesn't have node " + n.id);
        }

        // do we have this node?
        public boolean hasNode(Node n) { return a == n || b == n; }
        public boolean hasNode(int id) { return aID == id || bID == id; }


        // get and set the nodes referenced, ensuring the ids match
        public Node getNodeA() { return a; }
        public Node getNodeB() { return b; }
        public void setNodeA(Node a) {
                if(a.id != aID) throw new IllegalArgumentException("a.id != this.aID");
                this.a = a;
        }
        public void setNodeB(Node b) {
                if(b.id != bID) throw new IllegalArgumentException("b.id != this.bID");
                this.b = b;
        }

        public void setNode(Node n) {
                if(n.id == aID) a = n;
                else if(n.id == bID) b = n;
                else throw new IllegalArgumentException(this + " doesn't have node " + n.id);
        }

        // these let you use 0 or 1 instead of a or b
        public Node getNodeN(int n) {
                return n == 0 ? a : b;
        }
        public int getNID(int n) {
                return n == 0 ? aID : bID;
        }
        public void setNodeN(int n, Node node) {
                if(n == 0) setNodeA(node); else setNodeB(node);
        }

        // any two edges that connect the same nodes, even in the reverse order,
        // are equal.  Note that this is used mainly for generating random
        // graphs, so it's ok if subclasses don't get this exactly right.
        public boolean equals(Object o) {
                return (o instanceof Edge) && (
                       (aID == ((Edge)o).aID && bID == ((Edge)o).bID) ||
                       (aID == ((Edge)o).bID && bID == ((Edge)o).aID)
                       );
        }

        // since we changed equals, we also have to change this so hashsets work
        public int hashCode() {
                return aID * bID;
        }

        // returns a new (modifiable) cost to get from from to the other node
        // this should not add gCostOfFrom to the cost it creates. (it just may
        // need the gCostOfFrom to compute bus schedules, etc.)
        // all subclasses must override this
        public abstract Cost computeDeltaGCost(Node from, Cost gCostOfFrom, Search s);
        
        // returns whether the node should be displayed with the given map
        public boolean isOnMap(BackgroundMap m) {
                return true;
        }
        
        public String toString() {
                return "Edge(" + aID + ", " + bID + ")";
        }

        public final int aID, bID;

        private transient Node a, b;
}