P4

#include <stdio.h>
#include "types.h"
#include "center_list.h"
#include "party_list.h"

#define CODE_LENGTH 2

void C(tCenterName NombreCentro, tNumVotes TotalVoters, tListC *ListC){
    tItemC tempItemC;
    strcpy(tempItemC.centerName,NombreCentro);
    createEmptyList(&tempItemC.partyList);
    tempItemC.totalvoters = TotalVoters;
    tempItemC.validVotes = 0;
    tempItemC.nullVotes = 0;

    if(findItemC(NombreCentro,*ListC) != NULLC){
        printf("+ Error: Create not possible\n");
    } else {
        if (insertItemC(tempItemC, ListC) == 1) {
            printf("* Create: center %s totalvoters %d\n", tempItemC.centerName, tempItemC.totalvoters);
        } else {
            printf("+ Error: Create not possible\n");
        }
    }
}

void N(tCenterName NombreCentro, tPartyName NombrePartido, tListC *ListC){
    tItemC tempItemC;
    tPosC tempPosC;
    tempPosC = findItemC(NombreCentro,*ListC);
    if(tempPosC != NULLC){
        tempItemC = getItemC(tempPosC,*ListC);
        tPosL tempPosL;
        tempPosL = findItem(NombrePartido,tempItemC.partyList);
        if (tempPosL == LNULL){
            tItemL tempItemL;
            strcpy(tempItemL.partyName,NombrePartido);
            tempItemL.numVotes = 0;
            if(insertItem(tempItemL,&tempItemC.partyList) == 1){
                updateListC(tempItemC.partyList,tempPosC,ListC);
                printf("* New: center %s party %s\n",NombreCentro,NombrePartido);
            } else{
                printf("+ Error: New not possible\n");
            }
        } else{
            printf("+ Error: New not possible\n");
        }
    } else{
        printf("+ Error: New not possible\n");
    }
}

void V(tCenterName NombreCentro, tPartyName NombrePartido, tListC *ListC){
    tPosL tempPosL;
    tNumVotes tempNullVotes, tempValidVotes;
    tPosC tempPosC;
    tempPosC = findItemC(NombreCentro,*ListC);
    if(tempPosC != NULLC){
        tItemC tempItemC;
        tempItemC = getItemC(tempPosC,*ListC);
        tempNullVotes = tempItemC.nullVotes;
        tempValidVotes = tempItemC.validVotes;
        tempPosL = findItem(NombrePartido,tempItemC.partyList);
        if(tempPosL != LNULL){
            tItemL TempItem;
            TempItem = getItem(tempPosL,tempItemC.partyList);
            tNumVotes TempVotes;
            TempVotes = TempItem.numVotes + 1;
            updateVotes(TempVotes,tempPosL,&tempItemC.partyList);
            tempValidVotes = tempValidVotes + 1;
            updateValidVotesC(tempValidVotes,tempPosC,ListC);
            printf("* Vote: center %s party %s numvotes %d\n",NombreCentro,NombrePartido,TempVotes);
        }else{
            tempNullVotes = tempNullVotes + 1;
            updateNullVotesC(tempNullVotes,tempPosC,ListC);
            printf("+ Error: Vote not possible. Party %s not found in center %s. NULLVOTE\n",NombrePartido,
                   NombreCentro);
        }
    } else{
        printf("+ Error: Vote not possible\n");
    }
}

void R(tListC *ListC){
    tItemC tempItemC;
    tPosC primero,ultimo;
    primero = firstC(*ListC);
    ultimo = lastC(*ListC);
    while (primero != NULLC){
        tempItemC = getItemC(primero,*ListC);
        if(tempItemC.validVotes == 0){
            printf("* Remove: center %s\n", tempItemC.centerName);
            deleteList(&tempItemC.partyList);
            deleteAtPositionC(primero,ListC);
            primero = firstC(*ListC);
        } else{
            primero = nextC(primero,*ListC);
        }
    }
    if (primero == ultimo){
        printf("+ Remove: no centers removed\n");
    }
}

void S(tListC *ListC){
    tNumVotes totalValidVotes = 0;
    float porcentajePartido, porcentajeTotal;
    tItemC tempItemC;
    for(tPosC pos1 = firstC(*ListC); pos1 != NULLC; pos1 = nextC(pos1,*ListC)){
        tempItemC = getItemC(pos1,*ListC);
        totalValidVotes = tempItemC.validVotes;
        printf("Center %s\n",tempItemC.centerName);
        tNumVotes centerTotalVotes = 0;
        tPosL primero;
        primero = first(tempItemC.partyList);
        while(primero != LNULL) {
            tItemL TempItem;
            TempItem = getItem(primero,tempItemC.partyList);
            if (totalValidVotes == 0){
                porcentajePartido = 0;
            } else{
                porcentajePartido = (float) 100 * TempItem.numVotes/(float) totalValidVotes;
            }
            printf("Party %s numvotes %d (%.2f%%)\n",TempItem.partyName,TempItem.numVotes,porcentajePartido);
            primero = next(primero,tempItemC.partyList);
        }
        printf("Null votes %d\n",tempItemC.nullVotes);
        centerTotalVotes = tempItemC.nullVotes + tempItemC.validVotes;
        if(tempItemC.totalvoters == 0){
            porcentajeTotal = 100;
        } else{
            porcentajeTotal = (float) 100 * centerTotalVotes/tempItemC.totalvoters;
        }
        printf("Participation: %d votes from %d voters (%.2f%%)\n",centerTotalVotes,tempItemC.totalvoters,
               porcentajeTotal);
    }
}

void W(float PorcentajeMinimo,tListC *ListC){
    if (isEmptyListC(*ListC) == true){
        printf("+ Error: ShowWinners not possible\n");
    } else{
        for (tPosC pos = firstC(*ListC); pos != NULLC; pos = nextC(pos,*ListC)){
            tItemC tempItemC;
            tempItemC = getItemC(pos,*ListC);
            tNumVotes tempNumVotes;
            tempNumVotes = 0;
            tPartyName tempPartyName;
            for (tPosL tempPos = first(tempItemC.partyList); tempPos != LNULL; tempPos = next(tempPos,
                    tempItemC.partyList)){
                tItemL tempItemL;
                tempItemL = getItem(tempPos,tempItemC.partyList);
                if (tempItemL.numVotes > tempNumVotes){
                    tempNumVotes = tempItemL.numVotes;
                    strcpy(tempPartyName,tempItemL.partyName);
                }
            }
            float tempPorcentaje;
            tempPorcentaje = (float) 100 * tempNumVotes/(float) tempItemC.totalvoters;
            if (tempPorcentaje < PorcentajeMinimo){
                printf("Winner of center %s: *none*\n",tempItemC.centerName);
            } else{
                printf("Winner of center %s: %s (%.2f%%)\n",tempItemC.centerName,tempPartyName,tempPorcentaje);
            }
        }
    }
}

void processCommand(char commandNumber[CODE_LENGTH+1], char command,
        char param1[NAME_LENGTH_LIMIT+1], char param2[NAME_LENGTH_LIMIT+1],tListC *TempListC) {

    switch(command) {
        case 'C': {
            printf("********************\n");
            printf("%s %c: center %s totalvoters %s\n\n",commandNumber,command,param1,param2);
            C(param1,atoi(param2),TempListC);
            break;
        }
        case 'N': {
            printf("********************\n");
            printf("%s %c: center %s party %s\n\n",commandNumber, command, param1, param2);
            N(param1,param2,TempListC);
            break;
        }
        case 'V': {
            printf("********************\n");
            printf("%s %c: center %s party %s\n\n",commandNumber, command, param1, param2);
            V(param1,param2,TempListC);
            break;
        }
        case 'R': {
            printf("********************\n");
            printf("%s %c\n\n",commandNumber,command);
            R(TempListC);
            break;
        }
        case 'S': {
            printf("********************\n");
            printf("%s %c\n\n",commandNumber,command);
            S(TempListC);
            break;
        }
        case 'W':{
            printf("********************\n");
            printf("%s %c: threshold %s\n\n",commandNumber,command,param1);
            W(atof(param1),TempListC);
            break;
        }
        default: {
            break;
        }
    }
}

void readTasks(char *filename,tListC *TempListC) {
    FILE *df;
    char commandNumber[CODE_LENGTH+1], command, param1[NAME_LENGTH_LIMIT+1], param2[NAME_LENGTH_LIMIT+1];

    df = fopen(filename, "r");
    if (df != NULL) {
        while (!feof(df)) {
            char format[16];
            sprintf(format, "%%%is %%c ", CODE_LENGTH);
            fscanf(df, format, commandNumber, &command);
            if (command == 'S' || command == 'R') {
                param1[0] = '\0';
                param2[0] = '\0';
            } else if (command == 'W') {
                param2[0] = '\0';
                fscanf(df, "%5s", param1);
            } else {
                sprintf(format, "%%%is %%%is", NAME_LENGTH_LIMIT, NAME_LENGTH_LIMIT);
                fscanf(df, format, param1, param2);
            }
            processCommand(commandNumber, command, param1, param2, TempListC);
        }
        fclose(df);
    } else {
        printf("Cannot open file %s.\n", filename);
    }
}

int main(int nargs, char **args) {

    char *filename = "create.txt";

    if (nargs > 1) {
        filename = args[1];
    } else {
        #ifdef INPUT_FILE
        filename = INPUT_FILE;
        #endif
    }

    tListC *ListaCentros = malloc(sizeof(*ListaCentros));
    createEmptyListC(ListaCentros);
    readTasks(filename,ListaCentros);

    return 0;
}


///////////////////

#ifndef PARTY_LIST_H
#define PARTY_LIST_H

#include "types.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#define LNULL NULL

typedef struct tNode *tPosL;
struct tNode{
    tItemL data;
    tPosL sig;
};

typedef tPosL tList;

/* Write your code here... */

void createEmptyList (tList*);
/*{Objetivo: Crea una lista vacía.
 * Salidas: Lista inicializada.
 * Postcondición: La lista queda inicializada y no contiene elementos.}*/
bool insertItem(tItemL, tList*);
/*{Objetivo: Inserta un elemento de forma ordenada en función del campo partyname. Devuelve un valor true si el
 * elemento fue insertado y false en case contrario
 * Entradas: El elemento y la lista de partidos.
 * Salidas: Verdadero y la lista con el elemento si se pudo insertar, falso y la lista sin el elemento si no se pudo.
 * Postcondición: Las posiciones de los elementos de la lista posteriores al insertado pueden cambiar de valor.}*/
bool copyList(tList, tList*);
/*{Objetivo: Copia una lista en otra
 * Entradas: La lista de partidos en la que se quiere copiar y la lista de partidos a copiar.
 * Salidas: Verdadero y la lista copiada si se pudo copiar, falso y la lista sin copiar si no se pudo copiar.
 * Precondición: La lista que se quiere copiar existe.}*/
void updateVotes(tNumVotes, tPosL, tList*);
/*{Objetivo: Modifica el número de votos del elemento situado en la posición indicada de la lista.
 * Entradas: La cantidad de votos, la posición en la que actualizarlos y la lista de partidos.
 * Salidas: La lista de partidos con los votos de la posición indicada actualizados.
 * Precondición: La posición indicada es una posición válida en la lista.}*/
void deleteAtPosition(tPosL, tList*);
/*{Objetivo: Elimina de la lista el elemento que ocupa la posición indicada.
 * Entradas: Posición del elemento a eliminar y la lista de partidos.
 * Salidas: La lista sin el elemento que se quería eliminar.
 * Precondición: La posición indicada es una posición válida en la lista.
 * Postcondición: Tanto la posición del elemento eliminado como aquellas de los elementos de la lista a continuación
 * del mismo pueden cambiar de valor.}*/
void deleteList(tList*);
/*{Objetivo: Elimina una lista.
 * Entradas: Lista de partidos a eliminar.
 * Precondición: La lista indicada existe.}*/
tPosL findItem(tPartyName, tList);
/*{Objetivo:Devuelve la posición del primer elemento de la lista cuyo nombre de partido se corresponda con el indicado
 * (o LNULL si no existe tal elemento).
 * Entradas: Nombre del partido a buscar y la lista de partidos.
 * Salidas: Posición del elemento que se busca (LNULL si no existe).}*/
bool isEmptyList(tList);
/*{Objetivo: Determina si la lista está vacía.
 * Entradas: La lista de partidos.
 * Salidas: Verdadero si la lista está vacía, falso si no lo está.
 * Precondición: La lista existe.}*/
tItemL getItem(tPosL, tList);
/*{Objetivo: Devuelve el contenido del elemento de la lista que ocupa la posición indicada.
 * Entradas: La posición del elemento a buscar y la lista de partidos.
 * Salidas: El contenido del elemento buscado
 * Precondición: La posición indicada es una posición válida en la lista.}*/
tPosL first(tList);
/*{Objetivo: Devuelve la posición del primer elemento de la lista.
 * Entradas: La lista de partidos
 * Salidas: La posición del primer elemento de la lista.
 * Precondición: La lista no está vacía.}*/
tPosL last(tList);
/*{Objetivo: Devuelve la posición del último elemento de la lista.
 * Entradas: La lista de partidos.
 * Salidas: La posición del último elemento de la lista.
 * Precondición: La lista no está vacía.}*/
tPosL previous(tPosL, tList);
/*{Objetivo: Devuelve la posición en la lista del elemento anterior al de la posición indicada (o LNULL si la posición
 * no tiene anterior).
 * Entradas: La posición del elemento posterior al buscado y la lista de partidos.
 * Salidas: La posición del elemento anterior al de la posición indicada o LNULL si no existe una posición anterior.
 * Precondición: La posición indicada es una posición válida en la lista.}*/
tPosL next(tPosL, tList);
/*{Objetivo: Devuelve la posición en la lista del elemento siguiente al de la posición indicada (o LNULL si la posición
 * no tiene siguiente).
 * Entradas: La posición del elemento anterior al buscado y la lista de partidos.
 * Salidas: La posición del elemento posterior al de la posición indicada o LNULL si no existe una posición posterior.
 * Precondición: La posición indicada es una posición válida en la lista.}*/

#endif

/////////////////////////////////

#include "party_list.h"

/* Write your code here... */

void createEmptyList (tList *List){
    *List = LNULL;
}

bool isEmptyList(tList List){
    if (List == LNULL){
        return true;
    }
}

tPosL first(tList List){
    return List;
}

tPosL next(tPosL pos,tList List){
    return pos->sig;
}

tPosL previous(tPosL pos, tList List){
    tPosL pos1;
    if (pos == List){
        return LNULL;
    } else {
        pos1 = List;
        while(pos1->sig != pos){
            pos1 = next(pos1,List);
        } return pos1;
    }
}

tPosL last(tList List){
    tPosL pos;
    pos = List;
    while (pos->sig != LNULL){
        pos = next(pos,List);
    } return pos;
}

tItemL getItem(tPosL pos, tList List){
    return pos->data;
}

void updateVotes(tNumVotes nVote, tPosL pos, tList *List){
    pos->data.numVotes = nVote;
}

tPosL findItem(tPartyName NameParty, tList List) {
    tPosL pos;
    pos = List;
    while ((pos != LNULL) && (strcmp(pos->data.partyName,NameParty) != 0)){
        pos = next(pos,List);
    }
    if(pos != LNULL && strcmp(pos->data.partyName,NameParty) == 0){
        return pos;
    } else{
        return LNULL;
    }
}

void deleteList(tList *List){
    tPosL pos;
    while (*List != LNULL){
        pos = *List;
        *List = (*List)->sig;
        free(pos);
    }
}
bool createNode(tPosL *pos){
    *pos = malloc(sizeof(**pos));
    return *pos != LNULL;
}

bool insertItem(tItemL Item, tList *List){
    tPosL pos,pos1;
    if(!createNode(&pos)){
        return false;
    } else{
        pos->data = Item;
        pos->sig = LNULL;
        if(*List == LNULL){
            *List = pos;
        } else if(strcmp(Item.partyName, (*List)->data.partyName) < 0){
            pos->sig = *List;
            *List = pos;
        } else{
            tPosL pos2;
            pos2 = *List;
            while((pos2->sig != LNULL) && (strcmp(pos2->sig->data.partyName, Item.partyName) < 0)){
                pos2 = pos2->sig;
            }
            pos1 = pos2;
            pos->sig = pos1->sig;
            pos1->sig = pos;
        }
        return true;
    }
}

void deleteAtPosition(tPosL pos, tList *List) {
    tPosL pos1;
    if(pos == *List){    //borrar elemento primera posición
        *List = (*List)->sig;
    } else if(pos->sig == LNULL){     //borrar elemento última posición
        for(pos1 = *List; pos1->sig != pos; pos1 = pos1->sig){
        }
        pos1->sig = LNULL;
    } else{   //borrar elemento posición intermedia
        pos1 = pos->sig;
        pos->data = pos1->data;
        pos->sig = pos1->sig;
        pos = pos1;
    }
    free(pos);
}

bool copyList(tList List, tList *List1){
    tPosL pos,pos1,pos2;
    bool temp;
    temp = true;
    createEmptyList(List1);
    if(!isEmptyList((List))){
        pos = List;
        while ((pos != LNULL) && (createNode(&pos2))){
            pos2->data = pos->data;
            pos2->sig = LNULL;
            if(pos == List){
                *List1 = pos2;
                pos1 = pos2;
            } else{
                pos1->sig = pos2;
                pos1 = pos2;
            }
            pos = pos->sig;
        }
        if(pos != LNULL){
            temp = false;
        }
    }
    return temp;
}

//////////////////////////////

#ifndef CENTER_LIST_H
#define CENTER_LIST_H

#include "types.h"
#include "party_list.h"

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define NULLC -1
#define MAX 10

typedef struct tItemC {
    tCenterName centerName;
    tNumVotes totalvoters;
    tNumVotes validVotes;
    tNumVotes nullVotes;
    tList partyList;
} tItemC;


typedef int tPosC;
typedef struct {
    tItemC data[MAX];
    tPosC lastPos;
}tListC;

/* Write your code here... */

bool insertItemC(tItemC, tListC*);
/*{Objetivo: Inserta un elemento de forma ordenada en función del campo centername. Devuelve un valor true si el
 * elemento fue insertado; false en caso contrario.
 * Entradas: El elemento y la lista de centros.
 * Salidas: Verdadero y la lista con el elemento si se pudo insertar, falso y la lista sin el elemento si no se pudo.
 * Postcondición:Las posiciones de los elementos de la lista posteriores al insertado pueden cambiar de valor.}*/
void updateListC (tList, tPosC, tListC*);
/*{Objetivo: Modifica la lista de partidos del elemento situado en la posición indicada.
 * Entradas: La lista de partidos, la posición del centro y la lista de centros.
 * Salidas: La lista de partidos actualizada en el centro de la posición indicada.
 * Precondición: La posición indicada es una posición válida en la lista.}*/
void updateValidVotesC (tNumVotes, tPosC, tListC*);
/*{Objetivo: Modifica el número de votos válidos del elemento situado en la posición indicada de la lista.
 * Entradas: La cantidad de votos, la posición del elemento a actualizar y la lista de centros.
 * Salidas: La lista de centros con el número de votos actualizado en el centro indicado.
 * Precondición: La posición indicada es una posición válida en la lista.}*/
void updateNullVotesC (tNumVotes, tPosC, tListC*);
/*{Objetivo: Modifica el número de votos nulos del elemento situado en la posición indicada.
 * Entradas: La cantidad de votos, la posición del elemento a actualizar y la lista de centros.
 * Salidas: La lista de centros con el número de votos actualizado en el centro indicado.
 * Precondición: La posición indicada es una posición válida en la lista.}*/
tPosC findItemC (tCenterName, tListC);
/*{Objetivo: Devuelve la posición del primer elemento de la lista cuyo nombre de centro se corresponda con el indicado
 * (o NULLC si no existe tal elemento).
 * Entradas: El nombre del centro y la lista de centros.
 * Salidas: La posición del elemento que se busca (NULLC si no existe).}*/
tPosC firstC(tListC);
/*{Objetivo: Devuelve la posición del primer elemento de la lista.
 * Entradas: La lista de centros.
 * Salidas: La posición del primer elemento de la lista.
 * Precondición: La lista no está vacía.}*/
tPosC lastC(tListC);
/*{Objetivo: Devuelve la posición del último elemento de la lista.
 * Entradas: La lista de centros.
 * Salidas: La posición del último oelemento de la lista.
 * Precondición: La lista no está vacía.}*/
tPosC nextC(tPosC, tListC);
/*{Objetivo: Devuelve la posición en la lista del elemento siguiente al de la posición indicada (o NULLC si la posición
 * no tiene siguiente).
 * Entradas: La posición del elemento anterior al buscado y la lista de centros.
 * Salidas: La posición del elemento posterior al de la posición indicada o NULLC si no existe una posición posterior.
 * Precondición: La posición indicada es una posición válida en la lista.}*/
bool copyListC(tListC, tListC*);
/*{Objetivo: Copia una lista en otra.
 * Entradas: La lista de centros en la que se quiere copiar y la lista de centros a copiar.
 * Salidas: Verdadero y la lista copiada si se pudo copiar, falso y la lista sin copiar si no se pudo copiar.
 * Precondición: La lista que se quiere copiar existe.}*/
void deleteAtPositionC(tPosC, tListC*);
/*{Objetivo: Elimina de la lista el elemento que ocupa la posición indicada.
 * Entradas: Posición del elemento a eliminar y la lista de centros.
 * Salidas: La lista sin el elemento que se quería eliminar.
 * Precondición: La posición indicada es una posición válida en la lista.
 * Postcondición: Tanto la posición del elemento eliminado como aquellas de los elementos de la lista a continuación
 * del mismo pueden cambiar de valor.}*/
tPosC previousC(tPosC, tListC);
/*{Objetivo: Devuelve la posición en la lista del elemento anterior al de la posición indicada (o NULLC si la posición
 * no tiene anterior).
 * Entradas: La posición del elemento posterior al buscado y la lista de centros.
 * Salidas: La posición del elemento anterior al de la posición indicada o NULLC si no existe una posición anterior.
 * Precondición: La posición indicada es una posición válida en la lista.}*/
void createEmptyListC(tListC*);
/*{Objetivo: Crea una lista vacía.
 * Salidas: Lista inicializada.
 * Postcondición: La lista queda inicializada y no contiene elementos.}*/
bool isEmptyListC(tListC);
/*{Objetivo: Determina si la lista está vacía.
 * Entradas: La lista de centros.
 * Salidas: Verdadero si la lista está vacía, falso si no lo está.
 * Precondición: La lista existe.}*/
tItemC getItemC(tPosC, tListC);
/*{Objetivo: Devuelve el contenido del elemento de la lista que ocupa la posición indicada.
 * Entradas: La posición del elemento a buscar y la lista de centros.
 * Salidas: El contenido del elemento buscado.
 * Precondición: La posición indicada es una posición válida en la lista.}*/

#endif

////////////////////////////////////

#include "types.h"
#include "party_list.h"
#include "center_list.h"

/* Write your code here... */

bool insertItemC(tItemC ItemC,tListC *ListC){
    if(ListC->lastPos == MAX - 1){
        return false;
    } else{
        if(isEmptyListC(*ListC) || strcmp(ItemC.centerName, ListC->data[ListC->lastPos].centerName) > 0){
            ListC->lastPos++;
            ListC->data[ListC->lastPos] = ItemC;
        } else{
            ListC->lastPos++;
            tPosC primero;
            primero = firstC(*ListC);
            if(strcmp(ItemC.centerName,ListC->data[primero].centerName) < 0){
                tPosC pos;
                pos = ListC->lastPos;
                while ((pos > 0) && strcmp(ItemC.centerName,ListC->data[pos-1].centerName) < 0){
                    ListC->data[pos] = ListC->data[pos-1];
                    pos--;
                } ListC->data[pos] = ItemC;
            }else{
                for(tPosC pos = ListC->lastPos; pos >= 0 && strcmp(ItemC.centerName, ListC->data[pos-1].centerName) < 0;
                    pos--){
                    ListC->data[pos] = ListC->data[pos-1];
                    ListC->data[pos-1] = ItemC;
                }
            }
        } return true;
    }
}

tPosC firstC(tListC ListC){
    return 0;
}

tPosC lastC(tListC ListC){
    return ListC.lastPos;
}

tPosC nextC(tPosC pos, tListC ListC){
    if (pos == lastC(ListC)){
        return NULLC;
    } else{
        return ++pos;
    }
}

bool copyListC(tListC ListC, tListC *ListC1){
    tPosC pos;
    for(pos = 0; pos == ListC.lastPos; pos++){
        ListC1->data[pos] = ListC.data[pos];
    }
    ListC1->lastPos = ListC.lastPos;
    return true;
}

void deleteAtPositionC(tPosC pos, tListC *ListC){
    while (pos != lastC(*ListC)){
        ListC->data[pos] = ListC->data[nextC(pos,*ListC)];
        pos = nextC(pos,*ListC);
    }
    ListC->lastPos--;
}

tPosC previousC(tPosC pos, tListC ListC){
    if(pos == firstC(ListC)){
        return NULLC;
    } else{
        pos = pos - 1;
    }
    return pos;
}

void createEmptyListC(tListC *ListC){
    ListC->lastPos = NULLC;
}

bool isEmptyListC(tListC ListC){
    if(ListC.lastPos == NULLC){
        return true;
    } else{
        return false;
    }
}

void updateValidVotesC (tNumVotes ValidVotes, tPosC pos, tListC *ListC){
    ListC->data[pos].validVotes = ValidVotes;
}

void updateNullVotesC (tNumVotes NullVotes, tPosC pos, tListC *ListC){
    ListC->data[pos].nullVotes = NullVotes;
}

tPosC findItemC (tCenterName NombreCentro, tListC ListC){
    tPosC pos;
    if(ListC.lastPos == NULLC){
        return NULLC;
    } else{
        pos = firstC(ListC);
        while((pos < ListC.lastPos) && (strcmp(ListC.data[pos].centerName, NombreCentro) != 0)){
            pos = nextC(pos,ListC);
        }
        if(strcmp(ListC.data[pos].centerName,NombreCentro) == 0){
            return pos;
        } else{
            return NULLC;
        }
    }
}

void updateListC (tList Lista, tPosC pos, tListC *ListC){
    ListC->data[pos].partyList = Lista;
}

tItemC getItemC(tPosC pos, tListC ListC){
    return ListC.data[pos];
}

////////////////////////

#ifndef TYPES_H
#define TYPES_H

#define NAME_LENGTH_LIMIT 32

typedef char tPartyName[NAME_LENGTH_LIMIT];
typedef char tCenterName[NAME_LENGTH_LIMIT];
typedef int tNumVotes;

typedef struct tItemL {
    tPartyName partyName;
    tNumVotes numVotes;
} tItemL;

#endif //TYPES_H