src/clave_variable.cpp

   1
   2 #include <string>
   3 #include "clave_variable.h"
   4 #include <iostream>
   5
   6 ClaveVariable::ClaveVariable (const std::string &s, uint bd)
   7 {
   8         data = s;
   9         block_data = bd;
  10 }
  11
  12 ClaveVariable::ClaveVariable (uchar *n)
  13 {
  14         uint len;
  15
  16         memcpy (&len, n, sizeof (uint));
  17         uchar *str = new uchar[len+1];
  18         n += sizeof (uint);
  19         memcpy (str, n, sizeof (uchar)*len);
  20         str[len] = '\0';
  21         data = std::string ((const char *)(str));
  22         delete [] str;
  23         n += data.size () * sizeof (uchar);
  24         memcpy (&block_data, n, sizeof (uint));
  25
  26         raw_data = data;
  27 }
  28
  29 uint ClaveVariable::Size () const
  30 {
  31         return data.size ()*sizeof (uchar)+sizeof (uint)*2;
  32 }
  33
  34 uchar *ClaveVariable::ToArray () const
  35 {
  36         uchar *out;
  37         uint len = data.size ();
  38         out = new uchar[Size ()];
  39         int x = 0;
  40         memcpy (out, &len, sizeof (uint));
  41         x += sizeof (uint);
  42         memcpy (out+x, data.c_str (), data.size ()*sizeof (uchar));
  43         x += data.size () * sizeof (uchar);
  44         memcpy (out+x, &block_data, sizeof (uint));
  45
  46         return out;
  47 }
  48
  49 Clave *ClaveVariable::Clone () const
  50 {
  51         ClaveVariable *k = new ClaveVariable (*this);
  52         return k;
  53 }
  54
  55 bool ClaveVariable::operator < (const Clave &c) const
  56 {
  57         return data < ((ClaveVariable&)c).data;
  58 }
  59
  60 bool ClaveVariable::operator == (const Clave &c) const
  61 {
  62         return data == ((ClaveVariable&)c).data;
  63 }
  64
  65 bool ClaveVariable::Abrev (ClaveVariable *c)
  66 {
  67         if (c == NULL) return false;
  68         int iguales = 0;
  69         std::string resto;
  70
  71         resto = abreviar (c->data, data, iguales);
  72
  73         /* No hago nada si solo machea un caracter */
  74         if (iguales < 2) return false;
  75
  76         std::stringstream ss;
  77         ss << iguales;
  78         ss << "|";
  79         ss << resto;
  80         data = ss.str ();
  81
  82         return true;
  83 }
  84
  85 bool ClaveVariable::DesAbrev (ClaveVariable *c)
  86 {
  87         if (c == NULL) return false;
  88
  89         int pos = data.find ("|");
  90
  91         /* No esta abreviada! */
  92         if (pos <= 0) return false;
  93
  94         std::string siguales = data.substr (0, pos);
  95         int iguales = atoi (siguales.c_str ());
  96
  97         std::string primera_parte = c->data.substr (0, iguales);
  98         std::string segunda_parte = data.substr (pos+1, data.size () - pos - 1);
  99
 100         data = primera_parte + segunda_parte;
 101
 102         return true;
 103 }
 104
 105 std::string ClaveVariable::abreviar(std::string &p, std::string &a, int &iguales)
 106 {
 107         char *primera = (char *)p.c_str ();
 108         char *actual = (char *)a.c_str ();
 109
 110         iguales = 0;
 111         while (((*primera) != '\0') && ((*actual) != '\0')) {
 112                 if ((*primera) == (*actual)) {
 113                         primera++;
 114                         actual++;
 115                         iguales++;
 116                 } else {
 117                         /* No coinciden mas! */
 118                         break;
 119                 }
 120         }
 121
 122         return std::string (actual);
 123 }
 124
 125 uchar *ClaveVariable::ToRaw (uint &size) const
 126 {
 127         uchar *out;
 128         size = raw_data.size ()*sizeof (uchar)+sizeof (uint);
 129         uint len = raw_data.size ();
 130         out = new uchar[size];
 131         memcpy (out, &len, sizeof (uint));
 132         memcpy (out+sizeof(uint), raw_data.c_str (), raw_data.size ()*sizeof (uchar));
 133         return out;
 134 }
 135