COIN-OR::LEMON - Graph Library

Ticket #17: 305d03f9bcea.patch

File 305d03f9bcea.patch, 43.0 KB (added by Balazs Dezso, 11 years ago)
  • demo/lgf_demo.cc

    # HG changeset patch
    # User Balazs Dezso <deba@inf.elte.hu>
    # Date 1222674159 -7200
    # Node ID 305d03f9bceade28b5411268d2c2270fec56ffff
    # Parent  bb40b6db0a587e98535e84eb2b9c92f3df972b6a
    Simplifying exceptions
    
     - Using asserts instead of exceptions for unitialized parameters
     - Only the IO exceptions are used in the lemon
     - DataFormatError is renamed to IoError
     - The IoError is simplified
    
    diff -r bb40b6db0a58 -r 305d03f9bcea demo/lgf_demo.cc
    a b  
    4949      node("source", s).             // read 'source' node to s
    5050      node("target", t).             // read 'target' node to t
    5151      run();
    52   } catch (DataFormatError& error) { // check if there was any error
     52  } catch (IoError& error) { // check if there was any error
    5353    std::cerr << "Error: " << error.what() << std::endl;
    5454    return -1;
    5555  }
  • lemon/arg_parser.h

    diff -r bb40b6db0a58 -r 305d03f9bcea lemon/arg_parser.h
    a b  
    310310
    311311    ///This is the type of the return value of ArgParser::operator[]().
    312312    ///It automatically converts to \c int, \c double, \c bool or
    313     ///\c std::string if the type of the option matches, otherwise it
    314     ///throws an exception (i.e. it performs runtime type checking).
     313    ///\c std::string if the type of the option matches, which is checked
     314    ///with an \ref LEMON_ASSERT "assertion" (i.e. it performs runtime
     315    ///type checking).
    315316    class RefType
    316317    {
    317318      const ArgParser &_parser;
  • lemon/bfs.h

    diff -r bb40b6db0a58 -r 305d03f9bcea lemon/bfs.h
    a b  
    135135#endif
    136136  class Bfs {
    137137  public:
    138     ///\ref Exception for uninitialized parameters.
    139 
    140     ///This error represents problems in the initialization of the
    141     ///parameters of the algorithm.
    142     class UninitializedParameter : public lemon::UninitializedParameter {
    143     public:
    144       virtual const char* what() const throw() {
    145         return "lemon::Bfs::UninitializedParameter";
    146       }
    147     };
    148138
    149139    ///The type of the digraph the algorithm runs on.
    150140    typedef typename TR::Digraph Digraph;
     
    232222      typedef T PredMap;
    233223      static PredMap *createPredMap(const Digraph &)
    234224      {
    235         throw UninitializedParameter();
     225        LEMON_ASSERT(false, "PredMap is not initialized");
    236226      }
    237227    };
    238228    ///\brief \ref named-templ-param "Named parameter" for setting
     
    250240      typedef T DistMap;
    251241      static DistMap *createDistMap(const Digraph &)
    252242      {
    253         throw UninitializedParameter();
     243        LEMON_ASSERT(false, "DistMap is not initialized");
    254244      }
    255245    };
    256246    ///\brief \ref named-templ-param "Named parameter" for setting
     
    268258      typedef T ReachedMap;
    269259      static ReachedMap *createReachedMap(const Digraph &)
    270260      {
    271         throw UninitializedParameter();
     261        LEMON_ASSERT(false, "ReachedMap is not initialized");
    272262      }
    273263    };
    274264    ///\brief \ref named-templ-param "Named parameter" for setting
     
    286276      typedef T ProcessedMap;
    287277      static ProcessedMap *createProcessedMap(const Digraph &)
    288278      {
    289         throw UninitializedParameter();
     279        LEMON_ASSERT(false, "ProcessedMap is not initialized");
    290280      }
    291281    };
    292282    ///\brief \ref named-templ-param "Named parameter" for setting
     
    10401030    ///\return \c true if \c t is reachable form \c s.
    10411031    bool run(Node s, Node t)
    10421032    {
    1043       if (s==INVALID || t==INVALID) throw UninitializedParameter();
    10441033      Bfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
    10451034      if (Base::_pred)
    10461035        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
     
    13231312  class BfsVisit {
    13241313  public:
    13251314
    1326     /// \brief \ref Exception for uninitialized parameters.
    1327     ///
    1328     /// This error represents problems in the initialization
    1329     /// of the parameters of the algorithm.
    1330     class UninitializedParameter : public lemon::UninitializedParameter {
    1331     public:
    1332       virtual const char* what() const throw()
    1333       {
    1334         return "lemon::BfsVisit::UninitializedParameter";
    1335       }
    1336     };
    1337 
    13381315    ///The traits class.
    13391316    typedef _Traits Traits;
    13401317
     
    13891366    struct SetReachedMapTraits : public Traits {
    13901367      typedef T ReachedMap;
    13911368      static ReachedMap *createReachedMap(const Digraph &digraph) {
    1392         throw UninitializedParameter();
     1369        LEMON_ASSERT(false, "ReachedMap is not initialized");
    13931370      }
    13941371    };
    13951372    /// \brief \ref named-templ-param "Named parameter" for setting
  • lemon/concepts/heap.h

    diff -r bb40b6db0a58 -r 305d03f9bcea lemon/concepts/heap.h
    a b  
    129129      /// already stored in the heap.
    130130      /// Otherwise it inserts the given item with the given priority.
    131131      ///
    132       /// It may throw an \ref UnderflowPriorityException.
    133132      /// \param i The item.
    134133      /// \param p The priority.
    135134      void set(const Item &i, const Prio &p) {}
  • lemon/dfs.h

    diff -r bb40b6db0a58 -r 305d03f9bcea lemon/dfs.h
    a b  
    136136#endif
    137137  class Dfs {
    138138  public:
    139     ///\ref Exception for uninitialized parameters.
    140 
    141     ///This error represents problems in the initialization of the
    142     ///parameters of the algorithm.
    143     class UninitializedParameter : public lemon::UninitializedParameter {
    144     public:
    145       virtual const char* what() const throw() {
    146         return "lemon::Dfs::UninitializedParameter";
    147       }
    148     };
    149139
    150140    ///The type of the digraph the algorithm runs on.
    151141    typedef typename TR::Digraph Digraph;
     
    232222      typedef T PredMap;
    233223      static PredMap *createPredMap(const Digraph &)
    234224      {
    235         throw UninitializedParameter();
     225        LEMON_ASSERT(false, "PredMap is not initialized");
    236226      }
    237227    };
    238228    ///\brief \ref named-templ-param "Named parameter" for setting
     
    250240      typedef T DistMap;
    251241      static DistMap *createDistMap(const Digraph &)
    252242      {
    253         throw UninitializedParameter();
     243        LEMON_ASSERT(false, "DistMap is not initialized");
    254244      }
    255245    };
    256246    ///\brief \ref named-templ-param "Named parameter" for setting
     
    268258      typedef T ReachedMap;
    269259      static ReachedMap *createReachedMap(const Digraph &)
    270260      {
    271         throw UninitializedParameter();
     261        LEMON_ASSERT(false, "ReachedMap is not initialized");
    272262      }
    273263    };
    274264    ///\brief \ref named-templ-param "Named parameter" for setting
     
    286276      typedef T ProcessedMap;
    287277      static ProcessedMap *createProcessedMap(const Digraph &)
    288278      {
    289         throw UninitializedParameter();
     279        LEMON_ASSERT(false, "ProcessedMap is not initialized");
    290280      }
    291281    };
    292282    ///\brief \ref named-templ-param "Named parameter" for setting
     
    974964    ///\return \c true if \c t is reachable form \c s.
    975965    bool run(Node s, Node t)
    976966    {
    977       if (s==INVALID || t==INVALID) throw UninitializedParameter();
    978967      Dfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g));
    979968      if (Base::_pred)
    980969        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
     
    12701259  class DfsVisit {
    12711260  public:
    12721261
    1273     /// \brief \ref Exception for uninitialized parameters.
    1274     ///
    1275     /// This error represents problems in the initialization
    1276     /// of the parameters of the algorithm.
    1277     class UninitializedParameter : public lemon::UninitializedParameter {
    1278     public:
    1279       virtual const char* what() const throw()
    1280       {
    1281         return "lemon::DfsVisit::UninitializedParameter";
    1282       }
    1283     };
    1284 
    12851262    ///The traits class.
    12861263    typedef _Traits Traits;
    12871264
     
    13361313    struct SetReachedMapTraits : public Traits {
    13371314      typedef T ReachedMap;
    13381315      static ReachedMap *createReachedMap(const Digraph &digraph) {
    1339         throw UninitializedParameter();
     1316        LEMON_ASSERT(false, "ReachedMap is not initialized");
    13401317      }
    13411318    };
    13421319    /// \brief \ref named-templ-param "Named parameter" for setting
  • lemon/dijkstra.h

    diff -r bb40b6db0a58 -r 305d03f9bcea lemon/dijkstra.h
    a b  
    225225#endif
    226226  class Dijkstra {
    227227  public:
    228     ///\ref Exception for uninitialized parameters.
    229 
    230     ///This error represents problems in the initialization of the
    231     ///parameters of the algorithm.
    232     class UninitializedParameter : public lemon::UninitializedParameter {
    233     public:
    234       virtual const char* what() const throw() {
    235         return "lemon::Dijkstra::UninitializedParameter";
    236       }
    237     };
    238228
    239229    ///The type of the digraph the algorithm runs on.
    240230    typedef typename TR::Digraph Digraph;
     
    332322      typedef T PredMap;
    333323      static PredMap *createPredMap(const Digraph &)
    334324      {
    335         throw UninitializedParameter();
     325        LEMON_ASSERT(false, "PredMap is not initialized");
    336326      }
    337327    };
    338328    ///\brief \ref named-templ-param "Named parameter" for setting
     
    351341      typedef T DistMap;
    352342      static DistMap *createDistMap(const Digraph &)
    353343      {
    354         throw UninitializedParameter();
     344        LEMON_ASSERT(false, "DistMap is not initialized");
    355345      }
    356346    };
    357347    ///\brief \ref named-templ-param "Named parameter" for setting
     
    370360      typedef T ProcessedMap;
    371361      static ProcessedMap *createProcessedMap(const Digraph &)
    372362      {
    373         throw UninitializedParameter();
     363        LEMON_ASSERT(false, "ProcessedMap is not initialized");
    374364      }
    375365    };
    376366    ///\brief \ref named-templ-param "Named parameter" for setting
     
    408398      typedef CR HeapCrossRef;
    409399      typedef H Heap;
    410400      static HeapCrossRef *createHeapCrossRef(const Digraph &) {
    411         throw UninitializedParameter();
     401        LEMON_ASSERT(false, "HeapCrossRef is not initialized");
    412402      }
    413403      static Heap *createHeap(HeapCrossRef &)
    414404      {
    415         throw UninitializedParameter();
     405        LEMON_ASSERT(false, "Heap is not initialized");
    416406      }
    417407    };
    418408    ///\brief \ref named-templ-param "Named parameter" for setting
     
    11581148    ///in order to compute the shortest path to each node.
    11591149    void run(Node s)
    11601150    {
    1161       if (s==INVALID) throw UninitializedParameter();
    11621151      Dijkstra<Digraph,LengthMap,TR>
    11631152        dijk(*reinterpret_cast<const Digraph*>(Base::_g),
    11641153             *reinterpret_cast<const LengthMap*>(Base::_length));
     
    11801169    ///\return \c true if \c t is reachable form \c s.
    11811170    bool run(Node s, Node t)
    11821171    {
    1183       if (s==INVALID || t==INVALID) throw UninitializedParameter();
    11841172      Dijkstra<Digraph,LengthMap,TR>
    11851173        dijk(*reinterpret_cast<const Digraph*>(Base::_g),
    11861174             *reinterpret_cast<const LengthMap*>(Base::_length));
  • lemon/error.h

    diff -r bb40b6db0a58 -r 305d03f9bcea lemon/error.h
    a b  
    3535  /// \addtogroup exceptions
    3636  /// @{
    3737
    38   /// \brief Exception safe wrapper class.
     38  /// \brief Generic exception class.
    3939  ///
    40   /// Exception safe wrapper class to implement the members of exceptions.
    41   template <typename _Type>
    42   class ExceptionMember {
    43   public:
    44     typedef _Type Type;
    45 
    46     ExceptionMember() throw() {
    47       try {
    48         ptr.reset(new Type());
    49       } catch (...) {}
    50     }
    51 
    52     ExceptionMember(const Type& type) throw() {
    53       try {
    54         ptr.reset(new Type());
    55         if (ptr.get() == 0) return;
    56         *ptr = type;
    57       } catch (...) {}
    58     }
    59 
    60     ExceptionMember(const ExceptionMember& copy) throw() {
    61       try {
    62         if (!copy.valid()) return;
    63         ptr.reset(new Type());
    64         if (ptr.get() == 0) return;
    65         *ptr = copy.get();
    66       } catch (...) {}
    67     }
    68 
    69     ExceptionMember& operator=(const ExceptionMember& copy) throw() {
    70       if (ptr.get() == 0) return;
    71       try {
    72         if (!copy.valid()) return;
    73         *ptr = copy.get();
    74       } catch (...) {}
    75     }
    76 
    77     void set(const Type& type) throw() {
    78       if (ptr.get() == 0) return;
    79       try {
    80         *ptr = type;
    81       } catch (...) {}
    82     }
    83 
    84     const Type& get() const {
    85       return *ptr;
    86     }
    87 
    88     bool valid() const throw() {
    89       return ptr.get() != 0;
    90     }
    91 
    92   private:
    93     std::auto_ptr<_Type> ptr;
    94   };
    95 
    96   /// Exception-safe convenient error message builder class.
    97 
    98   /// Helper class which provides a convenient ostream-like (operator <<
    99   /// based) interface to create a string message. Mostly useful in
    100   /// exception classes (therefore the name).
    101   class ErrorMessage {
    102   protected:
    103     ///\e
    104 
    105     mutable std::auto_ptr<std::ostringstream> buf;
    106 
    107     ///\e
    108     bool init() throw() {
    109       try {
    110         buf.reset(new std::ostringstream);
    111       }
    112       catch(...) {
    113         buf.reset();
    114       }
    115       return buf.get();
    116     }
    117 
    118   public:
    119 
    120     ///\e
    121     ErrorMessage() throw() { init(); }
    122 
    123     ErrorMessage(const ErrorMessage& em) throw() : buf(em.buf) { }
    124 
    125     ///\e
    126     ErrorMessage(const char *msg) throw() {
    127       init();
    128       *this << msg;
    129     }
    130 
    131     ///\e
    132     ErrorMessage(const std::string &msg) throw() {
    133       init();
    134       *this << msg;
    135     }
    136 
    137     ///\e
    138     template <typename T>
    139     ErrorMessage& operator<<(const T &t) throw() {
    140       if( ! buf.get() ) return *this;
    141 
    142       try {
    143         *buf << t;
    144       }
    145       catch(...) {
    146         buf.reset();
    147       }
    148       return *this;
    149     }
    150 
    151     ///\e
    152     const char* message() throw() {
    153       if( ! buf.get() ) return 0;
    154 
    155       const char* mes = 0;
    156       try {
    157         mes = buf->str().c_str();
    158       }
    159       catch(...) {}
    160       return mes;
    161     }
    162 
    163   };
    164 
    165   /// Generic exception class.
    166 
    16740  /// Base class for exceptions used in LEMON.
    16841  ///
    16942  class Exception : public std::exception {
    17043  public:
    171     ///\e
     44    ///\e Constructor
    17245    Exception() {}
    173     ///\e
     46    ///\e Virtual destructor
    17447    virtual ~Exception() throw() {}
    175     ///\e
     48    ///\e A short description of the exception
    17649    virtual const char* what() const throw() {
    17750      return "lemon::Exception";
    17851    }
    17952  };
    18053
    181   /// One of the two main subclasses of \ref Exception.
    182 
    183   /// Logic errors represent problems in the internal logic of a program;
    184   /// in theory, these are preventable, and even detectable before the
    185   /// program runs (e.g. violations of class invariants).
    186   ///
    187   /// A typical example for this is \ref UninitializedParameter.
    188   class LogicError : public Exception {
    189   public:
    190     virtual const char* what() const throw() {
    191       return "lemon::LogicError";
    192     }
    193   };
    194 
    195   /// \ref Exception for uninitialized parameters.
    196 
    197   /// This error represents problems in the initialization
    198   /// of the parameters of the algorithms.
    199   class UninitializedParameter : public LogicError {
    200   public:
    201     virtual const char* what() const throw() {
    202       return "lemon::UninitializedParameter";
    203     }
    204   };
    205 
    206 
    207   /// One of the two main subclasses of \ref Exception.
    208 
    209   /// Runtime errors represent problems outside the scope of a program;
    210   /// they cannot be easily predicted and can generally only be caught
    211   /// as the program executes.
    212   class RuntimeError : public Exception {
    213   public:
    214     virtual const char* what() const throw() {
    215       return "lemon::RuntimeError";
    216     }
    217   };
    218 
    21954  ///\e
    220   class RangeError : public RuntimeError {
    221   public:
    222     virtual const char* what() const throw() {
    223       return "lemon::RangeError";
    224     }
    225   };
    226 
    227   ///\e
    228   class IoError : public RuntimeError {
    229   public:
    230     virtual const char* what() const throw() {
    231       return "lemon::IoError";
    232     }
    233   };
    234 
    235   ///\e
    236   class DataFormatError : public IoError {
     55  class IoError : Exception {
    23756  protected:
    238     ExceptionMember<std::string> _message;
    239     ExceptionMember<std::string> _file;
     57    std::string _message;
     58    std::string _file;
    24059    int _line;
    24160
    242     mutable ExceptionMember<std::string> _message_holder;
     61    mutable std::string _what;
    24362  public:
    24463
    245     DataFormatError(const DataFormatError &dfe) :
    246       IoError(dfe), _message(dfe._message), _file(dfe._file),
    247       _line(dfe._line) {}
    248 
    249     ///\e
    250     explicit DataFormatError(const char *the_message)
    251       : _message(the_message), _line(0) {}
    252 
    253     ///\e
    254     DataFormatError(const std::string &file_name, int line_num,
    255                     const char *the_message)
    256       : _message(the_message), _line(line_num) { file(file_name); }
    257 
    258     ///\e
    259     void line(int ln) { _line = ln; }
    260     ///\e
    261     void message(const std::string& msg) { _message.set(msg); }
    262     ///\e
    263     void file(const std::string &fl) { _file.set(fl); }
    264 
    265     ///\e
    266     int line() const { return _line; }
    267     ///\e
    268     const char* message() const {
    269       if (_message.valid() && !_message.get().empty()) {
    270         return _message.get().c_str();
    271       } else {
    272         return 0;
    273       }
     64    /// Copy constructor
     65    IoError(const IoError &error) {
     66      message(error._message);
     67      file(error._file);
     68      line(error._line);
    27469    }
    27570
    276     /// \brief Returns the filename.
    277     ///
    278     /// Returns \e null if the filename was not specified.
    279     const char* file() const {
    280       if (_file.valid() && !_file.get().empty()) {
    281         return _file.get().c_str();
    282       } else {
    283         return 0;
    284       }
     71    /// Constructor
     72    explicit IoError(const char *message) {
     73      IoError::message(message);
     74      _line = 0;
    28575    }
    28676
    287     ///\e
     77    /// Constructor
     78    explicit IoError(const std::string &message) {
     79      IoError::message(message);
     80      _line = 0;
     81    }
     82
     83    /// Constructor
     84    IoError(const std::string &file, int line, const char *message) {
     85      IoError::message(message);
     86      IoError::file(file);
     87      IoError::line(line);
     88    }
     89
     90    /// Constructor
     91    IoError(const std::string &file, int line, const std::string &message) {
     92      IoError::message(message);
     93      IoError::file(file);
     94      IoError::line(line);
     95    }
     96
     97    /// Virtual destructor
     98    virtual ~IoError() throw() {}
     99
     100    /// Set the line number
     101    void line(int line) { _line = line; }
     102
     103    /// Set the error message
     104    void message(const char *message) {
     105      try {
     106        _message = message;
     107      } catch (...) {}
     108    }
     109
     110    /// Set the error message
     111    void message(const std::string& message) {
     112      try {
     113        _message = message;
     114      } catch (...) {}
     115    }
     116
     117    /// Set the file name
     118    void file(const std::string &file) {
     119      try {
     120        _file = file;
     121      } catch (...) {}
     122    }
     123
     124    /// \brief Returns the line number
     125    ///
     126    /// Returns the line number or zero if it was not specified.
     127    int line() const { return _line; }
     128
     129    /// Returns the error message
     130    const std::string& message() const {
     131      return _message;
     132    }
     133
     134    /// \brief Returns the filename
     135    ///
     136    /// Returns the filename or empty string if the filename was not
     137    /// specified.
     138    const std::string& file() const {
     139      return _file;
     140    }
     141
     142    /// \brief Returns a short error message
     143    ///
     144    /// Returns a short error message which contains the message, the
     145    /// file name and the line number.
    288146    virtual const char* what() const throw() {
    289147      try {
    290         std::ostringstream ostr;
    291         ostr << "lemon:DataFormatError" << ": ";
    292         if (message()) ostr << message();
    293         if( file() || line() != 0 ) {
    294           ostr << " (";
    295           if( file() ) ostr << "in file '" << file() << "'";
    296           if( file() && line() != 0 ) ostr << " ";
    297           if( line() != 0 ) ostr << "at line " << line();
    298           ostr << ")";
     148        _what.clear();
     149        std::ostringstream oss;
     150        oss << "lemon:IoError" << ": ";
     151        oss << message();
     152        if (!file().empty() || line() != 0) {
     153          oss << " (";
     154          if (!file().empty()) oss << "in file '" << file() << "'";
     155          if (!file().empty() && line() != 0) oss << " ";
     156          if (line() != 0) oss << "at line " << line();
     157          oss << ")";
    299158        }
    300         _message_holder.set(ostr.str());
     159        _what = oss.str();
    301160      }
    302161      catch (...) {}
    303       if( _message_holder.valid()) return _message_holder.get().c_str();
    304       return "lemon:DataFormatError";
     162      if (!_what.empty()) return _what.c_str();
     163      else return "lemon:IoError";
    305164    }
    306165
    307     virtual ~DataFormatError() throw() {}
    308   };
    309 
    310   ///\e
    311   class FileOpenError : public IoError {
    312   protected:
    313     ExceptionMember<std::string> _file;
    314 
    315     mutable ExceptionMember<std::string> _message_holder;
    316   public:
    317 
    318     FileOpenError(const FileOpenError &foe) :
    319       IoError(foe), _file(foe._file) {}
    320 
    321     ///\e
    322     explicit FileOpenError(const std::string& fl)
    323       : _file(fl) {}
    324 
    325 
    326     ///\e
    327     void file(const std::string &fl) { _file.set(fl); }
    328 
    329     /// \brief Returns the filename.
    330     ///
    331     /// Returns \e null if the filename was not specified.
    332     const char* file() const {
    333       if (_file.valid() && !_file.get().empty()) {
    334         return _file.get().c_str();
    335       } else {
    336         return 0;
    337       }
    338     }
    339 
    340     ///\e
    341     virtual const char* what() const throw() {
    342       try {
    343         std::ostringstream ostr;
    344         ostr << "lemon::FileOpenError" << ": ";
    345         ostr << "Cannot open file - " << file();
    346         _message_holder.set(ostr.str());
    347       }
    348       catch (...) {}
    349       if( _message_holder.valid()) return _message_holder.get().c_str();
    350       return "lemon::FileOpenError";
    351     }
    352     virtual ~FileOpenError() throw() {}
    353   };
    354 
    355   class IoParameterError : public IoError {
    356   protected:
    357     ExceptionMember<std::string> _message;
    358     ExceptionMember<std::string> _file;
    359 
    360     mutable ExceptionMember<std::string> _message_holder;
    361   public:
    362 
    363     IoParameterError(const IoParameterError &ile) :
    364       IoError(ile), _message(ile._message), _file(ile._file) {}
    365 
    366     ///\e
    367     explicit IoParameterError(const char *the_message)
    368       : _message(the_message) {}
    369 
    370     ///\e
    371     IoParameterError(const char *file_name, const char *the_message)
    372       : _message(the_message), _file(file_name) {}
    373 
    374      ///\e
    375     void message(const std::string& msg) { _message.set(msg); }
    376     ///\e
    377     void file(const std::string &fl) { _file.set(fl); }
    378 
    379      ///\e
    380     const char* message() const {
    381       if (_message.valid()) {
    382         return _message.get().c_str();
    383       } else {
    384         return 0;
    385       }
    386     }
    387 
    388     /// \brief Returns the filename.
    389     ///
    390     /// Returns \c 0 if the filename was not specified.
    391     const char* file() const {
    392       if (_file.valid()) {
    393         return _file.get().c_str();
    394       } else {
    395         return 0;
    396       }
    397     }
    398 
    399     ///\e
    400     virtual const char* what() const throw() {
    401       try {
    402         std::ostringstream ostr;
    403         if (message()) ostr << message();
    404         if (file()) ostr << "(when reading file '" << file() << "')";
    405         _message_holder.set(ostr.str());
    406       }
    407       catch (...) {}
    408       if( _message_holder.valid() ) return _message_holder.get().c_str();
    409       return "lemon:IoParameterError";
    410     }
    411     virtual ~IoParameterError() throw() {}
    412166  };
    413167
    414168  /// @}
  • lemon/lgf_reader.h

    diff -r bb40b6db0a58 -r 305d03f9bcea lemon/lgf_reader.h
    a b  
    5252
    5353        char c;
    5454        if (is >> std::ws >> c) {
    55           throw DataFormatError("Remaining characters in token");
     55          throw IoError("Remaining characters in token");
    5656        }
    5757        return value;
    5858      }
     
    166166        if (it == _map.end()) {
    167167          std::ostringstream msg;
    168168          msg << "Item not found: " << str;
    169           throw DataFormatError(msg.str().c_str());
     169          throw IoError(msg.str());
    170170        }
    171171        return it->second;
    172172      }
     
    184184
    185185      typename Graph::Arc operator()(const std::string& str) {
    186186        if (str.empty() || (str[0] != '+' && str[0] != '-')) {
    187           throw DataFormatError("Item must start with '+' or '-'");
     187          throw IoError("Item must start with '+' or '-'");
    188188        }
    189189        typename std::map<std::string, typename Graph::Edge>
    190190          ::const_iterator it = _map.find(str.substr(1));
    191191        if (it == _map.end()) {
    192           throw DataFormatError("Item not found");
     192          throw IoError("Item not found");
    193193        }
    194194        return _graph.direct(it->second, str[0] == '+');
    195195      }
     
    235235    inline char readEscape(std::istream& is) {
    236236      char c;
    237237      if (!is.get(c))
    238         throw DataFormatError("Escape format error");
     238        throw IoError("Escape format error");
    239239
    240240      switch (c) {
    241241      case '\\':
     
    264264        {
    265265          int code;
    266266          if (!is.get(c) || !isHex(c))
    267             throw DataFormatError("Escape format error");
     267            throw IoError("Escape format error");
    268268          else if (code = valueHex(c), !is.get(c) || !isHex(c)) is.putback(c);
    269269          else code = code * 16 + valueHex(c);
    270270          return code;
     
    273273        {
    274274          int code;
    275275          if (!isOct(c))
    276             throw DataFormatError("Escape format error");
     276            throw IoError("Escape format error");
    277277          else if (code = valueOct(c), !is.get(c) || !isOct(c))
    278278            is.putback(c);
    279279          else if (code = code * 8 + valueOct(c), !is.get(c) || !isOct(c))
     
    300300          os << c;
    301301        }
    302302        if (!is)
    303           throw DataFormatError("Quoted format error");
     303          throw IoError("Quoted format error");
    304304      } else {
    305305        is.putback(c);
    306306        while (is.get(c) && !isWhiteSpace(c)) {
     
    845845      if (!readLine() || !(line >> c) || c == '@') {
    846846        if (readSuccess() && line) line.putback(c);
    847847        if (!_node_maps.empty())
    848           throw DataFormatError("Cannot find map names");
     848          throw IoError("Cannot find map names");
    849849        return;
    850850      }
    851851      line.putback(c);
     
    859859          if (maps.find(map) != maps.end()) {
    860860            std::ostringstream msg;
    861861            msg << "Multiple occurence of node map: " << map;
    862             throw DataFormatError(msg.str().c_str());
     862            throw IoError(msg.str());
    863863          }
    864864          maps.insert(std::make_pair(map, index));
    865865          ++index;
     
    871871          if (jt == maps.end()) {
    872872            std::ostringstream msg;
    873873            msg << "Map not found in file: " << _node_maps[i].first;
    874             throw DataFormatError(msg.str().c_str());
     874            throw IoError(msg.str());
    875875          }
    876876          map_index[i] = jt->second;
    877877        }
     
    895895          if (!_reader_bits::readToken(line, tokens[i])) {
    896896            std::ostringstream msg;
    897897            msg << "Column not found (" << i + 1 << ")";
    898             throw DataFormatError(msg.str().c_str());
     898            throw IoError(msg.str());
    899899          }
    900900        }
    901901        if (line >> std::ws >> c)
    902           throw DataFormatError("Extra character on the end of line");
     902          throw IoError("Extra character on the end of line");
    903903
    904904        Node n;
    905905        if (!_use_nodes) {
     
    908908            _node_index.insert(std::make_pair(tokens[label_index], n));
    909909        } else {
    910910          if (label_index == -1)
    911             throw DataFormatError("Label map not found in file");
     911            throw IoError("Label map not found in file");
    912912          typename std::map<std::string, Node>::iterator it =
    913913            _node_index.find(tokens[label_index]);
    914914          if (it == _node_index.end()) {
    915915            std::ostringstream msg;
    916916            msg << "Node with label not found: " << tokens[label_index];
    917             throw DataFormatError(msg.str().c_str());
     917            throw IoError(msg.str());
    918918          }
    919919          n = it->second;
    920920        }
     
    938938      if (!readLine() || !(line >> c) || c == '@') {
    939939        if (readSuccess() && line) line.putback(c);
    940940        if (!_arc_maps.empty())
    941           throw DataFormatError("Cannot find map names");
     941          throw IoError("Cannot find map names");
    942942        return;
    943943      }
    944944      line.putback(c);
     
    952952          if (maps.find(map) != maps.end()) {
    953953            std::ostringstream msg;
    954954            msg << "Multiple occurence of arc map: " << map;
    955             throw DataFormatError(msg.str().c_str());
     955            throw IoError(msg.str());
    956956          }
    957957          maps.insert(std::make_pair(map, index));
    958958          ++index;
     
    964964          if (jt == maps.end()) {
    965965            std::ostringstream msg;
    966966            msg << "Map not found in file: " << _arc_maps[i].first;
    967             throw DataFormatError(msg.str().c_str());
     967            throw IoError(msg.str());
    968968          }
    969969          map_index[i] = jt->second;
    970970        }
     
    987987        std::string target_token;
    988988
    989989        if (!_reader_bits::readToken(line, source_token))
    990           throw DataFormatError("Source not found");
     990          throw IoError("Source not found");
    991991
    992992        if (!_reader_bits::readToken(line, target_token))
    993           throw DataFormatError("Target not found");
     993          throw IoError("Target not found");
    994994
    995995        std::vector<std::string> tokens(map_num);
    996996        for (int i = 0; i < map_num; ++i) {
    997997          if (!_reader_bits::readToken(line, tokens[i])) {
    998998            std::ostringstream msg;
    999999            msg << "Column not found (" << i + 1 << ")";
    1000             throw DataFormatError(msg.str().c_str());
     1000            throw IoError(msg.str());
    10011001          }
    10021002        }
    10031003        if (line >> std::ws >> c)
    1004           throw DataFormatError("Extra character on the end of line");
     1004          throw IoError("Extra character on the end of line");
    10051005
    10061006        Arc a;
    10071007        if (!_use_arcs) {
     
    10121012          if (it == _node_index.end()) {
    10131013            std::ostringstream msg;
    10141014            msg << "Item not found: " << source_token;
    1015             throw DataFormatError(msg.str().c_str());
     1015            throw IoError(msg.str());
    10161016          }
    10171017          Node source = it->second;
    10181018
     
    10201020          if (it == _node_index.end()) {
    10211021            std::ostringstream msg;
    10221022            msg << "Item not found: " << target_token;
    1023             throw DataFormatError(msg.str().c_str());
     1023            throw IoError(msg.str());
    10241024          }
    10251025          Node target = it->second;
    10261026
     
    10291029            _arc_index.insert(std::make_pair(tokens[label_index], a));
    10301030        } else {
    10311031          if (label_index == -1)
    1032             throw DataFormatError("Label map not found in file");
     1032            throw IoError("Label map not found in file");
    10331033          typename std::map<std::string, Arc>::iterator it =
    10341034            _arc_index.find(tokens[label_index]);
    10351035          if (it == _arc_index.end()) {
    10361036            std::ostringstream msg;
    10371037            msg << "Arc with label not found: " << tokens[label_index];
    1038             throw DataFormatError(msg.str().c_str());
     1038            throw IoError(msg.str());
    10391039          }
    10401040          a = it->second;
    10411041        }
     
    10601060
    10611061        std::string attr, token;
    10621062        if (!_reader_bits::readToken(line, attr))
    1063           throw DataFormatError("Attribute name not found");
     1063          throw IoError("Attribute name not found");
    10641064        if (!_reader_bits::readToken(line, token))
    1065           throw DataFormatError("Attribute value not found");
     1065          throw IoError("Attribute value not found");
    10661066        if (line >> c)
    1067           throw DataFormatError("Extra character on the end of line");
     1067          throw IoError("Extra character on the end of line");
    10681068
    10691069        {
    10701070          std::set<std::string>::iterator it = read_attr.find(attr);
    10711071          if (it != read_attr.end()) {
    10721072            std::ostringstream msg;
    10731073            msg << "Multiple occurence of attribute " << attr;
    1074             throw DataFormatError(msg.str().c_str());
     1074            throw IoError(msg.str());
    10751075          }
    10761076          read_attr.insert(attr);
    10771077        }
     
    10931093        if (read_attr.find(it->first) == read_attr.end()) {
    10941094          std::ostringstream msg;
    10951095          msg << "Attribute not found in file: " << it->first;
    1096           throw DataFormatError(msg.str().c_str());
     1096          throw IoError(msg.str());
    10971097        }
    10981098      }
    10991099    }
     
    11091109    void run() {
    11101110      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");
    11111111      if (!*_is) {
    1112         throw DataFormatError("Cannot find file");
     1112        throw IoError("Cannot find file");
    11131113      }
    11141114
    11151115      bool nodes_done = _skip_nodes;
     
    11291129          _reader_bits::readToken(line, caption);
    11301130
    11311131          if (line >> c)
    1132             throw DataFormatError("Extra character on the end of line");
     1132            throw IoError("Extra character on the end of line");
    11331133
    11341134          if (section == "nodes" && !nodes_done) {
    11351135            if (_nodes_caption.empty() || _nodes_caption == caption) {
     
    11511151            readLine();
    11521152            skipSection();
    11531153          }
    1154         } catch (DataFormatError& error) {
     1154        } catch (IoError& error) {
    11551155          error.line(line_num);
    11561156          throw;
    11571157        }
    11581158      }
    11591159
    11601160      if (!nodes_done) {
    1161         throw DataFormatError("Section @nodes not found");
     1161        throw IoError("Section @nodes not found");
    11621162      }
    11631163
    11641164      if (!arcs_done) {
    1165         throw DataFormatError("Section @arcs not found");
     1165        throw IoError("Section @arcs not found");
    11661166      }
    11671167
    11681168      if (!attributes_done && !_attributes.empty()) {
    1169         throw DataFormatError("Section @attributes not found");
     1169        throw IoError("Section @attributes not found");
    11701170      }
    11711171
    11721172    }
     
    16731673      if (!readLine() || !(line >> c) || c == '@') {
    16741674        if (readSuccess() && line) line.putback(c);
    16751675        if (!_node_maps.empty())
    1676           throw DataFormatError("Cannot find map names");
     1676          throw IoError("Cannot find map names");
    16771677        return;
    16781678      }
    16791679      line.putback(c);
     
    16871687          if (maps.find(map) != maps.end()) {
    16881688            std::ostringstream msg;
    16891689            msg << "Multiple occurence of node map: " << map;
    1690             throw DataFormatError(msg.str().c_str());
     1690            throw IoError(msg.str());
    16911691          }
    16921692          maps.insert(std::make_pair(map, index));
    16931693          ++index;
     
    16991699          if (jt == maps.end()) {
    17001700            std::ostringstream msg;
    17011701            msg << "Map not found in file: " << _node_maps[i].first;
    1702             throw DataFormatError(msg.str().c_str());
     1702            throw IoError(msg.str());
    17031703          }
    17041704          map_index[i] = jt->second;
    17051705        }
     
    17231723          if (!_reader_bits::readToken(line, tokens[i])) {
    17241724            std::ostringstream msg;
    17251725            msg << "Column not found (" << i + 1 << ")";
    1726             throw DataFormatError(msg.str().c_str());
     1726            throw IoError(msg.str());
    17271727          }
    17281728        }
    17291729        if (line >> std::ws >> c)
    1730           throw DataFormatError("Extra character on the end of line");
     1730          throw IoError("Extra character on the end of line");
    17311731
    17321732        Node n;
    17331733        if (!_use_nodes) {
     
    17361736            _node_index.insert(std::make_pair(tokens[label_index], n));
    17371737        } else {
    17381738          if (label_index == -1)
    1739             throw DataFormatError("Label map not found in file");
     1739            throw IoError("Label map not found in file");
    17401740          typename std::map<std::string, Node>::iterator it =
    17411741            _node_index.find(tokens[label_index]);
    17421742          if (it == _node_index.end()) {
    17431743            std::ostringstream msg;
    17441744            msg << "Node with label not found: " << tokens[label_index];
    1745             throw DataFormatError(msg.str().c_str());
     1745            throw IoError(msg.str());
    17461746          }
    17471747          n = it->second;
    17481748        }
     
    17661766      if (!readLine() || !(line >> c) || c == '@') {
    17671767        if (readSuccess() && line) line.putback(c);
    17681768        if (!_edge_maps.empty())
    1769           throw DataFormatError("Cannot find map names");
     1769          throw IoError("Cannot find map names");
    17701770        return;
    17711771      }
    17721772      line.putback(c);
     
    17801780          if (maps.find(map) != maps.end()) {
    17811781            std::ostringstream msg;
    17821782            msg << "Multiple occurence of edge map: " << map;
    1783             throw DataFormatError(msg.str().c_str());
     1783            throw IoError(msg.str());
    17841784          }
    17851785          maps.insert(std::make_pair(map, index));
    17861786          ++index;
     
    17921792          if (jt == maps.end()) {
    17931793            std::ostringstream msg;
    17941794            msg << "Map not found in file: " << _edge_maps[i].first;
    1795             throw DataFormatError(msg.str().c_str());
     1795            throw IoError(msg.str());
    17961796          }
    17971797          map_index[i] = jt->second;
    17981798        }
     
    18151815        std::string target_token;
    18161816
    18171817        if (!_reader_bits::readToken(line, source_token))
    1818           throw DataFormatError("Node u not found");
     1818          throw IoError("Node u not found");
    18191819
    18201820        if (!_reader_bits::readToken(line, target_token))
    1821           throw DataFormatError("Node v not found");
     1821          throw IoError("Node v not found");
    18221822
    18231823        std::vector<std::string> tokens(map_num);
    18241824        for (int i = 0; i < map_num; ++i) {
    18251825          if (!_reader_bits::readToken(line, tokens[i])) {
    18261826            std::ostringstream msg;
    18271827            msg << "Column not found (" << i + 1 << ")";
    1828             throw DataFormatError(msg.str().c_str());
     1828            throw IoError(msg.str());
    18291829          }
    18301830        }
    18311831        if (line >> std::ws >> c)
    1832           throw DataFormatError("Extra character on the end of line");
     1832          throw IoError("Extra character on the end of line");
    18331833
    18341834        Edge e;
    18351835        if (!_use_edges) {
     
    18401840          if (it == _node_index.end()) {
    18411841            std::ostringstream msg;
    18421842            msg << "Item not found: " << source_token;
    1843             throw DataFormatError(msg.str().c_str());
     1843            throw IoError(msg.str());
    18441844          }
    18451845          Node source = it->second;
    18461846
     
    18481848          if (it == _node_index.end()) {
    18491849            std::ostringstream msg;
    18501850            msg << "Item not found: " << target_token;
    1851             throw DataFormatError(msg.str().c_str());
     1851            throw IoError(msg.str());
    18521852          }
    18531853          Node target = it->second;
    18541854
     
    18571857            _edge_index.insert(std::make_pair(tokens[label_index], e));
    18581858        } else {
    18591859          if (label_index == -1)
    1860             throw DataFormatError("Label map not found in file");
     1860            throw IoError("Label map not found in file");
    18611861          typename std::map<std::string, Edge>::iterator it =
    18621862            _edge_index.find(tokens[label_index]);
    18631863          if (it == _edge_index.end()) {
    18641864            std::ostringstream msg;
    18651865            msg << "Edge with label not found: " << tokens[label_index];
    1866             throw DataFormatError(msg.str().c_str());
     1866            throw IoError(msg.str());
    18671867          }
    18681868          e = it->second;
    18691869        }
     
    18881888
    18891889        std::string attr, token;
    18901890        if (!_reader_bits::readToken(line, attr))
    1891           throw DataFormatError("Attribute name not found");
     1891          throw IoError("Attribute name not found");
    18921892        if (!_reader_bits::readToken(line, token))
    1893           throw DataFormatError("Attribute value not found");
     1893          throw IoError("Attribute value not found");
    18941894        if (line >> c)
    1895           throw DataFormatError("Extra character on the end of line");
     1895          throw IoError("Extra character on the end of line");
    18961896
    18971897        {
    18981898          std::set<std::string>::iterator it = read_attr.find(attr);
    18991899          if (it != read_attr.end()) {
    19001900            std::ostringstream msg;
    19011901            msg << "Multiple occurence of attribute " << attr;
    1902             throw DataFormatError(msg.str().c_str());
     1902            throw IoError(msg.str());
    19031903          }
    19041904          read_attr.insert(attr);
    19051905        }
     
    19211921        if (read_attr.find(it->first) == read_attr.end()) {
    19221922          std::ostringstream msg;
    19231923          msg << "Attribute not found in file: " << it->first;
    1924           throw DataFormatError(msg.str().c_str());
     1924          throw IoError(msg.str());
    19251925        }
    19261926      }
    19271927    }
     
    19551955          _reader_bits::readToken(line, caption);
    19561956
    19571957          if (line >> c)
    1958             throw DataFormatError("Extra character on the end of line");
     1958            throw IoError("Extra character on the end of line");
    19591959
    19601960          if (section == "nodes" && !nodes_done) {
    19611961            if (_nodes_caption.empty() || _nodes_caption == caption) {
     
    19771977            readLine();
    19781978            skipSection();
    19791979          }
    1980         } catch (DataFormatError& error) {
     1980        } catch (IoError& error) {
    19811981          error.line(line_num);
    19821982          throw;
    19831983        }
    19841984      }
    19851985
    19861986      if (!nodes_done) {
    1987         throw DataFormatError("Section @nodes not found");
     1987        throw IoError("Section @nodes not found");
    19881988      }
    19891989
    19901990      if (!edges_done) {
    1991         throw DataFormatError("Section @edges not found");
     1991        throw IoError("Section @edges not found");
    19921992      }
    19931993
    19941994      if (!attributes_done && !_attributes.empty()) {
    1995         throw DataFormatError("Section @attributes not found");
     1995        throw IoError("Section @attributes not found");
    19961996      }
    19971997
    19981998    }
     
    22362236          _reader_bits::readToken(line, caption);
    22372237
    22382238          if (line >> c)
    2239             throw DataFormatError("Extra character on the end of line");
     2239            throw IoError("Extra character on the end of line");
    22402240
    22412241          if (extra_sections.find(section) != extra_sections.end()) {
    22422242            std::ostringstream msg;
    22432243            msg << "Multiple occurence of section " << section;
    2244             throw DataFormatError(msg.str().c_str());
     2244            throw IoError(msg.str());
    22452245          }
    22462246          Sections::iterator it = _sections.find(section);
    22472247          if (it != _sections.end()) {
     
    22502250          }
    22512251          readLine();
    22522252          skipSection();
    2253         } catch (DataFormatError& error) {
     2253        } catch (IoError& error) {
    22542254          error.line(line_num);
    22552255          throw;
    22562256        }
     
    22602260        if (extra_sections.find(it->first) == extra_sections.end()) {
    22612261          std::ostringstream os;
    22622262          os << "Cannot find section: " << it->first;
    2263           throw DataFormatError(os.str().c_str());
     2263          throw IoError(os.str());
    22642264        }
    22652265      }
    22662266    }
  • lemon/lgf_writer.h

    diff -r bb40b6db0a58 -r 305d03f9bcea lemon/lgf_writer.h
    a b  
    5555
    5656    template <typename T>
    5757    bool operator<(const T&, const T&) {
    58       throw DataFormatError("Label map is not comparable");
     58      throw IoError("Label map is not comparable");
    5959    }
    6060
    6161    template <typename _Map>
     
    203203        typename std::map<Value, std::string>::const_iterator it =
    204204          _map.find(str);
    205205        if (it == _map.end()) {
    206           throw DataFormatError("Item not found");
     206          throw IoError("Item not found");
    207207        }
    208208        return it->second;
    209209      }
     
    223223        typename std::map<typename Graph::Edge, std::string>
    224224          ::const_iterator it = _map.find(val);
    225225        if (it == _map.end()) {
    226           throw DataFormatError("Item not found");
     226          throw IoError("Item not found");
    227227        }
    228228        return (_graph.direction(val) ? '+' : '-') + it->second;
    229229      }