#include "stdafx.h"

#include <stack>

#include <boost/bind/bind.hpp>

#include <boost/thread.hpp>

#include <boost/thread/lock_factories.hpp>

using namespace std;

class Buffer

{

private:

    boost::mutex mu;

    boost::condition_variable_any cond_put;

    boost::condition_variable_any cond_get;

    int un_read, capacity;

    std::stack<int> m_stk;

    bool isFull()

    {

        return un_read == capacity;

    }

    bool isEmpty()

    {

        return un_read == ;

    }

public:

    Buffer(size_t n):un_read(), capacity(n) {}

    void put(int x)

    {

        {

            auto lock = make_unique_lock(mu);

            for (; isFull(); )

            {

                cout << "Full waiting"<<endl;

                cond_put.wait(lock);

            }

            m_stk.push(x);

            ++un_read;

        }

        cond_get.notify_one();

    }

    void get(int *x)

    {

        {

            auto lock = make_unique_lock(mu);

            for (; isEmpty(); )

            {

                cout<<"Empty waiting..."<<endl;

                cond_get.wait(lock);

            }

            --un_read;

            *x = m_stk.top();

            m_stk.pop();

        }

        cond_put.notify_one();

    }

};

Buffer buf();

void Producer(int n)

{

    for (int i=; i<n; i++)

    {

        cout<< "Putting "<<i<<endl;

        buf.put(i);

    }

}

void Consumer(int n)

{

    int x;

    for (int i=; i<n; i++)

    {

        buf.get(&x);

        cout<<"Getting "<<x<<endl;

    }

}

int main()

{

    boost::thread_group tg;

    tg.create_thread(bind(Producer, ));

    tg.create_thread(bind(Consumer, ));

    tg.create_thread(bind(Consumer, ));

    tg.join_all();

    return ;

}