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);
}
}
private void UpData(Nodo <T> node, T data, int Derecho)
{
if (node.CapacidadMax && node.Padre != MetodosNecesarios.NullPointer)
{
Nodo <T> nPadre = new Nodo <T>();
nPadre.ID = node.Padre;
nPadre = nPadre.LecturaNodo(this.Ruta, this.Orden, this.Raiz, node.Padre, createFixedSizeText);
int posicion = 0;
for (int i = 0; i < nPadre.Hijos.Count(); i++)
{
if (nPadre.Hijos[i] == node.ID)
{
posicion = i;
break;
}
}
Nodo <T> TemporalNode = new Nodo <T>();
if (nPadre.Hijos[posicion + 1] != MetodosNecesarios.NullPointer)
{
TemporalNode = TemporalNode.LecturaNodo(this.Ruta, this.Orden, this.Raiz, nPadre.Hijos[posicion + 1], createFixedSizeText);
if (!TemporalNode.CapacidadMax)
{
node.Data.Add(data);
node.Data.Sort();
T TemporalData = node.Data[node.Data.Count() - 1];
node.Data.Remove(TemporalData);
node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
T TemporalData2 = nPadre.Data[posicion - 1];
nPadre.Data.Insert(posicion - 1, TemporalData2);
TemporalNode.Data.Add(data);
TemporalNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
}
}
if (posicion > 0)
{
TemporalNode = TemporalNode.LecturaNodo(this.Ruta, this.Orden, this.Raiz, nPadre.Hijos[posicion - 1], createFixedSizeText);
if (!TemporalNode.CapacidadMax)
{
node.Data.Add(data);
node.Data.Sort();
T TemporalData = node.Data[0];
node.Data.Remove(TemporalData);
node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
T TemporalData2 = nPadre.Data[posicion - 1];
nPadre.Data.Insert(posicion - 1, TemporalData2);
TemporalNode.Data.Add(data);
TemporalNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
return;
}
}
List <T> SNodo = new List <T>();
foreach (var item in node.Data)
{
SNodo.Add(item);
}
if (nPadre.Hijos[posicion + 1] != MetodosNecesarios.NullPointer)
{
SNodo.Add(nPadre.Data[posicion]);
TemporalNode = TemporalNode.LecturaNodo(this.Ruta, this.Orden, this.Raiz, nPadre.Hijos[posicion + 1], createFixedSizeText);
}
else if (posicion > 0)
{
SNodo.Add(nPadre.Data[posicion - 1]);
TemporalNode = TemporalNode.LecturaNodo(this.Ruta, this.Orden, this.Raiz, nPadre.Hijos[posicion - 1], createFixedSizeText);
}
foreach (var item in TemporalNode.Data)
{
SNodo.Add(item);
}
SNodo.Add(data);
SNodo.Sort();
int min = (2 * (this.Orden - 1)) / 3;
node.Data.Clear();
TemporalNode.Data.Clear();
int contador = 0;
for (int i = 0; i < this.Orden - 1; i++)
{
if (contador < min)
{
node.Data.Add(SNodo[i]);
}
else
{
node.Data.Add(createFixedSizeText.CreateNull());
}
contador++;
}
nPadre.Data.Insert(posicion, SNodo[min]);
nPadre.Data.Insert(posicion + 1, SNodo[(min * 2) + 1]);
contador = 0;
for (int i = 0; i < this.Orden - 1; i++)
{
if (contador < min)
{
TemporalNode.Data.Add(SNodo[i + min + 1]);
}
else
{
TemporalNode.Data.Add(createFixedSizeText.CreateNull());
}
contador++;
}
contador = 0;
Nodo <T> NNode = new Nodo <T>();
NNode.Padre = nPadre.ID;
NNode.ID = UltimaPosicion;
NNode.Data = new List <T>();
NNode.Hijos = new List <int>();
UltimaPosicion++;
for (int i = 0; i < this.Orden - 1; i++)
{
if (contador < min)
{
NNode.Data.Add(SNodo[i + (2 * min) + 2]);
}
else
{
NNode.Data.Add(createFixedSizeText.CreateNull());
}
}
for (int i = 0; i < this.Orden; i++)
{
NNode.Hijos.Add(MetodosNecesarios.NullPointer);
}
node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
TemporalNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
nPadre.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
NNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
EscrituraEncabezado();
}
else if (true)
{
node.InsertarDatos(data);
node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
return;
}
Nodo <T> _NNode = new Nodo <T>(this.Orden, this.UltimaPosicion, node.Padre, createFixedSizeText);
this.UltimaPosicion++;
T TUData = createFixedSizeText.CreateNull();
node.SeparacionNodo(data, Derecho, _NNode, TUData, createFixedSizeText);
Nodo <T> NodoHijo = new Nodo <T>();
for (int i = 0; i < _NNode.Hijos.Count; i++)
{
if (_NNode.Hijos[i] != MetodosNecesarios.NullPointer)
{
NodoHijo = NodoHijo.LecturaNodo(this.Ruta, this.Orden, this.Raiz, _NNode.Hijos[i], createFixedSizeText);
NodoHijo.Padre = _NNode.ID;
NodoHijo.EscrituraEnDiscoNodo(Ruta, this.Raiz);
}
else
{
break;
}
}
if (node.Padre == MetodosNecesarios.NullPointer)
{
Nodo <T> NRaiz = new Nodo <T>(this.Orden, this.UltimaPosicion, MetodosNecesarios.NullPointer, createFixedSizeText);
this.UltimaPosicion++;
NRaiz.Hijos[0] = node.ID;
NRaiz.Hijos[1] = _NNode.ID;
NRaiz.InsertarDatos(data, _NNode.ID);
node.Padre = NRaiz.ID;
NRaiz.Padre = MetodosNecesarios.NullPointer;
_NNode.Padre = NRaiz.ID;
this.Raiz = NRaiz.ID;
node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
_NNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
NRaiz.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
}
else
{
node.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
_NNode.EscrituraEnDiscoNodo(this.Ruta, this.Raiz);
Nodo <T> Padre = new Nodo <T>();
Padre = Padre.LecturaNodo(this.Ruta, this.Orden, this.Raiz, node.Padre, createFixedSizeText);
UpData(Padre, data, _NNode.ID);
}
}
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);
}
