#include <iostream>
#include <string>

/// Beolvaso osztaly terve:

// beolvaso es wrappelo bazis osztaly
class MapReader {
public:
  virtual void read(typename Map::Key& key, istream& is) = 0;
};

// a default beolvaso osztaly egy maphez
// elboldogul olyan mappel is, amelyben valamilyen specialis tipus van
template <typename _Map>
class DefaultReader : public MapReader {
public:
  typedef _Map Map;

  DefaultReader(Map& _map) : map(_map) {}

  virtual void read(typename Map::Key& key, istream& is) {
    typename Map::Value val;
    is >> val;
    map.set(key, val);
  }
private:
  Map& map;
};

// egy adott tipusu elemet beolvas, de nem irja mapbe
template <typename _Type>
class SkipReader : public MapReader {
public:

  virtual void read(typename Map::Key&, istream& is) {
    _Type val;
    is >> val;
  }
};

// majd olyan stringeket lehet olvasni, ami idezojelek kozott van
template <typename _Map>
class QuotedStringReader {
public:
  typedef _Map Map;

  QuotedStringReader(Map& _map) : map(_map) {}

  virtual void read(typename Map::Key&, istream& is) {
    char c;
    is >> c;
  }
  
};


// a beolvaso
template <typename _Graph, template <typename> class _SkipReader = SkipReader<std::string> >
class GraphReader {

  GraphReader(istream& _is) : is(_is) {}

  template <typename _Map, typename _Reader = DefaultReader<_Map> >
  void readMap(std::string& name, _Map& _map) {
    readers.push_back(_Reader(_map));
  }

  template <_Type, typename _Reader = SkipReader<_Map> >
  void skipMap(std::string& name) {
    readers.push_back(_Reader());
  }

  void read() {    
    ...
    vector<int> index;
    // egy sor olvasasa
    for (int i = 0; i < index.size(); ++i) {
      if (index[i] != -1) {
	readers[index[i]].read(item, is);
      } else {
	_SkipReader().read(item, is);
      }
    }
    ...
  }


private:
  istream& is;
  vector<MapReader> readers;
};

// Ennek az implementacionak az elonye:
//  - altalanosabban mukodik a beolvasas
//  - konnyebb specialis beolvasasokat megvalositani
//  - ugyanolyan tipusu maphez ket kulonbozo beolvasasi modszert is alkalmazhatunk
//  - Megengedi, whitespace-t tartalmazo stringek beolvasasat is (?)

// Hatranya
//  - Ha whitespace-t hasznalunk egy mapben, de nem olvassuk ki, akkor meg kell
//    hivni a skipMap fuggvenyt az aktualis tipussal /a ws-eket ezt ellenjavalhatjuk a doksiban/

// Fejlesztesi lehetoseg:
// A GraphReader osztalynak nem a SkipReader lenne a parametere, hanem a kovetkezo tipusu osztaly:

class TypeReaderTraits {
public:
  class DefaultSkipReader {
    ...
  };

  template <typename Map>
  class MapReader {
    ...
  };

  template <typename Type>
  class SkipReader {
    ...
  };
};

// Ezt le lehetne cserelni peldaul DelimetedReaderTraits-re cserelni, amivel be lehetne spacekkel, vagy
// mas elvalasztojelekkel generalt file-t olvasni.  

// Kerdes
// Ugy ertelmeztem, hogy fontos az hogy kozos beolvaso interface legyen a kulonbozo
// tipusu beolvasasokhoz/file, adatbazis.../.
// Szerintem ez annyira nem fontos, mivel sem szarmaztatott viszonyban nem allnak
// a beolvaso interfacek, es annak sem latom ertelmet, hogy template parameter legyen
// a beolvaso osztaly. 
// Ezert szerintem nem kell kozos interfacce!
//
// Azonban celszeru kozel azonos szintaktikat kialakitani a beolvasokhoz,
// hogy egyszeru legyen hasznalni.