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