/**Inicialización de sus atributos*/
public CEntrada(CCubeta c,long miDir)
{
dir = miDir;
dirCubeta = c.getDir();
sigEntrada = -1;
cubeta = c;
}
/**Modifica la información de alguna entrada*/
public void ActualizaEntradas(CCubeta cubAux, CCubeta nueva )
{
CEntrada entAux;
int nEnt, tamHash;
tamHash = tHashExt.getListEntradas().Count;
nEnt = (int)Math.Pow(2, (double)(tHashExt.getPrefAsociacion() - cubAux.getPrefAsoc()));
for (int i = tamHash - 1; i >= 0 && nEnt != 0; i--)
{
entAux = tHashExt.getAtEntrada(i);
if (entAux.getCubeta() == cubAux)
{
entAux.setCubeta(nueva);
nEnt--;
getArchivo().EscribeEntrada(entAux);
}
}
}
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);
}
/**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);
}
/**´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);
}
public void setCubeta(CCubeta nueva)
{
cubeta = nueva;
setDirCubeta(nueva.getDir());
}
/**Lectura de una cubeta que se utilizara en el Hash Dinamica*/
public CCubeta LeerCubeta(long dir)
{
CCubeta cubetaAux = null;
if (dir != -1)
{
cubetaAux = new CCubeta();
br.BaseStream.Seek(dir, SeekOrigin.Begin);
cubetaAux.setDir(br.ReadInt64());
cubetaAux.setTamaño(br.ReadInt32());
cubetaAux.setNumDirBloques(br.ReadInt32());
cubetaAux.setPrefAsoc(br.ReadInt32());
cubetaAux.creaVectDirReg(cubetaAux.getTamaño());
for (int i = 0; i < cubetaAux.getTamaño(); cubetaAux.setAtDirBloque(i, br.ReadInt64()), i++) ;
}
return (cubetaAux);
}
/**Se escribe un objeto cubeta de la organizacion Hash Dinamica en el archivo de trabajo
* \param cubeta Cubeta a escribir, ya cuenta con su direccion en el archivo*/
public void EscribeCubeta(CCubeta cubeta)
{
bw.BaseStream.Seek(cubeta.getDir(), SeekOrigin.Begin);
bw.Write(cubeta.getDir());
bw.Write(cubeta.getTamaño());
bw.Write(cubeta.getNumDirBloques());
bw.Write(cubeta.getPrefAsoc());
for (int i = 0; i < cubeta.getTamaño(); bw.Write(cubeta.getAtDirBloque(i)), i++) ;
}
private List<int> buscaEntradas(CTablaHashExt tH, CCubeta cub)
{
List<int> L;
int numEnt;
L = new List<int>();
numEnt = (int)Math.Pow((int)2,((int)(tH.getPrefAsociacion()-cub.getPrefAsoc())));
foreach (CEntrada e in tH.getListEntradas())
if (numEnt > 0)
{
if (e.getCubeta() == cub)
{
L.Add(e.getID());
numEnt--;
}
}
else
break;
return(L);
}
private CCubeta creaCubeta(CCubeta c, CArchivo aN, CArchivo aO)
{
CCubeta nuevaCub;
CBloque bloqAux;
nuevaCub = new CCubeta(aN.ENDF(), c.getTamaño());
nuevaCub.setNumDirBloques(c.getNumDirBloques());
nuevaCub.setPrefAsoc(c.getPrefAsoc());
for (int i = 0; i < c.getTamaño(); i++)
if ((bloqAux = aO.leerBloque(c.getAtDirBloque(i), tamBloque)) != null)
{
bloqAux.setTamBlo(tamBloque);
nuevaCub.setAtDirBloque(i, aN.ENDF());
aN.EscribeBloque(bloqAux, aN.ENDF());
}
nuevaCub.setDir(aN.ENDF());
aN.EscribeCubeta(nuevaCub);
return (nuevaCub);
}
