COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Changes in / [293:47fbc814aa31:294:cbe3ec2d59d2] in lemon-1.2


Ignore:
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • demo/lgf_demo.cc

    r293 r294  
    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

    r288 r292  
    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

    r288 r292  
    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 r291  
    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
    172     Exception() {}
    173     ///\e
     44    ///Constructor
     45    Exception() throw() {}
     46    ///Virtual destructor
    17447    virtual ~Exception() throw() {}
    175     ///\e
     48    ///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) throw() : Exception() {
     68      message(error._message);
     69      file(error._file);
     70    }
     71
     72    /// Constructor
     73    explicit IoError(const char *message) throw() {
     74      IoError::message(message);
     75    }
     76
     77    /// Constructor
     78    explicit IoError(const std::string &message) throw() {
     79      IoError::message(message);
     80    }
     81
     82    /// Constructor
     83    explicit IoError(const char *message,
     84                     const std::string &file) throw() {
     85      IoError::message(message);
     86      IoError::file(file);
     87    }
     88
     89    /// Constructor
     90    explicit IoError(const std::string &message,
     91                     const std::string &file) throw() {
     92      IoError::message(message);
     93      IoError::file(file);
     94    }
     95
     96    /// Virtual destructor
     97    virtual ~IoError() throw() {}
     98
     99    /// Set the error message
     100    void message(const char *message) throw() {
     101      try {
     102        _message = message;
     103      } catch (...) {}
     104    }
     105
     106    /// Set the error message
     107    void message(const std::string& message) throw() {
     108      try {
     109        _message = message;
     110      } catch (...) {}
     111    }
     112
     113    /// Set the file name
     114    void file(const std::string &file) throw() {
     115      try {
     116        _file = file;
     117      } catch (...) {}
     118    }
     119
     120    /// Returns the error message
     121    const std::string& message() const throw() {
     122      return _message;
     123    }
     124
     125    /// \brief Returns the filename
     126    ///
     127    /// Returns the filename or an empty string if it was not specified.
     128    const std::string& file() const throw() {
     129      return _file;
     130    }
     131
     132    /// \brief Returns a short error message
     133    ///
     134    /// Returns a short error message which contains the message and the
     135    /// file name.
    190136    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 << ")";
     137      try {
     138        _what.clear();
     139        std::ostringstream oss;
     140        oss << "lemon:IoError" << ": ";
     141        oss << _message;
     142        if (!_file.empty()) {
     143          oss << " ('" << _file << "')";
    299144        }
    300         _message_holder.set(ostr.str());
     145        _what = oss.str();
    301146      }
    302147      catch (...) {}
    303       if( _message_holder.valid()) return _message_holder.get().c_str();
    304       return "lemon:DataFormatError";
    305     }
    306 
    307     virtual ~DataFormatError() throw() {}
     148      if (!_what.empty()) return _what.c_str();
     149      else return "lemon:IoError";
     150    }
     151
    308152  };
    309153
    310   ///\e
    311   class FileOpenError : public IoError {
     154  /// \brief Format error
     155  ///
     156  /// This exception is thrown when an input file has wrong
     157  /// format or a data representation is not legal.
     158  class FormatError : public Exception {
    312159  protected:
    313     ExceptionMember<std::string> _file;
    314 
    315     mutable ExceptionMember<std::string> _message_holder;
     160    std::string _message;
     161    std::string _file;
     162    int _line;
     163
     164    mutable std::string _what;
    316165  public:
    317166
    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
     167    /// Copy constructor
     168    FormatError(const FormatError &error) throw() : Exception() {
     169      message(error._message);
     170      file(error._file);
     171      line(error._line);
     172    }
     173
     174    /// Constructor
     175    explicit FormatError(const char *message) throw() {
     176      FormatError::message(message);
     177      _line = 0;
     178    }
     179
     180    /// Constructor
     181    explicit FormatError(const std::string &message) throw() {
     182      FormatError::message(message);
     183      _line = 0;
     184    }
     185
     186    /// Constructor
     187    explicit FormatError(const char *message,
     188                         const std::string &file, int line = 0) throw() {
     189      FormatError::message(message);
     190      FormatError::file(file);
     191      FormatError::line(line);
     192    }
     193
     194    /// Constructor
     195    explicit FormatError(const std::string &message,
     196                         const std::string &file, int line = 0) throw() {
     197      FormatError::message(message);
     198      FormatError::file(file);
     199      FormatError::line(line);
     200    }
     201
     202    /// Virtual destructor
     203    virtual ~FormatError() throw() {}
     204
     205    /// Set the line number
     206    void line(int line) throw() { _line = line; }
     207
     208    /// Set the error message
     209    void message(const char *message) throw() {
     210      try {
     211        _message = message;
     212      } catch (...) {}
     213    }
     214
     215    /// Set the error message
     216    void message(const std::string& message) throw() {
     217      try {
     218        _message = message;
     219      } catch (...) {}
     220    }
     221
     222    /// Set the file name
     223    void file(const std::string &file) throw() {
     224      try {
     225        _file = file;
     226      } catch (...) {}
     227    }
     228
     229    /// \brief Returns the line number
     230    ///
     231    /// Returns the line number or zero if it was not specified.
     232    int line() const throw() { return _line; }
     233
     234    /// Returns the error message
     235    const std::string& message() const throw() {
     236      return _message;
     237    }
     238
     239    /// \brief Returns the filename
     240    ///
     241    /// Returns the filename or an empty string if it was not specified.
     242    const std::string& file() const throw() {
     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 r291  
    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("Cannot write file", file_name);
     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("Cannot write file", file_name);
     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

    r293 r294  
    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);
    … …  
    462464    std::istream* _is;
    463465    bool local_is;
     466    std::string _filename;
    464467
    465468    Digraph& _digraph;
    … …  
    511514    /// file.
    512515    DigraphReader(Digraph& digraph, const std::string& fn)
    513       : _is(new std::ifstream(fn.c_str())), local_is(true), _digraph(digraph),
     516      : _is(new std::ifstream(fn.c_str())), local_is(true),
     517        _filename(fn), _digraph(digraph),
    514518        _use_nodes(false), _use_arcs(false),
    515         _skip_nodes(false), _skip_arcs(false) {}
     519        _skip_nodes(false), _skip_arcs(false) {
     520      if (!(*_is)) throw IoError("Cannot open file", fn);
     521    }
    516522
    517523    /// \brief Constructor
    … …  
    520526    /// file.
    521527    DigraphReader(Digraph& digraph, const char* fn)
    522       : _is(new std::ifstream(fn)), local_is(true), _digraph(digraph),
     528      : _is(new std::ifstream(fn)), local_is(true),
     529        _filename(fn), _digraph(digraph),
    523530        _use_nodes(false), _use_arcs(false),
    524         _skip_nodes(false), _skip_arcs(false) {}
     531        _skip_nodes(false), _skip_arcs(false) {
     532      if (!(*_is)) throw IoError("Cannot open file", fn);
     533    }
    525534
    526535    /// \brief Destructor
    … …  
    847856        if (readSuccess() && line) line.putback(c);
    848857        if (!_node_maps.empty())
    849           throw DataFormatError("Cannot find map names");
     858          throw FormatError("Cannot find map names");
    850859        return;
    851860      }
    … …  
    861870            std::ostringstream msg;
    862871            msg << "Multiple occurence of node map: " << map;
    863             throw DataFormatError(msg.str().c_str());
     872            throw FormatError(msg.str());
    864873          }
    865874          maps.insert(std::make_pair(map, index));
    … …  
    872881          if (jt == maps.end()) {
    873882            std::ostringstream msg;
    874             msg << "Map not found in file: " << _node_maps[i].first;
    875             throw DataFormatError(msg.str().c_str());
     883            msg << "Map not found: " << _node_maps[i].first;
     884            throw FormatError(msg.str());
    876885          }
    877886          map_index[i] = jt->second;
    … …  
    897906            std::ostringstream msg;
    898907            msg << "Column not found (" << i + 1 << ")";
    899             throw DataFormatError(msg.str().c_str());
     908            throw FormatError(msg.str());
    900909          }
    901910        }
    902911        if (line >> std::ws >> c)
    903           throw DataFormatError("Extra character on the end of line");
     912          throw FormatError("Extra character at the end of line");
    904913
    905914        Node n;
    … …  
    910919        } else {
    911920          if (label_index == -1)
    912             throw DataFormatError("Label map not found in file");
     921            throw FormatError("Label map not found");
    913922          typename std::map<std::string, Node>::iterator it =
    914923            _node_index.find(tokens[label_index]);
    … …  
    916925            std::ostringstream msg;
    917926            msg << "Node with label not found: " << tokens[label_index];
    918             throw DataFormatError(msg.str().c_str());
     927            throw FormatError(msg.str());
    919928          }
    920929          n = it->second;
    … …  
    940949        if (readSuccess() && line) line.putback(c);
    941950        if (!_arc_maps.empty())
    942           throw DataFormatError("Cannot find map names");
     951          throw FormatError("Cannot find map names");
    943952        return;
    944953      }
    … …  
    954963            std::ostringstream msg;
    955964            msg << "Multiple occurence of arc map: " << map;
    956             throw DataFormatError(msg.str().c_str());
     965            throw FormatError(msg.str());
    957966          }
    958967          maps.insert(std::make_pair(map, index));
    … …  
    965974          if (jt == maps.end()) {
    966975            std::ostringstream msg;
    967             msg << "Map not found in file: " << _arc_maps[i].first;
    968             throw DataFormatError(msg.str().c_str());
     976            msg << "Map not found: " << _arc_maps[i].first;
     977            throw FormatError(msg.str());
    969978          }
    970979          map_index[i] = jt->second;
    … …  
    989998
    990999        if (!_reader_bits::readToken(line, source_token))
    991           throw DataFormatError("Source not found");
     1000          throw FormatError("Source not found");
    9921001
    9931002        if (!_reader_bits::readToken(line, target_token))
    994           throw DataFormatError("Target not found");
     1003          throw FormatError("Target not found");
    9951004
    9961005        std::vector<std::string> tokens(map_num);
    … …  
    9991008            std::ostringstream msg;
    10001009            msg << "Column not found (" << i + 1 << ")";
    1001             throw DataFormatError(msg.str().c_str());
     1010            throw FormatError(msg.str());
    10021011          }
    10031012        }
    10041013        if (line >> std::ws >> c)
    1005           throw DataFormatError("Extra character on the end of line");
     1014          throw FormatError("Extra character at the end of line");
    10061015
    10071016        Arc a;
    … …  
    10141023            std::ostringstream msg;
    10151024            msg << "Item not found: " << source_token;
    1016             throw DataFormatError(msg.str().c_str());
     1025            throw FormatError(msg.str());
    10171026          }
    10181027          Node source = it->second;
    … …  
    10221031            std::ostringstream msg;
    10231032            msg << "Item not found: " << target_token;
    1024             throw DataFormatError(msg.str().c_str());
     1033            throw FormatError(msg.str());
    10251034          }
    10261035          Node target = it->second;
    … …  
    10311040        } else {
    10321041          if (label_index == -1)
    1033             throw DataFormatError("Label map not found in file");
     1042            throw FormatError("Label map not found");
    10341043          typename std::map<std::string, Arc>::iterator it =
    10351044            _arc_index.find(tokens[label_index]);
    … …  
    10371046            std::ostringstream msg;
    10381047            msg << "Arc with label not found: " << tokens[label_index];
    1039             throw DataFormatError(msg.str().c_str());
     1048            throw FormatError(msg.str());
    10401049          }
    10411050          a = it->second;
    … …  
    10621071        std::string attr, token;
    10631072        if (!_reader_bits::readToken(line, attr))
    1064           throw DataFormatError("Attribute name not found");
     1073          throw FormatError("Attribute name not found");
    10651074        if (!_reader_bits::readToken(line, token))
    1066           throw DataFormatError("Attribute value not found");
     1075          throw FormatError("Attribute value not found");
    10671076        if (line >> c)
    1068           throw DataFormatError("Extra character on the end of line");
     1077          throw FormatError("Extra character at the end of line");
    10691078
    10701079        {
    … …  
    10721081          if (it != read_attr.end()) {
    10731082            std::ostringstream msg;
    1074             msg << "Multiple occurence of attribute " << attr;
    1075             throw DataFormatError(msg.str().c_str());
     1083            msg << "Multiple occurence of attribute: " << attr;
     1084            throw FormatError(msg.str());
    10761085          }
    10771086          read_attr.insert(attr);
    … …  
    10941103        if (read_attr.find(it->first) == read_attr.end()) {
    10951104          std::ostringstream msg;
    1096           msg << "Attribute not found in file: " << it->first;
    1097           throw DataFormatError(msg.str().c_str());
     1105          msg << "Attribute not found: " << it->first;
     1106          throw FormatError(msg.str());
    10981107        }
    10991108      }
    … …  
    11101119    void run() {
    11111120      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");
    1112       if (!*_is) {
    1113         throw DataFormatError("Cannot find file");
    1114       }
    11151121
    11161122      bool nodes_done = _skip_nodes;
    … …  
    11311137
    11321138          if (line >> c)
    1133             throw DataFormatError("Extra character on the end of line");
     1139            throw FormatError("Extra character at the end of line");
    11341140
    11351141          if (section == "nodes" && !nodes_done) {
    … …  
    11531159            skipSection();
    11541160          }
    1155         } catch (DataFormatError& error) {
     1161        } catch (FormatError& error) {
    11561162          error.line(line_num);
     1163          error.file(_filename);
    11571164          throw;
    11581165        }
    … …  
    11601167
    11611168      if (!nodes_done) {
    1162         throw DataFormatError("Section @nodes not found");
     1169        throw FormatError("Section @nodes not found");
    11631170      }
    11641171
    11651172      if (!arcs_done) {
    1166         throw DataFormatError("Section @arcs not found");
     1173        throw FormatError("Section @arcs not found");
    11671174      }
    11681175
    11691176      if (!attributes_done && !_attributes.empty()) {
    1170         throw DataFormatError("Section @attributes not found");
     1177        throw FormatError("Section @attributes not found");
    11711178      }
    11721179
    … …  
    12481255    std::istream* _is;
    12491256    bool local_is;
     1257    std::string _filename;
    12501258
    12511259    Graph& _graph;
    … …  
    12971305    /// file.
    12981306    GraphReader(Graph& graph, const std::string& fn)
    1299       : _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),
    13001309        _use_nodes(false), _use_edges(false),
    1301         _skip_nodes(false), _skip_edges(false) {}
     1310        _skip_nodes(false), _skip_edges(false) {
     1311      if (!(*_is)) throw IoError("Cannot open file", fn);
     1312    }
    13021313
    13031314    /// \brief Constructor
    … …  
    13061317    /// file.
    13071318    GraphReader(Graph& graph, const char* fn)
    1308       : _is(new std::ifstream(fn)), local_is(true), _graph(graph),
     1319      : _is(new std::ifstream(fn)), local_is(true),
     1320        _filename(fn), _graph(graph),
    13091321        _use_nodes(false), _use_edges(false),
    1310         _skip_nodes(false), _skip_edges(false) {}
     1322        _skip_nodes(false), _skip_edges(false) {
     1323      if (!(*_is)) throw IoError("Cannot open file", fn);
     1324    }
    13111325
    13121326    /// \brief Destructor
    … …  
    16771691        if (readSuccess() && line) line.putback(c);
    16781692        if (!_node_maps.empty())
    1679           throw DataFormatError("Cannot find map names");
     1693          throw FormatError("Cannot find map names");
    16801694        return;
    16811695      }
    … …  
    16911705            std::ostringstream msg;
    16921706            msg << "Multiple occurence of node map: " << map;
    1693             throw DataFormatError(msg.str().c_str());
     1707            throw FormatError(msg.str());
    16941708          }
    16951709          maps.insert(std::make_pair(map, index));
    … …  
    17021716          if (jt == maps.end()) {
    17031717            std::ostringstream msg;
    1704             msg << "Map not found in file: " << _node_maps[i].first;
    1705             throw DataFormatError(msg.str().c_str());
     1718            msg << "Map not found: " << _node_maps[i].first;
     1719            throw FormatError(msg.str());
    17061720          }
    17071721          map_index[i] = jt->second;
    … …  
    17271741            std::ostringstream msg;
    17281742            msg << "Column not found (" << i + 1 << ")";
    1729             throw DataFormatError(msg.str().c_str());
     1743            throw FormatError(msg.str());
    17301744          }
    17311745        }
    17321746        if (line >> std::ws >> c)
    1733           throw DataFormatError("Extra character on the end of line");
     1747          throw FormatError("Extra character at the end of line");
    17341748
    17351749        Node n;
    … …  
    17401754        } else {
    17411755          if (label_index == -1)
    1742             throw DataFormatError("Label map not found in file");
     1756            throw FormatError("Label map not found");
    17431757          typename std::map<std::string, Node>::iterator it =
    17441758            _node_index.find(tokens[label_index]);
    … …  
    17461760            std::ostringstream msg;
    17471761            msg << "Node with label not found: " << tokens[label_index];
    1748             throw DataFormatError(msg.str().c_str());
     1762            throw FormatError(msg.str());
    17491763          }
    17501764          n = it->second;
    … …  
    17701784        if (readSuccess() && line) line.putback(c);
    17711785        if (!_edge_maps.empty())
    1772           throw DataFormatError("Cannot find map names");
     1786          throw FormatError("Cannot find map names");
    17731787        return;
    17741788      }
    … …  
    17841798            std::ostringstream msg;
    17851799            msg << "Multiple occurence of edge map: " << map;
    1786             throw DataFormatError(msg.str().c_str());
     1800            throw FormatError(msg.str());
    17871801          }
    17881802          maps.insert(std::make_pair(map, index));
    … …  
    17951809          if (jt == maps.end()) {
    17961810            std::ostringstream msg;
    1797             msg << "Map not found in file: " << _edge_maps[i].first;
    1798             throw DataFormatError(msg.str().c_str());
     1811            msg << "Map not found: " << _edge_maps[i].first;
     1812            throw FormatError(msg.str());
    17991813          }
    18001814          map_index[i] = jt->second;
    … …  
    18191833
    18201834        if (!_reader_bits::readToken(line, source_token))
    1821           throw DataFormatError("Node u not found");
     1835          throw FormatError("Node u not found");
    18221836
    18231837        if (!_reader_bits::readToken(line, target_token))
    1824           throw DataFormatError("Node v not found");
     1838          throw FormatError("Node v not found");
    18251839
    18261840        std::vector<std::string> tokens(map_num);
    … …  
    18291843            std::ostringstream msg;
    18301844            msg << "Column not found (" << i + 1 << ")";
    1831             throw DataFormatError(msg.str().c_str());
     1845            throw FormatError(msg.str());
    18321846          }
    18331847        }
    18341848        if (line >> std::ws >> c)
    1835           throw DataFormatError("Extra character on the end of line");
     1849          throw FormatError("Extra character at the end of line");
    18361850
    18371851        Edge e;
    … …  
    18441858            std::ostringstream msg;
    18451859            msg << "Item not found: " << source_token;
    1846             throw DataFormatError(msg.str().c_str());
     1860            throw FormatError(msg.str());
    18471861          }
    18481862          Node source = it->second;
    … …  
    18521866            std::ostringstream msg;
    18531867            msg << "Item not found: " << target_token;
    1854             throw DataFormatError(msg.str().c_str());
     1868            throw FormatError(msg.str());
    18551869          }
    18561870          Node target = it->second;
    … …  
    18611875        } else {
    18621876          if (label_index == -1)
    1863             throw DataFormatError("Label map not found in file");
     1877            throw FormatError("Label map not found");
    18641878          typename std::map<std::string, Edge>::iterator it =
    18651879            _edge_index.find(tokens[label_index]);
    … …  
    18671881            std::ostringstream msg;
    18681882            msg << "Edge with label not found: " << tokens[label_index];
    1869             throw DataFormatError(msg.str().c_str());
     1883            throw FormatError(msg.str());
    18701884          }
    18711885          e = it->second;
    … …  
    18921906        std::string attr, token;
    18931907        if (!_reader_bits::readToken(line, attr))
    1894           throw DataFormatError("Attribute name not found");
     1908          throw FormatError("Attribute name not found");
    18951909        if (!_reader_bits::readToken(line, token))
    1896           throw DataFormatError("Attribute value not found");
     1910          throw FormatError("Attribute value not found");
    18971911        if (line >> c)
    1898           throw DataFormatError("Extra character on the end of line");
     1912          throw FormatError("Extra character at the end of line");
    18991913
    19001914        {
    … …  
    19021916          if (it != read_attr.end()) {
    19031917            std::ostringstream msg;
    1904             msg << "Multiple occurence of attribute " << attr;
    1905             throw DataFormatError(msg.str().c_str());
     1918            msg << "Multiple occurence of attribute: " << attr;
     1919            throw FormatError(msg.str());
    19061920          }
    19071921          read_attr.insert(attr);
    … …  
    19241938        if (read_attr.find(it->first) == read_attr.end()) {
    19251939          std::ostringstream msg;
    1926           msg << "Attribute not found in file: " << it->first;
    1927           throw DataFormatError(msg.str().c_str());
     1940          msg << "Attribute not found: " << it->first;
     1941          throw FormatError(msg.str());
    19281942        }
    19291943      }
    … …  
    19591973
    19601974          if (line >> c)
    1961             throw DataFormatError("Extra character on the end of line");
     1975            throw FormatError("Extra character at the end of line");
    19621976
    19631977          if (section == "nodes" && !nodes_done) {
    … …  
    19811995            skipSection();
    19821996          }
    1983         } catch (DataFormatError& error) {
     1997        } catch (FormatError& error) {
    19841998          error.line(line_num);
     1999          error.file(_filename);
    19852000          throw;
    19862001        }
    … …  
    19882003
    19892004      if (!nodes_done) {
    1990         throw DataFormatError("Section @nodes not found");
     2005        throw FormatError("Section @nodes not found");
    19912006      }
    19922007
    19932008      if (!edges_done) {
    1994         throw DataFormatError("Section @edges not found");
     2009        throw FormatError("Section @edges not found");
    19952010      }
    19962011
    19972012      if (!attributes_done && !_attributes.empty()) {
    1998         throw DataFormatError("Section @attributes not found");
     2013        throw FormatError("Section @attributes not found");
    19992014      }
    20002015
    … …  
    20572072    std::istream* _is;
    20582073    bool local_is;
     2074    std::string _filename;
    20592075
    20602076    typedef std::map<std::string, _reader_bits::Section*> Sections;
    … …  
    20772093    /// Construct a section reader, which reads from the given file.
    20782094    SectionReader(const std::string& fn)
    2079       : _is(new std::ifstream(fn.c_str())), local_is(true) {}
     2095      : _is(new std::ifstream(fn.c_str())), local_is(true),
     2096        _filename(fn) {
     2097      if (!(*_is)) throw IoError("Cannot open file", fn);
     2098    }
    20802099
    20812100    /// \brief Constructor
    … …  
    20832102    /// Construct a section reader, which reads from the given file.
    20842103    SectionReader(const char* fn)
    2085       : _is(new std::ifstream(fn)), local_is(true) {}
     2104      : _is(new std::ifstream(fn)), local_is(true),
     2105        _filename(fn) {
     2106      if (!(*_is)) throw IoError("Cannot open file", fn);
     2107    }
    20862108
    20872109    /// \brief Destructor
    … …  
    22392261
    22402262          if (line >> c)
    2241             throw DataFormatError("Extra character on the end of line");
     2263            throw FormatError("Extra character at the end of line");
    22422264
    22432265          if (extra_sections.find(section) != extra_sections.end()) {
    22442266            std::ostringstream msg;
    2245             msg << "Multiple occurence of section " << section;
    2246             throw DataFormatError(msg.str().c_str());
     2267            msg << "Multiple occurence of section: " << section;
     2268            throw FormatError(msg.str());
    22472269          }
    22482270          Sections::iterator it = _sections.find(section);
    … …  
    22532275          readLine();
    22542276          skipSection();
    2255         } catch (DataFormatError& error) {
     2277        } catch (FormatError& error) {
    22562278          error.line(line_num);
     2279          error.file(_filename);
    22572280          throw;
    22582281        }
    … …  
    22632286          std::ostringstream os;
    22642287          os << "Cannot find section: " << it->first;
    2265           throw DataFormatError(os.str().c_str());
     2288          throw FormatError(os.str());
    22662289        }
    22672290      }
    … …  
    23632386    /// file.
    23642387    LgfContents(const std::string& fn)
    2365       : _is(new std::ifstream(fn.c_str())), local_is(true) {}
     2388      : _is(new std::ifstream(fn.c_str())), local_is(true) {
     2389      if (!(*_is)) throw IoError("Cannot open file", fn);
     2390    }
    23662391
    23672392    /// \brief Constructor
    … …  
    23702395    /// file.
    23712396    LgfContents(const char* fn)
    2372       : _is(new std::ifstream(fn)), local_is(true) {}
     2397      : _is(new std::ifstream(fn)), local_is(true) {
     2398      if (!(*_is)) throw IoError("Cannot open file", fn);
     2399    }
    23732400
    23742401    /// \brief Destructor

  • lemon/lgf_writer.h

    r293 r294  
    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 Digraph& digraph, const std::string& fn)
    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("Cannot write file", fn);
     467    }
    466468
    467469    /// \brief Constructor
    … …  
    471473    DigraphWriter(const Digraph& digraph, const char* fn)
    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("Cannot write file", fn);
     477    }
    474478
    475479    /// \brief Destructor
    … …  
    10201024    GraphWriter(const Graph& graph, const std::string& fn)
    10211025      : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph),
    1022         _skip_nodes(false), _skip_edges(false) {}
     1026        _skip_nodes(false), _skip_edges(false) {
     1027      if (!(*_os)) throw IoError("Cannot write file", fn);
     1028    }
    10231029
    10241030    /// \brief Constructor
    … …  
    10281034    GraphWriter(const Graph& graph, const char* fn)
    10291035      : _os(new std::ofstream(fn)), local_os(true), _graph(graph),
    1030         _skip_nodes(false), _skip_edges(false) {}
     1036        _skip_nodes(false), _skip_edges(false) {
     1037      if (!(*_os)) throw IoError("Cannot write file", fn);
     1038    }
    10311039
    10321040    /// \brief Destructor
    … …  
    15791587    /// Construct a section writer, which writes into the given file.
    15801588    SectionWriter(const std::string& fn)
    1581       : _os(new std::ofstream(fn.c_str())), local_os(true) {}
     1589      : _os(new std::ofstream(fn.c_str())), local_os(true) {
     1590      if (!(*_os)) throw IoError("Cannot write file", fn);
     1591    }
    15821592
    15831593    /// \brief Constructor
    … …  
    15851595    /// Construct a section writer, which writes into the given file.
    15861596    SectionWriter(const char* fn)
    1587       : _os(new std::ofstream(fn)), local_os(true) {}
     1597      : _os(new std::ofstream(fn)), local_os(true) {
     1598      if (!(*_os)) throw IoError("Cannot write file", fn);
     1599    }
    15881600
    15891601    /// \brief Destructor
Note: See TracChangeset for help on using the changeset viewer.