COIN-OR::LEMON - Graph Library

Changeset 290:f6899946c1ac in lemon


Ignore:
Timestamp:
09/30/08 20:53:18 (10 years ago)
Author:
Balazs Dezso <deba@…>
Branch:
default
Message:

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
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • demo/lgf_demo.cc

    r209 r290  
    5050      node("target", t).             // read 'target' node to t 
    5151      run(); 
    52   } catch (DataFormatError& error) { // check if there was any error 
     52  } catch (Exception& error) { // check if there was any error 
    5353    std::cerr << "Error: " << error.what() << std::endl; 
    5454    return -1; 
  • lemon/arg_parser.h

    r261 r290  
    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    { 
  • lemon/assert.h

    r277 r290  
    109109/// \brief Macro for assertion with customizable message 
    110110/// 
    111 /// Macro for assertion with customizable message.   
     111/// Macro for assertion with customizable message. 
    112112/// \param exp An expression that must be convertible to \c bool.  If it is \c 
    113113/// false, then an assertion is raised. The concrete behaviour depends on the 
  • lemon/bfs.h

    r287 r290  
    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. 
     
    233223      static PredMap *createPredMap(const Digraph &) 
    234224      { 
    235         throw UninitializedParameter(); 
     225        LEMON_ASSERT(false, "PredMap is not initialized"); 
     226        return 0; // ignore warnings 
    236227      } 
    237228    }; 
     
    251242      static DistMap *createDistMap(const Digraph &) 
    252243      { 
    253         throw UninitializedParameter(); 
     244        LEMON_ASSERT(false, "DistMap is not initialized"); 
     245        return 0; // ignore warnings 
    254246      } 
    255247    }; 
     
    269261      static ReachedMap *createReachedMap(const Digraph &) 
    270262      { 
    271         throw UninitializedParameter(); 
     263        LEMON_ASSERT(false, "ReachedMap is not initialized"); 
     264        return 0; // ignore warnings 
    272265      } 
    273266    }; 
     
    287280      static ProcessedMap *createProcessedMap(const Digraph &) 
    288281      { 
    289         throw UninitializedParameter(); 
     282        LEMON_ASSERT(false, "ProcessedMap is not initialized"); 
     283        return 0; // ignore warnings 
    290284      } 
    291285    }; 
     
    305299      { 
    306300        return new ProcessedMap(g); 
     301        return 0; // ignore warnings 
    307302      } 
    308303    }; 
     
    10411036    bool run(Node s, Node t) 
    10421037    { 
    1043       if (s==INVALID || t==INVALID) throw UninitializedParameter(); 
    10441038      Bfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g)); 
    10451039      if (Base::_pred) 
     
    13241318  public: 
    13251319 
    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  
    13381320    ///The traits class. 
    13391321    typedef _Traits Traits; 
     
    13901372      typedef T ReachedMap; 
    13911373      static ReachedMap *createReachedMap(const Digraph &digraph) { 
    1392         throw UninitializedParameter(); 
     1374        LEMON_ASSERT(false, "ReachedMap is not initialized"); 
     1375        return 0; // ignore warnings 
    13931376      } 
    13941377    }; 
  • lemon/concepts/heap.h

    r220 r290  
    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. 
  • lemon/dfs.h

    r287 r290  
    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. 
     
    233223      static PredMap *createPredMap(const Digraph &) 
    234224      { 
    235         throw UninitializedParameter(); 
     225        LEMON_ASSERT(false, "PredMap is not initialized"); 
     226        return 0; // ignore warnings 
    236227      } 
    237228    }; 
     
    251242      static DistMap *createDistMap(const Digraph &) 
    252243      { 
    253         throw UninitializedParameter(); 
     244        LEMON_ASSERT(false, "DistMap is not initialized"); 
     245        return 0; // ignore warnings 
    254246      } 
    255247    }; 
     
    269261      static ReachedMap *createReachedMap(const Digraph &) 
    270262      { 
    271         throw UninitializedParameter(); 
     263        LEMON_ASSERT(false, "ReachedMap is not initialized"); 
     264        return 0; // ignore warnings 
    272265      } 
    273266    }; 
     
    287280      static ProcessedMap *createProcessedMap(const Digraph &) 
    288281      { 
    289         throw UninitializedParameter(); 
     282        LEMON_ASSERT(false, "ProcessedMap is not initialized"); 
     283        return 0; // ignore warnings 
    290284      } 
    291285    }; 
     
    975969    bool run(Node s, Node t) 
    976970    { 
    977       if (s==INVALID || t==INVALID) throw UninitializedParameter(); 
    978971      Dfs<Digraph,TR> alg(*reinterpret_cast<const Digraph*>(Base::_g)); 
    979972      if (Base::_pred) 
     
    12711264  public: 
    12721265 
    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  
    12851266    ///The traits class. 
    12861267    typedef _Traits Traits; 
     
    13371318      typedef T ReachedMap; 
    13381319      static ReachedMap *createReachedMap(const Digraph &digraph) { 
    1339         throw UninitializedParameter(); 
     1320        LEMON_ASSERT(false, "ReachedMap is not initialized"); 
     1321        return 0; // ignore warnings 
    13401322      } 
    13411323    }; 
  • lemon/dijkstra.h

    r287 r290  
    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. 
     
    333323      static PredMap *createPredMap(const Digraph &) 
    334324      { 
    335         throw UninitializedParameter(); 
     325        LEMON_ASSERT(false, "PredMap is not initialized"); 
     326        return 0; // ignore warnings 
    336327      } 
    337328    }; 
     
    352343      static DistMap *createDistMap(const Digraph &) 
    353344      { 
    354         throw UninitializedParameter(); 
     345        LEMON_ASSERT(false, "DistMap is not initialized"); 
     346        return 0; // ignore warnings 
    355347      } 
    356348    }; 
     
    371363      static ProcessedMap *createProcessedMap(const Digraph &) 
    372364      { 
    373         throw UninitializedParameter(); 
     365        LEMON_ASSERT(false, "ProcessedMap is not initialized"); 
     366        return 0; // ignore warnings 
    374367      } 
    375368    }; 
     
    409402      typedef H Heap; 
    410403      static HeapCrossRef *createHeapCrossRef(const Digraph &) { 
    411         throw UninitializedParameter(); 
     404        LEMON_ASSERT(false, "HeapCrossRef is not initialized"); 
     405        return 0; // ignore warnings 
    412406      } 
    413407      static Heap *createHeap(HeapCrossRef &) 
    414408      { 
    415         throw UninitializedParameter(); 
     409        LEMON_ASSERT(false, "Heap is not initialized"); 
     410        return 0; // ignore warnings 
    416411      } 
    417412    }; 
     
    11591154    void run(Node s) 
    11601155    { 
    1161       if (s==INVALID) throw UninitializedParameter(); 
    11621156      Dijkstra<Digraph,LengthMap,TR> 
    11631157        dijk(*reinterpret_cast<const Digraph*>(Base::_g), 
     
    11811175    bool run(Node s, Node t) 
    11821176    { 
    1183       if (s==INVALID || t==INVALID) throw UninitializedParameter(); 
    11841177      Dijkstra<Digraph,LengthMap,TR> 
    11851178        dijk(*reinterpret_cast<const Digraph*>(Base::_g), 
  • lemon/error.h

    r280 r290  
    3636  /// @{ 
    3737 
    38   /// \brief Exception safe wrapper class. 
    39   /// 
    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  
     38  /// \brief Generic exception class. 
     39  /// 
    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"; 
     
    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 { 
     54  /// \brief Input-Output error 
     55  /// 
     56  /// This exception is thrown when a file operation cannot be 
     57  /// succeeded. 
     58  class IoError : public Exception { 
     59  protected: 
     60    std::string _message; 
     61    std::string _file; 
     62 
     63    mutable std::string _what; 
    18964  public: 
     65 
     66    /// Copy constructor 
     67    IoError(const IoError &error) { 
     68      message(error._message); 
     69      file(error._file); 
     70    } 
     71 
     72    /// Constructor 
     73    explicit IoError(const char *message) { 
     74      IoError::message(message); 
     75    } 
     76 
     77    /// Constructor 
     78    explicit IoError(const std::string &message) { 
     79      IoError::message(message); 
     80    } 
     81 
     82    /// Constructor 
     83    IoError(const std::string &file, const char *message) { 
     84      IoError::message(message); 
     85      IoError::file(file); 
     86    } 
     87 
     88    /// Constructor 
     89    IoError(const std::string &file, const std::string &message) { 
     90      IoError::message(message); 
     91      IoError::file(file); 
     92    } 
     93 
     94    /// Virtual destructor 
     95    virtual ~IoError() throw() {} 
     96 
     97    /// Set the error message 
     98    void message(const char *message) { 
     99      try { 
     100        _message = message; 
     101      } catch (...) {} 
     102    } 
     103 
     104    /// Set the error message 
     105    void message(const std::string& message) { 
     106      try { 
     107        _message = message; 
     108      } catch (...) {} 
     109    } 
     110 
     111    /// Set the file name 
     112    void file(const std::string &file) { 
     113      try { 
     114        _file = file; 
     115      } catch (...) {} 
     116    } 
     117 
     118    /// Returns the error message 
     119    const std::string& message() const { 
     120      return _message; 
     121    } 
     122 
     123    /// \brief Returns the filename 
     124    /// 
     125    /// Returns the filename or empty string if the filename was not 
     126    /// specified. 
     127    const std::string& file() const { 
     128      return _file; 
     129    } 
     130 
     131    /// \brief Returns a short error message 
     132    /// 
     133    /// Returns a short error message which contains the message, the 
     134    /// file name and the line number. 
    190135    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  
    219   ///\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 { 
    237   protected: 
    238     ExceptionMember<std::string> _message; 
    239     ExceptionMember<std::string> _file; 
    240     int _line; 
    241  
    242     mutable ExceptionMember<std::string> _message_holder; 
    243   public: 
    244  
    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       } 
    274     } 
    275  
    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       } 
    285     } 
    286  
    287     ///\e 
    288     virtual const char* what() const throw() { 
    289       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 << ")"; 
     136      try { 
     137        _what.clear(); 
     138        std::ostringstream oss; 
     139        oss << "lemon:IoError" << ": "; 
     140        oss << message(); 
     141        if (!file().empty()) { 
     142          oss << " ("; 
     143          if (!file().empty()) oss << "with file '" << file() << "'"; 
     144          oss << ")"; 
    299145        } 
    300         _message_holder.set(ostr.str()); 
     146        _what = oss.str(); 
    301147      } 
    302148      catch (...) {} 
    303       if( _message_holder.valid()) return _message_holder.get().c_str(); 
    304       return "lemon:DataFormatError"; 
    305     } 
    306  
    307     virtual ~DataFormatError() throw() {} 
     149      if (!_what.empty()) return _what.c_str(); 
     150      else return "lemon:IoError"; 
     151    } 
     152 
    308153  }; 
    309154 
    310   ///\e 
    311   class FileOpenError : public IoError { 
     155  /// \brief Format error 
     156  /// 
     157  /// This class is used to indicate if an input file has wrong 
     158  /// formatting, or a data representation is not legal. 
     159  class FormatError : public Exception { 
    312160  protected: 
    313     ExceptionMember<std::string> _file; 
    314  
    315     mutable ExceptionMember<std::string> _message_holder; 
     161    std::string _message; 
     162    std::string _file; 
     163    int _line; 
     164 
     165    mutable std::string _what; 
    316166  public: 
    317167 
    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 
     168    /// Copy constructor 
     169    FormatError(const FormatError &error) { 
     170      message(error._message); 
     171      file(error._file); 
     172      line(error._line); 
     173    } 
     174 
     175    /// Constructor 
     176    explicit FormatError(const char *message) { 
     177      FormatError::message(message); 
     178      _line = 0; 
     179    } 
     180 
     181    /// Constructor 
     182    explicit FormatError(const std::string &message) { 
     183      FormatError::message(message); 
     184      _line = 0; 
     185    } 
     186 
     187    /// Constructor 
     188    FormatError(const std::string &file, int line, const char *message) { 
     189      FormatError::message(message); 
     190      FormatError::file(file); 
     191      FormatError::line(line); 
     192    } 
     193 
     194    /// Constructor 
     195    FormatError(const std::string &file, int line, const std::string &message) { 
     196      FormatError::message(message); 
     197      FormatError::file(file); 
     198      FormatError::line(line); 
     199    } 
     200 
     201    /// Virtual destructor 
     202    virtual ~FormatError() throw() {} 
     203 
     204    /// Set the line number 
     205    void line(int line) { _line = line; } 
     206 
     207    /// Set the error message 
     208    void message(const char *message) { 
     209      try { 
     210        _message = message; 
     211      } catch (...) {} 
     212    } 
     213 
     214    /// Set the error message 
     215    void message(const std::string& message) { 
     216      try { 
     217        _message = message; 
     218      } catch (...) {} 
     219    } 
     220 
     221    /// Set the file name 
     222    void file(const std::string &file) { 
     223      try { 
     224        _file = file; 
     225      } catch (...) {} 
     226    } 
     227 
     228    /// \brief Returns the line number 
     229    /// 
     230    /// Returns the line number or zero if it was not specified. 
     231    int line() const { return _line; } 
     232 
     233    /// Returns the error message 
     234    const std::string& message() const { 
     235      return _message; 
     236    } 
     237 
     238    /// \brief Returns the filename 
     239    /// 
     240    /// Returns the filename or empty string if the filename was not 
     241    /// specified. 
     242    const std::string& file() const { 
     243      return _file; 
     244    } 
     245 
     246    /// \brief Returns a short error message 
     247    /// 
     248    /// Returns a short error message which contains the message, the 
     249    /// file name and the line number. 
    341250    virtual const char* what() const throw() { 
    342251      try { 
    343         std::ostringstream ostr; 
    344         ostr << "lemon::FileOpenError" << ": "; 
    345         ostr << "Cannot open file - " << file(); 
    346         _message_holder.set(ostr.str()); 
     252        _what.clear(); 
     253        std::ostringstream oss; 
     254        oss << "lemon:FormatError" << ": "; 
     255        oss << message(); 
     256        if (!file().empty() || line() != 0) { 
     257          oss << " ("; 
     258          if (!file().empty()) oss << "in file '" << file() << "'"; 
     259          if (!file().empty() && line() != 0) oss << " "; 
     260          if (line() != 0) oss << "at line " << line(); 
     261          oss << ")"; 
     262        } 
     263        _what = oss.str(); 
    347264      } 
    348265      catch (...) {} 
    349       if( _message_holder.valid()) return _message_holder.get().c_str(); 
    350       return "lemon::FileOpenError"; 
    351     } 
    352     virtual ~FileOpenError() throw() {} 
     266      if (!_what.empty()) return _what.c_str(); 
     267      else return "lemon:FormatError"; 
     268    } 
     269 
    353270  }; 
    354271 
    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() {} 
    412   }; 
    413  
    414272  /// @} 
    415273 
  • lemon/graph_to_eps.h

    r280 r290  
    4141#include<lemon/color.h> 
    4242#include<lemon/bits/bezier.h> 
     43#include<lemon/error.h> 
    4344 
    4445 
     
    11671168graphToEps(G &g,const char *file_name) 
    11681169{ 
     1170  std::ostream* os = new std::ofstream(file_name); 
     1171  if (!(*os)) { 
     1172    delete os; 
     1173    throw IoError(file_name, "Cannot write file"); 
     1174  } 
    11691175  return GraphToEps<DefaultGraphToEpsTraits<G> > 
    1170     (DefaultGraphToEpsTraits<G>(g,*new std::ofstream(file_name),true)); 
     1176    (DefaultGraphToEpsTraits<G>(g,*os,true)); 
    11711177} 
    11721178 
     
    11831189graphToEps(G &g,const std::string& file_name) 
    11841190{ 
     1191  std::ostream* os = new std::ofstream(file_name.c_str()); 
     1192  if (!(*os)) { 
     1193    delete os; 
     1194    throw IoError(file_name, "Cannot write file"); 
     1195  } 
    11851196  return GraphToEps<DefaultGraphToEpsTraits<G> > 
    1186     (DefaultGraphToEpsTraits<G>(g,*new std::ofstream(file_name.c_str()),true)); 
     1197    (DefaultGraphToEpsTraits<G>(g,*os,true)); 
    11871198} 
    11881199 
  • lemon/lgf_reader.h

    r236 r290  
    4949        std::istringstream is(str); 
    5050        Value value; 
    51         is >> value; 
     51        if (!(is >> value)) { 
     52          throw FormatError("Cannot read token"); 
     53        } 
    5254 
    5355        char c; 
    5456        if (is >> std::ws >> c) { 
    55           throw DataFormatError("Remaining characters in token"); 
     57          throw FormatError("Remaining characters in token"); 
    5658        } 
    5759        return value; 
     
    167169          std::ostringstream msg; 
    168170          msg << "Item not found: " << str; 
    169           throw DataFormatError(msg.str().c_str()); 
     171          throw FormatError(msg.str()); 
    170172        } 
    171173        return it->second; 
     
    185187      typename Graph::Arc operator()(const std::string& str) { 
    186188        if (str.empty() || (str[0] != '+' && str[0] != '-')) { 
    187           throw DataFormatError("Item must start with '+' or '-'"); 
     189          throw FormatError("Item must start with '+' or '-'"); 
    188190        } 
    189191        typename std::map<std::string, typename Graph::Edge> 
    190192          ::const_iterator it = _map.find(str.substr(1)); 
    191193        if (it == _map.end()) { 
    192           throw DataFormatError("Item not found"); 
     194          throw FormatError("Item not found"); 
    193195        } 
    194196        return _graph.direct(it->second, str[0] == '+'); 
     
    236238      char c; 
    237239      if (!is.get(c)) 
    238         throw DataFormatError("Escape format error"); 
     240        throw FormatError("Escape format error"); 
    239241 
    240242      switch (c) { 
     
    265267          int code; 
    266268          if (!is.get(c) || !isHex(c)) 
    267             throw DataFormatError("Escape format error"); 
     269            throw FormatError("Escape format error"); 
    268270          else if (code = valueHex(c), !is.get(c) || !isHex(c)) is.putback(c); 
    269271          else code = code * 16 + valueHex(c); 
     
    274276          int code; 
    275277          if (!isOct(c)) 
    276             throw DataFormatError("Escape format error"); 
     278            throw FormatError("Escape format error"); 
    277279          else if (code = valueOct(c), !is.get(c) || !isOct(c)) 
    278280            is.putback(c); 
     
    301303        } 
    302304        if (!is) 
    303           throw DataFormatError("Quoted format error"); 
     305          throw FormatError("Quoted format error"); 
    304306      } else { 
    305307        is.putback(c); 
     
    461463    std::istream* _is; 
    462464    bool local_is; 
     465    std::string _filename; 
    463466 
    464467    Digraph& _digraph; 
     
    510513    /// file. 
    511514    DigraphReader(const std::string& fn, Digraph& digraph) 
    512       : _is(new std::ifstream(fn.c_str())), local_is(true), _digraph(digraph), 
     515      : _is(new std::ifstream(fn.c_str())), local_is(true), 
     516        _filename(fn), _digraph(digraph), 
    513517        _use_nodes(false), _use_arcs(false), 
    514         _skip_nodes(false), _skip_arcs(false) {} 
     518        _skip_nodes(false), _skip_arcs(false) { 
     519      if (!(*_is)) throw IoError(fn, "Cannot open file"); 
     520    } 
    515521 
    516522    /// \brief Constructor 
     
    519525    /// file. 
    520526    DigraphReader(const char* fn, Digraph& digraph) 
    521       : _is(new std::ifstream(fn)), local_is(true), _digraph(digraph), 
     527      : _is(new std::ifstream(fn)), local_is(true), 
     528        _filename(fn), _digraph(digraph), 
    522529        _use_nodes(false), _use_arcs(false), 
    523         _skip_nodes(false), _skip_arcs(false) {} 
     530        _skip_nodes(false), _skip_arcs(false) { 
     531      if (!(*_is)) throw IoError(fn, "Cannot open file"); 
     532    } 
    524533 
    525534    /// \brief Destructor 
     
    846855        if (readSuccess() && line) line.putback(c); 
    847856        if (!_node_maps.empty()) 
    848           throw DataFormatError("Cannot find map names"); 
     857          throw FormatError("Cannot find map names"); 
    849858        return; 
    850859      } 
     
    860869            std::ostringstream msg; 
    861870            msg << "Multiple occurence of node map: " << map; 
    862             throw DataFormatError(msg.str().c_str()); 
     871            throw FormatError(msg.str()); 
    863872          } 
    864873          maps.insert(std::make_pair(map, index)); 
     
    872881            std::ostringstream msg; 
    873882            msg << "Map not found in file: " << _node_maps[i].first; 
    874             throw DataFormatError(msg.str().c_str()); 
     883            throw FormatError(msg.str()); 
    875884          } 
    876885          map_index[i] = jt->second; 
     
    896905            std::ostringstream msg; 
    897906            msg << "Column not found (" << i + 1 << ")"; 
    898             throw DataFormatError(msg.str().c_str()); 
     907            throw FormatError(msg.str()); 
    899908          } 
    900909        } 
    901910        if (line >> std::ws >> c) 
    902           throw DataFormatError("Extra character on the end of line"); 
     911          throw FormatError("Extra character on the end of line"); 
    903912 
    904913        Node n; 
     
    909918        } else { 
    910919          if (label_index == -1) 
    911             throw DataFormatError("Label map not found in file"); 
     920            throw FormatError("Label map not found in file"); 
    912921          typename std::map<std::string, Node>::iterator it = 
    913922            _node_index.find(tokens[label_index]); 
     
    915924            std::ostringstream msg; 
    916925            msg << "Node with label not found: " << tokens[label_index]; 
    917             throw DataFormatError(msg.str().c_str()); 
     926            throw FormatError(msg.str()); 
    918927          } 
    919928          n = it->second; 
     
    939948        if (readSuccess() && line) line.putback(c); 
    940949        if (!_arc_maps.empty()) 
    941           throw DataFormatError("Cannot find map names"); 
     950          throw FormatError("Cannot find map names"); 
    942951        return; 
    943952      } 
     
    953962            std::ostringstream msg; 
    954963            msg << "Multiple occurence of arc map: " << map; 
    955             throw DataFormatError(msg.str().c_str()); 
     964            throw FormatError(msg.str()); 
    956965          } 
    957966          maps.insert(std::make_pair(map, index)); 
     
    965974            std::ostringstream msg; 
    966975            msg << "Map not found in file: " << _arc_maps[i].first; 
    967             throw DataFormatError(msg.str().c_str()); 
     976            throw FormatError(msg.str()); 
    968977          } 
    969978          map_index[i] = jt->second; 
     
    988997 
    989998        if (!_reader_bits::readToken(line, source_token)) 
    990           throw DataFormatError("Source not found"); 
     999          throw FormatError("Source not found"); 
    9911000 
    9921001        if (!_reader_bits::readToken(line, target_token)) 
    993           throw DataFormatError("Target not found"); 
     1002          throw FormatError("Target not found"); 
    9941003 
    9951004        std::vector<std::string> tokens(map_num); 
     
    9981007            std::ostringstream msg; 
    9991008            msg << "Column not found (" << i + 1 << ")"; 
    1000             throw DataFormatError(msg.str().c_str()); 
     1009            throw FormatError(msg.str()); 
    10011010          } 
    10021011        } 
    10031012        if (line >> std::ws >> c) 
    1004           throw DataFormatError("Extra character on the end of line"); 
     1013          throw FormatError("Extra character on the end of line"); 
    10051014 
    10061015        Arc a; 
     
    10131022            std::ostringstream msg; 
    10141023            msg << "Item not found: " << source_token; 
    1015             throw DataFormatError(msg.str().c_str()); 
     1024            throw FormatError(msg.str()); 
    10161025          } 
    10171026          Node source = it->second; 
     
    10211030            std::ostringstream msg; 
    10221031            msg << "Item not found: " << target_token; 
    1023             throw DataFormatError(msg.str().c_str()); 
     1032            throw FormatError(msg.str()); 
    10241033          } 
    10251034          Node target = it->second; 
     
    10301039        } else { 
    10311040          if (label_index == -1) 
    1032             throw DataFormatError("Label map not found in file"); 
     1041            throw FormatError("Label map not found in file"); 
    10331042          typename std::map<std::string, Arc>::iterator it = 
    10341043            _arc_index.find(tokens[label_index]); 
     
    10361045            std::ostringstream msg; 
    10371046            msg << "Arc with label not found: " << tokens[label_index]; 
    1038             throw DataFormatError(msg.str().c_str()); 
     1047            throw FormatError(msg.str()); 
    10391048          } 
    10401049          a = it->second; 
     
    10611070        std::string attr, token; 
    10621071        if (!_reader_bits::readToken(line, attr)) 
    1063           throw DataFormatError("Attribute name not found"); 
     1072          throw FormatError("Attribute name not found"); 
    10641073        if (!_reader_bits::readToken(line, token)) 
    1065           throw DataFormatError("Attribute value not found"); 
     1074          throw FormatError("Attribute value not found"); 
    10661075        if (line >> c) 
    1067           throw DataFormatError("Extra character on the end of line"); 
     1076          throw FormatError("Extra character on the end of line"); 
    10681077 
    10691078        { 
     
    10721081            std::ostringstream msg; 
    10731082            msg << "Multiple occurence of attribute " << attr; 
    1074             throw DataFormatError(msg.str().c_str()); 
     1083            throw FormatError(msg.str()); 
    10751084          } 
    10761085          read_attr.insert(attr); 
     
    10941103          std::ostringstream msg; 
    10951104          msg << "Attribute not found in file: " << it->first; 
    1096           throw DataFormatError(msg.str().c_str()); 
     1105          throw FormatError(msg.str()); 
    10971106        } 
    10981107      } 
     
    11101119      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader"); 
    11111120      if (!*_is) { 
    1112         throw DataFormatError("Cannot find file"); 
     1121        throw FormatError("Cannot find file"); 
    11131122      } 
    11141123 
     
    11301139 
    11311140          if (line >> c) 
    1132             throw DataFormatError("Extra character on the end of line"); 
     1141            throw FormatError("Extra character on the end of line"); 
    11331142 
    11341143          if (section == "nodes" && !nodes_done) { 
     
    11521161            skipSection(); 
    11531162          } 
    1154         } catch (DataFormatError& error) { 
     1163        } catch (FormatError& error) { 
    11551164          error.line(line_num); 
     1165          error.file(_filename); 
    11561166          throw; 
    11571167        } 
     
    11591169 
    11601170      if (!nodes_done) { 
    1161         throw DataFormatError("Section @nodes not found"); 
     1171        throw FormatError("Section @nodes not found"); 
    11621172      } 
    11631173 
    11641174      if (!arcs_done) { 
    1165         throw DataFormatError("Section @arcs not found"); 
     1175        throw FormatError("Section @arcs not found"); 
    11661176      } 
    11671177 
    11681178      if (!attributes_done && !_attributes.empty()) { 
    1169         throw DataFormatError("Section @attributes not found"); 
     1179        throw FormatError("Section @attributes not found"); 
    11701180      } 
    11711181 
     
    12451255    std::istream* _is; 
    12461256    bool local_is; 
     1257    std::string _filename; 
    12471258 
    12481259    Graph& _graph; 
     
    12941305    /// file. 
    12951306    GraphReader(const std::string& fn, Graph& graph) 
    1296       : _is(new std::ifstream(fn.c_str())), local_is(true), _graph(graph), 
     1307      : _is(new std::ifstream(fn.c_str())), local_is(true), 
     1308        _filename(fn), _graph(graph), 
    12971309        _use_nodes(false), _use_edges(false), 
    1298         _skip_nodes(false), _skip_edges(false) {} 
     1310        _skip_nodes(false), _skip_edges(false) { 
     1311      if (!(*_is)) throw IoError(fn, "Cannot open file"); 
     1312    } 
    12991313 
    13001314    /// \brief Constructor 
     
    13031317    /// file. 
    13041318    GraphReader(const char* fn, Graph& graph) 
    1305       : _is(new std::ifstream(fn)), local_is(true), _graph(graph), 
     1319      : _is(new std::ifstream(fn)), local_is(true), 
     1320        _filename(fn), _graph(graph), 
    13061321        _use_nodes(false), _use_edges(false), 
    1307         _skip_nodes(false), _skip_edges(false) {} 
     1322        _skip_nodes(false), _skip_edges(false) { 
     1323      if (!(*_is)) throw IoError(fn, "Cannot open file"); 
     1324    } 
    13081325 
    13091326    /// \brief Destructor 
     
    16741691        if (readSuccess() && line) line.putback(c); 
    16751692        if (!_node_maps.empty()) 
    1676           throw DataFormatError("Cannot find map names"); 
     1693          throw FormatError("Cannot find map names"); 
    16771694        return; 
    16781695      } 
     
    16881705            std::ostringstream msg; 
    16891706            msg << "Multiple occurence of node map: " << map; 
    1690             throw DataFormatError(msg.str().c_str()); 
     1707            throw FormatError(msg.str()); 
    16911708          } 
    16921709          maps.insert(std::make_pair(map, index)); 
     
    17001717            std::ostringstream msg; 
    17011718            msg << "Map not found in file: " << _node_maps[i].first; 
    1702             throw DataFormatError(msg.str().c_str()); 
     1719            throw FormatError(msg.str()); 
    17031720          } 
    17041721          map_index[i] = jt->second; 
     
    17241741            std::ostringstream msg; 
    17251742            msg << "Column not found (" << i + 1 << ")"; 
    1726             throw DataFormatError(msg.str().c_str()); 
     1743            throw FormatError(msg.str()); 
    17271744          } 
    17281745        } 
    17291746        if (line >> std::ws >> c) 
    1730           throw DataFormatError("Extra character on the end of line"); 
     1747          throw FormatError("Extra character on the end of line"); 
    17311748 
    17321749        Node n; 
     
    17371754        } else { 
    17381755          if (label_index == -1) 
    1739             throw DataFormatError("Label map not found in file"); 
     1756            throw FormatError("Label map not found in file"); 
    17401757          typename std::map<std::string, Node>::iterator it = 
    17411758            _node_index.find(tokens[label_index]); 
     
    17431760            std::ostringstream msg; 
    17441761            msg << "Node with label not found: " << tokens[label_index]; 
    1745             throw DataFormatError(msg.str().c_str()); 
     1762            throw FormatError(msg.str()); 
    17461763          } 
    17471764          n = it->second; 
     
    17671784        if (readSuccess() && line) line.putback(c); 
    17681785        if (!_edge_maps.empty()) 
    1769           throw DataFormatError("Cannot find map names"); 
     1786          throw FormatError("Cannot find map names"); 
    17701787        return; 
    17711788      } 
     
    17811798            std::ostringstream msg; 
    17821799            msg << "Multiple occurence of edge map: " << map; 
    1783             throw DataFormatError(msg.str().c_str()); 
     1800            throw FormatError(msg.str()); 
    17841801          } 
    17851802          maps.insert(std::make_pair(map, index)); 
     
    17931810            std::ostringstream msg; 
    17941811            msg << "Map not found in file: " << _edge_maps[i].first; 
    1795             throw DataFormatError(msg.str().c_str()); 
     1812            throw FormatError(msg.str()); 
    17961813          } 
    17971814          map_index[i] = jt->second; 
     
    18161833 
    18171834        if (!_reader_bits::readToken(line, source_token)) 
    1818           throw DataFormatError("Node u not found"); 
     1835          throw FormatError("Node u not found"); 
    18191836 
    18201837        if (!_reader_bits::readToken(line, target_token)) 
    1821           throw DataFormatError("Node v not found"); 
     1838          throw FormatError("Node v not found"); 
    18221839 
    18231840        std::vector<std::string> tokens(map_num); 
     
    18261843            std::ostringstream msg; 
    18271844            msg << "Column not found (" << i + 1 << ")"; 
    1828             throw DataFormatError(msg.str().c_str()); 
     1845            throw FormatError(msg.str()); 
    18291846          } 
    18301847        } 
    18311848        if (line >> std::ws >> c) 
    1832           throw DataFormatError("Extra character on the end of line"); 
     1849          throw FormatError("Extra character on the end of line"); 
    18331850 
    18341851        Edge e; 
     
    18411858            std::ostringstream msg; 
    18421859            msg << "Item not found: " << source_token; 
    1843             throw DataFormatError(msg.str().c_str()); 
     1860            throw FormatError(msg.str()); 
    18441861          } 
    18451862          Node source = it->second; 
     
    18491866            std::ostringstream msg; 
    18501867            msg << "Item not found: " << target_token; 
    1851             throw DataFormatError(msg.str().c_str()); 
     1868            throw FormatError(msg.str()); 
    18521869          } 
    18531870          Node target = it->second; 
     
    18581875        } else { 
    18591876          if (label_index == -1) 
    1860             throw DataFormatError("Label map not found in file"); 
     1877            throw FormatError("Label map not found in file"); 
    18611878          typename std::map<std::string, Edge>::iterator it = 
    18621879            _edge_index.find(tokens[label_index]); 
     
    18641881            std::ostringstream msg; 
    18651882            msg << "Edge with label not found: " << tokens[label_index]; 
    1866             throw DataFormatError(msg.str().c_str()); 
     1883            throw FormatError(msg.str()); 
    18671884          } 
    18681885          e = it->second; 
     
    18891906        std::string attr, token; 
    18901907        if (!_reader_bits::readToken(line, attr)) 
    1891           throw DataFormatError("Attribute name not found"); 
     1908          throw FormatError("Attribute name not found"); 
    18921909        if (!_reader_bits::readToken(line, token)) 
    1893           throw DataFormatError("Attribute value not found"); 
     1910          throw FormatError("Attribute value not found"); 
    18941911        if (line >> c) 
    1895           throw DataFormatError("Extra character on the end of line"); 
     1912          throw FormatError("Extra character on the end of line"); 
    18961913 
    18971914        { 
     
    19001917            std::ostringstream msg; 
    19011918            msg << "Multiple occurence of attribute " << attr; 
    1902             throw DataFormatError(msg.str().c_str()); 
     1919            throw FormatError(msg.str()); 
    19031920          } 
    19041921          read_attr.insert(attr); 
     
    19221939          std::ostringstream msg; 
    19231940          msg << "Attribute not found in file: " << it->first; 
    1924           throw DataFormatError(msg.str().c_str()); 
     1941          throw FormatError(msg.str()); 
    19251942        } 
    19261943      } 
     
    19561973 
    19571974          if (line >> c) 
    1958             throw DataFormatError("Extra character on the end of line"); 
     1975            throw FormatError("Extra character on the end of line"); 
    19591976 
    19601977          if (section == "nodes" && !nodes_done) { 
     
    19781995            skipSection(); 
    19791996          } 
    1980         } catch (DataFormatError& error) { 
     1997        } catch (FormatError& error) { 
    19811998          error.line(line_num); 
     1999          error.file(_filename); 
    19822000          throw; 
    19832001        } 
     
    19852003 
    19862004      if (!nodes_done) { 
    1987         throw DataFormatError("Section @nodes not found"); 
     2005        throw FormatError("Section @nodes not found"); 
    19882006      } 
    19892007 
    19902008      if (!edges_done) { 
    1991         throw DataFormatError("Section @edges not found"); 
     2009        throw FormatError("Section @edges not found"); 
    19922010      } 
    19932011 
    19942012      if (!attributes_done && !_attributes.empty()) { 
    1995         throw DataFormatError("Section @attributes not found"); 
     2013        throw FormatError("Section @attributes not found"); 
    19962014      } 
    19972015 
     
    20552073    std::istream* _is; 
    20562074    bool local_is; 
     2075    std::string _filename; 
    20572076 
    20582077    typedef std::map<std::string, _reader_bits::Section*> Sections; 
     
    20752094    /// Construct a section reader, which reads from the given file. 
    20762095    SectionReader(const std::string& fn) 
    2077       : _is(new std::ifstream(fn.c_str())), local_is(true) {} 
     2096      : _is(new std::ifstream(fn.c_str())), local_is(true), 
     2097        _filename(fn) { 
     2098      if (!(*_is)) throw IoError(fn, "Cannot open file"); 
     2099    } 
    20782100 
    20792101    /// \brief Constructor 
     
    20812103    /// Construct a section reader, which reads from the given file. 
    20822104    SectionReader(const char* fn) 
    2083       : _is(new std::ifstream(fn)), local_is(true) {} 
     2105      : _is(new std::ifstream(fn)), local_is(true), 
     2106        _filename(fn) { 
     2107      if (!(*_is)) throw IoError(fn, "Cannot open file"); 
     2108    } 
    20842109 
    20852110    /// \brief Destructor 
     
    22372262 
    22382263          if (line >> c) 
    2239             throw DataFormatError("Extra character on the end of line"); 
     2264            throw FormatError("Extra character on the end of line"); 
    22402265 
    22412266          if (extra_sections.find(section) != extra_sections.end()) { 
    22422267            std::ostringstream msg; 
    22432268            msg << "Multiple occurence of section " << section; 
    2244             throw DataFormatError(msg.str().c_str()); 
     2269            throw FormatError(msg.str()); 
    22452270          } 
    22462271          Sections::iterator it = _sections.find(section); 
     
    22512276          readLine(); 
    22522277          skipSection(); 
    2253         } catch (DataFormatError& error) { 
     2278        } catch (FormatError& error) { 
    22542279          error.line(line_num); 
     2280          error.file(_filename); 
    22552281          throw; 
    22562282        } 
     
    22612287          std::ostringstream os; 
    22622288          os << "Cannot find section: " << it->first; 
    2263           throw DataFormatError(os.str().c_str()); 
     2289          throw FormatError(os.str()); 
    22642290        } 
    22652291      } 
     
    23612387    /// file. 
    23622388    LgfContents(const std::string& fn) 
    2363       : _is(new std::ifstream(fn.c_str())), local_is(true) {} 
     2389      : _is(new std::ifstream(fn.c_str())), local_is(true) { 
     2390      if (!(*_is)) throw IoError(fn, "Cannot open file"); 
     2391    } 
    23642392 
    23652393    /// \brief Constructor 
     
    23682396    /// file. 
    23692397    LgfContents(const char* fn) 
    2370       : _is(new std::ifstream(fn)), local_is(true) {} 
     2398      : _is(new std::ifstream(fn)), local_is(true) { 
     2399      if (!(*_is)) throw IoError(fn, "Cannot open file"); 
     2400    } 
    23712401 
    23722402    /// \brief Destructor 
  • lemon/lgf_writer.h

    r248 r290  
    5656    template <typename T> 
    5757    bool operator<(const T&, const T&) { 
    58       throw DataFormatError("Label map is not comparable"); 
     58      throw FormatError("Label map is not comparable"); 
    5959    } 
    6060 
     
    204204          _map.find(str); 
    205205        if (it == _map.end()) { 
    206           throw DataFormatError("Item not found"); 
     206          throw FormatError("Item not found"); 
    207207        } 
    208208        return it->second; 
     
    224224          ::const_iterator it = _map.find(val); 
    225225        if (it == _map.end()) { 
    226           throw DataFormatError("Item not found"); 
     226          throw FormatError("Item not found"); 
    227227        } 
    228228        return (_graph.direction(val) ? '+' : '-') + it->second; 
     
    463463    DigraphWriter(const std::string& fn, const Digraph& digraph) 
    464464      : _os(new std::ofstream(fn.c_str())), local_os(true), _digraph(digraph), 
    465         _skip_nodes(false), _skip_arcs(false) {} 
     465        _skip_nodes(false), _skip_arcs(false) { 
     466      if (!(*_os)) throw IoError(fn, "Cannot write file"); 
     467    } 
    466468 
    467469    /// \brief Constructor 
     
    471473    DigraphWriter(const char* fn, const Digraph& digraph) 
    472474      : _os(new std::ofstream(fn)), local_os(true), _digraph(digraph), 
    473         _skip_nodes(false), _skip_arcs(false) {} 
     475        _skip_nodes(false), _skip_arcs(false) { 
     476      if (!(*_os)) throw IoError(fn, "Cannot write file"); 
     477    } 
    474478 
    475479    /// \brief Destructor 
     
    10191023    GraphWriter(const std::string& fn, const Graph& graph) 
    10201024      : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph), 
    1021         _skip_nodes(false), _skip_edges(false) {} 
     1025        _skip_nodes(false), _skip_edges(false) { 
     1026      if (!(*_os)) throw IoError(fn, "Cannot write file"); 
     1027    } 
    10221028 
    10231029    /// \brief Constructor 
     
    10271033    GraphWriter(const char* fn, const Graph& graph) 
    10281034      : _os(new std::ofstream(fn)), local_os(true), _graph(graph), 
    1029         _skip_nodes(false), _skip_edges(false) {} 
     1035        _skip_nodes(false), _skip_edges(false) { 
     1036      if (!(*_os)) throw IoError(fn, "Cannot write file"); 
     1037    } 
    10301038 
    10311039    /// \brief Destructor 
     
    15771585    /// Construct a section writer, which writes into the given file. 
    15781586    SectionWriter(const std::string& fn) 
    1579       : _os(new std::ofstream(fn.c_str())), local_os(true) {} 
     1587      : _os(new std::ofstream(fn.c_str())), local_os(true) { 
     1588      if (!(*_os)) throw IoError(fn, "Cannot write file"); 
     1589    } 
    15801590 
    15811591    /// \brief Constructor 
     
    15831593    /// Construct a section writer, which writes into the given file. 
    15841594    SectionWriter(const char* fn) 
    1585       : _os(new std::ofstream(fn)), local_os(true) {} 
     1595      : _os(new std::ofstream(fn)), local_os(true) { 
     1596      if (!(*_os)) throw IoError(fn, "Cannot write file"); 
     1597    } 
    15861598 
    15871599    /// \brief Destructor 
Note: See TracChangeset for help on using the changeset viewer.