/*Lee los archivos y crea las entidades y atributos con sus respectivos datos*/
private bool asignarMemoria()
{
long dat = 0;
Fichero = new FileStream(nombreArchivo, FileMode.Open, FileAccess.Read);
binaryReader = new BinaryReader(Fichero);
binaryReader.BaseStream.Seek(cab, SeekOrigin.Begin);//cabecera
while (leeArchivo)
{
byte[] id = new byte[5]; //para el id
id = binaryReader.ReadBytes(5); //la madre de el id
char[] c = binaryReader.ReadChars(35); //Obtiene la cadena de la entidad
entidad = new Entidad(c, id);
entidades.Add(entidad);
dat = binaryReader.ReadInt64(); //Obtiene la direccion de la entidad
entidades.Last().direccion_Entidad = dat;
dat = binaryReader.ReadInt64(); //Obtiene la direccion del 1.er atributo
entidades.Last().direccion_Atributo = dat;
long temp = Fichero.Position; //Obtiene la ultima posicion desde donde se leyo
if (entidades.Last().direccion_Atributo != -1)
{
char c2;
long aux;
int i;
binaryReader.BaseStream.Seek(entidades.Last().direccion_Atributo, SeekOrigin.Begin);
while (leeArchAux)
{
byte[] id2 = new byte[5]; //para el id
id2 = binaryReader.ReadBytes(5); //la madre de el id
char[] caux = binaryReader.ReadChars(35);
c2 = binaryReader.ReadChar(); // no puede leeer mas-----------------------------
i = binaryReader.ReadInt32();
//Se crea el atributo
atributo = new Atributo(id2, caux, c2, i);
entidades.Last().agregarAtributo(atributo);
aux = binaryReader.ReadInt64(); //Obtiene la direccion del atributo
entidades.Last().atributos.Last().direccion_Atributo = aux;
i = binaryReader.ReadInt32(); //Obtiene el tipo de indice
entidades.Last().atributos.Last().tipo_Indice = i;
aux = binaryReader.ReadInt64(); //Obtiene la direccion del indice
entidades.Last().atributos.Last().direccion_Indice = aux;
aux = binaryReader.ReadInt64(); //Obtiene la direccion del siguiente atributo
entidades.Last().atributos.Last().direccion_sigAtributo = aux;
if (aux == -1)
{
leeArchAux = false;
}
if (entidades.Last().atributos.Last().direccion_sigAtributo != -1)
{
binaryReader.BaseStream.Seek(aux, SeekOrigin.Begin);
}
}
}
leeArchAux = true;
binaryReader.BaseStream.Seek(temp, SeekOrigin.Begin); ///posiciona la lectura desde antes de entrar a los atributos
dat = binaryReader.ReadInt64(); ///Obtiene la direccion de los registros
entidades.Last().direccion_Dato = dat;
dat = binaryReader.ReadInt64(); ///Obtiene la direccion de la siguiente entidad
entidades.Last().direccion_Siguiente = dat;
if (dat == -1) //Si el ultimo es un -1 deja de leer las entidades
{
leeArchivo = false;
}
if (entidades.Last().direccion_Siguiente != -1)
{
binaryReader.BaseStream.Seek(entidades.Last().direccion_Siguiente, SeekOrigin.Begin); //Se posiciona en apuntar siguiente de la siguiente entidad
}
}
Fichero.Close();
return(true);
}
public void crearArbol(Atributo a, List <int> llego, Dictionary <int, long> sal)
{
ArbolB.Clear();
a.DirIndice = currentDir;
int nodoAct = 0;
ArbolB.Add(new nodoArbol(a.DirIndice));
ArbolB[0].Tipo = 'E';
currentDir += 65;
List <int> enteros = new List <int>();
foreach (int i in llego)
{
enteros.Add(i);
}
foreach (int ent in llego)
{
if (ArbolB[0].valores.Count < 4)
{
ArbolB[0].insertarDato(ent);
enteros.Remove(ent);
}
else
{
break;
}
}
foreach (int ent in enteros)
{
while (true)
{
if (ArbolB[nodoAct].valores.Count < 4 && ArbolB[nodoAct].Tipo == 'H')
{
ArbolB[nodoAct].insertarDato(ent);
nodoAct = buscarRaiz();
break;
}
else
{
long nuevaDirec = ArbolB[nodoAct].buscarPosicion(ent);
//Caso donde el nodo a dividir es la raiz
if (nuevaDirec == -1)
{
if (ArbolB[nodoAct].Tipo == 'E')
{
casoEspecial(nodoAct, ent);
nodoAct = buscarRaiz();
break;
}
if (ArbolB[nodoAct].Tipo == 'H')
{
casoHoja(nodoAct, ent);
nodoAct = buscarRaiz();
break;
}
}
else
{
nodoAct = buscarIndiceNodo(nuevaDirec);
}
}
}
}
}
public void AgregaAtributo(Atributo a)
{
LAtributo.Add(a);
}
/*Añadir atributos a la lista*/
public void agregarAtributo(Atributo atribut)
{
atributos.Add(atribut);
}
//Metodo para leer las entidades que hay en el archivo segun las direcciones, para posteriormente llamar al metodo que leera los atributos y generar la estructura del archivo
public void LeerArchivo()
{
List <Entidad> entidades = new List <Entidad>();
actualSize = new System.IO.FileInfo(sRuta).Length;
using (BinaryReader reader = new BinaryReader(new FileStream(sRuta, FileMode.Open)))
{
byte[] cabBytes = new byte[8];
long cab;
long currentDir;
reader.Read(cabBytes, 0, 8);
cab = BitConverter.ToInt64(cabBytes, 0);
this.Cabecera = cab;
currentDir = cab;
//Cada elemento se va a leer del archivo y se guardara en una variable
while (currentDir >= 0)
{
byte[] entBytes = new byte[62];
reader.BaseStream.Seek(currentDir, SeekOrigin.Begin);
reader.Read(entBytes, 0, 62);
byte[] entBytesNobre = new byte[29];
entBytesNobre = entBytes.Take(29).ToArray();
string nombre = BinaryToString(entBytesNobre);
byte[] entBytesDirRec = new byte[8];
entBytesDirRec = entBytes.Skip(29).Take(8).ToArray();
long direc = BitConverter.ToInt64(entBytesDirRec, 0);
byte[] entBytesDirAtr = new byte[8];
entBytesDirAtr = entBytes.Skip(37).Take(8).ToArray();
long dirAtr = BitConverter.ToInt64(entBytesDirAtr, 0);
byte[] entBytesDirDat = new byte[8];
entBytesDirDat = entBytes.Skip(45).Take(8).ToArray();
long dirRegDat = BitConverter.ToInt64(entBytesDirDat, 0);
byte[] entBytesDirSig = new byte[8];
entBytesDirSig = entBytes.Skip(53).Take(8).ToArray();
long dirSigEnt = BitConverter.ToInt64(entBytesDirSig, 0);
currentDir = dirSigEnt;
//Se crea una entidad nueva con las variables leidas del archivo para su utilizacion en el programa
Entidad Ent = new Entidad(nombre, direc, dirAtr, dirRegDat, dirSigEnt);
entidades.Add(Ent);
}
reader.Close();
}
//Se lee cada atributo de cada una de las entidades con la direccion del primer atributo de este
foreach (Entidad e in entidades)
{
long dirAux = e.DireccionAtr;
List <Atributo> agregar = new List <Atributo>();
while (dirAux >= 0)
{
Atributo auxiliar = LeerAtributo(dirAux);
agregar.Add(auxiliar);
dirAux = auxiliar.DirSigAtributo;
}
//Una vez obtenida la entidad y la lista de atributos que le corresponde, se incorpora al diccionario de datos.
this.DD.Add(e, agregar);
}
}
/*Crear un nuevo atributo*/
private void btn_Aceptar_Click(object sender, EventArgs e)
{
if (nombreRepetido(tb_Nombre.Text))
{
MessageBox.Show("El nombre esta repetido, no se agregara.");
return;
}
if (atributoForanea != null)
{
if (atributoForanea.string_Nombre == "ERR")
{
MessageBox.Show("ERR atributo");
return;
}
}
if (Convert.ToInt16(cb_Indice.Text) == 8)
{
atributo = new Atributo(tb_Nombre.Text, atributoForanea.tipo_Dato, atributoForanea.longitud_Tipo, Convert.ToInt16(cb_Indice.Text));
fa.dirIndiceForanea = entidades[posForanea].direccion_Entidad;
entidades.ElementAt(pos).agregarAtributo(atributo); //Agregamos la entidad seleccionada.
//MessageBox.Show(entidades.ElementAt(pos).atributos.Count.ToString());
if (fa.agregaAtributoArchivo(nombreArchivo, pos, entidades))
{
llenaDataG();
}
else
{
MessageBox.Show("Ocurrio un error");
}
}
else if (tb_Nombre != null || tb_Nombre.Text != "")
{
if (cb_TipoDato.Text != "")
{
atributo = new Atributo(tb_Nombre.Text,
Convert.ToChar(cb_TipoDato.Text),
Convert.ToInt16(tb_Longitud.Text),
Convert.ToInt16(cb_Indice.Text));
entidades.ElementAt(pos).agregarAtributo(atributo); //Agregamos la entidad seleccionada.
//MessageBox.Show(entidades.ElementAt(pos).atributos.Count.ToString());
if (fa.agregaAtributoArchivo(nombreArchivo, pos, entidades))
{
llenaDataG();
}
else
{
MessageBox.Show("Ocurrio un error");
}
}
else
{
MessageBox.Show("Verifica si los campos estan completos.");
}
}
else
{
MessageBox.Show("Verifica si los campos estan completos.");
}
botonesVisibles(true);
tb_Nombre.Text = "";
tb_Longitud.Text = "";
cb_Indice.Text = "";
cb_TipoDato.Text = "";
}
//Se abrirá un nuevo archivo y la información se mostrará en los datagrid
private void abrirToolStripMenuItem_Click(object sender, EventArgs e)
{
LEntidades.Clear(); //Se limpia la lista de entidades
long aux = 0; //Auxiliar de la cabecera
long aux2 = 0; //Auxiliar que guarda la dirección del siguiente atributo
abrir.Filter = "Diccionario de Datos(*.dd)|*.dd"; //Filtro de la extensión del archivo
//Condición para saber si el usuario abrió un archivo
if (abrir.ShowDialog() == DialogResult.OK)
{
//abrir.FileName es el nombre del archivo seleccionado
fs = new FileStream(abrir.FileName, FileMode.Open); //Se abre el archivo
fs.Seek(0, SeekOrigin.Begin); //Se posiciona al inicio del archivo
//Se crea un BinaryReader y un BinaryWriter
br = new BinaryReader(fs);
bw = new BinaryWriter(fs);
//Se leen los primero 8 bytes del archivo, los cuales representan a la cabecera
cabecera = br.ReadInt64();
aux = cabecera; //Se guarda el valor de la cabecera en un auxiliar
NomArch = abrir.FileName;
//Ciclo para leer el archivo usando la dirección de las siguientes entidades
while (aux != -1)
{
string nomb = ""; //Auxiliar del nombre de la entidad
fs.Seek(aux, SeekOrigin.Begin); //Se posiciona en la dirección de la cabecera
char[] nombre = br.ReadChars(30); //Se guarda el nombre de la entidad
//Ciclo para concatenar el nombre y guardarlo en un string
foreach (char n in nombre)
{
if (char.IsLetter(n))
{
nomb += n;
}
}
long DirEnt = br.ReadInt64(); //Se guarda la dirección de la entidad
long DirAtrib = br.ReadInt64(); //Se guarda la dirección del atributo
long DirDatos = br.ReadInt64(); //Se guarda la dirección de datos
long DSE = br.ReadInt64(); //Se guarda la dirección de la siguiente entidad
aux = DSE; //El auxiliar se iguala al valor de la dirección de la siguiente entidad
entidad = new Entidad(nomb, DirEnt, DirAtrib, DirDatos, DSE); //Se crea la entidad
LEntidades.Add(entidad); //Se agrega la entidad a la lista
}
//Ciclo para acceder a la lista de entidades
foreach (Entidad entidad in LEntidades)
{
//El auxiliar se iguala a la dirección de atributo que tiene la entidad
aux2 = entidad.DA;
//Ciclo para leer los atributos de una entidad
while (aux2 != -1)
{
string nomb = ""; //Auxiliar del nombre de la entidad
fs.Seek(aux2, SeekOrigin.Begin); //Se posiciona en la dirección del atributo
//Variables auxiliares para leer la información que pertenecen al atributo
char[] nombreA = br.ReadChars(30);
//Ciclo para concatenear el nombre y guardarlo en un string
foreach (char n in nombreA)
{
if (char.IsLetter(n))
{
nomb += n;
}
}
long DirA = br.ReadInt64();
char TipD = br.ReadChar();
int LongD = br.ReadInt32();
int TipInd = br.ReadInt32();
long DirInd = br.ReadInt64();
long DirSA = br.ReadInt64();
//Se iguala el auxiliar a la dirección de siguiente atributo
aux2 = DirSA;
atributo = new Atributo(nomb, DirA, TipD, LongD, TipInd, DirInd, DirSA); //Se crea un nuevo atributo
entidad.AgregaAtributo(atributo); //Se agrega el atributo a la lista de atributos de la entidad
}
}
fs.Close(); //Se cierra el archivo
Actualiza();
//Se muestran los datos del archivo en los DataGrid
AgregaFila();
AgregaAtribDG();
}
//Se habilitan los bontones de agregar, modificar y eliminar de enitidades y atributos
EntNueva.Enabled = NuevoAtrib.Enabled = NomNuevo.Enabled = txtTDato.Enabled = true;
AgregaEnt.Enabled = ModEnt.Enabled = EliminaEnt.Enabled = true;
AgregarAtrib.Enabled = ModifAtrib.Enabled = ElimAtrib.Enabled = true;
ListNombres.Enabled = ListaAtributos.Enabled = CBDatos.Enabled = CBIndice.Enabled = true;
}
//Se agrega un nuevo atributo a la entidad seleccionada
private void AgregarAtrib_Click(object sender, EventArgs e)
{
//Se abre el archivo seleccionado
fs = File.Open(NomArch, FileMode.Open, FileAccess.Write);
TamArch = fs.Length; //Auxiliar que guarda el tamaño del archivo
//int TamAtrib = EntModificar.LAtributo1.Count;
TamArch = fs.Length; //Variable que guarda el tamaño del archivo
EncuentraEntidad(); //Método que encuentrá la variable a la que se le asignarán los atributos
char TDato = Convert.ToChar(CBDatos.Text); //auxiliar que guarda el tipo de dato
int TIndice = Convert.ToInt32(CBIndice.Text); //auxiliar qie guarda el tipo de indice
int LDato = Convert.ToInt32(txtTDato.Text); //auxiliar que guarda la logitud de dato
//validación para que el nombre del atributo no este vacio
if (NuevoAtrib.Text != "" || NuevoAtrib.Text != " ")
{
//auxiliar que convierte el nombre en arreglo de char
char[] aux = NuevoAtrib.Text.ToCharArray();
//Validación del nombre del atributo, que sea menor o igual a 30 caracteres
if (aux.Length <= 30)
{
//Se posiciona al final del archivo
fs.Seek(TamArch, SeekOrigin.Begin);
bw = new BinaryWriter(fs); //Se crea un binarywriter
//Se crea un nuevo atributo
atributo = new Atributo(NuevoAtrib.Text, TamArch, TDato, LDato, TIndice, -1, -1);
bool EncAtrib = EntModificar.EncuentraAtributo(atributo.NA);
if (EncAtrib == true)
{
MessageBox.Show("No pueden existir dos atributos con el mismo nombre");
fs.Close();
}
else
{
//Se convierte el nombre del atributo en arreglo de char
atributo.ConvierteChar();
EntModificar.AgregaAtributo(atributo); //Se agrega el atributo a la lista de atributos de la entidad
EntModificar.DA = EntModificar.LAtributo1[0].DA; //Se asigna la dirección del atributo al campo de dirección de atributo de la entidad
atributo.EscribeAtributo(bw); //se escribe los datos del atributo en el archivo
fs.Close(); //Se cierra el archivo
AgregaAtribDG(); //Se muestra la información del atributo en el DatGrid
}
}
else
{
MessageBox.Show("El nombre del atributo no debe de superar los 30 caracteres");
}
}
else
{
MessageBox.Show("Escribe el nombre del nuevo atributo");
}
//Método que actualiza la información del archivo
Actualiza();
//Método que agrega los nombres de los atributos al combo box
ComboAtributo();
//Se limpian los campos que se rellenan con la información del atributo
ListNombres.Text = "";
CBDatos.Text = "";
CBIndice.Text = "";
NuevoAtrib.Clear();
txtTDato.Clear();
}
