private void ReinicioNodo(ICreateFixedSizeText <T> _DataFixedSizeText)
{
Hijos = new List <int>();
Data = new List <T>();
if (Padre.Equals(MetodosNecesarios.NullPointer))
{
int maximo = (4 * (Orden - 1)) / 3;
for (int i = 0; i < maximo + 1; i++)
{
Hijos.Add(MetodosNecesarios.NullPointer);
}
for (int i = 0; i < maximo; i++)
{
Data.Add(_DataFixedSizeText.CreateNull());
}
}
else
{
for (int i = 0; i < Orden; i++)
{
Hijos.Add(MetodosNecesarios.NullPointer);
}
for (int i = 0; i < Orden; i++)
{
Data.Add(_DataFixedSizeText.CreateNull());
}
}
}
private void ClearNode(ICreateFixedSizeText <T> createFixedSizeText)
{
Children = new List <int>();
Data = new List <T>();
if (Father.Equals(Util.NullPointer))
{
int max = (4 * (Order - 1)) / 3;
for (int i = 0; i < max + 1; i++)
{
Children.Add(Util.NullPointer);
}
for (int i = 0; i < max; i++)
{
Data.Add(createFixedSizeText.CreateNull());
}
}
else
{
for (int i = 0; i < Order; i++)
{
Children.Add(Util.NullPointer);
}
for (int i = 0; i < Order - 1; i++)
{
Data.Add(createFixedSizeText.CreateNull());
}
}
}
internal Nodo(int _orden, int _posicion, int _padre, ICreateFixedSizeText <T> _createFixedSizeText)
{
if (Orden < 0)
{
throw new ArgumentOutOfRangeException("Orden Invalido");
}
this.Orden = _orden;
this.Padre = _padre;
ReinicioNodo(_createFixedSizeText);
}
internal Node(int order, int ID, int father, ICreateFixedSizeText <T> createFixedSizeText)
{
if (order < 0)
{
throw new ArgumentOutOfRangeException("Orden inválido");
}
this.Order = order;
this.ID = ID;
this.Father = father;
this.createFixedSizeText = createFixedSizeText;
ClearNode(createFixedSizeText);
}
internal Node(int order, int position, int father, ICreateFixedSizeText <T> createFixedSizeText)
{
if (order < 0)
{
throw new ArgumentOutOfRangeException("Orden inválido");
}
this.Order = order;
//this.Position = position;
this.Father = father;
ClearNode(createFixedSizeText);
}
private void ClearNode(ICreateFixedSizeText <T> createFixedSizeText)
{
Children = new List <int>();
for (int i = 0; i < Order; i++)
{
Children.Add(Utilities.NullPointer);
}
Data = new List <T>();
for (int i = 0; i < Order - 1; i++)
{
Data.Add(createFixedSizeText.CreateNull());
}
}
public ArbolBStar(int _Orden, string _Ruta, ICreateFixedSizeText <T> _createFixedSizeText)
{
this.createFixedSizeText = _createFixedSizeText;
this.Orden = _Orden;
this.Ruta = _Ruta;
Nodo <T> Raiz = CreacionDelNodo(Orden);
Encabezado _Encabezado = CreacionDelEncabezado(Orden);
this.UltimaPosicion = _Encabezado.SiguientePosicion;
using (var _FileStream = new FileStream(_Ruta, FileMode.OpenOrCreate))
{
_FileStream.Write(GeneradorData.ConvertToBytes(_Encabezado.ParaAjusteTamanoCadena()), 0, _Encabezado.AjusteTamanoCadena);
_FileStream.Write(GeneradorData.ConvertToBytes(Raiz.ParaAjusteTamanoCadena()), 0, Raiz.TamanoTextoCorregido());
}
}
/// <summary>
/// To create a new file. Creates a Header and the Root node
/// </summary>
/// <param name="Order"></param>
/// <param name="Path"></param>
/// <param name="createFixedSizeText"></param>
public Tree(int Order, string Path, ICreateFixedSizeText <T> createFixedSizeText)
{
this.createFixedSizeText = createFixedSizeText;
this.Order = Order;
this.Path = Path;
Node <T> root = CreateNode(Order);
Header e = CreateHeader(Order);
this.LastPosition = e.NextPosition;
using (var fs = new FileStream(Path, FileMode.OpenOrCreate))
{
fs.Write(ByteGenerator.ConvertToBytes(e.ToFixedSizeString()), 0, e.FixedSizeText);
fs.Write(ByteGenerator.ConvertToBytes(root.ToFixedSizeString()), 0, root.FixedSizeText());
}
}
public ArbolBStar(int _Orden, string _Ruta, ICreateFixedSizeText <T> createFixedSizeText, int C)
{
this.Orden = _Orden;
this.Ruta = _Ruta;
this.createFixedSizeText = createFixedSizeText;
var buffer = new byte[Encabezado.tamanoAjustado];
using (var _FileStream = new FileStream(_Ruta, FileMode.OpenOrCreate))
{
_FileStream.Read(buffer, 0, Encabezado.tamanoAjustado);
}
var EncabezadoCadena = GeneradorData.ConvertToString(buffer);
var valores = EncabezadoCadena.Split(MetodosNecesarios.Separador);
this.Raiz = Convert.ToInt16(valores[0]);
this.Orden = Convert.ToInt16(valores[1]);
this.UltimaPosicion = Convert.ToInt16(valores[2]);
}
internal void EliminarDatos(T _data, ICreateFixedSizeText <T> createFixedSizeText)
{
if (!EsHoja)
{
throw new Exception("Restriccion, unicamente se puede eliminar data posicionada en nodos tipo hoja");
}
int PosicionParaEliminar = PosicionDentroNodo(_data);
if (PosicionParaEliminar == -1)
{
throw new ArgumentException("El valor no se encuentra dentro del nodo del arbol");
}
for (int i = 0; i < PosicionParaEliminar; i--)
{
Data[i - 1] = Data[i];
}
Data[Data.Count - 1] = createFixedSizeText.CreateNull();
}
internal void SplitNode(T data, int Right, Node <T> Node, T ToUpData, ICreateFixedSizeText <T> createFixedSizeText)
{
if (!Full)
{
throw new ArgumentException("No se puede serparar porque no está lleno");
}
// Incrementar en una posición
Data.Add(data);
Children.Add(Util.NullPointer);
// Agregarlos en orden
InsertData(data, Right, false);
// Dato a subir
int Middle = Order / 2;
ToUpData = Data[Middle];
Data[Middle] = createFixedSizeText.CreateNull();
// Llenar datos que suben
int j = 0;
for (int i = Middle + 1; i < Children.Count; i++)
{
Node.Data[j] = Data[i];
Data[i] = createFixedSizeText.CreateNull();
j++;
}
// Llenar hijos que suben
j = 0;
for (int i = Middle + 1; i < Children.Count; i++)
{
Node.Children[j] = Children[i];
Children[i] = Util.NullPointer;
j++;
}
Data.RemoveAt(Data.Count - 1);
Children.RemoveAt(Children.Count - 1);
}
public Tree(int Order, string Path, ICreateFixedSizeText <T> createFixedSizeText, int c)
{
this.Order = Order;
this.Path = Path;
this.createFixedSizeText = createFixedSizeText;
var buffer = new byte[Header.FixedSize];
using (var fs = new FileStream(Path, FileMode.OpenOrCreate))
{
fs.Read(buffer, 0, Header.FixedSize);
}
var HeaderString = ByteGenerator.ConvertToString(buffer);
var values = HeaderString.Split(Util.Separator);
this.Root = Convert.ToInt16(values[0]);
this.Order = Convert.ToInt16(values[1]);
this.LastPosition = Convert.ToInt16(values[2]);
}
internal void DeleteData(T data, ICreateFixedSizeText <T> createFixedSizeText)
{
if (!IsLeaf)
{
throw new Exception("Solo pueden eliminarse en nodos hoja");
}
int PositionToDelete = PositionInNode(data);
if (PositionToDelete == -1)
{
throw new ArgumentException("El dato no existe en el nodo");
}
for (int i = Data.Count - 1; i > PositionToDelete; i--)
{
Data[i - 1] = Data[i];
}
Data[Data.Count - 1] = createFixedSizeText.CreateNull();
}
internal Node <T> ReadNode(string Path, int Order, int Root, int Position, ICreateFixedSizeText <T> createFixedSizeText)
{
Node <T> node = new Node <T>(Order, Position, 0, createFixedSizeText);
node.Data = new List <T>();
int HeaderSize = Header.FixedSize;
var buffer = new byte[node.FixedSize(node.Father)];
using (var fs = new FileStream(Path, FileMode.OpenOrCreate))
{
fs.Seek((HeaderSize + ((Root - 1) * node.FixedSize(node.Father))), SeekOrigin.Begin);
fs.Read(buffer, 0, node.FixedSize(node.Father));
}
var NodeString = ByteGenerator.ConvertToString(buffer);
var Values = NodeString.Split(Util.Separator);
node.Father = Convert.ToInt32(Values[1]);
//Hijos
for (int i = 2; i < node.Children.Count + 2; i++)
{
node.Children[i] = Convert.ToInt32(Values[i]);
}
int DataLimit = node.Children.Count + 2;
//Valores
for (int i = DataLimit; i < node.Data.Count; i++)
{
node.Data[i] = createFixedSizeText.Create(Values[i]);
}
return(node);
}
internal void LimpiarNodo_Disco(string Path, ICreateFixedSizeText <T> createFixedSizeText)
{
ClearNode(createFixedSizeText);
WriteNodeOnDisk(Path);
}
internal void SplitNode(T data, int Right, Node <T> Node, T ToUpData, ICreateFixedSizeText <T> createFixedSizeText)
{
int Middle = 0;
if (Father.Equals(Util.NullPointer))
{
// Incrementar en una posición
Data.Add(data);
Children.Add(Util.NullPointer);
// Agregarlos en orden
InsertData(data, Right, false);
// Dato a subir
Middle = Data.Count / 2;
ToUpData = Data[Middle];
Data[Middle] = createFixedSizeText.CreateNull();
// Llenar datos que suben
int j = 0;
for (int i = Middle + 1; i < Data.Count; i++)
{
Node.Data[j] = Data[i];
Data[i] = createFixedSizeText.CreateNull();
j++;
}
// Llenar hijos que suben
j = 0;
for (int i = Middle + 1; i < Children.Count; i++)
{
Node.Children[j] = Children[i];
Children[i] = Util.NullPointer;
j++;
}
Data.RemoveAt(Data.Count - 1);
Children.RemoveAt(Children.Count - 1);
}
else
{
Data.Add(data);
Children.Add(Util.NullPointer);
// Agregarlos en orden
InsertData(data, Right, false);
// Dato a subir
Middle = Data.Count / 2;
ToUpData = Data[Middle];
Data[Middle] = createFixedSizeText.CreateNull();
// Llenar datos que suben
int j = 0;
for (int i = Middle + 1; i < Data.Count; i++)
{
Node.Data[j] = Data[i];
Data[i] = createFixedSizeText.CreateNull();
j++;
}
// Llenar hijos que suben
j = 0;
for (int i = Middle + 1; i < Children.Count; i++)
{
Node.Children[j] = Children[i];
Children[i] = Util.NullPointer;
j++;
}
Data.RemoveAt(Data.Count - 1);
Children.RemoveAt(Children.Count - 1);
}
}
internal Node <T> ReadNode(string Path, int Order, int Root, int ID, ICreateFixedSizeText <T> createFixedSizeText)
{
int Father = 0;
if (ID == Root)
{
Father = Util.NullPointer;
}
Node <T> node = new Node <T>(Order, ID, Father, createFixedSizeText);
int HeaderSize = Header.FixedSize;
byte[] buffer;
if (ID <= Root)
{
buffer = new byte[node.FixedSize(node.Father)];
using (var fs = new FileStream(Path, FileMode.OpenOrCreate))
{
fs.Seek((HeaderSize + ((ID - 1) * node.FixedSize(1))), SeekOrigin.Begin);
fs.Read(buffer, 0, node.FixedSize(node.Father));
}
}
else
{
buffer = new byte[node.FixedSize(node.Father)];
using (var fs = new FileStream(Path, FileMode.OpenOrCreate))
{
fs.Seek((HeaderSize + ((ID - 1) * node.FixedSize(1)) + node.FixedSize(Util.NullPointer)), SeekOrigin.Begin);
fs.Read(buffer, 0, node.FixedSize(node.Father));
}
}
var NodeString = ByteGenerator.ConvertToString(buffer);
var Values = NodeString.Split(Util.Separator);
node.Father = Convert.ToInt32(Values[1]);
//Hijos
int DataLimit = Order;
if (node.Father.Equals(Util.NullPointer))
{
DataLimit = (4 * (Order - 1)) / 3;
int j = 0;
for (int i = 2; i < DataLimit + 2; i++)
{
node.Data[j] = createFixedSizeText.Create(Values[i]);
j++;
}
j = 0;
int StartLimit = node.Data.Count + 2;
for (int i = StartLimit; i < Values.Length - 1; i++)
{
node.Children[j] = Convert.ToInt32(Values[i]);
j++;
}
}
else
{
int j = 0;
for (int i = 2; i < DataLimit + 1; i++)
{
node.Data[j] = createFixedSizeText.Create(Values[i]);
j++;
}
j = 0;
int StartLimit = node.Data.Count + 2;
//Valores
for (int i = StartLimit; i < Values.Length - 1; i++)
{
node.Children[j] = Convert.ToInt32(Values[i]);
j++;
}
}
return(node);
}
internal Nodo <T> LecturaNodo(string Ruta, int Order, int Raiz, int ID, ICreateFixedSizeText <T> createFixedSizeText)
{
int Padre = 0;
if (ID == Raiz)
{
Padre = MetodosNecesarios.NullPointer;
}
Nodo <T> nodo = new Nodo <T>(Order, ID, Padre, createFixedSizeText);
int TamanoEncabezado = Encabezado.tamanoAjustado;
byte[] buffer;
if (ID <= Raiz)
{
buffer = new byte[nodo.TamanoCorregido(nodo.Padre)];
using (var _FileStream = new FileStream(Ruta, FileMode.OpenOrCreate))
{
_FileStream.Seek((TamanoEncabezado + (Raiz - 1) * nodo.TamanoCorregido(nodo.Padre)), SeekOrigin.Begin);
_FileStream.Read(buffer, 0, nodo.TamanoCorregido(nodo.Padre));
}
}
buffer = new byte[nodo.TamanoCorregido(nodo.Padre)];
using (var _FileStream = new FileStream(Ruta, FileMode.OpenOrCreate))
{
_FileStream.Seek((TamanoEncabezado + ((Raiz - 1) * nodo.TamanoCorregido(nodo.Padre)) + nodo.TamanoCorregido(MetodosNecesarios.NullPointer)), SeekOrigin.Begin);
_FileStream.Read(buffer, 0, nodo.TamanoCorregido(nodo.Padre));
}
var CadenaNodo = GeneradorData.ConvertToString(buffer);
var valor = CadenaNodo.Split(MetodosNecesarios.Separador);
nodo.Padre = Convert.ToInt32(valor[1]);
int LimitacionData = Order;
if (nodo.Padre.Equals(MetodosNecesarios.NullPointer))
{
LimitacionData = (4 * (Order - 1)) / 3;
int j = 0;
for (int i = 2; i < LimitacionData + 2; i++)
{
nodo.Data[j] = createFixedSizeText.Create(valor[i]);
j++;
}
j = 0;
int LimitacionInicial = nodo.Data.Count + 2;
for (int i = LimitacionInicial; i < valor.Length; i++)
{
nodo.Hijos[j] = Convert.ToInt32(valor[i]);
j++;
}
}
else
{
int j = 0;
for (int i = 2; i < LimitacionData + 1; i++)
{
nodo.Data[j] = createFixedSizeText.Create(valor[i]);
j++;
}
j = 0;
int LimiteInicial = nodo.Data.Count + 2;
for (int i = LimiteInicial; i < valor.Length; i++)
{
nodo.Hijos[i] = Convert.ToInt32(valor[i]);
j++;
}
}
return(nodo);
}
internal void ReinicioEnDiscoNodo(string Ruta, ICreateFixedSizeText <T> createFixedSizeText, int raiz)
{
ReinicioNodo(createFixedSizeText);
EscrituraEnDiscoNodo(Ruta, raiz);
}
internal void SeparacionNodo(T _data, int derecho, Nodo <T> Nodo, T SubirData, ICreateFixedSizeText <T> createFixedSizeText)
{
int medio = 0;
if (Padre.Equals(MetodosNecesarios.NullPointer))
{
Data.Add(_data);
Hijos.Add(MetodosNecesarios.NullPointer);
InsertarDatos(_data, derecho, false);
medio = Data.Count / 2;
SubirData = Data[medio];
Data[medio] = createFixedSizeText.CreateNull();
int j = 0;
for (int i = medio + 1; i < Data.Count; i++)
{
Nodo.Data[j] = Data[i];
Data[i] = createFixedSizeText.CreateNull();
j++;
}
j = 0;
for (int i = medio + 1; i < Hijos.Count; i++)
{
Nodo.Hijos[j] = Hijos[i];
Hijos[j] = MetodosNecesarios.NullPointer;
j++;
}
Data.RemoveAt(Data.Count - 1);
Hijos.RemoveAt(Hijos.Count - 1);
}
else
{
Data.Add(_data);
Hijos.Add(MetodosNecesarios.NullPointer);
InsertarDatos(_data, derecho, false);
medio = Data.Count / 2;
SubirData = Data[medio];
Data[medio] = createFixedSizeText.CreateNull();
int j = 0;
for (int i = medio + 1; i < Hijos.Count; i++)
{
Nodo.Data[j] = Data[i];
Data[i] = createFixedSizeText.CreateNull();
j++;
}
j = 0;
for (int i = medio + 1; i < Hijos.Count; i++)
{
Nodo.Hijos[j] = Hijos[i];
Hijos[i] = MetodosNecesarios.NullPointer;
j++;
}
Data.RemoveAt(Data.Count - 1);
Hijos.RemoveAt(Hijos.Count - 1);
}
}