/*

     This file is part of Combean.

     Combean is free software; you can redistribute it and/or modify

     it under the terms of the GNU General Public License as published by

     the Free Software Foundation; either version 2 of the License, or

     (at your option) any later version.

     Combean is distributed in the hope that it will be useful,

     but WITHOUT ANY WARRANTY; without even the implied warranty of

     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

     GNU General Public License for more details.

     You should have received a copy of the GNU General Public License

     along with Combean; if not, write to the Free Software

     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

 /*

  * Created on 20.08.2005

  *

  */

 package net.sourceforge.combean.graph.alg.traversal;

 import net.sourceforge.combean.graph.alg.AbstractGraphAlg;

 import net.sourceforge.combean.graph.containers.statics.PathFromPredMapBuilder;

 import net.sourceforge.combean.interfaces.graph.Node;

 import net.sourceforge.combean.interfaces.graph.alg.traverse.GraphTraversalAlg;

 import net.sourceforge.combean.interfaces.graph.containers.FixedPath;

 import net.sourceforge.combean.interfaces.graph.prop.NeighborhoodGraphProp;

 import net.sourceforge.combean.util.except.IllegalParameterException;

 /**

  * @author schickin

  *

  */

 public class FindPathByTraversalAlg extends AbstractGraphAlg {

     NeighborhoodGraphProp neigh = null;

     private GraphTraversalAlg traversalAlg = null;

     private Node startNode = null;

     private Node targetNode = null;

     private boolean useOutgoingEdgesOnly = false;

     private ConstructPredMapVisitor predMapVisitor = null;

     /**

      * constructor

      */

     public FindPathByTraversalAlg() {

         super();

     }

     /* (non-Javadoc)

      * @see net.sourceforge.combean.interfaces.graph.alg.GraphAlgorithm#run()

      */

     public void run() {

         init();

         this.traversalAlg.run();

     }

     private void init() {

         if (this.traversalAlg == null) {

             this.traversalAlg = new BreadthFirstSearchImpl();

         }

         this.traversalAlg.setGraph(this.neigh);

         this.traversalAlg.setUseOnlyOutgoingEdges(this.useOutgoingEdgesOnly);

         if (this.startNode == null) {

             throw new IllegalParameterException("start node must be set");

         }

         this.traversalAlg.setLocalStartNode(this.startNode);

         this.predMapVisitor = new ConstructPredMapVisitor();

         if (this.targetNode != null) {

             this.predMapVisitor.setTarget(this.targetNode);

         }

         this.traversalAlg.setVisitor(this.predMapVisitor);

     }

     /**

      * @param traversalAlg The traversalAlg to set.

      */

     public final void setTraversalAlg(GraphTraversalAlg traversalAlg) {

         this.traversalAlg = traversalAlg;

     }

     /**

      * @param startNode The startNode to set.

      */

     public final void setStartNode(Node startNode) {

         this.startNode = startNode;

     }

     /**

      * @param targetNode The targetNode to set.

      */

     public final void setTargetNode(Node targetNode) {

         this.targetNode = targetNode;

     }

     /**

      * Return the path to t that has been found by the traversal algorithm

      * or null if the node is not reachable from the start node.

      * 

      * @param t the node to which the path shall be retrieved

      * @return the path to t

      */

     public FixedPath getPathTo(Node t) {

         FixedPath result =

             PathFromPredMapBuilder.buildPathFromPredMap(this.neigh,

                     this.predMapVisitor.getPredMap(), t);

         if (!result.getFirstNode().equals(this.startNode)) {

             return null;

         }

         return result;

     }

     /**

      * @param useOutgoingEdgesOnly The useOutgoingEdgesOnly to set.

      */

     public final void setUseOutgoingEdgesOnly(boolean useOutgoingEdgesOnly) {

         this.useOutgoingEdgesOnly = useOutgoingEdgesOnly;

     }

 }