KezvhLib/src-lib/net/kezvh/collections/graphs/directed/WrappedKeySet.java

   1 /**
   2  *
   3  */
   4 package net.kezvh.collections.graphs.directed;
   5
   6 import java.util.AbstractSet;
   7 import java.util.Iterator;
   8 import java.util.Set;
   9 import java.util.Map.Entry;
  10
  11 import net.kezvh.collections.views.SetView;
  12 import net.kezvh.functional.Operations;
  13 import net.kezvh.functional.lambda.L1;
  14
  15 import com.google.common.collect.AbstractMapEntry;
  16
  17 /**
  18  * @author afflux
  19  * @param <Node> node type
  20  * @param <NodeValue> node value type
  21  * @param <EdgeValue> edge value type
  22  */
  23 class WrappedKeySet<Node, NodeValue, EdgeValue> extends AbstractSet<Node> implements DirectedGraphWithEdgeValues<Node, EdgeValue> {
  24         private final DirectedGraphWithValues<Node, NodeValue, EdgeValue> wrappedGraph;
  25
  26         /**
  27          * @param wrappedGraph wrapped graph
  28          */
  29         public WrappedKeySet(final DirectedGraphWithValues<Node, NodeValue, EdgeValue> wrappedGraph) {
  30                 this.wrappedGraph = wrappedGraph;
  31         }
  32
  33         @Override
  34         public boolean containsEdge(final Node source, final Node destination) {
  35                 return this.wrappedGraph.containsEdge(source, destination);
  36         }
  37
  38         @Override
  39         public long edgeCount() {
  40                 return this.wrappedGraph.edgeCount();
  41         }
  42
  43         @Override
  44         public int inDegree(final Node destination) {
  45                 return this.wrappedGraph.inDegree(destination);
  46         }
  47
  48         @Override
  49         public int outDegree(final Node source) {
  50                 return this.wrappedGraph.outDegree(source);
  51         }
  52
  53         @Override
  54         public Set<Node> adjacentFrom(final Node source) {
  55                 return this.wrappedGraph.adjacentFrom(source);
  56         }
  57
  58         @Override
  59         public Set<Node> adjacentTo(final Node destination) {
  60                 return this.wrappedGraph.adjacentTo(destination);
  61         }
  62
  63         @Override
  64         public EdgeValue addEdge(final Node source, final Node destination, final EdgeValue edgeValue) {
  65                 return this.wrappedGraph.addEdge(source, destination, edgeValue);
  66         }
  67
  68         @Override
  69         public EdgeValue getEdgeValue(final Node source, final Node destination) {
  70                 return this.wrappedGraph.getEdgeValue(source, destination);
  71         }
  72
  73         @Override
  74         public EdgeValue removeEdge(final Node source, final Node destination) {
  75                 return this.wrappedGraph.removeEdge(source, destination);
  76         }
  77
  78         @Override
  79         public EdgeValue removeEdge(final EdgeWithEdgeValue<Node, EdgeValue> edge) {
  80                 return this.wrappedGraph.removeEdge(edge.getSourceNode(), edge.getDestinationNode());
  81         }
  82
  83         @Override
  84         public boolean containsEdge(final EdgeWithEdgeValue<Node, EdgeValue> edge) {
  85                 return this.wrappedGraph.containsEdge(edge.getSourceNode(), edge.getDestinationNode());
  86         }
  87
  88         private final L1<EdgeWithEdgeValue<Node, EdgeValue>, EdgeWithValues<Node, NodeValue, EdgeValue>> getSetEdges = new L1<EdgeWithEdgeValue<Node, EdgeValue>, EdgeWithValues<Node, NodeValue, EdgeValue>>() {
  89                 @Override
  90                 public EdgeWithEdgeValue<Node, EdgeValue> op(final EdgeWithValues<Node, NodeValue, EdgeValue> param) {
  91                         return new EdgeWithEdgeValue<Node, EdgeValue>() {
  92                                 @Override
  93                                 public Node getDestinationNode() {
  94                                         return param.getDestinationNode();
  95                                 }
  96
  97                                 @Override
  98                                 public Node getSourceNode() {
  99                                         return param.getSourceNode();
 100                                 }
 101
 102                                 @Override
 103                                 public EdgeValue getValue() {
 104                                         return param.getValue();
 105                                 }
 106
 107                                 public EdgeValue setValue(final EdgeValue newValue) {
 108                                         return param.setValue(newValue);
 109                                 }
 110                         };
 111                 }
 112         };
 113
 114         private final L1<EdgeWithValues<Node, NodeValue, EdgeValue>, EdgeWithEdgeValue<Node, EdgeValue>> inverseSetEdges = new L1<EdgeWithValues<Node, NodeValue, EdgeValue>, EdgeWithEdgeValue<Node, EdgeValue>>() {
 115                 @Override
 116                 public EdgeWithValues<Node, NodeValue, EdgeValue> op(final EdgeWithEdgeValue<Node, EdgeValue> param) {
 117                         return new EdgeWithValues<Node, NodeValue, EdgeValue>() {
 118                                 @Override
 119                                 public java.util.Map.Entry<Node, NodeValue> getDestination() {
 120                                         return new AbstractMapEntry<Node, NodeValue>() {
 121                                                 @Override
 122                                                 public Node getKey() {
 123                                                         return getDestinationNode();
 124                                                 }
 125
 126                                                 @Override
 127                                                 public NodeValue getValue() {
 128                                                         return WrappedKeySet.this.wrappedGraph.get(this.getKey());
 129                                                 }
 130                                         };
 131                                 }
 132
 133                                 @Override
 134                                 public Node getDestinationNode() {
 135                                         return param.getDestinationNode();
 136                                 }
 137
 138                                 @Override
 139                                 public java.util.Map.Entry<Node, NodeValue> getSource() {
 140                                         return new AbstractMapEntry<Node, NodeValue>() {
 141                                                 @Override
 142                                                 public Node getKey() {
 143                                                         return getSourceNode();
 144                                                 }
 145
 146                                                 @Override
 147                                                 public NodeValue getValue() {
 148                                                         return WrappedKeySet.this.wrappedGraph.get(this.getKey());
 149                                                 }
 150                                         };
 151                                 }
 152
 153                                 @Override
 154                                 public Node getSourceNode() {
 155                                         return param.getSourceNode();
 156                                 }
 157
 158                                 @Override
 159                                 public EdgeValue getValue() {
 160                                         return param.getValue();
 161                                 }
 162
 163                                 public EdgeValue setValue(final EdgeValue newValue) {
 164                                         return param.setValue(newValue);
 165                                 }
 166                         };
 167                 }
 168         };
 169
 170         private final Set<EdgeWithEdgeValue<Node, EdgeValue>> edgesView = new SetView<EdgeWithValues<Node, NodeValue, EdgeValue>, EdgeWithEdgeValue<Node, EdgeValue>>(this.wrappedGraph.edges(), this.getSetEdges, this.inverseSetEdges);
 171
 172         @Override
 173         public Set<EdgeWithEdgeValue<Node, EdgeValue>> edges() {
 174                 return this.edgesView;
 175         }
 176
 177         @Override
 178         public Set<EdgeWithEdgeValue<Node, EdgeValue>> inEdges(final Node destination) {
 179                 return new SetView<EdgeWithValues<Node, NodeValue, EdgeValue>, EdgeWithEdgeValue<Node, EdgeValue>>(this.wrappedGraph.inEdges(destination), this.getSetEdges, this.inverseSetEdges);
 180         }
 181
 182         @Override
 183         public Set<EdgeWithEdgeValue<Node, EdgeValue>> outEdges(final Node source) {
 184                 return new SetView<EdgeWithValues<Node, NodeValue, EdgeValue>, EdgeWithEdgeValue<Node, EdgeValue>>(this.wrappedGraph.outEdges(source), this.getSetEdges, this.inverseSetEdges);
 185         }
 186
 187         /**
 188          * @see java.util.Set#clear()
 189          */
 190         @Override
 191         public void clear() {
 192                 this.wrappedGraph.clear();
 193         }
 194
 195         @Override
 196         public boolean contains(final Object o) {
 197                 return this.wrappedGraph.containsKey(o);
 198         }
 199
 200         @Override
 201         public boolean isEmpty() {
 202                 return this.wrappedGraph.isEmpty();
 203         }
 204
 205         private final L1<Node, Entry<Node, NodeValue>> getKey = Operations.getKey();
 206         private final Set<Node> entrySet = new SetView<Entry<Node, NodeValue>, Node>(this.wrappedGraph.entrySet(), this.getKey);
 207
 208         @Override
 209         public Iterator<Node> iterator() {
 210                 return this.entrySet.iterator();
 211         }
 212
 213         @Override
 214         public boolean remove(final Object o) {
 215                 return this.wrappedGraph.remove(o) != null;
 216         }
 217
 218         @Override
 219         public int size() {
 220                 return this.wrappedGraph.size();
 221         }
 222
 223         @Override
 224         public Object[] toArray() {
 225                 return this.entrySet.toArray();
 226         }
 227
 228         @Override
 229         public <T> T[] toArray(final T[] a) {
 230                 return this.entrySet.toArray(a);
 231         }
 232 }