zaliczenie_pk

/*Tresc
1) Zadeklaruj klasę Zadanie, która reprezentuje zadania do wykonania (np. wpisy w terminarzu),
które wewnątrz obiektów klasy reprezentowane są przez łańcuchy opisujące zadanie oraz przez datę
planowanego wykonania zadania. Dodatkowo klasa posiada flagę oznaczjącą wykonanie zadania.
Zadeklaruj wszystkie potrzebne do realizacji kolejnych klas Kolejka i KolejkaS metody i operatory.

2) Zadeklaruj klasę Kolejka, która reprezentuje listę zadań. Zadania winny być przechowywane w liście jednokierunkowej
(zadeklaruj również typ elementu listy). Zadeklaruj wszystkie potrzebne metody i operatory.
Zdefiniuj następujące metody i operatory:
konstruktor domyślny klasy
konstruktor kopiujący klasy
destruktor
operator przypisania
metodę czysc() która usuwa wszystkie zadania z listy
metodę zaiwera(const Zadanie& z) zwracającą 1 gdy kolejka zawiera zadanie z
zaprzyjaźniony operator strumieniowy wypisujący obiekty z listy
operator += wstawiający zadanie do listy

3) Zadeklaruj klasę KolejkaS, pochodną klasy Kolejka, która reprezentuje kolejki priorytetowe zadań.
Wewnątrz kolejki zadania ułożone są w kolejności chronologicznej.
Zdefiniuj następujące metody i operatory :
operator += wstawiający zadanie do kolejki
metodę zakoncz(const Kolejka& tobedone), która wykonuje te zadania z kolejki, które są (jednocześnie również)
zawarte w kolejce tobedone
operator przypisania dla klasy KolejkaS, umożliwiający przpisanie zadań z klasy Kolejka oraz KolejkaS
zaprzyjaźniony operator strumieniowy wypisujący obiekty z klasy
*/



#include "stdafx.h"
#include <ostream>

class Zadanie
{
  char* todo;
  int data;
  int wykonane;

public:
    Zadanie();
    Zadanie(char*, int);
    Zadanie(const Zadanie&);
    ~Zadanie();
    Zadanie& operator=(const Zadanie&);

    void zakoncz(void);
    int operator>(const Zadanie&);  // porownuje daty
    int operator==(const Zadanie&); // porownuje CALE ZADANIA
  friend std::ostream & operator<<(std::ostream&, const Zadanie&);

};

Zadanie::Zadanie()
{
  todo = NULL;
  data = 0;
  wykonane = 0;
}

Zadanie::Zadanie(char* zad, int d)
{
  todo = new char[strlen(zad) + 1];
  strcpy(todo, zad);
  data = d;
  wykonane = 0;
}

Zadanie::Zadanie(const Zadanie& wzor)
{
  todo = new char[strlen(wzor.todo) + 1];
  strcpy(todo, wzor.todo);
  data = wzor.data;
  wykonane = wzor.wykonane;
}


Zadanie::~Zadanie()
{
  if (todo)
    delete todo;
}

Zadanie& Zadanie::operator=(const Zadanie& wzor)
{
    if (this == &wzor)
    return *this;

  if (todo)
    delete todo;

  todo = new char[strlen(wzor.todo) + 1];
  strcpy(todo, wzor.todo);
  data = wzor.data;
  wykonane = wzor.wykonane;

    return *this;
}

void Zadanie::zakoncz()
{
  std::cout<<"\nzadanie "<<todo<<" zaplanowane na "<<data<<" wykonane!";
  wykonane = 1;
}

int Zadanie::operator>(const Zadanie& z)
{
    return data > z.data;
}

int Zadanie::operator==(const Zadanie& z)
{
    return ((strcmp(todo, z.todo) == 0) && (data == z.data));
}

std::ostream& operator<<(std::ostream& os, const Zadanie& z)
{
    os<<z.todo;
    os<<" ";
    os<<z.data;
    return os;
};

//element listy jednokierunkowej
struct elem
{
    Zadanie zad;
    elem *nast;
    elem(const Zadanie& z):zad(z), nast(NULL) {};
};

class Kolejka
{
protected:
    elem *glowa, /* NULL jezeli kolejka pusta */
           *ogon; /* istotny gdy != NULL */

public:
    Kolejka():glowa(NULL), ogon(NULL) {}

    virtual Kolejka& operator+=(const Zadanie& z) // virtual!!!
    {
        elem *nowy = new elem(z);
        if (glowa)
            ogon->nast = nowy;
        else
            glowa = nowy;

        ogon = nowy;
        return *this;
    }

    Kolejka(const Kolejka& kol)
    {
    glowa = NULL;
        elem *biez = kol.glowa;

        while(biez)
        {
            (*this) += biez->zad;
            biez = biez->nast;
        }
    }

    ~Kolejka()
    {
    czysc();
    }

    void czysc()    // zostawi pusty (glowa==NULL) obiekt
    {
    elem *biez;
        while(glowa)
        {
      biez = glowa;
            glowa = glowa->nast;
            delete biez;
        }
    glowa = NULL;
  }

    Kolejka& operator=(const Kolejka& kol)
    {
        if (&kol == this)
            return *this;

        czysc();

        elem *biez = kol.glowa;
        while(biez)
        {
            (*this) += biez->zad;
            biez = biez->nast;
        }
        return *this;
    }

    int zawiera(const Zadanie& z)
    {
        elem *biez = glowa;
        while(biez)
            if (biez->zad == z)
                return 1;
            else
                biez = biez->nast;
        return 0;
    }

  friend std::ostream& operator<<(std::ostream& os, const Kolejka& kol)
    {
        elem *biez = kol.glowa;
        while(biez)
        {
            os<<biez->zad<<" ";
            biez = biez->nast;
        }
        return os;
    }

};

class KolejkaS:public Kolejka
{
public:
    KolejkaS& operator+=(const Zadanie &z)
    {
        elem* nowy = new elem(z);

        if((!glowa) || (glowa->zad > z))    // wstaw na poczatek
        {
      nowy->nast = glowa;
            glowa = nowy;
        }
        else
        {
            elem* biez = glowa;
            while((biez->nast) && (!(biez->nast->zad > z)))
                biez = biez->nast;

            nowy->nast = biez->nast;
            biez->nast = nowy;
        }
        if(!nowy->nast)
            ogon = nowy;
        return *this;
    }

    void zakoncz(Kolejka& tobedone)
    {
        elem *biez = glowa;
        while(biez)
        {
      if (tobedone.zawiera(biez->zad))
        biez->zad.zakoncz();
            biez = biez->nast;
        }
    }

    KolejkaS& operator=(const Kolejka& kol) // potrzebny bo zwraca KolejkaS
    {
        Kolejka::operator=(kol);    // += jest virtual !!!
        return *this;
    }

//  mamy konwersje automatyczne do klasy bazowej oraz wirtualne metody, zatem ponizsze juz mamy dzialajace
//  friend ostream & operator<<(ostream &os, const sorted_q &rq)

};

int main()
{
  //test Zadanie
  Zadanie z1("zadanie 1", 20071201);
  Zadanie z2("zadanie 2", 20071121);
  std::cout<<z1<<z2;

  Zadanie z3;
  z3 = z1;
  std::cout<<z3;
  z3.zakoncz();

  //test Kolejka
  Kolejka k1, k2;
  k1 += z1;
  k1 += Zadanie("zadanie 5", 20061111);
  k1 += z2;
  k2 += z3;
  k2 += Zadanie("zadanie 4", 20071231);
  std::cout<<std::endl<<k1;
  std::cout<<std::endl<<k2;

  Kolejka k3(k1);
  std::cout<<std::endl<<k3;

  k3 = k2;
  std::cout<<std::endl<<k3;

  //test KolejkaS
  KolejkaS ks1;
  std::cout<<std::endl<<ks1;
  ks1 = k1;
  std::cout<<std::endl<<ks1;

  ks1 += Zadanie("zadanie 6", 20080101);
  ks1 += Zadanie("zadanie 7", 20060101);
  std::cout<<std::endl<<ks1;
  ks1.zakoncz(k1);

}