/**Funciión Hash, implementada con el modulo*/
public int FuncionHash(CBloque b)
{
//Aplicando modulo
Object clave = b.dameClavePrim();
int pos, c = 0;
pos = -1;
switch (b.getTipoCA())
{
case 3: //Entero
pos = (int)clave % TAM_CUBETA;
break;
case 5: //Long
pos = (int)((long)clave)%TAM_CUBETA;
break;
case 7: //Cadena
pos = Math.Abs(((string)clave).GetHashCode())%TAM_CUBETA;
break;
}
return (pos);
}
/**\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);
}
}
/**Implemeta un función hash con la tecnica del plegamiento para obtener la posición
* donde se insertara la nueva deirección del registro en la cubeta y la tabla hash*/
public void FuncionHash(CBloque b, ref int fH, ref int fC)
{
Object clave = b.dameClavePrim();
int c = 0;
switch (b.getTipoCA())
{
case 3: //Entero
c = (int)clave;
break;
case 5: //Long
c = (int)((long)clave);
break;
case 7: //Cadena
c = Math.Abs(((string)clave).GetHashCode());
break;
}
while (c / 10 != 0)
c = plegamiento(c);
fC = fH = c;
if (fC >= TAM_CUBETA)
{
fC = (fC - TAM_CUBETA) - 2;
if (fC < 0)
fC = 0;
}
if (fH >= TAM_HASH)
fH -= TAM_HASH;
}
/**\brief Particiona un nodo del Arbol B+*/
public CNodo particiona(CNodo hoja, CBloque b, long posB, ref Object clave, ref long dirClave, int i)
{
CNodo nuevo = new CNodo(hoja.getTipoNodo(), GRADO);
int k, j;
Object claveAux = null;
long dirAux = -1;
if (hoja.getTipoNodo() == RAIZHOJA)
{
hoja.setTipoNodo(HOJA);
nuevo.setTipoNodo(HOJA);
}
else
if (hoja.getTipoNodo() == RAIZ)
{
hoja.setTipoNodo(PAGINA);
nuevo.setTipoNodo(PAGINA);
}
nuevo.setTipoClave(b.getTipoCA());
j = (2 * GRADO) - 1;
if (i >= GRADO)
{
if (hoja.getTipoNodo() == RAIZ || hoja.getTipoNodo() == PAGINA)
{
if (i == GRADO)
{
k = GRADO - 1;
hoja.setNumElemnt(GRADO);
claveAux = clave;
dirAux = dirClave;
}
else
{
k = GRADO - 2;
hoja.setNumElemnt(GRADO);
claveAux = hoja.getAtClave(GRADO);
dirAux = hoja.getAtDirClaves(GRADO);
}
}
else
{
k = GRADO - 1;
hoja.setNumElemnt(GRADO);
}
}
else
{
if (hoja.getTipoNodo() == RAIZ || hoja.getTipoNodo() == PAGINA)
{
claveAux = hoja.getAtClave(GRADO - 1);
dirAux = hoja.getAtDirClaves(GRADO - 1);
k = GRADO - 1;
}
else
k = GRADO;
hoja.setNumElemnt(GRADO - 1);
}
nuevo.setNumElemnt(k + 1);
for (; k >= 0; k--, j--)
{
nuevo.setAtClave(k, hoja.getAtClave(j));
nuevo.setAtDirClaves(k, hoja.getAtDirClaves(j));
if (hoja.getTipoNodo() == RAIZ || hoja.getTipoNodo() == PAGINA)
nuevo.setAtDirNodo(k + 1, hoja.getAtDirNodo(j + 1));
else
nuevo.setAtDirNodo(k, hoja.getAtDirNodo(j));
}
if (i >= GRADO)
{
if (hoja.getTipoNodo() == RAIZ || hoja.getTipoNodo() == PAGINA)
{
if (i != GRADO)
{
nuevo.setAtDirNodo(0, hoja.getAtDirNodo(GRADO + 1));
nuevo.insClaveOrd(clave, b, getArchivo(), (i - GRADO) - 1);
nuevo.setAtDirClaves((i - GRADO) - 1, dirClave);
nuevo.setAtDirNodo(i - GRADO, posB);
}else
nuevo.setAtDirNodo(0, posB);
}
else
nuevo.insClaveOrd(clave, b, getArchivo(), i - GRADO);
}
else
{
hoja.insClaveOrd(clave, b, getArchivo(), i);
if (hoja.getTipoNodo() == RAIZ || hoja.getTipoNodo() == PAGINA)
{
nuevo.setAtDirNodo(0, hoja.getAtDirNodo(GRADO));
hoja.setAtDirClaves(i, dirClave);
hoja.setAtDirNodo(i + 1, posB);
}
}
if (hoja.getTipoNodo() == RAIZ || hoja.getTipoNodo() == PAGINA)
{
clave = claveAux;
dirClave = dirAux;
}else
{
clave = nuevo.getAtClave(0);
dirClave = nuevo.getAtDirClaves(0);
}
getArchivo().escribeNodo(hoja);
nuevo.setDir(getArchivo().ENDF());
getArchivo().escribeNodo(nuevo);
return (nuevo);
}
/**Metodo principal para la inserción de la clave junto con su bloque de datos*/
public bool AltaArbolBplus(CNodoEntidad e, CBloque b, long posB)
{
CNodo nuevo = null;
Object clave;
bool res = true;
long dirClave = -1;
clave = b.dameClavePrim();
if (e.getApCabDatos() == -1)//Si no hay algun arbol se crea la primera pagina
{
nuevo = new CNodo(RAIZHOJA, GRADO);
nuevo.setDir(getArchivo().ENDF());
nuevo.setTipoClave(b.getTipoCA());
getArchivo().escribeNodo(nuevo);
e.setApCabDatos(nuevo.getDir());
getArchivo().escribeEntidad(e, e.getDir());
}
else
{
bool bandera = false;
res = EmpujaDato(e.getApCabDatos(), ref clave, ref dirClave, b, posB, ref nuevo, ref bandera);
if (bandera == true)//La raiz se partido
{
CNodo nuevaRaiz;
nuevaRaiz = new CNodo(RAIZ, GRADO);
nuevaRaiz.setAtClave(0, clave);
nuevaRaiz.setAtDirClaves(0, dirClave);
nuevaRaiz.setAtDirNodo(0, ent.getApCabDatos());
nuevaRaiz.setAtDirNodo(1, nuevo.getDir());
nuevaRaiz.setDir(getArchivo().ENDF());
nuevaRaiz.setNumElemnt(1);
nuevaRaiz.setTipoClave(b.getTipoCA());
getArchivo().escribeNodo(nuevaRaiz);
e.setApCabDatos(nuevaRaiz.getDir());
getArchivo().escribeEntidad(e, e.getDir());
}
}
return (res);
}
/* Crea el indice primario correspondiente al bloque*/
public CIndice generaIndPri(CBloque nuevoB)
{
CIndice nuevo = new CIndice();
byte[] indAux = null;
int num, tamInd = 0;
long num2;
switch (nuevoB.getTipoCA())
{
case 3://Clave Primaria de Tipo entera
num = BitConverter.ToInt32(nuevoB.dameClave(), 0);
indAux = BitConverter.GetBytes((num / 10) * 10);
tamInd = 4;
break;
case 5://Clave primaria de tipo Long
num2 = BitConverter.ToInt64(nuevoB.dameClave(), 0);
indAux = BitConverter.GetBytes((num2 / 10) * 10);
tamInd = 8;
break;
case 7://Clave Primaria de Tipo Cadena
indAux = new byte[1];//Se saca el primer caracter
indAux[0] = nuevoB.dameClave()[0];
tamInd = 1;
break;
}
nuevo.setTipoInd(nuevoB.getTipoCA());
nuevo.setTamIndPri(tamInd);
nuevo.setIndPrim(indAux);
return (nuevo);
}
