Beispiel #1
0
ErrorCode freeBlock(FileSystem* fs, size_type* blockId) {
    if(*blockId < 0 || *blockId >= fs->super_block.numOfDataBlocks)
        return OutOfBound;

    //First free block
    if(fs->super_block.pDataFreeListHead == -1) {
        fs->super_block.pDataFreeListHead = *blockId;
        fs->super_block.pDataFreeListTail = *blockId;
        fs->super_block.modified = true;
        initEmptyNode(&(fs->dataBlockFreeListHeadBuf));
        memcpy(&(fs->dataBlockFreeListTailBuf), &(fs->dataBlockFreeListHeadBuf), sizeof(FreeListNode));
        return Success;
    }

    FreeListNode* tailBuf = &(fs->dataBlockFreeListTailBuf);
    if(tailBuf->free_block_arr[FREE_BLOCK_ARRAY_SIZE-1] > -1) {
        if(fs->super_block.pDataFreeListHead != fs->super_block.pDataFreeListTail) {
            put(fs, fs->super_block.pDataFreeListTail+fs->super_block.firstDataBlockId, &(fs->dataBlockFreeListTailBuf));
        }
        initEmptyNode(&(fs->dataBlockFreeListTailBuf));
        fs->super_block.pDataFreeListTail = *blockId;
        fs->super_block.numOfFreeBlocks++;
        return Success;
    }

    int i;
    for(i = 0; i <= FREE_BLOCK_ARRAY_SIZE-1; i++) {
        if(tailBuf->free_block_arr[i] > -1)
            continue;
        tailBuf->free_block_arr[i] = *blockId;
        if(fs->super_block.pDataFreeListHead == fs->super_block.pDataFreeListTail) {
            fs->dataBlockFreeListHeadBuf.free_block_arr[i] = *blockId;
        }
        fs->super_block.numOfFreeBlocks++;
        break;
    }

    return Success;
}
Beispiel #2
0
int eSuficiente (float d, node pontos) { /* Descobre se a distância d é suficiente para tornar o grafo 'pontos' conexo */
    
    float d2 = d*d; /* Evita ter que multiplicar a cada iteração */
    
    node desconectados = pontos; /* Lista de pontos que ainda não conectamos */
    node conectados = initEmptyNode(); /* Lista de pontos que já foram conectados */
    node noduloCon; /* Percorrer a conectados */
    node noduloDes; /* Percorrer a desconectados */
    
    conectados->prox = removeProximoNodulo(desconectados); /* Escolhe-se um ponto arbitrário para começar */
    
    noduloCon = conectados;
    noduloDes = desconectados;
        
    while (noduloCon->prox != NULL) { /* Percorre a conectados */
        while (noduloDes->prox != NULL) { /* Percorre a desconectados */
            if (quickDistance(noduloDes->prox, noduloCon->prox) <= d2) { /* Se a distância for menor, precisa conectar */
                insereNodulo(removeProximoNodulo(noduloDes), noduloCon->prox); /* Tira da desconectados, põe na conectados.
                                                                                   Colocamos o ponto logo depois de noduloCon,
                                                                                   garantindo que ele ainda será analisado.*/
            }
            else {
                noduloDes = noduloDes->prox; /* Se removemos um ponto da desconectados, não precisa andar. Caso contrário, anda. */
            }
        }
        noduloDes = desconectados; /* Reinicia do começo da desconectados */
        noduloCon = noduloCon->prox; /* Anda na conectados */
    }
    
    if (desconectados->prox == NULL) {/* Se a desconectados está vazia, é porque conseguimos conectar todos os pontos com a distância d */
        pontos = juntaLista(desconectados, conectados); /* Reconstruimos a lista 'pontos' que foi separada em duas no processo */
        return YES;
    }
    
    pontos = juntaLista(desconectados, conectados);
    return NO;
    
}