Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.ir.util;
  
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.Set;

  
 public class Vertex<T> implements Comparable<Vertex<T>> {
     private DirectedGraph graph;
     private T data;
     private Set<Edge<T>> incoming = null;
     private Set<Edge<T>> outgoing = null;
     int id;
     
     public Vertex(DirectedGraph graph, T dataint id) {
         this. = graph;
         this. = data;
         this. = id;
     }
     
     public void addEdgeTo(Vertex destination) {
         addEdgeTo(destinationnull);
     }
 
     public void addEdgeTo(Vertex destinationObject type) {
         Edge edge = new Edge<T>(thisdestinationtype);
         getOutgoingEdges().add(edge);
         destination.getIncomingEdges().add(edge);
         .edges().add(edge);
     }
     
     public void addEdgeTo(T destination) {
         addEdgeTo(destinationnull);
     }    
     
     public void addEdgeTo(T destinationObject type) {
         Vertex destinationVertex = .vertexFor(destination);
         
         addEdgeTo(destinationVertextype);
     }
     
     public boolean removeEdgeTo(Vertex destination) {
         for (Edge edgegetOutgoingEdges()) {
             if (edge.getDestination() == destination) {
                 getOutgoingEdges().remove(edge);
                 edge.getDestination().getIncomingEdges().remove(edge);
                 .edges().remove(edge);
                 return true;
             }
         }
         
         return false;
     }
     
     public void removeAllIncomingEdges() {
         for (Edge edgegetIncomingEdges()) {
             edge.getSource().getOutgoingEdges().remove(edge);
             .edges().remove(edge);
         }
          = null;
     }
     
     public void removeAllOutgoingEdges() {
         for (Edge edgegetOutgoingEdges()) {
             edge.getDestination().getIncomingEdges().remove(edge);
             .edges().remove(edge);
         }
          = null;
     }
 
     public void removeAllEdges() {
         removeAllIncomingEdges();
         removeAllOutgoingEdges();
     }
 
     public int inDegree() {
         return ( == null) ? 0 : .size();
     }
 
     public int outDegree() {
         return ( == null) ? 0 : .size();
     }
     
     public Iterable<Edge<T>> getIncomingEdgesOfType(Object type) {
         return new EdgeTypeIterable<T>(getIncomingEdges(), type);
     }
 
     public Iterable<Edge<T>> getIncomingEdgesNotOfType(Object type) {
         return new EdgeTypeIterable<T>(getIncomingEdges(), typetrue);
     }
     
     public Iterable<Edge<T>> getOutgoingEdgesOfType(Object type) {
         return new EdgeTypeIterable<T>(getOutgoingEdges(), type);
     }
 
     public T getIncomingSourceData() {
         Edge<T> edge = getSingleEdge(getIncomingEdges().iterator(), "");
        
        return edge == null ? null : edge.getSource().getData();  
    }    
    
    public T getIncomingSourceDataOfType(Object type) {
        Edge<T> edge = getSingleEdge(getIncomingEdgesOfType(type).iterator(), type);
        
        return edge == null ? null : edge.getSource().getData();
    }    
    
    public Iterable<T> getIncomingSourcesData() {
        return new DataIterable<T>(getIncomingEdges(), nulltruetrue);
    }
    
    public Iterable<T> getIncomingSourcesDataOfType(Object type) {
        return new DataIterable<T>(getIncomingEdges(), typetruefalse);
    }      
    
    public Iterable<T> getIncomingSourcesDataNotOfType(Object type) {
        return new DataIterable<T>(getIncomingEdges(), typetruetrue);
    }      
        
    public Iterable<Edge<T>> getOutgoingEdgesNotOfType(Object type) {
        return new EdgeTypeIterable<T>(getOutgoingEdges(), typetrue);
    }
    
    public Iterable<T> getOutgoingDestinationsData() {
        return new DataIterable<T>(getOutgoingEdges(), nullfalsetrue);
    }
        return new DataIterable<T>(getOutgoingEdges(), typefalsefalse);
    }
    
        return new DataIterable<T>(getOutgoingEdges(), typefalsetrue);
    }
    public T getOutgoingDestinationData() {
        Edge<T> edge = getSingleEdge(getOutgoingEdges().iterator(), "");
        
        return edge == null ? null : edge.getDestination().getData();  
    }    
    
    public T getOutgoingDestinationDataOfType(Object type) {
        Edge<T> edge = getSingleEdge(getOutgoingEdgesOfType(type).iterator(), type);
        
        return edge == null ? null : edge.getDestination().getData();
    }
    
    private Edge<T> getSingleEdge(Iterator<Edge<T>> iteratorObject type) {
        if (iterator.hasNext()) {
            Edge<T> edge = iterator.next();
            
            assert !iterator.hasNext() : "Should only be one edge of type " + type;
            
            return edge;
        }
        
        return null;
    }
    
    public Edge<T> getIncomingEdgeOfType(Object type) {
        return getSingleEdge(getIncomingEdgesOfType(type).iterator(), type);
    }
    public Edge<T> getOutgoingEdgeOfType(Object type) {
        return getSingleEdge(getOutgoingEdgesOfType(type).iterator(), type);
    }
    
    
Get single incoming edge of any type and assert if there is more than one.
    public Edge<T> getIncomingEdge() {
        return getSingleEdge(getIncomingEdgesNotOfType(null).iterator(), null);
    }
    
    
Get single outgoing edge of any type and assert if there is more than one.
    public Edge<T> getOutgoingEdge() {
        return getSingleEdge(getOutgoingEdgesNotOfType(null).iterator(), null);
    }
    public Set<Edge<T>> getIncomingEdges() {
        if ( == null = new HashSet<Edge<T>>();
        
        return ;
    }
    
    public Set<Edge<T>> getOutgoingEdges() {
        if ( == null = new HashSet<Edge<T>>();
        
        return ;
    }    
    
    public T getData() {
        return ;
    }
    
    public int getID() {
        return  instanceof ExplicitVertexID ? ((ExplicitVertexID).getID() : ;
    }
    
    @Override
    public String toString() {
        boolean found = false;
        StringBuilder buf = new StringBuilder(.toString());
        buf.append(":");
        
        Set<Edge<T>> edges = getOutgoingEdges();
        int size = edges.size();
        
        if (size > 0) {
            found = true;
            buf.append(">[");
            Iterator<Edge<T>> iterator = edges.iterator();
            
            for (int i = 0; i < size - 1; i++) {
                buf.append(iterator.next().getDestination().getID()).append(",");
            }
            buf.append(iterator.next().getDestination().getID()).append("]");
        }
        edges = getIncomingEdges();
        size = edges.size();
        
        if (size > 0) {
            if (foundbuf.append(", ");
            buf.append("<[");            
            Iterator<Edge<T>> iterator = edges.iterator();
            for (int i = 0; i < size - 1; i++) {
                buf.append(iterator.next().getSource().getID()).append(",");
            }
            buf.append(iterator.next().getSource().getID()).append("]");
        }
        buf.append("\n");
        
        return buf.toString();
    }
    public int compareTo(Vertex<T> that) {
        if (getID() == that.getID()) return 0;
        if (getID() < that.getID()) return -1;
        return 1;
    }
New to GrepCode? Check out our FAQ X