LEMON/LEMON-official Changeset - r290:f6899946c1ac

Repositories » LEMON » LEMON-official

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

Changeset - r290:f6899946c1ac

« 287:bb40b6

291:d90132 »

r290:f6899946c1ac

Tue, 30 Sep 2008 20:53:18

[Not Reviewed]

0 comments (0 inline)

deba@inf.elte.hu
deba@inf.elte.hu

Simplifying exceptions - Using asserts instead of exceptions for unitialized parameters - Only the IO exceptions are used in the lemon - DataFormatError is renamed to FormatError - The IoError is used for file access errors

0 11 0

default

11 files changed with 380 insertions and 511 deletions:

demo/lgf_demo.cc

lemon/arg_parser.h

lemon/assert.h

lemon/bfs.h

lemon/concepts/heap.h

lemon/dfs.h

lemon/dijkstra.h

lemon/error.h

198

340

lemon/graph_to_eps.h

lemon/lgf_reader.h

112

lemon/lgf_writer.h

↑ Collapse diff ↑

demo/lgf_demo.cc

Show inline comments

@@ -40,25 +40,25 @@
 		int main() {
 		  SmartDigraph g;
 		  SmartDigraph::ArcMap<int> cap(g);
 		  SmartDigraph::Node s, t;
 		  try {
 		    digraphReader("digraph.lgf", g). // read the directed graph into g
 		      arcMap("capacity", cap).       // read the 'capacity' arc map into cap
 		      node("source", s).             // read 'source' node to s
 		      node("target", t).             // read 'target' node to t
 		      run();
-		  } catch (DataFormatError& error) { // check if there was any error
+		  } catch (Exception& error) { // check if there was any error
 		    std::cerr << "Error: " << error.what() << std::endl;
 		    return -1;
+		  }
 		  std::cout << "A digraph is read from 'digraph.lgf'." << std::endl;
 		  std::cout << "Number of nodes: " << countNodes(g) << std::endl;
 		  std::cout << "Number of arcs: " << countArcs(g) << std::endl;
 		  std::cout << "We can write it to the standard output:" << std::endl;
 		  digraphWriter(std::cout, g).     // write g to the standard output
 		    arcMap("capacity", cap).       // write cap into 'capacity'

lemon/arg_parser.h

Show inline comments

@@ -301,26 +301,27 @@
 		    ///Check if an opion has been given to the command.
 		    bool given(std::string op) const
+		    {
 		      Opts::const_iterator i = _opts.find(op);
 		      return i!=_opts.end()?i->second.set:false;
+		    }
 		    ///Magic type for operator[]
 		    ///This is the type of the return value of ArgParser::operator[]().
 		    ///It automatically converts to \c int, \c double, \c bool or
 		    ///\c std::string if the type of the option matches, otherwise it
 		    ///throws an exception (i.e. it performs runtime type checking).
 		    ///\c std::string if the type of the option matches, which is checked
 		    ///with an \ref LEMON_ASSERT "assertion" (i.e. it performs runtime
 		    ///type checking).
 		    class RefType
+		    {
 		      const ArgParser &_parser;
 		      std::string _name;
 		    public:
 		      ///\e
 		      RefType(const ArgParser &p,const std::string &n) :_parser(p),_name(n) {}
 		      ///\e
 		      operator bool()
+		      {
 		        Opts::const_iterator i = _parser._opts.find(_name);
 		        LEMON_ASSERT(i!=_parser._opts.end(),

lemon/assert.h

Show inline comments

@@ -99,25 +99,25 @@
 		#    define LEMON_FUNCTION_NAME (__func__)
 		#  else
 		#    define LEMON_FUNCTION_NAME ("<unknown>")
 		#  endif
 		#endif
 		#ifdef DOXYGEN
 		/// \ingroup exceptions
 		///
 		/// \brief Macro for assertion with customizable message
 		///
-		/// Macro for assertion with customizable message.
 		/// Macro for assertion with customizable message.
 		/// \param exp An expression that must be convertible to \c bool.  If it is \c
 		/// false, then an assertion is raised. The concrete behaviour depends on the
 		/// settings of the assertion system.
 		/// \param msg A <tt>const char*</tt> parameter, which can be used to provide
 		/// information about the circumstances of the failed assertion.
 		///
 		/// The assertions are enabled in the default behaviour.
 		/// You can disable them with the following code:
 		/// \code
 		/// #define LEMON_DISABLE_ASSERTS
 		/// \endcode
 		/// or with compilation parameters:

lemon/bfs.h

Show inline comments

@@ -126,34 +126,24 @@
 		  ///\ref BfsDefaultTraits "BfsDefaultTraits<GR>".
 		  ///See \ref BfsDefaultTraits for the documentation of
 		  ///a Bfs traits class.
 		#ifdef DOXYGEN
 		  template <typename GR,
 		            typename TR>
 		#else
 		  template <typename GR=ListDigraph,
 		            typename TR=BfsDefaultTraits<GR> >
 		#endif
 		  class Bfs {
 		  public:
 		    ///\ref Exception for uninitialized parameters.
 		    ///This error represents problems in the initialization of the
 		    ///parameters of the algorithm.
 		    class UninitializedParameter : public lemon::UninitializedParameter {
 		    public:
 		      virtual const char* what() const throw() {
 		        return "lemon::Bfs::UninitializedParameter";
+		      }
 		    };
 		    ///The type of the digraph the algorithm runs on.
 		    typedef typename TR::Digraph Digraph;
 		    ///\brief The type of the map that stores the predecessor arcs of the
 		    ///shortest paths.
 		    typedef typename TR::PredMap PredMap;
 		    ///The type of the map that stores the distances of the nodes.
 		    typedef typename TR::DistMap DistMap;
 		    ///The type of the map that indicates which nodes are reached.
 		    typedef typename TR::ReachedMap ReachedMap;
 		    ///The type of the map that indicates which nodes are processed.
@@ -223,96 +213,101 @@
 		    typedef Bfs Create;
 		    ///\name Named template parameters
 		    ///@{
 		    template <class T>
 		    struct SetPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &)
+		      {
-		        throw UninitializedParameter();
+		        LEMON_ASSERT(false, "PredMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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 SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > {
 		      typedef Bfs< Digraph, SetPredMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &)
+		      {
-		        throw UninitializedParameter();
+		        LEMON_ASSERT(false, "DistMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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 SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > {
 		      typedef Bfs< Digraph, SetDistMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &)
+		      {
-		        throw UninitializedParameter();
+		        LEMON_ASSERT(false, "ReachedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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 SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
 		      typedef Bfs< Digraph, SetReachedMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &)
+		      {
-		        throw UninitializedParameter();
+		        LEMON_ASSERT(false, "ProcessedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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 SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > {
 		      typedef Bfs< Digraph, SetProcessedMapTraits<T> > Create;
 		    };
 		    struct SetStandardProcessedMapTraits : public Traits {
 		      typedef typename Digraph::template NodeMap<bool> ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &g)
+		      {
 		        return new ProcessedMap(g);
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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.
 		    struct SetStandardProcessedMap :
 		      public Bfs< Digraph, SetStandardProcessedMapTraits > {
 		      typedef Bfs< Digraph, SetStandardProcessedMapTraits > Create;
 		    };
@@ -1031,25 +1026,24 @@
 		        alg.run();
+		    }
 		    ///Finds the shortest path between \c s and \c t.
 		    ///This method runs BFS algorithm from node \c s
 		    ///in order to compute the shortest path to node \c t
 		    ///(it stops searching when \c t is processed).
 		    ///
 		    ///\return \c true if \c t is reachable form \c s.
 		    bool run(Node s, Node t)
+		    {
 		      if (s==INVALID || t==INVALID) throw UninitializedParameter();
 		      Bfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
 		      if (Base::_pred)
 		        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
 		      if (Base::_dist)
 		        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
 		      if (Base::_reached)
 		        alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
 		      if (Base::_processed)
 		        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
 		      alg.run(s,t);
 		      if (Base::_path)
 		        *reinterpret_cast<Path*>(Base::_path) = alg.path(t);
@@ -1314,36 +1308,24 @@
 		  /// See \ref BfsVisitDefaultTraits for the documentation of
 		  /// a BFS visit traits class.
 		#ifdef DOXYGEN
 		  template <typename _Digraph, typename _Visitor, typename _Traits>
 		#else
 		  template <typename _Digraph = ListDigraph,
 		            typename _Visitor = BfsVisitor<_Digraph>,
 		            typename _Traits = BfsDefaultTraits<_Digraph> >
 		#endif
 		  class BfsVisit {
 		  public:
 		    /// \brief \ref Exception for uninitialized parameters.
 		    ///
 		    /// This error represents problems in the initialization
 		    /// of the parameters of the algorithm.
 		    class UninitializedParameter : public lemon::UninitializedParameter {
 		    public:
 		      virtual const char* what() const throw()
+		      {
 		        return "lemon::BfsVisit::UninitializedParameter";
+		      }
 		    };
 		    ///The traits class.
 		    typedef _Traits Traits;
 		    ///The type of the digraph the algorithm runs on.
 		    typedef typename Traits::Digraph Digraph;
 		    ///The visitor type used by the algorithm.
 		    typedef _Visitor Visitor;
 		    ///The type of the map that indicates which nodes are reached.
 		    typedef typename Traits::ReachedMap ReachedMap;
@@ -1380,25 +1362,26 @@
 		  public:
 		    typedef BfsVisit Create;
 		    /// \name Named template parameters
 		    ///@{
 		    template <class T>
 		    struct SetReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &digraph) {
-		        throw UninitializedParameter();
+		        LEMON_ASSERT(false, "ReachedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    /// \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 SetReachedMap : public BfsVisit< Digraph, Visitor,
 		                                            SetReachedMapTraits<T> > {
 		      typedef BfsVisit< Digraph, Visitor, SetReachedMapTraits<T> > Create;
 		    };
 		    ///@}

lemon/concepts/heap.h

Show inline comments

@@ -120,25 +120,24 @@
 		      /// Returns the priority of the given item.
 		      /// \pre \c i must be in the heap.
 		      /// \param i The item.
 		      Prio operator[](const Item &i) const {}
 		      /// \brief Sets the priority of an item or inserts it, if it is
 		      /// not stored in the heap.
 		      ///
 		      /// This method sets the priority of the given item if it is
 		      /// already stored in the heap.
 		      /// Otherwise it inserts the given item with the given priority.
 		      ///
 		      /// It may throw an \ref UnderflowPriorityException.
 		      /// \param i The item.
 		      /// \param p The priority.
 		      void set(const Item &i, const Prio &p) {}
 		      /// \brief Decreases the priority of an item to the given value.
 		      ///
 		      /// Decreases the priority of an item to the given value.
 		      /// \pre \c i must be stored in the heap with priority at least \c p.
 		      /// \param i The item.
 		      /// \param p The priority.
 		      void decrease(const Item &i, const Prio &p) {}

lemon/dfs.h

Show inline comments

@@ -127,34 +127,24 @@
 		  ///\ref DfsDefaultTraits "DfsDefaultTraits<GR>".
 		  ///See \ref DfsDefaultTraits for the documentation of
 		  ///a Dfs traits class.
 		#ifdef DOXYGEN
 		  template <typename GR,
 		            typename TR>
 		#else
 		  template <typename GR=ListDigraph,
 		            typename TR=DfsDefaultTraits<GR> >
 		#endif
 		  class Dfs {
 		  public:
 		    ///\ref Exception for uninitialized parameters.
 		    ///This error represents problems in the initialization of the
 		    ///parameters of the algorithm.
 		    class UninitializedParameter : public lemon::UninitializedParameter {
 		    public:
 		      virtual const char* what() const throw() {
 		        return "lemon::Dfs::UninitializedParameter";
+		      }
 		    };
 		    ///The type of the digraph the algorithm runs on.
 		    typedef typename TR::Digraph Digraph;
 		    ///\brief The type of the map that stores the predecessor arcs of the
 		    ///DFS paths.
 		    typedef typename TR::PredMap PredMap;
 		    ///The type of the map that stores the distances of the nodes.
 		    typedef typename TR::DistMap DistMap;
 		    ///The type of the map that indicates which nodes are reached.
 		    typedef typename TR::ReachedMap ReachedMap;
 		    ///The type of the map that indicates which nodes are processed.
@@ -223,79 +213,83 @@
 		    typedef Dfs Create;
 		    ///\name Named template parameters
 		    ///@{
 		    template <class T>
 		    struct SetPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &)
+		      {
-		        throw UninitializedParameter();
+		        LEMON_ASSERT(false, "PredMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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 SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > {
 		      typedef Dfs<Digraph, SetPredMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &)
+		      {
-		        throw UninitializedParameter();
+		        LEMON_ASSERT(false, "DistMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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 SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > {
 		      typedef Dfs<Digraph, SetDistMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &)
+		      {
-		        throw UninitializedParameter();
+		        LEMON_ASSERT(false, "ReachedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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 SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
 		      typedef Dfs< Digraph, SetReachedMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &)
+		      {
-		        throw UninitializedParameter();
+		        LEMON_ASSERT(false, "ProcessedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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 SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > {
 		      typedef Dfs< Digraph, SetProcessedMapTraits<T> > Create;
 		    };
@@ -965,25 +959,24 @@
 		        alg.run();
+		    }
 		    ///Finds the DFS path between \c s and \c t.
 		    ///This method runs DFS algorithm from node \c s
 		    ///in order to compute the DFS path to node \c t
 		    ///(it stops searching when \c t is processed).
 		    ///
 		    ///\return \c true if \c t is reachable form \c s.
 		    bool run(Node s, Node t)
+		    {
 		      if (s==INVALID || t==INVALID) throw UninitializedParameter();
 		      Dfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
 		      if (Base::_pred)
 		        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
 		      if (Base::_dist)
 		        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
 		      if (Base::_reached)
 		        alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
 		      if (Base::_processed)
 		        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
 		      alg.run(s,t);
 		      if (Base::_path)
 		        *reinterpret_cast<Path*>(Base::_path) = alg.path(t);
@@ -1261,36 +1254,24 @@
 		  /// See \ref DfsVisitDefaultTraits for the documentation of
 		  /// a DFS visit traits class.
 		#ifdef DOXYGEN
 		  template <typename _Digraph, typename _Visitor, typename _Traits>
 		#else
 		  template <typename _Digraph = ListDigraph,
 		            typename _Visitor = DfsVisitor<_Digraph>,
 		            typename _Traits = DfsDefaultTraits<_Digraph> >
 		#endif
 		  class DfsVisit {
 		  public:
 		    /// \brief \ref Exception for uninitialized parameters.
 		    ///
 		    /// This error represents problems in the initialization
 		    /// of the parameters of the algorithm.
 		    class UninitializedParameter : public lemon::UninitializedParameter {
 		    public:
 		      virtual const char* what() const throw()
+		      {
 		        return "lemon::DfsVisit::UninitializedParameter";
+		      }
 		    };
 		    ///The traits class.
 		    typedef _Traits Traits;
 		    ///The type of the digraph the algorithm runs on.
 		    typedef typename Traits::Digraph Digraph;
 		    ///The visitor type used by the algorithm.
 		    typedef _Visitor Visitor;
 		    ///The type of the map that indicates which nodes are reached.
 		    typedef typename Traits::ReachedMap ReachedMap;
@@ -1327,25 +1308,26 @@
 		  public:
 		    typedef DfsVisit Create;
 		    /// \name Named template parameters
 		    ///@{
 		    template <class T>
 		    struct SetReachedMapTraits : public Traits {
 		      typedef T ReachedMap;
 		      static ReachedMap *createReachedMap(const Digraph &digraph) {
-		        throw UninitializedParameter();
+		        LEMON_ASSERT(false, "ReachedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    /// \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 SetReachedMap : public DfsVisit< Digraph, Visitor,
 		                                            SetReachedMapTraits<T> > {
 		      typedef DfsVisit< Digraph, Visitor, SetReachedMapTraits<T> > Create;
 		    };
 		    ///@}

lemon/dijkstra.h

Show inline comments

@@ -216,34 +216,24 @@
 		  ///The default traits class is \ref DijkstraDefaultTraits
 		  ///"DijkstraDefaultTraits<GR,LM>". See \ref DijkstraDefaultTraits
 		  ///for the documentation of a Dijkstra traits class.
 		#ifdef DOXYGEN
 		  template <typename GR, typename LM, typename TR>
 		#else
 		  template <typename GR=ListDigraph,
 		            typename LM=typename GR::template ArcMap<int>,
 		            typename TR=DijkstraDefaultTraits<GR,LM> >
 		#endif
 		  class Dijkstra {
 		  public:
 		    ///\ref Exception for uninitialized parameters.
 		    ///This error represents problems in the initialization of the
 		    ///parameters of the algorithm.
 		    class UninitializedParameter : public lemon::UninitializedParameter {
 		    public:
 		      virtual const char* what() const throw() {
 		        return "lemon::Dijkstra::UninitializedParameter";
+		      }
 		    };
 		    ///The type of the digraph the algorithm runs on.
 		    typedef typename TR::Digraph Digraph;
 		    ///The type of the length of the arcs.
 		    typedef typename TR::LengthMap::Value Value;
 		    ///The type of the map that stores the arc lengths.
 		    typedef typename TR::LengthMap LengthMap;
 		    ///\brief The type of the map that stores the predecessor arcs of the
 		    ///shortest paths.
 		    typedef typename TR::PredMap PredMap;
 		    ///The type of the map that stores the distances of the nodes.
@@ -323,63 +313,66 @@
 		    typedef Dijkstra Create;
 		    ///\name Named template parameters
 		    ///@{
 		    template <class T>
 		    struct SetPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &)
+		      {
-		        throw UninitializedParameter();
+		        LEMON_ASSERT(false, "PredMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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 SetPredMap
 		      : public Dijkstra< Digraph, LengthMap, SetPredMapTraits<T> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetPredMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &)
+		      {
-		        throw UninitializedParameter();
+		        LEMON_ASSERT(false, "DistMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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 SetDistMap
 		      : public Dijkstra< Digraph, LengthMap, SetDistMapTraits<T> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetDistMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
 		      static ProcessedMap *createProcessedMap(const Digraph &)
+		      {
-		        throw UninitializedParameter();
+		        LEMON_ASSERT(false, "ProcessedMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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 SetProcessedMap
 		      : public Dijkstra< Digraph, LengthMap, SetProcessedMapTraits<T> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetProcessedMapTraits<T> > Create;
 		    };
@@ -399,29 +392,31 @@
 		    ///If you don't set it explicitly, it will be automatically allocated.
 		    struct SetStandardProcessedMap
 		      : public Dijkstra< Digraph, LengthMap, SetStandardProcessedMapTraits > {
 		      typedef Dijkstra< Digraph, LengthMap, SetStandardProcessedMapTraits >
 		      Create;
 		    };
 		    template <class H, class CR>
 		    struct SetHeapTraits : public Traits {
 		      typedef CR HeapCrossRef;
 		      typedef H Heap;
 		      static HeapCrossRef *createHeapCrossRef(const Digraph &) {
-		        throw UninitializedParameter();
+		        LEMON_ASSERT(false, "HeapCrossRef is not initialized");
 		        return 0; // ignore warnings
+		      }
 		      static Heap *createHeap(HeapCrossRef &)
+		      {
-		        throw UninitializedParameter();
+		        LEMON_ASSERT(false, "Heap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\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 SetHeap
 		      : public Dijkstra< Digraph, LengthMap, SetHeapTraits<H, CR> > {
 		      typedef Dijkstra< Digraph, LengthMap, SetHeapTraits<H, CR> > Create;
 		    };
@@ -1149,47 +1144,45 @@
 		    ///Copy constructor
 		    DijkstraWizard(const TR &b) : TR(b) {}
 		    ~DijkstraWizard() {}
 		    ///Runs Dijkstra algorithm from the given source node.
 		    ///This method runs %Dijkstra algorithm from the given source node
 		    ///in order to compute the shortest path to each node.
 		    void run(Node s)
+		    {
 		      if (s==INVALID) throw UninitializedParameter();
 		      Dijkstra<Digraph,LengthMap,TR>
 		        dijk(*reinterpret_cast<const Digraph*>(Base::_g),
 		             *reinterpret_cast<const LengthMap*>(Base::_length));
 		      if (Base::_pred)
 		        dijk.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
 		      if (Base::_dist)
 		        dijk.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
 		      if (Base::_processed)
 		        dijk.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
 		      dijk.run(s);
+		    }
 		    ///Finds the shortest path between \c s and \c t.
 		    ///This method runs the %Dijkstra algorithm from node \c s
 		    ///in order to compute the shortest path to node \c t
 		    ///(it stops searching when \c t is processed).
 		    ///
 		    ///\return \c true if \c t is reachable form \c s.
 		    bool run(Node s, Node t)
+		    {
 		      if (s==INVALID || t==INVALID) throw UninitializedParameter();
 		      Dijkstra<Digraph,LengthMap,TR>
 		        dijk(*reinterpret_cast<const Digraph*>(Base::_g),
 		             *reinterpret_cast<const LengthMap*>(Base::_length));
 		      if (Base::_pred)
 		        dijk.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
 		      if (Base::_dist)
 		        dijk.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
 		      if (Base::_processed)
 		        dijk.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
 		      dijk.run(s,t);
 		      if (Base::_path)
 		        *reinterpret_cast<Path*>(Base::_path) = dijk.path(t);

lemon/error.h

Show inline comments

@@ -26,393 +26,251 @@
 		#include <exception>
 		#include <string>
 		#include <sstream>
 		#include <iostream>
 		#include <cstdlib>
 		#include <memory>
 		namespace lemon {
 		  /// \addtogroup exceptions
 		  /// @{
-		  /// \brief Exception safe wrapper class.
+		  /// \brief Generic exception class.
 		  ///
 		  /// Exception safe wrapper class to implement the members of exceptions.
 		  template <typename _Type>
 		  class ExceptionMember {
 		  public:
 		    typedef _Type Type;
 		    ExceptionMember() throw() {
 		      try {
 		        ptr.reset(new Type());
 		      } catch (...) {}
+		    }
 		    ExceptionMember(const Type& type) throw() {
 		      try {
 		        ptr.reset(new Type());
 		        if (ptr.get() == 0) return;
 		        *ptr = type;
 		      } catch (...) {}
+		    }
 		    ExceptionMember(const ExceptionMember& copy) throw() {
 		      try {
 		        if (!copy.valid()) return;
 		        ptr.reset(new Type());
 		        if (ptr.get() == 0) return;
 		        *ptr = copy.get();
 		      } catch (...) {}
+		    }
 		    ExceptionMember& operator=(const ExceptionMember& copy) throw() {
 		      if (ptr.get() == 0) return;
 		      try {
 		        if (!copy.valid()) return;
 		        *ptr = copy.get();
 		      } catch (...) {}
+		    }
 		    void set(const Type& type) throw() {
 		      if (ptr.get() == 0) return;
 		      try {
 		        *ptr = type;
 		      } catch (...) {}
+		    }
 		    const Type& get() const {
 		      return *ptr;
+		    }
 		    bool valid() const throw() {
 		      return ptr.get() != 0;
+		    }
 		  private:
 		    std::auto_ptr<_Type> ptr;
 		  };
 		  /// Exception-safe convenient error message builder class.
 		  /// Helper class which provides a convenient ostream-like (operator <<
 		  /// based) interface to create a string message. Mostly useful in
 		  /// exception classes (therefore the name).
 		  class ErrorMessage {
 		  protected:
 		    ///\e
 		    mutable std::auto_ptr<std::ostringstream> buf;
 		    ///\e
 		    bool init() throw() {
 		      try {
 		        buf.reset(new std::ostringstream);
+		      }
 		      catch(...) {
 		        buf.reset();
+		      }
 		      return buf.get();
+		    }
 		  public:
 		    ///\e
 		    ErrorMessage() throw() { init(); }
 		    ErrorMessage(const ErrorMessage& em) throw() : buf(em.buf) { }
 		    ///\e
 		    ErrorMessage(const char *msg) throw() {
 		      init();
 		      *this << msg;
+		    }
 		    ///\e
 		    ErrorMessage(const std::string &msg) throw() {
 		      init();
 		      *this << msg;
+		    }
 		    ///\e
 		    template <typename T>
 		    ErrorMessage& operator<<(const T &t) throw() {
 		      if( ! buf.get() ) return *this;
 		      try {
 		        *buf << t;
+		      }
 		      catch(...) {
 		        buf.reset();
+		      }
 		      return *this;
+		    }
 		    ///\e
 		    const char* message() throw() {
 		      if( ! buf.get() ) return 0;
 		      const char* mes = 0;
 		      try {
 		        mes = buf->str().c_str();
+		      }
 		      catch(...) {}
 		      return mes;
+		    }
 		  };
 		  /// Generic exception class.
 		  /// Base class for exceptions used in LEMON.
 		  ///
 		  class Exception : public std::exception {
 		  public:
 		    ///\e
+		    ///\e Constructor
 		    Exception() {}
 		    ///\e
+		    ///\e Virtual destructor
 		    virtual ~Exception() throw() {}
 		    ///\e
+		    ///\e A short description of the exception
 		    virtual const char* what() const throw() {
 		      return "lemon::Exception";
+		    }
 		  };
-		  /// One of the two main subclasses of \ref Exception.
+		  /// \brief Input-Output error
 		  ///
 		  /// This exception is thrown when a file operation cannot be
 		  /// succeeded.
 		  class IoError : public Exception {
 		  protected:
 		    std::string _message;
 		    std::string _file;
 		  /// Logic errors represent problems in the internal logic of a program;
 		  /// in theory, these are preventable, and even detectable before the
 		  /// program runs (e.g. violations of class invariants).
 		  ///
 		  /// A typical example for this is \ref UninitializedParameter.
 		  class LogicError : public Exception {
 		    mutable std::string _what;
 		  public:
 		    /// Copy constructor
 		    IoError(const IoError &error) {
 		      message(error._message);
 		      file(error._file);
+		    }
 		    /// Constructor
 		    explicit IoError(const char *message) {
 		      IoError::message(message);
+		    }
 		    /// Constructor
 		    explicit IoError(const std::string &message) {
 		      IoError::message(message);
+		    }
 		    /// Constructor
 		    IoError(const std::string &file, const char *message) {
 		      IoError::message(message);
 		      IoError::file(file);
+		    }
 		    /// Constructor
 		    IoError(const std::string &file, const std::string &message) {
 		      IoError::message(message);
 		      IoError::file(file);
+		    }
 		    /// Virtual destructor
 		    virtual ~IoError() throw() {}
 		    /// Set the error message
 		    void message(const char *message) {
 		      try {
 		        _message = message;
 		      } catch (...) {}
+		    }
 		    /// Set the error message
 		    void message(const std::string& message) {
 		      try {
 		        _message = message;
 		      } catch (...) {}
+		    }
 		    /// Set the file name
 		    void file(const std::string &file) {
 		      try {
 		        _file = file;
 		      } catch (...) {}
+		    }
 		    /// Returns the error message
 		    const std::string& message() const {
 		      return _message;
+		    }
 		    /// \brief Returns the filename
 		    ///
 		    /// Returns the filename or empty string if the filename was not
 		    /// specified.
 		    const std::string& file() const {
 		      return _file;
+		    }
 		    /// \brief Returns a short error message
 		    ///
 		    /// Returns a short error message which contains the message, the
 		    /// file name and the line number.
 		    virtual const char* what() const throw() {
-		      return "lemon::LogicError";
+		      try {
 		        _what.clear();
 		        std::ostringstream oss;
 		        oss << "lemon:IoError" << ": ";
 		        oss << message();
 		        if (!file().empty()) {
 		          oss << " (";
 		          if (!file().empty()) oss << "with file '" << file() << "'";
 		          oss << ")";
+		        }
 		        _what = oss.str();
+		      }
 		      catch (...) {}
 		      if (!_what.empty()) return _what.c_str();
 		      else return "lemon:IoError";
+		    }
 		  };
 		  /// \ref Exception for uninitialized parameters.
 		  /// This error represents problems in the initialization
 		  /// of the parameters of the algorithms.
 		  class UninitializedParameter : public LogicError {
 		  public:
 		    virtual const char* what() const throw() {
 		      return "lemon::UninitializedParameter";
+		    }
 		  };
 		  /// One of the two main subclasses of \ref Exception.
 		  /// Runtime errors represent problems outside the scope of a program;
 		  /// they cannot be easily predicted and can generally only be caught
 		  /// as the program executes.
 		  class RuntimeError : public Exception {
 		  public:
 		    virtual const char* what() const throw() {
 		      return "lemon::RuntimeError";
+		    }
 		  };
 		  ///\e
 		  class RangeError : public RuntimeError {
 		  public:
 		    virtual const char* what() const throw() {
 		      return "lemon::RangeError";
+		    }
 		  };
 		  ///\e
 		  class IoError : public RuntimeError {
 		  public:
 		    virtual const char* what() const throw() {
 		      return "lemon::IoError";
+		    }
 		  };
 		  ///\e
 		  class DataFormatError : public IoError {
 		  /// \brief Format error
 		  ///
 		  /// This class is used to indicate if an input file has wrong
 		  /// formatting, or a data representation is not legal.
 		  class FormatError : public Exception {
 		  protected:
 		    ExceptionMember<std::string> _message;
 		    ExceptionMember<std::string> _file;
 		    std::string _message;
 		    std::string _file;
 		    int _line;
-		    mutable ExceptionMember<std::string> _message_holder;
+		    mutable std::string _what;
 		  public:
 		    DataFormatError(const DataFormatError &dfe) :
 		      IoError(dfe), _message(dfe._message), _file(dfe._file),
 		      _line(dfe._line) {}
 		    ///\e
 		    explicit DataFormatError(const char *the_message)
 		      : _message(the_message), _line(0) {}
 		    ///\e
 		    DataFormatError(const std::string &file_name, int line_num,
 		                    const char *the_message)
 		      : _message(the_message), _line(line_num) { file(file_name); }
 		    ///\e
 		    void line(int ln) { _line = ln; }
 		    ///\e
 		    void message(const std::string& msg) { _message.set(msg); }
 		    ///\e
 		    void file(const std::string &fl) { _file.set(fl); }
 		    ///\e
 		    int line() const { return _line; }
 		    ///\e
 		    const char* message() const {
 		      if (_message.valid() && !_message.get().empty()) {
 		        return _message.get().c_str();
 		      } else {
 		        return 0;
+		      }
+		    /// Copy constructor
 		    FormatError(const FormatError &error) {
 		      message(error._message);
 		      file(error._file);
 		      line(error._line);
+		    }
 		    /// \brief Returns the filename.
 		    ///
 		    /// Returns \e null if the filename was not specified.
 		    const char* file() const {
 		      if (_file.valid() && !_file.get().empty()) {
 		        return _file.get().c_str();
 		      } else {
 		        return 0;
+		      }
+		    /// Constructor
 		    explicit FormatError(const char *message) {
 		      FormatError::message(message);
 		      _line = 0;
+		    }
-		    ///\e
+		    /// Constructor
 		    explicit FormatError(const std::string &message) {
 		      FormatError::message(message);
 		      _line = 0;
+		    }
 		    /// Constructor
 		    FormatError(const std::string &file, int line, const char *message) {
 		      FormatError::message(message);
 		      FormatError::file(file);
 		      FormatError::line(line);
+		    }
 		    /// Constructor
 		    FormatError(const std::string &file, int line, const std::string &message) {
 		      FormatError::message(message);
 		      FormatError::file(file);
 		      FormatError::line(line);
+		    }
 		    /// Virtual destructor
 		    virtual ~FormatError() throw() {}
 		    /// Set the line number
 		    void line(int line) { _line = line; }
 		    /// Set the error message
 		    void message(const char *message) {
 		      try {
 		        _message = message;
 		      } catch (...) {}
+		    }
 		    /// Set the error message
 		    void message(const std::string& message) {
 		      try {
 		        _message = message;
 		      } catch (...) {}
+		    }
 		    /// Set the file name
 		    void file(const std::string &file) {
 		      try {
 		        _file = file;
 		      } catch (...) {}
+		    }
 		    /// \brief Returns the line number
 		    ///
 		    /// Returns the line number or zero if it was not specified.
 		    int line() const { return _line; }
 		    /// Returns the error message
 		    const std::string& message() const {
 		      return _message;
+		    }
 		    /// \brief Returns the filename
 		    ///
 		    /// Returns the filename or empty string if the filename was not
 		    /// specified.
 		    const std::string& file() const {
 		      return _file;
+		    }
 		    /// \brief Returns a short error message
 		    ///
 		    /// Returns a short error message which contains the message, the
 		    /// file name and the line number.
 		    virtual const char* what() const throw() {
 		      try {
 		        std::ostringstream ostr;
 		        ostr << "lemon:DataFormatError" << ": ";
 		        if (message()) ostr << message();
 		        if( file() || line() != 0 ) {
 		          ostr << " (";
 		          if( file() ) ostr << "in file '" << file() << "'";
 		          if( file() && line() != 0 ) ostr << " ";
 		          if( line() != 0 ) ostr << "at line " << line();
-		          ostr << ")";
+		        _what.clear();
 		        std::ostringstream oss;
 		        oss << "lemon:FormatError" << ": ";
 		        oss << message();
 		        if (!file().empty() || line() != 0) {
 		          oss << " (";
 		          if (!file().empty()) oss << "in file '" << file() << "'";
 		          if (!file().empty() && line() != 0) oss << " ";
 		          if (line() != 0) oss << "at line " << line();
 		          oss << ")";
+		        }
-		        _message_holder.set(ostr.str());
+		        _what = oss.str();
+		      }
 		      catch (...) {}
 		      if( _message_holder.valid()) return _message_holder.get().c_str();
 		      return "lemon:DataFormatError";
 		      if (!_what.empty()) return _what.c_str();
 		      else return "lemon:FormatError";
+		    }
 		    virtual ~DataFormatError() throw() {}
 		  };
 		  ///\e
 		  class FileOpenError : public IoError {
 		  protected:
 		    ExceptionMember<std::string> _file;
 		    mutable ExceptionMember<std::string> _message_holder;
 		  public:
 		    FileOpenError(const FileOpenError &foe) :
 		      IoError(foe), _file(foe._file) {}
 		    ///\e
 		    explicit FileOpenError(const std::string& fl)
 		      : _file(fl) {}
 		    ///\e
 		    void file(const std::string &fl) { _file.set(fl); }
 		    /// \brief Returns the filename.
 		    ///
 		    /// Returns \e null if the filename was not specified.
 		    const char* file() const {
 		      if (_file.valid() && !_file.get().empty()) {
 		        return _file.get().c_str();
 		      } else {
 		        return 0;
+		      }
+		    }
 		    ///\e
 		    virtual const char* what() const throw() {
 		      try {
 		        std::ostringstream ostr;
 		        ostr << "lemon::FileOpenError" << ": ";
 		        ostr << "Cannot open file - " << file();
 		        _message_holder.set(ostr.str());
+		      }
 		      catch (...) {}
 		      if( _message_holder.valid()) return _message_holder.get().c_str();
 		      return "lemon::FileOpenError";
+		    }
 		    virtual ~FileOpenError() throw() {}
 		  };
 		  class IoParameterError : public IoError {
 		  protected:
 		    ExceptionMember<std::string> _message;
 		    ExceptionMember<std::string> _file;
 		    mutable ExceptionMember<std::string> _message_holder;
 		  public:
 		    IoParameterError(const IoParameterError &ile) :
 		      IoError(ile), _message(ile._message), _file(ile._file) {}
 		    ///\e
 		    explicit IoParameterError(const char *the_message)
 		      : _message(the_message) {}
 		    ///\e
 		    IoParameterError(const char *file_name, const char *the_message)
 		      : _message(the_message), _file(file_name) {}
 		     ///\e
 		    void message(const std::string& msg) { _message.set(msg); }
 		    ///\e
 		    void file(const std::string &fl) { _file.set(fl); }
 		     ///\e
 		    const char* message() const {
 		      if (_message.valid()) {
 		        return _message.get().c_str();
 		      } else {
 		        return 0;
+		      }
+		    }
 		    /// \brief Returns the filename.
 		    ///
 		    /// Returns \c 0 if the filename was not specified.
 		    const char* file() const {
 		      if (_file.valid()) {
 		        return _file.get().c_str();
 		      } else {
 		        return 0;
+		      }
+		    }
 		    ///\e
 		    virtual const char* what() const throw() {
 		      try {
 		        std::ostringstream ostr;
 		        if (message()) ostr << message();
 		        if (file()) ostr << "(when reading file '" << file() << "')";
 		        _message_holder.set(ostr.str());
+		      }
 		      catch (...) {}
 		      if( _message_holder.valid() ) return _message_holder.get().c_str();
 		      return "lemon:IoParameterError";
+		    }
 		    virtual ~IoParameterError() throw() {}
 		  };
 		  /// @}
+		}
 		#endif // LEMON_ERROR_H

lemon/graph_to_eps.h

Show inline comments

@@ -31,24 +31,25 @@
 		#else
 		#define WIN32_LEAN_AND_MEAN
 		#define NOMINMAX
 		#include<windows.h>
 		#endif
 		#include<lemon/math.h>
 		#include<lemon/core.h>
 		#include<lemon/dim2.h>
 		#include<lemon/maps.h>
 		#include<lemon/color.h>
 		#include<lemon/bits/bezier.h>
 		#include<lemon/error.h>
 		///\ingroup eps_io
 		///\file
 		///\brief A well configurable tool for visualizing graphs
 		namespace lemon {
 		  namespace _graph_to_eps_bits {
 		    template<class MT>
 		    class _NegY {
 		    public:
@@ -1157,35 +1158,45 @@
 		///Generates an EPS file from a graph
 		///\ingroup eps_io
 		///This function does the same as
 		///\ref graphToEps(G &g,std::ostream& os)
 		///but it writes its output into the file \c file_name
 		///instead of a stream.
 		///\sa graphToEps(G &g, std::ostream& os)
 		template<class G>
 		GraphToEps<DefaultGraphToEpsTraits<G> >
 		graphToEps(G &g,const char *file_name)
+		{
 		  std::ostream* os = new std::ofstream(file_name);
 		  if (!(*os)) {
 		    delete os;
 		    throw IoError(file_name, "Cannot write file");
+		  }
 		  return GraphToEps<DefaultGraphToEpsTraits<G> >
-		    (DefaultGraphToEpsTraits<G>(g,*new std::ofstream(file_name),true));
+		    (DefaultGraphToEpsTraits<G>(g,*os,true));
+		}
 		///Generates an EPS file from a graph
 		///\ingroup eps_io
 		///This function does the same as
 		///\ref graphToEps(G &g,std::ostream& os)
 		///but it writes its output into the file \c file_name
 		///instead of a stream.
 		///\sa graphToEps(G &g, std::ostream& os)
 		template<class G>
 		GraphToEps<DefaultGraphToEpsTraits<G> >
 		graphToEps(G &g,const std::string& file_name)
+		{
 		  std::ostream* os = new std::ofstream(file_name.c_str());
 		  if (!(*os)) {
 		    delete os;
 		    throw IoError(file_name, "Cannot write file");
+		  }
 		  return GraphToEps<DefaultGraphToEpsTraits<G> >
-		    (DefaultGraphToEpsTraits<G>(g,*new std::ofstream(file_name.c_str()),true));
+		    (DefaultGraphToEpsTraits<G>(g,*os,true));
+		}
 		} //END OF NAMESPACE LEMON
 		#endif // LEMON_GRAPH_TO_EPS_H

lemon/lgf_reader.h

Show inline comments

@@ -39,29 +39,31 @@
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		namespace lemon {
 		  namespace _reader_bits {
 		    template <typename Value>
 		    struct DefaultConverter {
 		      Value operator()(const std::string& str) {
 		        std::istringstream is(str);
 		        Value value;
-		        is >> value;
+		        if (!(is >> value)) {
 		          throw FormatError("Cannot read token");
+		        }
 		        char c;
 		        if (is >> std::ws >> c) {
-		          throw DataFormatError("Remaining characters in token");
+		          throw FormatError("Remaining characters in token");
+		        }
 		        return value;
+		      }
 		    };
 		    template <>
 		    struct DefaultConverter<std::string> {
 		      std::string operator()(const std::string& str) {
 		        return str;
+		      }
 		    };
@@ -157,48 +159,48 @@
 		    struct MapLookUpConverter {
 		      const std::map<std::string, Value>& _map;
 		      MapLookUpConverter(const std::map<std::string, Value>& map)
 		        : _map(map) {}
 		      Value operator()(const std::string& str) {
 		        typename std::map<std::string, Value>::const_iterator it =
 		          _map.find(str);
 		        if (it == _map.end()) {
 		          std::ostringstream msg;
 		          msg << "Item not found: " << str;
-		          throw DataFormatError(msg.str().c_str());
+		          throw FormatError(msg.str());
+		        }
 		        return it->second;
+		      }
 		    };
 		    template <typename Graph>
 		    struct GraphArcLookUpConverter {
 		      const Graph& _graph;
 		      const std::map<std::string, typename Graph::Edge>& _map;
 		      GraphArcLookUpConverter(const Graph& graph,
 		                              const std::map<std::string,
 		                                             typename Graph::Edge>& map)
 		        : _graph(graph), _map(map) {}
 		      typename Graph::Arc operator()(const std::string& str) {
 		        if (str.empty() || (str[0] != '+' && str[0] != '-')) {
-		          throw DataFormatError("Item must start with '+' or '-'");
+		          throw FormatError("Item must start with '+' or '-'");
+		        }
 		        typename std::map<std::string, typename Graph::Edge>
 		          ::const_iterator it = _map.find(str.substr(1));
 		        if (it == _map.end()) {
-		          throw DataFormatError("Item not found");
+		          throw FormatError("Item not found");
+		        }
 		        return _graph.direct(it->second, str[0] == '+');
+		      }
 		    };
 		    inline bool isWhiteSpace(char c) {
 		      return c == ' ' || c == '\t' || c == '\v' ||
 		        c == '\n' || c == '\r' || c == '\f';
+		    }
 		    inline bool isOct(char c) {
 		      return '0' <= c && c <='7';
@@ -226,25 +228,25 @@
 		      return ('a' <= c && c <= 'z') ||
 		        ('A' <= c && c <= 'Z') || c == '_';
+		    }
 		    inline bool isIdentifierChar(char c) {
 		      return isIdentifierFirstChar(c) ||
 		        ('0' <= c && c <= '9');
+		    }
 		    inline char readEscape(std::istream& is) {
 		      char c;
 		      if (!is.get(c))
-		        throw DataFormatError("Escape format error");
+		        throw FormatError("Escape format error");
 		      switch (c) {
 		      case '\\':
 		        return '\\';
 		      case '\"':
 		        return '\"';
 		      case '\'':
 		        return '\'';
 		      case '\?':
 		        return '\?';
 		      case 'a':
 		        return '\a';
@@ -255,34 +257,34 @@
 		      case 'n':
 		        return '\n';
 		      case 'r':
 		        return '\r';
 		      case 't':
 		        return '\t';
 		      case 'v':
 		        return '\v';
 		      case 'x':
+		        {
 		          int code;
 		          if (!is.get(c) || !isHex(c))
-		            throw DataFormatError("Escape format error");
+		            throw FormatError("Escape format error");
 		          else if (code = valueHex(c), !is.get(c) || !isHex(c)) is.putback(c);
 		          else code = code * 16 + valueHex(c);
 		          return code;
+		        }
 		      default:
+		        {
 		          int code;
 		          if (!isOct(c))
-		            throw DataFormatError("Escape format error");
+		            throw FormatError("Escape format error");
 		          else if (code = valueOct(c), !is.get(c) || !isOct(c))
 		            is.putback(c);
 		          else if (code = code * 8 + valueOct(c), !is.get(c) || !isOct(c))
 		            is.putback(c);
 		          else code = code * 8 + valueOct(c);
 		          return code;
+		        }
+		      }
+		    }
 		    inline std::istream& readToken(std::istream& is, std::string& str) {
 		      std::ostringstream os;
@@ -291,25 +293,25 @@
 		      is >> std::ws;
 		      if (!is.get(c))
 		        return is;
 		      if (c == '\"') {
 		        while (is.get(c) && c != '\"') {
 		          if (c == '\\')
 		            c = readEscape(is);
 		          os << c;
+		        }
 		        if (!is)
-		          throw DataFormatError("Quoted format error");
+		          throw FormatError("Quoted format error");
 		      } else {
 		        is.putback(c);
 		        while (is.get(c) && !isWhiteSpace(c)) {
 		          if (c == '\\')
 		            c = readEscape(is);
 		          os << c;
+		        }
 		        if (!is) {
 		          is.clear();
 		        } else {
 		          is.putback(c);
+		        }
@@ -451,24 +453,25 @@
 		  template <typename _Digraph>
 		  class DigraphReader {
 		  public:
 		    typedef _Digraph Digraph;
 		    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 		  private:
 		    std::istream* _is;
 		    bool local_is;
 		    std::string _filename;
 		    Digraph& _digraph;
 		    std::string _nodes_caption;
 		    std::string _arcs_caption;
 		    std::string _attributes_caption;
 		    typedef std::map<std::string, Node> NodeIndex;
 		    NodeIndex _node_index;
 		    typedef std::map<std::string, Arc> ArcIndex;
 		    ArcIndex _arc_index;
@@ -500,36 +503,42 @@
 		    /// Construct a directed graph reader, which reads from the given
 		    /// input stream.
 		    DigraphReader(std::istream& is, Digraph& digraph)
 		      : _is(&is), local_is(false), _digraph(digraph),
 		        _use_nodes(false), _use_arcs(false),
 		        _skip_nodes(false), _skip_arcs(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph reader, which reads from the given
 		    /// file.
 		    DigraphReader(const std::string& fn, Digraph& digraph)
-		      : _is(new std::ifstream(fn.c_str())), local_is(true), _digraph(digraph),
 		      : _is(new std::ifstream(fn.c_str())), local_is(true),
 		        _filename(fn), _digraph(digraph),
 		        _use_nodes(false), _use_arcs(false),
-		        _skip_nodes(false), _skip_arcs(false) {}
 		        _skip_nodes(false), _skip_arcs(false) {
 		      if (!(*_is)) throw IoError(fn, "Cannot open file");
+		    }
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph reader, which reads from the given
 		    /// file.
 		    DigraphReader(const char* fn, Digraph& digraph)
-		      : _is(new std::ifstream(fn)), local_is(true), _digraph(digraph),
 		      : _is(new std::ifstream(fn)), local_is(true),
 		        _filename(fn), _digraph(digraph),
 		        _use_nodes(false), _use_arcs(false),
-		        _skip_nodes(false), _skip_arcs(false) {}
 		        _skip_nodes(false), _skip_arcs(false) {
 		      if (!(*_is)) throw IoError(fn, "Cannot open file");
+		    }
 		    /// \brief Destructor
 		    ~DigraphReader() {
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 		           it != _node_maps.end(); ++it) {
 		        delete it->second;
+		      }
 		      for (typename ArcMaps::iterator it = _arc_maps.begin();
 		           it != _arc_maps.end(); ++it) {
 		        delete it->second;
+		      }
@@ -836,346 +845,347 @@
 		      line.putback(c);
+		    }
 		    void readNodes() {
 		      std::vector<int> map_index(_node_maps.size());
 		      int map_num, label_index;
 		      char c;
 		      if (!readLine() || !(line >> c) || c == '@') {
 		        if (readSuccess() && line) line.putback(c);
 		        if (!_node_maps.empty())
-		          throw DataFormatError("Cannot find map names");
+		          throw FormatError("Cannot find map names");
 		        return;
+		      }
 		      line.putback(c);
+		      {
 		        std::map<std::string, int> maps;
 		        std::string map;
 		        int index = 0;
 		        while (_reader_bits::readToken(line, map)) {
 		          if (maps.find(map) != maps.end()) {
 		            std::ostringstream msg;
 		            msg << "Multiple occurence of node map: " << map;
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          maps.insert(std::make_pair(map, index));
 		          ++index;
+		        }
 		        for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {
 		          std::map<std::string, int>::iterator jt =
 		            maps.find(_node_maps[i].first);
 		          if (jt == maps.end()) {
 		            std::ostringstream msg;
 		            msg << "Map not found in file: " << _node_maps[i].first;
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          map_index[i] = jt->second;
+		        }
+		        {
 		          std::map<std::string, int>::iterator jt = maps.find("label");
 		          if (jt != maps.end()) {
 		            label_index = jt->second;
 		          } else {
 		            label_index = -1;
+		          }
+		        }
 		        map_num = maps.size();
+		      }
 		      while (readLine() && line >> c && c != '@') {
 		        line.putback(c);
 		        std::vector<std::string> tokens(map_num);
 		        for (int i = 0; i < map_num; ++i) {
 		          if (!_reader_bits::readToken(line, tokens[i])) {
 		            std::ostringstream msg;
 		            msg << "Column not found (" << i + 1 << ")";
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
+		        }
 		        if (line >> std::ws >> c)
-		          throw DataFormatError("Extra character on the end of line");
+		          throw FormatError("Extra character on the end of line");
 		        Node n;
 		        if (!_use_nodes) {
 		          n = _digraph.addNode();
 		          if (label_index != -1)
 		            _node_index.insert(std::make_pair(tokens[label_index], n));
 		        } else {
 		          if (label_index == -1)
-		            throw DataFormatError("Label map not found in file");
+		            throw FormatError("Label map not found in file");
 		          typename std::map<std::string, Node>::iterator it =
 		            _node_index.find(tokens[label_index]);
 		          if (it == _node_index.end()) {
 		            std::ostringstream msg;
 		            msg << "Node with label not found: " << tokens[label_index];
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          n = it->second;
+		        }
 		        for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {
 		          _node_maps[i].second->set(n, tokens[map_index[i]]);
+		        }
+		      }
 		      if (readSuccess()) {
 		        line.putback(c);
+		      }
+		    }
 		    void readArcs() {
 		      std::vector<int> map_index(_arc_maps.size());
 		      int map_num, label_index;
 		      char c;
 		      if (!readLine() || !(line >> c) || c == '@') {
 		        if (readSuccess() && line) line.putback(c);
 		        if (!_arc_maps.empty())
-		          throw DataFormatError("Cannot find map names");
+		          throw FormatError("Cannot find map names");
 		        return;
+		      }
 		      line.putback(c);
+		      {
 		        std::map<std::string, int> maps;
 		        std::string map;
 		        int index = 0;
 		        while (_reader_bits::readToken(line, map)) {
 		          if (maps.find(map) != maps.end()) {
 		            std::ostringstream msg;
 		            msg << "Multiple occurence of arc map: " << map;
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          maps.insert(std::make_pair(map, index));
 		          ++index;
+		        }
 		        for (int i = 0; i < static_cast<int>(_arc_maps.size()); ++i) {
 		          std::map<std::string, int>::iterator jt =
 		            maps.find(_arc_maps[i].first);
 		          if (jt == maps.end()) {
 		            std::ostringstream msg;
 		            msg << "Map not found in file: " << _arc_maps[i].first;
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          map_index[i] = jt->second;
+		        }
+		        {
 		          std::map<std::string, int>::iterator jt = maps.find("label");
 		          if (jt != maps.end()) {
 		            label_index = jt->second;
 		          } else {
 		            label_index = -1;
+		          }
+		        }
 		        map_num = maps.size();
+		      }
 		      while (readLine() && line >> c && c != '@') {
 		        line.putback(c);
 		        std::string source_token;
 		        std::string target_token;
 		        if (!_reader_bits::readToken(line, source_token))
-		          throw DataFormatError("Source not found");
+		          throw FormatError("Source not found");
 		        if (!_reader_bits::readToken(line, target_token))
-		          throw DataFormatError("Target not found");
+		          throw FormatError("Target not found");
 		        std::vector<std::string> tokens(map_num);
 		        for (int i = 0; i < map_num; ++i) {
 		          if (!_reader_bits::readToken(line, tokens[i])) {
 		            std::ostringstream msg;
 		            msg << "Column not found (" << i + 1 << ")";
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
+		        }
 		        if (line >> std::ws >> c)
-		          throw DataFormatError("Extra character on the end of line");
+		          throw FormatError("Extra character on the end of line");
 		        Arc a;
 		        if (!_use_arcs) {
 		          typename NodeIndex::iterator it;
 		          it = _node_index.find(source_token);
 		          if (it == _node_index.end()) {
 		            std::ostringstream msg;
 		            msg << "Item not found: " << source_token;
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          Node source = it->second;
 		          it = _node_index.find(target_token);
 		          if (it == _node_index.end()) {
 		            std::ostringstream msg;
 		            msg << "Item not found: " << target_token;
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          Node target = it->second;
 		          a = _digraph.addArc(source, target);
 		          if (label_index != -1)
 		            _arc_index.insert(std::make_pair(tokens[label_index], a));
 		        } else {
 		          if (label_index == -1)
-		            throw DataFormatError("Label map not found in file");
+		            throw FormatError("Label map not found in file");
 		          typename std::map<std::string, Arc>::iterator it =
 		            _arc_index.find(tokens[label_index]);
 		          if (it == _arc_index.end()) {
 		            std::ostringstream msg;
 		            msg << "Arc with label not found: " << tokens[label_index];
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          a = it->second;
+		        }
 		        for (int i = 0; i < static_cast<int>(_arc_maps.size()); ++i) {
 		          _arc_maps[i].second->set(a, tokens[map_index[i]]);
+		        }
+		      }
 		      if (readSuccess()) {
 		        line.putback(c);
+		      }
+		    }
 		    void readAttributes() {
 		      std::set<std::string> read_attr;
 		      char c;
 		      while (readLine() && line >> c && c != '@') {
 		        line.putback(c);
 		        std::string attr, token;
 		        if (!_reader_bits::readToken(line, attr))
-		          throw DataFormatError("Attribute name not found");
+		          throw FormatError("Attribute name not found");
 		        if (!_reader_bits::readToken(line, token))
-		          throw DataFormatError("Attribute value not found");
+		          throw FormatError("Attribute value not found");
 		        if (line >> c)
-		          throw DataFormatError("Extra character on the end of line");
+		          throw FormatError("Extra character on the end of line");
+		        {
 		          std::set<std::string>::iterator it = read_attr.find(attr);
 		          if (it != read_attr.end()) {
 		            std::ostringstream msg;
 		            msg << "Multiple occurence of attribute " << attr;
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          read_attr.insert(attr);
+		        }
+		        {
 		          typename Attributes::iterator it = _attributes.lower_bound(attr);
 		          while (it != _attributes.end() && it->first == attr) {
 		            it->second->set(token);
 		            ++it;
+		          }
+		        }
+		      }
 		      if (readSuccess()) {
 		        line.putback(c);
+		      }
 		      for (typename Attributes::iterator it = _attributes.begin();
 		           it != _attributes.end(); ++it) {
 		        if (read_attr.find(it->first) == read_attr.end()) {
 		          std::ostringstream msg;
 		          msg << "Attribute not found in file: " << it->first;
-		          throw DataFormatError(msg.str().c_str());
+		          throw FormatError(msg.str());
+		        }
+		      }
+		    }
 		  public:
 		    /// \name Execution of the reader
 		    /// @{
 		    /// \brief Start the batch processing
 		    ///
 		    /// This function starts the batch processing
 		    void run() {
 		      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");
 		      if (!*_is) {
-		        throw DataFormatError("Cannot find file");
+		        throw FormatError("Cannot find file");
+		      }
 		      bool nodes_done = _skip_nodes;
 		      bool arcs_done = _skip_arcs;
 		      bool attributes_done = false;
 		      line_num = 0;
 		      readLine();
 		      skipSection();
 		      while (readSuccess()) {
 		        try {
 		          char c;
 		          std::string section, caption;
 		          line >> c;
 		          _reader_bits::readToken(line, section);
 		          _reader_bits::readToken(line, caption);
 		          if (line >> c)
-		            throw DataFormatError("Extra character on the end of line");
+		            throw FormatError("Extra character on the end of line");
 		          if (section == "nodes" && !nodes_done) {
 		            if (_nodes_caption.empty() || _nodes_caption == caption) {
 		              readNodes();
 		              nodes_done = true;
+		            }
 		          } else if ((section == "arcs" || section == "edges") &&
 		                     !arcs_done) {
 		            if (_arcs_caption.empty() || _arcs_caption == caption) {
 		              readArcs();
 		              arcs_done = true;
+		            }
 		          } else if (section == "attributes" && !attributes_done) {
 		            if (_attributes_caption.empty() || _attributes_caption == caption) {
 		              readAttributes();
 		              attributes_done = true;
+		            }
 		          } else {
 		            readLine();
 		            skipSection();
+		          }
-		        } catch (DataFormatError& error) {
+		        } catch (FormatError& error) {
 		          error.line(line_num);
 		          error.file(_filename);
 		          throw;
+		        }
+		      }
 		      if (!nodes_done) {
-		        throw DataFormatError("Section @nodes not found");
+		        throw FormatError("Section @nodes not found");
+		      }
 		      if (!arcs_done) {
-		        throw DataFormatError("Section @arcs not found");
+		        throw FormatError("Section @arcs not found");
+		      }
 		      if (!attributes_done && !_attributes.empty()) {
-		        throw DataFormatError("Section @attributes not found");
+		        throw FormatError("Section @attributes not found");
+		      }
+		    }
 		    /// @}
 		  };
 		  /// \brief Return a \ref DigraphReader class
 		  ///
 		  /// This function just returns a \ref DigraphReader class.
 		  /// \relates DigraphReader
@@ -1235,24 +1245,25 @@
 		  /// it's value is an edge label prefixed with \c '+' or \c '-'.
 		  template <typename _Graph>
 		  class GraphReader {
 		  public:
 		    typedef _Graph Graph;
 		    TEMPLATE_GRAPH_TYPEDEFS(Graph);
 		  private:
 		    std::istream* _is;
 		    bool local_is;
 		    std::string _filename;
 		    Graph& _graph;
 		    std::string _nodes_caption;
 		    std::string _edges_caption;
 		    std::string _attributes_caption;
 		    typedef std::map<std::string, Node> NodeIndex;
 		    NodeIndex _node_index;
 		    typedef std::map<std::string, Edge> EdgeIndex;
 		    EdgeIndex _edge_index;
@@ -1284,36 +1295,42 @@
 		    /// Construct an undirected graph reader, which reads from the given
 		    /// input stream.
 		    GraphReader(std::istream& is, Graph& graph)
 		      : _is(&is), local_is(false), _graph(graph),
 		        _use_nodes(false), _use_edges(false),
 		        _skip_nodes(false), _skip_edges(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct an undirected graph reader, which reads from the given
 		    /// file.
 		    GraphReader(const std::string& fn, Graph& graph)
-		      : _is(new std::ifstream(fn.c_str())), local_is(true), _graph(graph),
 		      : _is(new std::ifstream(fn.c_str())), local_is(true),
 		        _filename(fn), _graph(graph),
 		        _use_nodes(false), _use_edges(false),
-		        _skip_nodes(false), _skip_edges(false) {}
 		        _skip_nodes(false), _skip_edges(false) {
 		      if (!(*_is)) throw IoError(fn, "Cannot open file");
+		    }
 		    /// \brief Constructor
 		    ///
 		    /// Construct an undirected graph reader, which reads from the given
 		    /// file.
 		    GraphReader(const char* fn, Graph& graph)
-		      : _is(new std::ifstream(fn)), local_is(true), _graph(graph),
 		      : _is(new std::ifstream(fn)), local_is(true),
 		        _filename(fn), _graph(graph),
 		        _use_nodes(false), _use_edges(false),
-		        _skip_nodes(false), _skip_edges(false) {}
 		        _skip_nodes(false), _skip_edges(false) {
 		      if (!(*_is)) throw IoError(fn, "Cannot open file");
+		    }
 		    /// \brief Destructor
 		    ~GraphReader() {
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 		           it != _node_maps.end(); ++it) {
 		        delete it->second;
+		      }
 		      for (typename EdgeMaps::iterator it = _edge_maps.begin();
 		           it != _edge_maps.end(); ++it) {
 		        delete it->second;
+		      }
@@ -1664,273 +1681,273 @@
 		      line.putback(c);
+		    }
 		    void readNodes() {
 		      std::vector<int> map_index(_node_maps.size());
 		      int map_num, label_index;
 		      char c;
 		      if (!readLine() || !(line >> c) || c == '@') {
 		        if (readSuccess() && line) line.putback(c);
 		        if (!_node_maps.empty())
-		          throw DataFormatError("Cannot find map names");
+		          throw FormatError("Cannot find map names");
 		        return;
+		      }
 		      line.putback(c);
+		      {
 		        std::map<std::string, int> maps;
 		        std::string map;
 		        int index = 0;
 		        while (_reader_bits::readToken(line, map)) {
 		          if (maps.find(map) != maps.end()) {
 		            std::ostringstream msg;
 		            msg << "Multiple occurence of node map: " << map;
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          maps.insert(std::make_pair(map, index));
 		          ++index;
+		        }
 		        for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {
 		          std::map<std::string, int>::iterator jt =
 		            maps.find(_node_maps[i].first);
 		          if (jt == maps.end()) {
 		            std::ostringstream msg;
 		            msg << "Map not found in file: " << _node_maps[i].first;
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          map_index[i] = jt->second;
+		        }
+		        {
 		          std::map<std::string, int>::iterator jt = maps.find("label");
 		          if (jt != maps.end()) {
 		            label_index = jt->second;
 		          } else {
 		            label_index = -1;
+		          }
+		        }
 		        map_num = maps.size();
+		      }
 		      while (readLine() && line >> c && c != '@') {
 		        line.putback(c);
 		        std::vector<std::string> tokens(map_num);
 		        for (int i = 0; i < map_num; ++i) {
 		          if (!_reader_bits::readToken(line, tokens[i])) {
 		            std::ostringstream msg;
 		            msg << "Column not found (" << i + 1 << ")";
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
+		        }
 		        if (line >> std::ws >> c)
-		          throw DataFormatError("Extra character on the end of line");
+		          throw FormatError("Extra character on the end of line");
 		        Node n;
 		        if (!_use_nodes) {
 		          n = _graph.addNode();
 		          if (label_index != -1)
 		            _node_index.insert(std::make_pair(tokens[label_index], n));
 		        } else {
 		          if (label_index == -1)
-		            throw DataFormatError("Label map not found in file");
+		            throw FormatError("Label map not found in file");
 		          typename std::map<std::string, Node>::iterator it =
 		            _node_index.find(tokens[label_index]);
 		          if (it == _node_index.end()) {
 		            std::ostringstream msg;
 		            msg << "Node with label not found: " << tokens[label_index];
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          n = it->second;
+		        }
 		        for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {
 		          _node_maps[i].second->set(n, tokens[map_index[i]]);
+		        }
+		      }
 		      if (readSuccess()) {
 		        line.putback(c);
+		      }
+		    }
 		    void readEdges() {
 		      std::vector<int> map_index(_edge_maps.size());
 		      int map_num, label_index;
 		      char c;
 		      if (!readLine() || !(line >> c) || c == '@') {
 		        if (readSuccess() && line) line.putback(c);
 		        if (!_edge_maps.empty())
-		          throw DataFormatError("Cannot find map names");
+		          throw FormatError("Cannot find map names");
 		        return;
+		      }
 		      line.putback(c);
+		      {
 		        std::map<std::string, int> maps;
 		        std::string map;
 		        int index = 0;
 		        while (_reader_bits::readToken(line, map)) {
 		          if (maps.find(map) != maps.end()) {
 		            std::ostringstream msg;
 		            msg << "Multiple occurence of edge map: " << map;
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          maps.insert(std::make_pair(map, index));
 		          ++index;
+		        }
 		        for (int i = 0; i < static_cast<int>(_edge_maps.size()); ++i) {
 		          std::map<std::string, int>::iterator jt =
 		            maps.find(_edge_maps[i].first);
 		          if (jt == maps.end()) {
 		            std::ostringstream msg;
 		            msg << "Map not found in file: " << _edge_maps[i].first;
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          map_index[i] = jt->second;
+		        }
+		        {
 		          std::map<std::string, int>::iterator jt = maps.find("label");
 		          if (jt != maps.end()) {
 		            label_index = jt->second;
 		          } else {
 		            label_index = -1;
+		          }
+		        }
 		        map_num = maps.size();
+		      }
 		      while (readLine() && line >> c && c != '@') {
 		        line.putback(c);
 		        std::string source_token;
 		        std::string target_token;
 		        if (!_reader_bits::readToken(line, source_token))
-		          throw DataFormatError("Node u not found");
+		          throw FormatError("Node u not found");
 		        if (!_reader_bits::readToken(line, target_token))
-		          throw DataFormatError("Node v not found");
+		          throw FormatError("Node v not found");
 		        std::vector<std::string> tokens(map_num);
 		        for (int i = 0; i < map_num; ++i) {
 		          if (!_reader_bits::readToken(line, tokens[i])) {
 		            std::ostringstream msg;
 		            msg << "Column not found (" << i + 1 << ")";
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
+		        }
 		        if (line >> std::ws >> c)
-		          throw DataFormatError("Extra character on the end of line");
+		          throw FormatError("Extra character on the end of line");
 		        Edge e;
 		        if (!_use_edges) {
 		          typename NodeIndex::iterator it;
 		          it = _node_index.find(source_token);
 		          if (it == _node_index.end()) {
 		            std::ostringstream msg;
 		            msg << "Item not found: " << source_token;
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          Node source = it->second;
 		          it = _node_index.find(target_token);
 		          if (it == _node_index.end()) {
 		            std::ostringstream msg;
 		            msg << "Item not found: " << target_token;
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          Node target = it->second;
 		          e = _graph.addEdge(source, target);
 		          if (label_index != -1)
 		            _edge_index.insert(std::make_pair(tokens[label_index], e));
 		        } else {
 		          if (label_index == -1)
-		            throw DataFormatError("Label map not found in file");
+		            throw FormatError("Label map not found in file");
 		          typename std::map<std::string, Edge>::iterator it =
 		            _edge_index.find(tokens[label_index]);
 		          if (it == _edge_index.end()) {
 		            std::ostringstream msg;
 		            msg << "Edge with label not found: " << tokens[label_index];
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          e = it->second;
+		        }
 		        for (int i = 0; i < static_cast<int>(_edge_maps.size()); ++i) {
 		          _edge_maps[i].second->set(e, tokens[map_index[i]]);
+		        }
+		      }
 		      if (readSuccess()) {
 		        line.putback(c);
+		      }
+		    }
 		    void readAttributes() {
 		      std::set<std::string> read_attr;
 		      char c;
 		      while (readLine() && line >> c && c != '@') {
 		        line.putback(c);
 		        std::string attr, token;
 		        if (!_reader_bits::readToken(line, attr))
-		          throw DataFormatError("Attribute name not found");
+		          throw FormatError("Attribute name not found");
 		        if (!_reader_bits::readToken(line, token))
-		          throw DataFormatError("Attribute value not found");
+		          throw FormatError("Attribute value not found");
 		        if (line >> c)
-		          throw DataFormatError("Extra character on the end of line");
+		          throw FormatError("Extra character on the end of line");
+		        {
 		          std::set<std::string>::iterator it = read_attr.find(attr);
 		          if (it != read_attr.end()) {
 		            std::ostringstream msg;
 		            msg << "Multiple occurence of attribute " << attr;
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          read_attr.insert(attr);
+		        }
+		        {
 		          typename Attributes::iterator it = _attributes.lower_bound(attr);
 		          while (it != _attributes.end() && it->first == attr) {
 		            it->second->set(token);
 		            ++it;
+		          }
+		        }
+		      }
 		      if (readSuccess()) {
 		        line.putback(c);
+		      }
 		      for (typename Attributes::iterator it = _attributes.begin();
 		           it != _attributes.end(); ++it) {
 		        if (read_attr.find(it->first) == read_attr.end()) {
 		          std::ostringstream msg;
 		          msg << "Attribute not found in file: " << it->first;
-		          throw DataFormatError(msg.str().c_str());
+		          throw FormatError(msg.str());
+		        }
+		      }
+		    }
 		  public:
 		    /// \name Execution of the reader
 		    /// @{
 		    /// \brief Start the batch processing
 		    ///
 		    /// This function starts the batch processing
@@ -1946,62 +1963,63 @@
 		      readLine();
 		      skipSection();
 		      while (readSuccess()) {
 		        try {
 		          char c;
 		          std::string section, caption;
 		          line >> c;
 		          _reader_bits::readToken(line, section);
 		          _reader_bits::readToken(line, caption);
 		          if (line >> c)
-		            throw DataFormatError("Extra character on the end of line");
+		            throw FormatError("Extra character on the end of line");
 		          if (section == "nodes" && !nodes_done) {
 		            if (_nodes_caption.empty() || _nodes_caption == caption) {
 		              readNodes();
 		              nodes_done = true;
+		            }
 		          } else if ((section == "edges" || section == "arcs") &&
 		                     !edges_done) {
 		            if (_edges_caption.empty() || _edges_caption == caption) {
 		              readEdges();
 		              edges_done = true;
+		            }
 		          } else if (section == "attributes" && !attributes_done) {
 		            if (_attributes_caption.empty() || _attributes_caption == caption) {
 		              readAttributes();
 		              attributes_done = true;
+		            }
 		          } else {
 		            readLine();
 		            skipSection();
+		          }
-		        } catch (DataFormatError& error) {
+		        } catch (FormatError& error) {
 		          error.line(line_num);
 		          error.file(_filename);
 		          throw;
+		        }
+		      }
 		      if (!nodes_done) {
-		        throw DataFormatError("Section @nodes not found");
+		        throw FormatError("Section @nodes not found");
+		      }
 		      if (!edges_done) {
-		        throw DataFormatError("Section @edges not found");
+		        throw FormatError("Section @edges not found");
+		      }
 		      if (!attributes_done && !_attributes.empty()) {
-		        throw DataFormatError("Section @attributes not found");
+		        throw FormatError("Section @attributes not found");
+		      }
+		    }
 		    /// @}
 		  };
 		  /// \brief Return a \ref GraphReader class
 		  ///
 		  /// This function just returns a \ref GraphReader class.
 		  /// \relates GraphReader
@@ -2045,51 +2063,58 @@
 		  /// In the \ref lgf-format "LGF" file extra sections can be placed,
 		  /// which contain any data in arbitrary format. Such sections can be
 		  /// read with this class. A reading rule can be added to the class
 		  /// with two different functions. With the \c sectionLines() function a
 		  /// functor can process the section line-by-line, while with the \c
 		  /// sectionStream() member the section can be read from an input
 		  /// stream.
 		  class SectionReader {
 		  private:
 		    std::istream* _is;
 		    bool local_is;
 		    std::string _filename;
 		    typedef std::map<std::string, _reader_bits::Section*> Sections;
 		    Sections _sections;
 		    int line_num;
 		    std::istringstream line;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section reader, which reads from the given input
 		    /// stream.
 		    SectionReader(std::istream& is)
 		      : _is(&is), local_is(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section reader, which reads from the given file.
 		    SectionReader(const std::string& fn)
-		      : _is(new std::ifstream(fn.c_str())), local_is(true) {}
+		      : _is(new std::ifstream(fn.c_str())), local_is(true),
 		        _filename(fn) {
 		      if (!(*_is)) throw IoError(fn, "Cannot open file");
+		    }
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section reader, which reads from the given file.
 		    SectionReader(const char* fn)
-		      : _is(new std::ifstream(fn)), local_is(true) {}
+		      : _is(new std::ifstream(fn)), local_is(true),
 		        _filename(fn) {
 		      if (!(*_is)) throw IoError(fn, "Cannot open file");
+		    }
 		    /// \brief Destructor
 		    ~SectionReader() {
 		      for (Sections::iterator it = _sections.begin();
 		           it != _sections.end(); ++it) {
 		        delete it->second;
+		      }
 		      if (local_is) {
 		        delete _is;
+		      }
@@ -2227,49 +2252,50 @@
 		      readLine();
 		      skipSection();
 		      while (readSuccess()) {
 		        try {
 		          char c;
 		          std::string section, caption;
 		          line >> c;
 		          _reader_bits::readToken(line, section);
 		          _reader_bits::readToken(line, caption);
 		          if (line >> c)
-		            throw DataFormatError("Extra character on the end of line");
+		            throw FormatError("Extra character on the end of line");
 		          if (extra_sections.find(section) != extra_sections.end()) {
 		            std::ostringstream msg;
 		            msg << "Multiple occurence of section " << section;
-		            throw DataFormatError(msg.str().c_str());
+		            throw FormatError(msg.str());
+		          }
 		          Sections::iterator it = _sections.find(section);
 		          if (it != _sections.end()) {
 		            extra_sections.insert(section);
 		            it->second->process(*_is, line_num);
+		          }
 		          readLine();
 		          skipSection();
-		        } catch (DataFormatError& error) {
+		        } catch (FormatError& error) {
 		          error.line(line_num);
 		          error.file(_filename);
 		          throw;
+		        }
+		      }
 		      for (Sections::iterator it = _sections.begin();
 		           it != _sections.end(); ++it) {
 		        if (extra_sections.find(it->first) == extra_sections.end()) {
 		          std::ostringstream os;
 		          os << "Cannot find section: " << it->first;
-		          throw DataFormatError(os.str().c_str());
+		          throw FormatError(os.str());
+		        }
+		      }
+		    }
 		    /// @}
 		  };
 		  /// \brief Return a \ref SectionReader class
 		  ///
 		  /// This function just returns a \ref SectionReader class.
 		  /// \relates SectionReader
@@ -2351,32 +2377,36 @@
 		    /// \brief Constructor
 		    ///
 		    /// Construct an \e LGF contents reader, which reads from the given
 		    /// input stream.
 		    LgfContents(std::istream& is)
 		      : _is(&is), local_is(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct an \e LGF contents reader, which reads from the given
 		    /// file.
 		    LgfContents(const std::string& fn)
-		      : _is(new std::ifstream(fn.c_str())), local_is(true) {}
 		      : _is(new std::ifstream(fn.c_str())), local_is(true) {
 		      if (!(*_is)) throw IoError(fn, "Cannot open file");
+		    }
 		    /// \brief Constructor
 		    ///
 		    /// Construct an \e LGF contents reader, which reads from the given
 		    /// file.
 		    LgfContents(const char* fn)
-		      : _is(new std::ifstream(fn)), local_is(true) {}
 		      : _is(new std::ifstream(fn)), local_is(true) {
 		      if (!(*_is)) throw IoError(fn, "Cannot open file");
+		    }
 		    /// \brief Destructor
 		    ~LgfContents() {
 		      if (local_is) delete _is;
+		    }
 		  private:
 		    LgfContents(const LgfContents&);
 		    LgfContents& operator=(const LgfContents&);
 		  public:

lemon/lgf_writer.h

Show inline comments

@@ -46,25 +46,25 @@
 		    template <typename Value>
 		    struct DefaultConverter {
 		      std::string operator()(const Value& value) {
 		        std::ostringstream os;
 		        os << value;
 		        return os.str();
+		      }
 		    };
 		    template <typename T>
 		    bool operator<(const T&, const T&) {
-		      throw DataFormatError("Label map is not comparable");
+		      throw FormatError("Label map is not comparable");
+		    }
 		    template <typename _Map>
 		    class MapLess {
 		    public:
 		      typedef _Map Map;
 		      typedef typename Map::Key Item;
 		    private:
 		      const Map& _map;
 		    public:
@@ -194,45 +194,45 @@
 		    template <typename Value>
 		    struct MapLookUpConverter {
 		      const std::map<Value, std::string>& _map;
 		      MapLookUpConverter(const std::map<Value, std::string>& map)
 		        : _map(map) {}
 		      std::string operator()(const Value& str) {
 		        typename std::map<Value, std::string>::const_iterator it =
 		          _map.find(str);
 		        if (it == _map.end()) {
-		          throw DataFormatError("Item not found");
+		          throw FormatError("Item not found");
+		        }
 		        return it->second;
+		      }
 		    };
 		    template <typename Graph>
 		    struct GraphArcLookUpConverter {
 		      const Graph& _graph;
 		      const std::map<typename Graph::Edge, std::string>& _map;
 		      GraphArcLookUpConverter(const Graph& graph,
 		                              const std::map<typename Graph::Edge,
 		                                             std::string>& map)
 		        : _graph(graph), _map(map) {}
 		      std::string operator()(const typename Graph::Arc& val) {
 		        typename std::map<typename Graph::Edge, std::string>
 		          ::const_iterator it = _map.find(val);
 		        if (it == _map.end()) {
-		          throw DataFormatError("Item not found");
+		          throw FormatError("Item not found");
+		        }
 		        return (_graph.direction(val) ? '+' : '-') + it->second;
+		      }
 		    };
 		    inline bool isWhiteSpace(char c) {
 		      return c == ' ' || c == '\t' || c == '\v' ||
 		        c == '\n' || c == '\r' || c == '\f';
+		    }
 		    inline bool isEscaped(char c) {
 		      return c == '\\' || c == '\"' || c == '\'' ||
@@ -453,33 +453,37 @@
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output stream.
 		    DigraphWriter(std::ostream& is, const Digraph& digraph)
 		      : _os(&is), local_os(false), _digraph(digraph),
 		        _skip_nodes(false), _skip_arcs(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output file.
 		    DigraphWriter(const std::string& fn, const Digraph& digraph)
 		      : _os(new std::ofstream(fn.c_str())), local_os(true), _digraph(digraph),
-		        _skip_nodes(false), _skip_arcs(false) {}
 		        _skip_nodes(false), _skip_arcs(false) {
 		      if (!(*_os)) throw IoError(fn, "Cannot write file");
+		    }
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output file.
 		    DigraphWriter(const char* fn, const Digraph& digraph)
 		      : _os(new std::ofstream(fn)), local_os(true), _digraph(digraph),
-		        _skip_nodes(false), _skip_arcs(false) {}
 		        _skip_nodes(false), _skip_arcs(false) {
 		      if (!(*_os)) throw IoError(fn, "Cannot write file");
+		    }
 		    /// \brief Destructor
 		    ~DigraphWriter() {
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 		           it != _node_maps.end(); ++it) {
 		        delete it->second;
+		      }
 		      for (typename ArcMaps::iterator it = _arc_maps.begin();
 		           it != _arc_maps.end(); ++it) {
 		        delete it->second;
+		      }
@@ -1009,33 +1013,37 @@
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output stream.
 		    GraphWriter(std::ostream& is, const Graph& graph)
 		      : _os(&is), local_os(false), _graph(graph),
 		        _skip_nodes(false), _skip_edges(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output file.
 		    GraphWriter(const std::string& fn, const Graph& graph)
 		      : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph),
-		        _skip_nodes(false), _skip_edges(false) {}
 		        _skip_nodes(false), _skip_edges(false) {
 		      if (!(*_os)) throw IoError(fn, "Cannot write file");
+		    }
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output file.
 		    GraphWriter(const char* fn, const Graph& graph)
 		      : _os(new std::ofstream(fn)), local_os(true), _graph(graph),
-		        _skip_nodes(false), _skip_edges(false) {}
 		        _skip_nodes(false), _skip_edges(false) {
 		      if (!(*_os)) throw IoError(fn, "Cannot write file");
+		    }
 		    /// \brief Destructor
 		    ~GraphWriter() {
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 		           it != _node_maps.end(); ++it) {
 		        delete it->second;
+		      }
 		      for (typename EdgeMaps::iterator it = _edge_maps.begin();
 		           it != _edge_maps.end(); ++it) {
 		        delete it->second;
+		      }
@@ -1567,31 +1575,35 @@
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section writer, which writes to the given output
 		    /// stream.
 		    SectionWriter(std::ostream& os)
 		      : _os(&os), local_os(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section writer, which writes into the given file.
 		    SectionWriter(const std::string& fn)
-		      : _os(new std::ofstream(fn.c_str())), local_os(true) {}
 		      : _os(new std::ofstream(fn.c_str())), local_os(true) {
 		      if (!(*_os)) throw IoError(fn, "Cannot write file");
+		    }
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section writer, which writes into the given file.
 		    SectionWriter(const char* fn)
-		      : _os(new std::ofstream(fn)), local_os(true) {}
 		      : _os(new std::ofstream(fn)), local_os(true) {
 		      if (!(*_os)) throw IoError(fn, "Cannot write file");
+		    }
 		    /// \brief Destructor
 		    ~SectionWriter() {
 		      for (Sections::iterator it = _sections.begin();
 		           it != _sections.end(); ++it) {
 		        delete it->second;
+		      }
 		      if (local_os) {
 		        delete _os;
+		      }

0 comments (0 inline)

RhodeCode

Login to your account