#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.