Biblioteka projekt

program bibl;

uses crt, sysutils;


{ Typ zawiera inf o czytelniku }
type dane_czytelnika = record
 imie :  string[32];
 nazwisko :  string[32];
 end;

{ Typ zawiera inf o ksiazce }
 type dane_ksiazki = record
   tytul : string[255];
   id : integer;
 end;

{ Typ reprezentujący czytelnika }
type
  pCzytelnik = ^TCzytelnik;
    TCzytelnik = record
      dane : dane_czytelnika;
      nast :  pCzytelnik;
    end;

 { Typ reprezentujący ksiazke }
type
pKsiazka = ^TKsiazka;
 TKsiazka = record
   dane : dane_ksiazki;
   dostepna : boolean;
   {
   lista czytelnikow - pierwszy element listy tj glowa zawiera dane czytelnika ktory
   aktualnie posiada ksiazke
   }
   czytelnicy : pCzytelnik;
   nast :  pKsiazka;
end;

{                                             }
{ Funkcje które operuja na liscie czytelnikow }
{                                             }

{ Procedura dodaje nowego czytelnika na poczatek listy }
procedure dodaj_czytelnika(var glowa : pCzytelnik; czytelnik : dane_czytelnika);
var
  nowy : pCzytelnik;
  begin

  new(nowy);

  nowy^.dane := czytelnik;
  nowy^.nast := glowa;
  glowa := nowy;

  end;

{ Procedura usuwa calkowice liste czytenilkow z pamieci }
procedure usun_czytelnikow(var glowa : pCzytelnik);
var
    aktualny: pCzytelnik;
begin
    aktualny := glowa;
    while aktualny <> nil  do begin
          aktualny := aktualny^.nast;
          dispose(glowa);
          glowa := aktualny;
    end;

    { lista jest pusta wiec wskazujemy na nil`a zeby funkcja dodaj_czytelnika dodawala nadal }
    glowa := nil;
end;

{ Funkcja liczy ilosc czytelnikow - tj ilosc elemetnow listy }
function ilosc_czytelnikow(glowa : pCzytelnik) : integer;
var
    ile : integer;
    begin
     ile := 0;
     while(glowa <> nil) do begin
           { inkrementacja w gore }
           inc(ile);
           glowa := glowa^.nast;
     end;
    ilosc_czytelnikow := ile;
end;

{                                         }
{ Funkcje ktore operuja na liscie ksiazek }
{                                         }
{ Procedura ustawiana ksiazke na zajeta badz wolna }
procedure ustaw_status_ksiazki(var ksiazka : pKsiazka; status : boolean);
begin
  ksiazka^.dostepna := status;
end;

{ Procedura dodaje nowa ksiazke na poczatek listy }
procedure dodaj_ksiazke(var glowa : pKsiazka; ksiazka : dane_ksiazki);
var
  nowa : pKsiazka;

  begin
  new(nowa);
  { lista czytelnikow domyslnie jest pusta - nie zawiera rekordow }
  nowa^.czytelnicy := nil;

  { ksiazka domyslnie jest dosptena }
  ustaw_status_ksiazki(nowa, true);

  nowa^.dane := ksiazka;

  nowa^.nast := glowa;
  glowa := nowa;

  end;

{ Procedura usuwa ksiazke z bazy danych jak i czytelnikow }
procedure usun_ksiazke(var glowa : pKsiazka;  usun_ksiazka : pKsiazka);
var
  aktualny, poprzedni : pKsiazka;
  begin
   aktualny := glowa;
  while(aktualny <> nil) do begin
    { jesli wskazniki do siebie pasuja - usuwamy }
    if(aktualny = usun_ksiazka) then begin

            { a) usuwamy pierwszy element z listy }
            if(aktualny = glowa) then begin

                   glowa := aktualny^.nast;

                   { usuwamy czytelnikow }
                   usun_czytelnikow(aktualny^.czytelnicy);

                   { usuwamy rekord }
                   dispose(aktualny);

                   { wskaznik pokazuje na "nic" }
                   aktualny := nil;

                   { to wszystko na dzis‡ }
                   exit;

            end
            { b) usuwamy obojetnie jaki element ktory nie jest glowa listy }
            else begin

                   poprzedni^.nast := aktualny^.nast;

                    { usuwamy czytelnikow }
                    usun_czytelnikow(aktualny^.czytelnicy);

                   { usuwamy nas }
                   dispose(aktualny);

                   { wskaznik pokazuje na "nic" }
                   aktualny := nil;

                   { dalej nie musimy iterowac‡ }
                   exit;
            end;
    end
    { przesuwamy się dalej }
    else begin
         poprzedni := aktualny;
         aktualny := aktualny^.nast;
    end;
  end;
  end;

{ Funkcja szuka ksiazki na liscie wedlug id - zwraca wskaznik na pKsiazka lub nil jesli nie ma takowej }
function szukaj_ksiazki_wedlug_id(var glowa : pKsiazka; id : integer) : pKsiazka;
var
  aktualny : pKsiazka;
  znaleziono : boolean;
  begin

   aktualny := glowa;
   while aktualny <> nil do begin
      if (aktualny^.dane.id = id) then begin
         znaleziono := true;
         break;
      end;

  aktualny := aktualny^.nast;
  end;

  if znaleziono then
    szukaj_ksiazki_wedlug_id := aktualny
  else
    szukaj_ksiazki_wedlug_id := nil;

  end;

{ Procedura usuwa wszystkie ksiazki z pamieci }
procedure usun_ksiazki(var glowa : pKsiazka);
var
    aktualny: pKsiazka;
begin
    aktualny := glowa;
    while aktualny <> nil  do begin
          aktualny := aktualny^.nast;
          { usuwamy czytelnikow ktorzy sa podwieszeni :-) dla danej ksiazki }
          usun_czytelnikow(glowa^.czytelnicy);
          dispose(glowa);
          glowa := aktualny;
    end;

    { lista jest pusta wiec wskazujemy na nil`a zeby funkcja usun_ksiazki dodawala nadal }
    glowa := nil;
end;


{                                  }
{ Funkcje operujace na pliku bazy  }
{                                  }
procedure zapisz_do_bazy(glowa : pKsiazka; sciezka_plik : string);
var
    plik_binarny : File;
    i, j : integer;
    glowa_czytelnik : pCzytelnik;
    begin
    { Wylaczamy bledy tymczasowo }
    {$I-}
    assign(plik_binarny, sciezka_plik);
    rewrite(plik_binarny, 1);
    { i wlaczamy }
    {$I+}

    { Sprawdzam czy plik otwarto i jest ogolnie git }
    if IOResult = 0 then begin
    while(glowa <> nil) do begin
       { Zapisujemy dane kazdej ksiazki }
       BlockWrite(plik_binarny, glowa^.dane.id, sizeof(glowa^.dane.id));
       BlockWrite(plik_binarny, glowa^.dane.tytul, sizeof(glowa^.dane.tytul));
       BlockWrite(plik_binarny, glowa^.dostepna, sizeof(glowa^.dostepna));

       { Liczmy ilosc osob ktore wypozyczyly ksiazke }
       i := ilosc_czytelnikow(glowa^.czytelnicy);

       { Zapisumjemy ta liczbe zeby przy odczycie wiedziec ile rekordow(bajtow) czytac }
       BlockWrite(plik_binarny, i, sizeof(i));

       { Glowa czytelnika }
       glowa_czytelnik := glowa^.czytelnicy;

       { Poruszamy sie po liscie czytelnikow danej ksiazki }
       while(glowa_czytelnik <> nil) do begin
          { Zapisujemy czytelnikow danej ksiazki - tj aktualnego czyli pierwszego na liscie i tych 'historycznych') }
          BlockWrite(plik_binarny, glowa_czytelnik^.dane.imie, sizeof(glowa_czytelnik^.dane.imie));
          BlockWrite(plik_binarny, glowa_czytelnik^.dane.nazwisko, sizeof(glowa_czytelnik^.dane.nazwisko));

          glowa_czytelnik := glowa_czytelnik^.nast;
       end;

       glowa := glowa^.nast;
    end;
  end;
    close(plik_binarny);
end;

{ Procedura czyta dane z bazy - pliku binarnego }
procedure czytaj_z_bazy(var glowa: pKsiazka; sciezka_plik : string);
var
  plik_binarny : File;
  i, ilosc : integer;
  glowa_czytelnik : pCzytelnik;
  ksiazka : dane_ksiazki;
  czytelnik : dane_czytelnika;
  nowa_ksiazka : pKsiazka;
  dostepna : boolean;
  begin
  { Wylaczamy bledy tymczasowo }
  {$I-}
  assign(plik_binarny, sciezka_plik);
  reset(plik_binarny, 1);
  { i wlaczamy }
  {$I+}

  { Sprawdzam czy plik otwarto i jest ogolnie git }
  if IOResult = 0 then begin
         while not eof(plik_binarny) do begin
            { Czytamy dane ksiazki }
            BlockRead(plik_binarny, ksiazka.id, sizeof(ksiazka.id));
            BlockRead(plik_binarny, ksiazka.tytul, sizeof(ksiazka.tytul));
            BlockRead(plik_binarny, dostepna, sizeof(dostepna));

            { Dodajemy ja do listy }
            dodaj_ksiazke(glowa, ksiazka);

            { Ustawmy ja na dostepna badz nie - zalezy jak zapisano do pliku }
            ustaw_status_ksiazki(glowa, dostepna);

            { Ksiazka to nasza aktluana zmienna 'glowa' - zatem wczytajmy jej czytelnikow }
             nowa_ksiazka := glowa;

            { Musimy wiedziec ile przy zapisie miala czytelnikow }
            BlockRead(plik_binarny, ilosc, sizeof(ilosc));

            { Wczytajmy ich }
            for i := 1 to ilosc do begin
                   BlockRead(plik_binarny, czytelnik.imie, sizeof(czytelnik.imie));
                   BlockRead(plik_binarny, czytelnik.nazwisko, sizeof(czytelnik.nazwisko));

                   { Dodajmy ich }
                   dodaj_czytelnika(nowa_ksiazka^.czytelnicy, czytelnik);
               end;
       end;
  end;
   close(plik_binarny);
end;

{                          }
{  Funkcje ekstra          }
{                          }

{ sprawdza czy zmienna tekstowa jest pusta - zwaraca true jesli pusta }
function pusty_tekst(tekst : string) : boolean;
begin
   if length(tekst) = 0 then begin
     pusty_tekst := true;
   end
   else begin
     pusty_tekst := false;
   end;
end;


{                          }
{ Funkcje trybu tekstowego }
{                          }

{ Procedura listuje ksiazki }
procedure PokazKsiazki(glowa : pKsiazka);
begin
     while (glowa <> nil) do begin
        if(glowa^.dostepna = true) then begin
              writeln('[+] Id: ', glowa^.dane.id, ', Tytul: ', glowa^.dane.tytul);
           end
           else begin
              writeln('[-] Id: ', glowa^.dane.id, ', Tytul: ', glowa^.dane.tytul);
           end;

           glowa := glowa^.nast;
    end;
 end;

{ Procedura dodaje ksiazke }
procedure DodajKsiazke(var glowa : pKsiazka);
var
    nowa : dane_ksiazki;
    id : integer;
    tytul : string[255];
    tmp_ksiazka : pKsiazka;
    begin

    ClrScr;
    write('Podaj tytul: ');
    readln(tytul);

    write('Podaj id: ');
    readln(id);

      if not pusty_tekst(tytul) then begin
           tmp_ksiazka := szukaj_ksiazki_wedlug_id(glowa, id);
            if tmp_ksiazka = nil then begin
                 nowa.tytul := tytul;
                 nowa.id := id;
                 dodaj_ksiazke(glowa, nowa);
                 writeln('Ksiazke dodano !');
                 end
             else begin
                    writeln('Ksiazka o podanym id juz istnieje');
                end;
      end
      else begin
        writeln('Nie podano tytulu');
      end;


 end;

{ Procedura usuwa ksiazke }
procedure UsunKsiazke(var glowa : pKsiazka);
var
    id : integer;
    tmp_ksiazka : pKsiazka;
    begin
       ClrScr;
       PokazKsiazki(glowa);
       write('Podaj id ksiazki jaka chcesz usunac: ');
       readln(id);

       tmp_ksiazka := szukaj_ksiazki_wedlug_id(glowa, id);
       if tmp_ksiazka <> nil then begin
           usun_ksiazke(glowa, tmp_ksiazka);
           writeln('Ksiazke usunieto !');
       end
       else begin
           writeln('Ksiazka o podanym id nie istnieje');
       end;

    end;

{ Procedura rezerwuje ksaizki }
procedure RezerwujKsiazke(var glowa : pKsiazka);
var
    imie, nazwisko : string[32];
    id : integer;
    tmp_ksiazka : pKsiazka;
    nowy_czytelnik : dane_czytelnika;
begin
     ClrScr;
     PokazKsiazki(glowa);

     write('Podaj id ksiazki: ');
     readln(id);

     tmp_ksiazka := szukaj_ksiazki_wedlug_id(glowa, id);
     { ksiazka znaleziona }
     if tmp_ksiazka <> nil then begin
           { jest dostpena }
             if tmp_ksiazka^.dostepna = true then begin
                writeln('Czytelnik - dane:');
                write('Podaj imie: ');
                readln(imie);

                write('Podaj nazwisko: ');
                readln(nazwisko);

                { dane sa okej - zarezerwujemy ksiazke }
                if not pusty_tekst(imie) and not pusty_tekst(nazwisko) then begin
                       { ksiazka zajeta = false }
                       ustaw_status_ksiazki(tmp_ksiazka, false);

                       { nowy czytelnik }
                       nowy_czytelnik.imie := imie;
                       nowy_czytelnik.nazwisko := nazwisko;

                       { dodajmy go }
                       dodaj_czytelnika(tmp_ksiazka^.czytelnicy, nowy_czytelnik);

                       writeln('Ksiazka zarezerowana');
                  end
                else begin
                   writeln('Nie podano imienia lub nazwiska');
                end;
             end
             else begin
                writeln('Ksiazka jest juz zarezerwowana - zwolnij ja');
             end;
     end
     else begin
        writeln('Ksiazki o podanym id nie znaleziono');
     end;
end;

{ Procedura dla oddania ksaizki }
procedure OddajKsiazke(var glowa : pKsiazka);
var
    id : integer;
    tmp_ksiazka : pKsiazka;
begin
     ClrScr;
     PokazKsiazki(glowa);

     write('Podaj ID ksiazki do zwrotu: ');
     readln(id);

     tmp_ksiazka := szukaj_ksiazki_wedlug_id(glowa, id);
     if tmp_ksiazka <> nil then begin
        ustaw_status_ksiazki(tmp_ksiazka, true);
        writeln('Ksiazka zwrocona');
     end
     else begin
        writeln('Ksiazka o podanym id nie istnieje');
     end;

end;

{ Procedura pokazuje wszystkie informacje o ksiazkach }
procedure PokazWszystko(glowa : pKsiazka);
var
  tmp_czytelnik : pCzytelnik;
begin
     ClrScr;
     while (glowa <> nil) do begin
        if(glowa^.dostepna = true) then begin
              writeln('| [+] Id: ', glowa^.dane.id, ', Tytul: ', glowa^.dane.tytul);

           end
           else begin
              writeln('| [-] Id: ', glowa^.dane.id, ', Tytul: ', glowa^.dane.tytul);
              { Potrzebujemy tylko pierwszego cztelnika (pierwszy element) - tego ktory posiada aktualnie ksiazke) }
              tmp_czytelnik := glowa^.czytelnicy;
              writeln('| Aktualny czytelnik: ', tmp_czytelnik^.dane.imie, ' ',   tmp_czytelnik^.dane.nazwisko);
           end;

           glowa := glowa^.nast;
    end;
end;

{ Procedura pokazuje menu }
procedure Menu;
begin
  writeln('a) Dodaj ksiazke');
  writeln('b) Usun ksiazke');
  writeln('c) Rezerwuj ksiazke');
  writeln('d) Oddaj ksiazke');
  writeln('e) Pokaz ksiazki');
  writeln('f) Pokaz wszystko');
  writeln('g) Wyjscie');
end;


{ Main }


var
    { glowna lista }
    lista : pKsiazka;

    { wybor w menu }
    wybor : char;

    sciezkaplik : string;

begin
  sciezkaplik := 'D:\biblioteka.bin';

  czytaj_z_bazy(lista, sciezkaplik);
  repeat

   Menu;
          repeat
          wybor := ReadKey;
          wybor := UpCase(wybor);

          until wybor in ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
          case wybor of

          'A': begin
               DodajKsiazke(lista);
               zapisz_do_bazy(lista, sciezkaplik);
               end;
          'B': begin
               UsunKsiazke(lista);
               zapisz_do_bazy(lista, sciezkaplik);
               end;
          'C': begin
               RezerwujKsiazke(lista);
               zapisz_do_bazy(lista, sciezkaplik);
               end;
          'D': begin
               OddajKsiazke(lista);
               zapisz_do_bazy(lista, sciezkaplik);
               end;
          'E': begin PokazKsiazki(lista); end;
          'F': begin PokazWszystko(lista); end;
          end;


    until wybor = 'G';

   { czyscimy pamiec }
   usun_ksiazki(lista);

   lista := nil;
end.