Abreviado de Claves Variables.

diff --git a/src/btree.cpp b/src/btree.cpp
index c0e72a380316666212007b446f84f2af3a856887..87471779f5f5ea15c12b7243e6b2842c40a51a54 100644 (file)
--- a/src/btree.cpp
+++ b/src/btree.cpp
@@ -990,11 +990,44 @@ std::list<BTreeData *> BTree::ReadKeys (uchar *node, BTreeNodeHeader &node_heade
                keys.push_back (data);
        }
 
+       DeAbrevKey (keys);
        return keys;
 }
 
+void BTree::AbrevKey (std::list<BTreeData *> &lst)
+{
+       /* Claves Fijas No se abrevian */
+       if (key_type == KEY_FIXED) return;
+
+       BTreeData *primera = NULL;
+       std::list<BTreeData *>::iterator it = lst.begin ();
+
+       while (it != lst.end ()) {
+               if ((*it)->Abrev (primera) == false)
+                       primera = (*it);
+               it++;
+       }
+}
+
+void BTree::DeAbrevKey (std::list<BTreeData *> &lst)
+{
+       /* Claves Fijas No se abrevian */
+       if (key_type == KEY_FIXED) return;
+
+       BTreeData *primera = NULL;
+       std::list<BTreeData *>::iterator it = lst.begin ();
+
+       while (it != lst.end ()) {
+               if ((*it)->DesAbrev (primera) == false)
+                       primera = (*it);
+               it++;
+       }
+}
+
 void BTree::WriteKeys (uchar *node, BTreeNodeHeader &node_header, std::list<BTreeData *> &keys)
 {
+       AbrevKey (keys);
+
        std::list<BTreeData *>::iterator it = keys.begin ();
 
        node += sizeof (BTreeNodeHeader);
@@ -1016,7 +1049,7 @@ void BTree::WriteKeys (uchar *node, BTreeNodeHeader &node_header, std::list<BTre
                it++;
        }
 
-       /* TODO : incrementar node_header.item_count aca o fuera de este metodo? */
+       DeAbrevKey (keys);
 }
                
 void BTree::PrintNode (uint num)

diff --git a/src/btree.h b/src/btree.h
index 61fbb8c36592695a965153e462816dd0d72120aa..f888eea9fbec91af7c22335448b9d01f0b08717c 100644 (file)
--- a/src/btree.h
+++ b/src/btree.h
@@ -175,6 +175,10 @@ class BTree {
                void WriteKeys (uchar *node, BTreeNodeHeader &node_header, std::list<BTreeData *> &keys);
                void DeleteKeys (std::list<BTreeData *> &keys);
 
+               /* Abreviacion de Claves */
+               void AbrevKey (std::list<BTreeData *> &lst);
+               void DeAbrevKey (std::list<BTreeData *> &lst);
+
                std::string filename;
                BTreeFileHeader header;
                int key_type;

diff --git a/src/btree_data.cpp b/src/btree_data.cpp
index bc0ce93c08882c4dd107b515429fddb497e151a4..bf92909969aedf7630105ac8c91fc9db61b52661 100644 (file)
--- a/src/btree_data.cpp
+++ b/src/btree_data.cpp
@@ -63,6 +63,22 @@ bool BTreeData::operator == (const BTreeData &data) const
        return (*clave) == (*(data.clave));
 }
 
+bool BTreeData::Abrev (BTreeData *anterior)
+{
+       if (anterior == NULL) return false;
+
+       ClaveVariable *c = (ClaveVariable *)clave;
+       return c->Abrev (dynamic_cast<ClaveVariable *>(anterior->getClave ()));
+}
+
+bool BTreeData::DesAbrev (BTreeData *anterior)
+{
+       if (anterior == NULL) return false;
+
+       ClaveVariable *c = (ClaveVariable *)clave;
+       return c->DesAbrev (dynamic_cast<ClaveVariable *>(anterior->getClave ()));
+}
+
 BTreeLeafData::BTreeLeafData (uchar *node, int key_type)
 {
        if (key_type == BTree::KEY_FIXED)

diff --git a/src/btree_data.h b/src/btree_data.h
index db40598aa7908e7770bd129c6f5f8f2dbf8a357f..027c5954fa8c57a32665749c81b856c54d9dbad8 100644 (file)
--- a/src/btree_data.h
+++ b/src/btree_data.h
@@ -53,6 +53,9 @@ class BTreeData {
                /** Setea el hijo apuntado */
                void setChild (uint c) { hijo = c; }
 
+               bool Abrev (BTreeData *anterior);
+               bool DesAbrev (BTreeData *anterior);
+
                bool operator < (const BTreeData &data) const;
                bool operator == (const BTreeData &data) const;
                virtual operator std::string () const {

diff --git a/src/clave_variable.cpp b/src/clave_variable.cpp
index c4fd1f1dc220272935caddb9a050734e269ace03..47d81ba5f292f1b2461b8b26f02f6d6a8bb816e1 100644 (file)
--- a/src/clave_variable.cpp
+++ b/src/clave_variable.cpp
@@ -52,3 +52,64 @@ bool ClaveVariable::operator == (const Clave &c) const
        return data == ((ClaveVariable&)c).data;
 }
 
+bool ClaveVariable::Abrev (ClaveVariable *c)
+{
+       if (c == NULL) return false;
+       int iguales = 0;
+       std::string resto;
+
+       resto = abreviar (c->data, data, iguales);
+
+       /* No hago nada si solo machea un caracter */
+       if (iguales < 2) return false;
+
+       std::stringstream ss;
+       ss << iguales;
+       ss << "|";
+       ss << resto;
+       data = ss.str ();
+
+       return true;
+}
+
+bool ClaveVariable::DesAbrev (ClaveVariable *c)
+{
+       if (c == NULL) return false;
+
+       int pos = data.find ("|");
+
+       /* No esta abreviada! */
+       if (pos <= 0) return false;
+
+       std::string siguales = data.substr (0, pos);
+       std::cout << siguales << std::endl;
+       int iguales = atoi (siguales.c_str ());
+
+       std::string primera_parte = c->data.substr (0, iguales);
+       std::string segunda_parte = data.substr (pos+1, data.size () - pos - 1);
+
+       data = primera_parte + segunda_parte;
+
+       return true;
+}
+
+std::string ClaveVariable::abreviar(std::string &p, std::string &a, int &iguales)
+{
+       char *primera = (char *)p.c_str ();
+       char *actual = (char *)a.c_str ();
+
+       iguales = 0;
+       while (((*primera) != '\0') && ((*actual) != '\0')) {
+               if ((*primera) == (*actual)) {
+                       primera++;
+                       actual++;
+                       iguales++;
+               } else {
+                       /* No coinciden mas! */
+                       break;
+               }
+       }
+
+       return std::string (actual);
+}
+

diff --git a/src/clave_variable.h b/src/clave_variable.h
index 75cecfd3a5157caa4569bc7f25b1dc2e571704ef..e568451fc012d0d8c3d9dbfa1f26458a71b63542 100644 (file)
--- a/src/clave_variable.h
+++ b/src/clave_variable.h
@@ -8,7 +8,7 @@
 
 /** Representa una clave de longitud variable.
  *
- *  \TODO Usar abreviaciones
+ *  \todo Usar abreviaciones
  */
 class ClaveVariable : public Clave {
        public :
@@ -20,12 +20,16 @@ class ClaveVariable : public Clave {
                uchar *ToArray () const;
                Clave *Clone () const;
 
+               bool Abrev (ClaveVariable *c);
+               bool DesAbrev (ClaveVariable *c);
+
                virtual bool operator < (const Clave &c) const;
                virtual bool operator == (const Clave &c) const;
                virtual operator std::string () const {
                        return data;
                }
        private:
+               std::string abreviar(std::string &primera, std::string &actual, int &iguales);
                std::string data;
 };