/*****Condition variable   *******/

#include<iostream>
#include<thread>
using namespace std;

class koordinator {
   enum redosled {PRVI, DRUGI, TRECI};
   redosled na_redu_je;
   mutex m;
   condition_variable c;
   condition_variable d;
public:
   koordinator() : na_redu_je(PRVI) {}
   void prvi_zavrsio() {
      lock_guard<mutex> lock(m);
      c.notify_one();
      na_redu_je = DRUGI;
   }
   void drugi_zavrsio() {
      lock_guard<mutex> lock(m);
      d.notify_one();
      na_redu_je = TRECI;
   }
   void drugi_ceka() {
      unique_lock<mutex> lock(m);
      while( !(na_redu_je == DRUGI) )
         c.wait(lock);
   }
   void treci_ceka() {
      unique_lock<mutex> lock(m);
      while( !(na_redu_je == TRECI) )
         d.wait(lock);
   }
};
koordinator k;

void a() {
   cout << "Ja sam nit a." << endl;
   //this_thread::sleep_for(chrono::seconds(7));
   k.prvi_zavrsio();
}

void b() {
   k.drugi_ceka();
   cout << "Ja sam nit b." << endl;
   k.drugi_zavrsio();
}
void c() {
   k.treci_ceka();
   cout << "Ja sam nit c." << endl;
}

int main() {
   thread ta(a);
   thread tb(b);
   thread tc(c);
   ta.join();
   tb.join();
   tc.join();
}



/******  Data race      *****/

#include<iostream>
#include<thread>
using namespace std;

class koordinator {
    enum redosled {PRVADVA,TRECI};
    redosled na_redu_je;
    int brojac;
    mutex m;
    condition_variable c;
public:
   koordinator() : na_redu_je(PRVADVA), brojac(0) {}

   void prvi_zavrsio() {
      lock_guard<mutex> lock(m);
      if(brojac == 1){
        brojac++;
        c.notify_one();
      } else
        brojac++;
   }

   void treci_ceka() {
      unique_lock<mutex> lock(m);
      while( !(brojac == 2) )
         c.wait(lock);
   }
};
koordinator k;

void a() {
   cout << "Ja sam nit a." << endl;
   //this_thread::sleep_for(chrono::seconds(7));
   k.prvi_zavrsio();
}

void b() {
   cout << "Ja sam nit b." << endl;
   k.prvi_zavrsio();
}
void c() {
   k.treci_ceka();
   cout << "Ja sam nit c." << endl;
}

int main() {
   thread ta(a);
   thread tb(b);
   thread tc(c);
   ta.join();
   tb.join();
   tc.join();
}

/*********  Komunikacija box mail     ********/

#include<iostream>
#include<thread>

using namespace std;

struct tacka {
   double x,y;
   tacka() : x(0), y(0) {}
   tacka(double x_, double y_) : x(x_), y(y_) {}
};

class Pozicija {
    tacka t;
    bool transfer;
    condition_variable full;
    condition_variable empty;
    mutable mutex mx;
public:
    Pozicija() : transfer(false) {}
    void set(const tacka& t_) {
        unique_lock<mutex> lock(mx);
        while(transfer)
            empty.wait(lock);
        t.x = t_.x;
        t.y = t_.y;
        transfer = true;
        full.notify_one();
   }
   // Konstantno jer samo cita vrednost atributa t.
    const tacka get(){
        unique_lock<mutex> lock(mx);
        while(!transfer)
            full.wait(lock);
        transfer= false;
        empty.notify_one();
        return t;
   }
};

Pozicija poz;

void proizvodjac() {
    poz.set(tacka(3, 5));
    poz.set(tacka(4, 7));
    poz.set(tacka(5, 6));
}

void potrosac() {
    tacka t = poz.get();
    cout << "X=" << t.x << ", Y=" << t.y << endl;
    t = poz.get();
    cout << "X=" << t.x << ", Y=" << t.y << endl;
    t = poz.get();
    cout << "X=" << t.x << ", Y=" << t.y << endl;
}

int main() {
    thread t1(proizvodjac);
    thread t2(potrosac);
    t1.join();
    t2.join();
}




/*** Parking.h *****/


#ifndef PARKING_H_INCLUDED
#define PARKING_H_INCLUDED

class Parking {
    mutex mx;
    enum Message_box_states { ZAUZET, RASPOLOZIV};
    Message_box_states state;
    int mesta,brojVozila;
    condition_variable full;
    condition_variable empty;
  public:
    Parking(int n) : state(RASPOLOZIV), mesta(n-1), brojVozila(0) {}

    void udji() {
        unique_lock<mutex> lock(mx);
        while(state == ZAUZET)
            empty.wait(lock);
        if(brojVozila == mesta )
            state = ZAUZET;
        full.notify_one();
        brojVozila++;
    }
    void izadji() {
        unique_lock<mutex> lock(mx);
        while(brojVozila == 0)
            full.wait(lock);
        state = RASPOLOZIV;
        brojVozila--;
        empty.notify_one();
    }
};


#endif // PARKING_H_INCLUDED

/*** Parking sa jednim mestom ****/

#ifndef PARKING_H_INCLUDED
#define PARKING_H_INCLUDED



class Parking {
    mutex mx;
    enum Message_box_states { EMPTY, FULL };
    Message_box_states state;
    condition_variable full;
    condition_variable empty;
  public:
    Parking() : state(EMPTY) {}

    void udji() {
        unique_lock<mutex> lock(mx);
        while(state == FULL)
            empty.wait(lock);
        state = FULL;
        full.notify_one();
    }
    void izadji() {
        unique_lock<mutex> lock(mx);
        while(state == EMPTY)
            full.wait(lock);
        state = EMPTY;
        empty.notify_one();
    }
};