COIN-OR::LEMON - Graph Library

Changeset 1845:f8bbfed86036 in lemon-0.x for lemon


Ignore:
Timestamp:
12/03/05 19:17:29 (14 years ago)
Author:
Balazs Dezso
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2404
Message:

Implementation redesign
Throws exception

Location:
lemon
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • lemon/error.h

    r1827 r1845  
    377377  };
    378378
    379   class IOParameterError : public LogicError {
     379  class IOParameterError : public IOError {
    380380  protected:
    381381    ExceptionMember<std::string> _message;
     
    386386
    387387    IOParameterError(const IOParameterError &ile) :
    388       LogicError(ile), _message(ile._message), _file(ile._file) {}
     388      IOError(ile), _message(ile._message), _file(ile._file) {}
    389389
    390390    ///\e
  • lemon/lemon_reader.h

    r1746 r1845  
    4646  namespace _reader_bits {
    4747
     48    template <typename T>
     49    bool operator<(T, T) {
     50      throw DataFormatError("Id is not comparable");
     51    }
     52
     53    template <typename T>
     54    struct Less {
     55      bool operator()(const T& p, const T& q) const {
     56        return p < q;
     57      }
     58    };
     59
    4860    template <typename Item>
    4961    class ItemIdReader {
     
    8496
    8597    };
    86  
    87     template <typename T>
    88     bool operator<(T, T) {
    89       throw DataFormatError("Id is not comparable");
    90     }
    91 
    92     template <typename T>
    93     struct Less {
    94       bool operator()(const T& p, const T& q) const {
    95         return p < q;
    96       }
    97     };
    9898
    9999    template <typename Map>
     
    197197    struct Arg<YMap<Map> > {
    198198      typedef const YMap<Map>& Type;
     199    };
     200
     201
     202    template <typename _Item>
     203    class MapReaderBase;
     204   
     205    template <typename _Item>
     206    class MapInverterBase : public MapReaderBase<_Item> {
     207    public:
     208      typedef _Item Item;
     209      virtual void read(std::istream&, const Item&) = 0;
     210      virtual Item read(std::istream&) const = 0;
     211
     212      virtual MapInverterBase<_Item>* getInverter() {
     213        return this;
     214      }
     215    };
     216
     217    template <typename _Item, typename _Map, typename _Reader>
     218    class MapReaderInverter : public MapInverterBase<_Item> {
     219    public:
     220      typedef _Item Item;
     221      typedef _Reader Reader;
     222      typedef typename Reader::Value Value;
     223      typedef _Map Map;
     224      typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse;
     225
     226      typename _reader_bits::Ref<Map>::Type map;
     227      Reader reader;
     228      Inverse inverse;
     229
     230      MapReaderInverter(typename _reader_bits::Arg<Map>::Type _map,
     231                        const Reader& _reader)
     232        : map(_map), reader(_reader) {}
     233
     234      virtual ~MapReaderInverter() {}
     235
     236      virtual void read(std::istream& is, const Item& item) {
     237        Value value;
     238        reader.read(is, value);
     239        map.set(item, value);
     240        typename Inverse::iterator it = inverse.find(value);
     241        if (it == inverse.end()) {
     242          inverse.insert(std::make_pair(value, item));
     243        } else {
     244          throw DataFormatError("Multiple ID occurence");
     245        }
     246      }
     247
     248      virtual Item read(std::istream& is) const {
     249        Value value;
     250        reader.read(is, value);
     251        typename Inverse::const_iterator it = inverse.find(value);
     252        if (it != inverse.end()) {
     253          return it->second;
     254        } else {
     255          throw DataFormatError("Invalid ID error");
     256        }
     257      }     
     258    };
     259
     260    template <typename _Item, typename _Reader>
     261    class SkipReaderInverter : public MapInverterBase<_Item> {
     262    public:
     263      typedef _Item Item;
     264      typedef _Reader Reader;
     265      typedef typename Reader::Value Value;
     266      typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse;
     267
     268      Reader reader;
     269
     270      SkipReaderInverter(const Reader& _reader)
     271        : reader(_reader) {}
     272
     273      virtual ~SkipReaderInverter() {}
     274
     275      virtual void read(std::istream& is, const Item& item) {
     276        Value value;
     277        reader.read(is, value);
     278        typename Inverse::iterator it = inverse.find(value);
     279        if (it == inverse.end()) {
     280          inverse.insert(std::make_pair(value, item));
     281        } else {
     282          throw DataFormatError("Multiple ID occurence error");
     283        }
     284      }
     285
     286      virtual Item read(std::istream& is) const {
     287        Value value;
     288        reader.read(is, value);
     289        typename Inverse::const_iterator it = inverse.find(value);
     290        if (it != inverse.end()) {
     291          return it->second;
     292        } else {
     293          throw DataFormatError("Invalid ID error");
     294        }
     295      }
     296
     297    private:
     298      Inverse inverse;
     299    };
     300
     301    template <typename _Item>   
     302    class MapReaderBase {
     303    public:
     304      typedef _Item Item;
     305
     306      MapReaderBase() { _touched = false; }
     307     
     308      void touch() { _touched = true; }
     309      bool touched() const { return _touched; }
     310
     311      virtual ~MapReaderBase() {}
     312
     313      virtual void read(std::istream& is, const Item& item) = 0;
     314      virtual MapInverterBase<_Item>* getInverter() = 0;
     315
     316    private:     
     317      bool _touched;
     318
     319    };
     320
     321    template <typename _Item, typename _Map, typename _Reader>
     322    class MapReader : public MapReaderBase<_Item> {
     323    public:
     324      typedef _Map Map;
     325      typedef _Reader Reader;
     326      typedef typename Reader::Value Value;
     327      typedef _Item Item;
     328     
     329      typename _reader_bits::Ref<Map>::Type map;
     330      Reader reader;
     331
     332      MapReader(typename _reader_bits::Arg<Map>::Type _map,
     333                const Reader& _reader)
     334        : map(_map), reader(_reader) {}
     335
     336      virtual ~MapReader() {}
     337
     338      virtual void read(std::istream& is, const Item& item) {
     339        Value value;
     340        reader.read(is, value);
     341        map.set(item, value);
     342      }
     343
     344      virtual MapInverterBase<_Item>* getInverter() {
     345        return new MapReaderInverter<Item, Map, Reader>(map, reader);
     346      }
     347    };
     348
     349
     350    template <typename _Item, typename _Reader>
     351    class SkipReader : public MapReaderBase<_Item> {
     352    public:
     353      typedef _Reader Reader;
     354      typedef typename Reader::Value Value;
     355      typedef _Item Item;
     356
     357      Reader reader;
     358      SkipReader(const Reader& _reader) : reader(_reader) {}
     359
     360      virtual ~SkipReader() {}
     361
     362      virtual void read(std::istream& is, const Item&) {
     363        Value value;
     364        reader.read(is, value);
     365      }     
     366
     367      virtual MapInverterBase<Item>* getInverter() {
     368        return new SkipReaderInverter<Item, Reader>(reader);
     369      }
     370    };
     371
     372    template <typename _Item>
     373    class IdReaderBase {
     374    public:
     375      typedef _Item Item;
     376      virtual ~IdReaderBase() {}
     377      virtual Item read(std::istream& is) const = 0;
     378      virtual bool isIdReader() const = 0;
     379    };
     380
     381    template <typename _Item, typename _BoxedIdReader>
     382    class IdReader : public IdReaderBase<_Item> {
     383    public:
     384      typedef _Item Item;
     385      typedef _BoxedIdReader BoxedIdReader;
     386     
     387      const BoxedIdReader& boxedIdReader;
     388
     389      IdReader(const BoxedIdReader& _boxedIdReader)
     390        : boxedIdReader(_boxedIdReader) {}
     391
     392      virtual Item read(std::istream& is) const {
     393        Item item;
     394        boxedIdReader.readId(is, item);
     395        return item;
     396      }
     397
     398      virtual bool isIdReader() const {
     399        return boxedIdReader.isIdReader();
     400      }
     401    };
     402
     403    template <typename _Item>
     404    class ItemStore {
     405    public:
     406
     407      typedef _Item Item;
     408
     409      ItemStore(Item& _item) : item(&_item) {
     410        _touched = false;
     411      }
     412     
     413      void touch() { _touched = true; }
     414      bool touched() const { return _touched; }
     415
     416      void read(const Item& _item) {
     417        *item = _item;
     418      }
     419     
     420    private:
     421      Item* item;
     422      bool _touched;
     423    };
     424
     425    class ValueReaderBase {
     426    public:
     427      virtual void read(std::istream&) {};
     428      virtual ~ValueReaderBase() {}
     429    };
     430
     431    template <typename _Value, typename _Reader>
     432    class ValueReader : public ValueReaderBase {
     433    public:
     434      typedef _Value Value;
     435      typedef _Reader Reader;
     436
     437      ValueReader(Value& _value, const Reader& _reader)
     438        : value(_value), reader(_reader) {}
     439
     440      virtual void read(std::istream& is) {
     441        reader.read(is, value);
     442      }
     443    private:
     444      Value& value;
     445      Reader reader;
    199446    };
    200447
     
    470717  };
    471718
    472   /// \brief Helper class for implementing the common SectionReaders.
    473   ///
    474   /// Helper class for implementing the common SectionReaders.
    475   class CommonSectionReaderBase : public LemonReader::SectionReader {
    476     typedef LemonReader::SectionReader Parent;
    477   protected:
    478    
    479     /// \brief Constructor for CommonSectionReaderBase.
    480     ///
    481     /// Constructor for CommonSectionReaderBase. It attach this reader to
    482     /// the given LemonReader.
    483     CommonSectionReaderBase(LemonReader& _reader)
    484       : Parent(_reader) {}
    485 
    486     template <typename _Item>
    487     class ReaderBase;
    488    
    489     template <typename _Item>
    490     class InverterBase : public ReaderBase<_Item> {
    491     public:
    492       typedef _Item Item;
    493       virtual void read(std::istream&, const Item&) = 0;
    494       virtual Item read(std::istream&) const = 0;
    495 
    496       virtual InverterBase<_Item>* getInverter() {
    497         return this;
    498       }
    499     };
    500 
    501     template <typename _Item, typename _Map, typename _Reader>
    502     class MapReaderInverter : public InverterBase<_Item> {
    503     public:
    504       typedef _Item Item;
    505       typedef _Reader Reader;
    506       typedef typename Reader::Value Value;
    507       typedef _Map Map;
    508       typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse;
    509 
    510       typename _reader_bits::Ref<Map>::Type map;
    511       Reader reader;
    512       Inverse inverse;
    513 
    514       MapReaderInverter(typename _reader_bits::Arg<Map>::Type _map,
    515                         const Reader& _reader)
    516         : map(_map), reader(_reader) {}
    517 
    518       virtual ~MapReaderInverter() {}
    519 
    520       virtual void read(std::istream& is, const Item& item) {
    521         Value value;
    522         reader.read(is, value);
    523         map.set(item, value);
    524         typename Inverse::iterator it = inverse.find(value);
    525         if (it == inverse.end()) {
    526           inverse.insert(std::make_pair(value, item));
    527         } else {
    528           throw DataFormatError("Multiple ID occurence");
    529         }
    530       }
    531 
    532       virtual Item read(std::istream& is) const {
    533         Value value;
    534         reader.read(is, value);
    535         typename Inverse::const_iterator it = inverse.find(value);
    536         if (it != inverse.end()) {
    537           return it->second;
    538         } else {
    539           throw DataFormatError("Invalid ID error");
    540         }
    541       }     
    542     };
    543 
    544     template <typename _Item, typename _Reader>
    545     class SkipReaderInverter : public InverterBase<_Item> {
    546     public:
    547       typedef _Item Item;
    548       typedef _Reader Reader;
    549       typedef typename Reader::Value Value;
    550       typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse;
    551 
    552       Reader reader;
    553 
    554       SkipReaderInverter(const Reader& _reader)
    555         : reader(_reader) {}
    556 
    557       virtual ~SkipReaderInverter() {}
    558 
    559       virtual void read(std::istream& is, const Item& item) {
    560         Value value;
    561         reader.read(is, value);
    562         typename Inverse::iterator it = inverse.find(value);
    563         if (it == inverse.end()) {
    564           inverse.insert(std::make_pair(value, item));
    565         } else {
    566           throw DataFormatError("Multiple ID occurence error");
    567         }
    568       }
    569 
    570       virtual Item read(std::istream& is) const {
    571         Value value;
    572         reader.read(is, value);
    573         typename Inverse::const_iterator it = inverse.find(value);
    574         if (it != inverse.end()) {
    575           return it->second;
    576         } else {
    577           throw DataFormatError("Invalid ID error");
    578         }
    579       }
    580 
    581     private:
    582       Inverse inverse;
    583     };
    584 
    585     template <typename _Item>   
    586     class ReaderBase {
    587     public:
    588       typedef _Item Item;
    589 
    590       virtual ~ReaderBase() {}
    591 
    592       virtual void read(std::istream& is, const Item& item) = 0;
    593       virtual InverterBase<_Item>* getInverter() = 0;
    594     };
    595 
    596     template <typename _Item, typename _Map, typename _Reader>
    597     class MapReader : public ReaderBase<_Item> {
    598     public:
    599       typedef _Map Map;
    600       typedef _Reader Reader;
    601       typedef typename Reader::Value Value;
    602       typedef _Item Item;
    603      
    604       typename _reader_bits::Ref<Map>::Type map;
    605       Reader reader;
    606 
    607       MapReader(typename _reader_bits::Arg<Map>::Type _map,
    608                 const Reader& _reader)
    609         : map(_map), reader(_reader) {}
    610 
    611       virtual ~MapReader() {}
    612 
    613       virtual void read(std::istream& is, const Item& item) {
    614         Value value;
    615         reader.read(is, value);
    616         map.set(item, value);
    617       }
    618 
    619       virtual InverterBase<_Item>* getInverter() {
    620         return new MapReaderInverter<Item, Map, Reader>(map, reader);
    621       }
    622     };
    623 
    624 
    625     template <typename _Item, typename _Reader>
    626     class SkipReader : public ReaderBase<_Item> {
    627     public:
    628       typedef _Reader Reader;
    629       typedef typename Reader::Value Value;
    630       typedef _Item Item;
    631 
    632       Reader reader;
    633       SkipReader(const Reader& _reader) : reader(_reader) {}
    634 
    635       virtual ~SkipReader() {}
    636 
    637       virtual void read(std::istream& is, const Item&) {
    638         Value value;
    639         reader.read(is, value);
    640       }     
    641 
    642       virtual InverterBase<Item>* getInverter() {
    643         return new SkipReaderInverter<Item, Reader>(reader);
    644       }
    645     };
    646 
    647     template <typename _Item>
    648     class IdReaderBase {
    649     public:
    650       typedef _Item Item;
    651       virtual ~IdReaderBase() {}
    652       virtual Item read(std::istream& is) const = 0;
    653       virtual bool isIdReader() const = 0;
    654     };
    655 
    656     template <typename _Item, typename _BoxedIdReader>
    657     class IdReader : public IdReaderBase<_Item> {
    658     public:
    659       typedef _Item Item;
    660       typedef _BoxedIdReader BoxedIdReader;
    661      
    662       const BoxedIdReader& boxedIdReader;
    663 
    664       IdReader(const BoxedIdReader& _boxedIdReader)
    665         : boxedIdReader(_boxedIdReader) {}
    666 
    667       virtual Item read(std::istream& is) const {
    668         Item item;
    669         boxedIdReader.readId(is, item);
    670         return item;
    671       }
    672 
    673       virtual bool isIdReader() const {
    674         return boxedIdReader.isIdReader();
    675       }
    676     };
    677 
    678     class ValueReaderBase {
    679     public:
    680       virtual void read(std::istream&) {};
    681       virtual ~ValueReaderBase() {}
    682     };
    683 
    684     template <typename _Value, typename _Reader>
    685     class ValueReader : public ValueReaderBase {
    686     public:
    687       typedef _Value Value;
    688       typedef _Reader Reader;
    689 
    690       ValueReader(Value& _value, const Reader& _reader)
    691         : value(_value), reader(_reader) {}
    692 
    693       virtual void read(std::istream& is) {
    694         reader.read(is, value);
    695       }
    696     private:
    697       Value& value;
    698       Reader reader;
    699     };
    700    
    701   };
    702 
    703719  /// \ingroup io_group
    704720  /// \brief SectionReader for reading a graph's nodeset.
     
    719735  /// \relates LemonReader
    720736  template <typename _Graph, typename _Traits = DefaultReaderTraits>
    721   class NodeSetReader : public CommonSectionReaderBase {
    722     typedef CommonSectionReaderBase Parent;
     737  class NodeSetReader : public LemonReader::SectionReader {
     738    typedef LemonReader::SectionReader Parent;
    723739  public:
    724740
     
    802818        msg << "Multiple read rule for node map: " << name;
    803819        throw IOParameterError(msg.message());
    804       }
     820      }     
    805821      readers.insert(
    806         make_pair(name, new MapReader<Node, Map, Reader>(map, reader)));
     822        make_pair(name, new _reader_bits::
     823                  MapReader<Node, Map, Reader>(map, reader)));
    807824      return *this;
    808825    }
     
    821838        throw IOParameterError(msg.message());
    822839      }
    823       readers.insert(make_pair(name, new SkipReader<Node, Reader>(reader)));
     840      readers.insert(make_pair(name, new _reader_bits::
     841                               SkipReader<Node, Reader>(reader)));
    824842      return *this;
    825843    }
     
    844862    /// It reads the content of the section.
    845863    virtual void read(std::istream& is) {
    846       std::vector<ReaderBase<Node>* > index;
     864      std::vector<_reader_bits::MapReaderBase<Node>* > index;
    847865      std::string line;
    848866
     
    852870        typename MapReaders::iterator it = readers.find(id);
    853871        if (it != readers.end()) {
     872          it->second->touch();
    854873          index.push_back(it->second);
    855874        } else {
     
    859878          inverter.reset(index.back()->getInverter());
    860879          index.back() = inverter.get();
     880        }
     881      }
     882      for (typename MapReaders::iterator it = readers.begin();
     883           it != readers.end(); ++it) {
     884        if (!it->second->touched()) {
     885          ErrorMessage msg;
     886          msg << "Map not found in file: " << it->first;
     887          throw IOParameterError(msg.message());
    861888        }
    862889      }
     
    890917  private:
    891918
    892     typedef std::map<std::string, ReaderBase<Node>*> MapReaders;
     919    typedef std::map<std::string, _reader_bits::MapReaderBase<Node>*> MapReaders;
    893920    MapReaders readers;
    894921   
    895922    Graph& graph;   
    896923    std::string id;
    897     SkipReader<Node, DefaultSkipper> skipper;
    898 
    899     std::auto_ptr<InverterBase<Node> > inverter;
     924    _reader_bits::SkipReader<Node, DefaultSkipper> skipper;
     925
     926    std::auto_ptr<_reader_bits::MapInverterBase<Node> > inverter;
    900927  };
    901928
     
    923950  /// \relates LemonReader
    924951  template <typename _Graph, typename _Traits = DefaultReaderTraits>
    925   class EdgeSetReader : public CommonSectionReaderBase {
    926     typedef CommonSectionReaderBase Parent;
     952  class EdgeSetReader : public LemonReader::SectionReader {
     953    typedef LemonReader::SectionReader Parent;
    927954  public:
    928955
     
    949976      : Parent(_reader), graph(_graph), id(_id), skipper(_skipper) {
    950977      checkConcept<_reader_bits::ItemIdReader<Node>, NodeIdReader>();
    951       nodeIdReader.reset(new IdReader<Node, NodeIdReader>(_nodeIdReader));
     978      nodeIdReader.reset(new _reader_bits::
     979                         IdReader<Node, NodeIdReader>(_nodeIdReader));
    952980    }
    953981    /// \brief Destructor.
     
    10141042      }
    10151043      readers.insert(
    1016         make_pair(name, new MapReader<Edge, Map, Reader>(map, reader)));
     1044        make_pair(name, new _reader_bits::
     1045                  MapReader<Edge, Map, Reader>(map, reader)));
    10171046      return *this;
    10181047    }
     
    10311060        throw IOParameterError(msg.message());
    10321061      }
    1033       readers.insert(make_pair(name, new SkipReader<Edge, Reader>(reader)));
     1062      readers.insert(make_pair(name, new _reader_bits::
     1063                               SkipReader<Edge, Reader>(reader)));
    10341064      return *this;
    10351065    }
     
    10571087        throw DataFormatError("Cannot find nodeset or ID map");
    10581088      }
    1059       std::vector<ReaderBase<Edge>* > index;
     1089      std::vector<_reader_bits::MapReaderBase<Edge>* > index;
    10601090      std::string line;
    10611091
     
    10661096        if (it != readers.end()) {
    10671097          index.push_back(it->second);
     1098          it->second->touch();
    10681099        } else {
    10691100          index.push_back(&skipper);
     
    10721103          inverter.reset(index.back()->getInverter());
    10731104          index.back() = inverter.get();
     1105        }
     1106      }
     1107      for (typename MapReaders::iterator it = readers.begin();
     1108           it != readers.end(); ++it) {
     1109        if (!it->second->touched()) {
     1110          ErrorMessage msg;
     1111          msg << "Map not found in file: " << it->first;
     1112          throw IOParameterError(msg.message());
    10741113        }
    10751114      }
     
    11051144  private:
    11061145
    1107     typedef std::map<std::string, ReaderBase<Edge>*> MapReaders;
     1146    typedef std::map<std::string, _reader_bits::MapReaderBase<Edge>*> MapReaders;
    11081147    MapReaders readers;
    11091148   
    11101149    Graph& graph;   
    11111150    std::string id;
    1112     SkipReader<Edge, DefaultSkipper> skipper;
    1113 
    1114     std::auto_ptr<InverterBase<Edge> > inverter;
    1115     std::auto_ptr<IdReaderBase<Node> > nodeIdReader;
     1151    _reader_bits::SkipReader<Edge, DefaultSkipper> skipper;
     1152
     1153    std::auto_ptr<_reader_bits::MapInverterBase<Edge> > inverter;
     1154    std::auto_ptr<_reader_bits::IdReaderBase<Node> > nodeIdReader;
    11161155  };
    11171156
     
    11441183  /// \relates LemonReader
    11451184  template <typename _Graph, typename _Traits = DefaultReaderTraits>
    1146   class UndirEdgeSetReader : public CommonSectionReaderBase {
    1147     typedef CommonSectionReaderBase Parent;
     1185  class UndirEdgeSetReader : public LemonReader::SectionReader {
     1186    typedef LemonReader::SectionReader Parent;
    11481187  public:
    11491188
     
    11711210      : Parent(_reader), graph(_graph), id(_id), skipper(_skipper) {
    11721211      checkConcept<_reader_bits::ItemIdReader<Node>, NodeIdReader>();
    1173       nodeIdReader.reset(new IdReader<Node, NodeIdReader>(_nodeIdReader));
     1212      nodeIdReader.reset(new _reader_bits::
     1213                         IdReader<Node, NodeIdReader>(_nodeIdReader));
    11741214    }
    11751215    /// \brief Destructor.
     
    12361276      }
    12371277      readers.insert(
    1238         make_pair(name, new MapReader<UndirEdge, Map, Reader>(map, reader)));
     1278        make_pair(name, new _reader_bits::
     1279                  MapReader<UndirEdge, Map, Reader>(map, reader)));
    12391280      return *this;
    12401281    }
     
    12531294        throw IOParameterError(msg.message());
    12541295      }
    1255       readers.insert(make_pair(name,
    1256                                new SkipReader<UndirEdge, Reader>(reader)));
     1296      readers.insert(make_pair(name, new _reader_bits::
     1297                               SkipReader<UndirEdge, Reader>(reader)));
    12571298      return *this;
    12581299    }
     
    13411382        throw DataFormatError("Cannot find nodeset or ID map");
    13421383      }
    1343       std::vector<ReaderBase<UndirEdge>* > index;
     1384      std::vector<_reader_bits::MapReaderBase<UndirEdge>* > index;
    13441385      std::string line;
    13451386
     
    13501391        if (it != readers.end()) {
    13511392          index.push_back(it->second);
     1393          it->second->touch();
    13521394        } else {
    13531395          index.push_back(&skipper);
     
    13561398          inverter.reset(index.back()->getInverter());
    13571399          index.back() = inverter.get();
     1400        }
     1401      }
     1402      for (typename MapReaders::iterator it = readers.begin();
     1403           it != readers.end(); ++it) {
     1404        if (!it->second->touched()) {
     1405          ErrorMessage msg;
     1406          msg << "Map not found in file: " << it->first;
     1407          throw IOParameterError(msg.message());
    13581408        }
    13591409      }
     
    14091459  private:
    14101460
    1411     typedef std::map<std::string, ReaderBase<UndirEdge>*> MapReaders;
     1461    typedef std::map<std::string,
     1462                     _reader_bits::MapReaderBase<UndirEdge>*> MapReaders;
    14121463    MapReaders readers;
    14131464   
    14141465    Graph& graph;   
    14151466    std::string id;
    1416     SkipReader<UndirEdge, DefaultSkipper> skipper;
    1417 
    1418     std::auto_ptr<InverterBase<UndirEdge> > inverter;
    1419     std::auto_ptr<IdReaderBase<Node> > nodeIdReader;
     1467    _reader_bits::SkipReader<UndirEdge, DefaultSkipper> skipper;
     1468
     1469    std::auto_ptr<_reader_bits::MapInverterBase<UndirEdge> > inverter;
     1470    std::auto_ptr<_reader_bits::IdReaderBase<Node> > nodeIdReader;
    14201471  };
    14211472
     
    14311482  /// \relates LemonReader
    14321483  template <typename _Graph>
    1433   class NodeReader : public CommonSectionReaderBase {
    1434     typedef CommonSectionReaderBase Parent;
     1484  class NodeReader : public LemonReader::SectionReader {
     1485    typedef LemonReader::SectionReader Parent;
    14351486    typedef _Graph Graph;
    14361487    typedef typename Graph::Node Node;
     
    14481499      : Parent(_reader), id(_id) {
    14491500      checkConcept<_reader_bits::ItemIdReader<Node>, _IdReader>();
    1450       nodeIdReader.reset(new IdReader<Node, _IdReader>(_idReader));
     1501      nodeIdReader.reset(new _reader_bits::
     1502                         IdReader<Node, _IdReader>(_idReader));
    14511503    }
    14521504
     
    14711523        throw IOParameterError(msg.message());
    14721524      }
    1473       readers.insert(make_pair(name, &item));
     1525      readers.insert(make_pair(name, _reader_bits::ItemStore<Node>(item)));
    14741526    }
    14751527
     
    15031555        typename NodeReaders::iterator it = readers.find(id);
    15041556        if (it != readers.end()) {
    1505           *(it->second) = nodeIdReader->read(ls);
     1557          it->second.read(nodeIdReader->read(ls));
     1558          it->second.touch();
    15061559        }       
     1560      }
     1561      for (typename NodeReaders::iterator it = readers.begin();
     1562           it != readers.end(); ++it) {
     1563        if (!it->second.touched()) {
     1564          ErrorMessage msg;
     1565          msg << "Node not found in file: " << it->first;
     1566          throw IOParameterError(msg.message());
     1567        }
    15071568      }
    15081569    }
     
    15121573    std::string id;
    15131574
    1514     typedef std::map<std::string, Node*> NodeReaders;
     1575    typedef std::map<std::string, _reader_bits::ItemStore<Node> > NodeReaders;
    15151576    NodeReaders readers;
    1516     std::auto_ptr<IdReaderBase<Node> > nodeIdReader;
     1577    std::auto_ptr<_reader_bits::IdReaderBase<Node> > nodeIdReader;
    15171578  };
    15181579
     
    15281589  /// \relates LemonReader
    15291590  template <typename _Graph>
    1530   class EdgeReader : public CommonSectionReaderBase {
    1531     typedef CommonSectionReaderBase Parent;
     1591  class EdgeReader : public LemonReader::SectionReader {
     1592    typedef LemonReader::SectionReader Parent;
    15321593    typedef _Graph Graph;
    15331594    typedef typename Graph::Edge Edge;
     
    15451606      : Parent(_reader), id(_id) {
    15461607      checkConcept<_reader_bits::ItemIdReader<Edge>, _IdReader>();
    1547       edgeIdReader.reset(new IdReader<Edge, _IdReader>(_idReader));
     1608      edgeIdReader.reset(new _reader_bits::
     1609                         IdReader<Edge, _IdReader>(_idReader));
    15481610    }
    15491611
     
    15671629        throw IOParameterError(msg.message());
    15681630      }
    1569       readers.insert(make_pair(name, &item));
     1631      readers.insert(make_pair(name, _reader_bits::ItemStore<Edge>(item)));
    15701632    }
    15711633
     
    15991661        typename EdgeReaders::iterator it = readers.find(id);
    16001662        if (it != readers.end()) {
    1601           *(it->second) = edgeIdReader->read(ls);
     1663          it->second.read(edgeIdReader->read(ls));
     1664          it->second.touch();
    16021665        }       
     1666      }
     1667      for (typename EdgeReaders::iterator it = readers.begin();
     1668           it != readers.end(); ++it) {
     1669        if (!it->second.touched()) {
     1670          ErrorMessage msg;
     1671          msg << "Edge not found in file: " << it->first;
     1672          throw IOParameterError(msg.message());
     1673        }
    16031674      }
    16041675    }
     
    16081679    std::string id;
    16091680
    1610     typedef std::map<std::string, Edge*> EdgeReaders;
     1681    typedef std::map<std::string, _reader_bits::ItemStore<Edge> > EdgeReaders;
    16111682    EdgeReaders readers;
    1612     std::auto_ptr<IdReaderBase<Edge> > edgeIdReader;
     1683    std::auto_ptr<_reader_bits::IdReaderBase<Edge> > edgeIdReader;
    16131684  };
    16141685
     
    16241695  /// \relates LemonReader
    16251696  template <typename _Graph>
    1626   class UndirEdgeReader : public CommonSectionReaderBase {
    1627     typedef CommonSectionReaderBase Parent;
     1697  class UndirEdgeReader : public LemonReader::SectionReader {
     1698    typedef LemonReader::SectionReader Parent;
    16281699    typedef _Graph Graph;
    16291700    typedef typename Graph::Edge Edge;
     
    16441715      checkConcept<_reader_bits::ItemIdReader<UndirEdge>, _IdReader>();
    16451716      checkConcept<_reader_bits::ItemIdReader<Edge>, _IdReader>();
    1646       undirEdgeIdReader.reset(new IdReader<UndirEdge, _IdReader>(_idReader));
    1647       edgeIdReader.reset(new IdReader<Edge, _IdReader>(_idReader));
     1717      undirEdgeIdReader.reset(new _reader_bits::
     1718                              IdReader<UndirEdge, _IdReader>(_idReader));
     1719      edgeIdReader.reset(new _reader_bits::
     1720                         IdReader<Edge, _IdReader>(_idReader));
    16481721    }
    16491722
     
    16671740        throw IOParameterError(msg.message());
    16681741      }
    1669       undirEdgeReaders.insert(make_pair(name, &item));
     1742      undirEdgeReaders.insert(make_pair(name, _reader_bits::
     1743                                        ItemStore<UndirEdge>(item)));
    16701744    }
    16711745
     
    16791753        throw IOParameterError(msg.message());
    16801754      }
    1681       edgeReaders.insert(make_pair(name, &item));
     1755      edgeReaders.insert(make_pair(name, _reader_bits::ItemStore<Edge>(item)));
    16821756    }
    16831757
     
    17151789          typename UndirEdgeReaders::iterator it = undirEdgeReaders.find(id);
    17161790          if (it != undirEdgeReaders.end()) {
    1717             *(it->second) = undirEdgeIdReader->read(ls);
    1718             break;
     1791            it->second.read(undirEdgeIdReader->read(ls));
     1792            it->second.touch();
     1793            continue;
    17191794          }     
    17201795        } {
    17211796          typename EdgeReaders::iterator it = edgeReaders.find(id);
    17221797          if (it != edgeReaders.end()) {
    1723             *(it->second) = edgeIdReader->read(ls);
    1724             break;
     1798            it->second.read(edgeIdReader->read(ls));
     1799            it->second.touch();
     1800            continue;
    17251801          }     
     1802        }
     1803      }
     1804      for (typename EdgeReaders::iterator it = edgeReaders.begin();
     1805           it != edgeReaders.end(); ++it) {
     1806        if (!it->second.touched()) {
     1807          ErrorMessage msg;
     1808          msg << "Edge not found in file: " << it->first;
     1809          throw IOParameterError(msg.message());
     1810        }
     1811      }
     1812      for (typename UndirEdgeReaders::iterator it = undirEdgeReaders.begin();
     1813           it != undirEdgeReaders.end(); ++it) {
     1814        if (!it->second.touched()) {
     1815          ErrorMessage msg;
     1816          msg << "UndirEdge not found in file: " << it->first;
     1817          throw IOParameterError(msg.message());
    17261818        }
    17271819      }
     
    17321824    std::string id;
    17331825
    1734     typedef std::map<std::string, UndirEdge*> UndirEdgeReaders;
     1826    typedef std::map<std::string,
     1827                     _reader_bits::ItemStore<UndirEdge> > UndirEdgeReaders;
    17351828    UndirEdgeReaders undirEdgeReaders;
    1736     std::auto_ptr<IdReaderBase<UndirEdge> > undirEdgeIdReader;
    1737 
    1738     typedef std::map<std::string, Edge*> EdgeReaders;
     1829    std::auto_ptr<_reader_bits::IdReaderBase<UndirEdge> > undirEdgeIdReader;
     1830
     1831    typedef std::map<std::string, _reader_bits::ItemStore<Edge> > EdgeReaders;
    17391832    EdgeReaders edgeReaders;
    1740     std::auto_ptr<IdReaderBase<Edge> > edgeIdReader;
     1833    std::auto_ptr<_reader_bits::IdReaderBase<Edge> > edgeIdReader;
    17411834  };
    17421835
     
    17531846  /// \relates LemonReader
    17541847  template <typename _Traits = DefaultReaderTraits>
    1755   class AttributeReader : public CommonSectionReaderBase {
    1756     typedef CommonSectionReaderBase Parent;
     1848  class AttributeReader : public LemonReader::SectionReader {
     1849    typedef LemonReader::SectionReader Parent;
    17571850    typedef _Traits Traits;
    17581851  public:
     
    18021895        throw IOParameterError(msg.message());
    18031896      }
    1804       readers.insert(make_pair(name, new ValueReader<Value, Reader>
    1805                                (value, reader)));
     1897      readers.insert(make_pair(name, new _reader_bits::
     1898                               ValueReader<Value, Reader>(value, reader)));
    18061899      return *this;
    18071900    }
     
    18411934    std::string id;
    18421935
    1843     typedef std::map<std::string, ValueReaderBase*> Readers;
     1936    typedef std::map<std::string, _reader_bits::ValueReaderBase*> Readers;
    18441937    Readers readers; 
    18451938  };
  • lemon/lemon_writer.h

    r1705 r1845  
    165165    };
    166166
     167
     168    template <typename _Item>   
     169    class MapWriterBase {
     170    public:
     171      typedef _Item Item;
     172
     173      virtual ~MapWriterBase() {}
     174
     175      virtual void write(std::ostream& os, const Item& item) = 0;
     176    };
     177
     178
     179    template <typename _Item, typename _Map, typename _Writer>
     180    class MapWriter : public MapWriterBase<_Item> {
     181    public:
     182      typedef _Map Map;
     183      typedef _Writer Writer;
     184      typedef typename Writer::Value Value;
     185      typedef _Item Item;
     186     
     187      typename _writer_bits::Ref<Map>::Type map;
     188      Writer writer;
     189
     190      MapWriter(const Map& _map, const Writer& _writer)
     191        : map(_map), writer(_writer) {}
     192
     193      virtual ~MapWriter() {}
     194
     195      virtual void write(std::ostream& os, const Item& item) {
     196        Value value = map[item];
     197        writer.write(os, value);
     198      }
     199
     200    };
     201
     202
     203    class ValueWriterBase {
     204    public:
     205      virtual ~ValueWriterBase() {}
     206      virtual void write(std::ostream&) = 0;
     207    };
     208
     209    template <typename _Value, typename _Writer>
     210    class ValueWriter : public ValueWriterBase {
     211    public:
     212      typedef _Value Value;
     213      typedef _Writer Writer;
     214
     215      ValueWriter(const Value& _value, const Writer& _writer)
     216        : value(_value), writer(_writer) {}
     217
     218      virtual void write(std::ostream& os) {
     219        writer.write(os, value);
     220      }
     221    private:
     222      const Value& value;
     223      Writer writer;
     224    };
     225   
     226
     227    template <typename _Item>
     228    class IdWriterBase {
     229    public:
     230      typedef _Item Item;
     231      virtual ~IdWriterBase() {}
     232      virtual void write(std::ostream&, const Item&) const = 0;
     233      virtual bool isIdWriter() const = 0;
     234    };
     235
     236    template <typename _Item, typename _BoxedIdWriter>
     237    class IdWriter : public IdWriterBase<_Item> {
     238    public:
     239      typedef _Item Item;
     240      typedef _BoxedIdWriter BoxedIdWriter;
     241
     242      const BoxedIdWriter& idWriter;
     243
     244      IdWriter(const BoxedIdWriter& _idWriter)
     245        : idWriter(_idWriter) {}
     246
     247      virtual void write(std::ostream& os, const Item& item) const {
     248        idWriter.writeId(os, item);
     249      }
     250
     251      virtual bool isIdWriter() const {
     252        return idWriter.isIdWriter();
     253      }
     254    };
     255
    167256  }
    168257
     
    282371  };
    283372
    284   /// \brief Helper class for implementing the common SectionWriters.
    285   ///
    286   /// Helper class for implementing the common SectionWriters.
    287   class CommonSectionWriterBase : public LemonWriter::SectionWriter {
    288     typedef LemonWriter::SectionWriter Parent;
    289   protected:
    290    
    291     /// \brief Constructor for CommonSectionWriterBase.
    292     ///
    293     /// Constructor for CommonSectionWriterBase. It attach this writer to
    294     /// the given LemonWriter.
    295     CommonSectionWriterBase(LemonWriter& _writer)
    296       : Parent(_writer) {}
    297 
    298     template <typename _Item>   
    299     class WriterBase {
    300     public:
    301       typedef _Item Item;
    302 
    303       virtual ~WriterBase() {}
    304 
    305       virtual void write(std::ostream& os, const Item& item) = 0;
    306     };
    307 
    308 
    309     template <typename _Item, typename _Map, typename _Writer>
    310     class MapWriter : public WriterBase<_Item> {
    311     public:
    312       typedef _Map Map;
    313       typedef _Writer Writer;
    314       typedef typename Writer::Value Value;
    315       typedef _Item Item;
    316      
    317       typename _writer_bits::Ref<Map>::Type map;
    318       Writer writer;
    319 
    320       MapWriter(const Map& _map, const Writer& _writer)
    321         : map(_map), writer(_writer) {}
    322 
    323       virtual ~MapWriter() {}
    324 
    325       virtual void write(std::ostream& os, const Item& item) {
    326         Value value = map[item];
    327         writer.write(os, value);
    328       }
    329 
    330     };
    331 
    332 
    333     class ValueWriterBase {
    334     public:
    335       virtual ~ValueWriterBase() {}
    336       virtual void write(std::ostream&) = 0;
    337     };
    338 
    339     template <typename _Value, typename _Writer>
    340     class ValueWriter : public ValueWriterBase {
    341     public:
    342       typedef _Value Value;
    343       typedef _Writer Writer;
    344 
    345       ValueWriter(const Value& _value, const Writer& _writer)
    346         : value(_value), writer(_writer) {}
    347 
    348       virtual void write(std::ostream& os) {
    349         writer.write(os, value);
    350       }
    351     private:
    352       const Value& value;
    353       Writer writer;
    354     };
    355    
    356 
    357     template <typename _Item>
    358     class IdWriterBase {
    359     public:
    360       typedef _Item Item;
    361       virtual ~IdWriterBase() {}
    362       virtual void write(std::ostream&, const Item&) const = 0;
    363       virtual bool isIdWriter() const = 0;
    364     };
    365 
    366     template <typename _Item, typename _BoxedIdWriter>
    367     class IdWriter : public IdWriterBase<_Item> {
    368     public:
    369       typedef _Item Item;
    370       typedef _BoxedIdWriter BoxedIdWriter;
    371 
    372       const BoxedIdWriter& idWriter;
    373 
    374       IdWriter(const BoxedIdWriter& _idWriter)
    375         : idWriter(_idWriter) {}
    376 
    377       virtual void write(std::ostream& os, const Item& item) const {
    378         idWriter.writeId(os, item);
    379       }
    380 
    381       virtual bool isIdWriter() const {
    382         return idWriter.isIdWriter();
    383       }
    384     };
    385   };
    386 
    387373  /// \ingroup io_group
    388374  /// \brief SectionWriter for writing a graph's nodeset.
     
    404390  /// \relates LemonWriter
    405391  template <typename _Graph, typename _Traits = DefaultWriterTraits>
    406   class NodeSetWriter : public CommonSectionWriterBase {
    407     typedef CommonSectionWriterBase Parent;
     392  class NodeSetWriter : public LemonWriter::SectionWriter {
     393    typedef LemonWriter::SectionWriter Parent;
    408394  public:
    409395
     
    458444      checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
    459445      writers.push_back(
    460         make_pair(name, new MapWriter<Node, Map, Writer>(map, writer)));
     446        make_pair(name, new _writer_bits::
     447                  MapWriter<Node, Map, Writer>(map, writer)));
    461448      return *this;
    462449    }
     
    528515  private:
    529516
    530     typedef std::vector<std::pair<std::string, WriterBase<Node>*> > MapWriters;
     517    typedef std::vector<std::pair<std::string, _writer_bits::
     518                                  MapWriterBase<Node>*> > MapWriters;
    531519    MapWriters writers;
    532520
    533     WriterBase<Node>* idMap;
     521    _writer_bits::MapWriterBase<Node>* idMap;
    534522    bool forceIdMap;
    535523   
     
    563551  /// \relates LemonWriter
    564552  template <typename _Graph, typename _Traits = DefaultWriterTraits>
    565   class EdgeSetWriter : public CommonSectionWriterBase {
    566     typedef CommonSectionWriterBase Parent;
     553  class EdgeSetWriter : public LemonWriter::SectionWriter {
     554    typedef LemonWriter::SectionWriter Parent;
    567555  public:
    568556
     
    587575        graph(_graph), id(_id) {
    588576      checkConcept<_writer_bits::ItemIdWriter<Node>, NodeIdWriter>();
    589       nodeIdWriter.reset(new IdWriter<Node, NodeIdWriter>(_nodeIdWriter));
     577      nodeIdWriter.reset(new _writer_bits::
     578                         IdWriter<Node, NodeIdWriter>(_nodeIdWriter));
    590579    }
    591580
     
    624613      checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
    625614      writers.push_back(
    626         make_pair(name, new MapWriter<Edge, Map, Writer>(map, writer)));
     615        make_pair(name, new _writer_bits::
     616                  MapWriter<Edge, Map, Writer>(map, writer)));
    627617      return *this;
    628618    }
     
    702692  private:
    703693
    704     typedef std::vector<std::pair<std::string, WriterBase<Edge>*> > MapWriters;
     694    typedef std::vector<std::pair<std::string, _writer_bits::
     695                                  MapWriterBase<Edge>*> > MapWriters;
    705696    MapWriters writers;
    706697
    707     WriterBase<Edge>* idMap;
     698    _writer_bits::MapWriterBase<Edge>* idMap;
    708699    bool forceIdMap;
    709700   
     
    711702    std::string id;
    712703
    713     std::auto_ptr<IdWriterBase<Node> > nodeIdWriter;
     704    std::auto_ptr<_writer_bits::IdWriterBase<Node> > nodeIdWriter;
    714705  };
    715706
     
    744735  /// \relates LemonWriter
    745736  template <typename _Graph, typename _Traits = DefaultWriterTraits>
    746   class UndirEdgeSetWriter : public CommonSectionWriterBase {
    747     typedef CommonSectionWriterBase Parent;
     737  class UndirEdgeSetWriter : public LemonWriter::SectionWriter {
     738    typedef LemonWriter::SectionWriter Parent;
    748739  public:
    749740
     
    769760        graph(_graph), id(_id) {
    770761      checkConcept<_writer_bits::ItemIdWriter<Node>, NodeIdWriter>();
    771       nodeIdWriter.reset(new IdWriter<Node, NodeIdWriter>(_nodeIdWriter));
     762      nodeIdWriter.reset(new _writer_bits::
     763                         IdWriter<Node, NodeIdWriter>(_nodeIdWriter));
    772764    }
    773765
     
    806798      checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
    807799      writers.push_back(
    808         make_pair(name, new MapWriter<UndirEdge, Map, Writer>(map, writer)));
     800        make_pair(name, new _writer_bits::
     801                  MapWriter<UndirEdge, Map, Writer>(map, writer)));
    809802      return *this;
    810803    }
     
    929922  private:
    930923
    931     typedef std::vector<std::pair<std::string,
    932                                   WriterBase<UndirEdge>*> > MapWriters;
     924    typedef std::vector<std::pair<std::string, _writer_bits::
     925                                  MapWriterBase<UndirEdge>*> > MapWriters;
    933926    MapWriters writers;
    934927
    935     WriterBase<UndirEdge>* idMap;
     928    _writer_bits::MapWriterBase<UndirEdge>* idMap;
    936929    bool forceIdMap;
    937930   
     
    939932    std::string id;
    940933
    941     std::auto_ptr<IdWriterBase<Node> > nodeIdWriter;
     934    std::auto_ptr<_writer_bits::IdWriterBase<Node> > nodeIdWriter;
    942935  };
    943936
     
    953946  /// \relates LemonWriter
    954947  template <typename _Graph>
    955   class NodeWriter : public CommonSectionWriterBase {
    956     typedef CommonSectionWriterBase Parent;
     948  class NodeWriter : public LemonWriter::SectionWriter {
     949    typedef LemonWriter::SectionWriter Parent;
    957950    typedef _Graph Graph;
    958951    typedef typename Graph::Node Node;
     
    969962      : Parent(_writer), id(_id) {
    970963      checkConcept<_writer_bits::ItemIdWriter<Node>, _IdWriter>();
    971       idWriter.reset(new IdWriter<Node, _IdWriter>(_idWriter));
     964      idWriter.reset(new _writer_bits::IdWriter<Node, _IdWriter>(_idWriter));
    972965    }
    973966
     
    10211014    typedef std::vector<std::pair<std::string, const Node*> > NodeWriters;
    10221015    NodeWriters writers;
    1023     std::auto_ptr<IdWriterBase<Node> > idWriter;
     1016    std::auto_ptr<_writer_bits::IdWriterBase<Node> > idWriter;
    10241017  };
    10251018
     
    10351028  /// \relates LemonWriter
    10361029  template <typename _Graph>
    1037   class EdgeWriter : public CommonSectionWriterBase {
    1038     typedef CommonSectionWriterBase Parent;
     1030  class EdgeWriter : public LemonWriter::SectionWriter {
     1031    typedef LemonWriter::SectionWriter Parent;
    10391032    typedef _Graph Graph;
    10401033    typedef typename Graph::Edge Edge;
     
    10511044      : Parent(_writer), id(_id) {
    10521045      checkConcept<_writer_bits::ItemIdWriter<Edge>, _IdWriter>();
    1053       idWriter.reset(new IdWriter<Edge, _IdWriter>(_idWriter));
     1046      idWriter.reset(new _writer_bits::IdWriter<Edge, _IdWriter>(_idWriter));
    10541047    }
    10551048
     
    11021095    EdgeWriters writers;
    11031096
    1104     std::auto_ptr<IdWriterBase<Edge> > idWriter;
     1097    std::auto_ptr<_writer_bits::IdWriterBase<Edge> > idWriter;
    11051098  };
    11061099
     
    11161109  /// \relates LemonWriter
    11171110  template <typename _Graph>
    1118   class UndirEdgeWriter : public CommonSectionWriterBase {
    1119     typedef CommonSectionWriterBase Parent;
     1111  class UndirEdgeWriter : public LemonWriter::SectionWriter {
     1112    typedef LemonWriter::SectionWriter Parent;
    11201113    typedef _Graph Graph;
    11211114    typedef typename Graph::Node Node;
     
    11361129      checkConcept<_writer_bits::ItemIdWriter<Edge>, _IdWriter>();
    11371130      checkConcept<_writer_bits::ItemIdWriter<UndirEdge>, _IdWriter>();
    1138       undirEdgeIdWriter.reset(new IdWriter<UndirEdge, _IdWriter>(_idWriter));
    1139       edgeIdWriter.reset(new IdWriter<Edge, _IdWriter>(_idWriter));
     1131      undirEdgeIdWriter.reset(new _writer_bits::
     1132                              IdWriter<UndirEdge, _IdWriter>(_idWriter));
     1133      edgeIdWriter.reset(new _writer_bits::
     1134                         IdWriter<Edge, _IdWriter>(_idWriter));
    11401135    }
    11411136
     
    12031198                                  const UndirEdge*> > UndirEdgeWriters;
    12041199    UndirEdgeWriters undirEdgeWriters;
    1205     std::auto_ptr<IdWriterBase<UndirEdge> > undirEdgeIdWriter;
     1200    std::auto_ptr<_writer_bits::IdWriterBase<UndirEdge> > undirEdgeIdWriter;
    12061201
    12071202    typedef std::vector<std::pair<std::string, const Edge*> > EdgeWriters;
    12081203    EdgeWriters edgeWriters;
    1209     std::auto_ptr<IdWriterBase<Edge> > edgeIdWriter;
     1204    std::auto_ptr<_writer_bits::IdWriterBase<Edge> > edgeIdWriter;
    12101205
    12111206  };
     
    12231218  /// \relates LemonWriter
    12241219  template <typename _Traits = DefaultWriterTraits>
    1225   class AttributeWriter : public CommonSectionWriterBase {
    1226     typedef CommonSectionWriterBase Parent;
     1220  class AttributeWriter : public LemonWriter::SectionWriter {
     1221    typedef LemonWriter::SectionWriter Parent;
    12271222    typedef _Traits Traits;
    12281223  public:
     
    12681263                                    const Writer& writer = Writer()) {
    12691264      checkConcept<_writer_bits::ItemWriter<Value>, Writer>();
    1270       writers.push_back(make_pair(name, new ValueWriter<Value, Writer>
    1271                                (value, writer)));
     1265      writers.push_back(make_pair(name, new _writer_bits::
     1266                                  ValueWriter<Value, Writer>(value, writer)));
    12721267      return *this;
    12731268    }
     
    12971292    std::string id;
    12981293
    1299     typedef std::vector<std::pair<std::string, ValueWriterBase*> > Writers;
     1294    typedef std::vector<std::pair<std::string,
     1295                                  _writer_bits::ValueWriterBase*> > Writers;
    13001296    Writers writers; 
    13011297  };
Note: See TracChangeset for help on using the changeset viewer.