PR2 ispitni

# include <iostream>
# include <vector>
# include <string>
# include <sstream>
# include <exception>
#include <algorithm>
using namespace std;

char* crt = "\n==========================================\n";
//globalne varijabla
int PACIJENT_ID = 0;

//globalna funkcija
template<class S>
string toString(S& obj){
    stringstream out;
    out << obj;
    return out.str();
}

//////////////////////////////////////KLASA KOLEKCIJA///////////////////////////////////////////////

template<class T1, class T2>
class Kolekcija{
    T1 * elementi1;
    T2 * elementi2;
    int * max;
    int * trenutnoElemenata;
public:
    //DEF. KONSTRUKTOR
    Kolekcija(){
        max = new int(3);
        trenutnoElemenata = new int(0);
        elementi1 = new T1[*max]; //def. konstruktor T1
        elementi2 = new T2[*max]; //def. konstruktor T2
    }
    //KONSTRUKTOR KOPIJE
    Kolekcija(Kolekcija<T1, T2> &obj){
        max = new int(*obj.max);
        trenutnoElemenata = new int(*obj.trenutnoElemenata);
        elementi1 = new T1[*max]; //def. konstruktor T1
        elementi2 = new T2[*max]; //def. konstruktor T2
        for (int i = 0; i < *trenutnoElemenata; i++){
            elementi1[i] = T1(obj.elementi1[i]); // konstruktor kopije T1
            elementi2[i] = T2(obj.elementi2[i]); // konstruktor kopije T1
        }
    }
    //DESTRUKTOR
    ~Kolekcija(){
        //cout << "DESTRUKTOR KOLEKCIJA\n";
        delete max;
        delete trenutnoElemenata;
        delete[] elementi1;
        delete[] elementi2;
        max = NULL;
        trenutnoElemenata = NULL;
        elementi1 = NULL;
        elementi2 = NULL;
    }

    //1. AddElement :: omogucava dodavanje novog elementa u kolekciju. Osigurati automatsko
    // prosiranje kolekcije ukoliko broj elemenata dostigne trenutni maksimum, te onemoguciti
    // ponavljanje elemenata. U zavisnosti od uspjesnosti operacije, funkcija vraca true ili false
    bool AddElement(T1 el1, T2 el2){

        for (int i = 0; i < *trenutnoElemenata; i++)
        {
            if (elementi1[i] == el1 && elementi2[i] == el2)
                return false;
        }
        if (*trenutnoElemenata == *max)
            ProsiriKapacitet();

        elementi1[*trenutnoElemenata] = el1;
        elementi2[*trenutnoElemenata] = el2;
        (*trenutnoElemenata)++;
        return true;
    }
    //2. RemoveElement :: na osnovu parametra tipa T1 uklanja elemente iz kolekcije. Ukoliko je
    // potrebno,prilikom uklanjanja elementa izvrsiti dealokaciju. Onemoguciti pojavljivanje
    // neinicijaliziranih elemenata, te ocuvati redoslijed dodavanja elemenata. U zavisnosti od
    // uspjesnosti operacije, funkcija vraca true ili false
    bool RemoveElement(T1 el){
        for (int i = 0; i < *trenutnoElemenata; i++)
        {
            if (elementi1[i] == el)
            {
                for (int j = i; j < (*trenutnoElemenata) - 1; j++)
                {
                    elementi1[j] = elementi1[j + 1];
                    elementi2[j] = elementi2[j + 1];
                }
                (*trenutnoElemenata)--;
                return true;
            }
        }
        return false;
    }
    //3. operator -= :: uklanja sve elemente iz kolekcije koji su identicni onima koje posjeduje
    // drugi objekat tipa Kolekcija koji je primljen kao parametar. Funkcija vraca broj uklonjenih elemenata

    //Kako bi se ispostovalo ocekivano ponasanje operatora -= prirodnija je implementacija na nacin prikazan ispod,
    //prvi operand je objekat tipa Kolekcija<T1,T2> te na njega utice rezultat operacije
    Kolekcija<T1, T2>& operator-= (T2 el2){
        int brojac = 0;
        for (int i = 0; i < (*trenutnoElemenata); i++)
        {
            if (elementi2[i] == el2)
            {
                for (int j = i; j < (*trenutnoElemenata) - 1; j++)
                {
                    elementi1[j] = elementi1[j + 1];
                    elementi2[j] = elementi2[j + 1];
                }
                brojac++;
                (*trenutnoElemenata)--;
            }
        }
        return *this;
    }


    //DODATNO/////////////////////////////////////////////////////////////////////////////////////////////////

    //Funkcija vrace velicinu kolekcije
    int getTrenutno(){ return *trenutnoElemenata; }

    //Funkcija prosiruje kapacitet kolekcije
    void ProsiriKapacitet(){

        T1 * temp1 = new T1[(*max) + 3];
        T2 * temp2 = new T2[(*max) + 3];

        for (int i = 0; i < *trenutnoElemenata; i++){
            temp1[i] = elementi1[i];
            temp2[i] = elementi2[i];
        }

        delete[] elementi1;
        delete[] elementi2;
        elementi1 = temp1;
        elementi2 = temp2;
        (*max) += 3;
    }

    //Funkcija vraca objekt T1 na osnovu primljene lokacije
    T1& getT1byLokacija(int lokacija) throw (exception){
        if (lokacija >= 0 && lokacija < *trenutnoElemenata)
            return elementi1[lokacija];
        throw exception("Lokacija ne postoji");
    }

    //Funkcija vraca objekt T1 na osnovu primljene lokacije
    T2& getT2byLokacija(int lokacija) throw (exception){
        if (lokacija >= 0 && lokacija < *trenutnoElemenata)
            return elementi2[lokacija];
        throw exception("Lokacija ne postoji");
    }

    //Primjetite da nije preklopljen operator << za klasu kolekcija
    //Ispis vrijednosti objekata ce se vrsiti pomocu predhodna dva getera za T1 i T2,
    //te je za te tipove, ako su korisnicki definirani, potrebno preklopiti operator << ili implementirati funkciju za ispis
    //Operator [] generalno nema smisla, osim u nekim eksplicitno trazenim situacijama,
    //konkretno u ovom zadatku bi mogao zamijeniti jednu od predhodne dvije funkcije
    //ali na taj nacin se opet gubi expected behavior
};

///////////////////////////////////////KLASA DATUM//////////////////////////////////////////////////

class Datum{
    int * dan, *mjesec, *godina;
public:
    Datum(){
        dan = new int(1);
        mjesec = new int(1);
        godina = new int(1900);
    }
    Datum(int d, int m, int g){
        dan = new int(d);
        mjesec = new int(m);
        godina = new int(g);
    }
    Datum(Datum & obj)
    {
        dan = new int(obj.getDan());
        mjesec = new int(obj.getMjesec());
        godina = new int(obj.getGodina());
    }
    Datum& operator= (Datum & obj)
    {
        if (this != &obj)
        {
            *dan = obj.getDan();
            *mjesec = obj.getMjesec();
            *godina = obj.getGodina();
        }
        return *this;
    }
    ~Datum(){
        //cout << "DESTRUKTOR DATUM\n";
        delete dan; dan = NULL;
        delete mjesec; mjesec = NULL;
        delete godina; godina = NULL;
    }
    bool operator==(const Datum &d)
    {
        if (*dan != *d.dan || *mjesec != *d.mjesec || *godina != *d.godina)
            return false;
        return true;
    }
    bool operator!=(const Datum &d) { return !(*this == d); }
    int getDan(){ return *dan; }
    int getMjesec(){ return *mjesec; }
    int getGodina(){ return *godina; }
    string Info(){
        string out = "";
        out += toString(*dan) + "." + toString(*mjesec) + "." + toString(*godina);
        return out;
    }
    //friend ostream & operator<<(ostream& cout, Datum & d);
};

//ostream & operator<<(ostream& out, Datum & d){
//  out << *d.dan << "." << *d.mjesec << "." << *d.godina;
//  return out;
//}

//////////////////////////////////////KLASA PREGLED/////////////////////////////////////////////////

class Pregled{
protected:
    vector<char *> terapije;
    bool * zakazanNoviTermin; //u slucaju da je pacijent narucen na kontrolni pregled
    Datum datumPregleda;
public:
    //1. potrebne funkcije
    //DEF. KONSTRUKTOR
    Pregled(bool novit = 0, Datum d = Datum(1, 1, 2000))
    {
        zakazanNoviTermin = new bool;
        *zakazanNoviTermin = novit;
        datumPregleda = d;
    }
    //KONSTRUKTOR
    Pregled(char*t, bool novit = 0, Datum d = Datum(1, 1, 2000))
    {
        zakazanNoviTermin = new bool;
        *zakazanNoviTermin = novit;
        datumPregleda = d;
        AddTerapija(t);
    }
    //KONSTRUKTOR KOPIJE
    Pregled(Pregled & obj){
        zakazanNoviTermin = new bool;
        *zakazanNoviTermin = *(obj.zakazanNoviTermin); //provjeriti
        terapije = obj.terapije;
        datumPregleda = obj.datumPregleda;
    }
    //DESTRUKTOR
    ~Pregled(){
        delete zakazanNoviTermin;
        zakazanNoviTermin = NULL;//cout << "DESTRUKTOR PREGLED\n";
    }

    //2. Info :: ispisuje sve podatke o pregledu. Koristiti ostream_iterator. Prije ispisa sve terapije sortirati
    string info(){
        string out = "";
        out += "Datum pregleda: " + datumPregleda.Info() + "\n";

        vector<char*>::iterator it;
        for (it = terapije.begin(); it != terapije.end(); it++)
            out += "Terapija: " + toString(*it) + "\n";
        if (*zakazanNoviTermin)
            out += "Kontrolni pregled je zakazan\n";
        return out;
    }

    //3. AddTerapija :: dodaje novu terapiju. Onemoguciti ponavljanje terapija. Koristiti iteratore
    void AddTerapija(char* t){
        vector<char*>::iterator it;
        for (it = terapije.begin(); it != terapije.end(); it++)
        {
            if (strcmp(t, (*it)) == 0)
                return;
        }
        terapije.push_back(t);
        SortTerapije();
    }

    //4. RemoveTerapija :: uklanja sve terapije koje u sebi sadrze rijec primljenu kao parametar. Koristiti iteratore
    void RemoveTerapija(char* t){
        int lokacija = 0;
        vector<char*>::iterator it;
        for (it = terapije.begin(); it != terapije.end(); it++)
        {
            if (strcmp(t, (*it)) == 0)
            {
                terapije.erase(terapije.begin() + lokacija);//IT
            }
            else
                lokacija++;
        }
        SortTerapije();
    }

    //DODATNO////////////////////////////////////////////////////////////////////////////////////////////////////////
    vector<char*> getTerapije(){ return terapije; }
    Datum getDatumpregleda(){ return datumPregleda; }
    char* getTerapija(int lokacija) throw (exception){
        if (lokacija >= 0 && lokacija < terapije.size())
            throw exception("Lokacija ne postoji");
        else
            return terapije[lokacija];

    }
    void SortTerapije(){ sort(terapije.begin(), terapije.end()); }; //algorithm biblioteka
    //OPERATORI
    Pregled & operator=(Pregled& obj){
        if (this != &obj){
            zakazanNoviTermin = new bool;
            *zakazanNoviTermin = *(obj.zakazanNoviTermin); //provjeriti
            terapije = obj.terapije;
            datumPregleda = obj.datumPregleda;
        }
        return *this;
    }
    bool operator==(Pregled & obj){
        if (datumPregleda != obj.datumPregleda)
            return false;
        if (*zakazanNoviTermin != *obj.zakazanNoviTermin)
            return false;
        if (terapije != obj.terapije)
            return false;

        return true;
    }
    bool operator!=(Pregled & obj){ return !(*this == obj); }
};

//////////////////////////////////////KLASA PACIJENT////////////////////////////////////////////////

class Pacijent{
protected:
    const int pacijentID;
    char imePrezime[20];
    Kolekcija<string, Pregled> * preglediPacijenta;
    //tip string je za podatke o postavljenoj dijagnozi (jedna dijagnoza moze imati vise terapija)
    //objekat tipa Pregled je za podatke o terapijama, te o zakazanom pregledu

public:
    //KONSTRUKTOR 2 in 1(DEF i OBICNI)
    Pacijent(char * ip = "") : pacijentID(PACIJENT_ID){
        PACIJENT_ID++;
        strncpy_s(imePrezime, 19, ip, _TRUNCATE);
        preglediPacijenta = new Kolekcija<string, Pregled>();
    }
    //KONSTRUKTOR KOPIJE
    Pacijent(Pacijent& obj): pacijentID(PACIJENT_ID){
        PACIJENT_ID++;
        strcpy_s(imePrezime, 19, obj.imePrezime);
        imePrezime[19] = '\0';
        preglediPacijenta = new Kolekcija<string, Pregled>(*obj.preglediPacijenta);//konstruktor kopije Kolekcija
    }
    //DESTRUKTOR
    ~Pacijent(){
        //cout << "DESTRUKTOR PACIJENT\n";
        delete preglediPacijenta;
        preglediPacijenta = NULL;
    }

    //1. operator [] :: vraca Pregled kod koga je postavljena dijagnoza koja je proslijedjena kao
    // parametar. Dakle, operatorska funkcija prima dijagnozu kao parametar
    Pregled& operator[] (string dijagnoza) throw(exception)
    {
        for (int i = 0; i < preglediPacijenta->getTrenutno(); i++)
        if (dijagnoza.compare(preglediPacijenta->getT1byLokacija(i)) == 0)
            return preglediPacijenta->getT2byLokacija(i);
        throw exception("Pregled ne postoji");
    }

    //2. AddPregled :: dodaje podatke o novom pregledu pacijenta. Nije dozvoljeno dodati dva
    // identicna pregleda. U zavisnosti od uspjesnosti operacije, funkcija vraca true ili false
    bool AddPregled(string dijagnoza, Pregled * p){
        for (int i = 0; i < preglediPacijenta->getTrenutno(); i++)
        if (preglediPacijenta->getT2byLokacija(i) == *p)
            return false;
        return preglediPacijenta->AddElement(dijagnoza, *p);
    }

    //3. RemovePregledByDatum :: na osnovu primljenog parametra (tipa Datum) uklanja podatke o svim pregledima
    // koji su obavljeni odredjenog datuma. U zavisnosti od uspjesnosti operacije, funkcija vraca true ili
    // false
    bool RemovePregledByDatum(Datum d){
        bool uklonjeno = false;
        for (int i = 0; i < preglediPacijenta->getTrenutno(); i++)
        {
            if (d == preglediPacijenta->getT2byLokacija(i).getDatumpregleda())
            {
                preglediPacijenta->RemoveElement(preglediPacijenta->getT1byLokacija(i));
                uklonjeno = true;
                i--;
            }
        }
        return uklonjeno;
    }

    //4. RemovePregledByTerapija :: na osnovu primljenog parametra (terapije) uklanja podatke o svim
    // pregledima kod koji je propisana trazena terapija. U zavisnosti od uspjesnosti operacije,
    // funkcija vraca true ili false
    bool RemovePregledByterapija(char *terapija){
        bool uklonjeno = false;
        //int BrojPregleda = 0;
        for (int i = 0; i < preglediPacijenta->getTrenutno(); i++)
        {
            for (int j = 0; j < preglediPacijenta->getT2byLokacija(i).getTerapije().size(); j++)
            {
                if (strcmp(terapija, preglediPacijenta->getT2byLokacija(i).getTerapije()[j]) == 0)
                {
                    (*preglediPacijenta) -= (preglediPacijenta->getT2byLokacija(i));
                    i--;
                    break;
                }
            }
        }
        return uklonjeno;
    }

    //5. operator<< :: ispisuje vrijednosti svih atributa klase
    friend ostream& operator<< (ostream & out, Pacijent & obj);
};
ostream& operator<< (ostream & out, Pacijent & obj){
    out << "ID: [" << obj.pacijentID << "] - Ime i prezime: " << obj.imePrezime << crt;
    for (int i = 0; i < obj.preglediPacijenta->getTrenutno(); i++)
        out << "Dijagnoza: " << obj.preglediPacijenta->getT1byLokacija(i) << endl << obj.preglediPacijenta->getT2byLokacija(i).info() << "\n------------------------------------------\n";
    return out;
}
void main(){
    //Konstruiranje objekta tipa Pacijent i dodavanje pregleda
    Pacijent p("Mustafa Mustafic"); // konstruktor Pacijent

    //Info pacijenta
    cout << "\t\tPACIJENT" << crt << p;

    cout << "Dodavanje pregleda\n\n";
    p.AddPregled("Depresija", new Pregled("Antidepresiv 500mg", true, Datum(25, 01, 2014)));
    p.AddPregled("Migrena", new Pregled("Antimigrenik 250 mg", true, Datum(15, 01, 2014)));
    p.AddPregled("Nervoza", new Pregled("Oxetin 100 mg", false, Datum(15, 01, 2014)));
    p.AddPregled("Astma", new Pregled("Flexofen 100 mg", true, Datum(17, 01, 2014)));
    p.AddPregled("Laringitis", new Pregled("Kortikosteroid ampule 2ml", true, Datum(17, 01, 2014)));

    cout << "Dodavanje istog elementa -> onemoguceno\n\n";
    p.AddPregled("Laringitis", new Pregled("Kortikosteroid ampule 2ml", true, Datum(17, 01, 2014)));
    p.AddPregled("Laringitis", new Pregled("Kortikosteroid ampule 2ml", true, Datum(17, 01, 2014)));

    //Info pacijenta
    cout << "\t\tPACIJENT" << crt << p;

    cout << "Test RemovePregledByDatum\n- uklanjamo sve preglede navedenog datuma\n\n";
    p.RemovePregledByDatum(Datum(15, 01, 2014));
    cout << "\t\tPACIJENT" << crt << p;

    cout << "Test Dodavanje terapija\n\n";
    p["Depresija"].AddTerapija("Deksometazon 50mg");
    p["Depresija"].AddTerapija("Kortikosteroid ampule 2ml");
    p["Depresija"].AddTerapija("Glibenklamid 2g");

    p["Astma"].AddTerapija("Glibenklamid 2g");
    p["Astma"].AddTerapija("Budelin 1000mg");

    p["Laringitis"].AddTerapija("Budelin 1000mg");
    p["Laringitis"].AddTerapija("Baby Inhaler Pinque");
    cout << "\t\tPACIJENT" << crt << p;

    cout << "TEST RemovePregledByTerapija\n\n";
    p.RemovePregledByterapija("Budelin 1000mg");
    cout << "\t\tPACIJENT" << crt << p;


    //izbjegavajte koristenje vlastitog imena i prezimena.
    //provjeriti validnost izvrsenja svih dostupnih funkcionalnosti na objektu tipa Pacijent
}