net.sf.javagimmicks.graph.AbstractGraph Maven / Gradle / Ivy

Go to download
package net.sf.javagimmicks.graph;

import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import net.sf.javagimmicks.collections.AbstractMap2;
import net.sf.javagimmicks.collections.transformer.Transformer;
import net.sf.javagimmicks.collections.transformer.TransformerUtils15;
import net.sf.javagimmicks.lang.Factory;
import net.sf.javagimmicks.lang.LangUtils;

public abstract class AbstractGraph> implements Graph 
{
   protected final Factory> _edgeSetFactory;
   
   protected AbstractGraph(Factory> edgeSetFactory)
   {
      _edgeSetFactory = edgeSetFactory;
   }

   public Map> edgeMap()
   {
      return new EdgeMap();
   }

   public boolean addVertex(V vertex)
   {
      throw new UnsupportedOperationException();
   }

   public E addEdge(V source, V target)
   {
      throw new UnsupportedOperationException();
   }

   public Set addEdges(V source, Collection targets)
   {
      final Set result = createEdgeSet();
      
      for(V target : targets)
      {
         final E edge = addEdge(source, target);
         result.add(edge);
      }
      
      return result;
   }

   public boolean containsVertex(V vertex)
   {
      return vertexSet().contains(vertex);
   }

   public Set targetsOf(V source)
   {
      return TransformerUtils15.decorate(edgesOf(source), new EdgeToTargetTransformer(source));
   }

   public Set getEdges(V source, V target)
   {
      final Set result = createEdgeSet();
      for(E edge : edgesOf(source))
      {
         final V currentTarget = edge.getOutgoingVertex(source);
         
         if(LangUtils.equalsNullSafe(target, currentTarget))
         {
            result.add(edge);
         }
      }
      
      return result;
   }

   public E getEdge(V source, V target)
   {
      for(E edge : edgesOf(source))
      {
         final V currentTarget = edge.getOutgoingVertex(source);
         
         if(LangUtils.equalsNullSafe(target, currentTarget))
         {
            return edge;
         }
      }
      
      return null;
   }
   
   public boolean isConnected(V source, V target)
   {
      return getEdge(source, target) != null;
   }

   public Set removeEdges(V source, V target)
   {
      final Set result = createEdgeSet();
      
      for(Iterator edges = edgesOf(source).iterator(); edges.hasNext();)
      {
         final E edge = edges.next();
         
         final V currentTarget = edge.getOutgoingVertex(source);
         
         if(LangUtils.equalsNullSafe(target, currentTarget))
         {
            edges.remove();
            
            result.add(edge);
         }
      }
      
      return result;
   }

   public E removeEdge(V source, V target)
   {
      for(Iterator edges = edgesOf(source).iterator(); edges.hasNext();)
      {
         final E edge = edges.next();
         
         final V currentTarget = edge.getOutgoingVertex(source);
         
         if(target == null)
         {
            if(currentTarget == null)
            {
               edges.remove();
               return edge;
            }
         }
         else if(target.equals(currentTarget))
         {
            edges.remove();
            return edge;
         }
      }
      
      return null;
   }

   public Set removeEdges(V source, Collection targets)
   {
      final Set result = createEdgeSet();
      
      for(Iterator edges = edgesOf(source).iterator(); edges.hasNext();)
      {
         final E edge = edges.next();
         
         if(targets.contains(edge.getOutgoingVertex(source)))
         {
            edges.remove();
            result.add(edge);
         }
      }
      
      return result;
   }

   public Set removeVertex(V vertex)
   {
      return edgeMap().remove(vertex);
   }
   
   protected Set createEdgeSet()
   {
      return _edgeSetFactory.create();
   }
   
   protected class EdgeMap extends AbstractMap2>
   {
      @Override
      public Set keySet()
      {
         return vertexSet();
      }

      @Override
      protected Set getValue(V key)
      {
         return edgesOf(key);
      }
   }

   protected static class EdgeToTargetTransformer, V> implements Transformer
   {
      protected final V _source;

      public EdgeToTargetTransformer(V source)
      {
         _source = source;
      }

      public V transform(E edge)
      {
         return edge.getOutgoingVertex(_source);
      }
   }
}