xseman.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#define PATH "auta.txt"
#define EVER ;;
#define pravda 1
#define loz 0

typedef struct auta
{
    char kategoria[50];
    char spz[8];
    char znacka[50];
    char predajca[100];
    double cena;
    int rok_vyroby;
    char stav_vozidla[200];
    struct auta *next;                      //ukazatel na dalsi prvok
}AUTA;

AUTA *secureMalloc()                        //funkcia na alokovanie jedneho prvku
{                                           //struktury
    AUTA *auta;
    auta = (AUTA *)malloc(sizeof(AUTA));
    if (auta == NULL)
    {
        printf("Nepodarilo sa alokovat.\n");
        return;
    }
    return auta;
}

void garbageCollector(AUTA *auta)           //samostatna funkcia na vymaz
{                                           //vsetkych zaznamov ulozenych v
     AUTA *a;                               //pamati
     if(auta==NULL)
     {
         return;                            //ak tam neni nic, nerobi nic
     }
     do
     {
         a = auta;
         auta = auta->next;
         free(a);
     }
     while(auta!=NULL);
}

char *tolow(char *a )                       //funkcia na prehodenie pismen
{                                           //aby to bolo case insensitive
    int index,dlzka;                        //vo funkcii z
    dlzka=strlen(a);

    for (index = 0; index < dlzka; index++)
    {
        a[index] = tolower(a[index]);
    }
    return a;
}

void nacitaj(AUTA **auta)
{
    FILE *fp = NULL;
    AUTA *p_akt, *p_new, *p_first;
    int intBuf;
    double doubleBuf;
    char charBuf[200], dolar = '\0';
    char c;
    int zaznamy = 0;

    garbageCollector(*auta);                //vymaze vsetky struktury, AK su nejake

    if ((fp = fopen(PATH, "r")) == NULL)
    {
        printf("Zaznamy neboli nacitane\n");
        return;
    }

    while((c=getc(fp))!= EOF)               //cyklus spocita pocet zaznamov v subore
    {
        ungetc(c,fp);
        if (c=getc(fp)=='*')                //dolarom sa zacne zaznam, cize kolko
        {                                   //dolarov, tolko zaznamov
            zaznamy++;
        }
    }

    p_first = secureMalloc();               //alokujeme prvy prvok
    p_akt = p_first;

    rewind(fp);

    for(intBuf = 0; intBuf < zaznamy; intBuf++)
    {
        if (intBuf>0)
        {
            p_new = secureMalloc();         //alokujeme novy prvok, samozrejme, prvy prvok sa
            p_akt->next = p_new;            //nam alokoval pred forom
            p_akt=p_new;
        }
        fscanf(fp, "%c\n", &dolar);          //toten dolar nacitam
        fgets(p_akt->kategoria, 50, fp);
        fscanf(fp, "%s\n", &p_akt->spz);
        fgets(p_akt->znacka, 50, fp);
        fgets(p_akt->predajca, 50, fp);
        fscanf(fp, "%lf\n", &p_akt->cena);
        fscanf(fp, "%d\n", &p_akt->rok_vyroby);
        fgets(p_akt->stav_vozidla, 200, fp);
    }

    p_akt -> next = NULL;                   //nastavenie poslednej struktury na NULL

    printf("Nacitalo sa %d zaznamov\n", zaznamy);

    if (fclose(fp) == EOF)
    {
        //printf("Subor sa neuzavrel\n");
    }
    *auta = p_first;                        //vratime toten ukazovatel na prvu strukturu, odkial
}                                           //vieme, ze kde sa zoznam zacina

void vypis(AUTA *auta)
{
    AUTA *p_akt;                            //no comment, obycajny vypis
    int index = 1;
    p_akt = auta;


    if (p_akt == NULL)
    {
        return;                             //ak je zoznam prazdny, nic sa nestane
    }

    while (p_akt != NULL)                   //postupuje, dokym nenarazi na koniec, cize NULL
    {
        printf("%d.\n",index++);
        printf("kategoria: %s",p_akt->kategoria);
        printf("spz: %s\n",p_akt->spz);
        printf("znacka: %s",p_akt->znacka);
        printf("predajca: %s",p_akt->predajca);
        printf("cena: %.2lf\n",p_akt->cena);
        printf("rok_vyroby: %d\n",p_akt->rok_vyroby);
        printf("stav_vozidla: %s",p_akt->stav_vozidla);
        p_akt = p_akt->next;
    }
    printf("\n");
}

AUTA *pridaj(AUTA *auta)
{
    int pos, iter, count = 2;
    AUTA *p_load = NULL, *p_akt, *p_temp;

    p_akt = auta;
    p_load = secureMalloc();                //naalokujeme si tu struct ktory nacitam

    scanf("%d",&pos);
    getchar();

    fgets(p_load->kategoria, 50, stdin);    //stdinom presmerujem vstup
    fgets(p_load->spz, 25, stdin);
    p_load->spz[7] = '\0';

    fgets(p_load->znacka, 50, stdin);       //z konzoly, cize toto je
    fgets(p_load->predajca, 100, stdin);    //ako key obyc gets
    scanf("%lf",&p_load->cena);
    scanf("%d",&p_load->rok_vyroby);
    getchar();                              //getchar kvoli scanfom
    fgets(p_load->stav_vozidla, 200, stdin);//aby to neskakalo cez fgets

    p_load->next = NULL;

    if (auta == NULL)
    {
        p_load->next = NULL;                //ked neexistoval ziadny prvok, tak sa to ulozi na prve miesto, logicky
        auta = p_load;
    }
    else
    {
        if(pos==1)
        {                                   //pridavanie na prve miesto, ak zoznam uz existuje
            p_load->next=auta;              //auta je prvy clen tak do load
            auta = p_load;                  //nacitame ten prvy
        }                                   //a potom prehodime load ako novy prvy prvok
        else
        {
            while (--pos > 1 && p_akt->next != NULL)
            {
                p_akt = p_akt->next;        //krokujeme do daneho prvku
            }
            p_temp = p_akt->next;           //vopchatie prvku na dane miesto a nasledne zretazenie
            p_akt->next = p_load;
            p_load->next = p_temp;
        }
    }



    return auta;
}

void vyhladaj(AUTA *auta)
{
    char spz[3];
    int cena, jeTam = 0;
    AUTA *p_akt = auta;
    scanf("%d %s", &cena, spz);

    while (p_akt != NULL)                   //postupuje, dokym nenarazi na koniec, cize NULL
    {
        if(spz[0] == p_akt->spz[0] && spz[1] == p_akt->spz[1] && cena >= p_akt->cena)
        {
            jeTam = 1;
            printf("kategoria: %s",p_akt->kategoria);
            printf("spz: %s\n",p_akt->spz);
            printf("znacka: %s",p_akt->znacka);
            printf("predajca: %s",p_akt->predajca);
            printf("cena: %.2lf\n",p_akt->cena);
            printf("rok_vyroby: %d\n",p_akt->rok_vyroby);
            printf("stav_vozidla: %s\n",p_akt->stav_vozidla);
        }
        p_akt = p_akt->next;
    }

    if(jeTam == 0)
    {
        printf("V ponuke nie su hladane auta\n");
    }

}

void odstran_prvok(AUTA **zoznam, AUTA *prvok)
{
    AUTA *pom;

    if (*zoznam == prvok)
    {
      *zoznam = (*zoznam)->next; // odstranenie prvého
    }
    else
    {
        // nájdenie predchodcu odoberaného prvku
        pom = *zoznam;
        while (pom->next != prvok) pom = pom->next;

        // spojenie predchodcu s nasledovníkom odoberaneho prvku
        pom->next = prvok->next;
    }

    free(prvok);
}

void zmaz(AUTA *auta)
{
    AUTA *p_akt, *p_temp, *p_prev = NULL;
    char string[99];
    int index = 0;
    int zaznamy = 0;

    p_akt = auta;

    scanf("%s",&string);                    //tutaj je string, ktora nam predstavuje ihlu v kope sena

    p_prev = auta;                          //ono toto je sranda, totiz tu cyklujes tak, ze si uchovavas predosly aj aktualny pointer
                                            //cize ak musis mazat daco, tak sa ti vie zretazit spat, na miesto toho co vypadlo
    if(strstr(tolow(p_akt->kategoria), tolow(string)))    //tuto pomocou case sensitive funkcie strstr spravime case
    {                                                       //insensitive funkciu, co nam hlada spendlik v kope hnoja
        p_temp = p_prev->next;

        p_prev->next = p_temp->next;
        p_prev = p_akt = p_akt->next;
        free(p_temp);
        zaznamy++;                  //pocet vymazanych zaznamov

    }
    while (p_akt != NULL)
    {
       p_prev = p_akt;
       while (p_prev->next != NULL)
       {
           if(strstr(tolow(p_akt->kategoria), tolow(string)))    //tuto pomocou case sensitive funkcie strstr spravime case
           {                                                       //insensitive funkciu, co nam hlada spendlik v kope hnoja
               p_temp = p_prev->next;
               p_prev->next = p_temp->next;
               free(p_temp);
               zaznamy++;                  //pocet vymazanych zaznamov
               if(p_prev->next == NULL)
               {
                   break;
               }
           }
           p_prev = p_prev->next;
       }
       p_akt = p_akt->next;
    }
    printf ("Vymazalo sa %d zaznamov\n", zaznamy);
}

void aktualizuj(AUTA *auta)
{
    AUTA *p_akt = auta;
    char spz[3];
    scanf("%s", spz);
    while(p_akt != NULL)
    {
        if(spz[0] == p_akt->spz[0] && spz[1] == p_akt->spz[1])
        {
            fgets(p_akt->kategoria, 50, stdin);    //stdinom presmerujem vstup
            fgets(p_akt->spz, 25, stdin);
            p_akt->spz[7] = '\0';

            fgets(p_akt->znacka, 50, stdin);       //z konzoly, cize toto je
            fgets(p_akt->predajca, 100, stdin);    //ako key obyc gets
            scanf("%lf",&p_akt->cena);
            scanf("%d",&p_akt->rok_vyroby);
            getchar();                              //getchar kvoli scanfom
            fgets(p_akt->stav_vozidla, 200, stdin);//aby to neskakalo cez fgets
            printf("Zaznam sa aktualizoval\n");
            return;
        }
        p_akt = p_akt->next;
    }
    printf("Zaznam sa neaktualizoval\n");
}

int main(void)
{
    AUTA *auta = NULL;

    for (EVER)
    {
        char c = getchar();
        switch (c)
        {
            case 'c':
                nacitaj(&auta);
                break;
            case 'v':
                vypis(auta);
                break;
            case 'p':
                auta = pridaj(auta);
                break;
            case 'z':
                zmaz(auta);
                break;
            case 'a':
                aktualizuj(auta);
                break;
            case 'h':
                vyhladaj(auta);
                break;
            case 'k':
                garbageCollector(auta);         //ku koncu, v lepsich rodinach sa slusi po sebe odpad odpratat
                exit(0);
                break;
        }
    }
    return 0;
}