internal void LimpiarNodoEnDisco(FileStream archivo, int tamañoEncabezado, IFabricaTextoTamañoFijo <T> fabrica)
{
// Se limpia el contenido del nodo
LimpiarNodo(fabrica);
// Se guarda en disco el objeto que ha sido limpiado
GuardarNodoEnDisco(archivo, tamañoEncabezado);
}
public ListaEnlazada(string nombreArchivo, IFabricaTextoTamañoFijo <T> fabrica)
{
// Se guardan los parámetros recibidos
_archivoNombre = nombreArchivo;
_fabrica = fabrica;
// Se abre la conexión al archivo
_archivo = new FileStream(_archivoNombre, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read);
// Se obtienen los valores del encabezado del archivo
_cabeza = Utilidades.LeerEntero(_archivo, 0);
_ultimaPosicionLibre = Utilidades.LeerEntero(_archivo, 1);
Tamanio = Utilidades.LeerEntero(_archivo, 2);
// Se corrigen los valores del encabezado cuando el archivo no existe previamente
if (_ultimaPosicionLibre == Utilidades.ApuntadorVacio)
{
_ultimaPosicionLibre = 0;
}
if (Tamanio == Utilidades.ApuntadorVacio)
{
Tamanio = 0;
}
// Si el archivo existe solamente se actualizan los encabezados, sino se crea y luego
// se almacenan los valores iniciales
GuardarEncabezado();
}
internal void LimpiarNodoEnDisco(FileStream archivo, int tamañoEncabezado, IFabricaTextoTamañoFijo <T> fabrica)
{
LimpiarNodo(fabrica);
GuardarNodoEnDisco(archivo, tamañoEncabezado);
}
internal void LimpiarNodoEnDisco(FileStream archivo, int tamañoEncabezado, IFabricaTextoTamañoFijo <T> fabrica)
{
//Se limpia el contenido del nodo
Siguiente = Utilidades.ApuntadorVacio;
Anterior = Utilidades.ApuntadorVacio;
Dato = fabrica.FabricarNulo();
GuardarNodoEnDisco(archivo, tamañoEncabezado);
}
public ArbolB(int orden, string nombreArchivo, IFabricaTextoTamañoFijo <T> fabrica)
{
// Se guardan los parámetros recibidos
_archivoNombre = nombreArchivo;
_fabrica = fabrica;
// Se abre la conexión al archivo
_archivo = new FileStream(_archivoNombre, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read);
// Se obtienen los valores del encabezado del archivo
_raiz = Utilidades.LeerEntero(_archivo, 0);
_ultimaPosicionLibre = Utilidades.LeerEntero(_archivo, 1);
Tamaño = Utilidades.LeerEntero(_archivo, 2);
Orden = Utilidades.LeerEntero(_archivo, 3);
Altura = Utilidades.LeerEntero(_archivo, 4);
// Se corrigen los valores del encabezado cuando el archivos no existe previamente
if (_ultimaPosicionLibre == Utilidades.ApuntadorVacio)
{
_ultimaPosicionLibre = 0;
}
if (Tamaño == Utilidades.ApuntadorVacio)
{
Tamaño = 0;
}
if (Orden == Utilidades.ApuntadorVacio)
{
Orden = orden;
}
if (Altura == Utilidades.ApuntadorVacio)
{
Altura = 1;
}
if (_raiz == Utilidades.ApuntadorVacio)
{
// Se crea la cabeza del árbol vacía
// para evitar futurs errores
NodoB <T> nodoCabeza = new NodoB <T>(Orden, _ultimaPosicionLibre, Utilidades.ApuntadorVacio, _fabrica);
_ultimaPosicionLibre++;
_raiz = nodoCabeza.Posicion;
nodoCabeza.GuardarNodoEnDisco(_archivo, _tamañoEncabezadoBinario);
}
// Si el archivo existe solamente se actualizan los encabezados, sino
// se crea y luego se almacenan los valores iniciales
GuardarEncabezado();
}
internal NodoB(int orden, int posicion, int padre, IFabricaTextoTamañoFijo <T> fabrica)
{
if ((orden < OrdenMinimo) || (orden > OrdenMaximo))
{
throw new ArgumentOutOfRangeException("orden");
}
if (posicion < 0)
{
throw new ArgumentOutOfRangeException("posicion");
}
Orden = orden; Posicion = posicion; Padre = padre;
LimpiarNodo(fabrica);
}
//Constructor
internal Nodes(int orden, int posicion, int padre, IFabricaTextoTamañoFijo <T> fabrica)
{
if ((orden < MinOrder) || (orden > MaxOrder))
{
throw new ArgumentOutOfRangeException("orden");
}
if (posicion < 0)
{
throw new ArgumentOutOfRangeException("posicion");
}
Orden = orden; Position = posicion;
Father = padre;
LimpiarNodo(fabrica);
}
//Limpia un nodo para poder inicializarlos
private void LimpiarNodo(IFabricaTextoTamañoFijo <T> fabrica)
{
Hijos = new List <int>();
for (int i = 0; i < Orden; i++)
{
Hijos.Add(Utilidades.ApuntadorVacio);
}
Llaves = new List <string>();
for (int i = 0; i < Orden - 1; i++)
{
Llaves.Add("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%");
}
Datos = new List <T>();
for (int i = 0; i < Orden - 1; i++)
{
Datos.Add(fabrica.FabricarNulo());
}
}
private void LimpiarNodo(IFabricaTextoTamañoFijo <T> fabrica)
{
Children = new List <int>();
for (int i = 0; i < Orden; i++)
{
Children.Add(Utilities.ApuntadorVacio);
}
Keys = new List <int>();
for (int i = 0; i < Orden - 1; i++)
{
Keys.Add(Utilities.ApuntadorVacio);
}
Datos = new List <T>();
for (int i = 0; i < Orden - 1; i++)
{
Datos.Add(fabrica.FabricarNulo());
}
}
public ArbolB(int orden, string nombreArchivo, IFabricaTextoTamañoFijo <T> _Creador)
{
NombreArchivo = nombreArchivo;
Creador = _Creador;
archivo = new FileStream(nombreArchivo, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read);
raiz = Utilities.LeerEntero(archivo, 0);
UltimaPosLibre = Utilities.LeerEntero(archivo, 1);
Tamaño = Utilities.LeerEntero(archivo, 3);
orden = Utilities.LeerEntero(archivo, 4);
if (UltimaPosLibre == Utilities.ApuntadorVacio)
{
UltimaPosLibre = 0;
}
if (Tamaño == Utilities.ApuntadorVacio)
{
Tamaño = 0;
}
if (Orden == Utilities.ApuntadorVacio)
{
Orden = orden;
}
if (Altura == Utilities.ApuntadorVacio)
{
Altura = 1;
}
if (raiz == Utilities.ApuntadorVacio)
{
Nodes <T, int> nodoCabeza = new Nodes <T, int>(Orden, UltimaPosLibre, Utilities.ApuntadorVacio, Creador);
UltimaPosLibre++;
raiz = nodoCabeza.Position;
nodoCabeza.GuardarNodoEnDisco(archivo, Encabezado);
}
GuardarEncabezado();
}
internal static NodoB <T> LeerNodoDesdeDisco(FileStream archivo, int tamañoEncabezado, int orden, int posicion, IFabricaTextoTamañoFijo <T> fabrica)
{
if (archivo == null)
{
throw new ArgumentNullException("archivo");
}
if (tamañoEncabezado < 0)
{
throw new ArgumentOutOfRangeException("tamañoEncabezado");
}
if ((orden < OrdenMinimo) || (orden > OrdenMaximo))
{
throw new ArgumentOutOfRangeException("orden");
}
if (posicion < 0)
{
throw new ArgumentOutOfRangeException("posicion");
}
if (fabrica == null)
{
throw new ArgumentNullException("fabrica");
}
// Se crea un nodo nulo para poder acceder a las
// propiedades de tamaño calculadas sobre la instancia
// el dato de la instancia del nodo
NodoB <T> nuevoNodo = new NodoB <T>(orden, posicion, 0, fabrica);
// Se crea un buffer donde se almacenarán los bytes leidos
byte[] datosBinario = new byte[nuevoNodo.TamañoEnBytes];
// Variables a ser utilizadas luego de que el archivo sea leido
string datosCadena = ""; string[] datosSeparados = null; int PosicionEnDatosCadena = 1;
// Se ubica la posición donde deberá estar el nodo y se lee desde el archivo
archivo.Seek(nuevoNodo.CalcularPosicionEnDisco(tamañoEncabezado), SeekOrigin.Begin);
archivo.Read(datosBinario, 0, nuevoNodo.TamañoEnBytes);
// Se convierten los bytes leidos del archivo a una cadena
datosCadena = Utilidades.ConvertirBinarioYTexto(datosBinario);
// Se quitan los saltos de línea y se separa en secciones
datosCadena = datosCadena.Replace(Utilidades.TextoNuevaLinea, "");
datosCadena = datosCadena.Replace("".PadRight(3, Utilidades.TextoSeparador), Utilidades.TextoSeparador.ToString());
datosSeparados = datosCadena.Split(Utilidades.TextoSeparador);
// Se se obtiene la posición del Padre
nuevoNodo.Padre = Convert.ToInt32(datosSeparados[PosicionEnDatosCadena]);
PosicionEnDatosCadena++;
// Se asignan al nodo vacío los hijos desde la cadena separada
for (int i = 0; i < nuevoNodo.Hijos.Count; i++)
{
nuevoNodo.Hijos[i] = Convert.ToInt32(datosSeparados[PosicionEnDatosCadena]);
PosicionEnDatosCadena++;
}
// Se asignan al nodo vacío las llaves desde la cadena separada
for (int i = 0; i < nuevoNodo.Llaves.Count; i++)
{
nuevoNodo.Llaves[i] = datosSeparados[PosicionEnDatosCadena];
PosicionEnDatosCadena++;
}
// Se asignan al nodo vacío los datos la cadena separada
for (int i = 0; i < nuevoNodo.Datos.Count; i++)
{
datosSeparados[PosicionEnDatosCadena] = datosSeparados[PosicionEnDatosCadena].Replace(Utilidades.TextoSustitutoSeparador, Utilidades.TextoSeparador);
nuevoNodo.Datos[i] = fabrica.Fabricar(datosSeparados[PosicionEnDatosCadena]);
PosicionEnDatosCadena++;
}
// Se retorna el nodo luego de agregar toda la información
return(nuevoNodo);
}
//lee el nodo ya existente en el dico
internal static Nodes <T, Tkey> ReadNodesInDisk(FileStream archivo, int tamañoEncabezado, int orden, int posicion, IFabricaTextoTamañoFijo <T> fabrica)
{
if (archivo == null)
{
throw new ArgumentNullException("archivo");
}
if (tamañoEncabezado < 0)
{
throw new ArgumentOutOfRangeException("tamañoEncabezado");
}
if ((orden < MinOrder) || (orden > MaxOrder))
{
throw new ArgumentOutOfRangeException("orden");
}
if (posicion < 0)
{
throw new ArgumentOutOfRangeException("posicion");
}
if (fabrica == null)
{
throw new ArgumentNullException("fabrica");
}
Nodes <T, Tkey> newNode = new Nodes <T, Tkey>(orden, posicion, 0, fabrica);
byte[] datosBinario = new byte[newNode.MemoryInBytes];
string datosCadena = "";
string[] datosSeparados = null;
int PosicionEnDatosCadena = 1;
archivo.Seek(newNode.CalcularPosicionEnDisco(tamañoEncabezado), SeekOrigin.Begin);
archivo.Read(datosBinario, 0, newNode.MemoryInBytes);
datosCadena = Utilities.ConvertirBinarioYTexto(datosBinario);
datosCadena = datosCadena.Replace(Utilities.TextoNuevaLinea, "");
datosCadena = datosCadena.Replace("".PadRight(3, Utilities.TextoSeparador), Utilities.TextoSeparador.ToString());
datosSeparados = datosCadena.Split(Utilities.TextoSeparador);
newNode.Father = Convert.ToInt32(datosSeparados[PosicionEnDatosCadena]);
PosicionEnDatosCadena++;
for (int i = 0; i < newNode.Keys.Count; i++)
{
newNode.Keys[i] = Convert.ToInt32(datosSeparados[PosicionEnDatosCadena]);
PosicionEnDatosCadena++;
}
for (int i = 0; i < newNode.Keys.Count; i++)
{
newNode.Keys[i] = Convert.ToInt32(datosSeparados[PosicionEnDatosCadena]);
PosicionEnDatosCadena++;
}
for (int i = 0; i < newNode.Datos.Count; i++)
{
datosSeparados[PosicionEnDatosCadena] = datosSeparados[PosicionEnDatosCadena].Replace(Utilidades.TextoSustitutoSeparador, Utilidades.TextoSeparador);
newNode.Datos[i] = fabrica.Fabricar(datosSeparados[PosicionEnDatosCadena]); PosicionEnDatosCadena++;
}
return(newNode);
}
internal static Nodo <T> CrearNodoDesdeDisco(FileStream archivo, int tamañoEncabezado, int posicion, IFabricaTextoTamañoFijo <T> fabrica)
{
if (archivo == null)
{
throw new ArgumentNullException("archivo");
}
if (tamañoEncabezado < 0)
{
throw new ArgumentOutOfRangeException("tamañoEncabezado");
}
if (posicion < 0)
{
throw new ArgumentOutOfRangeException("posicion");
}
if (fabrica == null)
{
throw new ArgumentNullException("fabrica");
}
// Se crea un nodo nulo para poder acceder a las propiedades de tamaño calculadas
// sobre la instancia el dato de la instancia del nodo.
Nodo <T> nuevoNodo = new Nodo <T>(posicion, fabrica.FabricarNulo());
// Se cea un buffer donde almacenarán los bytes leidos
byte[] datosBinario = new byte[nuevoNodo.TamañoEnBytes];
// Variables a ser utilizadas luego de que el archivo sea leido
string datosCadena = "";
string[] datosSeparados = null;
// Se ubica la posición donde deberá estar el nodo y se lee desde el archivo
archivo.Seek(nuevoNodo.CalcularPosicionEnDisco(tamañoEncabezado), SeekOrigin.Begin);
archivo.Read(datosBinario, 0, nuevoNodo.TamañoEnBytes);
// Se converiten los bytes leidos del archivo a una cadena
datosCadena = Utilidades.ConvertirBinarioYTexto(datosBinario);
// Se quitan los saltos de linea y se separa en secciones
datosCadena = datosCadena.Replace(Utilidades.TextoNuevaLinea, "");
datosSeparados = datosCadena.Split(Utilidades.TextoSeparador);
// Se asignan los apuntadores de Anterior y Siguiente
nuevoNodo.Anterior = Convert.ToInt32(datosSeparados[1]);
nuevoNodo.Siguiente = Convert.ToInt32(datosSeparados[2]);
// Se regenera el objeto Dato utilizando la fabrica
nuevoNodo.Anterior = Convert.ToInt32(datosSeparados[1]);
nuevoNodo.Siguiente = Convert.ToInt32(datosSeparados[2]);
// Se retorna el nodo luego de agregar toda la información
return(nuevoNodo);
}
