From 18dabcacb51313294c968b9a9217674666b4bbf9 Mon Sep 17 00:00:00 2001
From: Leandro Lucarella <llucax@gmail.com>
Date: Sun, 28 Sep 2003 05:46:10 +0000
Subject: [PATCH 1/1] =?utf8?q?Compila=20el=20UniveralString=20pero=20est?=
 =?utf8?q?=C3=A1=20incompleto.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=utf8
Content-Transfer-Encoding: 8bit

---
 universalstring.cpp | 83 ++++---------------------------------------
 universalstring.h   | 85 ++++++++++++++++++++++++++++++++++++++-------
 2 files changed, 80 insertions(+), 88 deletions(-)

diff --git a/universalstring.cpp b/universalstring.cpp
index 68d09f5..57d458f 100644
--- a/universalstring.cpp
+++ b/universalstring.cpp
@@ -14,83 +14,14 @@
  * $Id$
  */
 
+#include "ascii.h"
 #include "universalstring.h"
-#include <cstdlib>
+#include <algorithm>
+#include <iostream>
 
-#ifdef DEBUG
-#   include <iostream>
-#endif
-
-UniversalString::UniversalString(void): string(NULL) {
-#ifdef DEBUG
-    std::cerr << "En constructor de UniversalString." << std::endl;
-#endif
-}
-
-UniversalString::UniversalString(const UniversalString& str): string(NULL) {
-#ifdef DEBUG
-    std::cerr << "En constructor de copia de UniversalString." << std::endl;
-#endif
-    // Llamo al operador igual.
-    *this = str;
-}
-
-UniversalString::~UniversalString(void) {
-#ifdef DEBUG
-    std::cerr << "En destructor de UniversalString." << std::endl;
-#endif
-}
-
-UniversalString& UniversalString::operator=(const UniversalString& str) {
-#ifdef DEBUG
-    std::cerr << "En operator= de UniversalString." << std::endl;
-#endif
-    // Si tengo memoria reservada, la libero.
-    if (string) {
-        delete string;
-        string = NULL;
-    }
-    // Si el string a copiar no es nulo, aloco memoria y copio.
-    if (str.string) { // TODO creo que necesito len y max.
-        string = new T[strlen(str.string) + 1];
-    }
-    return *this;
-}
-
-bool UniversalString::operator<(const UniversalString& str) {
-#ifdef DEBUG
-    std::cerr << "En operator< de UniversalString." << std::endl;
-#endif
-    return caracter < str.caracter;
-}
-
-bool UniversalString::operator==(const UniversalString& str) {
-#ifdef DEBUG
-    std::cerr << "En operator== de UniversalString." << std::endl;
-#endif
-    return caracter == str.caracter;
-}
-
-short UniversalString::operator short(void) {
-#ifdef DEBUG
-    std::cerr << "En cast de UniversalString a short." << std::endl;
-#endif
-    return static_cast<short>(caracter);
-}
-
-/// Volcado a un stream de salida.
-std::ostream& operator<<(std::ostream& out, const UniversalString& str) {
-#ifdef DEBUG
-    std::cerr << "En operator<< de UniversalString." << std::endl;
-#endif
-    return out << str.caracter;
-}
-
-/// Captura desde un stream de entrada.
-std::istream& operator>>(std::istream& in, const UniversalString& str) {
-#ifdef DEBUG
-    std::cerr << "En operator>> de UniversalString." << std::endl;
-#endif
-    return in >> str.caracter;
+int main(void) {
+    UniversalString<Ascii> s("Hola mundo");
+    std::cout << s << std::endl;
+    return 0;
 }
 
diff --git a/universalstring.h b/universalstring.h
index 21116a9..6fac1ed 100644
--- a/universalstring.h
+++ b/universalstring.h
@@ -19,46 +19,107 @@
 
 #include <ostream>
 #include <istream>
+#include <iterator>
+#include <vector>
 
 #ifdef DEBUG
 #   include <iostream>
 #endif
 
 /// String Universal.
-template<class T>
+template <class T>
 class UniversalString {
 
         /// Cadena de caracteres.
-        T* string;
+        std::vector<T> string;
 
     public:
 
         /// Constructor.
-        UniversalString(char c = '0');
+        UniversalString(void) {
+#ifdef DEBUG
+            std::cerr << "En constructor de UniversalString." << std::endl;
+#endif
+        }
+
+        /// 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::endl;
+#endif
+            int len = strlen(str);
+            string.clear();
+            string.reserve(len);
+            for (int i = 0; i < len; i++) {
+                string.push_back(str[i]);
+            }
+        }
 
         /// Constructor de copia.
-        UniversalString(const UniversalString& str);
+        UniversalString(const UniversalString& str) {
+#ifdef DEBUG
+            std::cerr << "En constructor de copia de UniversalString."
+                << std::endl;
+#endif
+        }
 
         /// Destructor.
-        virtual ~UniversalString(void);
+        virtual ~UniversalString(void) {
+#ifdef DEBUG
+            std::cerr << "En destructor de UniversalString." << std::endl;
+#endif
+        }
 
         /// Asignación de una instancia a otra.
-        UniversalString& operator=(const UniversalString& str);
+        UniversalString& operator=(const UniversalString& str) {
+#ifdef DEBUG
+            std::cerr << "En operator= de UniversalString." << std::endl;
+#endif
+            string = str.string;
+            return *this;
+        }
 
         /// Comparación por menor de dos instancias.
-        bool operator<(const UniversalString& str);
+        bool operator<(const UniversalString& str) {
+#ifdef DEBUG
+            std::cerr << "En operator< de UniversalString." << std::endl;
+#endif
+            return string < str.string;
+        }
 
         /// Comparación por igual de dos instancias.
-        bool operator==(const UniversalString& str);
+        bool operator==(const UniversalString& str) {
+#ifdef DEBUG
+            std::cerr << "En operator== de UniversalString." << std::endl;
+#endif
+            return string == str.string;
+        }
 
-        /// Cast a short.
-        short int UniversalString::operator short int(void);
+        /// Cast a string C.
+        //operator char*(void);
 
         /// Volcado a un stream de salida.
-        friend std::ostream& operator<<(std::ostream& out, const UniversalString& str);
+        friend std::ostream& operator<<(std::ostream& out,
+                const UniversalString<T>& str) {
+#ifdef DEBUG
+            std::cerr << "En operator<< de UniversalString." << std::endl;
+#endif
+            std::copy(str.string.begin(), str.string.end(),
+                    std::ostream_iterator<T>(out, ""));
+            return out;
+        }
 
         /// Captura desde un stream de entrada.
-        friend std::istream& operator>>(std::istream& in, const UniversalString& str);
+        friend std::istream& operator>>(std::istream& in,
+                const UniversalString<T>& str) {
+#ifdef DEBUG
+            std::cerr << "En operator>> de UniversalString." << std::endl;
+#endif
+            std::copy(std::istream_iterator<T>(in), std::istream_iterator<T>(),
+                    back_inserter(str.string));
+            return in;
+        }
 
 };
 
-- 
2.43.0