[graphl-cvs] graphl/src/org/mediavirus/graphl/graph/filter XPathFilteredGraph.java NodeCompressionFilter.java XPathFilter.java FilteredGraph.java

[Flo L. <fl...@us...>]

Update of /cvsroot/graphl/graphl/src/org/mediavirus/graphl/graph/filter
In directory sc8-pr-cvs2.sourceforge.net:/tmp/cvs-serv15693/src/org/mediavirus/graphl/graph/filter

Modified Files:
	FilteredGraph.java 
Added Files:
	XPathFilteredGraph.java NodeCompressionFilter.java 
	XPathFilter.java 
Log Message:
implementing XPath-based filters

Index: FilteredGraph.java
===================================================================
RCS file: /cvsroot/graphl/graphl/src/org/mediavirus/graphl/graph/filter/FilteredGraph.java,v
retrieving revision 1.6
retrieving revision 1.7
diff -C2 -d -r1.6 -r1.7
*** FilteredGraph.java	8 Jun 2006 13:14:59 -0000	1.6
--- FilteredGraph.java	3 Jul 2006 15:26:33 -0000	1.7
***************
*** 14,17 ****
--- 14,18 ----
  import org.mediavirus.graphl.graph.Edge;
  import org.mediavirus.graphl.graph.Graph;
+ import org.mediavirus.graphl.graph.GraphElement;
  import org.mediavirus.graphl.graph.GraphListener;
  import org.mediavirus.graphl.graph.Node;
***************
*** 33,37 ****
  	
  	public FilteredGraph(Graph graph) {
! 		setSource(graph);
  	}
  	
--- 34,39 ----
  	
  	public FilteredGraph(Graph graph) {
!         sourceGraph = graph;
!         graph.addGraphListener(this);
  	}
  	
***************
*** 79,83 ****
  	}
  	
! 	public void update() {
  		cachedEdges.clear();
  		cachedNodes.clear();
--- 81,85 ----
  	}
  	
! 	public synchronized void update() {
  		cachedEdges.clear();
  		cachedNodes.clear();
***************
*** 119,123 ****
  	 * @param edges
  	 */
! 	private Collection<Edge> filterEdges(Collection<Edge> edges) {
  		if (edges != null) {
  			List<Edge> filteredEdges = new ArrayList<Edge>();
--- 121,125 ----
  	 * @param edges
  	 */
! 	protected Collection<Edge> filterEdges(Collection<Edge> edges) {
  		if (edges != null) {
  			List<Edge> filteredEdges = new ArrayList<Edge>();
***************
*** 136,140 ****
  	 * @param nodes
  	 */
! 	private Collection<Node> filterNodes(Collection<Node> nodes) {
  		if (nodes != null) {
  			List<Node> filteredNodes = new ArrayList<Node>();
--- 138,142 ----
  	 * @param nodes
  	 */
! 	protected Collection<Node> filterNodes(Collection<Node> nodes) {
  		if (nodes != null) {
  			List<Node> filteredNodes = new ArrayList<Node>();
***************
*** 245,253 ****
  
      public void addElements(Collection<Node> nodes, Collection<Edge> edges) {
          sourceGraph.addElements(nodes, edges);
      }
  
!     public void deleteElements(Collection<Node> nodes, Collection<Edge> edges) {
!         sourceGraph.deleteElements(nodes, edges);
      }
  
--- 247,257 ----
  
      public void addElements(Collection<Node> nodes, Collection<Edge> edges) {
+         cachedNodes.addAll(nodes);
+         cachedEdges.addAll(edges);
          sourceGraph.addElements(nodes, edges);
      }
  
!     public void removeElements(Collection<? extends GraphElement> elements) {
!         sourceGraph.removeElements(elements);
      }
  

--- NEW FILE: NodeCompressionFilter.java ---
/*
 * Created on 03.07.2006
 */

package org.mediavirus.graphl.graph.filter;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.jaxen.JaxenException;
import org.jaxen.XPath;
import org.mediavirus.graphl.graph.DefaultEdge;
import org.mediavirus.graphl.graph.DefaultNode;
import org.mediavirus.graphl.graph.Edge;
import org.mediavirus.graphl.graph.GraphElement;
import org.mediavirus.graphl.graph.Node;


public class NodeCompressionFilter {

    XPath selector;
    XPath groupBy;
    String newType;
    
    public NodeCompressionFilter(XPath selector, XPath groupBy, String newType) {
        this.selector = selector;
        this.groupBy = groupBy;
        this.newType = newType;
    }
    
    public XPath getGroupBy() {
        return groupBy;
    }
    
    public String getNewType() {
        return newType;
    }
    
    public XPath getSelector() {
        return selector;
    }
    
    public void filterGraph(XPathFilteredGraph graph) {
        try {
            Object elements = selector.evaluate(graph);
            if (elements instanceof List && ((List)elements).size() > 1) {
                // this maps groupBy results and a list of nodes who share them
                Map<Set, List<Node>> groups = new HashMap<Set, List<Node>>();
                for (Node node : (List<Node>)elements) {
                    Object groupElements = groupBy.evaluate(node);
                    Set nodeSet;
                    if (groupElements instanceof List) {
                        nodeSet = new HashSet((List)groupElements);
                    }
                    else {
                        nodeSet = Collections.singleton(groupElements);
                    }
                    
                    if (groups.get(nodeSet) == null) {
                        groups.put(nodeSet, new ArrayList<Node>());
                    }
                    groups.get(nodeSet).add(node);
                }
                List<Node> newNodes = new ArrayList<Node>();
                List<Edge> newEdges = new ArrayList<Edge>();
                for (List<Node> group : groups.values()) {
                    Node groupNode = graph.getSource().createNode();
                    newNodes.add(groupNode);
                    groupNode.setType(newType);
                    for (Node oldNode: group) {
                        for (Edge oldEdge : oldNode.getEdgesFrom()) {
                            Edge newEdge = graph.getSource().createEdge(groupNode, oldEdge.getTo());
                            newEdge.setType(oldEdge.getType());
                            newEdges.add(newEdge);
                        }
                        for (Edge oldEdge : oldNode.getEdgesTo()) {
                            Edge newEdge = graph.getSource().createEdge(oldEdge.getFrom(), groupNode);
                            newEdge.setType(oldEdge.getType());
                            newEdges.add(newEdge);
                        }
                    }
                }
                graph.removeElements((Collection<? extends GraphElement>) elements);
                graph.addElements(newNodes, newEdges);
            }
        }
        catch (JaxenException jexdasdu) {
            System.err.println("Error evaluation XPath " + selector.toString() + " on graph: " + jexdasdu);
        }
    }
    
    
}

--- NEW FILE: XPathFilteredGraph.java ---
/*
 * Created on 03.07.2006
 */

package org.mediavirus.graphl.graph.filter;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import javax.swing.SwingUtilities;

import org.jaxen.XPath;
import org.mediavirus.graphl.graph.Edge;
import org.mediavirus.graphl.graph.Graph;
import org.mediavirus.graphl.graph.GraphListener;
import org.mediavirus.graphl.graph.Node;


public class XPathFilteredGraph extends FilteredGraph implements GraphListener {

    List<XPathFilter> omissionFilters = new ArrayList<XPathFilter>();
    List<NodeCompressionFilter> nodeCompressionFilters = new ArrayList<NodeCompressionFilter>();
    
    List<Node> overlayNodes = new ArrayList<Node>();
    List<Edge> overlayEdges = new ArrayList<Edge>();
    
    public XPathFilteredGraph(Graph graph) {
        super(graph);
        omissionFilters = new ArrayList<XPathFilter>();
    }
    
    public void addOmissionFilter(XPathFilter filter) {
        omissionFilters.add(filter);
    }
    
    public void addNodeCompressionFilter(NodeCompressionFilter filter) {
        nodeCompressionFilters.add(filter);
    }
    
    public void addEdgeCompressionFilter(XPath selector, String newType) {
        
    }
    
    public void addTransitiveCompressionFilter(XPath selector, String newType) {
        
    }
    
    public synchronized void update() {
        // this is super.update() without notify
        cachedEdges.clear();
        cachedNodes.clear();
        overlayNodes.clear();
        overlayEdges.clear();
        
        Collection<Edge> filteredEdges = filterEdges(sourceGraph.getEdges());
        if (filteredEdges != null) cachedEdges.addAll(filteredEdges);
        
        Collection<Node> filteredNodes = filterNodes(sourceGraph.getNodes());
        if (filteredNodes != null) cachedNodes.addAll(filteredNodes);
        //
        
        //cachedEdges = new ArrayList<Edge>(sourceGraph.getEdges());
        //cachedNodes = new ArrayList<Node>(sourceGraph.getNodes());
        
        for (XPathFilter filter : omissionFilters) {
            filter.filterGraph(this);            
        }
        for (NodeCompressionFilter filter : nodeCompressionFilters) {
            filter.filterGraph(this);            
        }
        
        fireGraphContentsChanged();     
    }
    
    public void overlayElements(Collection<Node> nodes, Collection<Edge> edges) {
        overlayNodes.addAll(nodes);
        overlayEdges.addAll(edges);
        
        fireElementsAdded(nodes, edges);
    }

    @Override
    public List<Edge> getEdges() {
        if (overlayEdges.size()>0) {
            List<Edge> all = new ArrayList(super.getEdges());
            all.addAll(overlayEdges);
            return all;
        }
        else {
            return super.getEdges();
        }
    }

    @Override
    public List<Edge> getEdgesWithPropertyValue(String name, String value) {
        //todo
        return super.getEdgesWithPropertyValue(name, value);
    }

    @Override
    public Node getNodeOrAdd(String id) {
        //todo
        return super.getNodeOrAdd(id);
    }

    @Override
    public List<Node> getNodes() {
        if (overlayNodes.size()>0) {
            List<Node> all = new ArrayList(super.getNodes());
            all.addAll(overlayNodes);
            return all;
        }
        else {
            return super.getNodes();
        }
    }


}

--- NEW FILE: XPathFilter.java ---
/*
 * Created on 03.07.2006
 */

package org.mediavirus.graphl.graph.filter;

import java.util.Collection;
import java.util.Collections;
import java.util.List;

import org.jaxen.JaxenException;
import org.jaxen.XPath;
import org.mediavirus.graphl.graph.GraphElement;

public class XPathFilter {

    XPath filterExpression;
    
    public XPathFilter(XPath filterExpression) {
        this.filterExpression = filterExpression;
    }
   
    public XPath getFilterExpression() {
        return filterExpression;
    }

    public void filterGraph(XPathFilteredGraph graph) {
        try {
            Object elements = filterExpression.evaluate(graph);
            if (elements != null) {
                if (elements instanceof List) {
                    graph.removeElements((Collection<? extends GraphElement>) elements);
                }
                else if (elements instanceof GraphElement) {
                    graph.removeElements(Collections.singleton((GraphElement)elements));
                }
            }
        }
        catch (JaxenException jexdasdu) {
            System.err.println("Error evaluation XPath " + filterExpression.toString() + " on graph: " + jexdasdu);
        }
    }

}