jgraphmodeladapter.java

来自「JAVA图论的算法包。用过觉得还不错」· Java 代码 · 共 1,149 行 · 第 1/3 页

    {
        jCellsBeingAdded.add(cell);
        insert(new Object[] { cell }, attrs, cs, null, null);
        jCellsBeingAdded.remove(cell);
    }

    /**
     * Removed the specified cell from the JGraph graph model.
     *
     * @param cell
     */
    private void internalRemoveCell(GraphCell cell)
    {
        jCellsBeingRemoved.add(cell);
        remove(new Object[] { cell });
        jCellsBeingRemoved.remove(cell);
    }

    //~ Inner Interfaces -------------------------------------------------------

    /**
     * Creates the JGraph cells that reflect the respective JGraphT elements.
     *
     * @author Barak Naveh
     * @since Dec 12, 2003
     */
    public static interface CellFactory<VV, EE>
    {
        /**
         * Creates an edge cell that contains its respective JGraphT edge.
         *
         * @param jGraphTEdge a JGraphT edge to be contained.
         *
         * @return an edge cell that contains its respective JGraphT edge.
         */
        public DefaultEdge createEdgeCell(EE jGraphTEdge);

        /**
         * Creates a vertex cell that contains its respective JGraphT vertex.
         *
         * @param jGraphTVertex a JGraphT vertex to be contained.
         *
         * @return a vertex cell that contains its respective JGraphT vertex.
         */
        public DefaultGraphCell createVertexCell(VV jGraphTVertex);
    }

    //~ Inner Classes ----------------------------------------------------------

    /**
     * A simple default cell factory.
     *
     * @author Barak Naveh
     * @since Dec 12, 2003
     */
    public static class DefaultCellFactory<VV, EE>
        implements CellFactory<VV, EE>,
            Serializable
    {
        private static final long serialVersionUID = 3690194343461861173L;

        /**
         * @see JGraphModelAdapter.CellFactory#createEdgeCell(Object)
         */
        public DefaultEdge createEdgeCell(EE jGraphTEdge)
        {
            return new DefaultEdge(jGraphTEdge);
        }

        /**
         * @see JGraphModelAdapter.CellFactory#createVertexCell(Object)
         */
        public DefaultGraphCell createVertexCell(VV jGraphTVertex)
        {
            return new DefaultGraphCell(jGraphTVertex);
        }
    }

    /**
     * <p>Inner class listening to the GraphModel. If something is changed in
     * the GraphModel, this Listener gets notified and propagates the change
     * back to the JGraphT graph, if it didn't originate there.</p>
     *
     * <p>If this change contains changes that would make this an illegal
     * JGraphT graph, like adding an edge that is incident with only one vertex,
     * the illegal parts of the change are undone.</p>
     */
    private class JGraphListener
        implements GraphModelListener,
            Serializable
    {
        private static final long serialVersionUID = 3544673988098865209L;

        /**
         * This method is called for all JGraph changes.
         *
         * @param e
         */
        public void graphChanged(GraphModelEvent e)
        {
            // We first remove edges that have to be removed, then we
            // remove vertices, then we add vertices and finally we add
            // edges. Otherwise, things might go wrong: for example, if we
            // would first remove vertices and then edges, removal of the
            // vertices might induce 'automatic' removal of edges. If we
            // later attempt to re-remove these edges, we get confused.
            GraphModelChange change = e.getChange();

            Object [] removedCells = change.getRemoved();

            if (removedCells != null) {
                handleRemovedEdges(filterEdges(removedCells));
                handleRemovedVertices(filterVertices(removedCells));
            }

            Object [] insertedCells = change.getInserted();

            if (insertedCells != null) {
                handleInsertedVertices(filterVertices(insertedCells));
                handleInsertedEdges(filterEdges(insertedCells));
            }

            // Now handle edges that became 'dangling' or became connected.
            Object [] changedCells = change.getChanged();

            if (changedCells != null) {
                handleChangedEdges(filterEdges(changedCells));
            }
        }

        /**
         * Filters a list of edges out of an array of JGraph GraphCell objects.
         * Other objects are thrown away.
         *
         * @param cells Array of cells to be filtered.
         *
         * @return a list of edges.
         */
        private List<Object> filterEdges(Object [] cells)
        {
            List<Object> jEdges = new ArrayList<Object>();

            for (int i = 0; i < cells.length; i++) {
                if (cells[i] instanceof org.jgraph.graph.Edge) {
                    jEdges.add(cells[i]);
                }
            }

            return jEdges;
        }

        /**
         * Filters a list of vertices out of an array of JGraph GraphCell
         * objects. Other objects are thrown away.
         *
         * @param cells Array of cells to be filtered.
         *
         * @return a list of vertices.
         */
        private List<Object> filterVertices(Object [] cells)
        {
            List<Object> jVertices = new ArrayList<Object>();

            for (int i = 0; i < cells.length; i++) {
                Object cell = cells[i];

                if (cell instanceof org.jgraph.graph.Edge) {
                    // ignore -- we don't care about edges.
                } else if (cell instanceof Port) {
                    // ignore -- we don't care about ports.
                } else if (cell instanceof DefaultGraphCell) {
                    DefaultGraphCell graphCell = (DefaultGraphCell) cell;

                    // If a DefaultGraphCell has a Port as a child, it is a
                    // vertex.
                    // Note: do not change the order of following conditions;
                    // the code uses the short-circuit evaluation of ||.
                    if (graphCell.isLeaf()
                        || (graphCell.getFirstChild() instanceof Port))
                    {
                        jVertices.add(cell);
                    }
                } else if (cell instanceof GraphCell) {
                    // If it is not a DefaultGraphCell, it doesn't have
                    // children.
                    jVertices.add(cell);
                }
            }

            return jVertices;
        }

        private void handleChangedEdges(List<Object> jEdges)
        {
            for (Iterator<Object> i = jEdges.iterator(); i.hasNext();) {
                org.jgraph.graph.Edge jEdge = (org.jgraph.graph.Edge) i.next();

                handleJGraphChangedEdge(jEdge);
            }
        }

        private void handleInsertedEdges(List<Object> jEdges)
        {
            for (Iterator<Object> i = jEdges.iterator(); i.hasNext();) {
                org.jgraph.graph.Edge jEdge = (org.jgraph.graph.Edge) i.next();

                if (!jCellsBeingAdded.remove(jEdge)) {
                    handleJGraphInsertedEdge(jEdge);
                }
            }
        }

        private void handleInsertedVertices(List<Object> jVertices)
        {
            for (Iterator<Object> i = jVertices.iterator(); i.hasNext();) {
                GraphCell jVertex = (GraphCell) i.next();

                if (!jCellsBeingAdded.remove(jVertex)) {
                    handleJGraphInsertedVertex(jVertex);
                }
            }
        }

        private void handleRemovedEdges(List<Object> jEdges)
        {
            for (Iterator<Object> i = jEdges.iterator(); i.hasNext();) {
                org.jgraph.graph.Edge jEdge = (org.jgraph.graph.Edge) i.next();

                if (!jCellsBeingRemoved.remove(jEdge)) {
                    handleJGraphRemovedEdge(jEdge);
                }
            }
        }

        private void handleRemovedVertices(List<Object> jVertices)
        {
            for (Iterator<Object> i = jVertices.iterator(); i.hasNext();) {
                GraphCell jVertex = (GraphCell) i.next();

                if (!jCellsBeingRemoved.remove(jVertex)) {
                    handleJGraphRemovedVertex(jVertex);
                }
            }
        }
    }

    /**
     * A listener on the underlying JGraphT graph. This listener is used to keep
     * the JGraph model in sync. Whenever one of the event handlers is called,
     * it first checks whether the change is due to a previous change in the
     * JGraph model. If it is, then no action is taken.
     *
     * @author Barak Naveh
     * @since Aug 2, 2003
     */
    private class JGraphTListener
        implements GraphListener<V, E>,
            Serializable
    {
        private static final long serialVersionUID = 3616724963609360440L;

        /**
         * @see GraphListener#edgeAdded(GraphEdgeChangeEvent)
         */
        public void edgeAdded(GraphEdgeChangeEvent<V, E> e)
        {
            E jtEdge = e.getEdge();

            if (!jtElementsBeingAdded.remove(jtEdge)) {
                handleJGraphTAddedEdge(jtEdge);
            }
        }

        /**
         * @see GraphListener#edgeRemoved(GraphEdgeChangeEvent)
         */
        public void edgeRemoved(GraphEdgeChangeEvent<V, E> e)
        {
            E jtEdge = e.getEdge();

            if (!jtElementsBeingRemoved.remove(jtEdge)) {
                handleJGraphTRemovedEdge(jtEdge);
            }
        }

        /**
         * @see VertexSetListener#vertexAdded(GraphVertexChangeEvent)
         */
        public void vertexAdded(GraphVertexChangeEvent<V> e)
        {
            V jtVertex = e.getVertex();

            if (!jtElementsBeingAdded.remove(jtVertex)) {
                handleJGraphTAddedVertex(jtVertex);
            }
        }

        /**
         * @see VertexSetListener#vertexRemoved(GraphVertexChangeEvent)
         */
        public void vertexRemoved(GraphVertexChangeEvent<V> e)
        {
            V jtVertex = e.getVertex();

            if (!jtElementsBeingRemoved.remove(jtVertex)) {
                handleJGraphTRemoveVertex(jtVertex);
            }
        }
    }

    /**
     * A wrapper around a JGraphT graph that ensures a few atomic operations.
     */
    private class ShieldedGraph
    {
        private final Graph<V, E> graph;

        ShieldedGraph(Graph<V, E> graph)
        {
            this.graph = graph;
        }

        EdgeFactory<V, E> getEdgeFactory()
        {
            return graph.getEdgeFactory();
        }

        E addEdge(V jtSource, V jtTarget)
        {
            E jtEdge = graph.getEdgeFactory().createEdge(jtSource, jtTarget);
            jtElementsBeingAdded.add(jtEdge);

            boolean added = graph.addEdge(jtSource, jtTarget, jtEdge);
            jtElementsBeingAdded.remove(jtEdge);

            return added ? jtEdge : null;
        }

        V getEdgeSource(E e)
        {
            return graph.getEdgeSource(e);
        }

        V getEdgeTarget(E e)
        {
            return graph.getEdgeTarget(e);
        }

        void addVertex(V jtVertex)
        {
            jtElementsBeingAdded.add(jtVertex);
            graph.addVertex(jtVertex);
            jtElementsBeingAdded.remove(jtVertex);
        }

        Set<E> edgesOf(V vertex)
        {
            return graph.edgesOf(vertex);
        }

        boolean removeAllEdges(Collection<E> edges)
        {
            return graph.removeAllEdges(edges);
        }

        void removeEdge(E jtEdge)
        {
            jtElementsBeingRemoved.add(jtEdge);
            graph.removeEdge(jtEdge);
            jtElementsBeingRemoved.remove(jtEdge);
        }

        void removeVertex(V jtVertex)
        {
            jtElementsBeingRemoved.add(jtVertex);
            graph.removeVertex(jtVertex);
            jtElementsBeingRemoved.remove(jtVertex);
        }
    }
}

// End JGraphModelAdapter.java