GraphSearch.hh

Go to the documentation of this file.

#ifndef __DIADES__GRAPH__GRAPHSEARCH_HH_
#define __DIADES__GRAPH__GRAPHSEARCH_HH_



namespace Diades
{
  namespace Graph
  {



        template<typename TIncidentEdges,
                         typename TOpposite,
                         typename TContainer,
                         typename TAccumulator,
                         typename TMark,
                         typename TSolution,
                         typename TPathCut>
        class GraphSearch
        {
        public:
          
          typedef TContainer Container;
          typedef TAccumulator Accumulator;
          typedef TMark Mark;
          typedef TIncidentEdges IncidentEdges;
          typedef TOpposite Opposite;
          typedef TSolution Solution;
          typedef TPathCut PathCut;
          typedef typename IncidentEdges::Graph Graph;
          typedef typename IncidentEdges::Node Node;

          GraphSearch(Graph & graph, const Container & nodes,
                                  const Opposite & opposite, Solution & s,
                                  PathCut & cut, Accumulator & results):_updated(false),
                                                                                                                _m(graph),
                                                                                                                _graph(graph),
                                                                                                                _nodes(nodes),
                                                                                                                _opposite(opposite),
                                                                                                                _s(s),
                                                                                                                _cut(cut),
                                                                                                                _results(results){}

          virtual ~GraphSearch(){}


          const Accumulator & currentResults() 
          {
                _updated = false;
                return _results;
          }

\
          virtual void initialize()
          {
                _results.clear();
                _updated = false;
          }

          bool updated() const {return _updated; }


        protected:
          bool _updated;
          Mark _m;
          Graph & _graph;
          const Container & _nodes;
          const Opposite & _opposite;
          Solution & _s;
          PathCut & _cut;
          Accumulator & _results;
        };
  };
};

#endif