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);
}
