C++ DLLNode类代码示例

/**
 * @brief printDataStructureByUser imprime cómo está conformado el registro
 * según los campos que ingresó el usuario
 */
void BTRecordFile::printDataStructureByUser() // TODO ver que hay duplicado
{
    std::cout << "Los registros tienen la siguiente estructura: \n\n";

    DLLNode<IRecordDataType *> *current =
        _metadataPtr->getRecordStruct()->getHeadPtr();

    char headerName;

    do {
        headerName = *current->getData()->getName().c_str();

        if (headerName == BTRecordFileMetadata::STRING) {
            std::cout << "string";
        } else if (headerName == BTRecordFileMetadata::CHAR) {
            std::cout << "char";
        } else if (headerName == BTRecordFileMetadata::SHORT) {
            std::cout << "short";
        } else if (headerName == BTRecordFileMetadata::INT) {
            std::cout << "int";
        } else if (headerName == BTRecordFileMetadata::DOUBLE) {
            std::cout << "double";
        } else if (headerName == BTRecordFileMetadata::BOOL) {
            std::cout << "bool";
        } else {
            std::cout << "El tipo de dato no es soportado";
        }

        //        current = current->getNextPtr();
        current++;

    } while (current != nullptr);

    std::cout << "\n\n";
}

// Imprime cada uno de los elementos que hay en la lista, llamando al método
// print de cada nodo.
void LinkedList::print()const {
    DLLNode* tmp = head;
    for (int i=0; i < getSize; i++){
        tmp->print();
        tmp = tmp->getNext();
    }    
}

/**
 * @brief BTRecordFile::readRecordFromDiskTest
 * @param pDisk
 * @param pRecordID
 * Hace la lectura de un registro en la RAM
 */
void BTRecordFile::readRecordFromDiskTest(Disk pDisk, unsigned short pRecordID)
{
    const char *padre = pDisk.read(this->_metadataPtr->getFirstRecordPos(), 7);
    const char *hizq = pDisk.read(this->_metadataPtr->getFirstRecordPos() + 8, 7);
    const char *hder = pDisk.read(this->_metadataPtr->getFirstRecordPos() + 16, 7);
    std::string father(padre);          // obtiene el padre
    std::string HI(hizq);               // obtiene el hijo izq
    std::string HD(hder);               // obtiene el hijo der
    unsigned short _sizeCounter = this->_metadataPtr->getFirstRecordPos() + 24;       // inicio de la data
    DLL<IRecordDataType*> *tmp1 = _metadataPtr->getRecordStruct();
    DLLNode<IRecordDataType*> *tmp = tmp1->getHeadPtr();
    const char *data;

    cout << "Binario " << father << " " << HI << " " << HD << endl;
    std::string P = _conversion->binaryToDecimal(father);
    std::string PHI = _conversion->binaryToDecimal(HI);
    std::string PHD = _conversion->binaryToDecimal(HD);
    cout << P << " " << PHI << " " << PHD << " ";
    while (tmp != nullptr) {
        data = (dynamic_cast<RecordDataType<char>*>(tmp->getData()))->getDataPtr();
        const char *DATO = pDisk.read(_sizeCounter, 7);
        std::string DATOSTR(DATO);       // obtiene el padre
        _sizeCounter += 8;
        cout << sortUserDataFromDisk(DATOSTR, *data) << endl;
        tmp = tmp->getNextPtr();
    }
}

/**
 * @brief BTRecordFile::getUserRecordData
 * Itera sobre la DLL de los datos que el usuario introduce
 */
std::string BTRecordFile::getUserRecordData(DLL<IRecordDataType *> *_dataListPtr)
{
    std::string finalBinaryRecord;  // concatenacion del registro
    DLLNode<IRecordDataType*> *tmp = _dataListPtr->getHeadPtr();
    RecordDataType<std::string> *data;
    while (tmp != nullptr) {
        data = dynamic_cast<RecordDataType<std::string>*>(tmp->getData());
        QString qstrData = _conversion->fromStringToQString(*data->getDataPtr());

        if (_conversion->verificaValidezDouble(qstrData) == true) {                    // VERIFICACION DE SI EL DATO ES DEL TIPO DOUBLE
            _conversion->setFillData((data->getSize() * 8));
            finalBinaryRecord += _conversion->fromDoubleString2BinaryString(*data->getDataPtr());
        }

        else if (_conversion->verificaValidezInt(qstrData) == true) {   // cadena no de numeros
            _conversion->setFillData((data->getSize() * 8));
            finalBinaryRecord += _conversion->decimalToBinary(*data->getDataPtr());
        } else { // letras
            _conversion->setFillData((data->getSize() * 8));
            finalBinaryRecord += _conversion->stringToBinary(*data->getDataPtr());
        }
        tmp = tmp->getNextPtr();
    }
    cout << "El registro en BINARIO es: " << "\n" << finalBinaryRecord << endl;
    _conversion->setFillData(8);
    return finalBinaryRecord;
}

// Consigue el elemento index de la lista, si index es una posición válida
Object* LinkedList::get(int index)const {
    if (index < 0 || index >= getSize)
        return NULL;
    DLLNode* tmp = head;
    for (int i=0; i < index; i++)
        tmp = tmp->getNext();
    return tmp->getData();
}

// Retorna el último elemento de la lista, si es que hay alguno
Object* LinkedList::last()const {
    if (!head)
        return NULL;
    DLLNode* tmp = head;
    for (int i=0; i < getSize -1; i++)
        tmp = tmp->getNext();
    return tmp->getData();
}

TDAList* LinkedList::toFArrayList()const{
    TDAList* retVal = new FArrayList(getSize);
    DLLNode* temp = head;
    for (int i = 0; i<getSize ; i++){
        retVal->insert(temp->getData(),i);
        temp = temp->getNext();
    }
    return retVal;
}

/*
* Búsqueda del índice (posición) de un objeto
* Para que esta operación tenga éxito es necesario que los objetos que sean
* insertados en la lista tengan bien definido el método equals, pues es este
* método el que determinará la igualdad de un objeto con otro.
*/
int LinkedList::indexOf(Object* other)const {
    DLLNode* tmp = head;
    for (int i=0; i < getSize; i++){
        // Compara cada uno de los elementos con el parámetro
        if (tmp->getData()->equals(other))
                return i;
        tmp = tmp->getNext();
    }    
    // En el caso de no encontrarlo
    return -1;
}

// GetInputFiles
//------------------------------------------------------------------------------
void LinkerNode::GetInputFiles( Node * n, Args & fullArgs, const AString & pre, const AString & post ) const
{
    if ( n->GetType() == Node::LIBRARY_NODE )
    {
        const bool linkObjectsInsteadOfLibs = m_LinkerLinkObjects;

        if ( linkObjectsInsteadOfLibs )
        {
            LibraryNode * ln = n->CastTo< LibraryNode >();
            ln->GetInputFiles( fullArgs, pre, post, linkObjectsInsteadOfLibs );
        }
        else
        {
            // not building a DLL, so link the lib directly
            fullArgs += pre;
            fullArgs += n->GetName();
            fullArgs += post;
        }
    }
    else if ( n->GetType() == Node::OBJECT_LIST_NODE )
    {
        const bool linkObjectsInsteadOfLibs = m_LinkerLinkObjects;

        ObjectListNode * ol = n->CastTo< ObjectListNode >();
        ol->GetInputFiles( fullArgs, pre, post, linkObjectsInsteadOfLibs );
    }
    else if ( n->GetType() == Node::DLL_NODE )
    {
        // for a DLL, link to the import library
        DLLNode * dllNode = n->CastTo< DLLNode >();
        AStackString<> importLibName;
        dllNode->GetImportLibName( importLibName );
        fullArgs += pre;
        fullArgs += importLibName;
        fullArgs += post;
    }
    else if ( n->GetType() == Node::COPY_FILE_NODE )
    {
        CopyFileNode * copyNode = n->CastTo< CopyFileNode >();
        Node * srcNode = copyNode->GetSourceNode();
        GetInputFiles( srcNode, fullArgs, pre, post );
    }
    else
    {
        // link anything else directly
        fullArgs += pre;
        fullArgs += n->GetName();
        fullArgs += post;
    }

    fullArgs.AddDelimiter();
}

/**
 * @brief BTRecordFile::readOneRecordFromDisk
 * @param recordID
 * Lee solo un registro desde disco
 */
void BTRecordFile::readOneRecordFromDisk(unsigned short recordID)
{
    if (recordID <= this->_metadataPtr->getNumberOfRecords() - 1) {
        unsigned short BOF = this->_metadataPtr->getFirstRecordPos();
        unsigned short recordSize = this->_metadataPtr->getRecordSize();
        unsigned short recordSpace = BOF + (recordSize * (recordID - 1));
        const char* padre = this->_disk->read(recordSpace, 7);
        std::string stringData1 = _conversion->fromConstChar2String(padre);
        const char* Hizq = this->_disk->read(recordSpace + 8, 7);
        std::string stringData2 = _conversion->fromConstChar2String(Hizq);
        const char* Hder = this->_disk->read(recordSpace + 16, 7);
        std::string stringData3 = _conversion->fromConstChar2String(Hder);

        cout << "BOF: " << BOF << "EOF: " << _metadataPtr->getEOF() << "\nrecordSize: " << recordSize << "\nrecordSpace: " << recordSpace;

        cout << "Registro #" << recordID << " " ;
        cout << "Padre: ";
        cout << _conversion->binaryToDecimal(stringData1);
        cout << " hIzq: ";
        cout << _conversion->binaryToDecimal(stringData2);
        cout << " hDer: ";
        cout << _conversion->binaryToDecimal(stringData3);
        cout << endl;

        DLL<IRecordDataType*> *tmp1 = _metadataPtr->getRecordStruct();
        DLLNode<IRecordDataType*> *tmp = tmp1->getHeadPtr();
        const char *data;
        recordSpace += 24;
        while (tmp != nullptr) {
            cout << " " << tmp->getData()->getName() << ": " ;
            data = (dynamic_cast<RecordDataType<char>*>(tmp->getData()))->getDataPtr();
            const char *DATO = _disk->read(recordSpace, tmp->getData()->getSize() * 8 - 1);
            std::string DATOSTR(DATO);
            cout << sortUserDataFromDisk(DATOSTR, *data);
            recordSpace += (tmp->getData()->getSize() * 8);
            tmp = tmp->getNextPtr();
        }
        cout << endl;
        cout << "-----------------------------------------------------" << endl;
    }
}

/* 
* Inserción en la lista
* En esta operación se consideran cuatro casos generales de inserción:
* (A) La Lista está Vacía
* (B) Se desea Insertar antes de head (pos = 0)
* (C) Se desea Insertar en Medio de la Lista
* (D) Se desea Insertar al Final (pos = getSize)
*/
bool LinkedList::insert(Object* data, int pos) {
    // Si se desa meter en una posición inválida
    if (pos < 0 || pos > getSize)
        return false; // Fracaso en esta Operación
    
    // Creación del Nodo que insertaremos en la lista
    DLLNode* neo = new DLLNode(data);
    
    if (!head) // La lista está vacía
        head = neo;
    else { // La Lista tiene elementos
        if (pos == 0){ // Desea insertar al principio de la lista
            // Enlace de neo a la lista
            head->setPrev(neo);
            neo->setNext(head);
            // Actualizar la cabeza
            head = neo;
        }else if (pos > 0 && pos < getSize){ // Desea Insertar en medio
            DLLNode* tmp = head;
            // Recorrer hasta la posición anterior a la que deseamos insertar
            for (int i=1; i<pos; i++)
               tmp = tmp->getNext();
            // Enlazar el Nodo neo
            neo->setPrev(tmp);
            neo->setNext(tmp->getNext());
            tmp->getNext()->setPrev(neo);
            tmp->setNext(neo);
        }else { // Desea insertar al final
            DLLNode* tmp = head;
            // Recorrer la Lista hasta el final
            for (int i=1; i<pos; i++)
               tmp = tmp->getNext();
            // Enlazar el Nodo neo
            tmp->setNext(neo);
            neo->setPrev(tmp);        
        }    
    }
    // Incremento del tamaño
    getSize++;
    // Éxito en la operación
    return true;
}

/*
* Borra un elemento de la lista, dada la posición del mismo. Se consideran
* tres casos:
* (A) El Elemento es la Cabeza
* (B) El Elemento es el Último
* (C) El Elemento está en Medio
* Es importante recalcar que para borrar un elemento es necesario primero
* desenlazarlo de la lista y luego liberar su memoria, pues en caso contrario
* liberaríamos todos los elementos siguiente a este elemento.
*/
Object* LinkedList::remove(int pos) {
    // Si es una posición Inválida
    if (pos < 0 || pos >= getSize)
        return NULL; // Indicar fracaso en la operación
    DLLNode* tmp;
    Object* tmpData;
    if (pos == 0){ // Desea Borrar la Cabeza
        // Desenlazar
        tmpData = head->getData();
        tmp = head->getNext(); 
        head->setData(NULL);
        tmp->setPrev(NULL);
        head->setNext(NULL);
        // Liberar Memoria
        delete head;
        // Actualizar head
        head = tmp;
    }else if (pos == getSize - 1){ // Desea Borrar el último
        // Recorrer hasta el final
        tmp = head;
        for (int i=1; i<pos; i++)
           tmp = tmp->getNext();
        tmpData = tmp->getNext()->getData();
        // Desenlazar
        DLLNode* toErase = tmp->getNext();   
        tmp->setNext(NULL);
        toErase->setPrev(NULL);
        toErase->setData(NULL);
        
        // Liberar Memoria
        delete toErase; 
        
    }else { // Desea Borrar de enmedio
        // Recorrer hasta el nodo anterior al que se desea borrar
        tmp = head;
        for (int i=1; i<pos; i++)
           tmp = tmp->getNext();
        // Desenlazar
        tmpData = tmp->getNext()->getData();
        DLLNode* toErase = tmp->getNext();
        tmp->setNext(toErase->getNext());
        toErase->getNext()->setPrev(tmp);
        toErase->setNext(NULL);
        toErase->setPrev(NULL);
        toErase->setData(NULL);
        // Liberar Memoria
        delete toErase;        
    }
    getSize--; // Disminuir Tamaño
    return tmpData; // Indicar Éxito
}

/**
 * @brief BTRecordFile::saveMetadata2Disk
 * Guarda los metadatos antes de cerrar sesión y los escribirá en disco
 */
void BTRecordFile::saveMetadata2Disk()
{
    std::string metadataBinary;
    std::string puntero = _conversion->fromShort2String(_metadataPtr->getPointerNextBlock());
    std::string tamanoRegistro = _conversion->fromShort2String(_metadataPtr->getRecordSize());
    std::string BOF = _conversion->fromShort2String(_metadataPtr->getFirstRecordPos());
    std::string cantidadRegistro = _conversion->fromShort2String(_metadataPtr->getNumberOfRecords());
    std::string ENDOF = _conversion->fromShort2String(_metadataPtr->getEOF());
    std::string freeBlocks = _conversion->fromShort2String(_metadataPtr->getFreeBlockList());
    _conversion->setFillData(16);   // hace los datos de tamaño 16 en binario
    metadataBinary += _conversion->decimalToBinary(puntero);
    cout << _conversion->decimalToBinary(puntero) << endl;
    metadataBinary += _conversion->decimalToBinary(tamanoRegistro);
    cout << _conversion->decimalToBinary(tamanoRegistro) << endl;
    metadataBinary += _conversion->decimalToBinary(BOF);
    cout << _conversion->decimalToBinary(BOF) << endl;
    metadataBinary += _conversion->decimalToBinary(cantidadRegistro);
    cout << _conversion->decimalToBinary(cantidadRegistro) << endl;
    metadataBinary += _conversion->decimalToBinary(ENDOF);
    cout << _conversion->decimalToBinary(ENDOF) << endl;
    metadataBinary += _conversion->decimalToBinary(freeBlocks);
    cout << _conversion->decimalToBinary(freeBlocks) << endl;
    cout << "Metadatos: " << metadataBinary << endl;
    cout << "Tamaño Metadatos: " << metadataBinary.length() << endl;

    DLL<IRecordDataType*> *tmp1 = _metadataPtr->getRecordStruct();
    DLLNode<IRecordDataType*> *tmp = tmp1->getHeadPtr();
    std::string size = _conversion->fromShort2String(tmp1->getSize());  // numero de datos de usuario
    metadataBinary += _conversion->decimalToBinary(size);  // cantidad de datos usuario

    _conversion->setFillData(_sizeOwner_FileName);  //24
    metadataBinary += _conversion->stringToBinary(_metadataPtr->getFileName());
    cout << _conversion->stringToBinary(_metadataPtr->getFileName()) << endl;
    metadataBinary += _conversion->stringToBinary(_metadataPtr->getOwner());
    cout << _conversion->stringToBinary(_metadataPtr->getOwner()) << endl;

    cout << "Metadatos: " << metadataBinary << endl;
    cout << "Tamaño Metadatos: " << metadataBinary.length() << endl;
    unsigned short data1;
    std::string data2;
    std::string data3;
    std::string datos;
    while (tmp != nullptr) {
        data1 = (dynamic_cast<RecordDataType<char>*>(tmp->getData()))->getSize();
        data2 = (dynamic_cast<RecordDataType<char>*>(tmp->getData()))->getDataPtr();
        data3 = (dynamic_cast<RecordDataType<char>*>(tmp->getData()))->getName(); // titulo
        std::string tamanoDato = _conversion->fromShort2String(data1);
        _conversion->setFillData(_sizeOwner_FileName);  //24
        datos += _conversion->decimalToBinary(tamanoDato);
        datos += _conversion->decimalToBinary(data2);
        datos += _conversion->stringToBinary(data3);
        cout << "MUSR1: " << data1 << " " << _conversion->decimalToBinary(tamanoDato) << endl;
        cout << "MUSR2: " << data2 << " " << _conversion->decimalToBinary(data2) << endl;
        cout << "MUSR3: " << data3 << " " << _conversion->stringToBinary(data3) << endl;
        cout << "MetadatosUSR: " << datos << endl;
        cout << "Tamaño MetadatosUSR: " << datos.length() << endl;
        tmp = tmp->getNextPtr();
    }
    metadataBinary += datos;
    cout << "Metadatos: " << metadataBinary << endl;
    cout << "Tamaño Metadatos: " << metadataBinary.length() << endl;

    _disk->write(0, _conversion->fromStringToConstChar(metadataBinary));    // escribe a disco
  //    return metadataBinary;
}