source: lemon-0.x/src/work/deba/graph_reader.h @ 1032:9e903d3a1ef6

/* -*- C++ -*-
 * src/lemon/graph_reader.h - Part of LEMON, a generic C++ optimization library
 *
 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Combinatorial Optimization Research Group, EGRES).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,
 * express or implied, and with no claim as to its suitability for any
 * purpose.
 *
 */

///\ingroup gio
///\file
///\brief Map utilities.

#include <iostream>
#include <sstream>

#include <map>
#include <vector>

#include <lemon/error.h>

/// \todo fix exceptions


namespace lemon {
  
  struct DefaultReaderTraits {

    template <typename _Value>
    struct Reader {
      typedef _Value Value;
      void read(std::istream& is, Value& value) {
        is >> value;
      }
    };

    template <typename _Value>
    struct Skipper {
      typedef _Value Value;
      void read(std::istream& is) {
        Value tmp;
        is >> tmp;
      }      
    };

    struct DefaultSkipper {
      void read(std::istream& is) {
        std::string tmp;
        is >> tmp;
      }
    };
  };

  class IOException {
    virtual string message() = 0;
  };

  class FileReaderException {
    virtual int getLine() = 0;    
  };

  
  
  template <typename _Graph, typename _ReaderTraits = DefaultReaderTraits> 
  class GraphReader {

  public:
    
    typedef _Graph Graph;
    typedef typename Graph::Node Node;
    typedef typename Graph::Edge Edge;

    typedef _ReaderTraits ReaderTraits;
    

    GraphReader(std::istream& _is, Graph& _graph) : is(_is), graph(_graph) {}

    template <typename Map>
    GraphReader& readNodeMap(std::string name, Map& map, 
                             const typename ReaderTraits::template Reader<typename Map::Value>& reader =
                             typename ReaderTraits::template Reader<typename Map::Value>()) {
      return readNodeMap<Map, typename ReaderTraits::template Reader<typename Map::Value> >(name, map, reader);
    }

    template <typename Map, typename Reader>
    GraphReader& readNodeMap(std::string name, Map& map, const Reader& reader = Reader()) {
      node_readers.insert(make_pair(name, new MapReader<Node, Map, Reader>(map, reader)));
      return *this;
    }

    template <typename Map>
    GraphReader& readEdgeMap(std::string name, Map& map, 
                             const typename ReaderTraits::template Reader<typename Map::Value>& reader =
                             typename ReaderTraits::template Reader<typename Map::Value>()) {
      return readEdgeMap<Map, typename ReaderTraits::template Reader<typename Map::Value> >(name, map, reader);
    }

    template <typename Map, typename Reader>
    GraphReader& readEdgeMap(std::string name, Map& map, const Reader& reader = Reader()) {
      edge_readers.insert(make_pair(name, new MapReader<Edge, Map, Reader>(map, reader)));
      return *this;
    }

    void read() {
      int line_num = 0;
      readNodeSet(line_num);
      readEdgeSet(line_num);
      {
        std::string line = readNotEmptyLine(is, line_num);
      }
    }

  private:

    void readNodeSet(int& line_num) {
      int n = 0;
      {
        std::string line = readNotEmptyLine(is, line_num);      
      }
      std::vector<MapReaderBase<Node>*> index;
      {
        std::string line = readNotEmptyLine(is, line_num);    
        std::string id;
        std::istringstream ls(line);    
        while (ls >> id) {
          typename map<std::string, MapReaderBase<Node>* >::iterator it = node_readers.find(id);
          if (it != node_readers.end()) {
            index.push_back(it->second);
          } else {
            index.push_back(0);
          }
          ++n;
        }
      }
      std::string line;
      while (line = readNotEmptyLine(is, line_num), line[0] != '@') {
        Node node = graph.addNode();
        std::istringstream ls(line);
        for (int i = 0; i < n; ++i) {
          if (index[i] != 0) {      
            index[i]->read(ls, node);
          } else {
            default_skipper.read(ls);
          }
        }
      }
    }

    void readEdgeSet(int& line_num) {
      
    }

    std::string readNotEmptyLine(std::istream& is, int& line_num) {
      std::string line;
      while (++line_num, getline(is, line)) {   
        int vi = line.find_first_not_of(" \t");
        if (vi != string::npos && line[vi] != '#') {
          return line.substr(vi);
        }
      }
      throw Exception();
    }
    
    istream& is;
    Graph& graph;

    typename ReaderTraits::DefaultSkipper default_skipper;

    template <typename _Item>    
    class MapReaderBase {
    public:
      typedef _Item Item;
      virtual void read(istream& is, const Item& item) = 0;
    };
    
    template <typename _Item, typename _Map, typename _Reader>
    class MapReader : public MapReaderBase<_Item> {
    public:
      typedef _Map Map;
      typedef _Reader Reader;
      typedef _Item Item;
      
      Map& map;
      Reader reader;

      MapReader(Map& _map, const Reader& _reader) 
        : map(_map), reader(_reader) {}


      virtual void read(istream& is, const Item& item) {
        typename Reader::Value value;
        reader.read(is, value);
        map.set(item, value);
      }
    };

    typedef std::map<std::string, MapReaderBase<Node>* > NodeReaders;
    NodeReaders node_readers;

    typedef std::map<std::string, MapReaderBase<Edge>* > EdgeReaders;
    EdgeReaders edge_readers;

  };

}