private void tablaDatos_CellBeginEdit(object sender, DataGridViewCellCancelEventArgs e) { posReg = e.RowIndex; btGurdarReg.Enabled = true; if (edicion == false) dirBO = -1; for (int i = 0; i < tablaDatos.Rows.Count; i++) if (i != e.RowIndex) { tablaDatos.Rows[i].ReadOnly = true; for (int j = 0; j < tablaDatos.Columns.Count; j++) tablaDatos.Rows[i].Cells[j].Style.BackColor = Color.Gray; } if (tablaDatos.Rows[e.RowIndex].Cells[e.ColumnIndex].Value == null && nuevoReg != true && edicion == false) nuevoReg = true; if (nuevoReg == false && tablaDatos.Rows[e.RowIndex].Cells[e.ColumnIndex].Value != null && edicion != true) { bloqueOriginal = creaBloqueDatos(e.RowIndex); getArchivo().AbrirArchivo(); buscaDirBloque(bloqueOriginal); edicion = true; getArchivo().CerrarArchivo(); } }
/**\brief Inserta un bloque*/ public int InsDirBloque(CHash tablaH, int posCubeta, CBloque b, int fC) { /** * \details * Lleva a cabo la inserción de un bloque, utilizando la posición de fC, generada por la * función hash(Metodo de plegamiento) * \param tablaH Tabla Hash * \param posCuebta Posición de la cubeta * \param b Bloque a insertar * \param fC Posicion del bloque dentro de la tabla hash **/ Cubeta cubetaAux, cubetaAnt; long dirAux; int res = 1; cubetaAnt = cubetaAux = null; dirAux = tablaH.getAtDirCubeta(posCubeta); //Recorrido por las cubetas while (dirAux != -1 ) { cubetaAux = getArchivo().LeerCubetaHashEstatica(dirAux); if ((res = InsBloqueDatos(b, cubetaAux, fC)) == 2) { cubetaAnt = cubetaAux; dirAux = cubetaAux.getSigCubeta(); } else break; } if (res == 1) { if (tablaH.getAtDirCubeta(posCubeta) == -1)//Si no existen cubetas se crea la primera y se asocia con la entidad { cubetaAux = new Cubeta(getArchivo().ENDF(), TAM_CUBETA); res = InsBloqueDatos(b, cubetaAux, fC); getArchivo().EscribeCubetaHashEstatia(cubetaAux); tablaH.setAtDirCubeta(posCubeta, cubetaAux.getDir()); tablaH.incNumCubetas(); getArchivo().EscribeTablaHash(tablaH); } else if (dirAux == -1) { cubetaAux = new Cubeta(getArchivo().ENDF(), TAM_CUBETA); res = InsBloqueDatos(b, cubetaAux, fC); getArchivo().EscribeCubetaHashEstatia(cubetaAux); cubetaAnt.setSigCubeta(cubetaAux.getDir()); getArchivo().EscribeCubetaHashEstatia(cubetaAnt); } else if (res == 1) getArchivo().EscribeCubetaHashEstatia(cubetaAux); } return (res); }
/**Elimina un bloque el forma logica y fisica*/ public bool EliminaBloque(CBloque b, CTablaHashExt tH) { CEntrada entradaAux; CCubeta cubetaAux; int numEnt; bool res, band = false ; numEnt = ConvertDecimal(tH,b.ConvertClaveToBinary());//Se obtiene la poscion de la entrada entradaAux = tH.getListEntradas()[numEnt];//Se carga la entrada cubetaAux = entradaAux.getCubeta(); //Se elimina la clave de cuebta leida res = cubetaAux.eliminaClave(FuncionHash(b), b, getArchivo()); getArchivo().EscribeCubeta(cubetaAux); tH.decNumReg(); getArchivo().EscribeTablaHashExt(tH); if (res == true)//Si es verdadero es porque la cubeta se quedo vacia if (tH.getPrefAsociacion() == 0) band = true; else if (cubetaAux.getPrefAsoc() == tH.getPrefAsociacion())//Se checa los estados de prefijos, en la cubeta y la tabla hash { entradaAux.setCubeta(tH.getAtEntrada(entradaAux.getEspejo()).getCubeta()); getArchivo().EscribeEntrada(entradaAux); entradaAux.getCubeta().DecPrefAsoc(); getArchivo().EscribeCubeta(entradaAux.getCubeta()); while (!tH.validaPrefijos()) tH.Doblate(getArchivo()); if (tH.getNumReg() == 0) band = true; } return (band); }
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); } } } } }
private void buscaDirBloque(CBloque bO) { CCubeta cubetaAux; CBloque bAux; cubetaAux = tHashExt.getAtEntrada(cubetaSel).getCubeta(); for (int i = 0; i < cubetaAux.getTamaño(); i++) if (cubetaAux.getAtDirBloque(i) != -1) { bAux = getArchivo().leerBloque(cubetaAux.getAtDirBloque(i), bO.getTamBlo()); if (bO.ComparateTo(bAux) == 0) { dirBO = cubetaAux.getAtDirBloque(i); return; } } }
private bool Repetidos(CBloque b, CCubeta cubeta) { CBloque bAux; for (int i = 0; i < cubeta.getTamaño(); i++) { bAux = getArchivo().leerBloque(cubeta.getAtDirBloque(i), b.getTamBlo()); if (bAux != null && (b.ComparateTo(bAux) == 0)) return (true); } return (false); }
/**´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); }
/**\brief Inseta una clave en el nodo en forma ordenada*/ public void insClaveOrd(Object clave, CBloque bloque, CArchivo file, int posClave) { //Movimiento de claves, dirClaves y dirNodos for (int i = getNumElemnt(); i > posClave; i--) { claves[i] = claves[i - 1]; dirClaves[i] = dirClaves[i - 1]; if (getTipoNodo() == 1 || getTipoNodo() == 4)//Si la clave a insertar es diferente a una hoja dirNodos[i+1] = dirNodos[i]; else dirNodos[i] = dirNodos[i - 1]; } if (getTipoNodo() == 2 || getTipoNodo() == 3)//La clave se va a insertar en una hoja o en la raizHoja { dirNodos[posClave] = file.ENDF(); file.EscribeBloque(bloque, file.ENDF()); } claves[posClave] = clave; incNumElem(); if (getTipoNodo() == 2 || getTipoNodo() == 3)//Si la clave a insertar es diferente a una raiz o pagima { dirClaves[posClave] = file.ENDF(); escribeClave(clave, file.ENDF(), bloque.getTipoCA(), file); } }
/**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()); } }
private bool BuscaBloque(CBloque bN, long cabListCub, int indCub) { Cubeta cubAux; CBloque bAux; int posOri = indCub; while (cabListCub != -1) { cubAux = getArchivo().LeerCubetaHashEstatica(cabListCub); for (; ; ) { bAux = getArchivo().leerBloque(cubAux.getAtDirBloque(indCub), bN.getTamBlo()); if (bAux != null && bN.ComparateTo(bAux) == 0) return (true); else indCub++; if (indCub == cubAux.getTamaño()) indCub = 0; if (indCub == posOri) break; } cabListCub = cubAux.getSigCubeta(); } return (false); }
/**Busca algun bloque repeido*/ public bool buscaBloqueRep(CBloque nuevo) { int indT, indC; indT = indC = -1; FuncionHash(nuevo, ref indT, ref indC); return (BuscaBloque(nuevo, tablaHashStatic.getAtDirCubeta(indT), indC)); }
/**Implemeta un función hash con la tecnica del plegamiento para obtener la posición * donde se insertara la nueva deirección del registro en la cubeta y la tabla hash*/ public void FuncionHash(CBloque b, ref int fH, ref int fC) { Object clave = b.dameClavePrim(); int c = 0; switch (b.getTipoCA()) { case 3: //Entero c = (int)clave; break; case 5: //Long c = (int)((long)clave); break; case 7: //Cadena c = Math.Abs(((string)clave).GetHashCode()); break; } while (c / 10 != 0) c = plegamiento(c); fC = fH = c; if (fC >= TAM_CUBETA) { fC = (fC - TAM_CUBETA) - 2; if (fC < 0) fC = 0; } if (fH >= TAM_HASH) fH -= TAM_HASH; }
private bool ExisteDireccion(Cubeta cubeta, int pos, CBloque b) { bool res = true; if (cubeta.getAtDirBloque(pos) == -1) { cubeta.incNumDirBloques(); getArchivo().EscribeCubetaHashEstatia(cubeta); cubeta.setAtDirBloque(pos, getArchivo().ENDF()); getArchivo().EscribeBloque(b, getArchivo().ENDF()); res = false; } return (res); }
/**Se intenta insertar un la direccion de un bloque en la cubeta*/ public int InsBloqueDatos(CBloque b, Cubeta cubeta, int indexCubeta) { /** Este método retornara alguno de estos tres valores * 1 : Si hay espacio en la cubeta y se pudo insertar * 2 : Si la cubeta esta llena * 3 : Si el Bloque es repetido * */ int res = 1; if (cubeta.getNumDirBloques() == TAM_CUBETA) res = 2; else if( ((res = Repetidos(b,cubeta)) == 1) && ExisteDireccion(cubeta, indexCubeta, b) == true ) { indexCubeta++; for (; ; ) { if (indexCubeta == TAM_CUBETA) indexCubeta = 0; if (ExisteDireccion(cubeta, indexCubeta, b) == false) break; else indexCubeta++; } } return (res); }
/**Escribe un bloque en algun archivo*/ public void EscribeBloque(CBloque nuevo, long pos) { if (pos != -1) { bw.BaseStream.Seek(pos, SeekOrigin.Begin); bw.Write(pos); bw.Write(nuevo.getBloque(), 0, nuevo.getTamBlo()); } }
/**\brief Eliima un bloque de datos*/ private void EliminaBloque(CHash tablaH, CBloque b) { /** * \details * Se lleva a cabo la eliminación de algun registro. Aplicando la función has en la tabla y la cubeta * \param tablaH Tabla hash donde existe la cubeta * \param b Bloque a eliminar * */ Cubeta cubetaAux, cubetaAnt; long dirAux; cubetaAnt = cubetaAux = null; pH = pC = -1; FuncionHash(b, ref pH, ref pC);//Se hacen las funciones has en la tabla has y la cubeta dirAux = tablaH.getAtDirCubeta(pH); while (dirAux != -1)//Se intenta eliminar el registro { cubetaAux = getArchivo().LeerCubetaHashEstatica(dirAux); if (RegEliminado(cubetaAux, b, pC) == false) { cubetaAnt = cubetaAux; dirAux = cubetaAux.getSigCubeta(); } else break; } if (cubetaAux.getNumDirBloques() == 0) if (dirAux == tablaH.getAtDirCubeta(pH)) { tablaH.setAtDirCubeta(pH, cubetaAux.getSigCubeta()); if (cubetaAux.getSigCubeta() == -1) { tablaH.decNumCubetas(); cubetasRestantes = tablaH.getNumCubetas(); } getArchivo().EscribeTablaHash(tablaH); } else { cubetaAnt.setSigCubeta(cubetaAux.getSigCubeta()); getArchivo().EscribeCubetaHashEstatia(cubetaAnt); } }
/**Método para buscar un bloque en algun archivo*/ public bool buscaBloque(CBloque bloqueAux, long cabDatos, int tamBloque, ref long dir, ref long sigB) { long ptrAux; CBloque bAux; bool band = false; AbrirArchivo(); ptrAux = cabDatos; while (ptrAux != -1 && ptrAux != 0) { bAux = leerBloque(ptrAux, tamBloque); if (bloqueAux.ComparateTo(bAux) != 0) ptrAux = bAux.getSigBlo(); else { band = true; sigB = bAux.getSigBlo(); break; } } dir = ptrAux; CerrarArchivo(); return (band); }
private bool RegEliminado(Cubeta cubeta, CBloque b, int pC) { CBloque bAux; bool res = true; int posOrg = pC; while (true) { bAux = getArchivo().leerBloque(cubeta.getAtDirBloque(pC), b.getTamBlo()); if ( bAux != null && (b.ComparateTo(bAux) == 0)) break; else { pC++; if (pC == cubeta.getTamaño()) pC = 0; if (pC == posOrg) { res = false; break; } } } if (res == true) { cubeta.setAtDirBloque(pC, -1); cubeta.decNumDirBloques(); getArchivo().EscribeCubetaHashEstatia(cubeta); } return (res); }
private bool buscaBloqueRep(CBloque nuevo) { CCubeta cubetaAux; CBloque bloqueAux; int posCub; posCub = ConvertDecimal(tHashExt, nuevo.ConvertClaveToBinary()); cubetaAux = tHashExt.getAtEntrada(posCub).getCubeta(); for (int i = 0; i < cubetaAux.getTamaño(); i++) { bloqueAux = getArchivo().leerBloque(cubetaAux.getAtDirBloque(i), nuevo.getTamBlo()); if (bloqueAux != null && nuevo.ComparateTo(bloqueAux) == 0) return (true); } return (false); }
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(); } } }
/**Inserta un bloque en la Organización hash dinámica*/ private bool InsBloque(CBloque b) { CCubeta cubetaAux, nuevaCubeta; CBloque bAux; int entrada; bool res; cubetaSel = entrada = ConvertDecimal(tHashExt, b.ConvertClaveToBinary());//Se determina su posición en la tabla Hash cubetaAux = tHashExt.getAtEntrada(entrada).getCubeta();//Se lee la cubeta em la entrada corrrespondiente if ((res = Repetidos(b, cubetaAux)) == false)//Validación para repetidos if (cubetaAux.InsertaClave(b.getDir(), FuncionHash(b)) == true) { //Se escribe la cubeta con la nueva información getArchivo().EscribeCubeta(cubetaAux); getArchivo().EscribeBloque(b, b.getDir()); } else { //Se checan los prefijos de asociación entre la tabla hash y una de las cubetas if (tHashExt.getPrefAsociacion() == cubetaAux.getPrefAsoc()) { tHashExt.incPrefAsociacion(); tHashExt.Incrementate(getArchivo()); } //Inicialización de la nueva cubeta nuevaCubeta = new CCubeta(-1, TAM_CUBETA); cubetaAux.IncPrefAsoc(); nuevaCubeta.setPrefAsoc(cubetaAux.getPrefAsoc()); getArchivo().EscribeCubeta(cubetaAux); nuevaCubeta.setDir(getArchivo().ENDF()); ActualizaEntradas(cubetaAux, nuevaCubeta); getArchivo().EscribeCubeta(nuevaCubeta); //Se sacan todas las claves de la cubeta que se partio y se //Redistribuyen en todas las cubetas y la nueva cubeta creada. for (int i = 0; i < cubetaAux.getTamaño(); i++) { bAux = getArchivo().leerBloque(cubetaAux.getAtDirBloque(i), tamBloque); bAux.setTamAtri(tamAtri); bAux.setTipoCA(tipoDato); bAux.setDesp(desp); bAux.setTamBlo(tamBloque); cubetaAux.eliminaClave(i, cubetaAux.getAtDirBloque(i)); getArchivo().EscribeCubeta(cubetaAux); res = InsBloque(bAux); } b.setDir(getArchivo().ENDF()); InsBloque(b); } return (res); }
/**Busca la direccion del bloque que será modificado*/ public void buscaDirBloque(CBloque bO) { Cubeta cub; CBloque bAux; long dirCub; dirCub = tablaHashStatic.getAtDirCubeta(cubetaSel); while (dirCub != -1) { cub = getArchivo().LeerCubetaHashEstatica(tablaHashStatic.getAtDirCubeta(cubetaSel)); for(int i = 0; i < cub.getTamaño(); i++) if (cub.getAtDirBloque(i) != -1) { bAux = getArchivo().leerBloque(cub.getAtDirBloque(i), bO.getTamBlo()); if (bO.ComparateTo(bAux) == 0) { dirBO = cub.getAtDirBloque(i); return; } } dirCub = cub.getSigCubeta(); } }
/**Funciión Hash, implementada con el modulo*/ public int FuncionHash(CBloque b) { //Aplicando modulo Object clave = b.dameClavePrim(); int pos, c = 0; pos = -1; switch (b.getTipoCA()) { case 3: //Entero pos = (int)clave % TAM_CUBETA; break; case 5: //Long pos = (int)((long)clave)%TAM_CUBETA; break; case 7: //Cadena pos = Math.Abs(((string)clave).GetHashCode())%TAM_CUBETA; break; } return (pos); }
/**\brief Compara dos bloques*/ public int ComparateTo(CBloque bloqueB) { /** * \details * Se realiza la comparación de dos blques con respecto a su clave primaria * \param bloqueB Boque con el que se realizara la comparación * \return Valor de 0 (Iguales) * */ int res; byte[] cA; byte[] cB; bloqueB.setDesp(this.getDesp()); bloqueB.setTamAtri(this.getTamAtri()); cA = this.dameClave(); cB = bloqueB.dameClave(); res = comparaClaves(cA, cB, tipo); return (res); }
/**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 } } } }
/**Compara la clave externa con la clave primaria de otro bloque*/ public int CompareClaveExt(CBloque bloqueB) { int res = -1; byte[] cA; byte[] cB; cA = this.dameClaveExt(); cB = bloqueB.dameClave(); if (BitConverter.ToString(cA, 0).CompareTo(BitConverter.ToString(cB, 0)) == 0) res = 0; 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 lee un bloque da datos desde un archivo * \param pos Posicion donde inicia el bloque da datos * \param tam Tamaño de este boque*/ public CBloque leerBloque(long pos, int tam) { CBloque bloqueAux = new CBloque(); byte[] bloque; if (pos == -1) return (null); br.BaseStream.Seek(pos, SeekOrigin.Begin); bloqueAux.setDir(br.ReadInt64()); bloque = br.ReadBytes(tam); bloqueAux.setBloque(bloque); return (bloqueAux); }
public bool actualizaRegistro(CBloque nuevo) { /**Verificar si la clave primaria fue modificada en caso de que no se haya modificado, sobrescribir el registro en la misma direccion, pasar a otro procedimiento */ bool res = true; if (nuevo.ComparateTo(bloqueOriginal) == 0) { getArchivo().EscribeBloque(nuevo, dirBO); res = false; } else if ((res = buscaBloqueRep(nuevo)) == false)//Se checan que no se repetan los bloques con el nuevo { Elimina_BloqueHashDinamica(ent,bloqueOriginal); Alta_HashDinamica(ent, nuevo); List<CNodoEntidad> lR = new List<CNodoEntidad>(); List<CBloque> lB; lR = buscaRelacionesEnt(ent); if (lR.Count > 0) foreach (CNodoEntidad nE in lR) { lB = new List<CBloque>(); dameBloquesDatos(ref lB, nE, bloqueOriginal, ent); foreach (CBloque nB in lB) { nB.setClaveExt(nuevo.dameClave()); getArchivo().EscribeBloque(nB, nB.getDir()); } } } return (res); }
/**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); }