Se agrega la carátula.

[z.facultad/75.42/string.git] / universalstring.h

diff --git a/universalstring.h b/universalstring.h
index 4ec4d56b412f9b604e69182bc17c3944cc116d94..fe740e86bbdb017d04bc20cfd294776a132b8543 100644 (file)
--- a/universalstring.h
+++ b/universalstring.h
@@ -9,7 +9,7 @@
  * Puede copiar, modificar y distribuir este programa bajo los términos de
  * la licencia GPL (http://www.gnu.org/).
  *
- * Creado: Mon Sep 22 21:00:15 ART 2003
+ * Creado: sáb sep 27 15:38:29 ART 2003
  *
  * $Id$
  */
@@ -21,17 +21,18 @@
 #include <istream>
 #include <iterator>
 #include <vector>
+#include <cctype>
 
 #ifdef DEBUG
 #   include <iostream>
 #endif
 
 /// String Universal.
-template <class T>
+template < class T >
 class UniversalString {
 
         /// Cadena de caracteres.
-        std::vector<T> string;
+        std::vector< T > string;
 
     public:
 
@@ -45,23 +46,37 @@ class UniversalString {
         /// Constructor a partir de un string C.
         UniversalString(const char* str) {
 #ifdef DEBUG
-            std::cerr << "En constructor de UniversalString a partir de string C."
+            std::cerr << "En constructor de UniversalString desde string C."
                 << std::endl;
 #endif
             int len = strlen(str);
+            // Limpio cadena de caracteres anterior.
             string.clear();
+            // Reservo nuevo espacio.
             string.reserve(len);
+            // Agrego cada caracter.
             for (int i = 0; i < len; i++) {
                 string.push_back(str[i]);
             }
         }
 
+        /// Constructor a partir de otro UniversalString.
+        template < class T2 >
+        UniversalString(const UniversalString< T2 >& str) {
+#ifdef DEBUG
+            std::cerr << "En constructor de UniversalString a partir de otro."
+                << std::endl;
+#endif
+            *this = str;
+        }
+
         /// Constructor de copia.
         UniversalString(const UniversalString& str) {
 #ifdef DEBUG
             std::cerr << "En constructor de copia de UniversalString."
                 << std::endl;
 #endif
+            string = str.string;
         }
 
         /// Destructor.
@@ -76,10 +91,31 @@ class UniversalString {
 #ifdef DEBUG
             std::cerr << "En operator= de UniversalString." << std::endl;
 #endif
+            // Asigno la cadena de caracteres del string str.
             string = str.string;
             return *this;
         }
 
+        /// Asignación de una instancia a otra de distinto tipo.
+        template < class T2 >
+        UniversalString& operator=(const UniversalString< T2 >& str) {
+#ifdef DEBUG
+            std::cerr << "En operator= de UniversalString de tipos distintos."
+                << std::endl;
+#endif
+            // Obtengo un vector con los caracteres del string str.
+            std::vector< T2 > v = str.to_vector();
+            // Limpio mi cadena de caracteres.
+            string.clear();
+            // Reservo el nuevo espacio para mi cadena.
+            string.reserve(v.size());
+            // Voy agregando caracter a caracter.
+            for (size_t i = 0; i < v.size(); i++) {
+                string.push_back(T(v[i]));
+            }
+            return *this;
+        }
+
         /// Comparación por menor de dos instancias.
         bool operator<(const UniversalString& str) {
 #ifdef DEBUG
@@ -96,37 +132,41 @@ class UniversalString {
             return string == str.string;
         }
 
-        /// Cast a string C.
-        //operator char*(void);
+        /// Devuelve un vector de caracteres T.
+        std::vector< T > to_vector(void) const {
+            return string;
+        }
 
         /// Volcado a un stream de salida.
         friend std::ostream& operator<<(std::ostream& out,
-                const UniversalString<T>& str) {
+                const UniversalString< T >& str) {
 #ifdef DEBUG
             std::cerr << "En operator<< de UniversalString." << std::endl;
 #endif
             // Copio el vector de caracteres al stream de salida.
             std::copy(str.string.begin(), str.string.end(),
-                    std::ostream_iterator<T>(out, ""));
+                    std::ostream_iterator< T >(out, ""));
             return out;
         }
 
         /// Captura desde un stream de entrada.
         friend std::istream& operator>>(std::istream& in,
-                UniversalString<T>& str) {
+                UniversalString< T >& str) {
 #ifdef DEBUG
             std::cerr << "En operator>> de UniversalString." << std::endl;
 #endif
             // Limpio la cadena actual.
             str.string.clear();
-            T c;
             // Obtengo primer caracter, incluyendo espacios.
+            T c;
             in >> std::noskipws >> c;
-            // Mientras que no sea el fin de línea, sigo leyendo caracteres.
-            while (!c.is_endl()) {
+            // Mientras que no sea un fin de línea, sigo leyendo caracteres.
+            while (c != '\n') {
                 str.string.push_back(c);
                 in >> std::noskipws >> c;
             }
+            // Vuelvo a setear que ignore espacios.
+            in >> std::skipws;
             return in;
         }