001    package nl.tudelft.tbm.eeni.owl2java.model.jmodel;
002    
003    import org.apache.commons.logging.Log;
004    import org.apache.commons.logging.LogFactory;
005    import org.jgrapht.DirectedGraph;
006    import org.jgrapht.graph.DefaultDirectedGraph;
007    
008    import java.util.ArrayList;
009    import java.util.Iterator;
010    import java.util.List;
011    
012    public class JInheritanceGraph<V, E> extends DefaultDirectedGraph<V, E> implements DirectedGraph<V, E> {
013    
014        public JInheritanceGraph(Class<? extends E> edgeClass) {
015            super(edgeClass);
016        }
017    
018        @SuppressWarnings("unused")
019        private static Log log = LogFactory.getLog(JInheritanceGraph.class);
020        private static final long serialVersionUID = 3988427746724146370L;
021    
022        public void addParentVertex(V current, V neww) {
023            addVertex(neww);
024            addEdge(neww, current);
025    
026        }
027    
028        public void insertVertex(V source, V target, V neww) {
029            addVertex(neww);
030            removeEdge(source, target);
031            addEdge(source, neww);
032            addEdge(neww, target);
033        }
034    
035        public void addChildVertex(V current, V neww) {
036            addVertex(neww);
037            addEdge(current, neww);
038    
039        }
040    
041        public boolean hasDirectParent(V vertex, V parent) {
042            Iterator<E> edgeIt = incomingEdgesOf(vertex).iterator();
043            while (edgeIt.hasNext()) {
044                E edge = edgeIt.next();
045                V p = getEdgeSource(edge);
046    
047                if (p.equals(parent))
048                    return true;
049            }
050            return false;
051        }
052    
053        public boolean hasDirectChild(V vertex, V child) {
054            Iterator<E> edgeIt = outgoingEdgesOf(vertex).iterator();
055            while (edgeIt.hasNext()) {
056                E edge = edgeIt.next();
057                V c = getEdgeTarget(edge);
058    
059                if (c.equals(child))
060                    return true;
061            }
062            return false;
063        }
064    
065        public List<V> listDirectParents(V vertex) {
066            List<V> parents = new ArrayList<V>();
067            Iterator<E> edgeIt = incomingEdgesOf(vertex).iterator();
068            while (edgeIt.hasNext()) {
069                E edge = (E) edgeIt.next();
070                V parent = getEdgeSource(edge);
071                parents.add(parent);
072            }
073            return parents;
074        }
075    
076        public List<V> listDirectChildren(V vertex) {
077            List<V> children = new ArrayList<V>();
078            Iterator<E> edgeIt = outgoingEdgesOf(vertex).iterator();
079            while (edgeIt.hasNext()) {
080                E edge = (E) edgeIt.next();
081                V parent = getEdgeTarget(edge);
082                children.add(parent);
083            }
084            return children;
085        }
086    
087        public boolean hasParent(V vertex, V parent, boolean recursive) {
088            // simple case
089            if (recursive == false)
090                return hasDirectParent(vertex, parent);
091    
092            // recursive, yet direct parent
093            if (hasDirectParent(vertex, parent))
094                return true;
095    
096            // no direct parent -> call recursively
097            for (V v : listDirectParents(vertex)) {
098                boolean hasSC = hasParent(v, parent, recursive);
099                if (hasSC)
100                    return true;
101            }
102            return false;
103        }
104    
105        public boolean hasChild(V vertex, V child, boolean recursive) {
106            // simple case
107            if (recursive == false)
108                return hasDirectChild(vertex, child);
109    
110            // recursive, yet direct parent
111            if (hasDirectChild(vertex, child))
112                return true;
113    
114            // no direct parent -> call recursively
115            List<V> children = listDirectChildren(vertex);
116            for (V v : children) {
117                boolean hasSC = hasChild(v, child, recursive);
118                if (hasSC)
119                    return true;
120            }
121            return false;
122    
123        }
124    
125        public boolean hasAnyParents(V vertex) {
126            int parentCount = incomingEdgesOf(vertex).size();
127            if (parentCount > 0)
128                return true;
129            return false;
130        }
131    
132        public boolean hasAnyChildren(V vertex) {
133            int childCount = outgoingEdgesOf(vertex).size();
134            if (childCount > 0)
135                return true;
136            return false;
137    
138        }
139    }