pr2 int1k v1

#include <iostream>
#include <string>
#include <regex>
using namespace std;

char crt[] = { "-----------------------------\n" };
////////////////////////////////////////////////////////////////
template<class T1, class T2>
class Kolekcija{
    T1 * _elementi1;
    T2 * _elementi2;
    int _trenutnoElemenata;
public:
    Kolekcija(){
        _elementi1 = nullptr;
        _elementi2 = nullptr;
        _trenutnoElemenata = 0;
    }
    ~Kolekcija(){
        delete[]_elementi1;
        delete[]_elementi2;
        _elementi1 = nullptr;
        _elementi2 = nullptr;
    }
    Kolekcija(const Kolekcija & obj){
        _trenutnoElemenata = obj._trenutnoElemenata;
        _elementi1 = new T1[_trenutnoElemenata];
        _elementi2 = new T2[_trenutnoElemenata];

        for (int i = 0; i < _trenutnoElemenata; i++){
            _elementi1[i] = obj._elementi1[i];
            _elementi2[i] = obj._elementi2[i];
        }
    }
    ///////////////////////////////////////////////////////////////
    void addElement(T1 e1, T2 e2){
        // AddElement::omogucava dodavanje novog elementa u kolekciju.Osigurati automatsko
        //  prosiranje kolekcije prilikom dodavanja svakog novog elementa, te onemoguciti ponavljanje elemenata.

        // provjeriti ima li elemenata u kolekciji
        for (int i = 0; i < _trenutnoElemenata; i++){
            if (_elementi1[i] == e1 ){
                // nasao je isti element, baciti izuzetak
                throw exception("1 - Element je vec dodan u kolekciju!");
            }
        }
        // nema elemenata u kolekciji dodati
        // napraviti novi niz veci
        T1 * temp1 = new T1[_trenutnoElemenata + 1];
        T2 * temp2 = new T2[_trenutnoElemenata + 1];
        // kopirati elemente u nove nizove
        for (int i = 0; i < _trenutnoElemenata; i++){
            temp1[i] = _elementi1[i];
            temp2[i] = _elementi2[i];
        }
        // obrisati stare nizove
        delete[]_elementi1;
        delete[]_elementi2;
        // neka stari nizovi pokazuju na nove temp
        _elementi1 = temp1;
        _elementi2 = temp2;

        // dodati novi element
        _elementi1[_trenutnoElemenata] = e1;
        _elementi2[_trenutnoElemenata] = e2;

        // uvecati brojac
        _trenutnoElemenata++;
    }
    void removeElement(T1 element){
        // RemoveElement::na osnovu parametra tipa T1 uklanja elemente iz kolekcije i smanjuje velicinu niza.
        //  Ukoliko je potrebno, prilikom uklanjanja elementa izvrsiti dealokaciju.Prilikom uklanjanja elemenata ocuvati redoslijed njihovog dodavanja.

        // vidjeti ima li element u kolekciji
        for (int i = 0; i < _trenutnoElemenata; i++){
            if (_elementi1[i] == element){
                T1 * temp1 = new T1[(_trenutnoElemenata - 1)];
                T2 * temp2 = new T2[(_trenutnoElemenata - 1)];
                // kopirati u novi do elementa
                for (int j = 0; j < i; j++){
                    temp1[j] = _elementi1[j];
                    temp2[j] = _elementi2[j];
                }
                // kopiralo je do i sada i+1
                for (int j = i; j < (_trenutnoElemenata - 1); j++){
                    temp1[j] = _elementi1[j+1];
                    temp2[j] = _elementi2[j+1];
                }

                // obrisati stare nizove
                delete[]_elementi1;
                delete[]_elementi2;
                _elementi1 = temp1;
                _elementi2 = temp2;
                _trenutnoElemenata--;
                return;
            }
        }
        // nije pronasao element baciti exc
        throw exception("2 - Element nije pronadjen u kolekciji!");
    }
    void info(){
        cout << crt << "\tKOLEKCIJA\n" << crt;
        for (int i = 0; i < _trenutnoElemenata; i++){
            cout << _elementi1[i] << " - " << _elementi2[i] << endl;
        }
    }
    Kolekcija & operator =(const Kolekcija & obj){
        _trenutnoElemenata = 0;
        delete[]_elementi1;
        delete[]_elementi2;

        for (int i = 0; i < obj._trenutnoElemenata; i++){
            _elementi1[i] = obj._elementi1[i];
            _elementi2[i] = obj._elementi2[i];
        }
        return *this;
    }
    Kolekcija operator + (const Kolekcija<T1,T2> & obj){
        //3. operator+ ::vraca objekat tipa Kolekcija koji u sebi sadrzi sve elemente objekta koji je
        //  pozvao funkciju i objekta koji je proslijedjen kao parametar(takodjer tipa Kolekcija), pri cemu se
        //  elementi unutar kreirane kolekcije ne smiju ponavljati(ne smiju postojati dva ista elementa).

        Kolekcija temp;
        int tempMax = _trenutnoElemenata + obj._trenutnoElemenata;

        // kolekcija koja poziva
        for (int i = 0; i < _trenutnoElemenata; i++)
            temp.addElement(_elementi1[i], _elementi2[i]);

        int j = 0;
        for (int i = _trenutnoElemenata; i < tempMax; i++){
            temp.addElement(obj._elementi1[j], obj._elementi2[j]);
            j++;

        }

        return temp;
    }
    int getTrenutno()const{
        // potrebno da vidimo ima li elemenata u kolekciji, npr je li 1 student pristupio ispitu
        return _trenutnoElemenata;
    }
    T1 getElement1(int id){
        return _elementi1[id];
    }
    T2 getElement2(int id){
        return _elementi2[id];
    }
};
class Student{
    static int _brojStudenata;
    const int _brojIndeksa;
    string _ime;
    string _prezime;
    string _korisnickomIme;
    string _lozinka;

public:
    Student() :_brojIndeksa(++_brojStudenata){}
    Student(char * ime, char *prezime) :_brojIndeksa(++_brojStudenata){
        _ime = ime;
        _prezime = prezime;

        _korisnickomIme = ime;
        _korisnickomIme += ".";
        _korisnickomIme += prezime;

        bool tacno = false;
        string pravilo = "(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[$*@_,])(?=.{7,})";

        do{
            cout << "Unesi lozinku koja ne sadrzi ime i prezime: ";
            getline(cin, _lozinka);

            if (regex_search(_lozinka, regex(pravilo))){
                pravilo = "(?:(" +_ime + "|" + _prezime + "))";
                if (!regex_search(_lozinka, regex(pravilo))){
                    // dobra je lozinka, ne zaboravi uzvicnik u search
                    tacno = true;
                }

            }
        } while (tacno == false);
    }
    Student(const Student & obj):_brojIndeksa(++_brojStudenata){
        _ime = obj._ime;
        _prezime = obj._prezime;
        _korisnickomIme = obj._korisnickomIme;
        _lozinka = obj._lozinka;
    }
    void info(){
        cout << crt << "\tSTUDENT\n" << crt;
        cout << "IME PREZIME: " << _ime << " " << _prezime << endl;
        cout << "USERNAME:    " << _korisnickomIme << endl;
        cout << "PASSWORD:    ";
        for (int i = 0; i < _lozinka.size(); i++) cout << "*";
        cout << endl << crt;
    }
    // trebaju operatori []== =
    Student &operator =(const Student & obj){
        _ime = obj._ime;
        _prezime = obj._prezime;
        _korisnickomIme = obj._korisnickomIme;
        _lozinka = obj._lozinka;
        return *this;
    }
    bool operator == (const Student & obj){
        if (_ime == obj._ime && _prezime == obj._prezime) return true;
        return false;
    }
    friend ostream & operator <<(ostream & cout, const Student & student);
};
class Ispit{
    // tip string u kolekciji sluzi kao
protected:
    char * _opis; //npr. PR2::Integralni::30.01.2015
    Kolekcija<Student, string> * _listaStudenata;

public:
    Ispit(){
        _opis = nullptr;
        _listaStudenata = new Kolekcija < Student, string >;
    }
    Ispit(char * opis){
        int vel = strlen(opis) + 1;
        _opis = new char[vel];
        strcpy_s(_opis, vel, opis);

        _listaStudenata = new Kolekcija < Student, string > ;

    }
    Ispit(const Ispit& obj){
        int vel = strlen(obj._opis) + 1;
        _opis = new char[vel];
        strcpy_s(_opis, vel, obj._opis);
        // kkopije od kolekcije
        _listaStudenata = new Kolekcija<Student, string>(*obj._listaStudenata);
    }
    ~Ispit(){
        dealociraj();
    }
    void dealociraj(){
        delete[]_opis;
        delete _listaStudenata;
        _opis = nullptr;
        _listaStudenata = nullptr;
    }
    //////////////////////////////////////////////////////////////////////////////
    void info(){
        cout << crt << "\tISPIT\n" << crt;
        cout << _opis << endl;
        _listaStudenata->info();
    }
    void addStudent(const Student & student, string poruka = "------"){
        // 1. AddStudent :: dodaje podatke o studentu koji je pristupio ispitu uz odgovarajucu napomenu
        //    (napomena nije obavezna) napomena vezana za ponasanje studenta na ispitu gdje ce se evidentirati
        //       utisci dezurnog nastavnika npr.kasnio, dosao bez indeksa, izbacen zbog prepisivanja

        //    Studentu nije dozvoljeno da dva puta pristupi istom ispitu, a u slucaju da pokusa
        //    pristupiti automatski se dodaje adekvatna napomena (npr. ponovo pokusao pristupiti).

        _listaStudenata->addElement(student, poruka);
    }
    bool operator == (const Ispit & ispit){
        if (strcmp(_opis, ispit._opis) == 0) return true;
        return false;
    }
    int getTrenutno()const{
        return _listaStudenata->getTrenutno();
    }
    Student & getElement1(int id){
        return _listaStudenata->getElement1(id);
    }
    string getElement2(int id){
        return _listaStudenata->getElement2(id);
    }
    Ispit & operator = (const Ispit & obj){
        delete[] _opis;
        int vel = strlen(obj._opis) + 1;
        _opis = new char[vel];
        strcpy_s(_opis, vel, obj._opis);

        delete _listaStudenata;
        _listaStudenata = obj._listaStudenata;
        return *this;
    }
    friend ostream &  operator << (ostream & cout, const Ispit & ispit);
};
class Predmet{
    char * _nazivPredmeta;
    char * _profesor;
public:
    Predmet(char * nazivPredmeta = "-------", char * profesor = "-------"){
        int vel = strlen(nazivPredmeta) + 1;
        _nazivPredmeta = new char[vel];
        strcpy_s(_nazivPredmeta, vel, nazivPredmeta);

        vel = strlen(profesor) + 1;
        _profesor = new char[vel];
        strcpy_s(_profesor, vel, profesor);
    }
    Predmet(const Predmet & obj){
        int vel = strlen(obj._nazivPredmeta) + 1;
        _nazivPredmeta = new char[vel];
        strcpy_s(_nazivPredmeta, vel, obj._nazivPredmeta);

        vel = strlen(obj._profesor) + 1;
        _profesor = new char[vel];
        strcpy_s(_profesor, vel, obj._profesor);
    }
    ~Predmet(){
        delete[] _nazivPredmeta;
        delete[]_profesor;
        _nazivPredmeta = nullptr;
        _profesor = nullptr;
    }
    void info(){
        cout << crt << "\tPREDMET\n" << crt;
        cout << "PREDMET:  " << _nazivPredmeta << endl;
        cout << "PROFESOR: " << _profesor << endl;
    }
    bool operator == (const Predmet & obj){
        if (strcmp(_nazivPredmeta, obj._nazivPredmeta) == 0) return true;
        return false;
    }
    Predmet & operator = (const Predmet & obj){
        delete[] obj._nazivPredmeta;
        delete[] obj._profesor;

        int vel = strlen(obj._nazivPredmeta) + 1;
        _nazivPredmeta = new char[vel];
        strcpy_s(_nazivPredmeta, vel, obj._nazivPredmeta);

        vel = strlen(obj._profesor) + 1;
        _profesor = new char[vel];
        strcpy_s(_profesor, vel, obj._profesor);
        return *this;
    }
    friend ostream & operator <<(ostream & cout, const Predmet & predmet);
};
class SkolskaGodina{
    char * _skolskaGodina; //npr.2014/2015
    Kolekcija<Predmet, Ispit> * _odrzaniIspiti;
public:
    SkolskaGodina(char * skolskaGodina = "----/----"){
        int vel = strlen(skolskaGodina) + 1;
        _skolskaGodina = new char[vel];
        strcpy_s(_skolskaGodina, vel, skolskaGodina);

        _odrzaniIspiti = new Kolekcija < Predmet, Ispit >;
    }
    ~SkolskaGodina(){
        delete[] _skolskaGodina;
        delete _odrzaniIspiti;

        _skolskaGodina = nullptr;
        _odrzaniIspiti = nullptr;
    }
    void addIspit(const Predmet & predmet, const Ispit & ispit){
        // addIspit::dodate podatke o odrzanom ispitu na odredjenom predmetu
        _odrzaniIspiti->addElement(predmet, ispit);
    }
    ///////////////////////////////////////////
    void removeIspit(const Ispit & ispit){
        // RemoveIspit: : uklanja podatke o odrzanom ispitu, ali samo pod uslovom da tom ispitu nije pristupio niti jedan student
        // for petlja da prodjemo kroz kolekciju
        for (int i = 0; i < _odrzaniIspiti->getTrenutno(); i++){
            // trazimo ispite koji odgovaraju ispitu arugmentu
            if (_odrzaniIspiti->getElement2(i) == ispit){
                // provjera ima li na ispitu 0 studenata
                if (_odrzaniIspiti->getElement2(i).getTrenutno() == 0){
                    // bilo je nula moze se brisati
                    _odrzaniIspiti->removeElement(_odrzaniIspiti->getElement1(i));
                    return;
                }
                else throw exception("3 - Na ispit su prijavljeni studenti!\nNe moze se obrisati ispit!");
            }
        }
        throw exception("4 - Nije pronadjen zadati ispit!\n");
    }
    int getBrojIzlazakaByPredmet(const Predmet & predmet, const Student & student){
        //GetBrojIzlazakaByPredmet::vraca podatak o tome koliko je puta trazeni student
        // izasao na ispit iz odredjenog predmeta u toku skolske godine

        int brojac = 0;
        for (int i = 0; i < _odrzaniIspiti->getTrenutno(); i++){
            // sada za svaki predmet for petlju i
            if (_odrzaniIspiti->getElement1(i) == predmet){
                // nasli smo trazeni predmet, sada treba prebrojati koliko se puta na ispitima iz tog predmeta nalazi prijavljen studnet
                for (int j = 0; i < _odrzaniIspiti->getElement2(i).getTrenutno(); j++){
                    if (_odrzaniIspiti->getElement2(i).getElement1(j) == student){
                        // odrzani_ispiti(predmet,ispit) ispit je element2 i iz njega imamo (studente i opise)
                        // pronasao studenta povecaj brojac
                        brojac++;
                    }
                }
            }
        }
        return 0;
    }
    vector<Student> operator ()(string parametar){
        // operator() ::vraca sve studente koji u napomeni posjeduju sadrzaj koji je proslijedjen kao parametar
        // (npr.listu svih studenata koji u napomeni posjeduju sadrzaj "bez indeksa")
        vector<Student> nazadStudenti;
        for (int i = 0; i < _odrzaniIspiti->getTrenutno(); i++){
            for (int j = 0; j < _odrzaniIspiti->getElement2(i).getTrenutno(); j++){
                // sada se nalazimo u _listaStudenata<Student,opis>
                if (_odrzaniIspiti->getElement2(i).getElement2(j) == parametar){
                    // parametri odnosno opisi su jednaki, dodaj studenta u vektor
                    nazadStudenti.push_back(_odrzaniIspiti->getElement2(i).getElement1(j));
                }
            }
        }
        return nazadStudenti;
    }
    friend ostream & operator <<(ostream & cout, const SkolskaGodina & godina);

};
////////////////////////////////////////////////////////////////
int Student::_brojStudenata = 0;
ostream & operator <<(ostream & cout, const Student & student){
    cout << crt << "\tSTUDENT\n" << crt;
    cout << "IME PREZIME: " << student._ime << " " << student._prezime << endl;
    cout << "USERNAME:    " << student._korisnickomIme << endl;
    cout << "PASSWORD:    ";
    for (int i = 0; i < student._lozinka.size(); i++) cout << "*";
    cout << endl << crt;
    return cout;
}
ostream &  operator << (ostream & cout, const Ispit & ispit){
    cout << crt << "\tPREDMET\n" << crt;
    cout << "NAZIV PREDMETA: " << ispit._opis << endl;
    for (int i = 0; i < ispit._listaStudenata->getTrenutno(); i++){
        cout << ispit._listaStudenata->getElement1(i);
    }
    return cout;
}
ostream & operator <<(ostream & cout, const Predmet & predmet){
    cout << crt << "\tPREDMET\n" << crt;
    cout << "PREDMET:  " << predmet._nazivPredmeta << endl;
    cout << "PROFESOR: " << predmet._profesor << endl;
    return cout;
}
ostream & operator <<(ostream & cout, const SkolskaGodina & godina){
    // operator<<:: ispisuje sve dostupne podatke o odrzanim ispitima i studentima koji su im pristupili
    for (int i = 0; i < godina._odrzaniIspiti->getTrenutno(); i++){
        // ispisuje predmete u kolekciji
        cout << godina._odrzaniIspiti->getElement1(i);
        for (int j = 0; j < godina._odrzaniIspiti->getElement2(i).getTrenutno(); j++){
            //ispisuje ispite u kolekciji
            cout << godina._odrzaniIspiti->getElement2(j);
            for (int z = 0; z < godina._odrzaniIspiti->getElement2(j).getTrenutno(); z++){
                // ispisuje studente
                cout << godina._odrzaniIspiti->getElement2(j).getElement1(z);
            }
        }
    }
    return cout;
}
////////////////////////////////////////////////////////////////

int main(){
    try{









        Student s1("Nedim", "Fejzic");
        Student s2("Saldina", "Nurak");
        Student s3("Mirnes", "Turkovic");

        Ispit ispit("PR2::Integralni::30.01.2015");
        ispit.addStudent(s1, "obecava mali");
        ispit.addStudent(s2, "pitati ce za pomoc");
        ispit.addStudent(s3, "ne smije pristupiti");
        // ispit.addStudent(s3, "ne smije pristupiti");

        Predmet pr1("Programiranje 1", "Denis Music");
        Predmet pr2("Programiranje 2", "Denis Music");

        SkolskaGodina ova("2014/2015");
        ova.addIspit(pr2, ispit);


    }
    catch (exception & err){
        cout << "GRESKA! - " << err.what() << endl;
    }

    system("pause > null");
    return 0;
}