Pripreme 31.8.14

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int ID = 0;
template<class T1, class T2>
class Kolekcija{
protected:
    T1 * _elementi1;
    T2 * _elementi2;
    int * _max;
    int * _trenutnoElemenata;
public:
    Kolekcija(){
        _max = new int(3);
        _trenutnoElemenata = new int(0);
        _elementi1 = new T1[*_max];
        _elementi2 = new T2[*_max];
    }
    //Kolekcija(Kolekcija<T1, T2>& d){
    //  _max = new int(d->_max);
    //  _trenutnoElemenata = new int(d->_trenutnoElemenata);
    //  _elementi1 = new T1[*_max];
    //  _elementi2 = new T2[*_max];
    //  for (int i = 0; i < *_trenutnoElemenata; i++){
    //      _elementi1[i] = d._elementi1[i];
    //      _elementi2[i] = d._elementi2[i];
    //  }
    //}
    ~Kolekcija(){
        delete[]_elementi1;
        delete[]_elementi2;
        delete[]_max;
        delete[]_trenutnoElemenata;
    }
    T1& getT1(int lok){
        if (lok >= 0 && lok<*_trenutnoElemenata)
            return _elementi1[lok];
    }
    T2& getT2(int lok){
        if (lok >= 0 && lok < *_trenutnoElemenata)
            return _elementi2[lok];
    }
    void prosiri(){
        (*_max) += 3;
        T1 *temp1 = new T1[(*_max)];
        T2 *temp2 = new T2[(*_max)];
        for (int i = 0; i < *_trenutnoElemenata; i++)
        {
            temp1[i] = _elementi1[i];
            temp2[i] = _elementi2[i];
        }
        delete[]_elementi1;
        delete[]_elementi2;
        _elementi1 = temp1;
        _elementi2 = temp2;
    }
    bool ponavljase(T1 el1, T2 el2){
        bool a = false;
        for (int i = 0; i < *_trenutnoElemenata; i++)
        {
            if (_elementi1[i] == el1&&_elementi2[i] == el2)
                a = true;
        }
        return a;
    }
    int gettrenutno(){
        return *_trenutnoElemenata;
    }
    //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){
        if (ponavljase(el1, el2))
            return false;
        if (*_trenutnoElemenata == *_max)
            prosiri();
        _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){
        bool a = false;
        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)--;
                a = true;
            }
        }
        return a;
    }
    //bool operator==(Kolekcija<T1, T2> & obj) {

    //}

    //3. operator -= :: uklanja sve elemnte iz kolekcije koji su identicni onima koje posjeduje
    // drugi objekat tipa Kolekcija koji je primljen kao parametar. Funkcija vraca broj uklonjenih
    //elemenata
    int operator-=(Kolekcija<T1, T2> & obj) {
        int brojac = 0;
        for (int i = 0; i < *(obj._trenutnoElemenata); i++)
        {
            if (obj._elementi2[i] == _elementi2[i] && obj._elementi1[i] == _elementi1[i]) {
                RemoveElement(_elementi1[i]);
                brojac++;
            }
        }
        return brojac;
    }
    friend ostream &operator<< <>(ostream&, Kolekcija<T1, T2>&);
};
template<class T1,class T2>
ostream &operator<< <> (ostream& out, Kolekcija <T1, T2>& obj){
    for (int i = 0; i < *(obj._trenutnoElemenata); i++){
        out << obj._elementi1[i] << ": " << obj._elementi2[i] << endl;
    }
    return out;
}



class Datum{
protected:
    int _dan, _mjesec, _godina;
public:
    Datum(int d = 1, int m = 1, int g = 1900){
        _dan = d;
        _mjesec = m;
        _godina = g;
    }
    //Datum(Datum& d){
    //  _dan = d._dan;
    //  _mjesec = d._mjesec;
    //  _godina = d._godina;
    //}
    //1. potrebne funkcije

    Datum &operator=(Datum &d){
        if (this != &d){
            _dan = d._dan;
            _mjesec = d._mjesec;
            _godina = d._godina;
        }
        return *this;
    }
    bool operator==(Datum& d){
        if (_dan == d._dan&&_mjesec == _mjesec&&_godina == _godina){
            return true;
        }
        return false;
    }
    friend ostream &operator<<(ostream &, Datum);
};
ostream &operator<<(ostream &out, Datum d){
    out << d._dan << "." << d._mjesec << "." << d._godina;
    return out;
}

class Pregled{
protected:
    vector<char *> _terapije;
    bool * _zakazanNoviTermin; //u slucaju da je pacijent narucen na kontrolni pregled
    Datum _datumPregleda;
public:
    Pregled(bool a = false, Datum d = Datum(1, 1, 1900)){
        _zakazanNoviTermin = new bool(a);
        _datumPregleda = d;
    }
    Pregled(Pregled& d){
        _zakazanNoviTermin = new bool(d._zakazanNoviTermin);
        _datumPregleda = d._datumPregleda;
        _terapije = d._terapije;
    }
    ~Pregled(){
        //delete _zakazanNoviTermin;
        _zakazanNoviTermin = NULL;
    }

    //1. potrebne funkcije
    bool ponavljanje(char* t){
        for (vector<char*>::iterator it = _terapije.begin(); it != _terapije.end(); it++){
            if (strcmp(t, *it) == 0)
                return true;
        }
        /*for (int i=0; i<_terapije.size(); i++){
        if (strcmp(t, _terapije[i]) == 0)
        return true;
        }*/
        return false;
    }
    bool operator ==(Pregled &p){
        if (_terapije == p._terapije&&_datumPregleda == p._datumPregleda&&_zakazanNoviTermin == _zakazanNoviTermin)
            return true;
        return false;
    }

    //2. Info :: ispisuje sve podatke o pregledu. Koristiti ostream_iterator. Prije ispisa
    // sve terapije sortirati

    //void info(){
    //  cout << "Datum pregleda: " << _datumPregleda << endl << "Zakazan novi termin: ";
    //  if (*_zakazanNoviTermin)
    //      cout << "Da";
    //  else
    //      cout << "Ne";
    //  cout << endl << "Terapije:" << endl;
    //  for (vector<char*>::iterator it = _terapije.begin(); it != _terapije.end(); it++){
    //      cout << *it << endl;
    //  }
    //}
    void info(){
        sort(_terapije.begin(), _terapije.end());
        ostream_iterator<char*> out_it(cout, ", ");
            cout << "Datum pregleda: " << _datumPregleda << endl << "Zakazan novi termin: ";
            if (*_zakazanNoviTermin)
                cout << "Da";
            else
                cout << "Ne";
            cout << endl << "Terapije:" << endl;
        copy(_terapije.begin(), _terapije.end(), out_it);
    }

    //3. AddTerapija :: dodaje novu terapiju. Onemoguciti ponavljanje terapija. Koristiti iteratore
    void AddTerapija(char* t){
        if (ponavljanje(t) == false)
            _terapije.push_back(t);
    }
    //4. RemoveTerapija :: uklanja sve terapije koje u sebi sadrze rijec primljenu kao parametar.
    // Koristiti iteratore
    //void RemoveTerapija(char* t){
    //  for (int i = 0; i < _terapije.size(); i++){
    //      if (strstr(_terapije[i], t) != NULL){
    //          cout << "Brise terapiju: " << _terapije[i] << endl;
    //          _terapije.erase(_terapije.begin() + i);
    //      }
    //  }
    //}
    void RemoveTerapija(char*t){
        vector<char*>::iterator it;
        int brojac = 0;
        for (it = _terapije.begin(); it != _terapije.end();it++)
        {
            if (strstr(*it, t) != NULL){
                cout << "Brise terapiju: " << _terapije[brojac] << endl;
                it=_terapije.erase(_terapije.begin() + brojac);
                if (it == _terapije.end()) return; //U slucaju da smo dosli do kraja niza
            }
            brojac++;
        }
    }

    Datum vratidat(){
        return _datumPregleda;
    }
    friend ostream& operator<<(ostream&, Pregled&);
};
ostream& operator<<(ostream& out, Pregled& p){
    out << "Datum pregleda: " << p._datumPregleda << endl << "Zakazan novi termin: ";
    if (p._zakazanNoviTermin)
        out << "Da";
    else
        out << "Ne";
    out << endl << "Terapije;" << endl;
    for (vector<char*>::iterator it = p._terapije.begin(); it != p._terapije.end(); it++){
        out << *it<<endl;
    }
    return out;
}


class Pacijent{
protected:
    const int _pacijentID;
    char _imePrezime[20];
    //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
    Kolekcija<string, Pregled> * _preglediPacijenta;
public:
    Pacijent(char *ime = "<nepoznato>") :_pacijentID(++ID){
        strncpy_s(_imePrezime, 19, ime, _TRUNCATE);
        _preglediPacijenta = new Kolekcija<string, Pregled>;
    }
    //~Pacijent(){
    //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 dij){
        for (int i = 0; i < _preglediPacijenta->gettrenutno(); i++){
            if (dij.compare(_preglediPacijenta->getT1(i)) == 0)
                return _preglediPacijenta->getT2(i);
        }
    }
    //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 el1, Pregled &el2){
        return _preglediPacijenta->AddElement(el1, el2);
    }

    //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 &dat){
        bool jel =false;
        for (int i = 0; i < _preglediPacijenta->gettrenutno(); i++){
            if (_preglediPacijenta->getT2(i).vratidat() == dat){
                _preglediPacijenta->RemoveElement(_preglediPacijenta->getT1(i));
                jel = true;

            }
        }
        return jel;
    }

    //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*t){
        bool rem = false;
        for (int i = 0; i < _preglediPacijenta->gettrenutno(); i++){
            if (_preglediPacijenta->getT2(i).ponavljanje(t)){
                _preglediPacijenta->RemoveElement(_preglediPacijenta->getT1(i));
                rem = true;
            }
        }
        return rem;
    }

    //5. operator<< :: ispisuje vrijednosti svih atributa klase
    friend ostream & operator<< (ostream&, Pacijent&);
};
ostream & operator<< (ostream& out, Pacijent& p){
    out << "Pacijent ID: " << p._pacijentID << endl << "Ime i prezime:" << p._imePrezime << endl << "Pregledi pacijenta:" << endl;
        for (int j = 0; j < p._preglediPacijenta->gettrenutno(); j++){
            out << "Dijagnoza: "<<p._preglediPacijenta->getT1(j) << endl<<"Pregled: "<<endl << p._preglediPacijenta->getT2(j);
        }
    return out;
}
void main(){
    //izbjegavajte koristenje vlastitog imena i prezimena.
    //provjeriti validnost izvrsenja svih dostupnih funkcionalnosti na objektu tipa Pacijent
    Datum d1;
    Datum d2(20, 11, 2014);
    cout << d1 << endl << d2 << endl;
    Pregled * p1 = new Pregled;
    Pregled p2(true, d2);
    p1->AddTerapija("Terapija 1");
    p1->AddTerapija("Deseta terapija");
    p1->AddTerapija("Terapija 2");
    p1->AddTerapija("meso");
    p1->RemoveTerapija("meso");
    p2.AddTerapija("Neka terapija");
    p1->info();
    cout << endl;
    p2.info();
    cout << endl;
    Pacijent pac1;
    pac1.AddPregled("Prvi pregled", *p1);
    pac1.AddPregled("Drugi pregled", p2);
    cout << "Ispis pregleda operator[]" << endl;
    pac1["Prvi pregled"].info();
    Pregled pre(p2);
    pac1.AddPregled("Treci pregled", pre);
    pac1.AddPregled("Cetvrti pregled", *p1);
    pac1.RemovePregledByDatum(d2);
    cout << endl<<endl<<endl<<endl << "Ispis klase pacijent: " << endl << pac1 << endl;
    pac1.RemovePregledByTerapija("Terapija 1");
    cout << endl << endl << endl << endl << "Ispis klase pacijent nakon uklanjanja terapije: " << endl << pac1 << endl;
    Kolekcija<string, Pregled> kol1;
    Kolekcija<string, Pregled> kol2;

    kol1.AddElement("sarma", *p1);
    kol1.AddElement("meso", p2);
    kol1.AddElement("sogan", *p1);
    kol1.AddElement("dolma", p2);

    kol2.AddElement("ddd", *p1);
    kol2.AddElement("meso", p2);
    kol2.AddElement("sogan", p2);
    kol2.AddElement("dolma", p2);
    cout <<endl<<"Prije uklanjanja: "<<endl<< kol1<<endl;
    cout <<"Uklonjeno elemenata: "<< (kol1 -= kol2) << endl;
    cout <<endl<<"Poslje uklanjanja: "<<endl<< kol1;

    system("pause>0");
}