LEMON/LEMON-official Changeset - r260:c691064dfd4f

Repositories » LEMON » LEMON-official

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r260:c691064dfd4f

« 258:0310c8
« 259:362415

278:931190 »
272:e63a95 »
263:be8a86 »
262:0181b7 »
261:1c2ac7 »

r260:c691064dfd4f

Thu, 11 Sep 2008 12:10:44

[Not Reviewed]

0 comments (0 inline)

alpar (Alpar Juttner)
alpar@cs.elte.hu

Merge

0 5 0

merge default

0 files changed with 132 insertions and 133 deletions:

lemon/bfs.h

lemon/bits/base_extender.h

lemon/dfs.h

lemon/dijkstra.h

test/heap_test.cc

↑ Collapse diff ↑

lemon/bfs.h

Show inline comments

@@ -227,100 +227,99 @@
 		    ///\name Named template parameters
 		    ///@{
 		    template <class T>
-		    struct DefPredMapTraits : public Traits {
+		    struct SetPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\ref PredMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\ref PredMap type.
 		    template <class T>
 		    struct DefPredMap : public Bfs< Digraph, DefPredMapTraits<T> > {
 		      typedef Bfs< Digraph, DefPredMapTraits<T> > Create;
 		    struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > {
 		      typedef Bfs< Digraph, SetPredMapTraits<T> > Create;
 		    };
 		    template <class T>
-		    struct DefDistMapTraits : public Traits {
+		    struct SetDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\ref DistMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\ref DistMap type.
 		    template <class T>
 		    struct DefDistMap : public Bfs< Digraph, DefDistMapTraits<T> > {
 		      typedef Bfs< Digraph, DefDistMapTraits<T> > Create;
 		    struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > {
 		      typedef Bfs< Digraph, SetDistMapTraits<T> > Create;
 		    };
 		    template <class T>
-		    struct DefReachedMapTraits : public Traits {
+		    struct SetReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\ref ReachedMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\ref ReachedMap type.
 		    template <class T>
 		    struct DefReachedMap : public Bfs< Digraph, DefReachedMapTraits<T> > {
 		      typedef Bfs< Digraph, DefReachedMapTraits<T> > Create;
 		    struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
 		      typedef Bfs< Digraph, SetReachedMapTraits<T> > Create;
 		    };
 		    template <class T>
-		    struct DefProcessedMapTraits : public Traits {
+		    struct SetProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\ref ProcessedMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\ref ProcessedMap type.
 		    template <class T>
 		    struct DefProcessedMap : public Bfs< Digraph, DefProcessedMapTraits<T> > {
 		      typedef Bfs< Digraph, DefProcessedMapTraits<T> > Create;
 		    struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > {
 		      typedef Bfs< Digraph, SetProcessedMapTraits<T> > Create;
 		    };
-		    struct DefDigraphProcessedMapTraits : public Traits {
+		    struct SetStandardProcessedMapTraits : public Traits {
 		      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &g)
+		      {
 		        return new ProcessedMap(g);
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///If you don't set it explicitly, it will be automatically allocated.
 		    template <class T>
 		    struct DefProcessedMapToBeDefaultMap :
 		      public Bfs< Digraph, DefDigraphProcessedMapTraits> {
 		      typedef Bfs< Digraph, DefDigraphProcessedMapTraits> Create;
 		    struct SetStandardProcessedMap :
 		      public Bfs< Digraph, SetStandardProcessedMapTraits > {
 		      typedef Bfs< Digraph, SetStandardProcessedMapTraits > Create;
 		    };
 		    ///@}
 		  public:
@@ -1062,81 +1061,81 @@
+		    {
 		      Base::_source=s;
 		      return *this;
+		    }
 		    template<class T>
-		    struct DefPredMapBase : public Base {
+		    struct SetPredMapBase : public Base {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &) { return 0; };
-		      DefPredMapBase(const TR &b) : TR(b) {}
+		      SetPredMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///for setting \ref PredMap object.
 		    ///
 		    /// \ref named-templ-param "Named parameter"
 		    ///for setting \ref PredMap object.
 		    template<class T>
-		    BfsWizard<DefPredMapBase<T> > predMap(const T &t)
+		    BfsWizard<SetPredMapBase<T> > predMap(const T &t)
+		    {
 		      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
-		      return BfsWizard<DefPredMapBase<T> >(*this);
+		      return BfsWizard<SetPredMapBase<T> >(*this);
+		    }
 		    template<class T>
-		    struct DefReachedMapBase : public Base {
+		    struct SetReachedMapBase : public Base {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &) { return 0; };
-		      DefReachedMapBase(const TR &b) : TR(b) {}
+		      SetReachedMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///for setting \ref ReachedMap object.
 		    ///
 		    /// \ref named-templ-param "Named parameter"
 		    ///for setting \ref ReachedMap object.
 		    template<class T>
-		    BfsWizard<DefReachedMapBase<T> > reachedMap(const T &t)
+		    BfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
+		    {
 		      Base::_reached=reinterpret_cast<void*>(const_cast<T*>(&t));
-		      return BfsWizard<DefReachedMapBase<T> >(*this);
+		      return BfsWizard<SetReachedMapBase<T> >(*this);
+		    }
 		    template<class T>
-		    struct DefProcessedMapBase : public Base {
+		    struct SetProcessedMapBase : public Base {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
-		      DefProcessedMapBase(const TR &b) : TR(b) {}
+		      SetProcessedMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///for setting \ref ProcessedMap object.
 		    ///
 		    /// \ref named-templ-param "Named parameter"
 		    ///for setting \ref ProcessedMap object.
 		    template<class T>
-		    BfsWizard<DefProcessedMapBase<T> > processedMap(const T &t)
+		    BfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
+		    {
 		      Base::_processed=reinterpret_cast<void*>(const_cast<T*>(&t));
-		      return BfsWizard<DefProcessedMapBase<T> >(*this);
+		      return BfsWizard<SetProcessedMapBase<T> >(*this);
+		    }
 		    template<class T>
-		    struct DefDistMapBase : public Base {
+		    struct SetDistMapBase : public Base {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &) { return 0; };
-		      DefDistMapBase(const TR &b) : TR(b) {}
+		      SetDistMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///for setting \ref DistMap object.
 		    ///
 		    /// \ref named-templ-param "Named parameter"
 		    ///for setting \ref DistMap object.
 		    template<class T>
-		    BfsWizard<DefDistMapBase<T> > distMap(const T &t)
+		    BfsWizard<SetDistMapBase<T> > distMap(const T &t)
+		    {
 		      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
-		      return BfsWizard<DefDistMapBase<T> >(*this);
+		      return BfsWizard<SetDistMapBase<T> >(*this);
+		    }
 		  };
 		  ///Function type interface for Bfs algorithm.
@@ -1351,26 +1350,26 @@
 		    typedef BfsVisit Create;
 		    /// \name Named template parameters
 		    ///@{
 		    template <class T>
-		    struct DefReachedMapTraits : public Traits {
+		    struct SetReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &digraph) {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// ReachedMap type.
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting ReachedMap type.
 		    template <class T>
 		    struct DefReachedMap : public BfsVisit< Digraph, Visitor,
 		                                            DefReachedMapTraits<T> > {
-		      typedef BfsVisit< Digraph, Visitor, DefReachedMapTraits<T> > Create;
+		    struct SetReachedMap : public BfsVisit< Digraph, Visitor,
 		                                            SetReachedMapTraits<T> > {
 		      typedef BfsVisit< Digraph, Visitor, SetReachedMapTraits<T> > Create;
 		    };
 		    ///@}
 		  public:
 		    /// \brief Constructor.

lemon/bits/base_extender.h

Show inline comments

@@ -56,13 +56,13 @@
 		      Arc(const Edge &ue, bool _forward) :
 		        Edge(ue), forward(_forward) {}
 		    public:
 		      Arc() {}
-		      /// Invalid arc constructor
 		      // Invalid arc constructor
 		      Arc(Invalid i) : Edge(i), forward(true) {}
 		      bool operator==(const Arc &that) const {
 		        return forward==that.forward && Edge(*this)==Edge(that);
+		      }
 		      bool operator!=(const Arc &that) const {
@@ -71,44 +71,47 @@
 		      bool operator<(const Arc &that) const {
 		        return forward<that.forward ||
 		          (!(that.forward<forward) && Edge(*this)<Edge(that));
+		      }
 		    };
 		    /// First node of the edge
 		    Node u(const Edge &e) const {
 		      return Parent::source(e);
+		    }
 		    using Parent::source;
 		    /// Source of the given Arc.
 		    /// Source of the given arc
 		    Node source(const Arc &e) const {
 		      return e.forward ? Parent::source(e) : Parent::target(e);
+		    }
-		    using Parent::target;
+		    /// Second node of the edge
 		    Node v(const Edge &e) const {
 		      return Parent::target(e);
+		    }
-		    /// Target of the given Arc.
+		    /// Target of the given arc
 		    Node target(const Arc &e) const {
 		      return e.forward ? Parent::target(e) : Parent::source(e);
+		    }
 		    /// \brief Directed arc from an edge.
 		    ///
 		    /// Returns a directed arc corresponding to the specified Edge.
 		    /// If the given bool is true the given edge and the
 		    /// returned arc have the same source node.
 		    static Arc direct(const Edge &ue, bool d) {
-		      return Arc(ue, d);
+		    /// Returns a directed arc corresponding to the specified edge.
 		    /// If the given bool is true, the first node of the given edge and
 		    /// the source node of the returned arc are the same.
 		    static Arc direct(const Edge &e, bool d) {
 		      return Arc(e, d);
+		    }
 		    /// Returns whether the given directed arc is same orientation as the
 		    /// corresponding edge.
 		    /// Returns whether the given directed arc has the same orientation
 		    /// as the corresponding edge.
 		    ///
 		    /// \todo reference to the corresponding point of the undirected digraph
 		    /// concept. "What does the direction of an edge mean?"
 		    static bool direction(const Arc &e) { return e.forward; }
 		    static bool direction(const Arc &a) { return a.forward; }
 		    using Parent::first;
 		    using Parent::next;
 		    void first(Arc &e) const {
 		      Parent::first(e);
@@ -226,13 +229,12 @@
+		    }
 		    int maxEdgeId() const {
 		      return Parent::maxArcId();
+		    }
 		    int arcNum() const {
 		      return 2 * Parent::arcNum();
+		    }
 		    int edgeNum() const {
 		      return Parent::arcNum();

lemon/dfs.h

Show inline comments

@@ -227,100 +227,99 @@
 		    ///\name Named template parameters
 		    ///@{
 		    template <class T>
-		    struct DefPredMapTraits : public Traits {
+		    struct SetPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\ref PredMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\ref PredMap type.
 		    template <class T>
 		    struct DefPredMap : public Dfs<Digraph, DefPredMapTraits<T> > {
 		      typedef Dfs<Digraph, DefPredMapTraits<T> > Create;
 		    struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > {
 		      typedef Dfs<Digraph, SetPredMapTraits<T> > Create;
 		    };
 		    template <class T>
-		    struct DefDistMapTraits : public Traits {
+		    struct SetDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\ref DistMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\ref DistMap type.
 		    template <class T>
 		    struct DefDistMap : public Dfs< Digraph, DefDistMapTraits<T> > {
 		      typedef Dfs<Digraph, DefDistMapTraits<T> > Create;
 		    struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > {
 		      typedef Dfs<Digraph, SetDistMapTraits<T> > Create;
 		    };
 		    template <class T>
-		    struct DefReachedMapTraits : public Traits {
+		    struct SetReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\ref ReachedMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\ref ReachedMap type.
 		    template <class T>
 		    struct DefReachedMap : public Dfs< Digraph, DefReachedMapTraits<T> > {
 		      typedef Dfs< Digraph, DefReachedMapTraits<T> > Create;
 		    struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
 		      typedef Dfs< Digraph, SetReachedMapTraits<T> > Create;
 		    };
 		    template <class T>
-		    struct DefProcessedMapTraits : public Traits {
+		    struct SetProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\ref ProcessedMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\ref ProcessedMap type.
 		    template <class T>
 		    struct DefProcessedMap : public Dfs< Digraph, DefProcessedMapTraits<T> > {
 		      typedef Dfs< Digraph, DefProcessedMapTraits<T> > Create;
 		    struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > {
 		      typedef Dfs< Digraph, SetProcessedMapTraits<T> > Create;
 		    };
-		    struct DefDigraphProcessedMapTraits : public Traits {
+		    struct SetStandardProcessedMapTraits : public Traits {
 		      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &g)
+		      {
 		        return new ProcessedMap(g);
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///If you don't set it explicitly, it will be automatically allocated.
 		    template <class T>
 		    struct DefProcessedMapToBeDefaultMap :
 		      public Dfs< Digraph, DefDigraphProcessedMapTraits> {
 		      typedef Dfs< Digraph, DefDigraphProcessedMapTraits> Create;
 		    struct SetStandardProcessedMap :
 		      public Dfs< Digraph, SetStandardProcessedMapTraits > {
 		      typedef Dfs< Digraph, SetStandardProcessedMapTraits > Create;
 		    };
 		    ///@}
 		  public:
@@ -997,81 +996,81 @@
+		    {
 		      Base::_source=s;
 		      return *this;
+		    }
 		    template<class T>
-		    struct DefPredMapBase : public Base {
+		    struct SetPredMapBase : public Base {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &) { return 0; };
-		      DefPredMapBase(const TR &b) : TR(b) {}
+		      SetPredMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///for setting \ref PredMap object.
 		    ///
 		    ///\ref named-templ-param "Named parameter"
 		    ///for setting \ref PredMap object.
 		    template<class T>
-		    DfsWizard<DefPredMapBase<T> > predMap(const T &t)
+		    DfsWizard<SetPredMapBase<T> > predMap(const T &t)
+		    {
 		      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
-		      return DfsWizard<DefPredMapBase<T> >(*this);
+		      return DfsWizard<SetPredMapBase<T> >(*this);
+		    }
 		    template<class T>
-		    struct DefReachedMapBase : public Base {
+		    struct SetReachedMapBase : public Base {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &) { return 0; };
-		      DefReachedMapBase(const TR &b) : TR(b) {}
+		      SetReachedMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///for setting \ref ReachedMap object.
 		    ///
 		    /// \ref named-templ-param "Named parameter"
 		    ///for setting \ref ReachedMap object.
 		    template<class T>
-		    DfsWizard<DefReachedMapBase<T> > reachedMap(const T &t)
+		    DfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
+		    {
 		      Base::_reached=reinterpret_cast<void*>(const_cast<T*>(&t));
-		      return DfsWizard<DefReachedMapBase<T> >(*this);
+		      return DfsWizard<SetReachedMapBase<T> >(*this);
+		    }
 		    template<class T>
-		    struct DefProcessedMapBase : public Base {
+		    struct SetProcessedMapBase : public Base {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
-		      DefProcessedMapBase(const TR &b) : TR(b) {}
+		      SetProcessedMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///for setting \ref ProcessedMap object.
 		    ///
 		    /// \ref named-templ-param "Named parameter"
 		    ///for setting \ref ProcessedMap object.
 		    template<class T>
-		    DfsWizard<DefProcessedMapBase<T> > processedMap(const T &t)
+		    DfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
+		    {
 		      Base::_processed=reinterpret_cast<void*>(const_cast<T*>(&t));
-		      return DfsWizard<DefProcessedMapBase<T> >(*this);
+		      return DfsWizard<SetProcessedMapBase<T> >(*this);
+		    }
 		    template<class T>
-		    struct DefDistMapBase : public Base {
+		    struct SetDistMapBase : public Base {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &) { return 0; };
-		      DefDistMapBase(const TR &b) : TR(b) {}
+		      SetDistMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///for setting \ref DistMap object.
 		    ///
 		    ///\ref named-templ-param "Named parameter"
 		    ///for setting \ref DistMap object.
 		    template<class T>
-		    DfsWizard<DefDistMapBase<T> > distMap(const T &t)
+		    DfsWizard<SetDistMapBase<T> > distMap(const T &t)
+		    {
 		      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
-		      return DfsWizard<DefDistMapBase<T> >(*this);
+		      return DfsWizard<SetDistMapBase<T> >(*this);
+		    }
 		  };
 		  ///Function type interface for Dfs algorithm.
@@ -1298,26 +1297,26 @@
 		    typedef DfsVisit Create;
 		    /// \name Named template parameters
 		    ///@{
 		    template <class T>
-		    struct DefReachedMapTraits : public Traits {
+		    struct SetReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &digraph) {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// ReachedMap type.
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting ReachedMap type.
 		    template <class T>
 		    struct DefReachedMap : public DfsVisit< Digraph, Visitor,
 		                                            DefReachedMapTraits<T> > {
-		      typedef DfsVisit< Digraph, Visitor, DefReachedMapTraits<T> > Create;
+		    struct SetReachedMap : public DfsVisit< Digraph, Visitor,
 		                                            SetReachedMapTraits<T> > {
 		      typedef DfsVisit< Digraph, Visitor, SetReachedMapTraits<T> > Create;
 		    };
 		    ///@}
 		  public:
 		    /// \brief Constructor.

lemon/dijkstra.h

Show inline comments

@@ -328,90 +328,89 @@
 		    ///\name Named template parameters
 		    ///@{
 		    template <class T>
-		    struct DefPredMapTraits : public Traits {
+		    struct SetPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\ref PredMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\ref PredMap type.
 		    template <class T>
 		    struct DefPredMap
 		      : public Dijkstra< Digraph, LengthMap, DefPredMapTraits<T> > {
-		      typedef Dijkstra< Digraph, LengthMap, DefPredMapTraits<T> > Create;
+		    struct SetPredMap
 		      : public Dijkstra< Digraph, LengthMap, SetPredMapTraits<T> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetPredMapTraits<T> > Create;
 		    };
 		    template <class T>
-		    struct DefDistMapTraits : public Traits {
+		    struct SetDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\ref DistMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\ref DistMap type.
 		    template <class T>
 		    struct DefDistMap
 		      : public Dijkstra< Digraph, LengthMap, DefDistMapTraits<T> > {
-		      typedef Dijkstra< Digraph, LengthMap, DefDistMapTraits<T> > Create;
+		    struct SetDistMap
 		      : public Dijkstra< Digraph, LengthMap, SetDistMapTraits<T> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetDistMapTraits<T> > Create;
 		    };
 		    template <class T>
-		    struct DefProcessedMapTraits : public Traits {
+		    struct SetProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &)
+		      {
 		        throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\ref ProcessedMap type.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\ref ProcessedMap type.
 		    template <class T>
 		    struct DefProcessedMap
 		      : public Dijkstra< Digraph, LengthMap, DefProcessedMapTraits<T> > {
-		      typedef Dijkstra< Digraph, LengthMap, DefProcessedMapTraits<T> > Create;
+		    struct SetProcessedMap
 		      : public Dijkstra< Digraph, LengthMap, SetProcessedMapTraits<T> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetProcessedMapTraits<T> > Create;
 		    };
-		    struct DefDigraphProcessedMapTraits : public Traits {
+		    struct SetStandardProcessedMapTraits : public Traits {
 		      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &g)
+		      {
 		        return new ProcessedMap(g);
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\ref ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
 		    ///If you don't set it explicitly, it will be automatically allocated.
 		    template <class T>
 		    struct DefProcessedMapToBeDefaultMap
 		      : public Dijkstra< Digraph, LengthMap, DefDigraphProcessedMapTraits> {
 		      typedef Dijkstra< Digraph, LengthMap, DefDigraphProcessedMapTraits>
 		    struct SetStandardProcessedMap
 		      : public Dijkstra< Digraph, LengthMap, SetStandardProcessedMapTraits > {
 		      typedef Dijkstra< Digraph, LengthMap, SetStandardProcessedMapTraits >
 		      Create;
 		    };
 		    template <class H, class CR>
-		    struct DefHeapTraits : public Traits {
+		    struct SetHeapTraits : public Traits {
 		      typedef CR HeapCrossRef;
 		      typedef H Heap;
 		      static HeapCrossRef *createHeapCrossRef(const Digraph &) {
 		        throw UninitializedParameter();
+		      }
 		      static Heap *createHeap(HeapCrossRef &)
@@ -422,19 +421,19 @@
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///heap and cross reference type
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting heap and cross
 		    ///reference type.
 		    template <class H, class CR = typename Digraph::template NodeMap<int> >
 		    struct DefHeap
 		      : public Dijkstra< Digraph, LengthMap, DefHeapTraits<H, CR> > {
-		      typedef Dijkstra< Digraph, LengthMap, DefHeapTraits<H, CR> > Create;
+		    struct SetHeap
 		      : public Dijkstra< Digraph, LengthMap, SetHeapTraits<H, CR> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetHeapTraits<H, CR> > Create;
 		    };
 		    template <class H, class CR>
-		    struct DefStandardHeapTraits : public Traits {
+		    struct SetStandardHeapTraits : public Traits {
 		      typedef CR HeapCrossRef;
 		      typedef H Heap;
 		      static HeapCrossRef *createHeapCrossRef(const Digraph &G) {
 		        return new HeapCrossRef(G);
+		      }
 		      static Heap *createHeap(HeapCrossRef &R)
@@ -447,32 +446,32 @@
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting heap and cross
 		    ///reference type. It can allocate the heap and the cross reference
 		    ///object if the cross reference's constructor waits for the digraph as
 		    ///parameter and the heap's constructor waits for the cross reference.
 		    template <class H, class CR = typename Digraph::template NodeMap<int> >
 		    struct DefStandardHeap
 		      : public Dijkstra< Digraph, LengthMap, DefStandardHeapTraits<H, CR> > {
-		      typedef Dijkstra< Digraph, LengthMap, DefStandardHeapTraits<H, CR> >
+		    struct SetStandardHeap
 		      : public Dijkstra< Digraph, LengthMap, SetStandardHeapTraits<H, CR> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetStandardHeapTraits<H, CR> >
 		      Create;
 		    };
 		    template <class T>
-		    struct DefOperationTraitsTraits : public Traits {
+		    struct SetOperationTraitsTraits : public Traits {
 		      typedef T OperationTraits;
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    ///\ref OperationTraits type
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting
 		    ///\ref OperationTraits type.
 		    template <class T>
 		    struct DefOperationTraits
 		      : public Dijkstra<Digraph, LengthMap, DefOperationTraitsTraits<T> > {
-		      typedef Dijkstra<Digraph, LengthMap, DefOperationTraitsTraits<T> >
+		    struct SetOperationTraits
 		      : public Dijkstra<Digraph, LengthMap, SetOperationTraitsTraits<T> > {
 		      typedef Dijkstra<Digraph, LengthMap, SetOperationTraitsTraits<T> >
 		      Create;
 		    };
 		    ///@}
 		  protected:
@@ -1202,63 +1201,63 @@
+		    {
 		      Base::_source=s;
 		      return *this;
+		    }
 		    template<class T>
-		    struct DefPredMapBase : public Base {
+		    struct SetPredMapBase : public Base {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &) { return 0; };
-		      DefPredMapBase(const TR &b) : TR(b) {}
+		      SetPredMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///for setting \ref PredMap object.
 		    ///
 		    ///\ref named-templ-param "Named parameter"
 		    ///for setting \ref PredMap object.
 		    template<class T>
-		    DijkstraWizard<DefPredMapBase<T> > predMap(const T &t)
+		    DijkstraWizard<SetPredMapBase<T> > predMap(const T &t)
+		    {
 		      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
-		      return DijkstraWizard<DefPredMapBase<T> >(*this);
+		      return DijkstraWizard<SetPredMapBase<T> >(*this);
+		    }
 		    template<class T>
-		    struct DefProcessedMapBase : public Base {
+		    struct SetProcessedMapBase : public Base {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
-		      DefProcessedMapBase(const TR &b) : TR(b) {}
+		      SetProcessedMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///for setting \ref ProcessedMap object.
 		    ///
 		    /// \ref named-templ-param "Named parameter"
 		    ///for setting \ref ProcessedMap object.
 		    template<class T>
-		    DijkstraWizard<DefProcessedMapBase<T> > processedMap(const T &t)
+		    DijkstraWizard<SetProcessedMapBase<T> > processedMap(const T &t)
+		    {
 		      Base::_processed=reinterpret_cast<void*>(const_cast<T*>(&t));
-		      return DijkstraWizard<DefProcessedMapBase<T> >(*this);
+		      return DijkstraWizard<SetProcessedMapBase<T> >(*this);
+		    }
 		    template<class T>
-		    struct DefDistMapBase : public Base {
+		    struct SetDistMapBase : public Base {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &) { return 0; };
-		      DefDistMapBase(const TR &b) : TR(b) {}
+		      SetDistMapBase(const TR &b) : TR(b) {}
 		    };
 		    ///\brief \ref named-templ-param "Named parameter"
 		    ///for setting \ref DistMap object.
 		    ///
 		    ///\ref named-templ-param "Named parameter"
 		    ///for setting \ref DistMap object.
 		    template<class T>
-		    DijkstraWizard<DefDistMapBase<T> > distMap(const T &t)
+		    DijkstraWizard<SetDistMapBase<T> > distMap(const T &t)
+		    {
 		      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
-		      return DijkstraWizard<DefDistMapBase<T> >(*this);
+		      return DijkstraWizard<SetDistMapBase<T> >(*this);
+		    }
 		  };
 		  ///Function type interface for Dijkstra algorithm.

test/heap_test.cc

Show inline comments

@@ -128,13 +128,13 @@
 		template <typename Heap>
 		void dijkstraHeapTest(const Digraph& digraph, const IntArcMap& length,
 		                      Node source) {
-		  typename Dijkstra<Digraph, IntArcMap>::template DefStandardHeap<Heap>::
+		  typename Dijkstra<Digraph, IntArcMap>::template SetStandardHeap<Heap>::
 		    Create dijkstra(digraph, length);
 		  dijkstra.run(source);
 		  for(ArcIt a(digraph); a != INVALID; ++a) {
 		    Node s = digraph.source(a);

0 comments (0 inline)

RhodeCode

Login to your account