#ifndef __LECTURE_H__
#define __LECTURE_H__

#include <vector>
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>

//#define __DUMP_LECTURE__

namespace instanceNs {

    extern std::ifstream input_stream ;

    template<typename TYPE>
            TYPE lire_valeur(std::string nom) {
        std::string token ;
        input_stream >> token ;
        if (token!=nom) throw std::string("Entrée invalide : ")+token+" : "+nom+" attendu.";
        TYPE valeur ;
        instanceNs::input_stream >> valeur ;
#ifdef __DUMP_LECTURE__
        std::cerr << nom << "\t" << valeur << std::endl;
#endif
        return valeur ;
            }

    template<typename TYPE>
    void lire_intervalle(std::string nom, TYPE & start, TYPE & end) {
        std::string token ;
        input_stream >> token ;
        if (token!=nom) throw std::string("Entrée invalide : ")+token+" : "+nom+" attendu.";
        int valeur1, valeur2 ;
        instanceNs::input_stream >> valeur1 ;
        instanceNs::input_stream >> valeur2 ;
        start    = (TYPE) valeur1 ;
        end      = (TYPE) valeur2 ;
#ifdef __DUMP_LECTURE__
        std::cerr << nom << "\t" << valeur1 << "\t" << valeur2 << std::endl;
#endif
    }

    template<typename TYPE>
    std::vector<TYPE> lire_liste(std::string nom, size_t debut, size_t fin)
    {
        std::string token ;
        instanceNs::input_stream >> token ;
        if (token!=nom) throw std::string("Entrée invalide : ")+token+" : "+nom+" attendu.";
        std::vector<TYPE> liste(fin+1) ;
        for (size_t i=debut; i<=fin; i++)
        {
            instanceNs::input_stream >> liste[i] ;
        }
    #ifdef __DUMP_LECTURE__
        std::cerr << nom ;
        for (int i=debut; i<=fin; i++)
        {
            std::cerr << "\t" << liste[i] ;
        }
        std::cerr << std::endl ;
    #endif
        return liste ;
    }


    template<typename TYPE>
    void lire_valeur(std::string nom, TYPE & valeur) {
        std::string token ;
        input_stream >> token ;
        if (token!=nom) throw std::string("Entrée invalide : ")+token+" : "+nom+" attendu.";
        instanceNs::input_stream >> valeur ;
#ifdef __DUMP_LECTURE__
        std::cerr << nom << "\t" << valeur << std::endl;
#endif
        return valeur ;
    }


    template<typename TYPE>
    void lire_liste(std::string nom, std::vector<TYPE> & liste)
    {
        std::string token ;
        instanceNs::input_stream >> token ;
        if (token!=nom) throw std::string("Entrée invalide : ")+token+" : "+nom+" attendu.";
#ifdef __DUMP_LECTURE__
        std::cerr << nom ;
#endif
        for (typename std::vector<TYPE>::iterator it=liste.begin(); it!=liste.end(); it++)
        {
            instanceNs::input_stream >> *it ;
#ifdef __DUMP_LECTURE__
            std::cerr << "\t" << *it ;
#endif
        }
#ifdef __DUMP_LECTURE__
        std::cerr << std::endl ;
#endif
    }

    template<typename TYPE>
    std::vector<TYPE> lire_liste(std::string nom)
    {
        std::string token ;
        instanceNs::input_stream >> token ;
        if (token!=nom) throw std::string("Entrée invalide : ")+token+" : "+nom+" attendu.";
        std::vector<TYPE> liste;
        std::string ligne ;
        getline( instanceNs::input_stream, ligne ) ;
        std::stringstream stream( ligne );
        while ( !stream.eof() )
        {
            int valeur ;
            stream >> valeur ;
            //if ( stream.eof() ) break ;
            liste.push_back( (TYPE) valeur ) ;
        }
#ifdef __DUMP_LECTURE__
        std::cerr << nom ;
        for ( typename std::vector<TYPE>::iterator it=liste.begin(); it!=liste.end(); it++)
        {
            std::cerr << "\t" << *it ;
        }
        std::cerr << std::endl ;
#endif
        return liste ;
    }
}

#endif