T ListaEnc<T>::retiraEspecifico(const T& dado) {
if (listaVazia())
throw ERROLISTAVAZIA;
int pos = posicao(dado);
return retiraDaPosicao(pos);
}
T ListaEnc<T>::retiraEspecifico(const T& dado) {
if (listaVazia()) {
throw std::runtime_error("Lista Vazia");
} else {
return retiraDaPosicao(posicao(dado));
}
}
/* Inicializando restrições de movimento. */
void zeros(unsigned int *indexp, unsigned int *tams, Vertex *Mtz) {
unsigned int *aux, x, y;
aux = (unsigned int *) malloc(k*sizeof(int));
VUTIL rest = 1;
/* Restringindo o ponto zero em cada dimensão. */
for (x=0; x<k; x++) {
for (y=0; y<x; y++)
aux[y] = 0;
Mtz[posicao(aux,indexp)].restricao += rest;
while (inclui(aux, tams, x))
Mtz[posicao(aux,indexp)].restricao += rest;
rest *= 2;
}
free(aux);
}
/** Verifica se a Lista contêm o elemento especificado.
* @param dado O dado que será verificado a existência dentro da Lista.
* @return um boolean que indica se a Lista contêm ou não o elemento especificado.
*/
bool contem(T dado) {
try {
posicao(dado);
return true;
} catch (std::exception& e) {
return false;
}
}
bool ListaEnc<T>::contem(const T& dado) {
try {
posicao(dado);
return true;
} catch (int e) {
return false;
}
}
/**
* @brief Testa se o dado está na lista
*
* @param[in] dado Dado a ser testato
*
* @return true se o dado estiver na lista, senão, false
*/
bool contem(const T& dado) {
try {
posicao(dado);
} catch (std::runtime_error& err) {
return false;
}
return true;
}
//comentário
T retiraEspecifico(T dado)
{
if(listaVazia())
throw 20;
int pos = posicao(dado);
if (pos < 0)
throw 20;
return retiraDaPosicao(pos);
}
void atualiza () {
// Accel da Nave1
acelNave ();
// Accel dos tiros
acelTiros ();
// Posicao Tiros
posicao ();
//Colisao dos tiros
colisaoTiro();
}
/*
* @brief Metodo para retirar um dado especifico da Lista
* @details Verifica se a lista não está vazia, caso esteja retorna um throw.
* Cria uma variavel auxiliar de inteiro chamada 'pos' e chama o metedo 'posicao'
* para atribuir a posição no array 'dados[]' do elemento 'dado'.
* Verifica se a variavel 'pos' tem um valor valido, ou seja maior que zero, caso
* isso se confirme retorna o metodo 'retiraDaPosicao' e passa como parametro a variavel 'pos'
*/
T retiraEspecifico(T dado) {
int pos;
if (listaVazia()) {
throw(ERROLISTAVAZIA);
} else {
pos = posicao(dado);
if (pos < 0) {
throw(ERROPOSICAO);
} else {
return (retiraDaPosicao(pos));
}
}
}
/** Retira um elemento da Lista, se este objeto existir dentro da Lista.
* @see listaVazia()
* @param dado A posição do dado a ser retirado.
* @exception ExcecaoErroPosicao Exceção que indica que o dado enviado via argumento não existe dentro dessa Lista, logo não pode ser removido.
* @exception ExcecaoListaVazia Exceção que indica que um dado não pode ser retirado, pois a lsita já está vazia.
* @return o dado do tipo T que foi retirado.
*/
T retiraEspecifico(T dado) {
int indice = posicao(dado);
return retiraDaPosicao(indice);
}
//Retira dado elemento
int Lista::retirarEspecifico(const char* lancamento) {
int pos = posicao(lancamento);
if (pos < 0)
return -1;
return retirarDaPosicao(pos);
}
/**
* Método que retira um objeto específico da classe ElementoDeLista.
*
* Para isso ele utiliza o método retiraDaPosicao, levando a posição do dado recebido como parametro. Para maiores informações vide retiraDaPosicao().
*
* @param elemento = objeto da classe ElementoDeLista que vai ser retirado da lista.
*
@return InfoLista = ponteiro para um objeto da classe InfoLista.
*/
InfoLista* CabecaDeLista::retiraEspecifico(ElementoDeLista *elemento) {
return retiraDaPosicao(posicao(elemento));
}
T ListaCirc<T>::retiraEspecifico(const T& dado) {
if (ListaEnc<T>::listaVazia()) {
throw ExcecaoListaVazia();
}
return retiraDaPosicao(posicao(dado) + 1);
}
T Lista<T>::retiraEspecifico(T dado) {
if(listaVazia()) {
throw ExcecaoListaVazia();
}
return retiraDaPosicao(posicao(dado));
}
/**
* @brief Retira o dado que for igual ao dado de entrada
*
* @param[in] dado Dado a ser retirado
*
* @return O dado retirado
*/
T retiraEspecifico(const T& dado) {
return retiraDaPosicao(posicao(dado));
}
/*!
\return Retorna e retira um dado específico do tipo T (apaga elemento).
\param dado eh o endereço do dado que será retirado do tipo T.
*/
T retiraEspecifico(const T& dado) {
int pos;
if (!((pos = posicao(dado))+1))
throw(20);
return retiraDaPosicao(pos);
}
/** Retira um objeto específico da Lista Encadeada.
* Este método retira o primeiro objeto da Lista Encadeada que tem o mesmo valor do dado fornecido.
* @see retiraDaPosicao(int pos)
* @see posicao(int pos)
* @return o objeto do tipo T que foi retirado da Lista. Retorna NULL caso esse objeto não exista.
*/
T retiraEspecifico(const T& dado) {
int pos = posicao(dado);
return retiraDaPosicao(pos + 1);
}
bool contem(const T& dado){
return posicao(dado)!=-1;
}
//Olha se o lançamento está contido
bool Lista::contem(const char* lancamento) const {
return posicao(lancamento) > 0;
}
