/**Método principal para llevar a cabo la eliminación de algun bloque*/
        public void Elimina_BloqueHashDinamica(CNodoEntidad e, CBloque b)
        {
            CTablaHashExt tH;
            /**
             * \param e Entidad a la que pertenece el nuevo bloque
             * \param b Objeto del nuevo bloque
             * */

            tH = getArchivo().LeerTablaHashExt(e.getApCabDatos());
            if (EliminaBloque(b, tH))
            {
                e.setApCabDatos(-1);
                getArchivo().escribeEntidad(e, e.getDir());
            }
        }
        /**Método principal para la eliminación de un registro*/
        public  void EliminaHashEstatica(CNodoEntidad e, CBloque b)
        {
            CHash tablaHash;

            tablaHash = getArchivo().LeerTablaHash(e.getApCabDatos());
            EliminaBloque(tablaHash, b);

            if (tablaHash.getNumCubetas() == 0)
            {
                e.setApCabDatos(-1);
                getArchivo().escribeEntidad(e, e.getDir());
            }
        }
        /**´Méetodo principal para llevar a cabo la inserción de algun bloque*/
        public bool Alta_HashDinamica(CNodoEntidad e, CBloque b)
        {
            /**
             * \param e Entidad a la que pertrnece el bloque
             * \param b Bloque Nuevo bloque a insertar
             * \return Retorna Falso(Si tuvo exito), True(Si ya existe el bloque alguna cubeta)
             * */
            CCubeta cubetaAux;
            CEntrada entradaAux;
            bool res = false;

            if (e.getApCabDatos() == -1)
            {
                tHashExt = new CTablaHashExt(); 
                cubetaAux = new CCubeta(-1, TAM_CUBETA); 
                entradaAux = new CEntrada(cubetaAux, -1);
                
                tHashExt.insEntrada(entradaAux);

                cubetaAux.setDir(getArchivo().ENDF());
                getArchivo().EscribeCubeta(cubetaAux);

                entradaAux.setDirCubeta(cubetaAux.getDir());
                entradaAux.setDir(getArchivo().ENDF());
                getArchivo().EscribeEntrada(entradaAux);

                tHashExt.setCabEntradas(entradaAux.getDir());
                tHashExt.setDir(getArchivo().ENDF());
                getArchivo().EscribeTablaHashExt(tHashExt);

                e.setApCabDatos(tHashExt.getDir());
                getArchivo().escribeEntidad(e, e.getDir());
            }
            else
                tHashExt = getArchivo().LeerTablaHashExt(e.getApCabDatos());

            b.setDir(getArchivo().ENDF());
         
            if ((res = InsBloque(b)) == false)
            {
                tHashExt.incNumReg();
                getArchivo().EscribeTablaHashExt(tHashExt);
            }

            return (res);
        }
Example #4
0
        /**Médoto principal para eliminar un  registro*/
        public void eliminaABplus(CNodoEntidad e, CBloque b)
        {
            long dirCabNueva = -1;

            if (eliminaClaveRec(e.getApCabDatos(), b.dameClavePrim(), ref dirCabNueva))
            {
                e.setApCabDatos(dirCabNueva);
                getArchivo().escribeEntidad(e, e.getDir());
            }
        }
        /**Método principal para llevar a cabo el alta de algun bloque*/
        public int Alta_HashEstatica(CNodoEntidad e, CBloque b)
        {
            int fH, fC;
            int res;
            CHash tHash;

            fH = fC = 0;

            if (e.getApCabDatos() == -1)
            {
                tHash = new CHash(getArchivo().ENDF(), TAM_HASH);
                getArchivo().EscribeTablaHash(tHash);
                e.setApCabDatos(tHash.getDir());
                getArchivo().escribeEntidad(e, e.getDir());
            }else
                tHash = getArchivo().LeerTablaHash(e.getApCabDatos());//Se lee la tabla Hash 

            FuncionHash(b, ref fH, ref fC);
            cubetaSel = fH;
            res = InsDirBloque(tHash, fH, b, fC);

            return (res);
        }
        /** Se elimina un indice primiraio*/
        public void eliminaIndicePrimario(CNodoEntidad e, CIndice ind)
        {
            CIndice bloAux, bloAnt;
            long ptrAux, ptrAnt;

            bloAux = bloAnt = null;
            ptrAux = ptrAnt = -1;

            ptrAux = e.getApCabDatos();

            while (ptrAux != -1)
            {
                bloAux = getArchivo().LeerIndicePrimario(ptrAux);

                if (ind.comparateTo(bloAux) != 0 )
                {
                    ptrAnt = ptrAux;
                    bloAnt = bloAux;
                    ptrAux = bloAux.getSigInd();
                }
                else
                    break;
            }

            if (ptrAux == e.getApCabDatos())
            {
                e.setApCabDatos(bloAux.getSigInd());
                getArchivo().escribeEntidad(e, e.getDir());
            }
            else
            {
                bloAnt.setSigInd(bloAux.getSigInd());
                getArchivo().EscribeIndicePrimario(bloAnt);
            }
        }
Example #7
0
        /**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);
        }
Example #8
0
        /**Función de Mantenimiento para la Hash Dinamica*/
        private void MantenimientoHashDinamica(CArchivo fileOri, CArchivo fileNew, CNodoEntidad ent, CNodoEntidad entC, int tamBloque)
        {
            CTablaHashExt tH, nuevaTH;
            List<CCubeta> listCub;
            List<int> lE;
            CCubeta nuevaCub;
            long cabDatos;

            cabDatos = ent.getApCabDatos();

            if (cabDatos != -1)
            {
                tH = fileOri.LeerTablaHashExt(cabDatos);
                nuevaTH = creaTabla(tH);

                listCub = dameCubetas(tH);
                foreach (CCubeta c in listCub)
                {
                    lE = buscaEntradas(tH, c);
                    nuevaCub = creaCubeta(c, fileNew, fileOri);

                    foreach (int i in lE)
                        nuevaTH.getAtEntrada(i).setCubeta(nuevaCub);
                }

                foreach (CEntrada e in nuevaTH.getListEntradas())
                {
                    e.setDir(fileNew.ENDF());
                    fileNew.EscribeEntrada(e);
                }

                for (int i = 0; i < nuevaTH.getListEntradas().Count - 1; i++)
                {
                    nuevaTH.getAtEntrada(i).setSigEntrada(nuevaTH.getAtEntrada(i + 1).getDir());
                    fileNew.EscribeEntrada(nuevaTH.getAtEntrada(i));
                }

                nuevaTH.setCabEntradas(nuevaTH.getAtEntrada(0).getDir());
                nuevaTH.setDir(fileNew.ENDF());
                fileNew.EscribeTablaHashExt(nuevaTH);
                entC.setApCabDatos(nuevaTH.getDir());
                fileNew.escribeEntidad(entC,entC.getDir());
            }
        }
        /* Inserta un indice primario en la lista de indices*/
        private void insIndicePri(CNodoEntidad e, ref CIndice nuevo, long posInd)
        {
            CIndice indAux, indAnt = null;
            long ptrAux, ptrAnt = -1;

            ptrAux = e.getApCabDatos();
            
            while (ptrAux != -1)
            {
                indAux = getArchivo().LeerIndicePrimario(ptrAux);

                if (indAux.comparateTo(nuevo) < 0)
                {
                    ptrAnt = ptrAux;
                    indAnt = indAux;
                    ptrAux = indAux.getSigInd();
                }
                else
                    break;
            }

            if (ptrAux == e.getApCabDatos())
            {
                e.setApCabDatos(posInd);
                getArchivo().escribeEntidad(e, e.getDir());
            }
            else
            {
                indAnt.setSigInd(posInd);
                getArchivo().EscribeIndicePrimario(indAnt);
            }

            nuevo.setDirInd(posInd);
            nuevo.setSigInd(ptrAux);
            getArchivo().EscribeIndicePrimario(nuevo);
        }
Example #10
0
        /**Función de Mantenimiento para la Hash Estatica*/
        private void MantenimientoHashEstatica(CArchivo fileOri, CArchivo fileNew, CNodoEntidad ent, CNodoEntidad entC, int tamBloque)
        {
            CHash tablaHash, nuevaTablaHash;
            long cabTabla;

            cabTabla = ent.getApCabDatos();

            if (cabTabla != -1)
            {
                tablaHash = fileOri.LeerTablaHash(cabTabla);
                nuevaTablaHash = new CHash(fileNew.ENDF(), tablaHash.getTamaño());
                nuevaTablaHash.setNumCubetas(tablaHash.getNumCubetas());

                fileNew.EscribeTablaHash(nuevaTablaHash);

                for (int i = 0; i < tablaHash.getTamaño(); i++)
                    nuevaTablaHash.setAtDirCubeta(i, CopiarListaCubetasRec(tablaHash.getAtDirCubeta(i), fileOri, fileNew, tamBloque));

                fileNew.EscribeTablaHash(nuevaTablaHash);

                entC.setApCabDatos(nuevaTablaHash.getDir());
                fileNew.escribeEntidad(entC, entC.getDir());
            }
        }
Example #11
0
 /**Función de Mantenimiento para Arboles B+*/
 public void MantenimientoArbolBplus(CArchivo fileOri, CArchivo fileNew, CNodoEntidad ent, CNodoEntidad entC, int tamBloque)
 {
     if (ent.getApCabDatos() != -1)
     {
         entC.setApCabDatos(generaArbolRec(fileOri, fileNew, tamBloque, ent.getApCabDatos()));
         fileNew.escribeEntidad(entC, entC.getDir());
     }
 }
Example #12
0
        /**Función de Mantenimiento para la Organizacion Secuencial indexada*/
        public void MantenimientoSecInd(CArchivo fileOri, CArchivo fileNew, CNodoEntidad ent, CNodoEntidad entC, int tamBloque)
        {
            List<CBloque> listBloque;
            List<CIndice> listaInd;
            CIndice indPri,nuevoInd;
            long aux;
            
            listaInd = new List<CIndice>();
            
            aux = ent.getApCabDatos();
            
            while (aux != -1)
            {
                indPri = fileOri.LeerIndicePrimario(aux);
                nuevoInd = new CIndice();

                nuevoInd.setIndPrim(indPri.getIndPrim());
                nuevoInd.setTamIndPri(indPri.getTamIndPri());
                nuevoInd.setTipoInd(indPri.getTipoInd());

                listBloque = new List<CBloque>();
                
                CopiarSec(fileOri, fileNew, indPri.getCabBloques(), tamBloque, ref listBloque);
                
                nuevoInd.setDirInd(fileNew.ENDF());
                nuevoInd.setCabBloques(listBloque[0].getDir());
                fileNew.EscribeIndicePrimario(nuevoInd);
                
                listaInd.Add(nuevoInd);
                
                aux = indPri.getSigInd();
            }

            for (int i = 0; i < listaInd.Count - 1; i++)
            {
                listaInd[i].setSigInd(listaInd[i + 1].getDirInd());
                fileNew.EscribeIndicePrimario((listaInd[i]));
            }
            
            entC.setApCabDatos(listaInd[0].getDirInd());
            fileNew.escribeEntidad(entC, ent.getDir());
        }
Example #13
0
        /**Funcionde Matenimiento para  la Organizacion Secuencial*/
        public void MantenimientoSec(CArchivo fileOri, CArchivo fileNew, CNodoEntidad ent, CNodoEntidad entC, int tamBloque)
        {
            List<CBloque> listBloque;

            listBloque = new List<CBloque>();
          
            CopiarSec(fileOri, fileNew, ent.getApCabDatos(), tamBloque, ref listBloque);
            
            entC.setApCabDatos(listBloque[0].getDir());
            fileNew.escribeEntidad(entC, ent.getDir());
        }
        /**\brief Baja de un registro*/
        public void BajaOS(CBloque blo, CNodoEntidad e, int tamB)
        {
            /**
             * \details
             * Elimina una registro del archivo secuencial. Para ello accede al primer registro
             * y busca el bloque a eliminar.
             * \param blo Bloque que sera eliminado.
             * \param e Entidad donde se ecuentra este bloque
             * \param tamB Tamaño del bloque
             * */

            CBloque bloAux, bloAnt;
            long ptrAux, ptrAnt;

            bloAux = bloAnt = null;
            ptrAux = ptrAnt = -1;
           
            ptrAux = e.getApCabDatos();

            while (ptrAux != -1)//Se busca la dirección del bloque
            {
                bloAux = getArchivo().leerBloque(ptrAux, tamB);

                if (blo.ComparateTo(bloAux) != 0)
                {
                    ptrAnt = ptrAux;
                    bloAnt = bloAux;
                    bloAnt.setTamBlo(tamB);
                    ptrAux = bloAux.getSigBlo();
                }
                else
                    break;
                
            }

            if (ptrAux == e.getApCabDatos())//Si es el primer bloque, se actualiza la cabecera de la entidad
            {
                e.setApCabDatos(bloAux.getSigBlo());
                getArchivo().escribeEntidad(e, e.getDir());
            }
            else
            {
                bloAnt.setSigBlo(bloAux.getSigBlo());
                bloAnt.setTamBlo(tamB);
                getArchivo().EscribeBloque(bloAnt, ptrAnt);
            }
        }