Robust/src/Benchmarks/oooJava/DelaunayRefinement/DirectedEdgeGraph.java

   1 import java.util.*;
   2
   3 public class DirectedEdgeGraph
   4     implements EdgeGraph {
   5                 protected class EdgeGraphNode
   6                         implements Node {
   7
   8                                 protected final boolean hasInNeighbor(EdgeGraphNode n) {
   9                                         return inEdges.containsKey(n);
  10                                 }
  11
  12                                 protected boolean addInEdge(EdgeGraphNode n, GraphEdge e) {
  13                                         if(hasInNeighbor(n)) {
  14                                                 return false;
  15                                         } else {
  16                                                 inEdges.put(n, e);
  17                                                 return true;
  18                                         }
  19                                 }
  20
  21                                 protected boolean removeInEdge(EdgeGraphNode n) {
  22                                         if(!hasInNeighbor(n)) {
  23                                                 return false;
  24                                         } else {
  25                                                 inEdges.remove(n);
  26                                                 return true;
  27                                         }
  28                                 }
  29
  30                                 protected GraphEdge getInEdge(EdgeGraphNode n) {
  31                                         return (GraphEdge)inEdges.get(n);
  32                                 }
  33
  34                                 protected Collection getInEdges() {
  35                                         return inEdges.values();
  36                                 }
  37
  38                                 protected final Collection getInNeighbors() {
  39                                         return inEdges.keySet();
  40                                 }
  41
  42                                 protected final Collection getInNeighborsCopy() {
  43                                         return new ArrayList(inEdges.keySet());
  44                                 }
  45
  46                                 protected final boolean hasOutNeighbor(EdgeGraphNode n) {
  47                                         return outEdges.containsKey(n);
  48                                 }
  49
  50                                 protected boolean addOutEdge(EdgeGraphNode n, GraphEdge e) {
  51                                         if(hasOutNeighbor(n)) {
  52                                                 return false;
  53                                         } else {
  54                                                 outEdges.put(n, e);
  55                                                 return true;
  56                                         }
  57                                 }
  58
  59                                 protected boolean removeOutEdge(EdgeGraphNode n) {
  60                                         if(!hasOutNeighbor(n)) {
  61                                                 return false;
  62                                         } else {
  63                                                 outEdges.remove(n);
  64                                                 return true;
  65                                         }
  66                                 }
  67
  68                                 protected GraphEdge getOutEdge(EdgeGraphNode n) {
  69                                         return (GraphEdge)outEdges.get(n);
  70                                 }
  71
  72                                 protected Collection getOutEdges() {
  73                                         return outEdges.values();
  74                                 }
  75
  76                                 protected final Collection getOutNeighbors() {
  77                                         return outEdges.keySet();
  78                                 }
  79
  80                                 protected final Collection getOutNeighborsCopy() {
  81                                         return new ArrayList(outEdges.keySet());
  82                                 }
  83
  84                                 public Object getData() {
  85                                         return getNodeData(this);
  86                                 }
  87
  88                                 public Object setData(Object n) {
  89                                         return setNodeData(this, n);
  90                                 }
  91
  92                                 protected Map inEdges;
  93                                 protected Map outEdges;
  94                                 protected Object data;
  95                                 final DirectedEdgeGraph this$0;
  96
  97                                 EdgeGraphNode() {
  98                                   super();
  99                                         this$0 = DirectedEdgeGraph.this;
 100                                 }
 101
 102                                 EdgeGraphNode(Object d) {
 103           super();
 104                                         this$0 = DirectedEdgeGraph.this;
 105                                         inEdges = new HashMap();
 106                                         outEdges = new HashMap();
 107                                         data = d;
 108                                 }
 109                         }
 110
 111                 protected class GraphEdge
 112                         implements Edge {
 113
 114                                 protected final EdgeGraphNode getOpposite(EdgeGraphNode n) {
 115                                         return n != src ? src : dest;
 116                                 }
 117
 118                                 protected final EdgeGraphNode getSrc() {
 119                                         return src;
 120                                 }
 121
 122                                 protected final EdgeGraphNode getDest() {
 123                                         return dest;
 124                                 }
 125
 126                                 public Object getData() {
 127                                         return getEdgeData(this);
 128                                 }
 129
 130                                 public Object setData(Object e) {
 131                                         return setEdgeData(this, e);
 132                                 }
 133
 134                                 protected EdgeGraphNode src;
 135                                 protected EdgeGraphNode dest;
 136                                 protected Object d;
 137                                 final DirectedEdgeGraph this$0;
 138
 139                                 public GraphEdge(Object d) {
 140                                   super();
 141                                         this$0 = DirectedEdgeGraph.this;
 142                                         this.d = d;
 143                                 }
 144
 145                                 public GraphEdge(EdgeGraphNode src, EdgeGraphNode dest, Object d) {
 146                                         this(d);
 147                                         this.src = src;
 148                                         this.dest = dest;
 149                                 }
 150                         }
 151
 152
 153                 public DirectedEdgeGraph() {
 154                         nodes = Collections.synchronizedSet(new HashSet());
 155                 }
 156
 157                 public boolean addEdge(Edge e) {
 158                         GraphEdge ge = (GraphEdge)e;
 159                         EdgeGraphNode src = ge.getSrc();
 160                         EdgeGraphNode dest = ge.getDest();
 161                         return src.addOutEdge(dest, ge) ? dest.addInEdge(src, ge) : false;
 162                 }
 163
 164                 public Edge createEdge(Node src, Node dest, Object e) {
 165                         return new GraphEdge((EdgeGraphNode)src, (EdgeGraphNode)dest, e);
 166                 }
 167
 168                 public Node getDest(Edge e) {
 169                         return ((GraphEdge)e).getDest();
 170                 }
 171
 172                 public Edge getEdge(Node src, Node dest) {
 173                         return ((EdgeGraphNode)src).getOutEdge((EdgeGraphNode)dest);
 174                 }
 175
 176                 public Collection getInEdges(Node n) {
 177                         return ((EdgeGraphNode)n).getInEdges();
 178                 }
 179
 180                 public Collection getOutEdges(Node n) {
 181                         return ((EdgeGraphNode)n).getOutEdges();
 182                 }
 183
 184                 public Node getSource(Edge e) {
 185                         return ((GraphEdge)e).src;
 186                 }
 187
 188                 public boolean hasEdge(Edge e) {
 189                         GraphEdge ge = (GraphEdge)e;
 190                         return ge.getSrc().hasOutNeighbor(ge.getDest());
 191                 }
 192
 193                 public boolean removeEdge(Edge e) {
 194                         GraphEdge ge = (GraphEdge)e;
 195                         EdgeGraphNode src = ge.getSrc();
 196                         EdgeGraphNode dest = ge.getDest();
 197                         return src.removeOutEdge(dest) ? dest.removeInEdge(src) : false;
 198                 }
 199
 200                 public boolean addNeighbor(Node src, Node dest) {
 201                         throw new UnsupportedOperationException("addNeighbor not supported in EdgeGraphs. Use createEdge/addEdge instead");
 202                 }
 203
 204                 public Node createNode(Object n) {
 205                         return new EdgeGraphNode(n);
 206                 }
 207
 208                 public Collection getInNeighbors(Node src) {
 209                         return ((EdgeGraphNode)src).getInNeighbors();
 210                 }
 211
 212                 public Collection getOutNeighbors(Node src) {
 213                         return ((EdgeGraphNode)src).getOutNeighbors();
 214                 }
 215
 216                 public boolean removeNeighbor(Node src, Node dest) {
 217                         EdgeGraphNode gsrc = (EdgeGraphNode)src;
 218                         EdgeGraphNode gdest = (EdgeGraphNode)dest;
 219                         return gsrc.removeOutEdge(gdest) ? gdest.removeInEdge(gsrc) : false;
 220                 }
 221
 222                 public Object getEdgeData(Edge e) {
 223                         return ((GraphEdge)e).d;
 224                 }
 225
 226                 public Object setEdgeData(Edge e, Object d) {
 227                         GraphEdge ge = (GraphEdge)e;
 228                         Object retval = ge.d;
 229                         ge.d = d;
 230                         return retval;
 231                 }
 232
 233                 public Iterator iterator() {
 234                         return nodes.iterator();
 235                 }
 236
 237                 public boolean addNode(Node n) {
 238                         return nodes.add((EdgeGraphNode)n);
 239                 }
 240
 241                 public boolean containsNode(Node n) {
 242                         return nodes.contains(n);
 243                 }
 244
 245                 public Object getNodeData(Node n) {
 246                         EdgeGraphNode egn = (EdgeGraphNode)n;
 247                         return egn.data;
 248                 }
 249
 250                 public int getNumNodes() {
 251                         return nodes.size();
 252                 }
 253
 254                 public Node getRandom() {
 255                         return (Node)Sets.getAny(nodes);
 256                 }
 257
 258                 public boolean hasNeighbor(Node src, Node dest) {
 259                         EdgeGraphNode esrc = (EdgeGraphNode)src;
 260                         EdgeGraphNode edest = (EdgeGraphNode)dest;
 261                         return esrc.hasOutNeighbor(edest);
 262                 }
 263
 264                 public boolean removeNode(Node n) {
 265                         removeConnectingEdges((EdgeGraphNode)n);
 266                         return nodes.remove(n);
 267                 }
 268
 269                 protected void removeConnectingEdges(EdgeGraphNode n) {
 270                         Collection outNeighbors = n.getOutNeighborsCopy();
 271                         EdgeGraphNode g;
 272                         for(Iterator iterator1 = outNeighbors.iterator(); iterator1.hasNext(); removeNeighbor(n, g))
 273                                 g = (EdgeGraphNode)iterator1.next();
 274
 275                         Collection inNeighbors = n.getInNeighborsCopy();
 276                         for(Iterator iterator2 = inNeighbors.iterator(); iterator2.hasNext(); removeNeighbor(g, n))
 277                                 g = (EdgeGraphNode)iterator2.next();
 278
 279                 }
 280
 281                 public Object setNodeData(Node n, Object d) {
 282                         EdgeGraphNode egn = (EdgeGraphNode)n;
 283                         Object retval = egn.data;
 284                         egn.data = d;
 285                         return retval;
 286                 }
 287
 288                 public boolean isDirected() {
 289                         return true;
 290                 }
 291
 292                 Set nodes;
 293         }