/**Inserta un atribuoto, el entidad especificada*/ public void insAtributo(CNodoAtributo nuevo, CNodoEntidad ent) { CNodoAtributo aux, ant = null; aux = ent.getCabListAtri(); while (aux != null) { ant = aux; aux = aux.getSigAtri(); } if (aux == ent.getCabListAtri()) ent.setCabListAtri(nuevo); else ant.setSigAtri(nuevo); nuevo.setSigAtri(aux); }
/**Inicializa los controles necesaria para iniciar la interfaz de la organización*/ public void iniControles() { CNodoEntidad ent = archivo.getListaEntidad().getCabListEnt(); while (ent != null) { listaEnt.Items.Add(ent.getNombre()); ent = ent.getSigEnt(); } tablaDatos = new DataGridView(); tablaDatos.BackgroundColor = Color.White; tablaDatos.AllowUserToAddRows = false; Size tamaño = new Size(475, 331); tablaDatos.Location = new Point(299, 29); tablaDatos.Size = tamaño; tablaDatos.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill; Controls.Add(getTablaDatos()); }
/** Inserta una objeto entidad en la lista de etnidades*/ public void insEntidad(CNodoEntidad nueva) { CNodoEntidad aux, ant = null; aux = getCabListEnt(); while (aux != null) { ant = aux; aux = aux.getSigEnt(); } if (aux == cabListEnt) cabListEnt = nueva; else ant.setSigEnt(nueva); nueva.setSigEnt(aux); }
private void dameBloquesDatos(ref List<CBloque> lB, CNodoEntidad nE, CBloque bS, CNodoEntidad e) { CBloque bloqueAux; CTablaHashExt tH; List<CCubeta> listaCub; CCubeta cubetaAux; long ptrAux, ptrAux2; int despCE, tipoD, tamCE, tamBloq, despCB, tipoCB, tamCB; ; despCE = tipoD = tamCE = tamBloq = despCB = tipoCB = tamCB = 0; lB = new List<CBloque>(); listaCub = new List<CCubeta>(); ptrAux = nE.getApCabDatos(); if (ptrAux != -1) { DameCE(nE, ref despCE, ref tipoD, ref tamCE, ref tamBloq, ref despCB, ref tipoCB, ref tamCB, e); tH = getArchivo().LeerTablaHashExt(ptrAux); foreach (CEntrada entrada in tH.getListEntradas()) { cubetaAux = entrada.getCubeta(); if (listaCub.Contains(cubetaAux)==false) { listaCub.Add(cubetaAux); for (int j = 0; j < cubetaAux.getTamaño(); j++) if (cubetaAux.getAtDirBloque(j) != -1) { bloqueAux = getArchivo().leerBloque(cubetaAux.getAtDirBloque(j), tamBloq); bloqueAux.setDespCE(despCE); bloqueAux.setTipoCE(tipoD); bloqueAux.setTamCE(tamCE); bloqueAux.setDesp(despCB); bloqueAux.setTamAtri(tamCB); bloqueAux.setTipoCA(tipoCB); bloqueAux.setTamBlo(tamBloq); if (bloqueAux.CompareClaveExt(bS) == 0) lB.Add(bloqueAux); } } } } }
/**´Méetodo principal para llevar a cabo la inserción de algun bloque*/ public bool Alta_HashDinamica(CNodoEntidad e, CBloque b) { /** * \param e Entidad a la que pertrnece el bloque * \param b Bloque Nuevo bloque a insertar * \return Retorna Falso(Si tuvo exito), True(Si ya existe el bloque alguna cubeta) * */ CCubeta cubetaAux; CEntrada entradaAux; bool res = false; if (e.getApCabDatos() == -1) { tHashExt = new CTablaHashExt(); cubetaAux = new CCubeta(-1, TAM_CUBETA); entradaAux = new CEntrada(cubetaAux, -1); tHashExt.insEntrada(entradaAux); cubetaAux.setDir(getArchivo().ENDF()); getArchivo().EscribeCubeta(cubetaAux); entradaAux.setDirCubeta(cubetaAux.getDir()); entradaAux.setDir(getArchivo().ENDF()); getArchivo().EscribeEntrada(entradaAux); tHashExt.setCabEntradas(entradaAux.getDir()); tHashExt.setDir(getArchivo().ENDF()); getArchivo().EscribeTablaHashExt(tHashExt); e.setApCabDatos(tHashExt.getDir()); getArchivo().escribeEntidad(e, e.getDir()); } else tHashExt = getArchivo().LeerTablaHashExt(e.getApCabDatos()); b.setDir(getArchivo().ENDF()); if ((res = InsBloque(b)) == false) { tHashExt.incNumReg(); getArchivo().EscribeTablaHashExt(tHashExt); } return (res); }
/**Actualiza una entidad*/ public void ModificaEntidad(string nameEnt, CNodoEntidad nueva) { CNodoEntidad aux, nodoVerAux = null; CNodoAtributo auxAtri; buscaEntidad(ref nodoVerAux, nameEnt); nueva.setCabListAtri(nodoVerAux.getCabListAtri()); nueva.setApCabListAtri(nodoVerAux.getApCabListAtri()); AbrirArchivo(); nueva.setDir(fs.Length); aux = listaEntidades.getCabListEnt(); while (aux != null) { if (aux != nodoVerAux) { auxAtri = aux.getCabListAtri(); while (auxAtri != null) { if (auxAtri.getEntRel() == nodoVerAux) { auxAtri.setEntRel(nueva); auxAtri.setApEntRel(nueva.getDir()); escribeAtributo(auxAtri, auxAtri.getDir()); } auxAtri = auxAtri.getSigAtri(); } } aux = aux.getSigEnt(); } CerrarArchivo(); BajaEntidad(nameEnt); AltaEntidad(nueva); }
/** Se ecribe una nueva entidad en el diccionario*/ public void escribeEntidad(CNodoEntidad nueva, long pos) { bw.BaseStream.Seek(pos, SeekOrigin.Begin); bw.Write(nueva.getApSigEnt()); bw.Write(nueva.getNombre()); bw.Write(nueva.getApCabListAtri()); bw.Write(nueva.getDir()); bw.Write(nueva.getApCabDatos()); }
private void dameBloquesDatos(ref List<CBloque> lB, CNodoEntidad nE, CBloque bS, CNodoEntidad e) { CBloque bloqueAux; CHash tablaAux; Cubeta cubetaAux; long ptrAux, ptrAux2; int despCE, tipoD, tamCE, tamBloq, despCB, tipoCB, tamCB; ; despCE = tipoD = tamCE = tamBloq = despCB = tipoCB = tamCB = 0; lB = new List<CBloque>(); ptrAux = nE.getApCabDatos(); if (ptrAux != -1) { DameCE(nE, ref despCE, ref tipoD, ref tamCE, ref tamBloq, ref despCB, ref tipoCB, ref tamCB, e); tablaAux = getArchivo().LeerTablaHash(ptrAux); for(int i = 0; i < tablaAux.getTamaño(); i++) if( (ptrAux2 = tablaAux.getAtDirCubeta(i)) != -1) while(ptrAux2 != -1 ) { cubetaAux = getArchivo().LeerCubetaHashEstatica(ptrAux2); for(int j = 0; j < cubetaAux.getTamaño(); j++) if(cubetaAux.getAtDirBloque(j) != -1 ) { bloqueAux = getArchivo().leerBloque(cubetaAux.getAtDirBloque(j),tamBloq); bloqueAux.setDespCE(despCE); bloqueAux.setTipoCE(tipoD); bloqueAux.setTamCE(tamCE); bloqueAux.setDesp(despCB); bloqueAux.setTamAtri(tamCB); bloqueAux.setTipoCA(tipoCB); bloqueAux.setTamBlo(tamBloq); if (bloqueAux.CompareClaveExt(bS) == 0) lB.Add(bloqueAux); } ptrAux2 = cubetaAux.getSigCubeta(); } } }
/**Método principal para llevar a cabo el alta de algun bloque*/ public int Alta_HashEstatica(CNodoEntidad e, CBloque b) { int fH, fC; int res; CHash tHash; fH = fC = 0; if (e.getApCabDatos() == -1) { tHash = new CHash(getArchivo().ENDF(), TAM_HASH); getArchivo().EscribeTablaHash(tHash); e.setApCabDatos(tHash.getDir()); getArchivo().escribeEntidad(e, e.getDir()); }else tHash = getArchivo().LeerTablaHash(e.getApCabDatos());//Se lee la tabla Hash FuncionHash(b, ref fH, ref fC); cubetaSel = fH; res = InsDirBloque(tHash, fH, b, fC); return (res); }
/* Inserta un indice primario en la lista de indices*/ private void insIndicePri(CNodoEntidad e, ref CIndice nuevo, long posInd) { CIndice indAux, indAnt = null; long ptrAux, ptrAnt = -1; ptrAux = e.getApCabDatos(); while (ptrAux != -1) { indAux = getArchivo().LeerIndicePrimario(ptrAux); if (indAux.comparateTo(nuevo) < 0) { ptrAnt = ptrAux; indAnt = indAux; ptrAux = indAux.getSigInd(); } else break; } if (ptrAux == e.getApCabDatos()) { e.setApCabDatos(posInd); getArchivo().escribeEntidad(e, e.getDir()); } else { indAnt.setSigInd(posInd); getArchivo().EscribeIndicePrimario(indAnt); } nuevo.setDirInd(posInd); nuevo.setSigInd(ptrAux); getArchivo().EscribeIndicePrimario(nuevo); }
/**\brief Inserta un bloque de datos a la organización*/ public int AltaOSI(CNodoEntidad e, CBloque nuevo, long posB) { CIndice indPri, indAux = null; int res; long ptrAux, posInd; indPri = generaIndPri(nuevo); getArchivo().AbrirArchivo(); ptrAux = e.getApCabDatos(); while (ptrAux != -1) { indPrim = getArchivo().LeerIndicePrimario(ptrAux); if (indPrim.comparateTo(indPri) != 0) ptrAux = indPrim.getSigInd(); else break; } if (ptrAux == -1) { posInd = getArchivo().getFS().Length; insIndicePri(e, ref indPri,posInd); posB = getArchivo().getFS().Length; indPrim = indPri; res = insBloque(indPri, nuevo, posB); } else res = insBloque(indPrim, nuevo, posB); getArchivo().CerrarArchivo(); return (res); }
/**Función de Mantenimiento para la Hash Dinamica*/ private void MantenimientoHashDinamica(CArchivo fileOri, CArchivo fileNew, CNodoEntidad ent, CNodoEntidad entC, int tamBloque) { CTablaHashExt tH, nuevaTH; List<CCubeta> listCub; List<int> lE; CCubeta nuevaCub; long cabDatos; cabDatos = ent.getApCabDatos(); if (cabDatos != -1) { tH = fileOri.LeerTablaHashExt(cabDatos); nuevaTH = creaTabla(tH); listCub = dameCubetas(tH); foreach (CCubeta c in listCub) { lE = buscaEntradas(tH, c); nuevaCub = creaCubeta(c, fileNew, fileOri); foreach (int i in lE) nuevaTH.getAtEntrada(i).setCubeta(nuevaCub); } foreach (CEntrada e in nuevaTH.getListEntradas()) { e.setDir(fileNew.ENDF()); fileNew.EscribeEntrada(e); } for (int i = 0; i < nuevaTH.getListEntradas().Count - 1; i++) { nuevaTH.getAtEntrada(i).setSigEntrada(nuevaTH.getAtEntrada(i + 1).getDir()); fileNew.EscribeEntrada(nuevaTH.getAtEntrada(i)); } nuevaTH.setCabEntradas(nuevaTH.getAtEntrada(0).getDir()); nuevaTH.setDir(fileNew.ENDF()); fileNew.EscribeTablaHashExt(nuevaTH); entC.setApCabDatos(nuevaTH.getDir()); fileNew.escribeEntidad(entC,entC.getDir()); } }
/**Función de Mantenimiento para la Hash Estatica*/ private void MantenimientoHashEstatica(CArchivo fileOri, CArchivo fileNew, CNodoEntidad ent, CNodoEntidad entC, int tamBloque) { CHash tablaHash, nuevaTablaHash; long cabTabla; cabTabla = ent.getApCabDatos(); if (cabTabla != -1) { tablaHash = fileOri.LeerTablaHash(cabTabla); nuevaTablaHash = new CHash(fileNew.ENDF(), tablaHash.getTamaño()); nuevaTablaHash.setNumCubetas(tablaHash.getNumCubetas()); fileNew.EscribeTablaHash(nuevaTablaHash); for (int i = 0; i < tablaHash.getTamaño(); i++) nuevaTablaHash.setAtDirCubeta(i, CopiarListaCubetasRec(tablaHash.getAtDirCubeta(i), fileOri, fileNew, tamBloque)); fileNew.EscribeTablaHash(nuevaTablaHash); entC.setApCabDatos(nuevaTablaHash.getDir()); fileNew.escribeEntidad(entC, entC.getDir()); } }
/**Función de Mantenimiento para Arboles B+*/ public void MantenimientoArbolBplus(CArchivo fileOri, CArchivo fileNew, CNodoEntidad ent, CNodoEntidad entC, int tamBloque) { if (ent.getApCabDatos() != -1) { entC.setApCabDatos(generaArbolRec(fileOri, fileNew, tamBloque, ent.getApCabDatos())); fileNew.escribeEntidad(entC, entC.getDir()); } }
/**Función de Mantenimiento para la Organizacion Secuencial indexada*/ public void MantenimientoSecInd(CArchivo fileOri, CArchivo fileNew, CNodoEntidad ent, CNodoEntidad entC, int tamBloque) { List<CBloque> listBloque; List<CIndice> listaInd; CIndice indPri,nuevoInd; long aux; listaInd = new List<CIndice>(); aux = ent.getApCabDatos(); while (aux != -1) { indPri = fileOri.LeerIndicePrimario(aux); nuevoInd = new CIndice(); nuevoInd.setIndPrim(indPri.getIndPrim()); nuevoInd.setTamIndPri(indPri.getTamIndPri()); nuevoInd.setTipoInd(indPri.getTipoInd()); listBloque = new List<CBloque>(); CopiarSec(fileOri, fileNew, indPri.getCabBloques(), tamBloque, ref listBloque); nuevoInd.setDirInd(fileNew.ENDF()); nuevoInd.setCabBloques(listBloque[0].getDir()); fileNew.EscribeIndicePrimario(nuevoInd); listaInd.Add(nuevoInd); aux = indPri.getSigInd(); } for (int i = 0; i < listaInd.Count - 1; i++) { listaInd[i].setSigInd(listaInd[i + 1].getDirInd()); fileNew.EscribeIndicePrimario((listaInd[i])); } entC.setApCabDatos(listaInd[0].getDirInd()); fileNew.escribeEntidad(entC, ent.getDir()); }
private void dameBloques(ref List<CBloque> lB, CNodoEntidad nE, CBloque bS, CNodoEntidad e) { int despCE, tipoD, tamCE, tamBloq, despCB, tipoCB, tamCB; despCE = tipoD = tamCE = tamBloq = despCB = tipoCB = tamCB = 0; if (nE.getApCabDatos() != -1) { DameCE(nE, ref despCE, ref tipoD, ref tamCE, ref tamBloq, ref despCB, ref tipoCB, ref tamCB, e); creaListaBloques(nE.getApCabDatos(), ref lB, despCE, tipoD, tamCE, tamBloq, despCB, tipoCB, tamCB, bS); } }
/**Médoto principal para eliminar un registro*/ public void eliminaABplus(CNodoEntidad e, CBloque b) { long dirCabNueva = -1; if (eliminaClaveRec(e.getApCabDatos(), b.dameClavePrim(), ref dirCabNueva)) { e.setApCabDatos(dirCabNueva); getArchivo().escribeEntidad(e, e.getDir()); } }
/**Busca si no existe un bloque en el archivo comparandolo con el nuevo*/ public bool buscaBloqueRep(CNodoEntidad e, CBloque bO, CBloque bN) { CBloque bAux; CIndice indAux; long ptrAux, ptrAux2; bool band = false; getArchivo().AbrirArchivo(); ptrAux = e.getApCabDatos(); while (ptrAux != -1 && band != true) { indAux = getArchivo().LeerIndicePrimario(ptrAux); ptrAux2 = indAux.getCabBloques(); while (ptrAux2 != -1) { bAux = getArchivo().leerBloque(ptrAux2, tamBloque); if (indPrim.comparateTo(indAux) == 0) { if (bO.ComparateTo(bAux) != 0 && bN.ComparateTo(bAux) == 0) { band = true; break; } }else if (bN.ComparateTo(bAux) == 0) { band = true; break; } ptrAux2 = bAux.getSigBlo(); } ptrAux = indAux.getSigInd(); } getArchivo().CerrarArchivo(); return (band); }
/**Método principal para la eliminación de un registro*/ public void EliminaHashEstatica(CNodoEntidad e, CBloque b) { CHash tablaHash; tablaHash = getArchivo().LeerTablaHash(e.getApCabDatos()); EliminaBloque(tablaHash, b); if (tablaHash.getNumCubetas() == 0) { e.setApCabDatos(-1); getArchivo().escribeEntidad(e, e.getDir()); } }
/** Se elimina un indice primiraio*/ public void eliminaIndicePrimario(CNodoEntidad e, CIndice ind) { CIndice bloAux, bloAnt; long ptrAux, ptrAnt; bloAux = bloAnt = null; ptrAux = ptrAnt = -1; ptrAux = e.getApCabDatos(); while (ptrAux != -1) { bloAux = getArchivo().LeerIndicePrimario(ptrAux); if (ind.comparateTo(bloAux) != 0 ) { ptrAnt = ptrAux; bloAnt = bloAux; ptrAux = bloAux.getSigInd(); } else break; } if (ptrAux == e.getApCabDatos()) { e.setApCabDatos(bloAux.getSigInd()); getArchivo().escribeEntidad(e, e.getDir()); } else { bloAnt.setSigInd(bloAux.getSigInd()); getArchivo().EscribeIndicePrimario(bloAnt); } }
/**\brief Se inserta una entidad en el Diccionario de datos*/ public void AltaEntidad(CNodoEntidad nueva) { /** * \details * \param nueva Recibe un objeto de tipo entidad, que sera agregada a la lista de entidades * y posteriormente escrita en el diccionario **/ CNodoEntidad aux, ant = null; long ptrAnt, ptrAux, posCab; bool band = false; ptrAux = ptrAnt = -1; AbrirArchivo();//Se abren el archivo que contiene el diccionario de datos aux = listaEntidades.getCabListEnt(); ptrAux = leerCabecera(); while (aux != null) if ((aux.getNombre()).CompareTo(nueva.getNombre()) < 0) { ant = aux; ptrAnt = ptrAux; ptrAux = aux.getApSigEnt(); aux = aux.getSigEnt(); } else if ((aux.getNombre()).CompareTo(nueva.getNombre()) == 0) { band = true; break; } else break; if (aux == listaEntidades.getCabListEnt()) { if (band == false) { posCab = leerCabecera(); nueva.setApSigEnt(posCab); actCab(fs.Length); listaEntidades.setCabListEnt(nueva); } } else if (band == false) { nueva.setApSigEnt(ptrAux); ant.setApSigEnt(fs.Length); escribeEntidad(ant, ptrAnt); ant.setSigEnt(nueva); } if (band == false) { nueva.setDir(fs.Length); escribeEntidad(nueva, fs.Length); nueva.setSigEnt(aux); } numEntidades++; CerrarArchivo(); }
/**Método principal para llevar a cabo la elimianción de un registro*/ public void eliminaOSI(CNodoEntidad e, CBloque b) { CIndice index, index2 = null; long ptrAux; index = generaIndPri(b); ptrAux = e.getApCabDatos(); while (ptrAux != -1) { index2 = getArchivo().LeerIndicePrimario(ptrAux); if (index2.comparateTo(index) < 0) ptrAux = index2.getSigInd(); else break; } eliminaBloque(ref index2, b); if (index2.getCabBloques() == -1) eliminaIndicePrimario(e, index2); }
/** Busca una entidad en el diccionario*/ public void buscaEntidad(ref CNodoEntidad auxEnt, string nameEnt) { auxEnt = listaEntidades.getCabListEnt(); while (auxEnt != null && auxEnt.getNombre().CompareTo(nameEnt) != 0) auxEnt = auxEnt.getSigEnt(); }
/**Elimina en forma recursiva los registros, siempre y cuando haya claves externas entre * las entidades*/ public void BajaOSIRec(CNodoEntidad e, CBloque bS) { List<CNodoEntidad> lR = new List<CNodoEntidad>(); List<CBloque> lB; lR = buscaRelacionesEnt(e);//Busqueda de las entidades que tengan alguna relación con la entidad actual*/ if (lR.Count > 0) { foreach (CNodoEntidad nE in lR) { lB = new List<CBloque>(); dameBloquesDatos(ref lB, nE, bS, e); if(lB.Count > 0 ) foreach (CBloque nB in lB) { BajaOSIRec(nE, nB); eliminaOSI(nE, nB); } } } }
private void btEditarEntidad_Click(object sender, EventArgs e) { CapturaEntidad dlgEnt = new CapturaEntidad(); if (nameEntidad != null) { dlgEnt.nameEntidad.Text = nameEntidad; if (dlgEnt.ShowDialog() == DialogResult.OK) { CNodoEntidad nuevo = new CNodoEntidad(dlgEnt.nameEntidad.Text); archivo.ModificaEntidad(nameEntidad, nuevo); imprimeEntidades(); imprimeAtributos(); } } else MessageBox.Show("Seleccione el nombre de la entidad", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); }
private void dameBloquesDatos(ref List<CBloque> lB, CNodoEntidad nE, CBloque bS, CNodoEntidad e) { CBloque aux; CIndice indAux; long ptrAux, ptrAux2; int despCE, tipoD, tamCE, tamBloq, despCB, tipoCB, tamCB; ; despCE = tipoD = tamCE = tamBloq = despCB = tipoCB = tamCB = 0; lB = new List<CBloque>(); ptrAux = nE.getApCabDatos(); if (ptrAux != -1) { DameCE(nE, ref despCE, ref tipoD, ref tamCE, ref tamBloq, ref despCB, ref tipoCB, ref tamCB, e); while (ptrAux != -1) { indAux = getArchivo().LeerIndicePrimario(ptrAux); ptrAux2 = indAux.getCabBloques(); while (ptrAux2 != -1) { aux = getArchivo().leerBloque(ptrAux2, tamBloq); aux.setDespCE(despCE); aux.setTipoCE(tipoD); aux.setTamCE(tamCE); aux.setDesp(despCB); aux.setTamAtri(tamCB); aux.setTipoCA(tipoCB); aux.setTamBlo(tamBloq); aux.setDir(ptrAux2); if (aux.CompareClaveExt(bS) == 0) lB.Add(aux); ptrAux2 = aux.getSigBlo(); } ptrAux = indAux.getSigInd(); } } }
/**Elimina en forma recursiva todos los registros afectados por la eliminación de algun * registro externo*/ private void Baja_HashDinamicaRec(CNodoEntidad e, CBloque bS) { List<CNodoEntidad> lR = new List<CNodoEntidad>(); List<CBloque> lB; lR = buscaRelacionesEnt(e); if (lR.Count > 0)//Caso Base { foreach (CNodoEntidad nE in lR) { lB = new List<CBloque>(); dameBloquesDatos(ref lB, nE, bS, e);//Se buscan los bloques que seran afectados if (lB.Count > 0) foreach (CBloque nB in lB) { Baja_HashDinamicaRec(nE, nB); Elimina_BloqueHashDinamica(nE, nB);//Llamada recursiva } } } }
/**Metodo principal para la inserción de la clave junto con su bloque de datos*/ public bool AltaArbolBplus(CNodoEntidad e, CBloque b, long posB) { CNodo nuevo = null; Object clave; bool res = true; long dirClave = -1; clave = b.dameClavePrim(); if (e.getApCabDatos() == -1)//Si no hay algun arbol se crea la primera pagina { nuevo = new CNodo(RAIZHOJA, GRADO); nuevo.setDir(getArchivo().ENDF()); nuevo.setTipoClave(b.getTipoCA()); getArchivo().escribeNodo(nuevo); e.setApCabDatos(nuevo.getDir()); getArchivo().escribeEntidad(e, e.getDir()); } else { bool bandera = false; res = EmpujaDato(e.getApCabDatos(), ref clave, ref dirClave, b, posB, ref nuevo, ref bandera); if (bandera == true)//La raiz se partido { CNodo nuevaRaiz; nuevaRaiz = new CNodo(RAIZ, GRADO); nuevaRaiz.setAtClave(0, clave); nuevaRaiz.setAtDirClaves(0, dirClave); nuevaRaiz.setAtDirNodo(0, ent.getApCabDatos()); nuevaRaiz.setAtDirNodo(1, nuevo.getDir()); nuevaRaiz.setDir(getArchivo().ENDF()); nuevaRaiz.setNumElemnt(1); nuevaRaiz.setTipoClave(b.getTipoCA()); getArchivo().escribeNodo(nuevaRaiz); e.setApCabDatos(nuevaRaiz.getDir()); getArchivo().escribeEntidad(e, e.getDir()); } } return (res); }
/**Método principal para llevar a cabo la eliminación de algun bloque*/ public void Elimina_BloqueHashDinamica(CNodoEntidad e, CBloque b) { CTablaHashExt tH; /** * \param e Entidad a la que pertenece el nuevo bloque * \param b Objeto del nuevo bloque * */ tH = getArchivo().LeerTablaHashExt(e.getApCabDatos()); if (EliminaBloque(b, tH)) { e.setApCabDatos(-1); getArchivo().escribeEntidad(e, e.getDir()); } }
/**Se Lleva a cabo la elimación de los registros en forma rucursiva, en el caso * de que algun registro se vea afectado por la eliminación de uno seleccionado en el dataGrid*/ public void BajaABplusRec(CNodoEntidad e, CBloque bS) { List<CNodoEntidad> lR = new List<CNodoEntidad>(); List<CBloque> lB; lR = buscaRelacionesEnt(e); if (lR.Count > 0) { foreach (CNodoEntidad nE in lR) { lB = new List<CBloque>(); dameBloques(ref lB, nE, bS, e); if (lB.Count > 0) foreach (CBloque nB in lB) { BajaABplusRec(nE, nB); eliminaABplus(nE, nB);//Elimacion de un elemento de un arbol } } } }