C++ LIS_ObterValor函数代码示例

int firstFit(Memory *mem, LIS_tppLista lisProntos)
{	
	Processo *aux;
	int cnt = 0, fail = 0,i;
	IrInicioLista(lisProntos);
	aux = (Processo*)LIS_ObterValor(lisProntos);
	cnt = LIS_ObterTamanho(lisProntos);
	fail = 1;
	while(cnt > 0)
	{
		for(i = 0; i < 5; i++)
		{
			if((aux->tamanho <= mem->s[i].tam) && (mem->s[i].proc == NULL) && (aux->naMemoria == 0)) // se o tamanho do process é menor q o segmento da memoria
			{
				InsereProcessosMem(mem, aux, mem->s[i].tam);
				fail = 0;
				break;
			}
		}
		LIS_AvancarElementoCorrente(lisProntos, 1);
		aux = (Processo*)LIS_ObterValor(lisProntos);
		cnt--;
	}
	return fail;
}

MTZ_tpCondRet MTZ_DestruirMatriz ( LIS_tppLista Tab )
{
	
	LIS_tppLista Col;
	PLH_tppPilha p;

	while ( Tab != NULL) {
			
			IrFinalLista( Tab );
			Col = (LIS_tppLista) LIS_ObterValor( Tab );
			
		while (Col != NULL) {
				IrFinalLista( Col );
				p = (PLH_tppPilha) LIS_ObterValor( Col );
				PLH_Libera( p );
				LIS_ExcluirElemento( Col );
				IrInicioLista( Col );			
		}

			LIS_ExcluirElemento( Tab );
			IrInicioLista( Tab );
	}		

		free ( Tab );

		return MTZ_CondRetOK;
}

   int ListaDePassosSaoIguais(LIS_tppLista pPassos1, LIS_tppLista pPassos2)
   {
      PAS_tppPasso pPasso1;
      PAS_tppPasso pPasso2;
      LIS_tpCondRet ret1 = LIS_CondRetOK;
      LIS_tpCondRet ret2 = LIS_CondRetOK;

      LIS_IrInicioLista(pPassos1);
      LIS_IrInicioLista(pPassos2);

      while (ret1 == LIS_CondRetOK && ret2 == LIS_CondRetOK)
      {
         int saoIguais;
         LIS_ObterValor(pPassos1, (void **) &pPasso1);
         LIS_ObterValor(pPassos2, (void **) &pPasso2);

         PAS_CompararPassos(pPasso1, pPasso2, &saoIguais);
         if (!saoIguais)
         {
            return FALSE;
         }
         
         ret1 = LIS_AvancarElementoCorrente(pPassos1, 1);
         ret2 = LIS_AvancarElementoCorrente(pPassos2, 1);
      }

      if (ret1 != ret2)
      {
         return FALSE;
      }

      return TRUE;
   }

TAB_tpCondRet TAB_setarCasa(Tabuleiro *tabuleiro, int linha, char coluna, Peca *peca, int limpar)
{
    LIS_tppLista lista;
    Peca *antiga;

    --linha;
    coluna = tolower(coluna) - 'a';

    if(LIS_IrIndice(tabuleiro->lista, linha) != LIS_CondRetOK)
        return TAB_CondRetLinhaInexistente;
    lista = (LIS_tppLista)LIS_ObterValor(tabuleiro->lista);
    if(!lista)
        return TAB_CondRetLinhaInexistente;
    
    if(LIS_IrIndice(lista, coluna) != LIS_CondRetOK)
        return TAB_CondRetColunaInexistente;

    if(limpar) {
        antiga = LIS_ObterValor(lista);
        if(antiga)
            ListaExcluirPeca(antiga);
    }

    LIS_SetarValor(lista, peca);
    return TAB_CondRetOK;
}/* Fim função: TAB  &Setar valor de uma peça no tabuleiro */

void get_pair_by_id(GRA_tppGrafo pGrafo, int idAresta, tpVertice ** u, tpVertice ** v){
    tpAresta * aresta = NULL;
    tpVertice * vertice = NULL;

    LIS_IrInicioLista( pGrafo->vertices );

    // Para cada vértice
    do{
        vertice = (tpVertice*)LIS_ObterValor( pGrafo->vertices ) ;
        if(vertice == NULL) break;
        LIS_IrInicioLista( vertice->pNode->arestas ) ;
        // Procura em todos os seus vizinhos
        do{
            aresta = (tpAresta*)LIS_ObterValor( vertice->pNode->arestas ) ;
            
            if(aresta == NULL){
                continue;
            }
         
            if ( aresta->id == idAresta ){
                *u = vertice ;
                *v = aresta->pVizinho ;
                break;
            }
        }while(LIS_AvancarElementoCorrente( vertice->pNode->arestas , 1) == LIS_CondRetOK );
    }while ( LIS_AvancarElementoCorrente( pGrafo->vertices , 1) == LIS_CondRetOK ) ;
}

/***************************************************************************
*
*  Função: TAB  &Imprimir estado atual de um tabuleiro
*  ****/
void TAB_imprimir(Tabuleiro *tabuleiro)
{
    int x, y;
    //Assertivas de entrada
#ifdef _DEBUG
    if(tabuleiro == NULL)
        printf("\n Não foi possível imprimir o tabuleiro (não existe) \n");
#endif

    LIS_IrFinalLista(tabuleiro->lista);
    for(y = TabuleiroAltura - 1; y >= 0; --y) {
        LIS_tppLista lista;
        printf("%d|", y+1);

        lista = (LIS_tppLista)LIS_ObterValor(tabuleiro->lista);
        LIS_IrInicioLista(lista);
        for(x = 0; x < TabuleiroLargura; ++x) {
            Peca *peca = LIS_ObterValor(lista);
            if(peca)
                PEC_imprimir(peca);
            else
                printf(" |");

            LIS_AvancarElementoCorrente(lista, 1);
        }
        printf("\n");
        LIS_AvancarElementoCorrente(tabuleiro->lista, -1);
    }
    printf(" |A|B|C|D|E|F|G|H|\n");
}/* Fim função: TAB  &Imprimir estado atual de um tabuleiro */

int WorstFit (Memory *mem, LIS_tppLista lisProntos){
	Processo *aux;
	int cnt = 0, fail = 0, i;
	IrInicioLista(lisProntos);
	aux = (Processo*)LIS_ObterValor(lisProntos);
	cnt = LIS_ObterTamanho(lisProntos);
	fail = 1;
	while (cnt > 0)
	{
		int diferenca = 0;
		int BestInd = -1;
		for (i = 0; i < 5; i++)
		{
			if ((aux->tamanho <= mem->s[i].tam) && (mem->s[i].proc == NULL) && (aux->naMemoria == 0)) // se o tamanho do process é menor q o segmento da memoria
			{
				if (mem->s[i].tam - aux->tamanho >= diferenca){
					BestInd = i;
					diferenca = mem->s[i].tam - aux->tamanho;
				}
			}
		}
		if (BestInd != -1){
			InsereProcessosMem(mem, aux, mem->s[BestInd].tam);
			fail = 0;
		}
		LIS_AvancarElementoCorrente(lisProntos, 1);
		aux = (Processo*)LIS_ObterValor(lisProntos);
		cnt--;
	}
	return fail;
}

void GRA_DelNode (Graph *g)
{
	Node *n;
#ifdef _DEBUG
	int nOfNodesAntigo = g->nOfNodes;
	AssertGraph(g);
#endif /* _DEBUG */

    CNT_CONTAR("GRA_delNode - Inicializao");
	assert(g->currentNode);
	n = (Node *) LIS_ObterValor(g->currentNode);
	assert( n!=NULL );
#ifdef _DEBUG
	AssertNode(n,g);
#endif /* _DEBUG */

    CNT_CONTAR("GRA_delNode - Deletando no");
	delNode(g,n);
	LIS_ExcluirElemento(g->nodes);
	g->currentNode = LIS_ObterValor(g->nodes);
#ifdef _DEBUG
	g->nOfNodes--;
	assert ( g->nOfNodes == (nOfNodesAntigo - 1) );
	AssertGraph(g);
#endif /* _DEBUG */
}

void *GRA_NodesGetNext (Graph *g)
{
	void *ret;
	LIS_tppLista l;
    CNT_CONTAR("GRA_NodesGetNext - inicio");
#ifdef _DEBUG
	AssertGraph(g);
#endif /* _DEBUG */
	if (!g->currentNode){
		return NULL;
    }
    CNT_CONTAR("GRA_NodesGetNext - guardando g->nodes");
	l = g->nodes;
	if (!l){
        CNT_CONTAR("GRA_NodesGetNext - Nao existe g->nodes");
		return NULL;
    }
    CNT_CONTAR("GRA_NodesGetNext - Obtendo dado");
	ret = ((Node*)LIS_ObterValor (LIS_ObterValor(l)))->data;
	if (g->nodesOld == ret){ /* Se esse dado ja' repitiu, ja terminou a lista */
	    CNT_CONTAR("GRA_NodesGetNext - Dado repetido, fim da lista");
		return NULL;
	}
	CNT_CONTAR("GRA_NodesGetNext - Avanando elemento corrente");
	g->nodesOld = ret;
	LIS_AvancarElementoCorrente (l, 1);
#ifdef _DEBUG
	AssertGraph(g);
#endif /* _DEBUG */
    CNT_CONTAR("GRA_NodesGetNext - Finalizando");
	return ret;
}

void getNext(LIS_tppLista lisProc)
{
	Processo *aux;
	IrInicioLista(lisProc);
	aux = (Processo*)LIS_ObterValor(lisProc);
	while(aux->naMemoria == 0)
	{
		LIS_AvancarElementoCorrente(lisProc, 1);
		aux = (Processo*)LIS_ObterValor(lisProc);
	}
}

    static int BFS(tpVertice* v, tpVertice* u) {
        LIS_tppLista V = NULL; // LISTA VERTICE VISITADOS
        LIS_tppLista Q = NULL; //FILA
        LIS_tppLista arestas = NULL;
        tpVertice* t = NULL;
        tpVertice* s = NULL;
        tpAresta* a = NULL;
        int achou = 0;
        int achou_V = 0;

        V = LIS_CriarLista(NULL); // dados são referenciados por outros, não devem ser apagados
        Q = LIS_CriarLista(NULL); // dados são referenciados por outros, não devem ser apagados

        LIS_InserirElementoApos(V, v);
        LIS_InserirElementoApos(Q, v); //Usado como uma Fila.
        while (LIS_NumeroDeElementos(Q) > 0) {
            LIS_IrInicioLista(Q);
            t = (tpVertice *)LIS_ObterValor(Q);
            LIS_ExcluirElemento(Q);
            if (t == u) {
                achou = 1; 
                break;
            }
            arestas = t->pNode->arestas;
            LIS_IrInicioLista(arestas);
            do {
                a = (tpAresta *)LIS_ObterValor(arestas);
                if(a == NULL) continue;
                s = a->pVizinho;
                
                LIS_IrInicioLista(V);
                achou_V = 0;
                do {
                    tpVertice * re = (tpVertice *)LIS_ObterValor(V);
                    if (re == NULL) {
                        continue;
                    }
                    if(re == s) achou_V = 1;
                } while(LIS_AvancarElementoCorrente(V, 1) == LIS_CondRetOK);
            
                if (!achou_V) {
                    if(LIS_InserirElementoApos(V, s)!= LIS_CondRetOK){ achou = -1;break;}
                    if(LIS_InserirElementoApos(Q, s)!= LIS_CondRetOK){ achou = -1;break;}
                }
            } while(LIS_AvancarElementoCorrente(arestas, 1) == LIS_CondRetOK);
        }

        LIS_DestruirLista(V);
        LIS_DestruirLista(Q);

        return achou;
    }

    GRA_tpCondRet GRA_BuscarVertice( GRA_tppGrafo pGrafo , int* idVertice , int predicado(void* pDado, void* _parametro), void* parametro )
    {
        LIS_tppLista vertices;
        tpVertice* vertice;
        vertices = pGrafo->vertices;

        if(LIS_NumeroDeElementos(vertices) == 0){
            *idVertice = -1;
            return GRA_CondRetGrafoVazio;
        }

        LIS_IrInicioLista(vertices);
        do
        {
            vertice = (tpVertice*)LIS_ObterValor(vertices);
            
            if (predicado(vertice->pNode->pValor, parametro))
            {
                *idVertice = vertice->id;
                return GRA_CondRetOK;
            }
        }
        while (LIS_AvancarElementoCorrente(vertices, 1) == LIS_CondRetOK);

        return GRA_CondRetNaoEhVertice;
    }

void GRA_Del (Graph *g)
{
#ifdef _DEBUG
	AssertGraph(g);
#endif /* _DEBUG */
    CNT_CONTAR("GRA_Del - Inicializao");
	IrInicioLista ( g->nodes );
	if ( !g->currentNode || !LIS_AvancarElementoCorrente ( g->nodes , 1)){
	CNT_CONTAR("GRA_Del - Grafo vazio");
		return;
	}
	IrInicioLista ( g->nodes );
	do {
        CNT_CONTAR("GRA_Del - Deletando nos");
		g->currentNode = LIS_ObterValor( g->nodes );
		GRA_DelNode( g );
	} while ( LIS_AvancarElementoCorrente ( g->nodes , 1)
	== LIS_CondRetOK );
/*		== 0 ); */

    CNT_CONTAR("GRA_Del - Destruindo, finalizao");
	LIS_DestruirLista( g->nodes );

	free(g);
	return;
}

int GRA_comparaVerticeConteudo( void * pVerticeO , void * pValorO )
{

	int ret = 0;
	char * Corrente ;
	char * Buscado ;
	tpVerticeGrafo * pValorVert ;
    LIS_tppLista pVerticeLista ;

	Corrente = "";
	Buscado  = "";
	
	pVerticeLista = ( LIS_tppLista ) pVerticeO ;
    
	LIS_ObterValor (pVerticeLista , (void**)&pValorVert);


	VER_RetornaValor ((VER_tppVerticeCont)pValorVert->pConteudo , Corrente) ;

	VER_RetornaValor ((VER_tppVerticeCont)pValorO , Buscado) ;
	
	if(strcmp(Corrente , Buscado) == 0){

		return 0;
	}

	return 1;


} /* Fim função: GRA  &Compara valores */

GRA_tpCondRet GRA_DefinirCorrente(GRA_tppGrafo pGrafo, char IdVert)
{

	tpVerticeGrafo * pVerticeBusca ;

	ListaRet = LIS_IrInicioLista(pGrafo->pListaVertices);

	while(ListaRet == LIS_CondRetOK || ListaRet == LIS_CondRetFimLista){

		LIS_ObterValor (pGrafo->pListaVertices , (void**)&pVerticeBusca);

		if(pVerticeBusca->pIdVertice == IdVert){
			pGrafo->pCorrente = pVerticeBusca;
			return GRA_CondRetOK;
		} /* if */

		if(ListaRet==LIS_CondRetFimLista){
			break;
		} /* if */

		ListaRet = LIS_AvancarElementoCorrente(pGrafo->pListaVertices, 1);

	} /* while */

	return GRA_CondRetNaoAchou ;
}