universalstring.h

   1 /* vim: set et sts=4 sw=4 fdm=marker fmr={,} fdn=1 fo+=t tw=80:
   2  *
   3  * Taller de Programación (75.42).
   4  *
   5  * Ejercicio Número 4:
   6  * Ordena texto ASCII o Unicode.
   7  *
   8  * Copyleft 2003 - Leandro Lucarella <llucare@fi.uba.ar>
   9  * Puede copiar, modificar y distribuir este programa bajo los términos de
  10  * la licencia GPL (http://www.gnu.org/).
  11  *
  12  * Creado: sáb sep 27 15:38:29 ART 2003
  13  *
  14  * $Id$
  15  */
  16
  17 #ifndef UNIVERSALSTRING_H
  18 #define UNIVERSALSTRING_H
  19
  20 #include <ostream>
  21 #include <istream>
  22 #include <iterator>
  23 #include <vector>
  24
  25 #ifdef DEBUG
  26 #   include <iostream>
  27 #endif
  28
  29 /// String Universal.
  30 template < class T >
  31 class UniversalString {
  32
  33         /// Cadena de caracteres.
  34         std::vector< T > string;
  35
  36     public:
  37
  38         /// Constructor.
  39         UniversalString(void) {
  40 #ifdef DEBUG
  41             std::cerr << "En constructor de UniversalString." << std::endl;
  42 #endif
  43         }
  44
  45         /// Constructor a partir de un string C.
  46         UniversalString(const char* str) {
  47 #ifdef DEBUG
  48             std::cerr << "En constructor de UniversalString desde string C."
  49                 << std::endl;
  50 #endif
  51             int len = strlen(str);
  52             // Limpio cadena de caracteres anterior.
  53             string.clear();
  54             // Reservo nuevo espacio.
  55             string.reserve(len);
  56             // Agrego cada caracter.
  57             for (int i = 0; i < len; i++) {
  58                 string.push_back(str[i]);
  59             }
  60         }
  61
  62         /// Constructor de copia.
  63         UniversalString(const UniversalString& str) {
  64 #ifdef DEBUG
  65             std::cerr << "En constructor de copia de UniversalString."
  66                 << std::endl;
  67 #endif
  68             string = str.string;
  69         }
  70
  71         /// Destructor.
  72         virtual ~UniversalString(void) {
  73 #ifdef DEBUG
  74             std::cerr << "En destructor de UniversalString." << std::endl;
  75 #endif
  76         }
  77
  78         /// Asignación de una instancia a otra.
  79         UniversalString& operator=(const UniversalString& str) {
  80 #ifdef DEBUG
  81             std::cerr << "En operator= de UniversalString." << std::endl;
  82 #endif
  83             // Asigno la cadena de caracteres del string str.
  84             string = str.string;
  85             return *this;
  86         }
  87
  88         /// Asignación de una instancia a otra de distinto tipo.
  89         template < class T2 >
  90         UniversalString& operator=(const UniversalString< T2 >& str) {
  91 #ifdef DEBUG
  92             std::cerr << "En operator= de UniversalString de tipos distintos."
  93                 << std::endl;
  94 #endif
  95             // Obtengo un vector con los caracteres del string str.
  96             std::vector< T2 > v = str.to_vector();
  97             // Limpio mi cadena de caracteres.
  98             string.clear();
  99             // Reservo el nuevo espacio para mi cadena.
 100             string.reserve(v.size());
 101             // Voy agregando caracter a caracter.
 102             for (size_t i = 0; i < v.size(); i++) {
 103                 string.push_back(T(v[i]));
 104             }
 105             return *this;
 106         }
 107
 108         /// Comparación por menor de dos instancias.
 109         bool operator<(const UniversalString& str) {
 110 #ifdef DEBUG
 111             std::cerr << "En operator< de UniversalString." << std::endl;
 112 #endif
 113             return string < str.string;
 114         }
 115
 116         /// Comparación por igual de dos instancias.
 117         bool operator==(const UniversalString& str) {
 118 #ifdef DEBUG
 119             std::cerr << "En operator== de UniversalString." << std::endl;
 120 #endif
 121             return string == str.string;
 122         }
 123
 124         /// Devuelve un vector de caracteres T.
 125         std::vector< T > to_vector(void) const {
 126             return string;
 127         }
 128
 129         /// Volcado a un stream de salida.
 130         friend std::ostream& operator<<(std::ostream& out,
 131                 const UniversalString< T >& str) {
 132 #ifdef DEBUG
 133             std::cerr << "En operator<< de UniversalString." << std::endl;
 134 #endif
 135             // Copio el vector de caracteres al stream de salida.
 136             std::copy(str.string.begin(), str.string.end(),
 137                     std::ostream_iterator< T >(out, ""));
 138             return out;
 139         }
 140
 141         /// Captura desde un stream de entrada.
 142         friend std::istream& operator>>(std::istream& in,
 143                 UniversalString< T >& str) {
 144 #ifdef DEBUG
 145             std::cerr << "En operator>> de UniversalString." << std::endl;
 146 #endif
 147             // Limpio la cadena actual.
 148             str.string.clear();
 149             // Obtengo primer caracter, incluyendo espacios.
 150             T c;
 151             in >> std::noskipws >> c;
 152             // Mientras que no sea el fin de línea, sigo leyendo caracteres.
 153             while (!c.is_endl()) {
 154                 str.string.push_back(c);
 155                 in >> std::noskipws >> c;
 156             }
 157             return in;
 158         }
 159
 160 };
 161
 162 #endif // UNIVERSALSTRING_H