Agrega un modo de salida intentando que sea más fácil generar tablas con la evolución...

[z.facultad/75.68/celdas.git] / trunk / src / indicemagico.h

diff --git a/trunk/src/indicemagico.h b/trunk/src/indicemagico.h
index 4c3396e6769dc9ef179b9dd4fae9ae9507744d52..9ad336e62dc778bf41da49109f8775624539f8cd 100644 (file)
--- a/trunk/src/indicemagico.h
+++ b/trunk/src/indicemagico.h
@@ -8,57 +8,48 @@
 
 
 #include <string>
-#include <map>
-#include <iostream>
+#include <vector>
+#include <ostream>
+#include <iostream> // FIXME
 
 
 template <class T>
 class CIndiceMagico
 {
 public:
-       std::string*    m_nombres ;
-       T*                              m_datos ;
-       unsigned                m_cant ;
+       std::vector< std::string >                      m_nombres ;
+       std::vector< T >                                m_datos ;
+       typedef typename std::vector< T >::iterator     iterator;
 
 public:
-       CIndiceMagico() 
-       { 
-               m_cant = 0 ; 
-               m_nombres = (std::string*)calloc(sizeof(std::string), MAX_ELEMENTOS) ;
-               m_datos = (T*)calloc(sizeof(m_datos), MAX_ELEMENTOS) ;
 
+       iterator begin() { return m_datos.begin(); }
 
-               if (!m_nombres)
-                       std::cerr << "No se pudo allocar el arreglo CIndiceMagico::m_nombres.\n";
+       iterator end() { return m_datos.end(); }
 
-               if (!m_datos)
-                       std::cerr << "No se pudo allocar el arreglo CIndiceMagico::m_datos.\n";
-
-       }
-
-public:
-       void add(const char* nombre, const T dato)
+       void add(const std::string& nombre, const T& dato)
        {
                //Si ya existía, lo borro
                if (exist(nombre))
                        remove(nombre) ;
 
-
-               m_nombres[m_cant] = nombre ;
-               m_datos[m_cant++] = dato ;
+               m_nombres.push_back(nombre);
+               m_datos.push_back(dato);
        }
 
 
        void add(CIndiceMagico<T>& indice)
        {
-               for (unsigned i=0; i<indice.m_cant; i++)
-                       add(indice.m_nombres[i].c_str(), indice.m_datos[i]) ;
+               for (unsigned i = 0; i < indice.m_nombres.size(); ++i)
+               {
+                       add(indice.m_nombres[i], indice.m_datos[i]) ;
+               }
        }
 
 
-       bool exist(const char* nombre)
+       bool exist(const std::string& nombre)
        {
-               for (unsigned i=0; i<m_cant; i++)
+               for (unsigned i = 0; i < m_nombres.size(); ++i)
                        if (m_nombres[i]==nombre)
                                return true ;
 
@@ -67,60 +58,97 @@ public:
 
        //PRE: Existe un elemento con la clave <nombre>.
        //POS: Retorna el elemento.
-       T& find(const char* nombre)
+       T& find(const std::string& nombre)
        {
                unsigned i;
-               for (i=0; i<m_cant && m_nombres[i]!=nombre; i++) ;
-               return m_datos[i] ;
+               for (i = 0; i < m_nombres.size() && m_nombres[i] != nombre; ++i);
+               return m_datos[i];
        }
 
 
-       void set_val(const std::string nombre, T valor)
+       void set_val(const std::string& nombre, const T& valor)
        {
-               for (unsigned i=0; i<m_cant; i++)
-                       if (m_datos[i]!=valor)
-                               m_datos[i] ;
+               for (unsigned i = 0; i < m_nombres.size(); ++i)
+               {
+                       if (m_nombres[i] == nombre)
+                       {
+                               m_datos[i] = valor;
+                               return;
+                       }
+               }
+               add(nombre, valor);
        }
 
 
        void clear()
        {
-               m_cant = 0 ;
+               m_nombres.clear();
+               m_datos.clear();
        }
 
-       void remove(const unsigned long index)
+       void remove(unsigned long index)
        {
-               for (unsigned i=index+1u; i<m_cant; i++)
-               {
-                       m_nombres[i-1] = m_nombres[i] ; 
-                       m_datos[i-1] = m_datos[i] ; 
-               }
-
-               m_cant-- ;
+               m_nombres.erase(m_nombres.begin() + index);
+               m_datos.erase(m_datos.begin() + index);
        }
 
-       void remove(const char* nombre)
+       void remove(const std::string& nombre)
        {
-               bool exito = false ;
-               unsigned i;
-
-               for (i=0; !exito && i<m_cant; i++)
-                       exito = m_nombres[i]==nombre ;
-
-               if (exito)
-                       remove(i) ;
+               for (unsigned i = 0; i < m_nombres.size(); ++i)
+                       if (m_nombres[i]==nombre)
+                       {
+                               remove(i);
+                               return;
+                       }
        }
 
+
        T& operator [] (unsigned i) { return m_datos[i]; }
 
        T& items (unsigned i) { return m_datos[i]; }
 
-       char* keys (unsigned i) const { return (char*)(m_nombres[i].c_str()); }
-
-       unsigned count() { return m_cant ; }
+       std::string keys (unsigned i) const { return m_nombres[i]; }
 
-} ;
+       unsigned count() { return m_nombres.size(); }
 
+};
 
+template < typename T >
+inline
+std::ostream& operator<< (std::ostream& os, CIndiceMagico<T>& im)
+{
+       unsigned c = im.count();
+#ifdef LOG
+       if (c-- == 0) return os << "";
+       for (unsigned i = 0; i < c; ++i)
+               os << im[i] << ",";
+       os << im[c];
+       return os;
+#else // ! LOG
+       if (c == 0) return os << "\t\tvacío\n";
+       for (unsigned i = 0; i < c; ++i)
+               os << "\t\t" << im.keys(i) << ":\t" << im[i] << "\n";
+       return os;
+#endif // LOG
+}
+
+template < typename T >
+inline
+std::ostream& operator<< (std::ostream& os, CIndiceMagico<T*>& im)
+{
+       unsigned c = im.count();
+#ifdef LOG
+       if (c-- == 0) return os << "";
+       for (unsigned i = 0; i < c; ++i)
+               os << *im[i] << ",";
+       os << *im[c];
+       return os;
+#else // ! LOG
+       if (c == 0) return os << "\t\tvacío\n";
+       for (unsigned i = 0; i < c; ++i)
+               os << "\t\t" << im.keys(i) << ":\t" << *im[i] << "\n";
+       return os;
+#endif // LOG
+}
 
 #endif