lemon/lgf_reader.h
author Alpar Juttner <alpar@cs.elte.hu>
Wed, 09 Jul 2008 07:57:09 +0200
changeset 196 420013ff029b
parent 190 1e6af6f0843c
child 197 5893bacaa720
permissions -rw-r--r--
Merge
deba@127
     1
/* -*- C++ -*-
deba@127
     2
 *
deba@127
     3
 * This file is a part of LEMON, a generic C++ optimization library
deba@127
     4
 *
deba@127
     5
 * Copyright (C) 2003-2008
deba@127
     6
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
deba@127
     7
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
deba@127
     8
 *
deba@127
     9
 * Permission to use, modify and distribute this software is granted
deba@127
    10
 * provided that this copyright notice appears in all copies. For
deba@127
    11
 * precise terms see the accompanying LICENSE file.
deba@127
    12
 *
deba@127
    13
 * This software is provided "AS IS" with no warranty of any kind,
deba@127
    14
 * express or implied, and with no claim as to its suitability for any
deba@127
    15
 * purpose.
deba@127
    16
 *
deba@127
    17
 */
deba@127
    18
deba@127
    19
///\ingroup lemon_io
deba@127
    20
///\file
kpeter@192
    21
///\brief \ref lgf-format "Lemon Graph Format" reader.
deba@127
    22
deba@127
    23
deba@127
    24
#ifndef LEMON_LGF_READER_H
deba@127
    25
#define LEMON_LGF_READER_H
deba@127
    26
deba@127
    27
#include <iostream>
deba@127
    28
#include <fstream>
deba@127
    29
#include <sstream>
deba@127
    30
deba@127
    31
#include <set>
deba@127
    32
#include <map>
deba@127
    33
deba@127
    34
#include <lemon/assert.h>
deba@127
    35
#include <lemon/graph_utils.h>
deba@127
    36
deba@127
    37
#include <lemon/lgf_writer.h>
deba@127
    38
deba@127
    39
#include <lemon/concept_check.h>
deba@127
    40
#include <lemon/concepts/maps.h>
deba@127
    41
deba@127
    42
namespace lemon {
deba@127
    43
deba@127
    44
  namespace _reader_bits {
deba@127
    45
deba@127
    46
    template <typename Value>
deba@127
    47
    struct DefaultConverter {
deba@127
    48
      Value operator()(const std::string& str) {
deba@127
    49
	std::istringstream is(str);
deba@127
    50
	Value value;
deba@127
    51
	is >> value;
deba@127
    52
deba@127
    53
	char c;
deba@127
    54
	if (is >> std::ws >> c) {
deba@127
    55
	  throw DataFormatError("Remaining characters in token");
deba@127
    56
	}
deba@127
    57
	return value;
deba@127
    58
      }
deba@127
    59
    };
deba@127
    60
deba@127
    61
    template <>
deba@127
    62
    struct DefaultConverter<std::string> {
deba@127
    63
      std::string operator()(const std::string& str) {
deba@127
    64
	return str;
deba@127
    65
      }
deba@127
    66
    };
deba@127
    67
deba@127
    68
    template <typename _Item>    
deba@127
    69
    class MapStorageBase {
deba@127
    70
    public:
deba@127
    71
      typedef _Item Item;
deba@127
    72
deba@127
    73
    public:
deba@127
    74
      MapStorageBase() {}
deba@127
    75
      virtual ~MapStorageBase() {}
deba@127
    76
deba@127
    77
      virtual void set(const Item& item, const std::string& value) = 0;
deba@127
    78
deba@127
    79
    };
deba@127
    80
deba@127
    81
    template <typename _Item, typename _Map, 
deba@127
    82
	      typename _Converter = DefaultConverter<typename _Map::Value> >
deba@127
    83
    class MapStorage : public MapStorageBase<_Item> {
deba@127
    84
    public:
deba@127
    85
      typedef _Map Map;
deba@127
    86
      typedef _Converter Converter;
deba@127
    87
      typedef _Item Item;
deba@127
    88
      
deba@127
    89
    private:
deba@127
    90
      Map& _map;
deba@127
    91
      Converter _converter;
deba@127
    92
deba@127
    93
    public:
deba@127
    94
      MapStorage(Map& map, const Converter& converter = Converter()) 
deba@127
    95
	: _map(map), _converter(converter) {}
deba@127
    96
      virtual ~MapStorage() {}
deba@127
    97
deba@127
    98
      virtual void set(const Item& item ,const std::string& value) {
deba@127
    99
	_map.set(item, _converter(value));
deba@127
   100
      }
deba@127
   101
    };
deba@127
   102
deba@165
   103
    template <typename _Graph, bool _dir, typename _Map, 
deba@165
   104
	      typename _Converter = DefaultConverter<typename _Map::Value> >
deba@165
   105
    class GraphArcMapStorage : public MapStorageBase<typename _Graph::Edge> {
deba@165
   106
    public:
deba@165
   107
      typedef _Map Map;
deba@165
   108
      typedef _Converter Converter;
deba@165
   109
      typedef _Graph Graph;
deba@165
   110
      typedef typename Graph::Edge Item;
deba@165
   111
      static const bool dir = _dir;
deba@165
   112
      
deba@165
   113
    private:
deba@165
   114
      const Graph& _graph;
deba@165
   115
      Map& _map;
deba@165
   116
      Converter _converter;
deba@165
   117
deba@165
   118
    public:
deba@165
   119
      GraphArcMapStorage(const Graph& graph, Map& map, 
deba@165
   120
			 const Converter& converter = Converter()) 
deba@165
   121
	: _graph(graph), _map(map), _converter(converter) {}
deba@165
   122
      virtual ~GraphArcMapStorage() {}
deba@165
   123
deba@165
   124
      virtual void set(const Item& item ,const std::string& value) {
deba@165
   125
	_map.set(_graph.direct(item, dir), _converter(value));
deba@165
   126
      }
deba@165
   127
    };
deba@165
   128
deba@127
   129
    class ValueStorageBase {
deba@127
   130
    public:
deba@127
   131
      ValueStorageBase() {}
deba@127
   132
      virtual ~ValueStorageBase() {}
deba@127
   133
deba@127
   134
      virtual void set(const std::string&) = 0;
deba@127
   135
    };
deba@127
   136
deba@127
   137
    template <typename _Value, typename _Converter = DefaultConverter<_Value> >
deba@127
   138
    class ValueStorage : public ValueStorageBase {
deba@127
   139
    public:
deba@127
   140
      typedef _Value Value;
deba@127
   141
      typedef _Converter Converter;
deba@127
   142
deba@127
   143
    private:
deba@127
   144
      Value& _value;
deba@127
   145
      Converter _converter;
deba@127
   146
deba@127
   147
    public:
deba@127
   148
      ValueStorage(Value& value, const Converter& converter = Converter())
deba@127
   149
 	: _value(value), _converter(converter) {}
deba@127
   150
deba@127
   151
      virtual void set(const std::string& value) {
deba@127
   152
	_value = _converter(value);
deba@127
   153
      }
deba@127
   154
    };
deba@127
   155
deba@127
   156
    template <typename Value>
deba@127
   157
    struct MapLookUpConverter {
deba@127
   158
      const std::map<std::string, Value>& _map;
deba@127
   159
deba@127
   160
      MapLookUpConverter(const std::map<std::string, Value>& map)
deba@127
   161
        : _map(map) {}
deba@127
   162
deba@127
   163
      Value operator()(const std::string& str) {
deba@127
   164
        typename std::map<std::string, Value>::const_iterator it =
deba@127
   165
          _map.find(str);
deba@127
   166
        if (it == _map.end()) {
deba@127
   167
          std::ostringstream msg;
deba@127
   168
          msg << "Item not found: " << str;
deba@127
   169
          throw DataFormatError(msg.str().c_str());
deba@127
   170
        }
deba@127
   171
        return it->second;
deba@127
   172
      }
deba@127
   173
    };
deba@127
   174
deba@165
   175
    template <typename Graph>
deba@165
   176
    struct GraphArcLookUpConverter {
deba@165
   177
      const Graph& _graph;
deba@165
   178
      const std::map<std::string, typename Graph::Edge>& _map;
deba@165
   179
      
deba@165
   180
      GraphArcLookUpConverter(const Graph& graph, 
deba@165
   181
			      const std::map<std::string,
deba@165
   182
			                     typename Graph::Edge>& map) 
deba@165
   183
	: _graph(graph), _map(map) {}
deba@165
   184
      
deba@165
   185
      typename Graph::Arc operator()(const std::string& str) {
deba@165
   186
	if (str.empty() || (str[0] != '+' && str[0] != '-')) {
deba@165
   187
	  throw DataFormatError("Item must start with '+' or '-'");
deba@165
   188
	}
deba@165
   189
	typename std::map<std::string, typename Graph::Edge>
deba@165
   190
	  ::const_iterator it = _map.find(str.substr(1));
deba@165
   191
	if (it == _map.end()) {
deba@165
   192
	  throw DataFormatError("Item not found");
deba@165
   193
	}
deba@165
   194
	return _graph.direct(it->second, str[0] == '+');
deba@165
   195
      }
deba@165
   196
    };
deba@165
   197
deba@127
   198
    bool isWhiteSpace(char c) {
deba@127
   199
      return c == ' ' || c == '\t' || c == '\v' || 
deba@127
   200
        c == '\n' || c == '\r' || c == '\f'; 
deba@127
   201
    }
deba@127
   202
    
deba@127
   203
    bool isOct(char c) {
deba@127
   204
      return '0' <= c && c <='7'; 
deba@127
   205
    }
deba@127
   206
    
deba@127
   207
    int valueOct(char c) {
deba@127
   208
      LEMON_ASSERT(isOct(c), "The character is not octal.");
deba@127
   209
      return c - '0';
deba@127
   210
    }
deba@127
   211
deba@127
   212
    bool isHex(char c) {
deba@127
   213
      return ('0' <= c && c <= '9') || 
deba@127
   214
	('a' <= c && c <= 'z') || 
deba@127
   215
	('A' <= c && c <= 'Z'); 
deba@127
   216
    }
deba@127
   217
    
deba@127
   218
    int valueHex(char c) {
deba@127
   219
      LEMON_ASSERT(isHex(c), "The character is not hexadecimal.");
deba@127
   220
      if ('0' <= c && c <= '9') return c - '0';
deba@127
   221
      if ('a' <= c && c <= 'z') return c - 'a' + 10;
deba@127
   222
      return c - 'A' + 10;
deba@127
   223
    }
deba@127
   224
deba@127
   225
    bool isIdentifierFirstChar(char c) {
deba@127
   226
      return ('a' <= c && c <= 'z') ||
deba@127
   227
	('A' <= c && c <= 'Z') || c == '_';
deba@127
   228
    }
deba@127
   229
deba@127
   230
    bool isIdentifierChar(char c) {
deba@127
   231
      return isIdentifierFirstChar(c) ||
deba@127
   232
	('0' <= c && c <= '9');
deba@127
   233
    }
deba@127
   234
deba@127
   235
    char readEscape(std::istream& is) {
deba@127
   236
      char c;
deba@127
   237
      if (!is.get(c))
deba@127
   238
	throw DataFormatError("Escape format error");
deba@127
   239
deba@127
   240
      switch (c) {
deba@127
   241
      case '\\':
deba@127
   242
	return '\\';
deba@127
   243
      case '\"':
deba@127
   244
	return '\"';
deba@127
   245
      case '\'':
deba@127
   246
	return '\'';
deba@127
   247
      case '\?':
deba@127
   248
	return '\?';
deba@127
   249
      case 'a':
deba@127
   250
	return '\a';
deba@127
   251
      case 'b':
deba@127
   252
	return '\b';
deba@127
   253
      case 'f':
deba@127
   254
	return '\f';
deba@127
   255
      case 'n':
deba@127
   256
	return '\n';
deba@127
   257
      case 'r':
deba@127
   258
	return '\r';
deba@127
   259
      case 't':
deba@127
   260
	return '\t';
deba@127
   261
      case 'v':
deba@127
   262
	return '\v';
deba@127
   263
      case 'x':
deba@127
   264
	{
deba@127
   265
	  int code;
deba@127
   266
	  if (!is.get(c) || !isHex(c)) 
deba@127
   267
	    throw DataFormatError("Escape format error");
deba@127
   268
	  else if (code = valueHex(c), !is.get(c) || !isHex(c)) is.putback(c);
deba@127
   269
	  else code = code * 16 + valueHex(c);
deba@127
   270
	  return code;
deba@127
   271
	}
deba@127
   272
      default:
deba@127
   273
	{
deba@127
   274
	  int code;
deba@127
   275
	  if (!isOct(c)) 
deba@127
   276
	    throw DataFormatError("Escape format error");
deba@127
   277
	  else if (code = valueOct(c), !is.get(c) || !isOct(c)) 
deba@127
   278
	    is.putback(c);
deba@127
   279
	  else if (code = code * 8 + valueOct(c), !is.get(c) || !isOct(c)) 
deba@127
   280
	    is.putback(c);
deba@127
   281
	  else code = code * 8 + valueOct(c);
deba@127
   282
	  return code;
deba@127
   283
	}	      
deba@127
   284
      } 
deba@127
   285
    }
deba@127
   286
    
deba@127
   287
    std::istream& readToken(std::istream& is, std::string& str) {
deba@127
   288
      std::ostringstream os;
deba@127
   289
deba@127
   290
      char c;
deba@127
   291
      is >> std::ws;
deba@127
   292
      
deba@127
   293
      if (!is.get(c)) 
deba@127
   294
	return is;
deba@127
   295
deba@127
   296
      if (c == '\"') {
deba@127
   297
	while (is.get(c) && c != '\"') {
deba@127
   298
	  if (c == '\\') 
deba@127
   299
	    c = readEscape(is);
deba@127
   300
	  os << c;
deba@127
   301
	}
deba@127
   302
	if (!is) 
deba@127
   303
	  throw DataFormatError("Quoted format error");
deba@127
   304
      } else {
deba@127
   305
	is.putback(c);
deba@127
   306
	while (is.get(c) && !isWhiteSpace(c)) {
deba@127
   307
	  if (c == '\\') 
deba@127
   308
	    c = readEscape(is);
deba@127
   309
	  os << c;
deba@127
   310
	}
deba@127
   311
	if (!is) {
deba@127
   312
	  is.clear();
deba@127
   313
	} else {
deba@127
   314
	  is.putback(c);
deba@127
   315
	}
deba@127
   316
      }
deba@127
   317
      str = os.str();
deba@127
   318
      return is;
deba@127
   319
    }
deba@162
   320
deba@162
   321
    class Section {
deba@162
   322
    public:
deba@162
   323
      virtual ~Section() {}
deba@162
   324
      virtual void process(std::istream& is, int& line_num) = 0;
deba@162
   325
    };
deba@162
   326
deba@162
   327
    template <typename Functor>
deba@162
   328
    class LineSection : public Section {
deba@162
   329
    private:
deba@162
   330
deba@162
   331
      Functor _functor;
deba@162
   332
deba@162
   333
    public:
deba@162
   334
      
deba@162
   335
      LineSection(const Functor& functor) : _functor(functor) {}
deba@162
   336
      virtual ~LineSection() {}
deba@162
   337
deba@162
   338
      virtual void process(std::istream& is, int& line_num) {
deba@162
   339
	char c;
deba@162
   340
	std::string line;
deba@162
   341
	while (is.get(c) && c != '@') {
deba@162
   342
	  if (c == '\n') {
deba@162
   343
	    ++line_num;
deba@162
   344
	  } else if (c == '#') {
deba@162
   345
	    getline(is, line);
deba@162
   346
	    ++line_num;
deba@162
   347
	  } else if (!isWhiteSpace(c)) {
deba@162
   348
	    is.putback(c);
deba@162
   349
	    getline(is, line);
deba@162
   350
	    _functor(line);
deba@162
   351
	    ++line_num;
deba@162
   352
	  }
deba@162
   353
	}
deba@162
   354
	if (is) is.putback(c);
deba@162
   355
	else if (is.eof()) is.clear();
deba@162
   356
      }
deba@162
   357
    };
deba@162
   358
deba@162
   359
    template <typename Functor>
deba@162
   360
    class StreamSection : public Section {
deba@162
   361
    private:
deba@162
   362
deba@162
   363
      Functor _functor;
deba@162
   364
deba@162
   365
    public:
deba@162
   366
      
deba@162
   367
      StreamSection(const Functor& functor) : _functor(functor) {}
deba@162
   368
      virtual ~StreamSection() {} 
deba@162
   369
deba@162
   370
      virtual void process(std::istream& is, int& line_num) {
deba@162
   371
	_functor(is, line_num);
deba@162
   372
	char c;
deba@162
   373
	std::string line;
deba@162
   374
	while (is.get(c) && c != '@') {
deba@162
   375
	  if (c == '\n') {
deba@162
   376
	    ++line_num;
deba@162
   377
	  } else if (!isWhiteSpace(c)) {
deba@162
   378
	    getline(is, line);
deba@162
   379
	    ++line_num;
deba@162
   380
	  }
deba@162
   381
	}
deba@162
   382
	if (is) is.putback(c);
deba@162
   383
	else if (is.eof()) is.clear();	
deba@162
   384
      }
deba@162
   385
    };
deba@127
   386
    
deba@127
   387
  }
alpar@156
   388
deba@190
   389
  template <typename Digraph>
deba@190
   390
  class DigraphReader;
deba@190
   391
deba@190
   392
  template <typename Digraph>
deba@190
   393
  DigraphReader<Digraph> digraphReader(std::istream& is, Digraph& digraph);
deba@190
   394
deba@190
   395
  template <typename Digraph>
deba@190
   396
  DigraphReader<Digraph> digraphReader(const std::string& fn, Digraph& digraph);
deba@190
   397
deba@190
   398
  template <typename Digraph>
deba@190
   399
  DigraphReader<Digraph> digraphReader(const char *fn, Digraph& digraph);
deba@190
   400
alpar@156
   401
  /// \ingroup lemon_io
alpar@156
   402
  ///  
kpeter@192
   403
  /// \brief \ref lgf-format "LGF" reader for directed graphs
alpar@156
   404
  ///
alpar@156
   405
  /// This utility reads an \ref lgf-format "LGF" file.
alpar@156
   406
  ///
alpar@156
   407
  /// The reading method does a batch processing. The user creates a
alpar@156
   408
  /// reader object, then various reading rules can be added to the
alpar@156
   409
  /// reader, and eventually the reading is executed with the \c run()
alpar@156
   410
  /// member function. A map reading rule can be added to the reader
alpar@156
   411
  /// with the \c nodeMap() or \c arcMap() members. An optional
deba@162
   412
  /// converter parameter can also be added as a standard functor
kpeter@192
   413
  /// converting from \c std::string to the value type of the map. If it
deba@162
   414
  /// is set, it will determine how the tokens in the file should be
kpeter@192
   415
  /// converted to the value type of the map. If the functor is not set,
deba@162
   416
  /// then a default conversion will be used. One map can be read into
deba@162
   417
  /// multiple map objects at the same time. The \c attribute(), \c
deba@162
   418
  /// node() and \c arc() functions are used to add attribute reading
deba@162
   419
  /// rules.
alpar@156
   420
  ///
alpar@156
   421
  ///\code
kpeter@192
   422
  /// DigraphReader<Digraph>(std::cin, digraph).
kpeter@192
   423
  ///   nodeMap("coordinates", coord_map).
kpeter@192
   424
  ///   arcMap("capacity", cap_map).
kpeter@192
   425
  ///   node("source", src).
kpeter@192
   426
  ///   node("target", trg).
kpeter@192
   427
  ///   attribute("caption", caption).
kpeter@192
   428
  ///   run();
alpar@156
   429
  ///\endcode
alpar@156
   430
  ///
alpar@156
   431
  /// By default the reader uses the first section in the file of the
alpar@156
   432
  /// proper type. If a section has an optional name, then it can be
deba@162
   433
  /// selected for reading by giving an optional name parameter to the
deba@189
   434
  /// \c nodes(), \c arcs() or \c attributes() functions.
alpar@156
   435
  ///
alpar@156
   436
  /// The \c useNodes() and \c useArcs() functions are used to tell the reader
alpar@156
   437
  /// that the nodes or arcs should not be constructed (added to the
alpar@156
   438
  /// graph) during the reading, but instead the label map of the items
alpar@156
   439
  /// are given as a parameter of these functions. An
kpeter@192
   440
  /// application of these functions is multipass reading, which is
kpeter@192
   441
  /// important if two \c \@arcs sections must be read from the
kpeter@192
   442
  /// file. In this case the first phase would read the node set and one
alpar@156
   443
  /// of the arc sets, while the second phase would read the second arc
alpar@156
   444
  /// set into an \e ArcSet class (\c SmartArcSet or \c ListArcSet).
alpar@156
   445
  /// The previously read label node map should be passed to the \c
alpar@156
   446
  /// useNodes() functions. Another application of multipass reading when
kpeter@192
   447
  /// paths are given as a node map or an arc map. It is impossible to read this in
alpar@156
   448
  /// a single pass, because the arcs are not constructed when the node
alpar@156
   449
  /// maps are read.
deba@127
   450
  template <typename _Digraph>
deba@127
   451
  class DigraphReader {
deba@127
   452
  public:
deba@127
   453
deba@127
   454
    typedef _Digraph Digraph;
deba@148
   455
    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
deba@127
   456
    
deba@127
   457
  private:
deba@127
   458
deba@127
   459
deba@127
   460
    std::istream* _is;
deba@127
   461
    bool local_is;
deba@127
   462
deba@127
   463
    Digraph& _digraph;
deba@127
   464
deba@127
   465
    std::string _nodes_caption;
deba@127
   466
    std::string _arcs_caption;
deba@127
   467
    std::string _attributes_caption;
deba@127
   468
deba@127
   469
    typedef std::map<std::string, Node> NodeIndex;
deba@127
   470
    NodeIndex _node_index;
deba@127
   471
    typedef std::map<std::string, Arc> ArcIndex;
deba@127
   472
    ArcIndex _arc_index;
deba@127
   473
    
deba@127
   474
    typedef std::vector<std::pair<std::string, 
deba@127
   475
      _reader_bits::MapStorageBase<Node>*> > NodeMaps;    
deba@127
   476
    NodeMaps _node_maps; 
deba@127
   477
deba@127
   478
    typedef std::vector<std::pair<std::string,
deba@127
   479
      _reader_bits::MapStorageBase<Arc>*> >ArcMaps;
deba@127
   480
    ArcMaps _arc_maps;
deba@127
   481
deba@127
   482
    typedef std::multimap<std::string, _reader_bits::ValueStorageBase*> 
deba@127
   483
      Attributes;
deba@127
   484
    Attributes _attributes;
deba@127
   485
deba@127
   486
    bool _use_nodes;
deba@127
   487
    bool _use_arcs;
deba@127
   488
deba@188
   489
    bool _skip_nodes;
deba@188
   490
    bool _skip_arcs;
deba@188
   491
deba@127
   492
    int line_num;
deba@127
   493
    std::istringstream line;
deba@127
   494
deba@127
   495
  public:
deba@127
   496
alpar@156
   497
    /// \brief Constructor
alpar@156
   498
    ///
alpar@156
   499
    /// Construct a directed graph reader, which reads from the given
alpar@156
   500
    /// input stream.
deba@127
   501
    DigraphReader(std::istream& is, Digraph& digraph) 
deba@127
   502
      : _is(&is), local_is(false), _digraph(digraph),
deba@188
   503
	_use_nodes(false), _use_arcs(false),
deba@188
   504
	_skip_nodes(false), _skip_arcs(false) {}
deba@127
   505
alpar@156
   506
    /// \brief Constructor
alpar@156
   507
    ///
alpar@156
   508
    /// Construct a directed graph reader, which reads from the given
alpar@156
   509
    /// file.
deba@127
   510
    DigraphReader(const std::string& fn, Digraph& digraph) 
deba@127
   511
      : _is(new std::ifstream(fn.c_str())), local_is(true), _digraph(digraph),
deba@188
   512
    	_use_nodes(false), _use_arcs(false),
deba@188
   513
	_skip_nodes(false), _skip_arcs(false) {}
alpar@156
   514
    
alpar@156
   515
    /// \brief Constructor
alpar@156
   516
    ///
alpar@156
   517
    /// Construct a directed graph reader, which reads from the given
alpar@156
   518
    /// file.
deba@127
   519
    DigraphReader(const char* fn, Digraph& digraph) 
deba@127
   520
      : _is(new std::ifstream(fn)), local_is(true), _digraph(digraph),
deba@188
   521
    	_use_nodes(false), _use_arcs(false),
deba@188
   522
	_skip_nodes(false), _skip_arcs(false) {}
deba@127
   523
alpar@156
   524
    /// \brief Destructor
deba@127
   525
    ~DigraphReader() {
deba@127
   526
      for (typename NodeMaps::iterator it = _node_maps.begin(); 
deba@127
   527
	   it != _node_maps.end(); ++it) {
deba@127
   528
	delete it->second;
deba@127
   529
      }
deba@127
   530
deba@127
   531
      for (typename ArcMaps::iterator it = _arc_maps.begin(); 
deba@127
   532
	   it != _arc_maps.end(); ++it) {
deba@127
   533
	delete it->second;
deba@127
   534
      }
deba@127
   535
deba@127
   536
      for (typename Attributes::iterator it = _attributes.begin(); 
deba@127
   537
	   it != _attributes.end(); ++it) {
deba@127
   538
	delete it->second;
deba@127
   539
      }
deba@127
   540
deba@127
   541
      if (local_is) {
deba@127
   542
	delete _is;
deba@127
   543
      }
deba@127
   544
deba@127
   545
    }
deba@127
   546
deba@127
   547
  private:
deba@190
   548
deba@190
   549
    friend DigraphReader<Digraph> digraphReader<>(std::istream& is, 
deba@190
   550
						  Digraph& digraph);    
deba@190
   551
    friend DigraphReader<Digraph> digraphReader<>(const std::string& fn, 
deba@190
   552
						  Digraph& digraph);   
deba@190
   553
    friend DigraphReader<Digraph> digraphReader<>(const char *fn, 
deba@190
   554
						  Digraph& digraph);    
deba@190
   555
deba@190
   556
    DigraphReader(DigraphReader& other) 
deba@190
   557
      : _is(other._is), local_is(other.local_is), _digraph(other._digraph),
deba@190
   558
	_use_nodes(other._use_nodes), _use_arcs(other._use_arcs),
deba@190
   559
	_skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
deba@190
   560
deba@190
   561
      other._is = 0;
deba@190
   562
      other.local_is = false;
deba@190
   563
      
deba@190
   564
      _node_index.swap(other._node_index);
deba@190
   565
      _arc_index.swap(other._arc_index);
deba@190
   566
deba@190
   567
      _node_maps.swap(other._node_maps);
deba@190
   568
      _arc_maps.swap(other._arc_maps);
deba@190
   569
      _attributes.swap(other._attributes);
deba@190
   570
deba@190
   571
      _nodes_caption = other._nodes_caption;
deba@190
   572
      _arcs_caption = other._arcs_caption;
deba@190
   573
      _attributes_caption = other._attributes_caption;
deba@190
   574
deba@190
   575
    }
deba@190
   576
deba@127
   577
    DigraphReader& operator=(const DigraphReader&);
deba@127
   578
deba@127
   579
  public:
deba@127
   580
alpar@156
   581
    /// \name Reading rules
alpar@156
   582
    /// @{
alpar@156
   583
    
alpar@156
   584
    /// \brief Node map reading rule
alpar@156
   585
    ///
alpar@156
   586
    /// Add a node map reading rule to the reader.
deba@127
   587
    template <typename Map>
deba@127
   588
    DigraphReader& nodeMap(const std::string& caption, Map& map) {
deba@127
   589
      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
deba@127
   590
      _reader_bits::MapStorageBase<Node>* storage = 
deba@127
   591
	new _reader_bits::MapStorage<Node, Map>(map);
deba@127
   592
      _node_maps.push_back(std::make_pair(caption, storage));
deba@127
   593
      return *this;
deba@127
   594
    }
deba@127
   595
alpar@156
   596
    /// \brief Node map reading rule
alpar@156
   597
    ///
alpar@156
   598
    /// Add a node map reading rule with specialized converter to the
alpar@156
   599
    /// reader.
deba@127
   600
    template <typename Map, typename Converter>
deba@127
   601
    DigraphReader& nodeMap(const std::string& caption, Map& map, 
deba@127
   602
			   const Converter& converter = Converter()) {
deba@127
   603
      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
deba@127
   604
      _reader_bits::MapStorageBase<Node>* storage = 
deba@127
   605
	new _reader_bits::MapStorage<Node, Map, Converter>(map, converter);
deba@127
   606
      _node_maps.push_back(std::make_pair(caption, storage));
deba@127
   607
      return *this;
deba@127
   608
    }
deba@127
   609
alpar@156
   610
    /// \brief Arc map reading rule
alpar@156
   611
    ///
alpar@156
   612
    /// Add an arc map reading rule to the reader.
deba@127
   613
    template <typename Map>
deba@127
   614
    DigraphReader& arcMap(const std::string& caption, Map& map) {
deba@127
   615
      checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
deba@127
   616
      _reader_bits::MapStorageBase<Arc>* storage = 
deba@127
   617
	new _reader_bits::MapStorage<Arc, Map>(map);
deba@127
   618
      _arc_maps.push_back(std::make_pair(caption, storage));
deba@127
   619
      return *this;
deba@127
   620
    }
deba@127
   621
alpar@156
   622
    /// \brief Arc map reading rule
alpar@156
   623
    ///
alpar@156
   624
    /// Add an arc map reading rule with specialized converter to the
alpar@156
   625
    /// reader.
deba@127
   626
    template <typename Map, typename Converter>
deba@127
   627
    DigraphReader& arcMap(const std::string& caption, Map& map, 
deba@127
   628
			  const Converter& converter = Converter()) {
deba@127
   629
      checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
deba@127
   630
      _reader_bits::MapStorageBase<Arc>* storage = 
deba@127
   631
	new _reader_bits::MapStorage<Arc, Map, Converter>(map, converter);
deba@127
   632
      _arc_maps.push_back(std::make_pair(caption, storage));
deba@127
   633
      return *this;
deba@127
   634
    }
deba@127
   635
alpar@156
   636
    /// \brief Attribute reading rule
alpar@156
   637
    ///
alpar@156
   638
    /// Add an attribute reading rule to the reader.
deba@127
   639
    template <typename Value>
deba@127
   640
    DigraphReader& attribute(const std::string& caption, Value& value) {
deba@127
   641
      _reader_bits::ValueStorageBase* storage = 
deba@127
   642
	new _reader_bits::ValueStorage<Value>(value);
deba@127
   643
      _attributes.insert(std::make_pair(caption, storage));
deba@127
   644
      return *this;
deba@127
   645
    }
deba@127
   646
alpar@156
   647
    /// \brief Attribute reading rule
alpar@156
   648
    ///
alpar@156
   649
    /// Add an attribute reading rule with specialized converter to the
alpar@156
   650
    /// reader.
deba@127
   651
    template <typename Value, typename Converter>
deba@127
   652
    DigraphReader& attribute(const std::string& caption, Value& value, 
deba@127
   653
			     const Converter& converter = Converter()) {
deba@127
   654
      _reader_bits::ValueStorageBase* storage = 
deba@127
   655
	new _reader_bits::ValueStorage<Value, Converter>(value, converter);
deba@127
   656
      _attributes.insert(std::make_pair(caption, storage));
deba@127
   657
      return *this;
deba@127
   658
    }
deba@127
   659
alpar@156
   660
    /// \brief Node reading rule
alpar@156
   661
    ///
alpar@156
   662
    /// Add a node reading rule to reader.
deba@127
   663
    DigraphReader& node(const std::string& caption, Node& node) {
deba@127
   664
      typedef _reader_bits::MapLookUpConverter<Node> Converter;
deba@127
   665
      Converter converter(_node_index);
deba@127
   666
      _reader_bits::ValueStorageBase* storage = 
deba@127
   667
	new _reader_bits::ValueStorage<Node, Converter>(node, converter);
deba@127
   668
      _attributes.insert(std::make_pair(caption, storage));
deba@127
   669
      return *this;
deba@127
   670
    }
deba@127
   671
alpar@156
   672
    /// \brief Arc reading rule
alpar@156
   673
    ///
alpar@156
   674
    /// Add an arc reading rule to reader.
deba@127
   675
    DigraphReader& arc(const std::string& caption, Arc& arc) {
deba@127
   676
      typedef _reader_bits::MapLookUpConverter<Arc> Converter;
deba@127
   677
      Converter converter(_arc_index);
deba@127
   678
      _reader_bits::ValueStorageBase* storage = 
deba@127
   679
	new _reader_bits::ValueStorage<Arc, Converter>(arc, converter);
deba@127
   680
      _attributes.insert(std::make_pair(caption, storage));
deba@127
   681
      return *this;
deba@127
   682
    }
deba@127
   683
alpar@156
   684
    /// @}
alpar@156
   685
alpar@156
   686
    /// \name Select section by name
alpar@156
   687
    /// @{
alpar@156
   688
alpar@156
   689
    /// \brief Set \c \@nodes section to be read
alpar@156
   690
    ///
alpar@156
   691
    /// Set \c \@nodes section to be read
deba@127
   692
    DigraphReader& nodes(const std::string& caption) {
deba@127
   693
      _nodes_caption = caption;
deba@127
   694
      return *this;
deba@127
   695
    }
deba@127
   696
alpar@156
   697
    /// \brief Set \c \@arcs section to be read
alpar@156
   698
    ///
alpar@156
   699
    /// Set \c \@arcs section to be read
deba@127
   700
    DigraphReader& arcs(const std::string& caption) {
deba@127
   701
      _arcs_caption = caption;
deba@127
   702
      return *this;
deba@127
   703
    }
deba@127
   704
alpar@156
   705
    /// \brief Set \c \@attributes section to be read
alpar@156
   706
    ///
alpar@156
   707
    /// Set \c \@attributes section to be read
deba@127
   708
    DigraphReader& attributes(const std::string& caption) {
deba@127
   709
      _attributes_caption = caption;
deba@127
   710
      return *this;
deba@127
   711
    }
deba@127
   712
alpar@156
   713
    /// @}
alpar@156
   714
alpar@156
   715
    /// \name Using previously constructed node or arc set
alpar@156
   716
    /// @{
alpar@156
   717
alpar@156
   718
    /// \brief Use previously constructed node set
alpar@156
   719
    ///
alpar@156
   720
    /// Use previously constructed node set, and specify the node
alpar@156
   721
    /// label map.
deba@127
   722
    template <typename Map>
deba@127
   723
    DigraphReader& useNodes(const Map& map) {
deba@127
   724
      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
deba@127
   725
      LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member"); 
deba@127
   726
      _use_nodes = true;
deba@127
   727
      _writer_bits::DefaultConverter<typename Map::Value> converter;
deba@127
   728
      for (NodeIt n(_digraph); n != INVALID; ++n) {
deba@127
   729
	_node_index.insert(std::make_pair(converter(map[n]), n));
deba@127
   730
      }
deba@127
   731
      return *this;
deba@127
   732
    }
deba@127
   733
alpar@156
   734
    /// \brief Use previously constructed node set
alpar@156
   735
    ///
alpar@156
   736
    /// Use previously constructed node set, and specify the node
alpar@156
   737
    /// label map and a functor which converts the label map values to
kpeter@192
   738
    /// \c std::string.
deba@127
   739
    template <typename Map, typename Converter>
deba@127
   740
    DigraphReader& useNodes(const Map& map, 
deba@127
   741
			    const Converter& converter = Converter()) {
deba@127
   742
      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
deba@127
   743
      LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member"); 
deba@127
   744
      _use_nodes = true;
deba@127
   745
      for (NodeIt n(_digraph); n != INVALID; ++n) {
deba@127
   746
	_node_index.insert(std::make_pair(converter(map[n]), n));
deba@127
   747
      }
deba@127
   748
      return *this;
deba@127
   749
    }
deba@127
   750
alpar@156
   751
    /// \brief Use previously constructed arc set
alpar@156
   752
    ///
alpar@156
   753
    /// Use previously constructed arc set, and specify the arc
alpar@156
   754
    /// label map.
deba@127
   755
    template <typename Map>
deba@127
   756
    DigraphReader& useArcs(const Map& map) {
deba@127
   757
      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
deba@127
   758
      LEMON_ASSERT(!_use_arcs, "Multiple usage of useArcs() member");
deba@127
   759
      _use_arcs = true;
deba@127
   760
      _writer_bits::DefaultConverter<typename Map::Value> converter;
deba@127
   761
      for (ArcIt a(_digraph); a != INVALID; ++a) {
deba@127
   762
	_arc_index.insert(std::make_pair(converter(map[a]), a));
deba@127
   763
      }
deba@127
   764
      return *this;
deba@127
   765
    }
deba@127
   766
alpar@156
   767
    /// \brief Use previously constructed arc set
alpar@156
   768
    ///
alpar@156
   769
    /// Use previously constructed arc set, and specify the arc
alpar@156
   770
    /// label map and a functor which converts the label map values to
kpeter@192
   771
    /// \c std::string.
deba@127
   772
    template <typename Map, typename Converter>
deba@127
   773
    DigraphReader& useArcs(const Map& map, 
deba@188
   774
			   const Converter& converter = Converter()) {
deba@127
   775
      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
deba@127
   776
      LEMON_ASSERT(!_use_arcs, "Multiple usage of useArcs() member"); 
deba@127
   777
      _use_arcs = true;
deba@127
   778
      for (ArcIt a(_digraph); a != INVALID; ++a) {
deba@127
   779
	_arc_index.insert(std::make_pair(converter(map[a]), a));
deba@127
   780
      }
deba@127
   781
      return *this;
deba@127
   782
    }
deba@127
   783
deba@188
   784
    /// \brief Skips the reading of node section
deba@188
   785
    ///
deba@188
   786
    /// Omit the reading of the node section. This implies that each node
kpeter@192
   787
    /// map reading rule will be abandoned, and the nodes of the graph
deba@188
   788
    /// will not be constructed, which usually cause that the arc set
kpeter@192
   789
    /// could not be read due to lack of node name resolving.
kpeter@192
   790
    /// Therefore \c skipArcs() function should also be used, or
kpeter@192
   791
    /// \c useNodes() should be used to specify the label of the nodes.
deba@188
   792
    DigraphReader& skipNodes() {
deba@188
   793
      LEMON_ASSERT(!_skip_nodes, "Skip nodes already set"); 
deba@188
   794
      _skip_nodes = true;
deba@188
   795
      return *this;
deba@188
   796
    }
deba@188
   797
deba@188
   798
    /// \brief Skips the reading of arc section
deba@188
   799
    ///
deba@188
   800
    /// Omit the reading of the arc section. This implies that each arc
kpeter@192
   801
    /// map reading rule will be abandoned, and the arcs of the graph
deba@188
   802
    /// will not be constructed.
deba@188
   803
    DigraphReader& skipArcs() {
deba@188
   804
      LEMON_ASSERT(!_skip_arcs, "Skip arcs already set"); 
deba@188
   805
      _skip_arcs = true;
deba@188
   806
      return *this;
deba@188
   807
    }
deba@188
   808
alpar@156
   809
    /// @}
alpar@156
   810
deba@127
   811
  private:
deba@127
   812
deba@127
   813
    bool readLine() {
deba@127
   814
      std::string str;
deba@127
   815
      while(++line_num, std::getline(*_is, str)) {
deba@127
   816
	line.clear(); line.str(str);
deba@127
   817
	char c;
deba@127
   818
	if (line >> std::ws >> c && c != '#') {
deba@127
   819
	  line.putback(c);
deba@127
   820
	  return true;
deba@127
   821
	}
deba@127
   822
      }
deba@127
   823
      return false;
deba@127
   824
    }
deba@127
   825
deba@127
   826
    bool readSuccess() {
deba@127
   827
      return static_cast<bool>(*_is);
deba@127
   828
    }
deba@127
   829
    
deba@127
   830
    void skipSection() {
deba@127
   831
      char c;
deba@127
   832
      while (readSuccess() && line >> c && c != '@') {
deba@127
   833
	readLine();
deba@127
   834
      }
deba@127
   835
      line.putback(c);
deba@127
   836
    }
deba@127
   837
deba@127
   838
    void readNodes() {
deba@127
   839
deba@127
   840
      std::vector<int> map_index(_node_maps.size());
deba@127
   841
      int map_num, label_index;
deba@127
   842
deba@186
   843
      char c;
deba@186
   844
      if (!readLine() || !(line >> c) || c == '@') {
deba@186
   845
	if (readSuccess() && line) line.putback(c);
deba@186
   846
	if (!_node_maps.empty()) 
deba@186
   847
	  throw DataFormatError("Cannot find map names");
deba@186
   848
	return;
deba@186
   849
      }
deba@186
   850
      line.putback(c);
deba@186
   851
deba@127
   852
      {
deba@127
   853
	std::map<std::string, int> maps;
deba@127
   854
	
deba@127
   855
	std::string map;
deba@127
   856
	int index = 0;
alpar@156
   857
	while (_reader_bits::readToken(line, map)) {
deba@127
   858
	  if (maps.find(map) != maps.end()) {
deba@127
   859
	    std::ostringstream msg;
deba@127
   860
	    msg << "Multiple occurence of node map: " << map;
deba@127
   861
	    throw DataFormatError(msg.str().c_str());
deba@127
   862
	  }
deba@127
   863
	  maps.insert(std::make_pair(map, index));
deba@127
   864
	  ++index;
deba@127
   865
	}
deba@127
   866
	
deba@127
   867
	for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {
deba@127
   868
	  std::map<std::string, int>::iterator jt = 
deba@127
   869
	    maps.find(_node_maps[i].first);
deba@127
   870
	  if (jt == maps.end()) {
deba@127
   871
	    std::ostringstream msg;
deba@127
   872
	    msg << "Map not found in file: " << _node_maps[i].first;
deba@127
   873
	    throw DataFormatError(msg.str().c_str());
deba@127
   874
	  }
deba@127
   875
	  map_index[i] = jt->second;
deba@127
   876
	}
deba@127
   877
deba@127
   878
	{
deba@127
   879
	  std::map<std::string, int>::iterator jt = maps.find("label");
deba@186
   880
	  if (jt != maps.end()) {
deba@186
   881
	    label_index = jt->second;
deba@186
   882
	  } else {
deba@186
   883
	    label_index = -1;
deba@186
   884
	  }
deba@127
   885
	}
deba@127
   886
	map_num = maps.size();
deba@127
   887
      }
deba@127
   888
deba@127
   889
      while (readLine() && line >> c && c != '@') {
deba@127
   890
	line.putback(c);
deba@127
   891
deba@127
   892
	std::vector<std::string> tokens(map_num);
deba@127
   893
	for (int i = 0; i < map_num; ++i) {
deba@127
   894
	  if (!_reader_bits::readToken(line, tokens[i])) {
deba@127
   895
	    std::ostringstream msg;
deba@127
   896
	    msg << "Column not found (" << i + 1 << ")";
deba@127
   897
	    throw DataFormatError(msg.str().c_str());
deba@127
   898
	  }
deba@127
   899
	}
deba@127
   900
	if (line >> std::ws >> c)
deba@127
   901
	  throw DataFormatError("Extra character on the end of line");
deba@127
   902
	
deba@127
   903
	Node n;
deba@127
   904
	if (!_use_nodes) {
deba@127
   905
	  n = _digraph.addNode();
deba@186
   906
	  if (label_index != -1)
deba@186
   907
	    _node_index.insert(std::make_pair(tokens[label_index], n));
deba@127
   908
	} else {
deba@186
   909
	  if (label_index == -1) 
deba@186
   910
	    throw DataFormatError("Label map not found in file");
deba@127
   911
	  typename std::map<std::string, Node>::iterator it =
deba@127
   912
	    _node_index.find(tokens[label_index]);
deba@127
   913
	  if (it == _node_index.end()) {
deba@127
   914
	    std::ostringstream msg;
deba@127
   915
	    msg << "Node with label not found: " << tokens[label_index];
deba@127
   916
	    throw DataFormatError(msg.str().c_str());	    
deba@127
   917
	  }
deba@127
   918
	  n = it->second;
deba@127
   919
	}
deba@127
   920
deba@127
   921
	for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {
deba@127
   922
	  _node_maps[i].second->set(n, tokens[map_index[i]]);
deba@127
   923
	}
deba@127
   924
deba@127
   925
      }
deba@127
   926
      if (readSuccess()) {
deba@127
   927
	line.putback(c);
deba@127
   928
      }
deba@127
   929
    }
deba@127
   930
deba@127
   931
    void readArcs() {
deba@127
   932
deba@127
   933
      std::vector<int> map_index(_arc_maps.size());
deba@127
   934
      int map_num, label_index;
deba@127
   935
deba@186
   936
      char c;
deba@186
   937
      if (!readLine() || !(line >> c) || c == '@') {
deba@186
   938
	if (readSuccess() && line) line.putback(c);
deba@186
   939
	if (!_arc_maps.empty()) 
deba@186
   940
	  throw DataFormatError("Cannot find map names");
deba@186
   941
	return;
deba@186
   942
      }
deba@186
   943
      line.putback(c);
deba@127
   944
      
deba@127
   945
      {
deba@127
   946
	std::map<std::string, int> maps;
deba@127
   947
	
deba@127
   948
	std::string map;
deba@127
   949
	int index = 0;
alpar@156
   950
	while (_reader_bits::readToken(line, map)) {
deba@127
   951
	  if (maps.find(map) != maps.end()) {
deba@127
   952
	    std::ostringstream msg;
deba@127
   953
	    msg << "Multiple occurence of arc map: " << map;
deba@127
   954
	    throw DataFormatError(msg.str().c_str());
deba@127
   955
	  }
deba@127
   956
	  maps.insert(std::make_pair(map, index));
deba@127
   957
	  ++index;
deba@127
   958
	}
deba@127
   959
	
deba@127
   960
	for (int i = 0; i < static_cast<int>(_arc_maps.size()); ++i) {
deba@127
   961
	  std::map<std::string, int>::iterator jt = 
deba@127
   962
	    maps.find(_arc_maps[i].first);
deba@127
   963
	  if (jt == maps.end()) {
deba@127
   964
	    std::ostringstream msg;
deba@127
   965
	    msg << "Map not found in file: " << _arc_maps[i].first;
deba@127
   966
	    throw DataFormatError(msg.str().c_str());
deba@127
   967
	  }
deba@127
   968
	  map_index[i] = jt->second;
deba@127
   969
	}
deba@127
   970
deba@127
   971
	{
deba@127
   972
	  std::map<std::string, int>::iterator jt = maps.find("label");
deba@186
   973
	  if (jt != maps.end()) {
deba@186
   974
	    label_index = jt->second;
deba@186
   975
	  } else {
deba@186
   976
	    label_index = -1;
deba@186
   977
	  }
deba@127
   978
	}
deba@127
   979
	map_num = maps.size();
deba@127
   980
      }
deba@127
   981
deba@127
   982
      while (readLine() && line >> c && c != '@') {
deba@127
   983
	line.putback(c);
deba@127
   984
deba@127
   985
	std::string source_token;
deba@127
   986
	std::string target_token;
deba@127
   987
deba@127
   988
	if (!_reader_bits::readToken(line, source_token))
deba@127
   989
	  throw DataFormatError("Source not found");
deba@127
   990
deba@127
   991
	if (!_reader_bits::readToken(line, target_token))
deba@186
   992
	  throw DataFormatError("Target not found");
deba@127
   993
	
deba@127
   994
	std::vector<std::string> tokens(map_num);
deba@127
   995
	for (int i = 0; i < map_num; ++i) {
deba@127
   996
	  if (!_reader_bits::readToken(line, tokens[i])) {
deba@127
   997
	    std::ostringstream msg;
deba@127
   998
	    msg << "Column not found (" << i + 1 << ")";
deba@127
   999
	    throw DataFormatError(msg.str().c_str());
deba@127
  1000
	  }
deba@127
  1001
	}
deba@127
  1002
	if (line >> std::ws >> c)
deba@127
  1003
	  throw DataFormatError("Extra character on the end of line");
deba@127
  1004
	
deba@127
  1005
	Arc a;
deba@127
  1006
	if (!_use_arcs) {
deba@127
  1007
deba@127
  1008
          typename NodeIndex::iterator it;
deba@127
  1009
 
deba@127
  1010
          it = _node_index.find(source_token);
deba@127
  1011
          if (it == _node_index.end()) {
deba@127
  1012
            std::ostringstream msg;
deba@127
  1013
            msg << "Item not found: " << source_token;
deba@127
  1014
            throw DataFormatError(msg.str().c_str());
deba@127
  1015
          }
deba@127
  1016
          Node source = it->second;
deba@127
  1017
deba@127
  1018
          it = _node_index.find(target_token);
deba@127
  1019
          if (it == _node_index.end()) {       
deba@127
  1020
            std::ostringstream msg;            
deba@127
  1021
            msg << "Item not found: " << target_token;
deba@127
  1022
            throw DataFormatError(msg.str().c_str());
deba@127
  1023
          }                                          
deba@127
  1024
          Node target = it->second;                            
deba@127
  1025
deba@127
  1026
	  a = _digraph.addArc(source, target);
deba@186
  1027
	  if (label_index != -1) 
deba@186
  1028
	    _arc_index.insert(std::make_pair(tokens[label_index], a));
deba@127
  1029
	} else {
deba@186
  1030
	  if (label_index == -1) 
deba@186
  1031
	    throw DataFormatError("Label map not found in file");
deba@127
  1032
	  typename std::map<std::string, Arc>::iterator it =
deba@127
  1033
	    _arc_index.find(tokens[label_index]);
deba@127
  1034
	  if (it == _arc_index.end()) {
deba@127
  1035
	    std::ostringstream msg;
deba@127
  1036
	    msg << "Arc with label not found: " << tokens[label_index];
deba@127
  1037
	    throw DataFormatError(msg.str().c_str());	    
deba@127
  1038
	  }
deba@127
  1039
	  a = it->second;
deba@127
  1040
	}
deba@127
  1041
deba@127
  1042
	for (int i = 0; i < static_cast<int>(_arc_maps.size()); ++i) {
deba@127
  1043
	  _arc_maps[i].second->set(a, tokens[map_index[i]]);
deba@127
  1044
	}
deba@127
  1045
deba@127
  1046
      }
deba@127
  1047
      if (readSuccess()) {
deba@127
  1048
	line.putback(c);
deba@127
  1049
      }
deba@127
  1050
    }
deba@127
  1051
deba@127
  1052
    void readAttributes() {
deba@127
  1053
deba@127
  1054
      std::set<std::string> read_attr;
deba@127
  1055
deba@127
  1056
      char c;
deba@127
  1057
      while (readLine() && line >> c && c != '@') {
deba@127
  1058
	line.putback(c);
deba@127
  1059
	
deba@127
  1060
	std::string attr, token;
alpar@156
  1061
	if (!_reader_bits::readToken(line, attr))
deba@127
  1062
	  throw DataFormatError("Attribute name not found");
deba@127
  1063
	if (!_reader_bits::readToken(line, token))
deba@127
  1064
	  throw DataFormatError("Attribute value not found");
deba@127
  1065
	if (line >> c)
deba@127
  1066
	  throw DataFormatError("Extra character on the end of line");	  
deba@127
  1067
deba@127
  1068
	{
deba@127
  1069
	  std::set<std::string>::iterator it = read_attr.find(attr);
deba@127
  1070
	  if (it != read_attr.end()) {
deba@127
  1071
	    std::ostringstream msg;
deba@127
  1072
	    msg << "Multiple occurence of attribute " << attr;
deba@127
  1073
	    throw DataFormatError(msg.str().c_str());
deba@127
  1074
	  }
deba@127
  1075
	  read_attr.insert(attr);
deba@127
  1076
	}
deba@127
  1077
	
deba@127
  1078
	{
deba@127
  1079
	  typename Attributes::iterator it = _attributes.lower_bound(attr);
deba@127
  1080
	  while (it != _attributes.end() && it->first == attr) {
deba@127
  1081
	    it->second->set(token);
deba@127
  1082
	    ++it;
deba@127
  1083
	  }
deba@127
  1084
	}
deba@127
  1085
deba@127
  1086
      }
deba@127
  1087
      if (readSuccess()) {
deba@127
  1088
	line.putback(c);
deba@127
  1089
      }
deba@127
  1090
      for (typename Attributes::iterator it = _attributes.begin();
deba@127
  1091
	   it != _attributes.end(); ++it) {
deba@127
  1092
	if (read_attr.find(it->first) == read_attr.end()) {
deba@127
  1093
	  std::ostringstream msg;
deba@127
  1094
	  msg << "Attribute not found in file: " << it->first;
deba@127
  1095
	  throw DataFormatError(msg.str().c_str());
deba@127
  1096
	}	
deba@127
  1097
      }
deba@127
  1098
    }
deba@127
  1099
deba@127
  1100
  public:
alpar@156
  1101
alpar@156
  1102
    /// \name Execution of the reader    
alpar@156
  1103
    /// @{
alpar@156
  1104
alpar@156
  1105
    /// \brief Start the batch processing
alpar@156
  1106
    ///
alpar@156
  1107
    /// This function starts the batch processing
deba@127
  1108
    void run() {
deba@127
  1109
      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");
deba@163
  1110
      if (!*_is) {
deba@163
  1111
	throw DataFormatError("Cannot find file");
deba@163
  1112
      }
deba@127
  1113
      
deba@188
  1114
      bool nodes_done = _skip_nodes;
deba@188
  1115
      bool arcs_done = _skip_arcs;
deba@127
  1116
      bool attributes_done = false;
deba@127
  1117
deba@127
  1118
      line_num = 0;      
deba@127
  1119
      readLine();
deba@172
  1120
      skipSection();
deba@127
  1121
deba@127
  1122
      while (readSuccess()) {
deba@127
  1123
	try {
deba@127
  1124
	  char c;
deba@127
  1125
	  std::string section, caption;
deba@127
  1126
	  line >> c;
alpar@156
  1127
	  _reader_bits::readToken(line, section);
alpar@156
  1128
	  _reader_bits::readToken(line, caption);
deba@127
  1129
deba@127
  1130
	  if (line >> c) 
deba@127
  1131
	    throw DataFormatError("Extra character on the end of line");
deba@127
  1132
deba@127
  1133
	  if (section == "nodes" && !nodes_done) {
deba@127
  1134
	    if (_nodes_caption.empty() || _nodes_caption == caption) {
deba@127
  1135
	      readNodes();
deba@127
  1136
	      nodes_done = true;
deba@127
  1137
	    }
deba@127
  1138
	  } else if ((section == "arcs" || section == "edges") && 
deba@127
  1139
		     !arcs_done) {
deba@127
  1140
	    if (_arcs_caption.empty() || _arcs_caption == caption) {
deba@127
  1141
	      readArcs();
deba@127
  1142
	      arcs_done = true;
deba@127
  1143
	    }
deba@127
  1144
	  } else if (section == "attributes" && !attributes_done) {
deba@127
  1145
	    if (_attributes_caption.empty() || _attributes_caption == caption) {
deba@127
  1146
	      readAttributes();
deba@127
  1147
	      attributes_done = true;
deba@127
  1148
	    }
deba@127
  1149
	  } else {
deba@172
  1150
	    readLine();
deba@172
  1151
	    skipSection();
deba@127
  1152
	  }
deba@127
  1153
	} catch (DataFormatError& error) {
deba@127
  1154
	  error.line(line_num);
deba@127
  1155
	  throw;
deba@127
  1156
	}	
deba@127
  1157
      }
deba@127
  1158
deba@127
  1159
      if (!nodes_done) {
deba@127
  1160
	throw DataFormatError("Section @nodes not found");
deba@127
  1161
      }
deba@127
  1162
deba@127
  1163
      if (!arcs_done) {
deba@127
  1164
	throw DataFormatError("Section @arcs not found");
deba@127
  1165
      }
deba@127
  1166
deba@127
  1167
      if (!attributes_done && !_attributes.empty()) {
deba@127
  1168
	throw DataFormatError("Section @attributes not found");
deba@127
  1169
      }
deba@127
  1170
deba@127
  1171
    }
alpar@156
  1172
alpar@156
  1173
    /// @}
deba@127
  1174
    
deba@127
  1175
  };
deba@127
  1176
kpeter@192
  1177
  /// \brief Return a \ref DigraphReader class
kpeter@192
  1178
  /// 
kpeter@192
  1179
  /// This function just returns a \ref DigraphReader class.
alpar@156
  1180
  /// \relates DigraphReader
deba@127
  1181
  template <typename Digraph>
deba@127
  1182
  DigraphReader<Digraph> digraphReader(std::istream& is, Digraph& digraph) {
deba@163
  1183
    DigraphReader<Digraph> tmp(is, digraph);
deba@163
  1184
    return tmp;
deba@127
  1185
  }
deba@127
  1186
kpeter@192
  1187
  /// \brief Return a \ref DigraphReader class
kpeter@192
  1188
  /// 
kpeter@192
  1189
  /// This function just returns a \ref DigraphReader class.
alpar@156
  1190
  /// \relates DigraphReader
deba@127
  1191
  template <typename Digraph>
deba@127
  1192
  DigraphReader<Digraph> digraphReader(const std::string& fn, 
deba@127
  1193
				       Digraph& digraph) {
deba@163
  1194
    DigraphReader<Digraph> tmp(fn, digraph);
deba@163
  1195
    return tmp;
deba@127
  1196
  }
deba@127
  1197
kpeter@192
  1198
  /// \brief Return a \ref DigraphReader class
kpeter@192
  1199
  /// 
kpeter@192
  1200
  /// This function just returns a \ref DigraphReader class.
alpar@156
  1201
  /// \relates DigraphReader
deba@127
  1202
  template <typename Digraph>
deba@127
  1203
  DigraphReader<Digraph> digraphReader(const char* fn, Digraph& digraph) {
deba@163
  1204
    DigraphReader<Digraph> tmp(fn, digraph);
deba@163
  1205
    return tmp;
deba@127
  1206
  }
deba@165
  1207
deba@190
  1208
  template <typename Graph>
deba@190
  1209
  class GraphReader;
deba@190
  1210
deba@190
  1211
  template <typename Graph>
deba@190
  1212
  GraphReader<Graph> graphReader(std::istream& is, Graph& graph);    
deba@190
  1213
deba@190
  1214
  template <typename Graph>
deba@190
  1215
  GraphReader<Graph> graphReader(const std::string& fn, Graph& graph);   
deba@190
  1216
deba@190
  1217
  template <typename Graph>
deba@190
  1218
  GraphReader<Graph> graphReader(const char *fn, Graph& graph);    
deba@190
  1219
deba@165
  1220
  /// \ingroup lemon_io
deba@165
  1221
  ///  
kpeter@192
  1222
  /// \brief \ref lgf-format "LGF" reader for undirected graphs
deba@165
  1223
  ///
deba@165
  1224
  /// This utility reads an \ref lgf-format "LGF" file.
kpeter@192
  1225
  ///
kpeter@192
  1226
  /// It can be used almost the same way as \c DigraphReader.
kpeter@192
  1227
  /// The only difference is that this class can handle edges and
kpeter@192
  1228
  /// edge maps as well as arcs and arc maps.
deba@165
  1229
  template <typename _Graph>
deba@165
  1230
  class GraphReader {
deba@165
  1231
  public:
deba@165
  1232
deba@165
  1233
    typedef _Graph Graph;
deba@165
  1234
    TEMPLATE_GRAPH_TYPEDEFS(Graph);
deba@165
  1235
    
deba@165
  1236
  private:
deba@165
  1237
deba@165
  1238
    std::istream* _is;
deba@165
  1239
    bool local_is;
deba@165
  1240
deba@165
  1241
    Graph& _graph;
deba@165
  1242
deba@165
  1243
    std::string _nodes_caption;
deba@165
  1244
    std::string _edges_caption;
deba@165
  1245
    std::string _attributes_caption;
deba@165
  1246
deba@165
  1247
    typedef std::map<std::string, Node> NodeIndex;
deba@165
  1248
    NodeIndex _node_index;
deba@165
  1249
    typedef std::map<std::string, Edge> EdgeIndex;
deba@165
  1250
    EdgeIndex _edge_index;
deba@165
  1251
    
deba@165
  1252
    typedef std::vector<std::pair<std::string, 
deba@165
  1253
      _reader_bits::MapStorageBase<Node>*> > NodeMaps;    
deba@165
  1254
    NodeMaps _node_maps; 
deba@165
  1255
deba@165
  1256
    typedef std::vector<std::pair<std::string,
deba@165
  1257
      _reader_bits::MapStorageBase<Edge>*> > EdgeMaps;
deba@165
  1258
    EdgeMaps _edge_maps;
deba@165
  1259
deba@165
  1260
    typedef std::multimap<std::string, _reader_bits::ValueStorageBase*> 
deba@165
  1261
      Attributes;
deba@165
  1262
    Attributes _attributes;
deba@165
  1263
deba@165
  1264
    bool _use_nodes;
deba@165
  1265
    bool _use_edges;
deba@165
  1266
deba@188
  1267
    bool _skip_nodes;
deba@188
  1268
    bool _skip_edges;
deba@188
  1269
deba@165
  1270
    int line_num;
deba@165
  1271
    std::istringstream line;
deba@165
  1272
deba@165
  1273
  public:
deba@165
  1274
deba@165
  1275
    /// \brief Constructor
deba@165
  1276
    ///
kpeter@192
  1277
    /// Construct an undirected graph reader, which reads from the given
deba@165
  1278
    /// input stream.
deba@165
  1279
    GraphReader(std::istream& is, Graph& graph) 
deba@165
  1280
      : _is(&is), local_is(false), _graph(graph),
deba@188
  1281
	_use_nodes(false), _use_edges(false),
deba@188
  1282
	_skip_nodes(false), _skip_edges(false) {}
deba@165
  1283
deba@165
  1284
    /// \brief Constructor
deba@165
  1285
    ///
kpeter@192
  1286
    /// Construct an undirected graph reader, which reads from the given
deba@165
  1287
    /// file.
deba@165
  1288
    GraphReader(const std::string& fn, Graph& graph) 
deba@165
  1289
      : _is(new std::ifstream(fn.c_str())), local_is(true), _graph(graph),
deba@188
  1290
    	_use_nodes(false), _use_edges(false),
deba@188
  1291
	_skip_nodes(false), _skip_edges(false) {}
deba@165
  1292
    
deba@165
  1293
    /// \brief Constructor
deba@165
  1294
    ///
kpeter@192
  1295
    /// Construct an undirected graph reader, which reads from the given
deba@165
  1296
    /// file.
deba@165
  1297
    GraphReader(const char* fn, Graph& graph) 
deba@165
  1298
      : _is(new std::ifstream(fn)), local_is(true), _graph(graph),
deba@188
  1299
    	_use_nodes(false), _use_edges(false),
deba@188
  1300
	_skip_nodes(false), _skip_edges(false) {}
deba@165
  1301
deba@165
  1302
    /// \brief Destructor
deba@165
  1303
    ~GraphReader() {
deba@165
  1304
      for (typename NodeMaps::iterator it = _node_maps.begin(); 
deba@165
  1305
	   it != _node_maps.end(); ++it) {
deba@165
  1306
	delete it->second;
deba@165
  1307
      }
deba@165
  1308
deba@165
  1309
      for (typename EdgeMaps::iterator it = _edge_maps.begin(); 
deba@165
  1310
	   it != _edge_maps.end(); ++it) {
deba@165
  1311
	delete it->second;
deba@165
  1312
      }
deba@165
  1313
deba@165
  1314
      for (typename Attributes::iterator it = _attributes.begin(); 
deba@165
  1315
	   it != _attributes.end(); ++it) {
deba@165
  1316
	delete it->second;
deba@165
  1317
      }
deba@165
  1318
deba@165
  1319
      if (local_is) {
deba@165
  1320
	delete _is;
deba@165
  1321
      }
deba@165
  1322
deba@165
  1323
    }
deba@165
  1324
deba@165
  1325
  private:
deba@190
  1326
    friend GraphReader<Graph> graphReader<>(std::istream& is, Graph& graph);    
deba@190
  1327
    friend GraphReader<Graph> graphReader<>(const std::string& fn, 
deba@190
  1328
					    Graph& graph);   
deba@190
  1329
    friend GraphReader<Graph> graphReader<>(const char *fn, Graph& graph);    
deba@190
  1330
deba@190
  1331
    GraphReader(GraphReader& other) 
deba@190
  1332
      : _is(other._is), local_is(other.local_is), _graph(other._graph),
deba@190
  1333
	_use_nodes(other._use_nodes), _use_edges(other._use_edges),
deba@190
  1334
	_skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
deba@190
  1335
deba@190
  1336
      other._is = 0;
deba@190
  1337
      other.local_is = false;
deba@190
  1338
      
deba@190
  1339
      _node_index.swap(other._node_index);
deba@190
  1340
      _edge_index.swap(other._edge_index);
deba@190
  1341
deba@190
  1342
      _node_maps.swap(other._node_maps);
deba@190
  1343
      _edge_maps.swap(other._edge_maps);
deba@190
  1344
      _attributes.swap(other._attributes);
deba@190
  1345
deba@190
  1346
      _nodes_caption = other._nodes_caption;
deba@190
  1347
      _edges_caption = other._edges_caption;
deba@190
  1348
      _attributes_caption = other._attributes_caption;
deba@190
  1349
deba@190
  1350
    }
deba@190
  1351
deba@165
  1352
    GraphReader& operator=(const GraphReader&);
deba@165
  1353
deba@165
  1354
  public:
deba@165
  1355
deba@165
  1356
    /// \name Reading rules
deba@165
  1357
    /// @{
deba@165
  1358
    
deba@165
  1359
    /// \brief Node map reading rule
deba@165
  1360
    ///
deba@165
  1361
    /// Add a node map reading rule to the reader.
deba@165
  1362
    template <typename Map>
deba@165
  1363
    GraphReader& nodeMap(const std::string& caption, Map& map) {
deba@165
  1364
      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
deba@165
  1365
      _reader_bits::MapStorageBase<Node>* storage = 
deba@165
  1366
	new _reader_bits::MapStorage<Node, Map>(map);
deba@165
  1367
      _node_maps.push_back(std::make_pair(caption, storage));
deba@165
  1368
      return *this;
deba@165
  1369
    }
deba@165
  1370
deba@165
  1371
    /// \brief Node map reading rule
deba@165
  1372
    ///
deba@165
  1373
    /// Add a node map reading rule with specialized converter to the
deba@165
  1374
    /// reader.
deba@165
  1375
    template <typename Map, typename Converter>
deba@165
  1376
    GraphReader& nodeMap(const std::string& caption, Map& map, 
deba@165
  1377
			   const Converter& converter = Converter()) {
deba@165
  1378
      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
deba@165
  1379
      _reader_bits::MapStorageBase<Node>* storage = 
deba@165
  1380
	new _reader_bits::MapStorage<Node, Map, Converter>(map, converter);
deba@165
  1381
      _node_maps.push_back(std::make_pair(caption, storage));
deba@165
  1382
      return *this;
deba@165
  1383
    }
deba@165
  1384
deba@165
  1385
    /// \brief Edge map reading rule
deba@165
  1386
    ///
deba@165
  1387
    /// Add an edge map reading rule to the reader.
deba@165
  1388
    template <typename Map>
deba@165
  1389
    GraphReader& edgeMap(const std::string& caption, Map& map) {
deba@165
  1390
      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
deba@165
  1391
      _reader_bits::MapStorageBase<Edge>* storage = 
deba@165
  1392
	new _reader_bits::MapStorage<Edge, Map>(map);
deba@165
  1393
      _edge_maps.push_back(std::make_pair(caption, storage));
deba@165
  1394
      return *this;
deba@165
  1395
    }
deba@165
  1396
deba@165
  1397
    /// \brief Edge map reading rule
deba@165
  1398
    ///
deba@165
  1399
    /// Add an edge map reading rule with specialized converter to the
deba@165
  1400
    /// reader.
deba@165
  1401
    template <typename Map, typename Converter>
deba@165
  1402
    GraphReader& edgeMap(const std::string& caption, Map& map, 
deba@165
  1403
			  const Converter& converter = Converter()) {
deba@165
  1404
      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
deba@165
  1405
      _reader_bits::MapStorageBase<Edge>* storage = 
deba@165
  1406
	new _reader_bits::MapStorage<Edge, Map, Converter>(map, converter);
deba@165
  1407
      _edge_maps.push_back(std::make_pair(caption, storage));
deba@165
  1408
      return *this;
deba@165
  1409
    }
deba@165
  1410
deba@165
  1411
    /// \brief Arc map reading rule
deba@165
  1412
    ///
deba@165
  1413
    /// Add an arc map reading rule to the reader.
deba@165
  1414
    template <typename Map>
deba@165
  1415
    GraphReader& arcMap(const std::string& caption, Map& map) {
deba@165
  1416
      checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
deba@165
  1417
      _reader_bits::MapStorageBase<Edge>* forward_storage = 
deba@165
  1418
	new _reader_bits::GraphArcMapStorage<Graph, true, Map>(_graph, map);
deba@165
  1419
      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
deba@165
  1420
      _reader_bits::MapStorageBase<Edge>* backward_storage = 
deba@165
  1421
	new _reader_bits::GraphArcMapStorage<Graph, false, Map>(_graph, map);
deba@165
  1422
      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
deba@165
  1423
      return *this;
deba@165
  1424
    }
deba@165
  1425
deba@165
  1426
    /// \brief Arc map reading rule
deba@165
  1427
    ///
deba@165
  1428
    /// Add an arc map reading rule with specialized converter to the
deba@165
  1429
    /// reader.
deba@165
  1430
    template <typename Map, typename Converter>
deba@165
  1431
    GraphReader& arcMap(const std::string& caption, Map& map, 
deba@165
  1432
			  const Converter& converter = Converter()) {
deba@165
  1433
      checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
deba@165
  1434
      _reader_bits::MapStorageBase<Edge>* forward_storage = 
deba@165
  1435
	new _reader_bits::GraphArcMapStorage<Graph, true, Map, Converter>
deba@165
  1436
	(_graph, map, converter);
deba@165
  1437
      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
deba@165
  1438
      _reader_bits::MapStorageBase<Edge>* backward_storage = 
deba@165
  1439
	new _reader_bits::GraphArcMapStorage<Graph, false, Map, Converter>
deba@165
  1440
	(_graph, map, converter);
deba@165
  1441
      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
deba@165
  1442
      return *this;
deba@165
  1443
    }
deba@165
  1444
deba@165
  1445
    /// \brief Attribute reading rule
deba@165
  1446
    ///
deba@165
  1447
    /// Add an attribute reading rule to the reader.
deba@165
  1448
    template <typename Value>
deba@165
  1449
    GraphReader& attribute(const std::string& caption, Value& value) {
deba@165
  1450
      _reader_bits::ValueStorageBase* storage = 
deba@165
  1451
	new _reader_bits::ValueStorage<Value>(value);
deba@165
  1452
      _attributes.insert(std::make_pair(caption, storage));
deba@165
  1453
      return *this;
deba@165
  1454
    }
deba@165
  1455
deba@165
  1456
    /// \brief Attribute reading rule
deba@165
  1457
    ///
deba@165
  1458
    /// Add an attribute reading rule with specialized converter to the
deba@165
  1459
    /// reader.
deba@165
  1460
    template <typename Value, typename Converter>
deba@165
  1461
    GraphReader& attribute(const std::string& caption, Value& value, 
deba@165
  1462
			     const Converter& converter = Converter()) {
deba@165
  1463
      _reader_bits::ValueStorageBase* storage = 
deba@165
  1464
	new _reader_bits::ValueStorage<Value, Converter>(value, converter);
deba@165
  1465
      _attributes.insert(std::make_pair(caption, storage));
deba@165
  1466
      return *this;
deba@165
  1467
    }
deba@165
  1468
deba@165
  1469
    /// \brief Node reading rule
deba@165
  1470
    ///
deba@165
  1471
    /// Add a node reading rule to reader.
deba@165
  1472
    GraphReader& node(const std::string& caption, Node& node) {
deba@165
  1473
      typedef _reader_bits::MapLookUpConverter<Node> Converter;
deba@165
  1474
      Converter converter(_node_index);
deba@165
  1475
      _reader_bits::ValueStorageBase* storage = 
deba@165
  1476
	new _reader_bits::ValueStorage<Node, Converter>(node, converter);
deba@165
  1477
      _attributes.insert(std::make_pair(caption, storage));
deba@165
  1478
      return *this;
deba@165
  1479
    }
deba@165
  1480
deba@165
  1481
    /// \brief Edge reading rule
deba@165
  1482
    ///
deba@165
  1483
    /// Add an edge reading rule to reader.
deba@165
  1484
    GraphReader& edge(const std::string& caption, Edge& edge) {
deba@165
  1485
      typedef _reader_bits::MapLookUpConverter<Edge> Converter;
deba@165
  1486
      Converter converter(_edge_index);
deba@165
  1487
      _reader_bits::ValueStorageBase* storage = 
deba@165
  1488
	new _reader_bits::ValueStorage<Edge, Converter>(edge, converter);
deba@165
  1489
      _attributes.insert(std::make_pair(caption, storage));
deba@165
  1490
      return *this;
deba@165
  1491
    }
deba@165
  1492
deba@165
  1493
    /// \brief Arc reading rule
deba@165
  1494
    ///
deba@165
  1495
    /// Add an arc reading rule to reader.
deba@165
  1496
    GraphReader& arc(const std::string& caption, Arc& arc) {
deba@165
  1497
      typedef _reader_bits::GraphArcLookUpConverter<Graph> Converter;
deba@165
  1498
      Converter converter(_graph, _edge_index);
deba@165
  1499
      _reader_bits::ValueStorageBase* storage = 
deba@165
  1500
	new _reader_bits::ValueStorage<Arc, Converter>(arc, converter);
deba@165
  1501
      _attributes.insert(std::make_pair(caption, storage));
deba@165
  1502
      return *this;
deba@165
  1503
    }
deba@165
  1504
deba@165
  1505
    /// @}
deba@165
  1506
deba@165
  1507
    /// \name Select section by name
deba@165
  1508
    /// @{
deba@165
  1509
deba@165
  1510
    /// \brief Set \c \@nodes section to be read
deba@165
  1511
    ///
kpeter@192
  1512
    /// Set \c \@nodes section to be read.
deba@165
  1513
    GraphReader& nodes(const std::string& caption) {
deba@165
  1514
      _nodes_caption = caption;
deba@165
  1515
      return *this;
deba@165
  1516
    }
deba@165
  1517
deba@165
  1518
    /// \brief Set \c \@edges section to be read
deba@165
  1519
    ///
kpeter@192
  1520
    /// Set \c \@edges section to be read.
deba@165
  1521
    GraphReader& edges(const std::string& caption) {
deba@165
  1522
      _edges_caption = caption;
deba@165
  1523
      return *this;
deba@165
  1524
    }
deba@165
  1525
deba@165
  1526
    /// \brief Set \c \@attributes section to be read
deba@165
  1527
    ///
kpeter@192
  1528
    /// Set \c \@attributes section to be read.
deba@165
  1529
    GraphReader& attributes(const std::string& caption) {
deba@165
  1530
      _attributes_caption = caption;
deba@165
  1531
      return *this;
deba@165
  1532
    }
deba@165
  1533
deba@165
  1534
    /// @}
deba@165
  1535
deba@165
  1536
    /// \name Using previously constructed node or edge set
deba@165
  1537
    /// @{
deba@165
  1538
deba@165
  1539
    /// \brief Use previously constructed node set
deba@165
  1540
    ///
deba@165
  1541
    /// Use previously constructed node set, and specify the node
deba@165
  1542
    /// label map.
deba@165
  1543
    template <typename Map>
deba@165
  1544
    GraphReader& useNodes(const Map& map) {
deba@165
  1545
      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
deba@165
  1546
      LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member"); 
deba@165
  1547
      _use_nodes = true;
deba@165
  1548
      _writer_bits::DefaultConverter<typename Map::Value> converter;
deba@165
  1549
      for (NodeIt n(_graph); n != INVALID; ++n) {
deba@165
  1550
	_node_index.insert(std::make_pair(converter(map[n]), n));
deba@165
  1551
      }
deba@165
  1552
      return *this;
deba@165
  1553
    }
deba@165
  1554
deba@165
  1555
    /// \brief Use previously constructed node set
deba@165
  1556
    ///
deba@165
  1557
    /// Use previously constructed node set, and specify the node
deba@165
  1558
    /// label map and a functor which converts the label map values to
kpeter@192
  1559
    /// \c std::string.
deba@165
  1560
    template <typename Map, typename Converter>
deba@165
  1561
    GraphReader& useNodes(const Map& map, 
deba@165
  1562
			    const Converter& converter = Converter()) {
deba@165
  1563
      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
deba@165
  1564
      LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member"); 
deba@165
  1565
      _use_nodes = true;
deba@165
  1566
      for (NodeIt n(_graph); n != INVALID; ++n) {
deba@165
  1567
	_node_index.insert(std::make_pair(converter(map[n]), n));
deba@165
  1568
      }
deba@165
  1569
      return *this;
deba@165
  1570
    }
deba@165
  1571
deba@165
  1572
    /// \brief Use previously constructed edge set
deba@165
  1573
    ///
deba@165
  1574
    /// Use previously constructed edge set, and specify the edge
deba@165
  1575
    /// label map.
deba@165
  1576
    template <typename Map>
deba@165
  1577
    GraphReader& useEdges(const Map& map) {
deba@165
  1578
      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
deba@165
  1579
      LEMON_ASSERT(!_use_edges, "Multiple usage of useEdges() member");
deba@165
  1580
      _use_edges = true;
deba@165
  1581
      _writer_bits::DefaultConverter<typename Map::Value> converter;
deba@165
  1582
      for (EdgeIt a(_graph); a != INVALID; ++a) {
deba@165
  1583
	_edge_index.insert(std::make_pair(converter(map[a]), a));
deba@165
  1584
      }
deba@165
  1585
      return *this;
deba@165
  1586
    }
deba@165
  1587
deba@165
  1588
    /// \brief Use previously constructed edge set
deba@165
  1589
    ///
deba@165
  1590
    /// Use previously constructed edge set, and specify the edge
deba@165
  1591
    /// label map and a functor which converts the label map values to
kpeter@192
  1592
    /// \c std::string.
deba@165
  1593
    template <typename Map, typename Converter>
deba@165
  1594
    GraphReader& useEdges(const Map& map, 
deba@165
  1595
			    const Converter& converter = Converter()) {
deba@165
  1596
      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
deba@165
  1597
      LEMON_ASSERT(!_use_edges, "Multiple usage of useEdges() member"); 
deba@165
  1598
      _use_edges = true;
deba@165
  1599
      for (EdgeIt a(_graph); a != INVALID; ++a) {
deba@165
  1600
	_edge_index.insert(std::make_pair(converter(map[a]), a));
deba@165
  1601
      }
deba@165
  1602
      return *this;
deba@165
  1603
    }
deba@165
  1604
kpeter@192
  1605
    /// \brief Skip the reading of node section
deba@188
  1606
    ///
deba@188
  1607
    /// Omit the reading of the node section. This implies that each node
kpeter@192
  1608
    /// map reading rule will be abandoned, and the nodes of the graph
deba@188
  1609
    /// will not be constructed, which usually cause that the edge set
deba@188
  1610
    /// could not be read due to lack of node name
kpeter@192
  1611
    /// could not be read due to lack of node name resolving.
kpeter@192
  1612
    /// Therefore \c skipEdges() function should also be used, or
kpeter@192
  1613
    /// \c useNodes() should be used to specify the label of the nodes.
deba@188
  1614
    GraphReader& skipNodes() {
deba@188
  1615
      LEMON_ASSERT(!_skip_nodes, "Skip nodes already set"); 
deba@188
  1616
      _skip_nodes = true;
deba@188
  1617
      return *this;
deba@188
  1618
    }
deba@188
  1619
kpeter@192
  1620
    /// \brief Skip the reading of edge section
deba@188
  1621
    ///
deba@188
  1622
    /// Omit the reading of the edge section. This implies that each edge
kpeter@192
  1623
    /// map reading rule will be abandoned, and the edges of the graph
deba@188
  1624
    /// will not be constructed.
deba@188
  1625
    GraphReader& skipEdges() {
deba@188
  1626
      LEMON_ASSERT(!_skip_edges, "Skip edges already set"); 
deba@188
  1627
      _skip_edges = true;
deba@188
  1628
      return *this;
deba@188
  1629
    }
deba@188
  1630
deba@165
  1631
    /// @}
deba@165
  1632
deba@165
  1633
  private:
deba@165
  1634
deba@165
  1635
    bool readLine() {
deba@165
  1636
      std::string str;
deba@165
  1637
      while(++line_num, std::getline(*_is, str)) {
deba@165
  1638
	line.clear(); line.str(str);
deba@165
  1639
	char c;
deba@165
  1640
	if (line >> std::ws >> c && c != '#') {
deba@165
  1641
	  line.putback(c);
deba@165
  1642
	  return true;
deba@165
  1643
	}
deba@165
  1644
      }
deba@165
  1645
      return false;
deba@165
  1646
    }
deba@165
  1647
deba@165
  1648
    bool readSuccess() {
deba@165
  1649
      return static_cast<bool>(*_is);
deba@165
  1650
    }
deba@165
  1651
    
deba@165
  1652
    void skipSection() {
deba@165
  1653
      char c;
deba@165
  1654
      while (readSuccess() && line >> c && c != '@') {
deba@165
  1655
	readLine();
deba@165
  1656
      }
deba@165
  1657
      line.putback(c);
deba@165
  1658
    }
deba@165
  1659
deba@165
  1660
    void readNodes() {
deba@165
  1661
deba@165
  1662
      std::vector<int> map_index(_node_maps.size());
deba@165
  1663
      int map_num, label_index;
deba@165
  1664
deba@186
  1665
      char c;
deba@186
  1666
      if (!readLine() || !(line >> c) || c == '@') {
deba@186
  1667
	if (readSuccess() && line) line.putback(c);
deba@186
  1668
	if (!_node_maps.empty()) 
deba@186
  1669
	  throw DataFormatError("Cannot find map names");
deba@186
  1670
	return;
deba@186
  1671
      }
deba@186
  1672
      line.putback(c);
deba@165
  1673
      
deba@165
  1674
      {
deba@165
  1675
	std::map<std::string, int> maps;
deba@165
  1676
	
deba@165
  1677
	std::string map;
deba@165
  1678
	int index = 0;
deba@165
  1679
	while (_reader_bits::readToken(line, map)) {
deba@165
  1680
	  if (maps.find(map) != maps.end()) {
deba@165
  1681
	    std::ostringstream msg;
deba@165
  1682
	    msg << "Multiple occurence of node map: " << map;
deba@165
  1683
	    throw DataFormatError(msg.str().c_str());
deba@165
  1684
	  }
deba@165
  1685
	  maps.insert(std::make_pair(map, index));
deba@165
  1686
	  ++index;
deba@165
  1687
	}
deba@165
  1688
	
deba@165
  1689
	for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {
deba@165
  1690
	  std::map<std::string, int>::iterator jt = 
deba@165
  1691
	    maps.find(_node_maps[i].first);
deba@165
  1692
	  if (jt == maps.end()) {
deba@165
  1693
	    std::ostringstream msg;
deba@165
  1694
	    msg << "Map not found in file: " << _node_maps[i].first;
deba@165
  1695
	    throw DataFormatError(msg.str().c_str());
deba@165
  1696
	  }
deba@165
  1697
	  map_index[i] = jt->second;
deba@165
  1698
	}
deba@165
  1699
deba@165
  1700
	{
deba@165
  1701
	  std::map<std::string, int>::iterator jt = maps.find("label");
deba@186
  1702
	  if (jt != maps.end()) {
deba@186
  1703
	    label_index = jt->second;
deba@186
  1704
	  } else {
deba@186
  1705
	    label_index = -1;
deba@186
  1706
	  }
deba@165
  1707
	}
deba@165
  1708
	map_num = maps.size();
deba@165
  1709
      }
deba@165
  1710
deba@165
  1711
      while (readLine() && line >> c && c != '@') {
deba@165
  1712
	line.putback(c);
deba@165
  1713
deba@165
  1714
	std::vector<std::string> tokens(map_num);
deba@165
  1715
	for (int i = 0; i < map_num; ++i) {
deba@165
  1716
	  if (!_reader_bits::readToken(line, tokens[i])) {
deba@165
  1717
	    std::ostringstream msg;
deba@165
  1718
	    msg << "Column not found (" << i + 1 << ")";
deba@165
  1719
	    throw DataFormatError(msg.str().c_str());
deba@165
  1720
	  }
deba@165
  1721
	}
deba@165
  1722
	if (line >> std::ws >> c)
deba@165
  1723
	  throw DataFormatError("Extra character on the end of line");
deba@165
  1724
	
deba@165
  1725
	Node n;
deba@165
  1726
	if (!_use_nodes) {
deba@165
  1727
	  n = _graph.addNode();
deba@186
  1728
	  if (label_index != -1) 
deba@186
  1729
	    _node_index.insert(std::make_pair(tokens[label_index], n));
deba@165
  1730
	} else {
deba@186
  1731
	  if (label_index == -1) 
deba@186
  1732
	    throw DataFormatError("Label map not found in file");
deba@165
  1733
	  typename std::map<std::string, Node>::iterator it =
deba@165
  1734
	    _node_index.find(tokens[label_index]);
deba@165
  1735
	  if (it == _node_index.end()) {
deba@165
  1736
	    std::ostringstream msg;
deba@165
  1737
	    msg << "Node with label not found: " << tokens[label_index];
deba@165
  1738
	    throw DataFormatError(msg.str().c_str());	    
deba@165
  1739
	  }
deba@165
  1740
	  n = it->second;
deba@165
  1741
	}
deba@165
  1742
deba@165
  1743
	for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {
deba@165
  1744
	  _node_maps[i].second->set(n, tokens[map_index[i]]);
deba@165
  1745
	}
deba@165
  1746
deba@165
  1747
      }
deba@165
  1748
      if (readSuccess()) {
deba@165
  1749
	line.putback(c);
deba@165
  1750
      }
deba@165
  1751
    }
deba@165
  1752
deba@165
  1753
    void readEdges() {
deba@165
  1754
deba@165
  1755
      std::vector<int> map_index(_edge_maps.size());
deba@165
  1756
      int map_num, label_index;
deba@165
  1757
deba@186
  1758
      char c;
deba@186
  1759
      if (!readLine() || !(line >> c) || c == '@') {
deba@186
  1760
	if (readSuccess() && line) line.putback(c);
deba@186
  1761
	if (!_edge_maps.empty()) 
deba@186
  1762
	  throw DataFormatError("Cannot find map names");
deba@186
  1763
	return;
deba@186
  1764
      }
deba@186
  1765
      line.putback(c);
deba@165
  1766
      
deba@165
  1767
      {
deba@165
  1768
	std::map<std::string, int> maps;
deba@165
  1769
	
deba@165
  1770
	std::string map;
deba@165
  1771
	int index = 0;
deba@165
  1772
	while (_reader_bits::readToken(line, map)) {
deba@165
  1773
	  if (maps.find(map) != maps.end()) {
deba@165
  1774
	    std::ostringstream msg;
deba@165
  1775
	    msg << "Multiple occurence of edge map: " << map;
deba@165
  1776
	    throw DataFormatError(msg.str().c_str());
deba@165
  1777
	  }
deba@165
  1778
	  maps.insert(std::make_pair(map, index));
deba@165
  1779
	  ++index;
deba@165
  1780
	}
deba@165
  1781
	
deba@165
  1782
	for (int i = 0; i < static_cast<int>(_edge_maps.size()); ++i) {
deba@165
  1783
	  std::map<std::string, int>::iterator jt = 
deba@165
  1784
	    maps.find(_edge_maps[i].first);
deba@165
  1785
	  if (jt == maps.end()) {
deba@165
  1786
	    std::ostringstream msg;
deba@165
  1787
	    msg << "Map not found in file: " << _edge_maps[i].first;
deba@165
  1788
	    throw DataFormatError(msg.str().c_str());
deba@165
  1789
	  }
deba@165
  1790
	  map_index[i] = jt->second;
deba@165
  1791
	}
deba@165
  1792
deba@165
  1793
	{
deba@165
  1794
	  std::map<std::string, int>::iterator jt = maps.find("label");
deba@186
  1795
	  if (jt != maps.end()) {
deba@186
  1796
	    label_index = jt->second;
deba@186
  1797
	  } else {
deba@186
  1798
	    label_index = -1;
deba@186
  1799
	  }
deba@165
  1800
	}
deba@165
  1801
	map_num = maps.size();
deba@165
  1802
      }
deba@165
  1803
deba@165
  1804
      while (readLine() && line >> c && c != '@') {
deba@165
  1805
	line.putback(c);
deba@165
  1806
deba@165
  1807
	std::string source_token;
deba@165
  1808
	std::string target_token;
deba@165
  1809
deba@165
  1810
	if (!_reader_bits::readToken(line, source_token))
deba@186
  1811
	  throw DataFormatError("Node u not found");
deba@165
  1812
deba@165
  1813
	if (!_reader_bits::readToken(line, target_token))
deba@186
  1814
	  throw DataFormatError("Node v not found");
deba@165
  1815
	
deba@165
  1816
	std::vector<std::string> tokens(map_num);
deba@165
  1817
	for (int i = 0; i < map_num; ++i) {
deba@165
  1818
	  if (!_reader_bits::readToken(line, tokens[i])) {
deba@165
  1819
	    std::ostringstream msg;
deba@165
  1820
	    msg << "Column not found (" << i + 1 << ")";
deba@165
  1821
	    throw DataFormatError(msg.str().c_str());
deba@165
  1822
	  }
deba@165
  1823
	}
deba@165
  1824
	if (line >> std::ws >> c)
deba@165
  1825
	  throw DataFormatError("Extra character on the end of line");
deba@165
  1826
	
deba@165
  1827
	Edge e;
deba@165
  1828
	if (!_use_edges) {
deba@165
  1829
deba@165
  1830
          typename NodeIndex::iterator it;
deba@165
  1831
 
deba@165
  1832
          it = _node_index.find(source_token);
deba@165
  1833
          if (it == _node_index.end()) {
deba@165
  1834
            std::ostringstream msg;
deba@165
  1835
            msg << "Item not found: " << source_token;
deba@165
  1836
            throw DataFormatError(msg.str().c_str());
deba@165
  1837
          }
deba@165
  1838
          Node source = it->second;
deba@165
  1839
deba@165
  1840
          it = _node_index.find(target_token);
deba@165
  1841
          if (it == _node_index.end()) {       
deba@165
  1842
            std::ostringstream msg;            
deba@165
  1843
            msg << "Item not found: " << target_token;
deba@165
  1844
            throw DataFormatError(msg.str().c_str());
deba@165
  1845
          }                                          
deba@165
  1846
          Node target = it->second;                            
deba@165
  1847
deba@165
  1848
	  e = _graph.addEdge(source, target);
deba@186
  1849
	  if (label_index != -1) 
deba@186
  1850
	    _edge_index.insert(std::make_pair(tokens[label_index], e));
deba@165
  1851
	} else {
deba@186
  1852
	  if (label_index == -1) 
deba@186
  1853
	    throw DataFormatError("Label map not found in file");
deba@165
  1854
	  typename std::map<std::string, Edge>::iterator it =
deba@165
  1855
	    _edge_index.find(tokens[label_index]);
deba@165
  1856
	  if (it == _edge_index.end()) {
deba@165
  1857
	    std::ostringstream msg;
deba@165
  1858
	    msg << "Edge with label not found: " << tokens[label_index];
deba@165
  1859
	    throw DataFormatError(msg.str().c_str());	    
deba@165
  1860
	  }
deba@165
  1861
	  e = it->second;
deba@165
  1862
	}
deba@165
  1863
deba@165
  1864
	for (int i = 0; i < static_cast<int>(_edge_maps.size()); ++i) {
deba@165
  1865
	  _edge_maps[i].second->set(e, tokens[map_index[i]]);
deba@165
  1866
	}
deba@165
  1867
deba@165
  1868
      }
deba@165
  1869
      if (readSuccess()) {
deba@165
  1870
	line.putback(c);
deba@165
  1871
      }
deba@165
  1872
    }
deba@165
  1873
deba@165
  1874
    void readAttributes() {
deba@165
  1875
deba@165
  1876
      std::set<std::string> read_attr;
deba@165
  1877
deba@165
  1878
      char c;
deba@165
  1879
      while (readLine() && line >> c && c != '@') {
deba@165
  1880
	line.putback(c);
deba@165
  1881
	
deba@165
  1882
	std::string attr, token;
deba@165
  1883
	if (!_reader_bits::readToken(line, attr))
deba@165
  1884
	  throw DataFormatError("Attribute name not found");
deba@165
  1885
	if (!_reader_bits::readToken(line, token))
deba@165
  1886
	  throw DataFormatError("Attribute value not found");
deba@165
  1887
	if (line >> c)
deba@165
  1888
	  throw DataFormatError("Extra character on the end of line");	  
deba@165
  1889
deba@165
  1890
	{
deba@165
  1891
	  std::set<std::string>::iterator it = read_attr.find(attr);
deba@165
  1892
	  if (it != read_attr.end()) {
deba@165
  1893
	    std::ostringstream msg;
deba@165
  1894
	    msg << "Multiple occurence of attribute " << attr;
deba@165
  1895
	    throw DataFormatError(msg.str().c_str());
deba@165
  1896
	  }
deba@165
  1897
	  read_attr.insert(attr);
deba@165
  1898
	}
deba@165
  1899
	
deba@165
  1900
	{
deba@165
  1901
	  typename Attributes::iterator it = _attributes.lower_bound(attr);
deba@165
  1902
	  while (it != _attributes.end() && it->first == attr) {
deba@165
  1903
	    it->second->set(token);
deba@165
  1904
	    ++it;
deba@165
  1905
	  }
deba@165
  1906
	}
deba@165
  1907
deba@165
  1908
      }
deba@165
  1909
      if (readSuccess()) {
deba@165
  1910
	line.putback(c);
deba@165
  1911
      }
deba@165
  1912
      for (typename Attributes::iterator it = _attributes.begin();
deba@165
  1913
	   it != _attributes.end(); ++it) {
deba@165
  1914
	if (read_attr.find(it->first) == read_attr.end()) {
deba@165
  1915
	  std::ostringstream msg;
deba@165
  1916
	  msg << "Attribute not found in file: " << it->first;
deba@165
  1917
	  throw DataFormatError(msg.str().c_str());
deba@165
  1918
	}	
deba@165
  1919
      }
deba@165
  1920
    }
deba@165
  1921
deba@165
  1922
  public:
deba@165
  1923
deba@165
  1924
    /// \name Execution of the reader    
deba@165
  1925
    /// @{
deba@165
  1926
deba@165
  1927
    /// \brief Start the batch processing
deba@165
  1928
    ///
deba@165
  1929
    /// This function starts the batch processing
deba@165
  1930
    void run() {
deba@165
  1931
      
deba@165
  1932
      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");
deba@165
  1933
      
deba@188
  1934
      bool nodes_done = _skip_nodes;
deba@188
  1935
      bool edges_done = _skip_edges;
deba@165
  1936
      bool attributes_done = false;
deba@165
  1937
deba@165
  1938
      line_num = 0;      
deba@165
  1939
      readLine();
deba@172
  1940
      skipSection();
deba@165
  1941
deba@165
  1942
      while (readSuccess()) {
deba@165
  1943
	try {
deba@165
  1944
	  char c;
deba@165
  1945
	  std::string section, caption;
deba@165
  1946
	  line >> c;
deba@165
  1947
	  _reader_bits::readToken(line, section);
deba@165
  1948
	  _reader_bits::readToken(line, caption);
deba@165
  1949
deba@165
  1950
	  if (line >> c) 
deba@165
  1951
	    throw DataFormatError("Extra character on the end of line");
deba@165
  1952
deba@165
  1953
	  if (section == "nodes" && !nodes_done) {
deba@165
  1954
	    if (_nodes_caption.empty() || _nodes_caption == caption) {
deba@165
  1955
	      readNodes();
deba@165
  1956
	      nodes_done = true;
deba@165
  1957
	    }
deba@165
  1958
	  } else if ((section == "edges" || section == "arcs") && 
deba@165
  1959
		     !edges_done) {
deba@165
  1960
	    if (_edges_caption.empty() || _edges_caption == caption) {
deba@165
  1961
	      readEdges();
deba@165
  1962
	      edges_done = true;
deba@165
  1963
	    }
deba@165
  1964
	  } else if (section == "attributes" && !attributes_done) {
deba@165
  1965
	    if (_attributes_caption.empty() || _attributes_caption == caption) {
deba@165
  1966
	      readAttributes();
deba@165
  1967
	      attributes_done = true;
deba@165
  1968
	    }
deba@165
  1969
	  } else {
deba@172
  1970
	    readLine();
deba@172
  1971
	    skipSection();
deba@165
  1972
	  }
deba@165
  1973
	} catch (DataFormatError& error) {
deba@165
  1974
	  error.line(line_num);
deba@165
  1975
	  throw;
deba@165
  1976
	}	
deba@165
  1977
      }
deba@165
  1978
deba@165
  1979
      if (!nodes_done) {
deba@165
  1980
	throw DataFormatError("Section @nodes not found");
deba@165
  1981
      }
deba@165
  1982
deba@165
  1983
      if (!edges_done) {
deba@165
  1984
	throw DataFormatError("Section @edges not found");
deba@165
  1985
      }
deba@165
  1986
deba@165
  1987
      if (!attributes_done && !_attributes.empty()) {
deba@165
  1988
	throw DataFormatError("Section @attributes not found");
deba@165
  1989
      }
deba@165
  1990
deba@165
  1991
    }
deba@165
  1992
deba@165
  1993
    /// @}
deba@165
  1994
    
deba@165
  1995
  };
deba@165
  1996
kpeter@192
  1997
  /// \brief Return a \ref GraphReader class
kpeter@192
  1998
  /// 
kpeter@192
  1999
  /// This function just returns a \ref GraphReader class.
deba@165
  2000
  /// \relates GraphReader
deba@165
  2001
  template <typename Graph>
deba@165
  2002
  GraphReader<Graph> graphReader(std::istream& is, Graph& graph) {
deba@165
  2003
    GraphReader<Graph> tmp(is, graph);
deba@165
  2004
    return tmp;
deba@165
  2005
  }
deba@165
  2006
kpeter@192
  2007
  /// \brief Return a \ref GraphReader class
kpeter@192
  2008
  /// 
kpeter@192
  2009
  /// This function just returns a \ref GraphReader class.
deba@165
  2010
  /// \relates GraphReader
deba@165
  2011
  template <typename Graph>
deba@165
  2012
  GraphReader<Graph> graphReader(const std::string& fn, 
deba@165
  2013
				       Graph& graph) {
deba@165
  2014
    GraphReader<Graph> tmp(fn, graph);
deba@165
  2015
    return tmp;
deba@165
  2016
  }
deba@165
  2017
kpeter@192
  2018
  /// \brief Return a \ref GraphReader class
kpeter@192
  2019
  /// 
kpeter@192
  2020
  /// This function just returns a \ref GraphReader class.
deba@165
  2021
  /// \relates GraphReader
deba@165
  2022
  template <typename Graph>
deba@165
  2023
  GraphReader<Graph> graphReader(const char* fn, Graph& graph) {
deba@165
  2024
    GraphReader<Graph> tmp(fn, graph);
deba@165
  2025
    return tmp;
deba@165
  2026
  }
deba@173
  2027
deba@190
  2028
  class SectionReader;
deba@190
  2029
deba@190
  2030
  SectionReader sectionReader(std::istream& is);
deba@190
  2031
  SectionReader sectionReader(const std::string& fn);
deba@190
  2032
  SectionReader sectionReader(const char* fn);
deba@190
  2033
  
kpeter@192
  2034
  /// \ingroup lemon_io
kpeter@192
  2035
  ///
deba@189
  2036
  /// \brief Section reader class
deba@189
  2037
  ///
kpeter@192
  2038
  /// In the \ref lgf-format "LGF" file extra sections can be placed, 
kpeter@192
  2039
  /// which contain any data in arbitrary format. Such sections can be
kpeter@192
  2040
  /// read with this class. A reading rule can be added to the class 
kpeter@192
  2041
  /// with two different functions. With the \c sectionLines() function a
kpeter@192
  2042
  /// functor can process the section line-by-line, while with the \c
deba@189
  2043
  /// sectionStream() member the section can be read from an input
deba@189
  2044
  /// stream.
deba@189
  2045
  class SectionReader {
deba@189
  2046
  private:
deba@189
  2047
    
deba@189
  2048
    std::istream* _is;
deba@189
  2049
    bool local_is;
deba@189
  2050
deba@189
  2051
    typedef std::map<std::string, _reader_bits::Section*> Sections;
deba@189
  2052
    Sections _sections;
deba@189
  2053
deba@189
  2054
    int line_num;
deba@189
  2055
    std::istringstream line;
deba@189
  2056
deba@189
  2057
  public:
deba@189
  2058
deba@189
  2059
    /// \brief Constructor
deba@189
  2060
    ///
deba@189
  2061
    /// Construct a section reader, which reads from the given input
deba@189
  2062
    /// stream.
deba@189
  2063
    SectionReader(std::istream& is) 
deba@189
  2064
      : _is(&is), local_is(false) {}
deba@189
  2065
deba@189
  2066
    /// \brief Constructor
deba@189
  2067
    ///
deba@189
  2068
    /// Construct a section reader, which reads from the given file.
deba@189
  2069
    SectionReader(const std::string& fn) 
deba@189
  2070
      : _is(new std::ifstream(fn.c_str())), local_is(true) {}
deba@189
  2071
    
deba@189
  2072
    /// \brief Constructor
deba@189
  2073
    ///
deba@189
  2074
    /// Construct a section reader, which reads from the given file.
deba@189
  2075
    SectionReader(const char* fn) 
deba@189
  2076
      : _is(new std::ifstream(fn)), local_is(true) {}
deba@189
  2077
deba@189
  2078
    /// \brief Destructor
deba@189
  2079
    ~SectionReader() {
deba@189
  2080
      for (Sections::iterator it = _sections.begin(); 
deba@189
  2081
	   it != _sections.end(); ++it) {
deba@189
  2082
	delete it->second;
deba@189
  2083
      }
deba@189
  2084
deba@189
  2085
      if (local_is) {
deba@189
  2086
	delete _is;
deba@189
  2087
      }
deba@189
  2088
deba@189
  2089
    }
deba@189
  2090
deba@189
  2091
  private:
deba@190
  2092
deba@190
  2093
    friend SectionReader sectionReader(std::istream& is);
deba@190
  2094
    friend SectionReader sectionReader(const std::string& fn);
deba@190
  2095
    friend SectionReader sectionReader(const char* fn);
deba@190
  2096
deba@190
  2097
    SectionReader(SectionReader& other) 
deba@190
  2098
      : _is(other._is), local_is(other.local_is) {
deba@190
  2099
deba@190
  2100
      other._is = 0;
deba@190
  2101
      other.local_is = false;
deba@190
  2102
      
deba@190
  2103
      _sections.swap(other._sections);
deba@190
  2104
    }
deba@189
  2105
    
deba@189
  2106
    SectionReader& operator=(const SectionReader&);
deba@189
  2107
deba@189
  2108
  public:
deba@189
  2109
deba@189
  2110
    /// \name Section readers
deba@189
  2111
    /// @{
deba@189
  2112
deba@189
  2113
    /// \brief Add a section processor with line oriented reading
deba@189
  2114
    ///
deba@189
  2115
    /// The first parameter is the type descriptor of the section, the
deba@189
  2116
    /// second is a functor, which takes just one \c std::string
deba@189
  2117
    /// parameter. At the reading process, each line of the section
deba@189
  2118
    /// will be given to the functor object. However, the empty lines
deba@189
  2119
    /// and the comment lines are filtered out, and the leading
deba@189
  2120
    /// whitespaces are trimmed from each processed string.
deba@189
  2121
    ///
deba@189
  2122
    /// For example let's see a section, which contain several
deba@189
  2123
    /// integers, which should be inserted into a vector.
deba@189
  2124
    ///\code
deba@189
  2125
    ///  @numbers
deba@189
  2126
    ///  12 45 23
deba@189
  2127
    ///  4
deba@189
  2128
    ///  23 6
deba@189
  2129
    ///\endcode
deba@189
  2130
    ///
kpeter@192
  2131
    /// The functor is implemented as a struct:
deba@189
  2132
    ///\code
deba@189
  2133
    ///  struct NumberSection {
deba@189
  2134
    ///    std::vector<int>& _data;
deba@189
  2135
    ///    NumberSection(std::vector<int>& data) : _data(data) {}
deba@189
  2136
    ///    void operator()(const std::string& line) {
deba@189
  2137
    ///      std::istringstream ls(line);
deba@189
  2138
    ///      int value;
deba@189
  2139
    ///      while (ls >> value) _data.push_back(value);
deba@189
  2140
    ///    }
deba@189
  2141
    ///  };
deba@189
  2142
    ///
deba@189
  2143
    ///  // ...
deba@189
  2144
    ///
deba@189
  2145
    ///  reader.sectionLines("numbers", NumberSection(vec));  
deba@189
  2146
    ///\endcode
deba@189
  2147
    template <typename Functor>
deba@189
  2148
    SectionReader& sectionLines(const std::string& type, Functor functor) {
kpeter@192
  2149
      LEMON_ASSERT(!type.empty(), "Type is empty.");
deba@189
  2150
      LEMON_ASSERT(_sections.find(type) == _sections.end(), 
deba@189
  2151
		   "Multiple reading of section.");
deba@189
  2152
      _sections.insert(std::make_pair(type, 
deba@189
  2153
        new _reader_bits::LineSection<Functor>(functor)));
deba@189
  2154
      return *this;
deba@189
  2155
    }
deba@189
  2156
deba@189
  2157
deba@189
  2158
    /// \brief Add a section processor with stream oriented reading
deba@189
  2159
    ///
deba@189
  2160
    /// The first parameter is the type of the section, the second is
kpeter@192
  2161
    /// a functor, which takes an \c std::istream& and an \c int&
deba@189
  2162
    /// parameter, the latter regard to the line number of stream. The
deba@189
  2163
    /// functor can read the input while the section go on, and the
deba@189
  2164
    /// line number should be modified accordingly.
deba@189
  2165
    template <typename Functor>
deba@189
  2166
    SectionReader& sectionStream(const std::string& type, Functor functor) {
kpeter@192
  2167
      LEMON_ASSERT(!type.empty(), "Type is empty.");
deba@189
  2168
      LEMON_ASSERT(_sections.find(type) == _sections.end(), 
deba@189
  2169
		   "Multiple reading of section.");
deba@189
  2170
      _sections.insert(std::make_pair(type, 
deba@189
  2171
	 new _reader_bits::StreamSection<Functor>(functor)));
deba@189
  2172
      return *this;
deba@189
  2173
    }    
deba@189
  2174
    
deba@189
  2175
    /// @}
deba@189
  2176
deba@189
  2177
  private:
deba@189
  2178
deba@189
  2179
    bool readLine() {
deba@189
  2180
      std::string str;
deba@189
  2181
      while(++line_num, std::getline(*_is, str)) {
deba@189
  2182
	line.clear(); line.str(str);
deba@189
  2183
	char c;
deba@189
  2184
	if (line >> std::ws >> c && c != '#') {
deba@189
  2185
	  line.putback(c);
deba@189
  2186
	  return true;
deba@189
  2187
	}
deba@189
  2188
      }
deba@189
  2189
      return false;
deba@189
  2190
    }
deba@189
  2191
deba@189
  2192
    bool readSuccess() {
deba@189
  2193
      return static_cast<bool>(*_is);
deba@189
  2194
    }
deba@189
  2195
    
deba@189
  2196
    void skipSection() {
deba@189
  2197
      char c;
deba@189
  2198
      while (readSuccess() && line >> c && c != '@') {
deba@189
  2199
	readLine();
deba@189
  2200
      }
deba@189
  2201
      line.putback(c);
deba@189
  2202
    }
deba@189
  2203
deba@189
  2204
  public:
deba@189
  2205
deba@189
  2206
deba@189
  2207
    /// \name Execution of the reader    
deba@189
  2208
    /// @{
deba@189
  2209
deba@189
  2210
    /// \brief Start the batch processing
deba@189
  2211
    ///
kpeter@192
  2212
    /// This function starts the batch processing.
deba@189
  2213
    void run() {
deba@189
  2214
      
deba@189
  2215
      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");
deba@189
  2216
      
deba@189
  2217
      std::set<std::string> extra_sections;
deba@189
  2218
deba@189
  2219
      line_num = 0;      
deba@189
  2220
      readLine();
deba@189
  2221
      skipSection();
deba@189
  2222
deba@189
  2223
      while (readSuccess()) {
deba@189
  2224
	try {
deba@189
  2225
	  char c;
deba@189
  2226
	  std::string section, caption;
deba@189
  2227
	  line >> c;
deba@189
  2228
	  _reader_bits::readToken(line, section);
deba@189
  2229
	  _reader_bits::readToken(line, caption);
deba@189
  2230
deba@189
  2231
	  if (line >> c) 
deba@189
  2232
	    throw DataFormatError("Extra character on the end of line");
deba@189
  2233
deba@189
  2234
	  if (extra_sections.find(section) != extra_sections.end()) {
deba@189
  2235
	    std::ostringstream msg;
deba@189
  2236
	    msg << "Multiple occurence of section " << section;
deba@189
  2237
	    throw DataFormatError(msg.str().c_str());
deba@189
  2238
	  }
deba@189
  2239
	  Sections::iterator it = _sections.find(section);
deba@189
  2240
	  if (it != _sections.end()) {
deba@189
  2241
	    extra_sections.insert(section);
deba@189
  2242
	    it->second->process(*_is, line_num);
deba@189
  2243
	  }
deba@189
  2244
	  readLine();
deba@189
  2245
	  skipSection();
deba@189
  2246
	} catch (DataFormatError& error) {
deba@189
  2247
	  error.line(line_num);
deba@189
  2248
	  throw;
deba@189
  2249
	}	
deba@189
  2250
      }
deba@189
  2251
      for (Sections::iterator it = _sections.begin();
deba@189
  2252
	   it != _sections.end(); ++it) {
deba@189
  2253
	if (extra_sections.find(it->first) == extra_sections.end()) {
deba@189
  2254
	  std::ostringstream os;
deba@189
  2255
	  os << "Cannot find section: " << it->first;
deba@189
  2256
	  throw DataFormatError(os.str().c_str());
deba@189
  2257
	}
deba@189
  2258
      }
deba@189
  2259
    }
deba@189
  2260
deba@189
  2261
    /// @}
deba@189
  2262
        
deba@189
  2263
  };
deba@189
  2264
kpeter@192
  2265
  /// \brief Return a \ref SectionReader class
kpeter@192
  2266
  /// 
kpeter@192
  2267
  /// This function just returns a \ref SectionReader class.
deba@189
  2268
  /// \relates SectionReader
deba@189
  2269
  inline SectionReader sectionReader(std::istream& is) {
deba@189
  2270
    SectionReader tmp(is);
deba@189
  2271
    return tmp;
deba@189
  2272
  }
deba@189
  2273
kpeter@192
  2274
  /// \brief Return a \ref SectionReader class
kpeter@192
  2275
  /// 
kpeter@192
  2276
  /// This function just returns a \ref SectionReader class.
deba@189
  2277
  /// \relates SectionReader
deba@189
  2278
  inline SectionReader sectionReader(const std::string& fn) {
deba@189
  2279
    SectionReader tmp(fn);
deba@189
  2280
    return tmp;
deba@189
  2281
  }
deba@189
  2282
kpeter@192
  2283
  /// \brief Return a \ref SectionReader class
kpeter@192
  2284
  /// 
kpeter@192
  2285
  /// This function just returns a \ref SectionReader class.
deba@189
  2286
  /// \relates SectionReader
deba@189
  2287
  inline SectionReader sectionReader(const char* fn) {
deba@189
  2288
    SectionReader tmp(fn);
deba@189
  2289
    return tmp;
deba@189
  2290
  }
deba@189
  2291
deba@173
  2292
  /// \ingroup lemon_io
deba@173
  2293
  ///
alpar@179
  2294
  /// \brief Reader for the contents of the \ref lgf-format "LGF" file 
deba@173
  2295
  ///
deba@173
  2296
  /// This class can be used to read the sections, the map names and
deba@173
  2297
  /// the attributes from a file. Usually, the Lemon programs know
deba@173
  2298
  /// that, which type of graph, which maps and which attributes
deba@173
  2299
  /// should be read from a file, but in general tools (like glemon)
alpar@179
  2300
  /// the contents of an LGF file should be guessed somehow. This class
deba@173
  2301
  /// reads the graph and stores the appropriate information for
deba@173
  2302
  /// reading the graph.
deba@173
  2303
  ///
kpeter@192
  2304
  ///\code 
kpeter@192
  2305
  /// LgfContents contents("graph.lgf"); 
alpar@179
  2306
  /// contents.run();
deba@173
  2307
  ///
kpeter@192
  2308
  /// // Does it contain any node section and arc section?
alpar@179
  2309
  /// if (contents.nodeSectionNum() == 0 || contents.arcSectionNum()) {
kpeter@192
  2310
  ///   std::cerr << "Failure, cannot find graph." << std::endl;
deba@173
  2311
  ///   return -1;
deba@173
  2312
  /// }
kpeter@192
  2313
  /// std::cout << "The name of the default node section: " 
alpar@179
  2314
  ///           << contents.nodeSection(0) << std::endl;
kpeter@192
  2315
  /// std::cout << "The number of the arc maps: " 
alpar@179
  2316
  ///           << contents.arcMaps(0).size() << std::endl;
kpeter@192
  2317
  /// std::cout << "The name of second arc map: " 
alpar@179
  2318
  ///           << contents.arcMaps(0)[1] << std::endl;
deba@173
  2319
  ///\endcode
alpar@179
  2320
  class LgfContents {    
deba@173
  2321
  private:
deba@173
  2322
deba@173
  2323
    std::istream* _is;
deba@173
  2324
    bool local_is;
deba@173
  2325
deba@173
  2326
    std::vector<std::string> _node_sections;
deba@173
  2327
    std::vector<std::string> _edge_sections;
deba@173
  2328
    std::vector<std::string> _attribute_sections;
deba@173
  2329
    std::vector<std::string> _extra_sections;
deba@173
  2330
deba@173
  2331
    std::vector<bool> _arc_sections;
deba@173
  2332
deba@173
  2333
    std::vector<std::vector<std::string> > _node_maps;
deba@173
  2334
    std::vector<std::vector<std::string> > _edge_maps;
deba@173
  2335
deba@173
  2336
    std::vector<std::vector<std::string> > _attributes;
deba@173
  2337
deba@173
  2338
deba@173
  2339
    int line_num;
deba@173
  2340
    std::istringstream line;
deba@173
  2341
    
deba@173
  2342
  public:
deba@173
  2343
deba@173
  2344
    /// \brief Constructor
deba@173
  2345
    ///
alpar@179
  2346
    /// Construct an \e LGF contents reader, which reads from the given
deba@173
  2347
    /// input stream.
alpar@179
  2348
    LgfContents(std::istream& is) 
deba@173
  2349
      : _is(&is), local_is(false) {}
deba@173
  2350
deba@173
  2351
    /// \brief Constructor
deba@173
  2352
    ///
alpar@179
  2353
    /// Construct an \e LGF contents reader, which reads from the given
deba@173
  2354
    /// file.
alpar@179
  2355
    LgfContents(const std::string& fn) 
deba@173
  2356
      : _is(new std::ifstream(fn.c_str())), local_is(true) {}
deba@173
  2357
deba@173
  2358
    /// \brief Constructor
deba@173
  2359
    ///
alpar@179
  2360
    /// Construct an \e LGF contents reader, which reads from the given
deba@173
  2361
    /// file.
alpar@179
  2362
    LgfContents(const char* fn)
deba@173
  2363
      : _is(new std::ifstream(fn)), local_is(true) {}
deba@173
  2364
    
deba@173
  2365
    /// \brief Destructor
alpar@179
  2366
    ~LgfContents() {
deba@173
  2367
      if (local_is) delete _is;
deba@173
  2368
    }
deba@173
  2369
deba@190
  2370
  private:
deba@190
  2371
    
deba@190
  2372
    LgfContents(const LgfContents&);
deba@190
  2373
    LgfContents& operator=(const LgfContents&);
deba@190
  2374
deba@190
  2375
  public:
deba@190
  2376
deba@173
  2377
deba@173
  2378
    /// \name Node sections
deba@173
  2379
    /// @{
deba@173
  2380
deba@173
  2381
    /// \brief Gives back the number of node sections in the file.
deba@173
  2382
    ///
deba@173
  2383
    /// Gives back the number of node sections in the file.
deba@173
  2384
    int nodeSectionNum() const {
deba@173
  2385
      return _node_sections.size();
deba@173
  2386
    }
deba@173
  2387
kpeter@192
  2388
    /// \brief Returns the node section name at the given position. 
deba@173
  2389
    ///
kpeter@192
  2390
    /// Returns the node section name at the given position. 
deba@173
  2391
    const std::string& nodeSection(int i) const {
deba@173
  2392
      return _node_sections[i];
deba@173
  2393
    }
deba@173
  2394
deba@173
  2395
    /// \brief Gives back the node maps for the given section.
deba@173
  2396
    ///
deba@173
  2397
    /// Gives back the node maps for the given section.
alpar@182
  2398
    const std::vector<std::string>& nodeMapNames(int i) const {
deba@173
  2399
      return _node_maps[i];
deba@173
  2400
    }
deba@173
  2401
deba@173
  2402
    /// @}
deba@173
  2403
alpar@181
  2404
    /// \name Arc/Edge sections 
deba@173
  2405
    /// @{
deba@173
  2406
alpar@181
  2407
    /// \brief Gives back the number of arc/edge sections in the file.
deba@173
  2408
    ///
alpar@181
  2409
    /// Gives back the number of arc/edge sections in the file.
alpar@181
  2410
    /// \note It is synonym of \c edgeSectionNum().
deba@173
  2411
    int arcSectionNum() const {
deba@173
  2412
      return _edge_sections.size();
deba@173
  2413
    }
deba@173
  2414
kpeter@192
  2415
    /// \brief Returns the arc/edge section name at the given position. 
deba@173
  2416
    ///
kpeter@192
  2417
    /// Returns the arc/edge section name at the given position. 
alpar@181
  2418
    /// \note It is synonym of \c edgeSection().
deba@173
  2419
    const std::string& arcSection(int i) const {
deba@173
  2420
      return _edge_sections[i];
deba@173
  2421
    }
deba@173
  2422
alpar@181
  2423
    /// \brief Gives back the arc/edge maps for the given section.
deba@173
  2424
    ///
alpar@181
  2425
    /// Gives back the arc/edge maps for the given section.
alpar@182
  2426
    /// \note It is synonym of \c edgeMapNames().
alpar@182
  2427
    const std::vector<std::string>& arcMapNames(int i) const {
deba@173
  2428
      return _edge_maps[i];
deba@173
  2429
    }
deba@173
  2430
deba@173
  2431
    /// @}
deba@173
  2432
alpar@181
  2433
    /// \name Synonyms
deba@173
  2434
    /// @{
deba@173
  2435
alpar@181
  2436
    /// \brief Gives back the number of arc/edge sections in the file.
deba@173
  2437
    ///
alpar@181
  2438
    /// Gives back the number of arc/edge sections in the file.
alpar@181
  2439
    /// \note It is synonym of \c arcSectionNum().
deba@173
  2440
    int edgeSectionNum() const {
deba@173
  2441
      return _edge_sections.size();
deba@173
  2442
    }
deba@173
  2443
deba@173
  2444
    /// \brief Returns the section name at the given position. 
deba@173
  2445
    ///
deba@173
  2446
    /// Returns the section name at the given position. 
alpar@181
  2447
    /// \note It is synonym of \c arcSection().
deba@173
  2448
    const std::string& edgeSection(int i) const {
deba@173
  2449
      return _edge_sections[i];
deba@173
  2450
    }
deba@173
  2451
deba@173
  2452
    /// \brief Gives back the edge maps for the given section.
deba@173
  2453
    ///
deba@173
  2454
    /// Gives back the edge maps for the given section.
alpar@182
  2455
    /// \note It is synonym of \c arcMapNames().
alpar@182
  2456
    const std::vector<std::string>& edgeMapNames(int i) const {
deba@173
  2457
      return _edge_maps[i];
deba@173
  2458
    }
deba@173
  2459
deba@173
  2460
    /// @}
deba@173
  2461
deba@173
  2462
    /// \name Attribute sections   
deba@173
  2463
    /// @{
deba@173
  2464
deba@173
  2465
    /// \brief Gives back the number of attribute sections in the file.
deba@173
  2466
    ///
deba@173
  2467
    /// Gives back the number of attribute sections in the file.
deba@173
  2468
    int attributeSectionNum() const {
deba@173
  2469
      return _attribute_sections.size();
deba@173
  2470
    }
deba@173
  2471
kpeter@192
  2472
    /// \brief Returns the attribute section name at the given position. 
deba@173
  2473
    ///
kpeter@192
  2474
    /// Returns the attribute section name at the given position. 
alpar@182
  2475
    const std::string& attributeSectionNames(int i) const {
deba@173
  2476
      return _attribute_sections[i];
deba@173
  2477
    }
deba@173
  2478
deba@173
  2479
    /// \brief Gives back the attributes for the given section.
deba@173
  2480
    ///
deba@173
  2481
    /// Gives back the attributes for the given section.
deba@173
  2482
    const std::vector<std::string>& attributes(int i) const {
deba@173
  2483
      return _attributes[i];
deba@173
  2484
    }
deba@173
  2485
deba@173
  2486
    /// @}
deba@173
  2487
deba@173
  2488
    /// \name Extra sections   
deba@173
  2489
    /// @{
deba@173
  2490
deba@173
  2491
    /// \brief Gives back the number of extra sections in the file.
deba@173
  2492
    ///
deba@173
  2493
    /// Gives back the number of extra sections in the file.
deba@173
  2494
    int extraSectionNum() const {
deba@173
  2495
      return _extra_sections.size();
deba@173
  2496
    }
deba@173
  2497
deba@173
  2498
    /// \brief Returns the extra section type at the given position. 
deba@173
  2499
    ///
deba@173
  2500
    /// Returns the section type at the given position. 
deba@173
  2501
    const std::string& extraSection(int i) const {
deba@173
  2502
      return _extra_sections[i];
deba@173
  2503
    }
deba@173
  2504
deba@173
  2505
    /// @}
deba@173
  2506
deba@173
  2507
  private:
deba@173
  2508
deba@173
  2509
    bool readLine() {
deba@173
  2510
      std::string str;
deba@173
  2511
      while(++line_num, std::getline(*_is, str)) {
deba@173
  2512
	line.clear(); line.str(str);
deba@173
  2513
	char c;
deba@173
  2514
	if (line >> std::ws >> c && c != '#') {
deba@173
  2515
	  line.putback(c);
deba@173
  2516
	  return true;
deba@173
  2517
	}
deba@173
  2518
      }
deba@173
  2519
      return false;
deba@173
  2520
    }
deba@173
  2521
deba@173
  2522
    bool readSuccess() {
deba@173
  2523
      return static_cast<bool>(*_is);
deba@173
  2524
    }
deba@173
  2525
deba@173
  2526
    void skipSection() {
deba@173
  2527
      char c;
deba@173
  2528
      while (readSuccess() && line >> c && c != '@') {
deba@173
  2529
	readLine();
deba@173
  2530
      }
deba@173
  2531
      line.putback(c);
deba@173
  2532
    }
deba@173
  2533
deba@173
  2534
    void readMaps(std::vector<std::string>& maps) {
deba@186
  2535
      char c;
deba@186
  2536
      if (!readLine() || !(line >> c) || c == '@') {
deba@186
  2537
	if (readSuccess() && line) line.putback(c);
deba@186
  2538
	return;
deba@186
  2539
      }
deba@186
  2540
      line.putback(c);
deba@173
  2541
      std::string map;
deba@173
  2542
      while (_reader_bits::readToken(line, map)) {
deba@173
  2543
	maps.push_back(map);
deba@173
  2544
      }
deba@173
  2545
    }
deba@173
  2546
deba@173
  2547
    void readAttributes(std::vector<std::string>& attrs) {
deba@173
  2548
      readLine();
deba@173
  2549
      char c;
deba@173
  2550
      while (readSuccess() && line >> c && c != '@') {
deba@173
  2551
	line.putback(c);
deba@173
  2552
	std::string attr;
deba@173
  2553
	_reader_bits::readToken(line, attr);
deba@173
  2554
	attrs.push_back(attr);
deba@173
  2555
	readLine();
deba@173
  2556
      }
deba@173
  2557
      line.putback(c);
deba@173
  2558
    }
deba@173
  2559
deba@173
  2560
  public:
deba@173
  2561
alpar@179
  2562
    /// \name Execution of the contents reader    
deba@173
  2563
    /// @{
deba@173
  2564
kpeter@192
  2565
    /// \brief Starts the reading
deba@173
  2566
    ///
kpeter@192
  2567
    /// This function starts the reading.
deba@173
  2568
    void run() {
deba@173
  2569
deba@173
  2570
      readLine();
deba@173
  2571
      skipSection();
deba@173
  2572
deba@173
  2573
      while (readSuccess()) {
deba@173
  2574
deba@173
  2575
	char c;
deba@173
  2576
	line >> c;
deba@173
  2577
deba@173
  2578
	std::string section, caption;
deba@173
  2579
	_reader_bits::readToken(line, section);
deba@173
  2580
	_reader_bits::readToken(line, caption);
deba@173
  2581
deba@173
  2582
	if (section == "nodes") {
deba@173
  2583
	  _node_sections.push_back(caption);
deba@173
  2584
	  _node_maps.push_back(std::vector<std::string>());
deba@173
  2585
	  readMaps(_node_maps.back());
deba@173
  2586
	  readLine(); skipSection();
deba@173
  2587
	} else if (section == "arcs" || section == "edges") {
deba@173
  2588
	  _edge_sections.push_back(caption);
deba@173
  2589
	  _arc_sections.push_back(section == "arcs");
deba@173
  2590
	  _edge_maps.push_back(std::vector<std::string>());
deba@173
  2591
	  readMaps(_edge_maps.back());
deba@173
  2592
	  readLine(); skipSection();
deba@173
  2593
	} else if (section == "attributes") {
deba@173
  2594
	  _attribute_sections.push_back(caption);
deba@173
  2595
	  _attributes.push_back(std::vector<std::string>());
deba@173
  2596
	  readAttributes(_attributes.back());
deba@173
  2597
	} else {
deba@173
  2598
	  _extra_sections.push_back(section);
deba@173
  2599
	  readLine(); skipSection();
deba@173
  2600
	}
deba@173
  2601
      }
deba@173
  2602
    }
deba@173
  2603
deba@173
  2604
    /// @}
deba@173
  2605
    
deba@173
  2606
  };
deba@127
  2607
}
deba@127
  2608
deba@127
  2609
#endif