Arbol Class Reference

Clase que crea una estructura en forma de arbol para almacenar el plan contable. More...

#include <arbol.h>


Public Member Functions

 Arbol ()
 ~Arbol ()
void nuevarama (cursor2 *)
 Añade una nueva rama al arbol con su hoja.
void inicializa (cursor2 *)
 Constituye el arbol inicializando los valores que corresponden a cada cuenta (hoja).
void actualizahojas (cursor2 *)
 Actualiza los valores de las hojas en el arbol.
void inicia ()
 Inicializa el acceso al arbol cambiando el valor de la variable "visitada".
bool deshoja (unsigned int, bool)
 Mueve el puntero que indexa una hoja del arbol: primer parametro indica el nivel en el que queremos deshojar; el segundo si deshoja o no otros niveles.
QString hojaactual (QString)
 Devuelve el valor solicitado: codigo, saldoant, debe, haber, saldo, debeej, haberej, saldoej, etc.
bool irHoja (QString, unsigned int nivel=4)

Private Member Functions

void SintetizarRamas (cursor2 **, tiporama **)
 Código de la última hoja visitada (nos servirá de índice).
void ActualizarHoja (tiporama **, cursor2 *, bool *)
void Deshojar (tiporama *, unsigned int, bool, bool *)

Private Attributes

tipohoja ** raiz
tipohoja * hoja
 Raiz del arbol que contiene todas las cuentas de nivel 2.
tiporama * rama
 Hoja que contiene los datos de una cuenta.
postgresiface2 * conexionbase
 Rama que contiene una hoja y más ramas o no.
QString hojaactiva
 Nos da acceso a la base de datos con la que estamos trabajando.

Data Structures

struct  tipohoja
struct  tiporama

Detailed Description

Clase que crea una estructura en forma de arbol para almacenar el plan contable.

Fichero de definicion de las clase arbol. Crea una estructura tipo arbol para almacenar en memoria dinamica todas las cuentas del plan contable de la base de datos y calcula sus saldos cuando se genera. La potencia de esta estructura radica en la actualizacion automatica de todos los estados de cada cuenta (las hojas) cada vez que se modifican los valores de alguna de ellas.

Definition at line 40 of file arbol.h.

Constructor & Destructor Documentation

Arbol::Arbol (  ) 

Definition at line 27 of file arbol.cpp.

References _depura(), and raiz.

00027              {
00028     _depura("Arbol::Arbol", 0);
00029     unsigned int i;
00031     raiz = new tipohoja*[70];
00033     for (i = 0; i < 70; i++) {
00034         raiz[i] = NULL;
00035     } // end for
00036     _depura("END Arbol::Arbol", 0);
00037 }

Arbol::~Arbol (  ) 

Definition at line 43 of file arbol.cpp.

References _depura(), hoja, raiz, and rama.

00043               {
00044     _depura("Arbol::~Arbol", 0);
00045     unsigned int i;
00047     for (i = 0; i < 70; i++) {
00048         raiz[i] = NULL;
00049     }
00050     delete raiz;
00051     delete hoja;
00052     delete rama;
00053     _depura("END Arbol::~Arbol", 0);
00054 }

Member Function Documentation

void Arbol::SintetizarRamas ( cursor2 **  cuentas,
tiporama **  ramas 
) [private]

Código de la última hoja visitada (nos servirá de índice).

Parameters:
cuentas 
ramas 

Reservamos un huequecito de memoria para almacenar los datos de la rama.

Idem para una hojita.

Pero aún puede haber más ramas que crezcan, en tal caso habrá que sintetizarlas

Definition at line 131 of file arbol.cpp.

References _depura(), Arbol::tipohoja::codigo, cuentas, Arbol::tipohoja::debe, Arbol::tipohoja::debeej, Arbol::tipohoja::descripcion, cursor2::eof(), Arbol::tipohoja::haber, Arbol::tipohoja::haberej, Arbol::tiporama::hoja, hoja, Arbol::tipohoja::idcuenta, Arbol::tipohoja::numapuntes, rama, Arbol::tipohoja::ramas, Arbol::tipohoja::saldo, Arbol::tipohoja::saldoant, Arbol::tipohoja::saldoej, Arbol::tiporama::sgte, cursor2::siguienteregistro(), and cursor2::valor().

Referenced by inicializa().

00131                                                                {
00132     _depura("Arbol::SintetizarRamas", 0);
00133     tiporama *guia, *rama;
00134     tipohoja *hoja;
00135     int nivel;
00136     cursor2* ptrcuentas = *cuentas;
00137     nivel = atoi(ptrcuentas->valor("nivel").toAscii().constData());
00138     ptrcuentas->siguienteregistro();
00139     guia = NULL;
00140     while (!ptrcuentas->eof() && (atoi(ptrcuentas->valor("nivel").toAscii().constData()) > nivel)) {
00142         rama = new tiporama;
00143         if (!guia) {
00144             *ramas = guia = rama;
00145         } else {
00146             guia->sgte = rama;
00147             guia = guia->sgte;
00148         } // end if
00149         hoja = new tipohoja; 
00150         hoja->idcuenta = atoi(ptrcuentas->valor("idcuenta").toAscii().constData());
00151         hoja->codigo = ptrcuentas->valor("codigo");
00152         hoja->descripcion = ptrcuentas->valor("descripcion");
00153         hoja->saldoant = hoja->debe = hoja->haber = hoja->saldo = hoja->debeej = hoja->haberej = hoja->saldoej = Fixed("0.00");
00154         hoja->numapuntes = 0;
00155         hoja->ramas = NULL;
00156         guia->hoja = hoja;
00157         guia->sgte = NULL;
00160         SintetizarRamas(&ptrcuentas, &(hoja->ramas));
00161     } // end while
00162     _depura("END Arbol::SintetizarRamas", 0);
00163 }

void Arbol::ActualizarHoja ( tiporama **  ramaraiz,
cursor2 *  cuenta,
bool *  actualizado 
) [private]

Parameters:
ramaraiz 
cuenta 
actualizado 

Buscamos por cada una de las ramas.

Ponemos los valores obtenidos de la BD.

A la vuelta, actualizamos los valores si alguna hoja fue actualizada.

Definition at line 205 of file arbol.cpp.

References _depura(), Arbol::tipohoja::debe, Arbol::tipohoja::debeej, Arbol::tipohoja::haber, Arbol::tipohoja::haberej, Arbol::tiporama::hoja, Arbol::tipohoja::idcuenta, Arbol::tipohoja::numapuntes, rama, Arbol::tipohoja::ramas, Arbol::tipohoja::saldo, Arbol::tipohoja::saldoant, Arbol::tipohoja::saldoej, Arbol::tiporama::sgte, and cursor2::valor().

Referenced by actualizahojas().

00205                                                                                   {
00206     _depura("Arbol::ActualizarHoja", 0);
00207     tiporama* rama = *ramaraiz;
00209     while (rama && !(*actualizado)) {
00210         int idcuenta = atoi(cuenta->valor("idcuenta").toAscii().constData());
00211         if (rama->hoja->idcuenta == idcuenta) {
00213             rama->hoja->saldoant = Fixed(cuenta->valor("saldoant"));
00214             rama->hoja->debe = Fixed(cuenta->valor("debe"));
00215             rama->hoja->haber = Fixed(cuenta->valor("haber"));
00216             rama->hoja->saldo = Fixed(cuenta->valor("saldo"));
00217             rama->hoja->debeej = Fixed(cuenta->valor("debeej"));
00218             rama->hoja->haberej = Fixed(cuenta->valor("haberej"));
00219             rama->hoja->saldoej = Fixed(cuenta->valor("saldoej"));
00220             rama->hoja->numapuntes = cuenta->valor("numapuntes").toInt();
00221             *actualizado = true;
00222         } else {
00223             if (rama->hoja->ramas) {
00224                 ActualizarHoja(&(rama->hoja->ramas), cuenta, &(*actualizado));
00226                 if (*actualizado) {
00227                     rama->hoja->saldoant = rama->hoja->saldoant + Fixed(cuenta->valor("saldoant"));
00228                     rama->hoja->debe = rama->hoja->debe + Fixed(cuenta->valor("debe"));
00229                     rama->hoja->haber = rama->hoja->haber + Fixed(cuenta->valor("haber"));
00230                     rama->hoja->saldo = rama->hoja->saldo + Fixed(cuenta->valor("saldo"));
00231                     rama->hoja->debeej = rama->hoja->debeej + Fixed(cuenta->valor("debeej"));
00232                     rama->hoja->haberej = rama->hoja->haberej + Fixed(cuenta->valor("haberej"));
00233                     rama->hoja->saldoej = rama->hoja->saldoej + Fixed(cuenta->valor("saldoej"));
00234                     rama->hoja->numapuntes += cuenta->valor("numapuntes").toInt();
00235                 } // end if
00236             } // end if
00237         } // end if
00238         rama = rama->sgte;
00239     } // end while
00240     _depura("END Arbol::ActualizarHoja", 0);
00241 }

void Arbol::Deshojar ( tiporama *  rama,
unsigned int  nivel,
bool  superiores,
bool *  deshojada 
) [private]

Parameters:
rama 
nivel 
superiores 
deshojada 

No deshojaremos por aquí, busquemos por otra rama.

Deshojamos

Puede ser que hojas del mismo nivel en el arbol no sean del mismo nivel de cuentas. Ej: 4750001, 4751 y 4752 podrian ser hojas hermanas porque no exista un 4750 En este caso, recorreremos tambien sus hojas hermanas por si acaso.

Definition at line 330 of file arbol.cpp.

References _depura(), Arbol::tipohoja::codigo, hoja, Arbol::tiporama::hoja, hojaactiva, Arbol::tipohoja::numapuntes, rama, Arbol::tipohoja::ramas, and Arbol::tiporama::sgte.

Referenced by deshoja().

00330                                                                                          {
00331     _depura("Arbol::Deshojar", 0);
00332     unsigned int nivelhoja = rama->hoja->codigo.length();
00333     if (hojaactiva >= rama->hoja->codigo) {
00334         if (rama->hoja->ramas && nivelhoja < nivel)
00335             Deshojar(rama->hoja->ramas, nivel, superiores, &(*deshojada));
00336         if (rama->sgte && !(*deshojada))
00337             Deshojar(rama->sgte, nivel, superiores, &(*deshojada));
00338     } else {
00340         if (rama->hoja->numapuntes == 0) {
00341             if (rama->sgte)
00342                 Deshojar(rama->sgte, nivel, superiores, &(*deshojada));
00343         } else { 
00344             if (superiores) {
00345                 if (nivelhoja <= nivel) {
00346                     hoja = rama->hoja;
00347                     hojaactiva = hoja->codigo;
00348                     *deshojada = true;
00349                 } else {
00350                     if (rama->sgte)
00357                         Deshojar(rama->sgte, nivel, superiores, &(*deshojada));
00358                 } // end if
00359             } else {
00360                 if (nivelhoja == nivel) {
00361                     hoja = rama->hoja;
00362                     hojaactiva = hoja->codigo;
00363                     *deshojada = true;
00364                 } else {
00365                     if (rama->hoja->ramas && nivelhoja < nivel)
00366                         Deshojar(rama->hoja->ramas, nivel, superiores, &(*deshojada));
00367                     if (rama->sgte && !(*deshojada))
00368                         Deshojar(rama->sgte, nivel, superiores, &(*deshojada));
00369                 } // end if
00370             } // end if
00371         } // end if
00372     } // end if
00373     _depura("END Arbol::Deshojar", 0);
00374 }

void Arbol::nuevarama ( cursor2 *  ramas  ) 

Añade una nueva rama al arbol con su hoja.

Parameters:
ramas 

Rellenamos los valores de inicializacion para una hoja.

Buscamos en que rama hay que poner la hoja.

Definition at line 61 of file arbol.cpp.

References _depura(), Arbol::tipohoja::codigo, Arbol::tipohoja::debe, Arbol::tipohoja::debeej, Arbol::tipohoja::descripcion, Arbol::tipohoja::haber, Arbol::tipohoja::haberej, hoja, Arbol::tipohoja::idcuenta, Arbol::tipohoja::numapuntes, raiz, Arbol::tipohoja::ramas, Arbol::tipohoja::saldo, Arbol::tipohoja::saldoant, Arbol::tipohoja::saldoej, and cursor2::valor().

Referenced by CAnualesPrintView::on_mui_aceptar_clicked(), BalancePrintView::presentar(), and BalanceView::presentarSyS().

00061                                     {
00062     _depura("Arbol::nuevarama", 0);
00063     unsigned int i;
00065     hoja = new tipohoja;
00066     hoja->idcuenta = atoi(ramas->valor("idcuenta").toAscii().constData());
00067     hoja->codigo = QString(ramas->valor("codigo"));
00068     hoja->descripcion = QString(ramas->valor("descripcion"));
00069     hoja->saldoant = hoja->debe = hoja->haber = hoja->saldo = hoja->debeej = hoja->haberej = hoja->saldoej = Fixed("0.00");
00070     hoja->numapuntes = 0;
00071     hoja->ramas = NULL;
00073     for(i = 0; i < 70 && raiz[i]; i++) {}
00074     raiz[i] = hoja;
00075     _depura("END Arbol::nuevarama", 0);
00076 }

void Arbol::inicializa ( cursor2 *  ramas  ) 

Constituye el arbol inicializando los valores que corresponden a cada cuenta (hoja).

Parameters:
ramas 

Hay que construir el arbol con todas sus hojitas (cuentas).

Creamos las primeras hojas en la raíz y sintetizamos el resto recursivamente (si es que existen aun más hojas hijas).

Creamos una hoja.

Creamos la unión con la raíz.

Avanzamos el puntero a la siguiente supuesta rama.

Buscamos si además de esta hoja hay más ramas que crezcan, en tal caso habrá que sintetizarlas.

Definition at line 83 of file arbol.cpp.

References _depura(), Arbol::tipohoja::codigo, Arbol::tipohoja::debe, Arbol::tipohoja::debeej, Arbol::tipohoja::descripcion, cursor2::eof(), Arbol::tipohoja::haber, Arbol::tipohoja::haberej, Arbol::tiporama::hoja, hoja, Arbol::tipohoja::idcuenta, Arbol::tipohoja::numapuntes, cursor2::primerregistro(), rama, Arbol::tipohoja::ramas, Arbol::tipohoja::saldo, Arbol::tipohoja::saldoant, Arbol::tipohoja::saldoej, Arbol::tiporama::sgte, cursor2::siguienteregistro(), SintetizarRamas(), and cursor2::valor().

Referenced by CAnualesPrintView::on_mui_aceptar_clicked(), BalancePrintView::presentar(), and BalanceView::presentarSyS().

00083                                      {
00084     _depura("Arbol::inicializa", 0);
00085     unsigned int i;
00086     QString padre;
00087     tiporama* guia = NULL;
00088     ramas->primerregistro();
00090     for(i = 0; raiz[i] && i < 70; i++) {
00091         padre = raiz[i]->codigo;
00094         while (!ramas->eof() && ramas->valor("codigo").startsWith(padre)) {
00095             if (ramas->valor("nivel").toInt() > 2) {
00097                 hoja = new tipohoja;
00098                 hoja->idcuenta = atoi(ramas->valor("idcuenta").toAscii().constData());
00099                 hoja->codigo = QString(ramas->valor("codigo"));
00100                 hoja->descripcion = QString(ramas->valor("descripcion"));
00101                 hoja->saldoant = hoja->debe = hoja->haber = hoja->saldo = hoja->debeej = hoja->haberej = hoja->saldoej = Fixed("0.00");
00102                 hoja->numapuntes = 0;
00103                 hoja->ramas = NULL;
00104                 rama = new tiporama;
00105                 rama->hoja = hoja;
00106                 rama->sgte = NULL;
00108                 if (!raiz[i]->ramas) {
00109                     raiz[i]->ramas = guia = rama;
00110                 } else { 
00111                     guia->sgte = rama;
00112                     guia = guia->sgte;
00113                 } // end if
00116                 SintetizarRamas(&ramas, &(hoja->ramas));
00117             } else {
00118                 ramas->siguienteregistro();
00119             } // end if
00120         } // end while
00121     } // end for
00122     _depura("END Arbol::inicializa", 0);
00123 }

void Arbol::actualizahojas ( cursor2 *  cuenta  ) 

Actualiza los valores de las hojas en el arbol.

Parameters:
cuenta 

Definition at line 170 of file arbol.cpp.

References _depura(), ActualizarHoja(), Arbol::tipohoja::debe, Arbol::tipohoja::debeej, Arbol::tipohoja::haber, Arbol::tipohoja::haberej, Arbol::tipohoja::numapuntes, Arbol::tipohoja::ramas, Arbol::tipohoja::saldo, Arbol::tipohoja::saldoant, Arbol::tipohoja::saldoej, and cursor2::valor().

Referenced by CAnualesPrintView::on_mui_aceptar_clicked(), BalancePrintView::presentar(), and BalanceView::presentarSyS().

00170                                           {
00171     _depura("Arbol::actualizahojas", 0);
00172     unsigned int i = 0;
00173     bool actualizado;
00174     tipohoja *hojaraiz;
00175 
00176     QString cuentapadre = cuenta->valor("codigo").left(2);
00177     do {
00178         hojaraiz = raiz[i];
00179         i++;
00180     } while (i < 70 && cuentapadre != hojaraiz->codigo);
00181     actualizado = false;
00182     if (hojaraiz->ramas) {
00183         ActualizarHoja(&(hojaraiz->ramas), cuenta, &actualizado);
00184         if (actualizado) {
00185             hojaraiz->saldoant = hojaraiz->saldoant + Fixed(cuenta->valor("saldoant"));
00186             hojaraiz->debe = hojaraiz->debe + Fixed(cuenta->valor("debe"));
00187             hojaraiz->haber = hojaraiz->haber + Fixed(cuenta->valor("haber"));
00188             hojaraiz->saldo = hojaraiz->saldo + Fixed(cuenta->valor("saldo"));
00189             hojaraiz->debeej = hojaraiz->debeej + Fixed(cuenta->valor("debeej"));
00190             hojaraiz->haberej = hojaraiz->haberej + Fixed(cuenta->valor("haberej"));
00191             hojaraiz->saldoej = hojaraiz->saldoej + Fixed(cuenta->valor("saldoej"));
00192             hojaraiz->numapuntes += cuenta->valor("numapuntes").toInt();
00193         } // end if
00194     } // end if
00195     _depura("END Arbol::actualizahojas", 0);
00196 }

void Arbol::inicia (  ) 

Inicializa el acceso al arbol cambiando el valor de la variable "visitada".

Siempre será la primera del arbol.

Definition at line 247 of file arbol.cpp.

References _depura(), and hojaactiva.

Referenced by BalancePrintView::presentar(), and BalanceView::presentarSyS().

00247                    {
00248     _depura("Arbol::inicia", 0);
00250     hojaactiva = QString("00");
00251     _depura("END Arbol::inicia", 0);
00252 }

bool Arbol::deshoja ( unsigned int  nivel,
bool  superiores 
)

Mueve el puntero que indexa una hoja del arbol: primer parametro indica el nivel en el que queremos deshojar; el segundo si deshoja o no otros niveles.

Parameters:
nivel 
superiores 
Returns:

Primero averiguamos en qué raíz deshojamos la última vez para continuar por ahí.

Miramos si hay hoja candidata que deshojar.

Si hay que sacar los niveles superiores tenemos que deshojar también en el nivel 2.

Sólo deshojamos si ha habido movimientos en la cuenta durante el ejercicio.

Buscamos por las hojas hijas.

Sólo deshojamos si ha habido movimientos en la cuenta durante el ejercicio.

Definition at line 261 of file arbol.cpp.

References _depura(), Arbol::tipohoja::codigo, Deshojar(), hoja, hojaactiva, and Arbol::tipohoja::numapuntes.

Referenced by irHoja(), BalancePrintView::presentar(), and BalanceView::presentarSyS().

00261                                                        {
00262     _depura("Arbol::deshoja", 0);
00263     unsigned int i;
00264     bool deshojada = false;
00265     if (nivel > 2) {
00268         QString raizcandidata = hojaactiva.left(2);
00269         if (hojaactiva == QString("00"))
00270             i = 0;
00271         else {
00272             for(i = 0; i < 70 && raiz[i]; i++) {
00273                 if (raiz[i]->codigo == raizcandidata)
00274                     break;
00275             } // end for
00276         } // end if
00278         while (!deshojada && raiz[i]) {
00281             if (superiores && raiz[i]->codigo > hojaactiva && raiz[i]->numapuntes > 0) {
00282                 hoja = raiz[i];
00285                 if (hoja->numapuntes > 0) {
00286                     hojaactiva = hoja->codigo;
00287                     deshojada = true;
00288                 } // end if
00289             } else {
00290                 if (raiz[i]->ramas)
00292                     Deshojar(raiz[i]->ramas, nivel, superiores, &deshojada);
00293             } // end if
00294             i++;
00295         } // end while
00296     } else {
00297         if (hojaactiva == QString("00")) {
00298             if (raiz[0]) {
00299                 hojaactiva = raiz[0]->codigo;
00300                 hoja = raiz[0];
00301                 deshojada = true;
00302             } // end if
00303         } else {
00304             for (i = 0; i < 70 && raiz[i]; i++) {
00305                 if(raiz[i]->codigo > hojaactiva) {
00306                     hoja = raiz[i];
00309                     if (hoja->numapuntes > 0) {
00310                         hojaactiva = hoja->codigo;
00311                         deshojada = true;
00312                         break;
00313                     }
00314                 } // end if
00315             } // end for
00316         } // end if
00317     } // end if
00318     return deshojada;
00319     _depura("END Arbol::deshoja", 0);
00320 }

QString Arbol::hojaactual ( QString  valor  ) 

Devuelve el valor solicitado: codigo, saldoant, debe, haber, saldo, debeej, haberej, saldoej, etc.

Parameters:
valor 
Returns:

Definition at line 382 of file arbol.cpp.

References _depura(), Arbol::tipohoja::codigo, Arbol::tipohoja::debe, Arbol::tipohoja::debeej, Arbol::tipohoja::descripcion, Arbol::tipohoja::haber, Arbol::tipohoja::haberej, hoja, Arbol::tipohoja::idcuenta, Arbol::tipohoja::saldo, Arbol::tipohoja::saldoant, Arbol::tipohoja::saldoej, and Fixed::toQString().

Referenced by irHoja(), CAnualesPrintView::on_mui_aceptar_clicked(), BalancePrintView::presentar(), and BalanceView::presentarSyS().

00382                                        {
00383     _depura("Arbol::hojaactual", 0);
00384     QString resultado;
00385     if (valor == "saldoant")
00386         resultado = hoja->saldoant.toQString();
00387     else if (valor == "debe" )
00388         resultado = hoja->debe.toQString();
00389     else if (valor == "haber" )
00390         resultado = hoja->haber.toQString();
00391     else if (valor == "saldo" )
00392         resultado = hoja->saldo.toQString();
00393     else if (valor == "debeej" )
00394         resultado = hoja->debeej.toQString();
00395     else if (valor == "haberej" )
00396         resultado = hoja->haberej.toQString();
00397     else if (valor == "saldoej" )
00398         resultado = hoja->saldoej.toQString();
00399     else if (valor == "codigo" )
00400         resultado = hoja->codigo;
00401     else if (valor == "descripcion" )
00402         resultado = hoja->descripcion;
00403     else if (valor == "idcuenta" )
00404         resultado.setNum(hoja->idcuenta);
00405     else
00406         _depura("Campo " + valor + " no encontrado en la hoja del arbol", 2);
00407     return resultado;
00408     _depura("END Arbol::hojaactual", 0);
00409 }

bool Arbol::irHoja ( QString  ,
unsigned int  nivel = 4 
)

Se posiciona el puntero en la hoja cuyo codigo corresponde al pasado por parametro e informa del exito o no El segundo parametro indica a que nivel de profundidad buscar las cuentas; por defecto a 4, el m�imo exigido en un balance abreviado

Definition at line 418 of file arbol.cpp.

References _depura(), deshoja(), hojaactiva, and hojaactual().

Referenced by CAnualesPrintView::on_mui_aceptar_clicked().

00418                                                      {
00419     _depura("Arbol::irHoja", 0);
00420     hojaactiva = QString("00");
00421     while (deshoja(nivel, true) && hojaactual("codigo") != codigo);
00422     if (hojaactual("codigo") == codigo) {
00423         return true;
00424     } else {
00425         return false;
00426     } // end if
00427     _depura("END Arbol::irHoja", 0);
00428 }

Field Documentation

tipohoja** Arbol::raiz [private]

Definition at line 56 of file arbol.h.

Referenced by Arbol(), nuevarama(), and ~Arbol().

tipohoja* Arbol::hoja [private]

Raiz del arbol que contiene todas las cuentas de nivel 2.

Definition at line 57 of file arbol.h.

Referenced by deshoja(), Deshojar(), hojaactual(), inicializa(), nuevarama(), SintetizarRamas(), and ~Arbol().

tiporama* Arbol::rama [private]

Hoja que contiene los datos de una cuenta.

Definition at line 58 of file arbol.h.

Referenced by ActualizarHoja(), Deshojar(), inicializa(), SintetizarRamas(), and ~Arbol().

postgresiface2* Arbol::conexionbase [private]

Rama que contiene una hoja y más ramas o no.

Definition at line 59 of file arbol.h.

QString Arbol::hojaactiva [private]

Nos da acceso a la base de datos con la que estamos trabajando.

Definition at line 60 of file arbol.h.

Referenced by deshoja(), Deshojar(), inicia(), and irHoja().

The documentation for this class was generated from the following files:
Generated on Sat Dec 15 00:01:42 2007 for BulmaGes by  doxygen 1.5.1