/*#include "FXTrade.h"
#include <string>
#include <sstream>
#include <vector>
#include <queue>
#include <vector>
#include <iostream>
#include <cmath>
#include <exception>
#include <boost/random.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/bind.hpp>

using namespace std;
using namespace boost;

namespace write_namespace
{
	mutex file_mutex;
	ofstream out;
	const size_t dimension(10000);
	const size_t size(10);
	const unsigned int number_of_threads(10);
}

queue<CFXTrade> TradeVector;

namespace read_namespace
{
	mutex in_file_mutex;
	ifstream in;
}

void write_to_disk(const vector<CFXTrade>& nVector)
{

	using namespace write_namespace;

	mutex::scoped_lock lock(file_mutex);
	
	for(vector<CFXTrade>::const_iterator i_ptr=nVector.begin(); i_ptr!=nVector.end(); ++i_ptr)
	{
		out << i_ptr->m_TradeID << ";" << i_ptr->m_Name << ";" << i_ptr->m_Amount << endl;
	}

}

auto_ptr<CFXTrade> getTradeFromString(string& c_tmp)
{

	int i_TradeID;
	string c_Name, c_sub;
	string::size_type pos;
	double d_Amount(0.0);

	pos = c_tmp.find(";");
	c_sub = c_tmp.substr(0, pos);
	i_TradeID = atoi(c_sub.c_str());

	c_sub = c_tmp.substr(++pos, 3);
	c_Name = c_sub;

	c_sub = c_tmp.substr(pos+4, 3);
	
	d_Amount = atof(c_sub.c_str());
	d_Amount = 100.;

	return auto_ptr<CFXTrade>(new CFXTrade(i_TradeID, c_Name, d_Amount));

}

void read_from_disk(queue<CFXTrade>& nTradeVector)
{
	using namespace write_namespace;
	using namespace read_namespace;
	
	string c_tmp;

	try
	{
		mutex::scoped_lock lock(in_file_mutex);	

		for(size_t i=0; i<dimension; ++i)
		{
			getline(in, c_tmp);
			TradeVector.push(*getTradeFromString(c_tmp) );
		}
	}

	catch(exception& e)
	{
		mutex::scoped_lock lock(in_file_mutex);	

		cout << "A standard exception caught from " << __LINE__ << endl;
		cout << e.what() << endl;
	}

}

bool generate_file()
{

	using namespace write_namespace;

	vector< thread* > ThreadVector(number_of_threads);

	mt19937 mt2;
	random_number_generator<mt19937> std_rng(mt2);

	int TradeIDVector[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	char* NameVector[] = {"ABC", "BCD", "CDE", "DEF", "EFG", "FGH", "GHI", "HIJ", "IJK", "JKL"};
	double AmountVector[] = {10., 20., 30., 40., 50., 60., 70., 80., 90., 11.};

	vector< vector<CFXTrade> > TradeVector(number_of_threads);

	for(int i=0; i<number_of_threads; ++i)
	{
		for(int j=0; j<dimension; ++j)
		{
			TradeVector[i].push_back(CFXTrade(TradeIDVector[std_rng(size)], string(NameVector[std_rng(size)]),
											AmountVector[std_rng(size)]));
		}
	}

	out.open("file.txt");

	for(int i=0; i<number_of_threads; ++i)
	{
		ThreadVector[i] = new thread(bind(&write_to_disk, TradeVector[i]));
	}

	for(int i=0; i<number_of_threads; ++i)
	{
		ThreadVector[i]->join();
	}

	for(int i=0; i<number_of_threads; ++i)
	{
		delete ThreadVector[i];
	}

	out.close();

	return true;
}

bool read_trades()
{
	using namespace write_namespace;
	using namespace read_namespace;

	vector<thread*> ReadThreadVector(number_of_threads);

	in.open("file.txt");

	try
	{
		for(int i=0; i<number_of_threads; ++i)
		{
			ReadThreadVector[i] = new thread(bind(&read_from_disk, TradeVector));
		}

		for(int i=0; i<number_of_threads; ++i)
		{
			ReadThreadVector[i]->join();
		}

		for(int i=0; i<number_of_threads; ++i)
		{
			delete ReadThreadVector[i];
		}
	}
	catch(exception& e)
	{
		cout << "A standard exception caught from " << __LINE__ << endl;
		cout << e.what() << endl;

		return false;
	}

	in.close();

	return true;
}

void classified()
{
	using namespace read_namespace;
	try
	{
		generate_file();
		read_trades();
	}

	catch(exception& e)
	{
		cout << e.what() << endl;
		exit(EXIT_FAILURE);
	}
	catch(...)
	{
		cout << "Unknown exception occured" << endl;
	}

	cout << TradeVector.size() << endl;

}

int main()
{

	classified();

}
*/

// Copyright (C) 2001-2003
// William E. Kempf
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation.  William E. Kempf makes no representations
// about the suitability of this software for any purpose.
// It is provided "as is" without express or implied warranty.

#include <boost/thread/condition.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
#include <iostream>
#include <vector>

using namespace boost;
mutex io_mutex;

class bounded_buffer : private boost::noncopyable
{
public:
    typedef boost::mutex::scoped_lock lock;
    bounded_buffer(int n) : begin(0), end(0), buffered(0), circular_buf(n) { }
    void send (int m) {
        lock lk(monitor);
        while (buffered == circular_buf.size())
            buffer_not_full.wait(lk);
        circular_buf[end] = m;
        end = (end+1) % circular_buf.size();
        ++buffered;
        buffer_not_empty.notify_one();
    }
    int receive() {
        lock lk(monitor);
        while (buffered == 0)
            buffer_not_empty.wait(lk);
        int i = circular_buf[begin];
        begin = (begin+1) % circular_buf.size();
        --buffered;
        buffer_not_full.notify_one();
        return i;
    }
private:
    int begin, end, buffered;
    std::vector<int> circular_buf;
    boost::condition buffer_not_full, buffer_not_empty;
    boost::mutex monitor;
};
bounded_buffer buf(2);

void sender() {
    int n = 0;
    while (n < 100) {
        buf.send(n);
		mutex::scoped_lock l(io_mutex);
        std::cout << "sent: " << n << std::endl;
        ++n;
    }
    buf.send(-1);
}

void receiver() {
    int n;
    do {
        n = buf.receive();
		mutex::scoped_lock l(io_mutex);
        std::cout << "received: " << n << std::endl;
    } while (n != -1); // -1 indicates end of buffer
}

int main()
{
    boost::thread thrd1(&sender);
    boost::thread thrd2(&receiver);
    thrd1.join();
    thrd2.join();

	return 0;
}