ROK 2 – VETERINARSKA STANICA I ŽIVOTINJE

ŽIVOTINJA CPP

#include "Zivotinja.h"
#include <iostream>

int Zivotinja::brojZivotinja = 0;

const std::string& Zivotinja::getIme() const {

return ime;
}
int Zivotinja::getGodine() const{
return godine;
}

double Zivotinja::getTezina() const{

return tezina;
}

bool Zivotinja::getVakcinisan() const {

return vakcinisan;
}

Zivotinja::Spol Zivotinja::getSpol() const {

return spol;
}

void Zivotinja::setIme(const std::string s) {

ime = s;
}

void Zivotinja::setGodine(int g) {
godine = g;
}

void Zivotinja::setTezina(double t) {
tezina = t;
}

void Zivotinja::setVakcinisan(bool v) {
vakcinisan = v;
}

void Zivotinja::setSpol(Spol s) {
spol = s;
}

void Zivotinja::vakcinisi() const {

if (!vakcinisan) {
std::cout << "Vakcinacija izvršena!";
 }
else {
std::cout << "Zivotinja je vec vakcinisana!";
}
}

int Zivotinja::vratiBrojZivotinja() {
return brojZivotinja;
}

void Zivotinja::ispis(std::ostream& out) const{

out << "Ime: " << ime << std::endl;
out << "Godine: " << godine << std::endl;
out << "Tezina: " << tezina << std::endl;
out << "Vakcinisana: ";
if (vakcinisan) out << "DA";
else out << "NE";
std::cout << std::endl;
out << "Spol: ";
if (spol == Zivotinja::Spol::Muzjak) out << "Muzjak";
else out << "Zenka";
}

std::istream& operator>>(std::istream& in, Zivotinja& z) {

std::cout << "Ime: ";
in >> z.ime;
std::cout << "Godine: ";
in >> z.godine;
std::cout << "Tezina: ";
in >> z.tezina;
std::cout << "Vakcinisana: \n\t1 - DA\n\t2 - NE";
int temp;
do {
std::cout << "\nIzbor:";
in >> temp;
} while (temp > 1 || temp > 2);
if (temp == 1) z.vakcinisan = true;
else z.vakcinisan = false;
std::cout << "Spol: \n\t1 - MUZJAK\n\t2 - ZENKA";
int t = 0;
do {
std::cout << "\nIzbor:";
in >> t;
} while (t > 1 || t > 2);
if (t == 1) z.spol = Zivotinja::Spol::Muzjak;
else z.spol = Zivotinja::Spol::Zenka;

return in;
}
ŽIVOTINJA.H

#pragma once
#include <string>

class Zivotinja {
protected:
std::string ime;
int godine;
double tezina;
bool vakcinisan;

static int brojZivotinja;

public:
enum class Spol { Muzjak, Zenka };

Zivotinja() = default;

Zivotinja(const std::string& i, int g, double t, bool v, Spol s) :

ime(i), godine(g), tezina(t), vakcinisan(v), spol(s) {
}

[[nodiscard]] const std::string &getIme() const;

[[nodiscard]] int getGodine() const;
[[nodiscard]] double getTezina() const;
[[nodiscard]] bool getVakcinisan() const;
[[nodiscard]] Spol getSpol() const;

void setIme(const std::string s);

void setGodine(int g);
void setTezina(double t);
void setVakcinisan(bool v);
void setSpol(Spol s);

virtual std::string vratiNaziv() const = 0;

virtual void vakcinisi() const;

static int vratiBrojZivotinja();

virtual void ispis(std::ostream& out) const;

friend std::istream& operator>>(std::istream& in, Zivotinja& z);
virtual bool ima(const std::string r) const = 0;

virtual ~Zivotinja() = default;

protected:
Spol spol;

};

PAS CPP
#include "Pas.h"
#include <iostream>

Pas::Pas(const std::string& r, const std::string zP, const std::string& i, int g, double t, bool v, Spol s) :
Zivotinja(i, g, t, v, s), rasa(r), zemljaPorijekla(zP){
}

void Pas::setRasa(const std::string& r) {

rasa = r;
}

const std::string& Pas::getRasa() const {

return rasa;
}

void Pas::setZP(const std::string& zp) {

zemljaPorijekla = zp;
}

const std::string& Pas::getZP() const {

return zemljaPorijekla;
}

std::string Pas::vratiNaziv() const

{
return "Pas";
}

void Pas::ispis(std::ostream& out) const{

Zivotinja::ispis(out);
out << "\nRasa: " << rasa;
out << "\nZemlja porijekla: " << zemljaPorijekla;
}

bool Pas::ima(const std::string r) const {

if (rasa == r) return true;
else return false;
}

std::istream& operator>>(std::istream& unos, Pas& p) {

unos >> static_cast<Zivotinja&>(p);
std::cout << "Rasa: ";
unos >> p.rasa;
std::cout << "Zemlja porijekla: ";
unos >> p.zemljaPorijekla;

return unos;
}

PAS.H
#pragma once

#include "Zivotinja.h"
#include <vector>

class Pas : public Zivotinja{

private:
std::string rasa, zemljaPorijekla;

public:
Pas() = default;

Pas(const std::string& r, const std::string zP, const std::string& i, int g, double t, bool v, Spol s);

void setRasa(const std::string& r);

[[nodiscard]] const std::string& getRasa() const;

void setZP(const std::string& zp);

[[nodiscard]] const std::string& getZP() const;

std::string vratiNaziv() const override;

friend std::istream& operator>>(std::istream& unos, Pas& p);

void ispis(std::ostream& out) const override;

bool ima(const std::string r) const override;

~Pas() override = default;

};

KONJ CPP
#include "Konj.h"
#include <iostream>

Konj::Konj(const std::string& sv, const std::string& i, int g, double t, bool v, Spol s):
Zivotinja(i, g, t, v, s), svrha(sv) {brojZivotinja++;}

std::string Konj::vratiNaziv() const{

return "Konj";
}

void Konj::setSvrha(const std::string& S) {

svrha = S;
}

const std::string& Konj::getSvrha() const {

return svrha;
}

void Konj::ispis(std::ostream& out) const{

Zivotinja::ispis(out);
out << "\nSvrha: " << svrha;
}

bool Konj::ima(const std::string r) const {

if (svrha == r) return true;
else return false;
}

std::istream& operator>>(std::istream& unos, Konj& k) {

unos >> static_cast<Zivotinja&>(k);
std::cout << "Svrha: ";
unos >> k.svrha;

return unos;
}

KONJ.H
#pragma once

#include "Zivotinja.h"

class Konj : public Zivotinja{

private:
std::string svrha;

public:

Konj() = default;

Konj(const std::string& sv, const std::string& i, int g, double t, bool v, Spol s);

std::string vratiNaziv() const override;

void setSvrha(const std::string& S);

[[nodiscard]] const std::string& getSvrha() const;

void ispis(std::ostream& out) const override;

friend std::istream& operator>>(std::istream& unos, Konj& k);

bool ima(const std::string r) const override;

~Konj() override = default;

};

VETERINARSKA STANICA CPP

#include "VeterinarskaStanica.h"
#include "VeterinarskaStanica.h"
#include <memory>
#include <fstream>
#include <iostream>

VeterinarskaStanica::VeterinarskaStanica(){
ucitaj();
}

void VeterinarskaStanica::ucitaj() {
auto pas = new Pas();
auto konj = new Konj();
std::string provjera, tekst;
std::ifstream ispis("zivotinja.txt");
if (ispis.is_open()) {
while (!ispis.eof()) {
ispis >> provjera;
if (provjera == "Vrsta:") {
ispis >> provjera;
if (provjera == "Pas") {
ispis >> provjera;
if (provjera == "Ime:") {
tekst = "";
do {
ispis >> provjera;
if (provjera != "Godine:") {
tekst += provjera;
}
} while (provjera != "Godine:");
pas->setIme(tekst);
}
if (provjera == "Godine:") {
ispis >> provjera;
pas->setGodine(stoi(provjera));
}
if (provjera == "Tezina:") {
ispis >> provjera;
pas->setTezina(stod(provjera));
}
if (provjera == "Vakcinisana:") {
ispis >> provjera;
if (provjera == "da") pas->setVakcinisan(true);
else pas->setVakcinisan(false);
}
if (provjera == "Spol:") {
ispis >> provjera;
if (provjera == "Z") pas->setSpol(Zivotinja::Spol::Zenka);
else pas->setSpol(Zivotinja::Spol::Muzjak);
}
if (provjera == "Rasa:") {
ispis >> provjera;
tekst = "";
do {
ispis >> provjera;
if (provjera != "ZP:") {
tekst += provjera;
}
} while (provjera != "ZP:");
 pas->setRasa(tekst);
}
if (provjera == "ZP:") {
ispis >> provjera;
tekst = "";
do {
ispis >> provjera;
if (provjera != "Vrsta:") {
tekst += provjera;
}
} while (provjera != "Vrsta:");
pas->setZP(tekst);
zivotinja.push_back(pas);
}
}
else if (provjera == "Konj") {
ispis >> provjera;
if (provjera == "Ime:") {
tekst = "";
do {
ispis >> provjera;
if (provjera != "Godine:") {
tekst += provjera;
}
} while (provjera != "Godine:");
konj->setIme(tekst);
}
if (provjera == "Godine:") {
ispis >> provjera;
pas->setGodine(stoi(provjera));
}
if (provjera == "Tezina:") {
ispis >> provjera;
konj->setTezina(stod(provjera));
}
if (provjera == "Vakcinisana:") {
ispis >> provjera;
if (provjera == "da") konj->setVakcinisan(true);
else konj->setVakcinisan(false);
}
if (provjera == "Spol:") {
ispis >> provjera;
if (provjera == "Z") konj->setSpol(Zivotinja::Spol::Zenka);
else konj->setSpol(Zivotinja::Spol::Muzjak);
}
if (provjera == "Svrha:") {
ispis >> provjera;
tekst = "";
do {
ispis >> provjera;
if (provjera != "Vrsta:") {
tekst += provjera;
}
} while (provjera != "Vrsta:");
konj->setSvrha(tekst);
zivotinja.push_back(konj);
}
}
}
 }
ispis.close();
}
else {
std::cout << "\nDatoteka ne postoji";
}
}

int VeterinarskaStanica::brojZivotinja() const {

return zivotinja.size();
}

void VeterinarskaStanica::dodajPsa(const std::string r, const std::string zP, const std::string& i, int g, double t, bool v,
Zivotinja::Spol s) {
auto temp = new Pas();
temp->setIme(i);
temp->setGodine(g);
temp->setTezina(t);
temp->setVakcinisan(v);
temp->setSpol(s);
temp->setRasa(r);
temp->setZP(zP);

zivotinja.push_back(temp);
}

void VeterinarskaStanica::dodajKonj(const std::string& sv, const std::string& i, int g, double t, bool v, Zivotinja::Spol s){
auto temp = new Konj();
temp->setIme(i);
temp->setGodine(g);
temp->setTezina(t);
temp->setVakcinisan(v);
temp->setSpol(s);
temp->setSvrha(sv);

zivotinja.push_back(temp);
}
std::vector<Zivotinja*>& VeterinarskaStanica::vakcinisaneZ(){
std::vector<Zivotinja*>animal;
for (const auto& z : zivotinja) {
if (z->getVakcinisan()) {
animal.push_back(z);
}
}
return animal;
}

std::vector<Zivotinja*>& VeterinarskaStanica::PasM(){
std::vector<Zivotinja*>animal;
std::cout << "\nUnesite trazenu rasu: \n";
std::string r;
std::cin >> r;
for (const auto& z : zivotinja) {
if (z->ima(r)){
animal.push_back(z);
}
}
return animal;
}

std::vector<Zivotinja*>& VeterinarskaStanica::Konjo() {
std::vector<Zivotinja*>animal;
std::cout << "\nUnesite zeljenu svrhu: \n";
std::string r;
std::getline(std::cin, r);
for (const auto& z : zivotinja) {
if (z->ima(r)) {
animal.push_back(z);
}
}
return animal;
}

VETERINARSKA STAMICA H

#pragma once

#include "Konj.h"
#include "Pas.h"
#include <vector>

class VeterinarskaStanica {

std::vector<Zivotinja*>zivotinja;

public:
VeterinarskaStanica();

void ucitaj();

[[nodiscard]] int brojZivotinja() const;

void dodajPsa(const std::string r, const std::string zP, const std::string& i, int g, double t, bool v, Zivotinja::Spol
s);
void dodajKonj(const std::string& sv, const std::string& i, int g, double t, bool v, Zivotinja::Spol s);

[[nodiscard]] inline void operator!() {

int index = 0, temp = 0;
for (int i = 0; i < zivotinja.size(); i++) {
if (zivotinja[i]->getGodine() > temp) {
temp = zivotinja[i]->getGodine();
index = i;
}
}
}

std::vector<Zivotinja*>& vakcinisaneZ();
std::vector<Zivotinja*>& PasM();
std::vector<Zivotinja*>& Konjo();
 inline ~VeterinarskaStanica() {
for (const auto& s : zivotinja) {
delete s;
}
}

};

MAIN CPP

#include <iostream>

#include "VeterinarskaStanica.h"

int main(){
VeterinarskaStanica vets;
vets.ucitaj();
int broj;
do {
std::cout << "1 - Unos psa" << std::endl;
std::cout << "2 - Unos konja" << std::endl;
std::cout << "3 - Ispis vakcinisanih zivotinja" << std::endl;
std::cout << "4 - Ispis najstarije zivotinje" << std::endl;
std::cout << "5 - Pretraga po rasi" << std::endl;
std::cout << "6 - Pretraga po vrsti" << std::endl;
std::cout << "7 - Kraj" << std::endl;
do {
std::cout << "Izbor: ";
std::cin >> broj;
} while (broj < 0 || broj > 6);
switch (broj) {
case 1: {
std::cout << "\nUnos psa\n";
std::cout << "Ime: ";
std::string ime;
std::cin >> ime;
std::cin.ignore();

std::cout << "Godine: ";

int g;
std::cin >> g;

std::cout << "Tezina: ";

double t;
std::cin >> t;
 std::cout << "Vakcinisana: \n\t1 - DA\n\t2 - NE\nIzbor:";
int temp;
bool v;
do {
std::cin >> temp;
} while (temp < 1 || temp > 2);
if (temp == 1) v = true;
else v = false;

std::cout << "Spol: \n\t1 - MUZJAL\n\t2 - ZENKA\nIzbor:";

int temp1;
Zivotinja::Spol s;
do {
std::cin >> temp1;
} while (temp1 < 1 || temp1 > 2);
if (temp1 == 1) s = Zivotinja::Spol::Muzjak;
else s = Zivotinja::Spol::Zenka;

std::cout << "Rasa: ";

std::string r;
std::cin >> r;

std::cout << "Zemlja porijekla: ";

std::string zp;
std::cin >> zp;

vets.dodajPsa(r, zp, ime, g, t, v, s);

break;
}
case 2: {
std::cout << "\nUnos konj\n";
std::cout << "Ime: ";
std::string ime;
std::cin >> ime;

std::cout << "Godine: ";

int g;
std::cin >> g;

std::cout << "Tezina: ";

double t;
std::cin >> t;

std::cout << "Vakcinisana: \n\t1 - DA\n\t2 - NE\nIzbor:";

int temp = 0;
bool v;
do {
std::cin >> temp;
} while (temp < 1 || temp > 2);
if (temp == 1) v = true;
else v = false;

std::cout << "Spol: \n\t1 - MUZJAL\n\t2 - ZENKA\nIzbor:";

int temp1 = 0;
Zivotinja::Spol s;
do {
std::cin >> temp1;
} while (temp1 < 1 || temp1 > 2);
if (temp1 == 1) s = Zivotinja::Spol::Muzjak;
 else s = Zivotinja::Spol::Zenka;

std::cout << "Rasa: ";

std::string sv;
std::cin >> sv;

vets.dodajKonj(sv, ime, g, t, v, s);

break;
}
case 3: {
std::cout << "Ispis vakcinisanih: ";
std::vector<Zivotinja*> vakc = vets.vakcinisaneZ();
if (vakc.empty()) {
std::cout << "\nNema vakcinisanih zivotinja\n";
break;
}
std::cout << "\nVakcinisane zivotinje su: \n";
for (const auto& ziv : vakc) {
std::cout << ziv;
}
break;
}
case 4: {
std::cout << "\nNajstarije zivotinje: \n";
!vets;
break;
}
case 5: {
std::cout << "\nPretraga psa po rasi:\n";
std::vector<Zivotinja*> psic = vets.PasM();
if (psic.empty()) {
std::cout << "\nNema psa te rase\n";
break;
}
std::cout << "\nPsi: \n";
for (const auto& ziv : psic) ziv->ispis(std::cout);
break;

}
case 6: {
std::cout << "\nPretraga konja po vrsti:\n";
std::vector<Zivotinja*> psic = vets.Konjo();
if (psic.empty()) {
std::cout << "\nNema konja te vrste\n";
break;
}
std::cout << "\nKonji: \n";
for (const auto& ziv : psic) ziv->ispis(std::cout);
break;
}
case 0: {
std::cout << "\nKraj programa";
}
default:
break;
}

} while (broj != 0);

}

PRIPREMA ZA ISPIT – VOZILO

VOZILO.H
#ifndef OOP_PRIPREMA2_VOZILO_H
#define OOP_PRIPREMA2_VOZILO_H

#include <string>
class Vozilo {
protected:
int godinaProizvodnje, brojTockova;
std::string proizvodjac;
public:
Vozilo() = default;
static int trenutnaGodina();
[[nodiscard]] int getGodinaProizvodnje() const;
void setGodinaProizvodnje(int godinaProizvodnje);
[[nodiscard]] int getBrojTockova() const;
void setBrojTockova(int brojTockova);
[[nodiscard]] const std::string& getProizvodjac() const;
void setProizvodjac(const std::string& proizvodjac);
virtual void ispis(std::ostream& out) const;
[[nodiscard]] virtual bool oldTimer() const = 0;
virtual ~Vozilo() = default;
};

#endif

VOZILO.CPP

#include "Vozilo.h"
#include <iostream>
#include <ctime>

int Vozilo::getGodinaProizvodnje() const {

return godinaProizvodnje;
}

void Vozilo::setGodinaProizvodnje(int godinaProizvodnje) {

Vozilo::godinaProizvodnje = godinaProizvodnje;
}

int Vozilo::getBrojTockova() const {

return brojTockova;
}

void Vozilo::setBrojTockova(int brojTockova) {

Vozilo::brojTockova = brojTockova;
}

const std::string &Vozilo::getProizvodjac() const {

return proizvodjac;
}

void Vozilo::setProizvodjac(const std::string &proizvodjac) {

Vozilo::proizvodjac = proizvodjac;
}

void Vozilo::ispis(std::ostream &out) const {

 out << proizvodjac << " (" << godinaProizvodnje << ") - " << brojTockova << "-tockas\n";
}

int Vozilo::trenutnaGodina() {
const time_t time = std::time(nullptr);
struct tm *tm = std::localtime(&time);
return tm->tm_year + 1900;
}

AUTOMOBIL.H
#ifndef OOP_PRIPREMA2_AUTOMOBIL_H
#define OOP_PRIPREMA2_AUTOMOBIL_H

#include "Vozilo.h"

class Automobil : public Vozilo {

std::string marka, tip;
public:
enum class Gorivo {
DIZEL, BENZIN, ELEKTRICNO_VOZILO
};
Automobil() = default;
void ispis(std::ostream& out) const override;
[[nodiscard]] bool oldTimer() const override;
[[nodiscard]] const std::string &getMarka() const;
void setMarka(const std::string &marka);
[[nodiscard]] const std::string &getTip() const;
void setTip(const std::string &tip);
[[nodiscard]] Gorivo getGorivo() const;
void setGorivo(Gorivo gorivo);
~Automobil() override = default;
private:
Gorivo gorivo;
};

#endif

AUTOMOBIL.CPP

#include "Automobil.h"
#include <iostream>

bool Automobil::oldTimer() const {

return trenutnaGodina()-godinaProizvodnje > 30;
}

void Automobil::ispis(std::ostream &out) const {

 Vozilo::ispis(out);
out << marka << " " << tip << " - Gorivo: ";
switch (gorivo) {
case Gorivo::BENZIN: out << "BENZIN"; break;
case Gorivo::DIZEL: out << "DIZEL"; break;
case Gorivo::ELEKTRICNO_VOZILO: out << "ELEKTRICNO VOZILO"; break;
}
out << std::endl;
}

const std::string &Automobil::getMarka() const {

return marka;
}

void Automobil::setMarka(const std::string &marka) {

Automobil::marka = marka;
}

const std::string &Automobil::getTip() const {

return tip;
}

void Automobil::setTip(const std::string &tip) {

Automobil::tip = tip;
}

Automobil::Gorivo Automobil::getGorivo() const {

return gorivo;
}

void Automobil::setGorivo(Automobil::Gorivo gorivo) {

Automobil::gorivo = gorivo;
}

MOTOR.H

#ifndef OOP_PRIPREMA2_MOTOR_H
#define OOP_PRIPREMA2_MOTOR_H

#include "Vozilo.h"

class Motor : public Vozilo {

 int brojKubika;
public:
Motor() = default;
[[nodiscard]] int getBrojKubika() const;
void setBrojKubika(int brojKubika);
[[nodiscard]] bool oldTimer() const override;
void ispis(std::ostream& out) const override;
~Motor() override = default;
};

#endif

MOTOR.CPP

#include "Motor.h"
#include <iostream>

int Motor::getBrojKubika() const {

return brojKubika;
}

void Motor::setBrojKubika(int brojKubika) {

Motor::brojKubika = brojKubika;
}

bool Motor::oldTimer() const {

return trenutnaGodina()-godinaProizvodnje > 15;
}

void Motor::ispis(std::ostream &out) const {

Vozilo::ispis(out);
out << "Broj kubika: " << brojKubika << std::endl;
}

KONTEJNER.H

#ifndef OOP_PRIPREMA2_KONTEJNER_H
#define OOP_PRIPREMA2_KONTEJNER_H

#include <vector>
#include <stdexcept>
#include "Vozilo.h"
#include "Automobil.h"

class Kontejner {
std::vector<Vozilo*> vozila;
public:
Kontejner() = default;
[[nodiscard]] inline size_t operator!() {
return vozila.size();
}
[[nodiscard]] inline Vozilo* operator[](int index) const {
/*if (index < 0 || index >= vozila.size())
throw std::invalid_argument("Neispravan indeks");
return vozila[index];*/
return vozila.at(index);
}
void dodajAutomobil(const std::string& marka, const std::string& tip, Automobil::Gorivo gorivo, int brojTockova, int
godinaProizvodnje, const std::string& proizvodjac);
void dodajMotor(int brojTockova, int godinaProizvodnje, const std::string& proizvodjac, int brojKubika);
[[nodiscard]] inline std::vector<Vozilo*> sviOldTajmeri() const {
std::vector<Vozilo*> pomocniVektor;
for (const auto& vozilo : vozila)
if (vozilo->oldTimer()) pomocniVektor.push_back(vozilo);
return pomocniVektor;
}
inline ~Kontejner() {
for (const auto& vozilo : vozila) delete vozilo;
}
};

#endif

KONTEJNER.CPP
#include "Kontejner.h"
#include "Motor.h"

void
Kontejner::dodajAutomobil(const std::string &marka, const std::string &tip, Automobil::Gorivo gorivo, int brojTockova,
int godinaProizvodnje, const std::string &proizvodjac) {
auto* automobil = new Automobil();
automobil->setMarka(marka);
automobil->setTip(tip);
automobil->setGorivo(gorivo);
 automobil->setBrojTockova(brojTockova);
automobil->setGodinaProizvodnje(godinaProizvodnje);
automobil->setProizvodjac(proizvodjac);
vozila.push_back(automobil);
}

void Kontejner::dodajMotor(int brojTockova, int godinaProizvodnje, const std::string &proizvodjac, int brojKubika) {
auto* motor = new Motor();
motor->setBrojKubika(brojKubika);
motor->setBrojTockova(brojTockova);
motor->setGodinaProizvodnje(godinaProizvodnje);
motor->setProizvodjac(proizvodjac);
vozila.push_back(motor);
}

MAIN.CPP
#include <iostream>
#include "Kontejner.h"

inline int meni() {

std::cout << "1. Dodavanje automobila\n";
std::cout << "2. Dodavanje motora\n";
std::cout << "3. Broj elemenata u kontejneru\n";
std::cout << "4. Ispis vozila po indeksu\n";
std::cout << "5. Ispis svih old tajmera iz kontejnera\n";
std::cout << "0. Izlaz\nIzbor: ";
int izbor = 0;
do {
std::cin >> izbor;
if (std::cin.fail()) {
std::cin.clear();
std::cin.ignore(std::numeric_limits<std::streamsize>::max());
}
} while (izbor < 0 || izbor > 5);
return izbor;
}

int main() {
Kontejner kontejner;
int izbor;
while ((izbor = meni())) {
std::cin.ignore();
switch (izbor) {
case 1: {
std::cout << "Unesite marku automobila: ";
std::string marka;
std::getline(std::cin, marka);

std::cout << "Unesite tip automobila: ";

std::string tip;
std::getline(std::cin, tip);
 std::cout << "Unesite ime proizvodjaca automobila: ";
std::string proizvodjac;
std::getline(std::cin, proizvodjac);

int brojTockova, godinaProizvodnje;

std::cout << "Unesite broj tockova automobila: ";
std::cin >> brojTockova;
std::cout << "Unesite godinu proizvodnje automobila: ";
std::cin >> godinaProizvodnje;

int gorivoIndex;
std::cout << "Unesite tip goriva automobila (0 - DIZEL, 1 - BENZIN, 2 ELEKTRICNO VOZILO): ";
do {
std::cin >> gorivoIndex;
} while (gorivoIndex < 0 || gorivoIndex > 2);
Automobil::Gorivo gorivo;
switch (gorivoIndex) {
case 0: gorivo = Automobil::Gorivo::DIZEL; break;
case 1: gorivo = Automobil::Gorivo::BENZIN; break;
case 2: gorivo = Automobil::Gorivo::ELEKTRICNO_VOZILO; break;
default: gorivo = Automobil::Gorivo::DIZEL; break;
}

kontejner.dodajAutomobil(marka, tip, gorivo, brojTockova, godinaProizvodnje, proizvodjac);

break;
}
case 2: {
std::cout << "Unesite ime proizvodjaca motora: ";
std::string proizvodjac;
std::getline(std::cin, proizvodjac);

int brojTockova, godinaProizvodnje, brojKubika;

std::cout << "Unesite broj tockova motora: ";
std::cin >> brojTockova;
std::cout << "Unesite godinu proizvodnje motora: ";
std::cin >> godinaProizvodnje;
std::cout << "Unesite broj kubika motora: ";
std::cin >> brojKubika;

kontejner.dodajMotor(brojTockova, godinaProizvodnje, proizvodjac, brojKubika);

break;
}
case 3: {
std::cout << "Uneseno je " << !kontejner << " vozila!\n";
break;
}
case 4: {
try {
std::cout << "Unesite indeks vozila za ispis: ";
int index;
std::cin >> index;
kontejner[index]->ispis(std::cout);
} catch (...) {
std::cout << "Neispravan indeks ili nepoznata greska!\n";
}
break;
}
case 5: {
std::vector<Vozilo*> oldTajmeri = kontejner.sviOldTajmeri();
 if (oldTajmeri.empty()) {
std::cout << "Nema unesenih old tajmera\n";
break;
}
std::cout << "Old tajmeri u kontejneru su:\n";
for (const auto &vozilo: oldTajmeri) vozilo->ispis(std::cout);
break;
}
default: {
std::cout << "Pogresan izbor!\n";
break;
}
}
}
return 0;
}