/**Crea cada uno de los nodos de arbol en forma recursiva, asindo un recorrido en preorden
* y va agranagando todos estos nodos al nuevo archivo*/
public long generaArbolRec(CArchivo aO, CArchivo aD, int tamBloque, long dirCab)
{
CNodo nodoAux, nuevoNodo;
CBloque bloqueAux,bloqueNuevo;
long dirNodo = -1;
int LS;
if (dirCab != -1)
{
nodoAux = aO.leerNodo(dirCab);
nuevoNodo = creaNodo(aO,aD,nodoAux);
if (nodoAux.getTipoNodo() == HOJA || nodoAux.getTipoNodo() == RAIZHOJA)
LS = nodoAux.getNumElemnt();
else
LS = nodoAux.getNumElemnt() + 1;
for (int i = 0; i < LS; i++)
if (nodoAux.getTipoNodo() == HOJA || nodoAux.getTipoNodo() == RAIZHOJA)
{
bloqueAux = aO.leerBloque(nodoAux.getAtDirNodo(i), tamBloque);
bloqueNuevo = new CBloque();
bloqueNuevo.setBloque(bloqueAux.getBloque());
bloqueNuevo.setTamBlo(tamBloque);
bloqueNuevo.setDir(aD.ENDF());
aD.EscribeBloque(bloqueNuevo, aD.ENDF());
nuevoNodo.setAtDirNodo(i, bloqueNuevo.getDir());
}
else
nuevoNodo.setAtDirNodo(i,generaArbolRec(aO,aD,tamBloque,nodoAux.getAtDirNodo(i)));
aD.escribeNodo(nuevoNodo);
dirNodo = nuevoNodo.getDir();
}
return(dirNodo);
}
private CNodo creaNodo(CArchivo aO, CArchivo aN, CNodo nodoAux)
{
CNodo nuevo;
nuevo = new CNodo(nodoAux.getTipoNodo(), nodoAux.getGrado());
nuevo.setNumElemnt(nodoAux.getNumElemnt());
nuevo.setTipoClave(nodoAux.getTipoClave());
for(int i = 0; i< nodoAux.getNumElemnt(); i++)
{
nuevo.setAtDirClaves(i, aN.ENDF());
nuevo.escribeClave(nodoAux.getAtClave(i), aN.ENDF(), nodoAux.getTipoClave(), aN);
}
nuevo.setDir(aN.ENDF());
aN.escribeNodo(nuevo);
return (nuevo);
}
/**Dobla la tabla, eliminado la mitad de entradas de la tabla hash dinamica
y actulizando los espejos.
*/
public void Doblate(CArchivo file)
{
CEntrada entAux;
int ultimaEnt;
ultimaEnt = (listaEntradas.Count / 2) - 1;
entAux = getAtEntrada(ultimaEnt);
entAux.setSigEntrada(-1);
decPrefAsociacion();
for (int i = (ultimaEnt * 2) + 1; i > ultimaEnt; i--)
listaEntradas.Remove(getAtEntrada(i));
file.EscribeEntrada(entAux);
file.EscribeTablaHashExt(this);
EstableceEspejos(file);
}
/**Función de Mantenimiento para Arboles B+*/
public void MantenimientoArbolBplus(CArchivo fileOri, CArchivo fileNew, CNodoEntidad ent, CNodoEntidad entC, int tamBloque)
{
if (ent.getApCabDatos() != -1)
{
entC.setApCabDatos(generaArbolRec(fileOri, fileNew, tamBloque, ent.getApCabDatos()));
fileNew.escribeEntidad(entC, entC.getDir());
}
}
private void menuArchNuevo_Click(object sender, EventArgs e)
{
string name;
SaveFileDialog nuevoDic = new SaveFileDialog();
nuevoDic.Title = "Crear nuevo Diccionario";
nuevoDic.Filter = "Archivo |.*dic";
nuevoDic.FileName = "Nombre";
if (nuevoDic.ShowDialog() == DialogResult.OK)
{
name = nuevoDic.FileName+".dic";
archivo = new CArchivo(name);
btAddEntidad.Enabled = true;
btDeleteEnt.Enabled = false;
btEditarEntidad.Enabled = false;
btAgregarAtri.Enabled = false;
btEditaAtributo.Enabled = false;
btElimarAtri.Enabled = false;
tablaEntidades.Rows.Clear();
TablaDeAtributos.Rows.Clear();
}
}
/**\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);
}
}
private void FormOrg_FormClosed(object sender, FormClosedEventArgs e)
{
CNodoEntidad entidadAux, entCopia;
CArchivo aO, aD;
string nameFileO, nameFileN;
int despCE, tipoD, tamCE, tamBloq, despCB, tipoCB, tamCB; ;
despCE = tipoD = tamCE = tamBloq = despCB = tipoCB = tamCB = 0;
aO = getArchivo();
aD = new CArchivo("Copia");//Se crea el nuevo archivo y se almacena en un directorio temporal
nameFileO = aO.getNameFile();//Se obtienen la ruta de la organizacion de trabajo
nameFileN = aD.getNameFile();//Se Obtiene la ruta del donde se hara el mantenimiento
creaCopia(aO, aD);//Se caraga el diccionario de datos que utilizo en la organiacion
aO.AbrirArchivo();//Abrir los flujos de archivos para operar en ellos
aD.AbrirArchivo();
entidadAux = aO.getListaEntidad().getCabListEnt();
entCopia = aD.getListaEntidad().getCabListEnt();
while (entidadAux != null)//Se visitan todas las entidades de la organizacion
{
if (entidadAux.getApCabDatos() != -1)
{
DameCE(entidadAux, ref despCE, ref tipoD, ref tamCE, ref tamBloq, ref despCB, ref tipoCB, ref tamCB, null);
switch(getTipoOrg())
{
case 1://Mantenimiento en Organizacion Secuencial
MantenimientoSec(aO, aD, entidadAux, entCopia, tamBloq);
break;
case 2://Manteniemito en Organizacion Secuencial Indexada
MantenimientoSecInd(aO, aD, entidadAux, entCopia, tamBloq);
break;
case 3://Mantenimiento en Arboles B+
MantenimientoArbolBplus(aO, aD, entidadAux, entCopia, tamBloque);
break;
case 4://Mantenimiento en Hash Estática
MantenimientoHashEstatica(aO, aD, entidadAux, entCopia, tamBloque);
break;
case 5://Mantenimiento en hash Dinámica
MantenimientoHashDinamica(aO, aD, entidadAux, entCopia, tamBloque);
break;
}
}
entidadAux = entidadAux.getSigEnt();
entCopia = entCopia.getSigEnt();
}
aO.CerrarArchivo();
aD.CerrarArchivo();
File.Delete(nameFileO);//Se elimina la organizacion a la que se le hizo mantenimiento
File.Move(nameFileN,nameFileO);//Se mueve el archivo creado a la ruta de la orgnizacion que fue mantenida
//Se conserva el mismo nombre de archivo
}
/**Función de Mantenimiento para la Hash Dinamica*/
private void MantenimientoHashDinamica(CArchivo fileOri, CArchivo fileNew, CNodoEntidad ent, CNodoEntidad entC, int tamBloque)
{
CTablaHashExt tH, nuevaTH;
List<CCubeta> listCub;
List<int> lE;
CCubeta nuevaCub;
long cabDatos;
cabDatos = ent.getApCabDatos();
if (cabDatos != -1)
{
tH = fileOri.LeerTablaHashExt(cabDatos);
nuevaTH = creaTabla(tH);
listCub = dameCubetas(tH);
foreach (CCubeta c in listCub)
{
lE = buscaEntradas(tH, c);
nuevaCub = creaCubeta(c, fileNew, fileOri);
foreach (int i in lE)
nuevaTH.getAtEntrada(i).setCubeta(nuevaCub);
}
foreach (CEntrada e in nuevaTH.getListEntradas())
{
e.setDir(fileNew.ENDF());
fileNew.EscribeEntrada(e);
}
for (int i = 0; i < nuevaTH.getListEntradas().Count - 1; i++)
{
nuevaTH.getAtEntrada(i).setSigEntrada(nuevaTH.getAtEntrada(i + 1).getDir());
fileNew.EscribeEntrada(nuevaTH.getAtEntrada(i));
}
nuevaTH.setCabEntradas(nuevaTH.getAtEntrada(0).getDir());
nuevaTH.setDir(fileNew.ENDF());
fileNew.EscribeTablaHashExt(nuevaTH);
entC.setApCabDatos(nuevaTH.getDir());
fileNew.escribeEntidad(entC,entC.getDir());
}
}
private void OANueva_Click(object sender, EventArgs e)
{
FormOrganizacion dlgOrg = new FormOrganizacion();
FormOrganizacionSec orgSec;
FormOrgSecInd orgSecInd;
ArbolBplus arbol;
FOrgHashEstatica orgHashEstatica;
FOrgHashDinamica orgHashDinamica;
CArchivo aO, aC;
aO = aC = null;
if (dlgOrg.ShowDialog() == DialogResult.OK)
{
aO = new CArchivo(dlgOrg.tbNameDicc.Text);
aC = new CArchivo(dlgOrg.tbNameDiccOrg.Text);
creaCopia(aO, aC);
switch (dlgOrg.getTipoOrg())
{
case 0://Organizacion secuencial
orgSec = new FormOrganizacionSec();
orgSec.setArchivo(aC);
orgSec.setTipoOrg(1);
orgSec.Text = "Organizacion " + (string)dlgOrg.cbOrg.SelectedItem;
orgSec.MdiParent = this;
orgSec.Show();
break;
case 1://Organizacion secuencial indexada
orgSecInd = new FormOrgSecInd();
orgSecInd.MdiParent = this;
orgSecInd.setArchivo(aC);
orgSecInd.setTipoOrg(2);
orgSecInd.Text = "Organizacion " + (string)dlgOrg.cbOrg.SelectedItem;
orgSecInd.Show();
break;
case 2://Organizacion Secuencial indexada implementada con Arboles B+
arbol = new ArbolBplus();
arbol.MdiParent = this;
arbol.setArchivo(aC);
arbol.setTipoOrg(3);
arbol.Text = "Organizacion " + (string)dlgOrg.cbOrg.SelectedItem;
arbol.Show();
break;
case 3://Oganizacion Hash Estatica
orgHashEstatica = new FOrgHashEstatica();
orgHashEstatica.MdiParent = this;
orgHashEstatica.setArchivo(aC);
orgHashEstatica.setTipoOrg(4);
orgHashEstatica.Text = "Organizacion " + (string)dlgOrg.cbOrg.SelectedItem;
orgHashEstatica.Show();
break;
case 4://Organizacion Hash Dinámica
orgHashDinamica = new FOrgHashDinamica();
orgHashDinamica.MdiParent = this;
orgHashDinamica.setArchivo(aC);
orgHashDinamica.setTipoOrg(5);
orgHashDinamica.Text = "Organizacion " + (string)dlgOrg.cbOrg.SelectedItem;
orgHashDinamica.Show();
break;
}
}
}
/**Crea un nuevo archivo a partir de alguna organiacion de archivos
*En el archivo destino, carga todo el diccionario de datos, sin datos*/
public void creaCopia(CArchivo aO, CArchivo aC)
{
CNodoAtributo auxAtri, nuevo = null;
CNodoEntidad auxEnt, auxEntRel;
auxEnt = aO.getListaEntidad().getCabListEnt();
//Copiar las entidades
while (auxEnt != null)
{
aC.AltaEntidad(new CNodoEntidad(auxEnt.getNombre()));
auxEnt = auxEnt.getSigEnt();
}
//Copiar los atributos y sus relaciones de clave foranea
auxEnt = aO.getListaEntidad().getCabListEnt();
while (auxEnt != null)
{
auxAtri = auxEnt.getCabListAtri();
while (auxAtri != null)
{
nuevo = new CNodoAtributo();
nuevo.setClavePrimaria(auxAtri.getClave());
nuevo.setNombre(auxAtri.getNombre());
nuevo.setTipo(auxAtri.getTipo());
nuevo.setTamaño(auxAtri.getTamaño());
nuevo.setEntRel(null);
if (auxAtri.getEntRel() != null)
{
string entRel = auxAtri.getEntRel().getNombre();
auxEntRel = aC.getListaEntidad().getCabListEnt();
for (; auxEntRel != null; auxEntRel = auxEntRel.getSigEnt())
if (auxEntRel.getNombre().CompareTo(entRel) == 0)
break;
nuevo.setEntRel(auxEntRel);
nuevo.setApEntRel(auxEntRel.getDir());
}
aC.AltaAtributo(nuevo, auxEnt.getNombre());
auxAtri = auxAtri.getSigAtri();
}
auxEnt = auxEnt.getSigEnt();
}
}
private void OA_Abrir_Click(object sender, EventArgs e)
{
OpenFileDialog openFile = new OpenFileDialog();
FormOrganizacionSec orgSec;
FormOrgSecInd orgSecInd;
ArbolBplus arbol;
FOrgHashEstatica orgHashStatic;
FOrgHashDinamica orgHashDinamica;
CArchivo archivo;
string name;
openFile.Filter = "Organizacion secuencial|*.sec|"+
"Secuencial Indexada|*.osi|"+
"Arbol B+|*.bPlus|"+
"Hash Estatica|*.hashe|"+
"Hash Dinámica|*.hashd";
if( openFile.ShowDialog() == DialogResult.OK)
{
name = openFile.FileName;
switch (openFile.FilterIndex)
{
case 1: //Organizacion secuecial
archivo = new CArchivo(name);
orgSec = new FormOrganizacionSec();
orgSec.setArchivo(archivo);
orgSec.setTipoOrg(1);
orgSec.Text = "Organizacion Secuencial - " + openFile.SafeFileName.Substring(0,openFile.SafeFileName.Length-4);
orgSec.MdiParent = this;
orgSec.Show();
break;
case 2: //Organizacion secuencial indexada
archivo = new CArchivo(name);
orgSecInd = new FormOrgSecInd();
orgSecInd.setArchivo(archivo);
orgSecInd.setTipoOrg(2);
orgSecInd.Text = "Organizacion Secuencial Idexada - " + openFile.SafeFileName.Substring(0, openFile.SafeFileName.Length - 4); ;
orgSecInd.MdiParent = this;
orgSecInd.Show();
break;
case 3://Organizacion Secuencial Indexada con Arboles B+
archivo = new CArchivo(name);
arbol = new ArbolBplus();
arbol.setArchivo(archivo);
arbol.setTipoOrg(3);
arbol.Text = "Organizacion Secuencial Idexada con Arboles B+ - " + openFile.SafeFileName.Substring(0, openFile.SafeFileName.Length - 6);
arbol.MdiParent = this;
arbol.Show();
break;
case 4:
archivo = new CArchivo(name);
orgHashStatic = new FOrgHashEstatica();
orgHashStatic.setArchivo(archivo);
orgHashStatic.setTipoOrg(4);
orgHashStatic.Text = "Organizacion Hash Estatica - " + openFile.SafeFileName.Substring(0, openFile.SafeFileName.Length - 6);
orgHashStatic.MdiParent = this;
orgHashStatic.Show();
break;
case 5:
archivo = new CArchivo(name);
orgHashDinamica = new FOrgHashDinamica();
orgHashDinamica.setArchivo(archivo);
orgHashDinamica.setTipoOrg(5);
orgHashDinamica.Text = "Organizacion Hash Dinamica - " + openFile.SafeFileName.Substring(0, openFile.SafeFileName.Length - 6);
orgHashDinamica.MdiParent = this;
orgHashDinamica.Show();
break;
}
}
}
/**Se establcen los espejos de cada entrada*/
public void EstableceEspejos(CArchivo file)
{
int m, tam,i;
tam = listaEntradas.Count;
m = tam / 2;
for (i = 0; i < m; i++)
{
listaEntradas[i].setEspejo(m+i);
listaEntradas[m+i].setEspejo(i);
file.EscribeEntrada(listaEntradas[i]);
file.EscribeEntrada(listaEntradas[m+i]);
}
}
/**Se incrementa la tabla de direccionesa 2(i)*/
public void Incrementate(CArchivo file)
{
CEntrada nueva, aux, aux2;
int numEntradas, idAux;
numEntradas = listaEntradas.Count;
for (int i = 0; i < numEntradas; i++)
{
aux = getAtEntrada(i);
idAux = aux.getID();
nueva = new CEntrada(aux.getCubeta(), getAtEntrada(getListEntradas().Count - 1).getID() + 1, file.ENDF());
insEntrada(nueva);
file.EscribeEntrada(nueva);
aux2 = getAtEntrada(getListEntradas().Count - 2);
aux2.setSigEntrada(nueva.getDir());
file.EscribeEntrada(aux2);
}
EstableceEspejos(file);//Se actulizan los espejos
file.EscribeTablaHashExt(this);
}
/**Función de Mantenimiento para la Hash Estatica*/
private void MantenimientoHashEstatica(CArchivo fileOri, CArchivo fileNew, CNodoEntidad ent, CNodoEntidad entC, int tamBloque)
{
CHash tablaHash, nuevaTablaHash;
long cabTabla;
cabTabla = ent.getApCabDatos();
if (cabTabla != -1)
{
tablaHash = fileOri.LeerTablaHash(cabTabla);
nuevaTablaHash = new CHash(fileNew.ENDF(), tablaHash.getTamaño());
nuevaTablaHash.setNumCubetas(tablaHash.getNumCubetas());
fileNew.EscribeTablaHash(nuevaTablaHash);
for (int i = 0; i < tablaHash.getTamaño(); i++)
nuevaTablaHash.setAtDirCubeta(i, CopiarListaCubetasRec(tablaHash.getAtDirCubeta(i), fileOri, fileNew, tamBloque));
fileNew.EscribeTablaHash(nuevaTablaHash);
entC.setApCabDatos(nuevaTablaHash.getDir());
fileNew.escribeEntidad(entC, entC.getDir());
}
}
public void setArchivo(CArchivo a)
{
archivo = a;
}
private long CopiarListaCubetasRec(long dirCub, CArchivo aO, CArchivo aN, int tamBloque)
{
Cubeta cubAux, nuevaCub = null;
CBloque bloqAux;
long sigCub = -1;
if( dirCub != -1)
{
cubAux = aO.LeerCubetaHashEstatica(dirCub);
sigCub = CopiarListaCubetasRec(cubAux.getSigCubeta(), aO, aN, tamBloque);
nuevaCub = new Cubeta(aN.ENDF(), cubAux.getTamaño());
nuevaCub.setNumDirBloques(cubAux.getNumDirBloques());
for (int i = 0; i < cubAux.getTamaño(); i++)
if ((bloqAux = aO.leerBloque(cubAux.getAtDirBloque(i), tamBloque)) != null)
{
bloqAux.setTamBlo(tamBloque);
nuevaCub.setAtDirBloque(i, aN.ENDF());
aN.EscribeBloque(bloqAux, aN.ENDF());
}
nuevaCub.setDir(aN.ENDF());
nuevaCub.setSigCubeta(sigCub);
aN.EscribeCubetaHashEstatia(nuevaCub);
sigCub = nuevaCub.getDir();
}
return (sigCub);
}
/**Funcionde Matenimiento para la Organizacion Secuencial*/
public void MantenimientoSec(CArchivo fileOri, CArchivo fileNew, CNodoEntidad ent, CNodoEntidad entC, int tamBloque)
{
List<CBloque> listBloque;
listBloque = new List<CBloque>();
CopiarSec(fileOri, fileNew, ent.getApCabDatos(), tamBloque, ref listBloque);
entC.setApCabDatos(listBloque[0].getDir());
fileNew.escribeEntidad(entC, ent.getDir());
}
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);
}
/**Copia toda la lista de bloques al nuevo archivo*/
public void CopiarSec(CArchivo fileOri, CArchivo fileNew, long dirEnt, int tamBloque, ref List<CBloque> listBloque)
{
CBloque bloqueAux, bloqueNuevo;
while (dirEnt != -1)
{
bloqueAux = fileOri.leerBloque(dirEnt, tamBloque);
bloqueNuevo = new CBloque();
bloqueNuevo.setBloque(bloqueAux.getBloque());
bloqueNuevo.setTamBlo(tamBloque);
bloqueNuevo.setDir(fileNew.ENDF());
fileNew.EscribeBloque(bloqueNuevo, fileNew.ENDF());
listBloque.Add(bloqueNuevo);
dirEnt = bloqueAux.getSigBlo();
}
for (int i = 0; i < listBloque.Count - 1; i++)
{
listBloque[i].setSigBlo(listBloque[i + 1].getDir());
fileNew.EscribeBloque(listBloque[i], listBloque[i].getDir());
}
}
private void mArchAbrir_Click(object sender, EventArgs e)
{
OpenFileDialog dlgAbrir = new OpenFileDialog();
string name;
dlgAbrir.Filter = "Archivos |*.dic";
if (dlgAbrir.ShowDialog() == DialogResult.OK)
{
name = dlgAbrir.FileName;
archivo = new CArchivo(name);
btAddEntidad.Enabled = true;
btDeleteEnt.Enabled = false;
btEditarEntidad.Enabled = false;
btAgregarAtri.Enabled = false;
btEditaAtributo.Enabled = false;
btElimarAtri.Enabled = false;
TablaDeAtributos.Rows.Clear();
tablaEntidades.Rows.Clear();
if (archivo.getListaEntidad().getCabListEnt() != null)
{
btDeleteEnt.Enabled = true;
btEditarEntidad.Enabled = true;
imprimeEntidades();
}
}
}
/**Función de Mantenimiento para la Organizacion Secuencial indexada*/
public void MantenimientoSecInd(CArchivo fileOri, CArchivo fileNew, CNodoEntidad ent, CNodoEntidad entC, int tamBloque)
{
List<CBloque> listBloque;
List<CIndice> listaInd;
CIndice indPri,nuevoInd;
long aux;
listaInd = new List<CIndice>();
aux = ent.getApCabDatos();
while (aux != -1)
{
indPri = fileOri.LeerIndicePrimario(aux);
nuevoInd = new CIndice();
nuevoInd.setIndPrim(indPri.getIndPrim());
nuevoInd.setTamIndPri(indPri.getTamIndPri());
nuevoInd.setTipoInd(indPri.getTipoInd());
listBloque = new List<CBloque>();
CopiarSec(fileOri, fileNew, indPri.getCabBloques(), tamBloque, ref listBloque);
nuevoInd.setDirInd(fileNew.ENDF());
nuevoInd.setCabBloques(listBloque[0].getDir());
fileNew.EscribeIndicePrimario(nuevoInd);
listaInd.Add(nuevoInd);
aux = indPri.getSigInd();
}
for (int i = 0; i < listaInd.Count - 1; i++)
{
listaInd[i].setSigInd(listaInd[i + 1].getDirInd());
fileNew.EscribeIndicePrimario((listaInd[i]));
}
entC.setApCabDatos(listaInd[0].getDirInd());
fileNew.escribeEntidad(entC, ent.getDir());
}
public void escribeClave(Object clave, long pos, int tipoClave, CArchivo file)
{
BinaryWriter bW;
bW = file.getBw();
bW.BaseStream.Seek(pos, SeekOrigin.Begin);
switch (tipoClave)
{
case 2://Short
bW.Write((short)clave);
break;
case 3://Int
bW.Write((int)clave);
break;
case 4://Float
bW.Write((float)clave);
break;
case 5://Long
bW.Write((long)clave);
break;
case 6://Double
bW.Write((double)clave);
break;
case 7://Cadena
bW.Write((string)clave);
break;
}
}
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);
}
