Lab3

#include <iostream>
#include "TablicaPracownikow.h"

using namespace std;

int main()
{
    char c {};
    TablicaPracownikow pracow;
    while (c != 'q')
    {
        switch (c)
        {
        case 'd': {
            Pracownik temp;
            temp.Wpisz();
            pracow.Dodaj(temp);
            cout << "Dodano pracownika \n";
        } break;

        case 'u': {
            char imie[20];
            char nazwisko[20];
            cout << "Wpisz dane pracownika do usuniecia Imie-Nazwisko: ";
            cin >> imie >> nazwisko;

            const Pracownik *p = pracow.Szukaj(nazwisko, imie);
            if (p != nullptr)
            {
                pracow.Usun(*p);
                cout << "Usunieto pracownika: " << imie << " " << nazwisko<< endl;
                break;
            }
            cout << "Nie ma takiego pracownika! \n";
        } break;
        case 'w':
        {
            pracow.WypiszPracownikow();
        } break;
        case 's':
        {
            char imie[20];
            char nazwisko[20];
            cout << "Wpisz dane pracownika do szukania Imie-Nazwisko: ";
            cin >> imie >> nazwisko;

            const Pracownik *s = pracow.Szukaj(nazwisko, imie);
            if (s != nullptr)
            {
                cout << "Znaleziono pracownika: \n";
                s->Wypisz();
                //(*s).Wypisz();
                break;
            }
            cout << "Nie znaleziono pracownika \n";
        } break;
        case 'x':
        {
            Data d;
            cout << "Wpisz date urodzenia: ";
            d.Wpisz();
            const Pracownik *e = pracow.Szukaj(d);
            if (e != nullptr)
            {
                cout << "Znaleziono pracownika: \n";
                e->Wypisz();
                //(*s).Wypisz();
                break;
            }
            cout << "Nie znaleziono pracownika \n";
        }break;
        default:
            cout << "Instrukcja obslugi\n" <<
                "d - dodaj pracownika \n" <<
                "u - usun pracownika \n" <<
                "s - szukaj pracownika za pomoca imienia i nazwiska \n" <<
                "x - szukaj pracownika za pomoca daty urodzenia  \n" <<
                "w - wypisz tablice pracownikow \n" <<
                "q - wyjdz \n";

        }
        cout << "Wpisz instrukcje: ";
        cin >> c;
    }
    return 0;
}




#include "Napis.h"
#include <iostream>
#include <cstring>
#include <string.h>
using namespace std;
Napis::Napis(const char* napis)
{
    Ustaw(napis);
}

const char* Napis::Zwroc() const
{
    return m_przNapis;
}

void Napis::Ustaw(const char* nowy_napis)
{
    strncpy_s(m_przNapis, nowy_napis, sizeof(m_przNapis) - 1);
}

void Napis::Wypisz() const
{
    cout << m_przNapis;
}

void Napis::Wpisz()
{
    char temp[40];
    cin >> temp;
    Ustaw(temp);
}

int Napis::SprawdzNapis(const char* por_napis) const
{
    return strcmp(m_przNapis, por_napis);
}

#pragma once
class Napis
{
private:
    char m_przNapis[40];
public:
    Napis(const char* napis = " ");
    const char* Zwroc() const;
    void Ustaw(const char* nowy_napis);
    void Wypisz() const;
    void Wpisz();
    int SprawdzNapis(const char* por_napis) const;
};



#include "Data.h"
#include <iostream>

using namespace std;

Data::Data(int d, int m, int r)
{
    m_nDzien = d;
    m_nMiesiac = m;
    m_nRok = r;
}
void Data::Ustaw(int d, int m, int r)
{
    m_nDzien = d;
    m_nMiesiac = m;
    m_nRok = r;
    Koryguj();
}
int Data::Dzien() const
{
    return m_nDzien;
}
int Data::Miesiac() const
{
    return m_nMiesiac;
}
int Data::Rok() const
{
    return m_nRok;
}
void Data::Wypisz() const
{
    cout << "\nWyswietlam date\n";
    cout << m_nDzien << "-" << m_nMiesiac << "-" << m_nRok << endl;
}
void Data::Wpisz()
{
    int d, m, r;
    cout << "Wpisz dzien: ";
    cin >> d;
    cout << "Wpisz miesiac: ";
    cin >> m;
    cout << "Wpisz rok: ";
    cin >> r;
    Ustaw(d, m, r);
}
int Data::Porownaj(const Data& wzor) const
{
    Wypisz();
    cout << "\nData ze wzorca:";
    wzor.Wypisz();
    /*unsigned int tempa = 31536000 * m_nRok + 2592000 * m_nMiesiac + 86400 * m_nDzien;
    unsigned int tempb = 31536000 * wzor.Rok() + 2592000 * wzor.Miesiac() + 86400 * wzor.Dzien();
    if (tempa == tempb) return 0;
    else if (tempa < tempb) return 1;
    else return -1;*/
    if (wzor.Rok() > m_nRok) return 1;
    else if (wzor.Rok() < m_nRok) return -1;
    else if (wzor.Miesiac() > m_nMiesiac) return 1;
    else if (wzor.Miesiac() < m_nMiesiac) return -1;
    else if (wzor.Dzien() > m_nDzien) return 1;
    else if (wzor.Dzien() < m_nDzien) return -1;
    else return 0;
}
void Data::Koryguj()
{
    if (m_nMiesiac <= 0) m_nMiesiac = 1;
    if (m_nMiesiac > 12) m_nMiesiac = 12;
    if (m_nDzien < 0) m_nDzien = 1;
    if (m_nDzien > 31) m_nDzien = 31;// tak tez mozna
    /*int tmp[] = { 1, 3, 5, 7, 8, 10, 12};
    for (int i = 0; i < sizeof(tmp); i++)
    {
        if (m_nMiesiac == tmp[i] && m_nDzien > 31) m_nDzien = 31;
    }*/
    int temp[] = { 4,6,9,11 };
    for (int j = 0; j < sizeof(temp); j++)
    {
        if (m_nMiesiac == temp[j] && m_nDzien > 30) m_nDzien = 30;
    }
    if (m_nRok % 400 == 0 && m_nMiesiac == 2 && m_nDzien > 29) m_nDzien = 29;
    if (m_nRok % 400 != 0 && m_nMiesiac == 2 && m_nDzien > 28) m_nDzien = 28;
}

#pragma once
class Data
{
private:
    int m_nDzien;
    int m_nMiesiac;
    int m_nRok;
    void Koryguj();
public:
    Data(int d = 1, int m = 1, int r = 2000);
    void Ustaw(int d, int m, int r);
    int Dzien() const;
    int Miesiac() const;
    int Rok() const;
    void Wypisz() const;
    void Wpisz();
    int Porownaj(const Data& wzor) const;
};




#include <iostream>
#include <string.h>
#include "Pracownik.h"

using namespace std;

Pracownik::Pracownik(const char* imie, const char* nazwisko, int d, int m, int r)
{
    Imie(imie);
    Nazwisko(nazwisko);
    DataUrodzenia(d, m, r);
}

const char* Pracownik::Imie() const
{
    return m_Imie.Zwroc();
}

const char* Pracownik::Nazwisko() const
{
    return m_Nazwisko.Zwroc();
}

void Pracownik::Imie(const char* nowe_imie)
{
    m_Imie.Ustaw(nowe_imie);
}

void Pracownik::Nazwisko(const char* nowe_nazwisko)
{
    m_Nazwisko.Ustaw(nowe_nazwisko);
}

void Pracownik::DataUrodzenia(int nowy_dzien, int nowy_miesiac, int nowy_rok)
{
    m_DataUrodzenia.Ustaw(nowy_dzien, nowy_miesiac, nowy_rok);
}

void Pracownik::Wypisz() const
{
    cout << "Imie: ";
    m_Imie.Wypisz();
    cout << " Nazwisko: ";
    m_Nazwisko.Wypisz();
    m_DataUrodzenia.Wypisz();
}

void Pracownik::Wpisz()
{
    cout << "Wpisz imie pracownika: ";
    m_Imie.Wpisz();
    cout << "Wpisz nazwisko pracownika: ";
    m_Nazwisko.Wpisz();
    cout << "Wpisz date urodzenia pracownika: \n";
    m_DataUrodzenia.Wpisz();
}

int Pracownik::SprawdzImie(const char* por_imie) const
{
    return m_Imie.SprawdzNapis(por_imie);
}

int Pracownik::SprawdzNazwisko(const char* por_nazwisko) const
{
    return m_Nazwisko.SprawdzNapis(por_nazwisko);
}

int Pracownik::Porownaj(const Pracownik& wzorzec) const
{
    int tmp_Nazwisko = this->SprawdzNazwisko(wzorzec.Nazwisko());
    if (tmp_Nazwisko != 0) return tmp_Nazwisko > 0 ? 1 : -1;

    int tmp_Imie = this->SprawdzImie(wzorzec.Imie());
    if (tmp_Imie != 0) return tmp_Imie > 0 ? 1 : -1;

    int tmp_Data = this->m_DataUrodzenia.Porownaj(wzorzec.m_DataUrodzenia);
    return tmp_Data;
}

int Pracownik::SprawdzData(const Data & wzorzec) const
{
    return m_DataUrodzenia.Porownaj(wzorzec);
}


#pragma once
#include "Data.h"
#include "Napis.h"

class Pracownik {
private:
    Napis m_Imie;
    Napis m_Nazwisko;
    Data m_DataUrodzenia;

public:
    Pracownik() {};
    Pracownik(const char* imie, const char* nazwisko, int d, int m, int r);
    const char* Imie() const;
    const char* Nazwisko() const;
    void Imie(const char* nowe_imie);
    void Nazwisko(const char* nowe_nazwisko);
    void DataUrodzenia(int nowy_dzien, int nowy_miesiac, int nowy_rok);
    void Wypisz() const;
    void Wpisz();
    int SprawdzImie(const char* por_imie) const;
    int SprawdzNazwisko(const char* por_nazwisko) const;
    int Porownaj(const Pracownik& wzorzec) const;
    int SprawdzData(const Data& wzorzec) const;
};


#include "TablicaPracownikow.h"
#include <iostream>


TablicaPracownikow::TablicaPracownikow()
{
    m_nLiczbaPracownikow = 0;
}


TablicaPracownikow::~TablicaPracownikow()
{
}

void TablicaPracownikow::Dodaj(const Pracownik & p)
{
    int i;

    for (i = 0; i < m_nLiczbaPracownikow; i++)
    {
        int temp = m_pTablica[i].Porownaj(p);
        if (temp == 0) return;
        if (temp == 1) break;
    }

    if (i > 19) i = 19;
    int ostatni = m_nLiczbaPracownikow;
    if (ostatni > 19) ostatni = 19;

    for (; ostatni > i; ostatni--)
    {
        m_pTablica[ostatni] = m_pTablica[ostatni - 1];
    }
    m_pTablica[i] = p;
    if (m_nLiczbaPracownikow < 20) m_nLiczbaPracownikow++;
}

void TablicaPracownikow::Usun(const Pracownik & wzorzec)
{
    int index = -1;

    for (int i = 0; i < m_nLiczbaPracownikow; i++)
    {
        if (m_pTablica[i].Porownaj(wzorzec) == 0)
        {
            index = i;
            break;
        }
    }

    if (index == -1) return;

    for (int i = index; i < m_nLiczbaPracownikow - 1; i++)
    {
        m_pTablica[i] = m_pTablica[i + 1];
    }
    m_nLiczbaPracownikow--;
    m_pTablica[m_nLiczbaPracownikow] = Pracownik();

}

void TablicaPracownikow::WypiszPracownikow() const
{
    std::cout << "Wypisanie pracownikow: \n";
    for (int i = 0; i < m_nLiczbaPracownikow; i++)
    {
        m_pTablica[i].Wypisz();
    }
}

const Pracownik * TablicaPracownikow::Szukaj(const char * nazwisko, const char * imie) const
{
    for (int i = 0; i < m_nLiczbaPracownikow; i++)
    {
        int tmp = m_pTablica[i].SprawdzNazwisko(nazwisko);
        if (tmp != 0) continue;
        int tmpa = m_pTablica[i].SprawdzImie(imie);
        if (tmpa != 0) continue;
        return &m_pTablica[i];
    }
    return nullptr;
}

const Pracownik * TablicaPracownikow::Szukaj(const Data & wzorzec) const
{
    for (int i = 0; i < m_nLiczbaPracownikow; i++)
    {
        int tmp = m_pTablica[i].SprawdzData(wzorzec);
        if (tmp != 0) continue;
        return &m_pTablica[i];
    }
    return nullptr;
}



#pragma once
#include "Pracownik.h"

class TablicaPracownikow
{
    Pracownik m_pTablica[20];
    int m_nLiczbaPracownikow;
public:
    TablicaPracownikow();
    ~TablicaPracownikow();
    void Dodaj(const Pracownik& p);
    void Usun(const Pracownik& wzorzec);
    void WypiszPracownikow() const;
    const Pracownik* Szukaj(const char* nazwisko, const char* imie) const;
    const Pracownik* Szukaj(const Data& wzorzec) const;
};