src/parser.cpp

   1 #include "parser.h"
   2 #include <string>
   3 #include <cassert>
   4 #include <sstream>
   5 #include <fstream>
   6 #include <iostream>
   7 #include <algorithm>
   8
   9 Parser::
  10 Parser(Susanita& s):
  11         susanita(s)
  12 {
  13 }
  14
  15 // Para no exportar los símbolos (uso interno de este módulo)
  16 namespace
  17 {
  18         /// Saca espacios de una palabra
  19         std::string strip(std::string s) {
  20                 std::string ws = " \t\n";
  21                 int first = s.find_first_not_of(ws);
  22                 int last = s.find_last_not_of(ws);
  23
  24                 if (first == -1) {
  25                         int pos_first = s.find_first_of(ws);
  26                         if (pos_first == -1) {
  27                                 return s;
  28                         } else {
  29                                 return std::string("");
  30                         }
  31                 }
  32                 return s.substr(first,last-first+1).c_str();
  33         }
  34
  35         /// Devuelve palabra hasta el caracter indicado
  36         std::string get_hasta(std::istream& is, char hasta)
  37         {
  38                 std::string s;
  39                 std::getline(is, s, hasta);
  40                 return strip(s);
  41         }
  42 }
  43
  44 bool
  45 Parser::
  46 input(const std::string& filename)
  47 {
  48         std::ifstream f(filename.c_str());
  49         if (!f)
  50                 return false;
  51         Persona::sexo_type sexo = Persona::M;
  52         Persona::sexo_type opuesto = Persona::F;
  53         std::string l;
  54         while (std::getline(f, l))
  55         {
  56                 l = strip(l);
  57                 // la linea vacia alterna de sexo
  58                 if (l.empty())
  59                 {
  60                         sexo = Persona::F;
  61                         opuesto = Persona::M;
  62                         continue;
  63                 }
  64
  65                 // obtenemos el nombre y la lista
  66                 std::istringstream ss(l);
  67                 std::string nombre = get_hasta(ss, ':');
  68                 Persona* pp = susanita.get_persona(nombre);
  69                 if (!pp)
  70                 {
  71                         pp = new Persona(nombre, sexo);
  72                         susanita.add_persona(pp);
  73                 }
  74
  75                 Persona::prefs_type prefs;
  76                 while (ss)
  77                 {
  78                         std::string nombre = get_hasta(ss, ',');
  79                         nombre = strip(nombre);
  80                         if (nombre.empty()) {
  81                                 continue;
  82                         }
  83                         Persona* ppp = susanita.get_persona(nombre);
  84                         if (!ppp)
  85                         {
  86                                 ppp = new Persona(nombre, opuesto);
  87                                 susanita.add_persona(ppp);
  88                         }
  89                         pp->prefs.push_back(ppp);
  90                 }
  91         }
  92         return true;
  93 }
  94
  95 void
  96 Parser::
  97 output() const
  98 {
  99         for (Susanita::personas_type::const_iterator ih
 100                         = susanita.hombres.begin();
 101                         ih != susanita.hombres.end(); ++ih)
 102         {
 103                 Persona& h = **ih;
 104                 assert(h.estado == Persona::COMPROMETIDO);
 105                 std::cout << h.nombre << ", " << h.pareja->nombre << "\n";
 106         }
 107         std::cout << "\n";
 108         for (Susanita::personas_type::const_iterator im
 109                         = susanita.mujeres.begin();
 110                         im != susanita.mujeres.end(); ++im)
 111         {
 112                 Persona& m = **im;
 113                 assert(m.estado == Persona::COMPROMETIDO);
 114                 std::cout << m.nombre << ", " << m.pareja->nombre << "\n";
 115         }
 116 }
 117