FirmaIT - Completed

#############################Angajati.h#############################
#pragma once

#include<iostream>
#include<string>
#include<cstring>
#include<vector>

using namespace std;

class Angajati{
private:
    char* post;
    char* numeAngajat;
    unsigned int wage;
    unsigned int varsta;
    unsigned int vechime;
public:
    Angajati();
    Angajati(char*, char*, unsigned int, unsigned int, unsigned int); // all attributes
    ~Angajati();
    void setPost(char*);
    void setNumeAngajat(char*);
    void setWage(unsigned int);
    void setVarsta(unsigned int);
    void setVechime(unsigned int);
    char* getPost();
    char* getNumeAngajat();
    unsigned int getWage();
    unsigned int getVarsta();
    unsigned int getVechime();
    bool operator=(Angajati&);
};
#############################Angajati.cpp#############################
#include"Angajati.h"

Angajati::Angajati(){
    strcpy(this->numeAngajat, NULL);
    strcpy(this->post, NULL);
    this->wage = 0;
    this->varsta = 0;
    this->vechime = 0;
}

Angajati::Angajati(char* postN, char* numeA, unsigned int wageNR, unsigned int varstaNR, unsigned int vechimeNR){
    this->numeAngajat = new char[50];
    this->post = new char[100];
    strcpy(this->numeAngajat, numeA);
    strcpy(this->post, postN);
    this->wage = wageNR;
    this->varsta = varstaNR;
    this->vechime = vechimeNR;
}

Angajati::~Angajati(){}

void Angajati::setPost(char * postName){
    this->post = new char[100];
    strcpy(this->post, postName);
}

void Angajati::setNumeAngajat(char * numeA){
    this->numeAngajat = new char[50];
    strcpy(this->numeAngajat, numeA);
}

void Angajati::setWage(unsigned int number){
    this->wage = number;
}

void Angajati::setVarsta(unsigned int number){
    this->varsta = number;
}

void Angajati::setVechime(unsigned int number){
    this->vechime = number;
}

char* Angajati::getPost(){
    return this->post;
}

char* Angajati::getNumeAngajat(){
    return this->numeAngajat;
}

unsigned int Angajati::getWage(){
    return this->wage;
}

unsigned int Angajati::getVarsta(){
    return this->varsta;
}

unsigned int Angajati::getVechime(){
    return this->vechime;
}

bool Angajati::operator=(Angajati& AngajatSecundar){
    if (this->numeAngajat == NULL || this->post == NULL || this->wage == 0 || this->varsta == 0)
        return false;
    strcpy(this->post, AngajatSecundar.getPost());
    strcpy(this->numeAngajat, AngajatSecundar.getNumeAngajat());
    this->wage = AngajatSecundar.getWage();
    this->varsta = AngajatSecundar.getVarsta();
    this->vechime = AngajatSecundar.getVechime();
    return true;
}

#############################Departament.h#############################
#include"Angajati.h"

class Departament{
private:
    char * numeDepartament;
    vector<Angajati> Employers;
    unsigned int employersCount;
    unsigned int employersLimit;
public:
    Departament();
    Departament(char*, unsigned int); // name and limit
    ~Departament();
    bool addEmployed(Angajati&);
    Departament fireEmployed(char*); // dupa nume
    char* getNumeDepartament();
    vector<Angajati> getAngajati();
    void setEmployersLimit(unsigned int);
    unsigned int getEmpCount();
    unsigned int getEmpLimit();
    void setNumeDepartament(char*);
    bool operator =(Departament&);
};
#############################Departament.cpp#############################
#include"Departament.h"

Departament::Departament(){
    this->employersLimit = 150;
    this->employersCount = 0;
    this->Employers.clear();
    strcpy(this->numeDepartament, NULL);
}

Departament::Departament(char* numeD, unsigned int limit){
    this->Employers.clear();
    this->employersCount = 0;
    this->employersLimit = limit;
    this->numeDepartament = new char[100];
    strcpy(this->numeDepartament, numeD);
}

Departament::~Departament(){}

bool Departament::addEmployed(Angajati& angajat){
    if (this->employersCount == this->employersLimit)
        return false;
    this->Employers.push_back(angajat);
    this->employersCount++;
    return true;
}

Departament Departament::fireEmployed(char* deConcediat){
    if (this->employersCount == 0)
        return *this;
    for (unsigned int i = 0; i < this->Employers.size(); i++){
        if (Employers[i].getNumeAngajat() == deConcediat)
            Employers.erase(Employers.begin() + i);
    }
    return *this;
}// dupa nume

char* Departament::getNumeDepartament(){
    return this->numeDepartament;
}

vector<Angajati> Departament::getAngajati(){
    return this->Employers;
}

void Departament::setEmployersLimit(unsigned int number){
    this->employersLimit = number;
}

unsigned int Departament::getEmpCount(){
    return this->employersCount;
}

unsigned int Departament::getEmpLimit(){
    return this->employersLimit;
}

void Departament::setNumeDepartament(char * numeD){
    this->numeDepartament = new char[100];
    strcpy(this->numeDepartament, numeD);
}

bool Departament::operator =(Departament& departament){
    if (departament.getNumeDepartament() == NULL || departament.getEmpLimit() == 0)
        return false;
    strcpy(this->numeDepartament, departament.getNumeDepartament());
    this->employersCount = departament.getEmpCount();
    this->employersLimit = departament.getEmpLimit();
    this->Employers = departament.getAngajati();
    return true;
}

#############################FirmaIT.h#############################

#include"Departament.h"

class FirmaIT{
private:
    char* numeFirma;
    char* adresaFirma;
    vector<Departament> Departamente;
    unsigned int contorDepartamente;
    unsigned int limitaDepartamente;
public:
    FirmaIT();
    FirmaIT(char*, char*, unsigned int); // name, address and limit
    ~FirmaIT();
    bool adaugaDepartament(Departament&);
    FirmaIT inchideDepartament(char*); // dupa nume
    vector<Departament> getDepartamente();
    void setLimitaD(unsigned int);
    unsigned int getLimitaD();
    unsigned int getContorD();
    void setNumeFirma(char*);
    void setAdresaFirma(char*);
    char* getNumeFirma();
    char* getAdresaFirma();
    bool operator =(FirmaIT&);
};



#############################FirmaIT.cpp#############################
#include"FirmaIT.h"

FirmaIT::FirmaIT(){
    strcpy(this->numeFirma, NULL);
    strcpy(this->adresaFirma, NULL);
    this->Departamente.clear();
    this->limitaDepartamente = 10;
    this->contorDepartamente = 0;
}

FirmaIT::FirmaIT(char* numeD, char* adresaD, unsigned int limita){
    this->numeFirma = new char[30];
    this->adresaFirma = new char[100];
    strcpy(this->numeFirma, numeD);
    strcpy(this->adresaFirma, adresaD);
    this->Departamente.clear();
    this->limitaDepartamente = limita;
    this->contorDepartamente = 0;
}

FirmaIT::~FirmaIT(){}

bool FirmaIT::adaugaDepartament(Departament& departament){
    if (this->contorDepartamente == this->limitaDepartamente)
        return false;
    this->Departamente.push_back(departament);
    this->contorDepartamente++;
    return true;
}

FirmaIT FirmaIT::inchideDepartament(char* deInchis){
    if (this->contorDepartamente == 0)
        return *this;
    for (unsigned int i = 0; i < this->Departamente.size(); i++){
        if (Departamente[i].getNumeDepartament() == deInchis)
            Departamente.erase(Departamente.begin() + i);
    }
    return *this;
} // dupa nume

vector<Departament> FirmaIT::getDepartamente(){
    return this->Departamente;
}

void FirmaIT::setLimitaD(unsigned int numar){
    this->limitaDepartamente = numar;
}

unsigned int FirmaIT::getLimitaD(){
    return this->limitaDepartamente;
}

unsigned int FirmaIT::getContorD(){
    return this->contorDepartamente;
}

void FirmaIT::setNumeFirma(char* nume){
    this->numeFirma = new char[30];
    strcpy(this->numeFirma, nume);
}

void FirmaIT::setAdresaFirma(char* adresa){
    this->adresaFirma = new char[100];
    strcpy(this->adresaFirma, adresa);
}

char* FirmaIT::getNumeFirma(){
    return this->numeFirma;
}

char* FirmaIT::getAdresaFirma(){
    return this->adresaFirma;
}

bool FirmaIT::operator =(FirmaIT& firma){
    if (firma.getAdresaFirma() == NULL || firma.getNumeFirma() == NULL || firma.getLimitaD() == 0)
        return false;
    strcpy(this->numeFirma, firma.getNumeFirma());
    strcpy(this->adresaFirma, firma.getAdresaFirma());
    this->limitaDepartamente = firma.getLimitaD();
    this->contorDepartamente = firma.getContorD();
    this->Departamente = firma.getDepartamente();
    return true;
}

#############################main.cpp#############################
#include"FirmaIT.h"

void main(void){
    Angajati Emp1("Post", "Nume angajat", 2500, 20, 2);
    Departament Dep1("Nume departament", 15);
    Dep1.addEmployed(Emp1);
    FirmaIT Firm1("Nume firma", "Adresa", 4);
    Firm1.adaugaDepartament(Dep1);

    vector<Departament> ListaDepartamente = Firm1.getDepartamente(); // diferentierea e absolut necesara
    vector<Angajati> ListaAngajati1 = Dep1.getAngajati(); // la fel si aici

    printf("Firma %s, avand adresa %s, detine %d departamente, iar acestea fiind:\n", Firm1.getNumeFirma(), Firm1.getAdresaFirma(), Firm1.getContorD());
    for (unsigned int i = 0; i < Firm1.getContorD(); i++)
        printf("-%s\n", ListaDepartamente[i].getNumeDepartament());
    printf("Departamentul %s are urmatorii angajati:\n", ListaDepartamente[0].getNumeDepartament());
    for (unsigned int i = 0; i < Dep1.getEmpCount(); i++)
        printf("-Nume: %s, Post: %s, Varsta: %d, Vechime: %d, Salariu: %d\n", ListaAngajati1[i].getNumeAngajat(), ListaAngajati1[i].getPost(), ListaAngajati1[i].getVarsta(), ListaAngajati1[i].getVechime(), ListaAngajati1[i].getWage()); // toate datele despre angajati
}