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; } } }
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); }
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 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); }
/**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(); } }
/**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 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); }
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); }
/**Elimian un bloque del archivo implementado en la organización*/ public void eliminaBloque(ref CIndice ind, CBloque b) { CBloque bloAux, bloAnt; long ptrAux, ptrAnt; int tamB; bloAux = bloAnt = null; ptrAux = ptrAnt = -1; tamB = b.getTamBlo(); ptrAux = ind.getCabBloques(); while (ptrAux != -1)//Se ubica el registro en el archivo { bloAux = getArchivo().leerBloque(ptrAux, tamB); if (b.ComparateTo(bloAux) != 0) { ptrAnt = ptrAux; bloAnt = bloAux; bloAnt.setTamBlo(tamB); ptrAux = bloAux.getSigBlo(); } else break; } if (ptrAux == ind.getCabBloques())//Se actualiza la cabecera de datos de la entidad en caso de que sea el primero { ind.setCabBloques( bloAux.getSigBlo()); getArchivo().EscribeIndicePrimario(ind); } else { bloAnt.setSigBlo(bloAux.getSigBlo()); bloAnt.setTamBlo(tamB); getArchivo().EscribeBloque(bloAnt, ptrAnt); } }
/**\brief Modificacion de algun registro*/ public bool actualizaRegistro(CBloque nuevo, long posN) { bool res = true; int b = -1; List<CNodoEntidad> lR; List<CBloque> lB; // El registro que se modifico no altero la CP, por lo tanto // se sobreescribe el nuevo registro en la direccion correspondiente if (nuevo.ComparateTo(bloqueOriginal) == 0) { getArchivo().EscribeBloque(nuevo, dirBO); res = false; } else { //La clave primaria se ha modificado if (!(res = buscaBloqueRep(ent.getApCabDatos(), bloqueOriginal.dameClavePrim(), nuevo.dameClavePrim(),ref b))) { eliminaABplus(ent, bloqueOriginal); AltaArbolBplus(ent, nuevo, getArchivo().ENDF()); lR = new List<CNodoEntidad>(); lR = buscaRelacionesEnt(ent); if (lR.Count > 0) foreach (CNodoEntidad nE in lR) { lB = new List<CBloque>(); dameBloques(ref lB, nE, bloqueOriginal, ent); foreach (CBloque nB in lB) { nB.setClaveExt(nuevo.dameClave()); getArchivo().EscribeBloque(nB, nB.getDir()); } } } } return (res); }
/**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); }
/**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. */ public bool actualizaRegistro(CBloque nuevo, long posN) { bool res; if (nuevo.ComparateTo(bloqueOriginal) == 0) { getArchivo().AbrirArchivo(); nuevo.setSigBlo(bloqueOriginal.getSigBlo()); getArchivo().EscribeBloque(nuevo, dirBO); getArchivo().CerrarArchivo(); res = false; } else { if ((res = buscaBloqueRep(ent, bloqueOriginal, nuevo)) == false) { getArchivo().AbrirArchivo(); eliminaBloque(ref indPrim, bloqueOriginal); if (indPrim.getCabBloques() == -1) eliminaIndicePrimario(ent, indPrim); long posB = getArchivo().ENDF(); getArchivo().CerrarArchivo(); AltaOSI(ent, nuevo, posB); 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>(); getArchivo().AbrirArchivo(); dameBloquesDatos(ref lB, nE, bloqueOriginal, ent); foreach (CBloque nB in lB) { nB.setClaveExt(bloque.dameClave()); getArchivo().EscribeBloque(nB, nB.getDir()); } getArchivo().CerrarArchivo(); } } } return (res); }
/**Inserta el bloque de datos, accediendo a la estructura de datos implementada en el archivo*/ public int insBloque(CIndice ind, CBloque nuevo, long posB) { CBloque bAux, bAnt = null; long ptrAux, ptrAnt = -1; int band = -1; ptrAux = ind.getCabBloques(); while (ptrAux != -1) { bAux = getArchivo().leerBloque(ptrAux, nuevo.getTamBlo()); if ((band = nuevo.ComparateTo(bAux)) > 0) { ptrAnt = ptrAux; bAnt = bAux; bAnt.setTamBlo(nuevo.getTamBlo()); ptrAux = bAux.getSigBlo(); } else break; } if (band == 0) return 0; else if (ptrAux == ind.getCabBloques()) { ind.setCabBloques(posB); getArchivo().EscribeIndicePrimario(ind); } else { bAnt.setSigBlo(posB); getArchivo().EscribeBloque(bAnt, ptrAnt); } nuevo.setSigBlo(ptrAux); getArchivo().EscribeBloque(nuevo, posB); return (band); }
/**\brief Baja de un registro*/ public void BajaOS(CBloque blo, CNodoEntidad e, int tamB) { /** * \details * Elimina una registro del archivo secuencial. Para ello accede al primer registro * y busca el bloque a eliminar. * \param blo Bloque que sera eliminado. * \param e Entidad donde se ecuentra este bloque * \param tamB Tamaño del bloque * */ CBloque bloAux, bloAnt; long ptrAux, ptrAnt; bloAux = bloAnt = null; ptrAux = ptrAnt = -1; ptrAux = e.getApCabDatos(); while (ptrAux != -1)//Se busca la dirección del bloque { bloAux = getArchivo().leerBloque(ptrAux, tamB); if (blo.ComparateTo(bloAux) != 0) { ptrAnt = ptrAux; bloAnt = bloAux; bloAnt.setTamBlo(tamB); ptrAux = bloAux.getSigBlo(); } else break; } if (ptrAux == e.getApCabDatos())//Si es el primer bloque, se actualiza la cabecera de la entidad { e.setApCabDatos(bloAux.getSigBlo()); getArchivo().escribeEntidad(e, e.getDir()); } else { bloAnt.setSigBlo(bloAux.getSigBlo()); bloAnt.setTamBlo(tamB); getArchivo().EscribeBloque(bloAnt, ptrAnt); } }
public bool eliminaClave(int pos, CBloque b, CArchivo file) { CBloque bAux; bool res = false; if (getNumDirBloques() == 0) return (true); for (; ; ) { bAux = file.leerBloque(getAtDirBloque(pos), b.getTamBlo()); if (bAux != null && (b.ComparateTo(bAux) == 0)) { setAtDirBloque(pos, -1); decNumDirBloques(); if (getNumDirBloques() == 0) res = true; break; } else if (++pos == getTamaño()) pos = 0; } return (res); }