12 years of slavery in OOP

//include try-catch in constructori!!!!
//sa respecte dimensiunea, tipul de date, etc.

/*
Tema 7. Se dau clasele:
-Locuință (string numeClient, int suprafataUtila, float discount)
-Apartament (int etaj) : Locuinta
-Casa (int suprafataCurte) : Locuinta

La clasa Locuinta se va adauga metoda virtuala pura CalculChirie (X,Y)
cu X = valoare standard chirie/mp(intreg), Y=1 daca se ia in considerare discountul
si 0 daca nu se ia in considerare.
Metoda va fi adaugata in clasa Apartament dupa formula X*suprafataUtila*(1-Y*discount/100.0),
respectiv in clasa Casa dupa formula X*(suprafataUtila + 0.2*suprafataCurte) * (1-Y*discount/100.0).
Metodele vor fi testate prin parcurgerea unui vector de pointeri la Locuinta *, incarcat
cu obiecte de tip Apartament si Casa.

Se defineste clasa AgentieImobiliara continand un vector de pointeri la obiecte de tip
Locuinta alocat dinamic. Se va supraincarca operatorul >> pentru a citi locuintele agentiei si
operatorul << pentru afisarea lor.

    CUM SE DAU DATELE?
-cate locuinte sunt disponibile in ag. im.
-pentru fiecare in parte:
    -nume client, suprafata utila, discount
    -ce tip de locuinta este: apartament/casa
    -(in fct. de tip: etaj, respectiv suprafata curte)
    -se aplica discount: da/nu !!!

    CE AI FACUT?
-supraincarcarea operatorului de citire (AgIm)
-supraincarcarea operatorului de afisare (AgIm)
-CalculChirie()
-destructori
-operatorii ">>"
-operatorii "<<"
-Clasele derivate sa aiba destructori
-Locuinta:
    -constructori de inițializare
    -parametrizați
    -și de copiere
    -operator ==
-Clasele derivate trebuie sa contina constructori parametrizati
(prin care sa se evidentieze transmiterea parametrilor catre constructorul
din clasa de baza)
-moșteniri & encapsulare (date private)
-constructori de inițializare
-parametrizați
-și de copiere
-funcții virtuale (este goala) [CalculChirie]
-operatorii „=”
-upcasting v
-downcasting v
-Utilizarea de variabile și de funcții statice

    CE MAI AI DE FACUT?
-exceptiile try-catch (faci si tu 2/3 exceptii)
-meniul !!!!!!
-AgentieImobiliara toate functiile !!

    CE NU E NEVOIE?
-smart pointers = shared_ptr //nu e nevoi
*/


#include <iostream>
#include <cstring>
#include <vector>
#include <typeinfo>
#define N 10001

using namespace std;


//==================== LOCUINTA ====================//
//clasa abstracta --->vazuta ca interfata ---> nu poate instantia obiecte
class Locuinta
{
    //encapsulare
public:
    string numeClient;
    int suprafataUtila;
    float discount;

public:
    virtual void citire();
    virtual void afisare();
    friend istream& operator>> (istream&, Locuinta&);
    friend ostream& operator<< (ostream&, Locuinta&);
    virtual float CalculChirie(int x, int y) = 0;

    bool operator== (Locuinta& l1)
    {
        return numeClient == l1.numeClient && suprafataUtila == l1.suprafataUtila && discount == l1.discount;
    }

    Locuinta& operator= (Locuinta& l)
    {
        if(this != &l)
        {
            this->numeClient = l.numeClient;
            this->suprafataUtila = l.suprafataUtila;
            this->discount = l.discount;
        }
        return *this;
    }

    //constructori:
    Locuinta()
    {
        numeClient = "";
        suprafataUtila = 0;
        discount = 0;
    }

    Locuinta(string s, int sU, float d)
    {
        int OK = 0;
        for(int i = 0; i < s.size() && OK < 2; ++i)
        {
            if(!isalpha(s[i]))
            {
                if(!OK && isspace(s[i]))
                {
                    OK = 1;
                }
                else
                {
                    OK = 2;
                }
            }
        }
        if(OK == 2)
            numeClient = "-";
        else
            numeClient = s;
        if(suprafataUtila < 0)
            suprafataUtila = -1;
        else
            suprafataUtila = sU;
        if(discount > 100)
            discount = -1;
        else
            discount = d;
        //numeClient = s;         //sa fie string valid
        //suprafataUtila = sU;    //daca su este < 0 -> eroare
        //discount = d;           //nu poate fi > 100%
    }

    Locuinta(const Locuinta& l)
    {
        numeClient = l.numeClient;
        suprafataUtila = l.suprafataUtila;
        discount = l.discount;
    }

    ///=> memory leak ------> se rezolva prin destructor virtual:
    virtual ~Locuinta()
    {
        cout << "~Locuinta \n";
    }
};

void Locuinta::citire()
{
    cout << "Nume client: ";
    cin >> numeClient;
    cout << "Suprafata utila: ";
    cin >> suprafataUtila;
    cout << "Discount: ";
    cin >> discount;
}

void Locuinta::afisare()
{
    cout << "Nume client: ";
    cout << numeClient << "\n";
    cout << "Suprafata utila: ";
    cout << suprafataUtila << "\n";
    cout << "Discount: ";
    cout << discount << "\n";
}

istream& operator>> (istream& in, Locuinta& l)
{
    cout << "Nume client: ";
    in >> l.numeClient;
    cout << "Suprafata utila: ";
    in >> l.suprafataUtila;
    cout << "Discount: ";
    in >> l.discount;
    return in;
}

ostream& operator<< (ostream& out, Locuinta& l)
{
    cout << "Nume client: ";
    out << l.numeClient << "\n";
    cout << "Suprafata utila: ";
    out << l.suprafataUtila << "\n";
    cout << "Discount: ";
    out << l.discount << "\n";
    return out;
}

//================== APARTAMENT ===================//
class Apartament: public Locuinta
{
public:
    int etaj;
public:
    void citire();
    void afisare();
    friend istream& operator>> (istream&, Apartament&);
    friend ostream& operator<< (ostream&, Apartament&);
    float CalculChirie(int x, int y);

    Apartament& operator= (Apartament& a)
    {
        if(this != &a)
        {
            this->Locuinta::operator=(a);
            this->etaj = a.etaj;
        }
        return *this;
    }

    bool operator== (Apartament& a)
    {
        return Locuinta::operator==(a) && etaj == a.etaj;
    }

    //constructori:
    Apartament():Locuinta()
    {
        etaj = 0;
    }
    Apartament(string s, int sU, float d, int e);

    ///destructor:
    ~Apartament()
    {
        cout << "~Apartament \n";
    }
};

Apartament:: Apartament(string s, int sU = 0, float d = 0, int e = 0): Locuinta(s, sU, d)
{
    if(etaj < 0)
        etaj = -1;
    else
        etaj = e;
}

void Apartament::citire()
{
    Locuinta::citire();
    cout << "Etaj: ";
    cin >> etaj;
}

void Apartament::afisare()
{
    cout << "Locuinta de tip: Apartament \n";
    Locuinta::afisare();
    cout << "Etaj: ";
    cout << etaj << "\n";
}

istream& operator>> (istream& in, Apartament& a)
{
    in >> dynamic_cast<Locuinta&> (a);
    cout << "Etaj: ";
    in >> a.etaj;
    return in;
}

ostream& operator<< (ostream& out, Apartament& a)
{
    out << "Locuinta de tip: Apartament \n";
    out << dynamic_cast<Locuinta&> (a);
    out << "Etaj: ";
    out << a.etaj << "\n";
    return out;
}


float Apartament::CalculChirie(int x, int y)
{
    float chirie;
    chirie = x * suprafataUtila * (1 - y * discount / 100.0);
    return chirie;
}

//===================== CASA =====================//
class Casa: public Locuinta
{
    int suprafataCurte;

public:
    void citire();
    void afisare();
    friend istream& operator>> (istream&, Casa&);
    friend ostream& operator<< (ostream&, Casa&);
    float CalculChirie(int x, int y);

    Casa& operator= (Casa& c)
    {
        if(this != &c)
        {
            this->Locuinta::operator=(c);
            this->suprafataCurte = c.suprafataCurte;
        }
        return *this;
    }

    //constructori:
    Casa():Locuinta()
    {
        suprafataCurte = 0;
    }

    Casa(string s, int sU, float d, int sC);

    ///destructor:
    ~Casa()
    {
        cout << "~Casa \n";
    }
};

Casa:: Casa(string s, int sU = 0, float d = 0, int sC = 0): Locuinta(s, sU, d)
{
    try
    {
        if(sU >= 0)
            suprafataCurte = sC; //throw 2;
        else
            throw 2;//suprafataCurte = sC;
    }
    catch(int x)
    {
        if(x == 2)
            cout <<"Valoarea introdusa pentru suprafata de curte este invalida! Aceasta nu poate fi un nr. negativ. \n";
    }

    //suprafataCurte = sC;
}

void Casa::citire()
{
    Locuinta::citire();
    cout << "Suprafata curte: ";
    cin >> suprafataCurte;
}

void Casa::afisare()
{
    cout << "Locuinta de tip: Casa \n";
    Locuinta::afisare();
    cout << "Suprafata curte: ";
    cout << suprafataCurte << "\n";
}

istream& operator>> (istream& in, Casa& c)
{
    in >> dynamic_cast<Locuinta&> (c);
    cout << "Suprafata curte: ";
    in >> c.suprafataCurte;
    return in;
}

ostream& operator<< (ostream& out, Casa& c)
{
    out << "Locuinta de tip: Casa \n";
    out << dynamic_cast<Locuinta&> (c);
    out << "Suprafata curte: ";
    out << c.suprafataCurte << "\n";
    return out;
}

float Casa::CalculChirie(int x, int y)
{
    float chirie;
    chirie = x * (suprafataUtila + 0.2 * suprafataCurte) * (1 - y * discount / 100.0);
    return chirie;
}


//=============== AGENTIE IMOBILIARA ===============//
class AgentieImobiliara
{
    vector<Locuinta*> L;      ///vector de pointeri la obiecte de tip Locuinta alocat dinamic
    int NR;

    //date statice:
    static int nrCase;
    static int nrApartamente;

public:
    void afisareChirie();
    friend istream& operator>>(istream&, AgentieImobiliara&);
    friend ostream& operator<<(ostream&, AgentieImobiliara&);

    //constructori:
    AgentieImobiliara()
    {
        NR = 0;
    }

    AgentieImobiliara(const AgentieImobiliara& ai)
    {
        NR = ai.NR;
        L = ai.L;
    }

    //destructor:
    ~AgentieImobiliara()
    {
        cout << "~AgentieImobiliara \n";
    }

    void addApartament()
    {
        L.push_back(new Apartament(""));
        L[NR]->citire();
        NR++;
        AgentieImobiliara::nrApartamente++;
    }

    void addCasa()
    {
        L.push_back(new Casa(""));
        L[NR]->citire();
        NR++;
        AgentieImobiliara::nrCase++;
    }

    //functii statice:
    static void afisNrCase()
    {
        cout << "In aceasta agentie imobiliara sunt " << nrCase << " case. \n";
    }
    static void afisNrApartamente()
    {
        cout << "in aceasta agentie imobiliara sunt " << nrApartamente << " apartamente. \n";
    }
};

int AgentieImobiliara::nrCase;
int AgentieImobiliara::nrApartamente;

istream& operator>> (istream& in, AgentieImobiliara& a)
{
    cout << "Cate locuinte sunt? \n";
    in >> a.NR;

    cout << "Care sunt acestea? \n";
    for(int i = 0; i < a.NR; i++)
    {
        int op;
        cout << "Tip de locuinta: 1-Apartament 2-Casa \n";
        in >> op;   //sa fie valid operatorul
        switch(op)
        {
        //upcasting
        case 1:
        {
            a.L.push_back(new Apartament(""));    //faci incrementare la nrApartamente
            a.L[i]->citire();
            AgentieImobiliara::nrApartamente++;
            break;
        }
        case 2:
        {
            a.L.push_back(new Casa(""));    //faci incrementare la nrCase
            a.L[i]->citire();
            AgentieImobiliara::nrCase++;
            break;
        }
        }
    }
    return in;
}

ostream& operator<< (ostream& out, AgentieImobiliara& a)
{
    int i = 1;
    out << "\n";
    out << "Agentia imobiliara are " << a.NR  << " locuinte: \n";
    for(auto p = a.L.begin(); p != a.L.end(); p++,i++)
    {
        out << i << ". ";
        if(typeid(**p) == typeid(Apartament))   //downcasting
        {
            out << * dynamic_cast<Apartament*>(*p) << "\n";
            //out << (* dynamic_cast<Apartament*>(*p)).CalculChirie(3, 1) << "\n";
        }

        else if(typeid(**p) == typeid(Casa))
        {
            out << * dynamic_cast<Casa*>(*p) << "\n";
            //out << (* dynamic_cast<Casa*>(*p)).CalculChirie(4, 1) << "\n";
        }
    }
    return out;
}

void AgentieImobiliara::afisareChirie()
{
    int i = 1;
    cout << "\n";
    cout << "Agentia imobiliara are " << NR  << " locuinte: \n";
    for(auto p = L.begin(); p != L.end(); p++,i++)
    {
        cout << i << ". ";
        if(typeid(**p) == typeid(Apartament))   //downcasting
        {
            //out << * dynamic_cast<Apartament*>(*p) << "\n";
            cout << (* dynamic_cast<Apartament*>(*p)).CalculChirie(3, 1) << "\n";
        }

        else if(typeid(**p) == typeid(Casa))
        {
            //out << * dynamic_cast<Casa*>(*p) << "\n";
            cout << (* dynamic_cast<Casa*>(*p)).CalculChirie(4, 1) << "\n";
        }
    }
}

//===================== MENIU =====================//
void AfisareMeniu()
{
    cout << "\n";
    cout << "Acesta este meniul aplicatiei. \n" << "Pentru a executa o anumita comanda apasati tasta corespunzatoare nr. din fata fiecarei operatii din lista de mai jos: \n";
    cout << "0. Opriti acest proces acum. \n"; //v
    cout << "1. Introduceti primele date in agentia imobiliara. \n"; //v
    cout << "2. Adaugati locuinte in agentie. \n"; //v
    cout << "3. Eliminati locuinte din agentie. \n";
    cout << "4. As vrea sa stiu cate case/apartamente sunt in agentia imobiliara. \n"; //v
    cout << "5. As vrea sa aflu de cate locuinte este interesat un anumit client. \n";
    cout << "6. Cautati optiunea ideala de locuinta. \n";
    cout << "7. Calculati pretul pentru fiecare locuinta in functie de pretul actual de pe piata. \n"; //trebuie facuta mai frumos!!
    cout << "8. Care este cea mai ieftina locuinta pusa la dispozitie? Dar cea mai scumpa? \n";
    cout << "9. Afisati toate locuintele din agentia imobiliara. \n"; //v
    cout << "10. --- \n";
    cout << "\n";
}


//===================== MAIN =====================//
int main()
{
    int OK;
    string S;
    float d;
    int etaj, sU;
    do
    {
        OK = 1;
        cin >> S >> sU >> d >> etaj;
        Apartament A(S, sU, d, etaj);
        try
        {
            if(A.numeClient == "-" || A.suprafataUtila == -1 || A.discount == -1 || A.etaj == -1)
            {
                throw 1;
            }
        }
        catch(int x)
        {
            cout << "Introduceti datele corect!\n";
            OK = 0;
        }
        if(!OK)
            A.~Apartament();
        else
            cout << A;
    }
    while(!OK);

    /*AfisareMeniu();
    cout << "Ce comanda doriti sa executati? \n";
    cin >> op;
    while(op)
    {
        try
        {
            if(op < 0 || op > 10)
                throw -1;
            else
            {
                //cout << "hai ca mere \n";
                if(op == 1)
                    cin >> A;
                if(op == 2)
                {
                    try
                    {
                        cout << "Ce tip de locuinta adaugati? 1-Apartament 2-Casa \n";
                        int tip;
                        cin >> tip;
                        if(tip == 1)
                            A.addApartament();
                        else if(tip == 2)
                            A.addCasa();
                        else
                            throw 10;
                    }
                    catch(int x)
                    {
                        if(x == 10)
                            cout << "Ne pare rau...Nu exista acest tip de locuinte. \n";
                    }
                }
                if(op == 4)
                {
                    try
                    {
                        cout << "Pentru ce tip de locuinta doriti sa aflati numarul? 1-Apartament 2-Casa \n";
                        int tip;
                        cin >> tip;
                        if(tip == 1)
                            A.afisNrApartamente();
                        else if(tip == 2)
                            A.afisNrCase();
                        else
                            throw 11;
                    }
                    catch(int x)
                    {
                        if(x == 11)
                            cout << "Ne pare rau...Nu exista acest tip de locuinte. \n";
                    }
                }

                if(op == 7)
                {
                    try
                    {
                        int pret;
                        cout << "Care este tariful actual pentru chirie /mp? (nr. intreg) \n";
                        cin >> pret;
                        if(pret > 0)
                            A.afisareChirie();
                        else
                            throw 23;
                    }
                    catch(int x)
                    {
                        if(x == 23)
                            cout << "Ne pare rau...Valoarea chiriei pe mp nu poate fi mai mica decat 0. \n";
                    }

                }

                if(op == 9)
                    cout << A;
            }
        }
        catch(int x)
        {
            if(x == -1)
            {
                cout << "Aceasta optiune nu este una valida. Mai incercati o data va rugam! \n";
            }
        }

        cout << "Ce comanda doriti sa executati? \n";
        cin >> op;
    }

    */
    return 0;
}



/*
try {
  // Block of code to try
  throw exception; // Throw an exception when a problem arise

  if(---ceva ce nu e bun---)
        throw 2; //de ex
}
catch (int x) {
  // Block of code to handle errors
  if(x == 2) //afiseaza eroarea;
}
*/