RamDisco.cpp

Ir a la documentación de este archivo.
00001 // vim: set expandtab tabstop=8 shiftwidth=8 foldmethod=marker:
00013 #include <iostream>
00014 #include <iomanip>
00015 #include <list>
00016 #include <vector>
00017 #include <set>
00018 #include <fstream>
00019 #include <istream>
00020 #include <sstream>
00021 
00022 using namespace std;
00023 
00024 #include "RamDisco.hpp"
00025 
00026 
00027 
00032 unsigned long
00033 precalcula_escribe_con_hermanos(NodoTrieS *n)
00034 {
00035         //ASSERT(n == NULL || n->cad.length() > 0);
00036 
00037         int t = 0;
00038         if (n != NULL) {
00039                 t = 1; // Por \n
00040         }
00041         //cerr << "OJO precalcula_escribe_con_hermanos '" << (n!=NULL ? n->cad : string("null")) << "' t=" << t ;
00042         while (n != NULL) {
00043                 t += precalcula_escribe_actual(n->cad.length(),
00044                                                &(n->cpos));
00045                 //cerr << " 2 t=" << t;
00046                 n = n->hermano_mayor;
00047                 //cerr << " 3 t=" << t;
00048         }
00049         //cerr << endl;
00050         return t;
00051 }
00052 
00053 unsigned long
00054 precalcula_escribe(NodoTrieS *n)
00055 {
00056         long t = precalcula_escribe_con_hermanos(n);
00057         //cerr << "OJO precalcula_escribe en '" << (n!=NULL ? n->cad : string("null")) << "' t=" << t ;
00058 
00059         while (n != NULL) {
00060                 t += precalcula_escribe(n->hijo_menor);
00061                 //cerr << "  En ciclo t=" << t ;
00062                 n = n->hermano_mayor;
00063         }
00064         //cerr << endl;
00065         return t;
00066 }
00067 
00068 
00069 extern stringstream *depuraos ;
00070 
00080 void
00081 escribePlanoStream(NodoTrieS *n, std::iostream &os, long desp)
00082 {
00083 
00084         NodoTrieS *tn;
00085         long nh = precalcula_escribe_con_hermanos(n);
00086         long dultimo = nh; // Distancia a último desde comienzo de grupo de hermanos
00087         long dhijo = 0; // distancia a hijo desde hermano actual
00088 
00089         // Escribe hermanos
00090         tn = n;
00091         long pactual = 0;  // Posición actual desde comienzo de grupo de hermanos
00092         //cout << "escribePlanoStream de: " << endl; n->aDotty(cerr, "");
00093         while (tn != NULL && tn->cad.length() > 0) {
00094                 if (tn->hijo_menor != NULL) {
00095                         dhijo = dultimo - pactual;
00096                         dultimo += precalcula_escribe(tn->hijo_menor);
00097                 } else {
00098                         dhijo = 0;
00099                 }
00100                 //cout << "dultimo=" << dultimo << ", pactual=" << pactual << ", os.tellp=" << os.tellp() << ". Por llamar escribeNodo(ss, " << tn->cad << ", " << (tn->cpos).size() << ", " << dhijo << ")" << endl;
00101                 escribeNodo(os, tn->cad, &(tn->cpos), dhijo, desp);
00102                 //cout << "ret = " << r << endl;
00103                 if (depuraos != NULL) {
00104                         cout << depuraos->str() << endl;
00105                 }
00106                 pactual += precalcula_escribe_actual((tn->cad).length(),
00107                                                      &(tn->cpos));
00108                 tn = tn->hermano_mayor;
00109         }
00110         os << "\n";
00111         //cout << "Escribe hijos de cada hermano" << endl;
00112         tn = n;
00113         while (tn != NULL) {
00114                 if (tn->hijo_menor != NULL) {
00115                         escribePlanoStream(tn->hijo_menor, os, desp);
00116                 }
00117                 tn = tn->hermano_mayor;
00118         }
00119 }
00120 
00121 
00122 
00123 NodoTrieS *
00124 leePlanoStream(std::istream &is) throw(string)
00125 {
00126         string cad;
00127         set<Pos> *cpos;
00128         long hijo, hermano;
00129         int c = is.get();
00130         if (c == '\n' || c == EOF) {
00131                 return NULL;
00132         }
00133         while (c != FINCADENA && c != EOF) {
00134                 cad += c;
00135                 c = is.get();
00136         }
00137         //cout << "leePlanoStream cad="<<cad<<endl;
00138         if (c != FINCADENA) {
00139                 throw errorFormato(is, string("Se esperaba ") + FINCADENA);
00140         }
00141         hermano = leeNDesp(is);
00142         hijo = leeNDesp(is);
00143         //cout << "hermano ="<< hermano << ", hijo=" << hijo <<endl;
00144 
00145         cpos = leePos(is, NULL);
00146         if (long(is.tellg()) != hermano) {
00147                 stringstream ss;
00148                 ss << "Cursor y hermano difieren (" << is.tellg() << ", " << hermano << ")";
00149                 throw errorFormato(is, ss.str());
00150         }
00151 
00152         NodoTrieS *hermanomayor = leePlanoStream(is);
00153         NodoTrieS *hijomenor = NULL;
00154         if (hijo > 0) {
00155                 is.seekg(hijo);
00156                 hijomenor = leePlanoStream(is);
00157         }
00158         NodoTrieS *r = new NodoTrieS(cad, hijomenor,
00159                                      hermanomayor, *cpos);
00160 
00161         return r;
00162 }
00163 
00164 
00165 void
00166 escribePlano(NodoTrieS &t, vector<Doc> &docs, char *na, char *nrel)
00167 {
00168 
00169         ASSERT(na!=NULL && na[0] != '\0' && strlen(na)<FILENAME_MAX);
00170         ASSERT(nrel!=NULL && na[0] != '\0' && strlen(nrel)<FILENAME_MAX);
00171 
00172         fstream os(na, ios_base::out);
00173         os << MARCAIND << endl;
00174         escribePlanoStream(&t, os);
00175         os.close();
00176 
00177         escribeRelacion(nrel, docs, NULL);
00178 }
00179 
00180 
00181 
00182 NodoTrieS *
00183 leePlano(char *na, char *nrel, vector<Doc> &docs)
00184 {
00185         NodoTrieS *r;
00186         //cout << "leePlano(" << na << ", " << nrel << ", " << idocs.size() << ", " << condensados.size() << ")" << endl;
00187         fstream is(na, ios_base::in);
00188         verificaIndice(is);
00189         try {
00190                 r = leePlanoStream(is);
00191         } catch (string m) {
00192                 stringstream ss;
00193                 ss << na << ":" << is.tellg() << m << endl;
00194                 throw ss.str();
00195         }
00196         is.close();
00197 
00198         leeRelacion(nrel, docs);
00199 
00200         return r;
00201 }
00202 
00203 
00204 long escribeCopiaNodoRam(iostream &os, NodoTrieS *a, int saltacad,
00205                          NodoTrieS **phijo, vector<long>* renum)
00206 {
00207         ASSERT(phijo != NULL);
00208 
00209         long ret = 0;
00210 
00211         //clog << "\nescribeCopiaNodo is.tellg() = " << is.tellg();
00212         string cad = (a != NULL ? a->cad.substr(saltacad) : "");
00213         //clog  << " cad='" << cad << "'";
00214         if (cad != "") {
00215                 //clog << " phermano=" << phermano;
00216                 *phijo = a->hijo_menor;
00217                 long dhijo = 0;
00218                 if (*phijo != NULL) {
00219                         dhijo = precalcula_escribe_con_hermanos(a);
00220                 }
00221                 //clog << " phijo=" << phijo;
00222                 //clog << " cpos=" << *cpos;
00223                 //clog << " is.tellg() = " << is.tellg();
00224                 set<Pos> *cp = copiaPos((a->cpos), renum);
00225                 ret = escribeNodo(os, cad, cp, dhijo);
00226                 delete cp;
00227 
00228         }
00229 
00230         //clog << " ret=" << ret << endl;
00231         return ret;
00232 }
00233 
00234 
00235 long
00236 escribeCopiaSubarbolRam(iostream &os, NodoTrieS *a, int saltacad,
00237                         bool conHermanos, vector<long>* renum)
00238 {
00239 
00240         long prini = os.tellp();
00241         //cout << "OJO escribeCopiaSubarbol prini=" << prini << endl;
00242         //cout << "is.tellg()=" << is.tellg() << endl;
00243 
00244         string cad;
00245         long n; // Cantidad de nodos hermanos
00246         vector<NodoTrieS *> dhijo;
00247         vector<long> pih;
00248 
00249         cad = (a != NULL ? a->cad.substr(saltacad) : "");
00250         //cout << "OJO cad=" << cad << endl;
00251         /* INV: cad es cadena leida del nodo por copiar
00252          * "cursor" de is está a continuación de la cadena leída 
00253          * n es cantidad de nodos hermanos ya leidos
00254          * dhijo tiene lista de apuntadores a hijos 
00255          * pih es vector de posiciones de apuntadores a hijos escritos en os
00256          */
00257         for (n = 0; cad != "" && (conHermanos || n == 0); n++) {
00258                 /*long phermano = leeNDesp(is);
00259                 long h = leeNDesp(is); */
00260                 /*set<Pos> *cpos = leePos(is, renum); */
00261                 //cout << "OJO prini=" << prini << " cpos=" << *cpos << endl;
00262                 //cout << "OJO prini=" << prini << " phermano=" << phermano << endl;
00263                 //cout << "OJO prini=" << prini << " h=" << h << endl;
00264                 //cout << "OJO prini=" << prini << " is.tellg=" << is.tellg() << endl;
00265                 dhijo.push_back(a->hijo_menor);
00266                 set<Pos> *cp = copiaPos((a->cpos), renum);
00267                 long tp = escribeNodo(os, cad, cp, 0);
00268                 delete cp;
00269                 //cout << "OJO prini=" << prini << " tp=" << tp << endl;
00270                 pih.push_back(tp);
00271                 //cout << "2 prini=" << prini << ", tellp=" << os.tellp() << endl;
00272                 if (depuraos!=NULL) {
00273                         cout << depuraos->str() << endl;
00274                 }
00275                 a = a->hermano_mayor;
00276                 if (conHermanos) {
00277                         cad = (a != NULL ? a->cad : "");
00278                 }
00279         }
00280         if (n > 0) {
00281                 os << endl;
00282                 //cout << "OJO dhijo[0]=" << dhijo[0] << " " << dhijo.size() << endl;
00283         }
00284         long i;
00285         /* INV: n cantidad de nodos hermanos por copiar
00286          * "cursor" de os está al final
00287          * dhijo[i] tiene posición  en is del hijo menor del i-esimo nodo
00288          * pih[i] es posición en os donde está el hexadecimal con posición
00289          *      de hijo menor del i-esimo nodo.
00290          */
00291         long pini, pfin;
00292         for (i = 0; i < n; i++) {
00293                 if (dhijo[i] != NULL) {
00294                         //cout << "en hijos prini=" << prini << " dhijo["
00295                         //        << i << "]=" << dhijo[i] << endl;
00296                         pini = escribeCopiaSubarbolRam(os, dhijo[i], 0,
00297                                                        true, renum);
00298                         //cout << "prini=" << prini << " pini=" << pini << endl;
00299                         pfin = os.tellp();
00300                         //cout << "pfin=" << pfin <<endl;
00301                         os.seekp(pih[i]);
00302                         //cout << "pih[i]=" << pih[i] <<endl;
00303                         escribeNDesp(os, pini);
00304                         //cout << "escribiendo pini=" << pini <<endl;
00305                         os.seekp(pfin);
00306                 }
00307         }
00308 
00309         return prini;
00310 }
00311 
00312 
00313 long
00314 mezclaDiscoRam(istream &is1, NodoTrieS *a2, int saltacad, iostream &os,
00315                bool conHermanos1, bool conHermanos2,
00316                vector<long> *renum1, vector<long> *renum2)
00317 {
00318 
00319         string cad1;
00320         string cad2;
00321         long numhermanos; // Número de hermanos escritos en os
00322         long n1=0; // Número de hermanos revisados en is1
00323         long n2=0; // Número de hermanos revisados en a2
00324         long phermano1; // Posición de hermano en is1
00325 
00326         // Posibles operaciones con hijos en is1 y a2 para producir hijo(s)
00327         // en os
00328         const int O_COPIA1=1,
00329                            O_COPIA2=2,
00330                                     O_MEZCLA_H1H2=3,
00331                                                   O_MEZCLA_H1=4,
00332                                                               O_MEZCLA_H2=5,
00333                                                                           O_COPIA_PRIMERO_1=6,
00334                                                                                             O_COPIA_PRIMERO_2=7;
00335 
00336         ;
00337         vector<long> dhijo1(0); // apuntadores a hijos de nodos en is1
00338         vector<int> dhijo2_saltacad(0); // Cuanto saltar de cad de hijos
00339         vector<NodoTrieS *> dhijo2(0); // apuntadores a hijos de nodos en a2
00340         vector<string> resto1(0); // Cadenas con las que comenazarán hijos
00341         vector<string> resto2(0); // Cadenas con las que comenzarían hijos
00342         vector<int> opera(0); // operación por realizar a hijos en 2da parte
00343         vector<long> pih(0); // posiciones de apuntadores a hijos en os
00344 
00345         long prini = os.tellp();
00346         //clog << "OJO mezclaDiscoRam prini=" << prini << ", is1.tellg()=" << is1.tellg() << ", a2=" << (long)a2 << endl;
00347         //clog << "OJO peek1=" << is1.peek() << endl;
00348         if (a2 != NULL) {
00349                 //clog << "OJO a2->cad.substr(saltacad)=" << a2->cad.substr(saltacad) << endl;
00350         }
00351         for (cad1=leeCad(is1), cad2=(a2 != NULL ? a2->cad.substr(saltacad) : ""),
00352                         numhermanos = 0;
00353                         (cad1!="" && (conHermanos1 || n1==0)) ||
00354                         (cad2!="" && (conHermanos2 || n2==0));
00355                         numhermanos++) {
00356                 //clog << "OJO mezclaDiscoRam prini=" << prini << "cad1=" << cad1 << ", cad2= "<< cad2 << endl;
00357                 dhijo1.push_back(-1);
00358                 dhijo2_saltacad.push_back(0);
00359                 dhijo2.push_back(NULL);
00360                 resto1.push_back("");
00361                 resto2.push_back("");
00362                 opera.push_back(-1);
00363                 pih.push_back(-1);
00364 
00365                 if (!conHermanos1 && n1 >= 1) {
00366                         cad1="";
00367                 }
00368                 if (!conHermanos2 && n2 >= 1) {
00369                         cad2="";
00370                 }
00371                 /* INV:
00372                  * cad1 es cadena en nodo de is1
00373                  * cad2 es cadena en nodo de  a2
00374                  * cursor de is1 está a continuación de cad1 
00375                  *      (sobre inicio de posiciones)
00376                  * a2 está en nodo de cad2
00377                  * conHermanos1 es true si debe continuar con hermanos en is1
00378                  * conHermanos2 es true si debe seguir con hermanos en a2
00379                  */
00380                 string c = "";
00381                 if (cad1 != "" && cad2 != "") {
00382                         c = prefijo_comun_mas_largo(cad1, cad2);
00383                 }
00384                 //clog << "OJO  prefijo c="<<c<<endl;
00385                 if (c == "") { // No hay prefijo comun
00386                         resto1[numhermanos] = "";
00387                         resto2[numhermanos] = "";
00388                         if (cad2=="" || (cad1!="" && cad1<cad2)) {
00389                                 // e.g AMOR y BUENO  o
00390                                 //     ""   y BUENO
00391                                 //clog << "OJO se copia nodo de is1" <<endl;
00392                                 phermano1 = leeNDesp(is1);
00393                                 dhijo1[numhermanos] = leeNDesp(is1);
00394                                 dhijo2[numhermanos] = NULL;
00395                                 set<Pos> *cpos = leePos(is1, renum1);
00396                                 opera[numhermanos] = O_COPIA1;
00397                                 pih[numhermanos] =
00398                                         escribeNodo(os, cad1, cpos, 0);
00399                                 delete cpos;
00400                                 cpos = NULL;
00401                                 cad1 = leeCad(is1);
00402                                 n1++;
00403                                 // cad2 quieto
00404                                 // en la recursión hijos de cad1
00405                                 //quedamos en el siguiente hermano mayor en is1
00406                         } else { /*cad2!="" && (cad1=="" || cad1 >= cad2) */
00407                                 // e.g BUENO y AMOR o
00408                                 //      ""   y AMOR
00409                                 ASSERT(cad1 == "" || (cad1 > cad2));
00410                                 //clog << "OJO se copia nodo de a2" <<endl;
00411                                 dhijo1[numhermanos] = -1;
00412                                 dhijo2_saltacad[numhermanos] = 0;
00413                                 dhijo2[numhermanos] = a2->hijo_menor;
00414                                 //clog << "OJO phijo=" << dhijo2[numhermanos] << endl;
00415                                 opera[numhermanos] = O_COPIA2;
00416                                 set<Pos> *cp = copiaPos((a2->cpos), renum2);
00417                                 pih[numhermanos] =
00418                                         escribeNodo(os, cad2, cp, 0);
00419                                 delete cp;
00420                                 a2 = a2->hermano_mayor;
00421                                 cad2 = (a2 != NULL) ? a2->cad : "";
00422                                 n2++;
00423                         }
00424                 } else if (cad1 == cad2) { // Hay prefijo c != "" && cad1!="" && cad2!=""
00425                         phermano1 = leeNDesp(is1);
00426                         dhijo1[numhermanos] = leeNDesp(is1);
00427                         dhijo2_saltacad[numhermanos] = 0;
00428                         dhijo2[numhermanos] = a2->hijo_menor;
00429                         //clog << "OJO iguales" <<endl;
00430                         set<Pos> cpos;
00431                         insert_iterator<set<Pos> >
00432                         cpos_ins(cpos, cpos.begin());
00433                         set<Pos> *cpos1 = leePos(is1, renum1);
00434                         set<Pos> *cpos2 = copiaPos(a2->cpos, renum2);
00435 
00436                         set_union(cpos1->begin(), cpos1->end(),
00437                                   cpos2->begin(), cpos2->end(),
00438                                   cpos_ins);
00439                         //clog << "OJO cad2='" << cad2 << "', cpos=" << cpos << endl;
00440                         pih[numhermanos] = escribeNodo(os, cad2, &cpos, 0);
00441                         delete cpos1;
00442                         cpos1=NULL;
00443                         delete cpos2;
00444                         cpos1=NULL;
00445                         //En hijos NodoTrieS *m=mezcla(a1->hijo_menor, a2->hijo_menor);
00446                         resto1[numhermanos] = "";
00447                         resto2[numhermanos] = "";
00448                         opera[numhermanos] = O_MEZCLA_H1H2;
00449                         cad1 = leeCad(is1);
00450                         n1++;
00451                         a2 = a2->hermano_mayor;
00452                         cad2 = (a2 != NULL) ? a2->cad : "";
00453                         n2++;
00454                 } else { // hay prefijo c != "" && cad1!="" && cad2!="" && cad1!=cad2
00455                         string r1 = cad1.substr(c.size());
00456                         string r2 = cad2.substr(c.size());
00457                         resto1[numhermanos] = r1;
00458                         resto2[numhermanos] = r2;
00459                         ASSERT(r1 != "" || r2 != "");
00460                         //cerr << "hay posfijo r1="<<r1<<" r2="<<r2<<endl;
00461                         if (r1=="") {
00462                                 // e.g BUENO BUENOS
00463                                 ASSERT(r2 != "");
00464                                 //clog << "OJO r1 vacio"<<endl;
00465                                 // debe mezclar hijo de is1 con un sólo
00466                                 // nodo de a2 pero comenzando en el
00467                                 // posfijo r2
00468 
00469                                 phermano1 = leeNDesp(is1);
00470                                 dhijo1[numhermanos] = leeNDesp(is1);
00471                                 dhijo2_saltacad[numhermanos] = saltacad +
00472                                                                c.length();
00473                                 dhijo2[numhermanos] = a2;
00474                                 a2 = a2->hermano_mayor; // Salta al sig en a2
00475                                 set<Pos> *cpos1 = leePos(is1, renum1);
00476                                 pih[numhermanos] = escribeNodo(os, c, cpos1, 0);
00477                                 opera[numhermanos] = O_MEZCLA_H1;
00478                                 delete cpos1;
00479                                 cpos1=NULL;
00480                         } else if (r2 == "") {
00481                                 // e.g BUENOS BUENO,  am a
00482                                 ASSERT(r1 != "");
00483                                 //clog << "OJO r2 vacio"<<endl;
00484 
00485                                 phermano1 = leeNDesp(is1);
00486                                 dhijo1[numhermanos] = (long)is1.tellg() -
00487                                                       MAXLNUMERO - 1 - (long)r1.size();
00488                                 dhijo2_saltacad[numhermanos] = 0;
00489                                 dhijo2[numhermanos] = a2->hijo_menor;
00490                                 is1.seekg(phermano1);
00491                                 set<Pos> *cpos2 = copiaPos(a2->cpos, renum2);
00492 
00493                                 //clog << "OJO en nodo dhijo2[numhermanos]="<< dhijo2[numhermanos] << endl;
00494                                 pih[numhermanos] = escribeNodo(os, c,
00495                                                                cpos2, 0);
00496                                 // Recursion NodoTrieS *m=mezcla(n1, a2->hijo_menor);
00497                                 delete cpos2;
00498                                 a2 = a2->hermano_mayor;
00499                                 opera[numhermanos] = O_MEZCLA_H2;
00500                         } else if (r1 < r2) {
00501                                 // e.g BUENA BUENO
00502                                 //clog << "OJO r1<r2"<<endl;
00503 
00504                                 phermano1 = leeNDesp(is1);
00505                                 pih[numhermanos] = escribeNodo(os, c, NULL, 0);
00506                                 dhijo1[numhermanos] = (long)is1.tellg() -
00507                                                       MAXLNUMERO - 1 - (long)r1.size();
00508                                 dhijo2_saltacad[numhermanos] = saltacad +
00509                                                                c.length();
00510                                 dhijo2[numhermanos] = a2;
00511                                 is1.seekg(phermano1);
00512                                 a2 = a2->hermano_mayor;
00513                                 opera[numhermanos] = O_COPIA_PRIMERO_1;
00514                                 // El hijo de este nodo debe ser
00515                                 // a1 con hermano mayor a2
00516                                 //*r=new NodoTrieS(c, n1, NULL, set<Pos>());
00517                         } else { /* r1 >= r2 */
00518                                 // e.g BUENO BUENA
00519                                 //clog << "OJO r2 <= r1"<<endl;
00520                                 phermano1 = leeNDesp(is1);
00521                                 pih[numhermanos] = escribeNodo(os, c, NULL, 0);
00522                                 dhijo1[numhermanos] = (long)is1.tellg() -
00523                                                       MAXLNUMERO - 1 - (long)r1.size();
00524                                 dhijo2_saltacad[numhermanos] = saltacad +
00525                                                                c.length();
00526                                 dhijo2[numhermanos] = a2;
00527                                 //saltaPos(is1); leeNDesp(is1);
00528                                 is1.seekg(phermano1);
00529                                 a2 = a2->hermano_mayor;
00530                                 opera[numhermanos] = O_COPIA_PRIMERO_2;
00531                         }
00532                         cad1=leeCad(is1);
00533                         n1++;
00534                         cad2=(a2 != NULL ? a2->cad : "");
00535                         n2++;
00536                 }
00537         }
00538         os << endl;
00539         //clog << "OJO Termina hermanos, pasa a hijos" << endl;
00540 
00541         // Desplazamientos en os
00542         long pini, pfin;
00543         long hijo1 = 0;
00544         NodoTrieS *hijo2 = NULL;
00545         long ph1, ph2, pnh1, pnh2;
00546         for (int n = 0; n < numhermanos; n++) {
00547                 pini = 0; // Posición donde queda hijo en os
00548                 switch (opera[n]) {
00549                 case O_COPIA1:
00550                         //clog << "OJO COPIA1" <<endl;
00551                         if (dhijo1[n] > 0) {
00552                                 is1.seekg(dhijo1[n]);
00553                                 pini = escribeCopiaSubarbol(os, is1,
00554                                                             true, renum1);
00555                         }
00556                         break;
00557 
00558                 case O_COPIA2:
00559                         //clog << "OJO COPIA2" <<endl;
00560                         if (dhijo2[n] != NULL) {
00561                                 //clog << "OJO dhijo2[" << n << "]=" << dhijo2[n] << endl;
00562                                 pini = escribeCopiaSubarbolRam(os,
00563                                                                dhijo2[n],
00564                                                                0, true, renum2);
00565                         }
00566                         break;
00567 
00568                 case O_MEZCLA_H1H2:
00569                         //clog << "OJO MEZCLA_H1H2" <<endl;
00570                         if (depuraos!=NULL) {
00571                                 //clog << depuraos->str() << endl;
00572                         }
00573 
00574 
00575                         if (dhijo1[n] > 0 && dhijo2[n] != NULL) {
00576                                 is1.seekg(dhijo1[n]);
00577                                 pini = mezclaDiscoRam(is1, dhijo2[n],
00578                                                       dhijo2_saltacad[n], os,
00579                                                       true, true, renum1,
00580                                                       renum2) ;
00581                         } else if (dhijo1[n] > 0) {
00582                                 ASSERT(dhijo2[n] == NULL);
00583                                 is1.seekg(dhijo1[n]);
00584                                 pini = escribeCopiaSubarbol(os, is1,
00585                                                             true, renum1);
00586                         } else if (dhijo2[n] != NULL) {
00587                                 //clog << "OJO dhijo2[n]=" <<dhijo2[n]<< endl;
00588                                 ASSERT(dhijo1[n] == 0);
00589                                 pini = escribeCopiaSubarbolRam(os,
00590                                                                dhijo2[n],
00591                                                                dhijo2_saltacad[n],
00592                                                                true, renum2);
00593                                 //clog << "OJO pini=" << pini << endl;
00594                         }
00595                         break;
00596                 case O_MEZCLA_H1:
00597                         //clog << "OJO MEZCLA_H1" <<endl;
00598                         ASSERT(dhijo2[n] != NULL);
00599 
00600                         //clog << "OJO dhijo2[n]=" << dhijo2[n] << endl;
00601                         if (dhijo1[n] > 0) {
00602                                 is1.seekg(dhijo1[n]);
00603                                 pini = mezclaDiscoRam(is1, dhijo2[n],
00604                                                       dhijo2_saltacad[n],
00605                                                       os, true, false, renum1,
00606                                                       renum2) ;
00607                         } else {
00608                                 pini = escribeCopiaSubarbolRam(os,
00609                                                                dhijo2[n],
00610                                                                dhijo2_saltacad[n],
00611                                                                false, renum2);
00612                         }
00613                         break;
00614 
00615                 case O_MEZCLA_H2:
00616                         //clog << "OJO MEZCLA_H2" <<endl;
00617                         ASSERT(dhijo1[n] != 0);
00618 
00619                         is1.seekg(dhijo1[n]);
00620                         //clog << "OJO dhijo2[n]=" << dhijo2[n] <<  endl;
00621                         if (dhijo2[n] != NULL) {
00622                                 pini = mezclaDiscoRam(is1, dhijo2[n],
00623                                                       dhijo2_saltacad[n],
00624                                                       os, false, true, renum1,
00625                                                       renum2) ;
00626                         } else {
00627                                 pini = escribeCopiaSubarbol(os, is1,
00628                                                             false, renum1);
00629                         }
00630                         break;
00631 
00632                 case O_COPIA_PRIMERO_1:
00633                         //clog << "OJO COPIA_PRIMERO_1" <<endl;
00634                         ASSERT(dhijo1[n] != 0);
00635                         ASSERT(dhijo2[n] != NULL);
00636 
00637                         is1.seekg(dhijo1[n]);
00638                         pini = os.tellp();
00639 
00640                         // pos no es NULL en los siguientes,
00641                         // más bien copiar de is1 y a2 e hijos
00642                         // después.
00643                         pnh1 = escribeCopiaNodo(os, is1, hijo1, renum1);
00644                         pnh2 = escribeCopiaNodoRam(os, dhijo2[n],
00645                                                    dhijo2_saltacad[n],
00646                                                    &hijo2, renum2);
00647                         os << endl;
00648                         ph1=os.tellp();
00649                         if (hijo1 > 0) {
00650                                 is1.seekg(hijo1);
00651                                 (void)escribeCopiaSubarbol(os, is1,
00652                                                            true, renum1);
00653                         }
00654                         ph2=os.tellp();
00655                         if (hijo2 != NULL) {
00656                                 escribeCopiaSubarbolRam(os, hijo2,
00657                                                         0, true, renum2);
00658                         }
00659                         pfin = os.tellp();
00660                         if (hijo1 > 0) {
00661                                 os.seekp(pnh1);
00662                                 escribeNDesp(os, ph1);
00663                         }
00664                         if (hijo2 != NULL) {
00665                                 os.seekp(pnh2);
00666                                 escribeNDesp(os, ph2);
00667                         }
00668                         os.seekp(pfin);
00669 
00670                         break;
00671 
00672                 case O_COPIA_PRIMERO_2:
00673                         //clog << "OJO COPIA_PRIMERO_2" <<endl;
00674                         ASSERT(dhijo1[n] != 0);
00675                         ASSERT(dhijo2[n] != NULL);
00676 
00677                         is1.seekg(dhijo1[n]);
00678                         pini = os.tellp();
00679 
00680                         pnh2=escribeCopiaNodoRam(os, dhijo2[n],
00681                                                  dhijo2_saltacad[n],
00682                                                  &hijo2, renum2);
00683                         pnh1=escribeCopiaNodo(os, is1, hijo1, renum1);
00684                         os << endl;
00685                         ph2=os.tellp();
00686                         if (hijo2 != NULL) {
00687                                 escribeCopiaSubarbolRam(os, hijo2,
00688                                                         0, true, renum2);
00689                         }
00690                         ph1=os.tellp();
00691                         if (hijo1 > 0) {
00692                                 is1.seekg(hijo1);
00693                                 escribeCopiaSubarbol(os, is1,
00694                                                      true, renum1);
00695                         }
00696                         pfin = os.tellp();
00697                         if (hijo2 != NULL) {
00698                                 os.seekp(pnh2);
00699                                 escribeNDesp(os, ph2);
00700                         }
00701                         if (hijo1 > 0) {
00702                                 os.seekp(pnh1);
00703                                 escribeNDesp(os, ph1);
00704                         }
00705                         os.seekp(pfin);
00706 
00707                         break;
00708 
00709                 default:
00710                         throw std::string("Falla: estado desconocido");
00711                         break;
00712                 }
00713                 pfin = os.tellp();
00714                 //clog << "OJO pfin=" << pfin << endl;
00715                 //clog << "OJO n=" << n << ", pih[n]=" << pih[n]<< endl;
00716                 os.seekp(pih[n]);
00717                 escribeNDesp(os, pini);
00718                 os.seekp(pfin);
00719         }
00720         //clog << "OJO Termina hijos" << endl;
00721         return prini;
00722 }
00723 
00724 
00725 /* Polimorfico en progreso
00726  
00727 class fTrie {
00728  
00729         string retCad();
00730         unsigned long tellp();
00731 };
00732  
00733  
00734 class fTrieRam: fTrie {
00735         NodoTrieS *a2 = NULL;
00736  
00737         fTrieRam(NodoTrieS *r) 
00738         {
00739                 a2 = r;
00740         }
00741  
00742         string retCad()
00743         {
00744                 return (a2 != NULL ? a2->cad.substr(saltacad) : "");
00745         }
00746         unsigned long tellp()
00747         {
00748                 return (long)a2;
00749         }
00750 };
00751  
00752 class fTrieDisco: fTrie {
00753         istrema is1;
00754  
00755         fTrieRam(istream &i) 
00756         {
00757                 is1 = i;
00758         }
00759  
00760         string retCad()
00761         {
00762                 return leeCad(is1);
00763         }
00764         unsigned long tellp()
00765         {
00766                 return is1.tellp();
00767         }
00768         unsigned long leeNDesp()
00769         {
00770                 return leeNDesp(is1);
00771         }
00772  
00773 };
00774  
00775 long 
00776 mezclaPolimorfico(fTrie &is1, fTrie &a2, int saltacad, fTrie &os, 
00777                 bool conHermanos1, bool conHermanos2, 
00778                 vector<long> *renum) 
00779 {
00780         
00781         string cad1;
00782         string cad2;
00783         long numhermanos; // Número de hermanos escritos en os
00784         long n1=0; // Número de hermanos revisados en is1
00785         long n2=0; // Número de hermanos revisados en a2
00786         long phermano1; // Posición de hermano en is1
00787         long phermano2; // Posición de hermano en a2
00788  
00789         // Posibles operaciones con hijos en is1 y a2 para producir hijo(s)
00790         // en os
00791         const int O_COPIA1=1,
00792                 O_COPIA2=2,
00793                 O_MEZCLA_H1H2=3,
00794                 O_MEZCLA_H1=4,
00795                 O_MEZCLA_H2=5,
00796                 O_COPIA_PRIMERO_1=6,
00797                 O_COPIA_PRIMERO_2=7;
00798                                 
00799               ;
00800         vector<long> dhijo1(0); // apuntadores a hijos de nodos en is1
00801         vector<int> dhijo2_saltacad(0); // Cuanto saltar de cad de hijos
00802         vector<NodoTrieS *> dhijo2(0); // apuntadores a hijos de nodos en a2
00803         vector<string> resto1(0); // Cadenas con las que comenazarán hijos
00804         vector<string> resto2(0); // Cadenas con las que comenzarían hijos
00805         vector<int> opera(0); // operación por realizar a hijos en 2da parte
00806         vector<long> pih(0); // posiciones de apuntadores a hijos en os
00807  
00808         long prini = os.tellp();
00809         //cout << "OJO mezclaDiscoRam prini=" << prini << ", is1.tellg()=" << is1.tellg() << ", a2=" << (long)a2 << endl;
00810         //cout << "peek1=" << is1.peek() << endl;
00811         //cout << "a2->cad.substr(saltacad)=" << a2->cad.substr(saltacad) << endl;
00812         for (cad1=is1.retCad(), cad2=a2.retCad), 
00813                         numhermanos = 0; 
00814                         (cad1!="" && (conHermanos1 || n1==0)) || 
00815                         (cad2!="" && (conHermanos2 || n2==0)); 
00816                          numhermanos++) {
00817                 //cout << "OJO mezclaDiscoRam prini=" << prini << "cad1=" << cad1 << ", cad2= "<< cad2 << endl;
00818                 dhijo1.push_back(-1);
00819                 dhijo2_saltacad.push_back(0);
00820                 dhijo2.push_back(NULL);
00821                 resto1.push_back("");
00822                 resto2.push_back("");
00823                 opera.push_back(-1);
00824                 pih.push_back(-1);
00825  
00826                 if (!conHermanos1 && n1 >= 1) {
00827                         cad1="";
00828                 }
00829                 if (!conHermanos2 && n2 >= 1) {
00830                         cad2="";
00831                 }
00832  
00833                 string c = "";
00834                 if (cad1 != "" && cad2 != "") { 
00835                         c = prefijo_comun_mas_largo(cad1, cad2);
00836                 }
00837                 //cout << " prefijo c="<<c<<endl;
00838                 if (c == "") { // No hay prefijo comun 
00839                         resto1[numhermanos] = "";
00840                         resto2[numhermanos] = "";
00841                         if (cad2=="" || (cad1!="" && cad1<cad2)) {
00842                                 // e.g AMOR y BUENO  o 
00843                                 //     ""   y BUENO
00844                                 //cout<< "se copia nodo de is1" <<endl;
00845                                 phermano1 = leeNDesp(is1);
00846                                 dhijo1[numhermanos] = is1.leeNDesp();
00847                                 dhijo2[numhermanos] = NULL;
00848                                 set<Pos> *cpos = leePos(is1, NULL);
00849                                 opera[numhermanos] = O_COPIA1;
00850                                 pih[numhermanos] = 
00851                                         escribeNodo(os, cad1, cpos, 0);
00852                                 delete cpos; cpos = NULL;
00853                                 cad1 = leeCad(is1);
00854                                 n1++;
00855                                 // cad2 quieto
00856                                 // en la recursión hijos de cad1
00857                                 //quedamos en el siguiente hermano mayor en is1
00858                         }
00859                         else { // cad2!="" && (cad1=="" || cad1 >= cad2) 
00860                                 // e.g BUENO y AMOR o
00861                                 //      ""   y AMOR
00862                                 ASSERT(cad1 == "" || (cad1 > cad2));
00863                                 //cout << "se copia nodo de a2" <<endl;
00864                                 dhijo1[numhermanos] = -1;
00865                                 dhijo2_saltacad[numhermanos] = 0;
00866                                 dhijo2[numhermanos] = a2->hijo_menor;
00867                                 //cout << "phermano2=" << phermano2 <<
00868                                 //        ", phijo=" << dhijo2[numhermanos] << endl;
00869                                 opera[numhermanos] = O_COPIA2;
00870                                 pih[numhermanos] = 
00871                                         escribeNodo(os, cad2, &(a2->cpos), 0);
00872                                 a2 = a2->hermano_mayor;
00873                                 cad2 = (a2 != NULL) ? a2->cad : "";
00874                                 n2++;
00875                         }
00876                 }
00877                 else if (cad1 == cad2) { // Hay prefijo c != "" && cad1!="" && cad2!=""
00878                         phermano1 = leeNDesp(is1);
00879                         dhijo1[numhermanos] = leeNDesp(is1);
00880                         dhijo2_saltacad[numhermanos] = 0;
00881                         dhijo2[numhermanos] = a2->hermano_mayor;
00882                         //cout << "iguales" <<endl;
00883                         set<Pos> cpos;
00884                         insert_iterator<set<Pos> >
00885                                 cpos_ins(cpos, cpos.begin());
00886                         set<Pos> *cpos1 = leePos(is1, NULL);
00887                         
00888                         set_union(cpos1->begin(), cpos1->end(),
00889                                 (a2->cpos).begin(), (a2->cpos).end(),
00890                                 cpos_ins);
00891                         pih[numhermanos] = escribeNodo(os, cad2, &cpos, 0);
00892                         delete cpos1; cpos1=NULL;
00893                         //En hijos NodoTrieS *m=mezcla(a1->hijo_menor, a2->hijo_menor);                         
00894                         resto1[numhermanos] = "";
00895                         resto2[numhermanos] = "";
00896                         opera[numhermanos] = O_MEZCLA_H1H2;
00897                         cad1 = leeCad(is1); n1++;
00898                         a2 = a2->hermano_mayor;
00899                         cad2 = (a2 != NULL) ? a2->cad : "";
00900                         n2++;
00901                 }
00902                 else { // hay prefijo c != "" && cad1!="" && cad2!="" && cad1!=cad2
00903                         string r1 = cad1.substr(c.size());
00904                         string r2 = cad2.substr(c.size());
00905                         resto1[numhermanos] = r1;
00906                         resto2[numhermanos] = r2;
00907                         ASSERT(r1 != "" || r2 != "");
00908                         //cerr << "hay posfijo r1="<<r1<<" r2="<<r2<<endl;
00909                         if (r1=="") { 
00910                                 // e.g BUENO BUENOS
00911                                 ASSERT(r2 != "");
00912                                 //cout << "r1 vacio"<<endl;
00913                                 // debe mezclar hijo de is1 con un sólo
00914                                 // nodo de a2 pero comenzando en el 
00915                                 // posfijo r2
00916                                 
00917                                 phermano1 = leeNDesp(is1);
00918                                 dhijo1[numhermanos] = leeNDesp(is1);
00919                                 dhijo2_saltacad[numhermanos] = c.length();
00920                                 dhijo2[numhermanos] = a2;
00921                                 a2 = a2->hermano_mayor; // Salta al sig en a2
00922                                 set<Pos> *cpos1 = leePos(is1, NULL);
00923                                 pih[numhermanos] = escribeNodo(os, c, cpos1, 0);
00924                                 opera[numhermanos] = O_MEZCLA_H1;
00925                                 delete cpos1; cpos1=NULL;
00926                         }
00927                         else if (r2 == "") { 
00928                                 // e.g BUENOS BUENO
00929                                 ASSERT(r1 != "");
00930                                 //cout << "r2 vacio"<<endl;
00931                                 //
00932                                 phermano1 = leeNDesp(is1);
00933                                 dhijo1[numhermanos] = (long)is1.tellg() -
00934                                         MAXLNUMERO - 1 - (long)r1.size();
00935                                 dhijo2_saltacad[numhermanos] = 0;
00936                                 dhijo2[numhermanos] = a2->hermano_mayor;
00937                                 is1.seekg(phermano1);
00938                                 //cout << "OJO en nodo dhijo2[numhermanos]="
00939                                 //<< dhijo2[numhermanos] << endl;
00940                                 pih[numhermanos] = escribeNodo(os, c, 
00941                                                 &(a2->cpos), 0);
00942                                 // Recursion NodoTrieS *m=mezcla(n1, a2->hijo_menor);
00943                                 a2 = a2->hermano_mayor;
00944                                 opera[numhermanos] = O_MEZCLA_H2;
00945                         }
00946                         else if (r1 < r2) {
00947                                 // e.g BUENA BUENO
00948                                 //cout << "r1<r2"<<endl;
00949                                 
00950                                 phermano1 = leeNDesp(is1);
00951                                 pih[numhermanos] = escribeNodo(os, c, NULL, 0);
00952                                 dhijo1[numhermanos] = (long)is1.tellg() -
00953                                         MAXLNUMERO - 1 - (long)r1.size();
00954                                 dhijo2_saltacad[numhermanos] = c.length();
00955                                 dhijo2[numhermanos] = a2;
00956                                 is1.seekg(phermano1);
00957                                 a2 = a2->hermano_mayor;
00958                                 opera[numhermanos] = O_COPIA_PRIMERO_1;
00959                                 // El hijo de este nodo debe ser
00960                                 // a1 con hermano mayor a2
00961                                 // r=new NodoTrieS(c, n1, NULL, set<Pos>());
00962                         }
00963                         else { // r1 >= r2 
00964                                 // e.g BUENO BUENA
00965                                 //cout << "r2 <= r1"<<endl;
00966                                 phermano1 = leeNDesp(is1);
00967                                 pih[numhermanos] = escribeNodo(os, c, NULL, 0);
00968                                 dhijo1[numhermanos] = (long)is1.tellg() -
00969                                         MAXLNUMERO - 1 - (long)r1.size();
00970                                 dhijo2_saltacad[numhermanos] = c.length();
00971                                 dhijo2[numhermanos] = a2->hermano_mayor;
00972                                 //saltaPos(is1); leeNDesp(is1);
00973                                 is1.seekg(phermano1);
00974                                 a2 = a2->hermano_mayor;
00975                                 opera[numhermanos] = O_COPIA_PRIMERO_2;
00976                         }
00977                         cad1=leeCad(is1); n1++;
00978                         cad2=(a2 != NULL ? a2->cad : ""); n2++;
00979                 }
00980         }
00981         os << endl;
00982         //cout << "Termina hermanos, pasa a hijos" << endl;
00983  
00984         // Desplazamientos en os
00985         long pini, pfin;
00986         long hijo1 = 0;
00987         NodoTrieS *hijo2 = NULL;
00988         long ph1, ph2, pnh1, pnh2;
00989         for (int n = 0; n < numhermanos; n++) { 
00990                 pini = 0; // Posición donde queda hijo en os
00991                 switch (opera[n]) {
00992                         case O_COPIA1:
00993                                 //cout << "COPIA1" <<endl;
00994                                 if (dhijo1[n] > 0) {
00995                                         is1.seekg(dhijo1[n]);
00996                                         pini = escribeCopiaSubarbol(os, is1, 
00997                                                         true, NULL);
00998                                 }
00999                                 break;
01000  
01001                         case O_COPIA2:
01002                                 //cout << "COPIA2" <<endl;
01003                                 if (dhijo2[n] != NULL) {
01004                                         //cout << "dhijo2[" << n << "]=" <<
01005                                                 //dhijo2[n] << endl;
01006                                         pini = escribeCopiaSubarbolRam(os, 
01007                                                         dhijo2[n], 
01008                                                         0, true, renum);
01009                                 }
01010                                 break;
01011  
01012                         case O_MEZCLA_H1H2:
01013                                 //cout << "MEZCLA_H1H2" <<endl;
01014                 if (depuraos!=NULL) {
01015                         //cout << depuraos->str() << endl;
01016                 }
01017  
01018                                 
01019                                 if (dhijo1[n] > 0 && dhijo2[n] != NULL) {
01020                                         is1.seekg(dhijo1[n]);
01021                                         pini = mezclaDiscoRam(is1, dhijo2[n], 
01022                                                         dhijo2_saltacad[n], os, 
01023                                                         true, true, renum) ;
01024                                 }
01025                                 else if (dhijo1[n] > 0) {
01026                                         ASSERT(dhijo2[n] == NULL);
01027                                         is1.seekg(dhijo1[n]);
01028                                         pini = escribeCopiaSubarbol(os, is1, 
01029                                                         true, NULL);
01030                                 }
01031                                 else if (dhijo2[n] != NULL) {
01032                                         //cout << "OJO dhijo2[n]=" <<dhijo2[n]<< endl;
01033                                         ASSERT(dhijo1[n] == 0);
01034                                         pini = escribeCopiaSubarbolRam(os, 
01035                                                         dhijo2[n], 
01036                                                         dhijo2_saltacad[n],
01037                                                         true, renum);
01038                                         //cout << "OJO pini=" << pini << endl;
01039                                 }
01040                                 break;
01041                         case O_MEZCLA_H1:
01042                                 //cout << "MEZCLA_H1" <<endl;
01043                                 ASSERT(dhijo2[n] != NULL);
01044  
01045                                 //cout << "OJO dhijo2[n]=" << dhijo2[n] << endl;
01046                                 if (dhijo1[n] > 0) {
01047                                         is1.seekg(dhijo1[n]);
01048                                         pini = mezclaDiscoRam(is1, dhijo2[n],
01049                                                        dhijo2_saltacad[n],
01050                                                        os, true, false, renum) ;
01051                                 }
01052                                 else {
01053                                         pini = escribeCopiaSubarbolRam(os, 
01054                                                         dhijo2[n], 
01055                                                         dhijo2_saltacad[n],
01056                                                         false, renum);
01057                                 }
01058                                 break;
01059  
01060                         case O_MEZCLA_H2:
01061                                 //cout << "MEZCLA_H2" <<endl;
01062                                 ASSERT(dhijo1[n] != 0);
01063  
01064                                 is1.seekg(dhijo1[n]);
01065                                 //cout << "dhijo2[n]=" << dhijo2[n] <<  endl;
01066                                 if (dhijo2[n] != NULL) {
01067                                         pini = mezclaDiscoRam(is1, dhijo2[n], 
01068                                                         dhijo2_saltacad[n],
01069                                                         os, false, true, renum) ;
01070                                 }
01071                                 else {
01072                                         pini = escribeCopiaSubarbol(os, is1, 
01073                                                         false, NULL);
01074                                 }
01075                                 break;
01076  
01077                         case O_COPIA_PRIMERO_1:
01078                                 //cout << "COPIA_PRIMERO_1" <<endl;
01079                                 ASSERT(dhijo1[n] != 0);
01080                                 ASSERT(dhijo2[n] != NULL);
01081  
01082                                 is1.seekg(dhijo1[n]);
01083                                 pini = os.tellp();
01084  
01085                                 // pos no es NULL en los siguientes,
01086                                 // más bien copiar de is1 y a2 e hijos
01087                                 // después.
01088                                 pnh1=escribeCopiaNodo(os, is1, hijo1, NULL);
01089                                 pnh2=escribeCopiaNodoRam(os, dhijo2[n],
01090                                                 dhijo2_saltacad[n], 
01091                                                 &hijo2, renum);
01092                                 os << endl;
01093                                 ph1=os.tellp();
01094                                 if (hijo1 > 0) {
01095                                         is1.seekg(hijo1);
01096                                         (void)escribeCopiaSubarbol(os, is1, 
01097                                                         true, NULL);
01098                                 }
01099                                 ph2=os.tellp();
01100                                 if (hijo2 != NULL) {
01101                                         escribeCopiaSubarbolRam(os, hijo2, 
01102                                                         0, true, renum);
01103                                 }
01104                                 pfin = os.tellp();
01105                                 if (hijo1 > 0) {
01106                                         os.seekp(pnh1);
01107                                         escribeNDesp(os, ph1);
01108                                 }
01109                                 if (hijo2 != NULL) {
01110                                         os.seekp(pnh2);
01111                                         escribeNDesp(os, ph2);
01112                                 }
01113                                 os.seekp(pfin);
01114  
01115                                 break;
01116  
01117                         case O_COPIA_PRIMERO_2:
01118                                 //cout << "COPIA_PRIMERO_2" <<endl;
01119                                 ASSERT(dhijo1[n] != 0);
01120                                 ASSERT(dhijo2[n] != NULL);
01121  
01122                                 is1.seekg(dhijo1[n]);
01123                                 pini = os.tellp();
01124                                 
01125                                 pnh2=escribeCopiaNodoRam(os, dhijo2[n],
01126                                                 dhijo2_saltacad[n], 
01127                                                 &hijo2, renum);
01128                                 pnh1=escribeCopiaNodo(os, is1, hijo1, NULL);
01129                                 os << endl;
01130                                 ph2=os.tellp();
01131                                 if (hijo2 != NULL) {
01132                                         escribeCopiaSubarbolRam(os, hijo2,
01133                                                         0, true, renum);
01134                                 }
01135                                 ph1=os.tellp();
01136                                 if (hijo1 > 0) {
01137                                         is1.seekg(hijo1);
01138                                         escribeCopiaSubarbol(os, is1, 
01139                                                         true, NULL);
01140                                 }
01141                                 pfin = os.tellp();
01142                                 if (hijo2 != NULL) {
01143                                         os.seekp(pnh2);
01144                                         escribeNDesp(os, ph2);
01145                                 }
01146                                 if (hijo1 > 0) {
01147                                         os.seekp(pnh1);
01148                                         escribeNDesp(os, ph1);
01149                                 }
01150                                 os.seekp(pfin);
01151  
01152                                 break;
01153  
01154                         default:
01155                                 throw std::string("Falla: estado desconocido");
01156                                 break;
01157                 }
01158                 pfin = os.tellp();
01159                 //cout << "OJO pfin=" << pfin << endl;
01160                 //cout << "OJO n=" << n << ", pih[n]=" << pih[n]<< endl;
01161                 os.seekp(pih[n]);
01162                 escribeNDesp(os, pini);
01163                 os.seekp(pfin);
01164         }
01165         //cout << "Termina hijos" << endl;
01166         return prini;
01167 }
01168  
01169 */
Generado el Wed Jan 6 06:58:22 2010 para Mt77 por  doxygen 1.5.4