TrustGrapher  r52
A playabale simulator for modelling trust between agents
D:/src/cu/trustGrapher/graphs/JungAdapterGraph.java
Go to the documentation of this file.
00001 package cu.trustGrapher.graphs;
00002 
00003 import java.util.Collection;
00004 import java.util.HashSet;
00005 import java.util.Iterator;
00006 import java.util.Set;
00007 
00008 import org.jgrapht.graph.SimpleDirectedGraph;
00009 
00010 import edu.uci.ics.jung.graph.util.EdgeType;
00011 import edu.uci.ics.jung.graph.util.Pair;
00012 
00013 
00014 public class JungAdapterGraph<V,E> implements edu.uci.ics.jung.graph.DirectedGraph<V,E>
00015 {
00016         
00020         protected SimpleDirectedGraph<V, E> g;
00021         
00022         public SimpleDirectedGraph<V,E> getInnerGraph(){
00023                 return g;
00024         }
00025 
00026         public JungAdapterGraph(SimpleDirectedGraph<V, E> g)
00027         {
00028                 this.g=g;
00029                 
00030         }
00031 
00032         @Override
00033         public boolean addEdge(E arg0, V arg1, V arg2)
00034         {
00035                 
00036                 return g.addEdge(arg1, arg2, arg0);
00037         }
00038 
00039         @Override
00040         public boolean addEdge(E arg0, V arg1, V arg2, EdgeType arg3)
00041         {
00042                 if (arg3.equals(EdgeType.UNDIRECTED))
00043                                 throw new IllegalArgumentException();
00044                 
00045                 return addEdge(arg0, arg1, arg2);
00046         }
00047 
00048         @Override
00049         public V getDest(E arg0)
00050         {
00051                 
00052                 return g.getEdgeTarget(arg0);
00053         }
00054 
00055         @Override
00056         public Pair<V> getEndpoints(E arg0)
00057         {
00058                 
00059                 return new Pair(g.getEdgeSource(arg0),g.getEdgeTarget(arg0));
00060         }
00061 
00062         @Override
00063         public Collection<E> getInEdges(V arg0)
00064         {
00065                 
00066                 return g.incomingEdgesOf(arg0);
00067         }
00068 
00069         @Override
00070         public V getOpposite(V arg0, E arg1)
00071         {
00072                 V first = g.getEdgeSource(arg1);
00073                 if (first.equals(arg0)){
00074                         return g.getEdgeTarget(arg1);
00075                 } else
00076                 return first;
00077         }
00078 
00079         @Override
00080         public Collection<E> getOutEdges(V arg0)
00081         {
00082                 
00083                 return g.outgoingEdgesOf(arg0);
00084         }
00085 
00086         @Override
00087         public int getPredecessorCount(V arg0)
00088         {
00089                 
00090                 
00091                 return getPredecessors(arg0).size();
00092         }
00093 
00094         @Override
00095         public Collection<V> getPredecessors(V arg0)
00096         {
00097                 Set<V> nodes= new HashSet<V>();
00098                 for(E edge:     g.incomingEdgesOf(arg0)){
00099                         nodes.add(g.getEdgeSource(edge));
00100                 }
00101                 return nodes;
00102         }
00103 
00104         @Override
00105         public V getSource(E arg0)
00106         {
00107                 
00108                 return g.getEdgeSource(arg0);
00109         }
00110 
00111         @Override
00112         public int getSuccessorCount(V arg0)
00113         {
00114                 
00115                 return getSuccessors(arg0).size();
00116         }
00117 
00118         @Override
00119         public Collection<V> getSuccessors(V arg0)
00120         {
00121 
00122                 Set<V> nodes= new HashSet<V>();
00123                 for(E edge:     g.outgoingEdgesOf(arg0)){
00124                         nodes.add(g.getEdgeTarget(edge));
00125                 }
00126                 return nodes;
00127         }
00128 
00129         @Override
00130         public int inDegree(V arg0)
00131         {
00132                 
00133                 return g.inDegreeOf(arg0);
00134         }
00135 
00136         @Override
00137         public boolean isDest(V arg0, E arg1)
00138         {
00139                 
00140                 return g.getEdgeTarget(arg1).equals(arg0);
00141         }
00142 
00143         @Override
00144         public boolean isPredecessor(V arg0, V arg1)
00145         {
00146                 
00147                 return (g.getEdge(arg0, arg1) != null);
00148         }
00149 
00150         @Override
00151         public boolean isSource(V arg0, E arg1)
00152         {
00153                 
00154                 return (g.getEdgeSource(arg1).equals(arg0));
00155         }
00156 
00157         @Override
00158         public boolean isSuccessor(V arg0, V arg1)
00159         {
00160                 
00161                 return (g.getEdge(arg1,arg0)!=null);
00162         }
00163 
00164         @Override
00165         public int outDegree(V arg0)
00166         {
00167 
00168                 return g.outDegreeOf(arg0);
00169         }
00170 
00171         @Override
00172         public boolean addEdge(E arg0, Collection<? extends V> arg1)
00173         {
00174 
00175                 if (arg1.size()!=2)
00176                         throw new IllegalArgumentException();
00177                 
00178                 Iterator<? extends V> it = arg1.iterator();
00179                 V v1 = it.next();
00180                 V v2 = it.next();
00181                 return g.addEdge(v1, v2, arg0);
00182         }
00183 
00184         @Override
00185         public boolean addEdge(E arg0, Collection<? extends V> arg1, EdgeType arg2)
00186         {
00187                 if (!arg2.equals(EdgeType.DIRECTED))
00188                         throw new IllegalArgumentException();
00189                 return addEdge(arg0,arg1);
00190         }
00191 
00192         @Override
00193         public boolean addVertex(V arg0)
00194         {
00195 
00196                 return g.addVertex(arg0);
00197         }
00198 
00199         @Override
00200         public boolean containsEdge(E arg0)
00201         {
00202 
00203                 return g.containsEdge(arg0);
00204         }
00205 
00206         @Override
00207         public boolean containsVertex(V arg0)
00208         {
00209                 
00210                 return g.containsVertex(arg0);
00211         }
00212 
00213         @Override
00214         public int degree(V arg0)
00215         {
00216 
00217                 return g.degreeOf(arg0);
00218         }
00219 
00220         @Override
00221         public E findEdge(V arg0, V arg1)
00222         {
00223 
00224                 return g.getEdge(arg0, arg1);
00225         }
00226 
00227         @Override
00228         public Collection<E> findEdgeSet(V arg0, V arg1)
00229         {
00230                 
00231                 return g.getAllEdges(arg0, arg1);
00232         }
00233 
00234         @Override
00235         public int getEdgeCount()
00236         {
00237                 
00238                 return g.edgeSet().size();
00239         }
00240 
00241         @Override
00242         public int getEdgeCount(EdgeType arg0)
00243         {
00244 
00245                 if (!arg0.equals(EdgeType.DIRECTED))
00246                         throw new IllegalArgumentException();
00247                 return g.edgeSet().size();
00248         }
00249 
00250         @Override
00251         public EdgeType getEdgeType(E arg0)
00252         {
00253                 
00254                 return EdgeType.DIRECTED;
00255         }
00256 
00257         @Override
00258         public Collection<E> getEdges()
00259         {
00260                 
00261                 return g.edgeSet();
00262         }
00263 
00264         @Override
00265         public Collection<E> getEdges(EdgeType arg0)
00266         {
00267                 if (!arg0.equals(EdgeType.DIRECTED))
00268                         throw new IllegalArgumentException();
00269                 return g.edgeSet();
00270         }
00271 
00272         @Override
00273         public int getIncidentCount(E arg0)
00274         {
00275                 if (g.getEdgeSource(arg0).equals(g.getEdgeTarget(arg0)))
00276                         return 1; // loop
00277                 else
00278                         return 2;
00279         }
00280 
00281         @Override
00282         public Collection<E> getIncidentEdges(V arg0)
00283         {
00284                 
00285                 return g.edgesOf(arg0);
00286         }
00287 
00288         @Override
00289         public Collection<V> getIncidentVertices(E arg0)
00290         {
00291 
00292                 return new Pair<V>(g.getEdgeSource(arg0), g.getEdgeTarget(arg0));
00293         }
00294 
00295         @Override
00296         public int getNeighborCount(V arg0)
00297         {
00298                 return getNeighbors(arg0).size();
00299         }
00300 
00301         @Override
00302         public Collection<V> getNeighbors(V arg0)
00303         {
00304                 Set<V> nodes= new HashSet<V>();
00305                 for(E edge:     g.outgoingEdgesOf(arg0)){
00306                         nodes.add(g.getEdgeTarget(edge));
00307                 }
00308                 for(E edge:     g.incomingEdgesOf(arg0)){
00309                         nodes.add(g.getEdgeTarget(edge));
00310                 }
00311                 return nodes;
00312         }
00313 
00314         @Override
00315         public int getVertexCount()
00316         {
00317 
00318                 return g.vertexSet().size();
00319         }
00320 
00321         @Override
00322         public Collection<V> getVertices()
00323         {
00324                 // TODO Auto-generated method stub
00325                 return g.vertexSet();
00326         }
00327 
00328         @Override
00329         public boolean isIncident(V arg0, E arg1)
00330         {
00331                 
00332                 return getIncidentEdges(arg0).contains(arg1);
00333         }
00334 
00335         @Override
00336         public boolean isNeighbor(V arg0, V arg1)
00337         {
00338                 
00339                 return (isPredecessor(arg0, arg1)||isSuccessor(arg0, arg1));
00340         }
00341 
00342         @Override
00343         public boolean removeEdge(E arg0)
00344         {
00345                 
00346                 return g.removeEdge(arg0);
00347         }
00348 
00349         @Override
00350         public boolean removeVertex(V arg0)
00351         {
00352 
00353                 return g.removeVertex(arg0);
00354         }
00355 
00356     public EdgeType getDefaultEdgeType() {
00357         return EdgeType.DIRECTED;
00358     }
00359 
00360 }