RhodeCode

///\ingroup search

///\file

///\brief BFS algorithm.

#include <lemon/list_graph.h>

#include <lemon/bits/path_dump.h>

#include <lemon/core.h>

#include <lemon/error.h>

#include <lemon/maps.h>

#include <lemon/path.h>

namespace lemon {

  ///Default traits class of Bfs class.

  ///Default traits class of Bfs class.

  ///\tparam GR Digraph type.

  template<class GR>

  struct BfsDefaultTraits

  {

    ///The type of the digraph the algorithm runs on.

    typedef GR Digraph;

    ///\brief The type of the map that stores the predecessor

    ///arcs of the shortest paths.

    ///

    ///The type of the map that stores the predecessor

    ///arcs of the shortest paths.

    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.

    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;

    ///Instantiates a PredMap.

    ///\param g is the digraph, to which we would like to define the

    ///PredMap.

    static PredMap *createPredMap(const Digraph &g)

    {

      return new PredMap(g);

    }

    ///The type of the map that indicates which nodes are processed.

    ///The type of the map that indicates which nodes are processed.

    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.

    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;

    ///Instantiates a ProcessedMap.

    ///This function instantiates a ProcessedMap.

    ///\param g is the digraph, to which

    ///we would like to define the ProcessedMap

#ifdef DOXYGEN

    static ProcessedMap *createProcessedMap(const Digraph &g)

#else

    static ProcessedMap *createProcessedMap(const Digraph &)

#endif

    {

      return new ProcessedMap();

    }

    ///The type of the map that indicates which nodes are reached.

    typedef typename Digraph::template NodeMap<bool> ReachedMap;

    ///Instantiates a ReachedMap.

    ///This function instantiates a ReachedMap.

    ///\param g is the digraph, to which

    ///we would like to define the ReachedMap.

    static ReachedMap *createReachedMap(const Digraph &g)

    {

      return new ReachedMap(g);

    }

    ///The type of the map that stores the distances of the nodes.

    ///The type of the map that stores the distances of the nodes.

    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.

    typedef typename Digraph::template NodeMap<int> DistMap;

    ///Instantiates a DistMap.

    ///This function instantiates a DistMap.

    ///\param g is the digraph, to which we would like to define the

    ///DistMap.

    static DistMap *createDistMap(const Digraph &g)

    {

      return new DistMap(g);

    }

  };

  ///%BFS algorithm class.

  ///\ingroup search

  ///This class provides an efficient implementation of the %BFS algorithm.

  ///

    public:

      Node() {}

      Node (Invalid) { id = -1; }

      bool operator==(const Node& node) const {return id == node.id;}

      bool operator!=(const Node& node) const {return id != node.id;}

      bool operator<(const Node& node) const {return id < node.id;}

    };

    class Edge {

      friend class ListGraphBase;

    protected:

      int id;

      explicit Edge(int pid) { id = pid;}

    public:

      Edge() {}

      Edge (Invalid) { id = -1; }

      bool operator==(const Edge& edge) const {return id == edge.id;}

      bool operator!=(const Edge& edge) const {return id != edge.id;}

      bool operator<(const Edge& edge) const {return id < edge.id;}

    };

    class Arc {

      friend class ListGraphBase;

    protected:

      int id;

      explicit Arc(int pid) { id = pid;}

    public:

      }

      Arc() {}

      Arc (Invalid) { id = -1; }

      bool operator==(const Arc& arc) const {return id == arc.id;}

      bool operator!=(const Arc& arc) const {return id != arc.id;}

      bool operator<(const Arc& arc) const {return id < arc.id;}

    };

    ListGraphBase()

      : nodes(), first_node(-1),

        first_free_node(-1), arcs(), first_free_arc(-1) {}

    int maxNodeId() const { return nodes.size()-1; }

    int maxEdgeId() const { return arcs.size() / 2 - 1; }

    int maxArcId() const { return arcs.size()-1; }

    Node source(Arc e) const { return Node(arcs[e.id ^ 1].target); }

    Node target(Arc e) const { return Node(arcs[e.id].target); }

    Node u(Edge e) const { return Node(arcs[2 * e.id].target); }

    Node v(Edge e) const { return Node(arcs[2 * e.id + 1].target); }

    static bool direction(Arc e) {

      return (e.id & 1) == 1;

    }

    static Arc direct(Edge e, bool d) {

      return Arc(e.id * 2 + (d ? 1 : 0));

    public:

      Node() {}

      Node (Invalid) { _id = -1; }

      bool operator==(const Node& node) const {return _id == node._id;}

      bool operator!=(const Node& node) const {return _id != node._id;}

      bool operator<(const Node& node) const {return _id < node._id;}

    };

    class Edge {

      friend class SmartGraphBase;

    protected:

      int _id;

      explicit Edge(int id) { _id = id;}

    public:

      Edge() {}

      Edge (Invalid) { _id = -1; }

      bool operator==(const Edge& arc) const {return _id == arc._id;}

      bool operator!=(const Edge& arc) const {return _id != arc._id;}

      bool operator<(const Edge& arc) const {return _id < arc._id;}

    };

    class Arc {

      friend class SmartGraphBase;

    protected:

      int _id;

      explicit Arc(int id) { _id = id;}

    public:

      }

      Arc() {}

      Arc (Invalid) { _id = -1; }

      bool operator==(const Arc& arc) const {return _id == arc._id;}

      bool operator!=(const Arc& arc) const {return _id != arc._id;}

      bool operator<(const Arc& arc) const {return _id < arc._id;}

    };

    SmartGraphBase()

      : nodes(), arcs() {}

    int maxNodeId() const { return nodes.size()-1; }

    int maxEdgeId() const { return arcs.size() / 2 - 1; }

    int maxArcId() const { return arcs.size()-1; }

    Node source(Arc e) const { return Node(arcs[e._id ^ 1].target); }

    Node target(Arc e) const { return Node(arcs[e._id].target); }

    Node u(Edge e) const { return Node(arcs[2 * e._id].target); }

    Node v(Edge e) const { return Node(arcs[2 * e._id + 1].target); }

    static bool direction(Arc e) {

      return (e._id & 1) == 1;

    }

    static Arc direct(Edge e, bool d) {

      return Arc(e._id * 2 + (d ? 1 : 0));

    }

function update_init() {

    echo Update source files...

    TOTAL_FILES=0

    CHANGED_FILES=0

    WARNED_FILES=0

}

function update_done() {

    echo $CHANGED_FILES out of $TOTAL_FILES files has been changed.

    echo $WARNED_FILES out of $TOTAL_FILES files triggered warnings.

}

function update_begin() {

    ((TOTAL_FILES++))

    CHANGED=NO

    WARNED=NO

}

function update_end() {

    if [ $CHANGED == YES ]

    then

	((++CHANGED_FILES))

    fi

    if [ $WARNED == YES ]

    then

	((++WARNED_FILES))

    fi

}

function check_action() {

    if ! diff -q $1 $2 >/dev/null

    then

	FAILED=YES

    fi

}

function check_warning() {

    WARNED=YES

}

function check_init() {

    echo Check source files...

    FAILED_FILES=0

    WARNED_FILES=0

    TOTAL_FILES=0

}

function check_done() {

    echo $FAILED_FILES out of $TOTAL_FILES files has been failed.

    echo $WARNED_FILES out of $TOTAL_FILES files triggered warnings.

    if [ $FAILED_FILES -gt 0 ]

    then

	return 1

    elif [ $WARNED_FILES -gt 0 ]

    then

	if [ "$WARNING" == 'INTERACTIVE' ]

	then

	    echo -n "Are the files with warnings acceptable? (yes/no) "

	    while read answer

	    do

		if [ "$answer" == 'yes' ]

		then

		    return 0

		elif [ "$answer" == 'no' ]

		then

		    return 1

		fi

		echo -n "Are the files with warnings acceptable? (yes/no) "

 */

"

    awk 'BEGIN { pm=0; }

     pm==3 { print }

     /\/\* / && pm==0 { pm=1;}

     /[^:blank:]/ && (pm==0 || pm==2) { pm=3; print;}

     /\*\// && pm==1 { pm=2;}

    ' $1

    ) >$TMP_FILE

    "$ACTION"_action "$TMP_FILE" "$1" header

}

function tabs_check() {

    if echo $1 | grep -q -v -E 'Makefile\.am$'

    then

        OLD_PATTERN=$(echo -e '\t')

        NEW_PATTERN='        '

    else

        OLD_PATTERN='        '

        NEW_PATTERN=$(echo -e '\t')

    fi

    TMP_FILE=`mktemp`

    cat $1 | sed -e "s/$OLD_PATTERN/$NEW_PATTERN/g" >$TMP_FILE

    "$ACTION"_action "$TMP_FILE" "$1" 'tabs'

}

function spaces_check() {

    TMP_FILE=`mktemp`

    cat $1 | sed -e 's/ \+$//g' >$TMP_FILE

}

function long_lines_check() {

    if cat $1 | grep -q -E '.{81,}'

    then

	"$ACTION"_warning $1 'long lines'

    fi

}

# process the file

function process_file() {

    CHECKING="header tabs spaces long_lines"

    "$ACTION"_begin $1

    for check in $CHECKING

    do

	"$check"_check $1

    done

    "$ACTION"_end $1

    echo

}

function process_all {

    "$ACTION"_init

    while read file

    do

	process_file $file

    done < <($FILES)

    "$ACTION"_done

}

while [ $# -gt 0 ]

do

    if [ "$1" == '--help' ] || [ "$1" == '-h' ]

    then

	echo -n \

"Usage:

  $0 [OPTIONS] [files]

Options:

  --dry-run|-n

     Check the files, but do not modify them.

  --interactive|-i

     If --dry-run is specified and the checker emits warnings,

     then the user is asked if the warnings should be considered

     errors.

  --werror|-w

     Make all warnings into errors.

  --all|-a

  --modified|-m

     Check only the modified (and new) source files. This option is

     useful to check the modification before making a commit.

  --changed|-c

     Check only the changed source files compared to the parent(s) of

     the current hg node.  This option is useful as hg hook script.

     To automatically check all your changes before making a commit,

     add the following section to the appropriate .hg/hgrc file.

       [hooks]

       pretxncommit.checksources = scripts/unify-sources.sh -c -n -i

  --help|-h

     Print this help message.

  files

"

        exit 0

    elif [ "$1" == '--dry-run' ] || [ "$1" == '-n' ]

    then

	ACTION=check

    elif [ "$1" == "--all" ] || [ "$1" == '-a' ]

    then

	FILES=all_files

    elif [ "$1" == "--changed" ] || [ "$1" == '-c' ]

    then

	FILES=changed_files

    elif [ "$1" == "--modified" ] || [ "$1" == '-m' ]

    then

	FILES=modified_files

    elif [ "$1" == "--interactive" ] || [ "$1" == "-i" ]

    then

	WARNING='INTERACTIVE'

    elif [ "$1" == "--werror" ] || [ "$1" == "-w" ]

    then

	WARNING='WERROR'

    then

	echo "Invalid option $1" >&2 && exit 1

    else

	[ -n "$FILES" ] && echo "Invalid option $1" >&2 && exit 1

	GIVEN_FILES=$@

	FILES=given_files

	break

    fi

    shift

done

if [ -z $FILES ]

then

    FILES=modified_files

fi

if [ -z $ACTION ]

then

    ACTION=update

fi

process_all