#define _CRT_SECURE_NO_WARNINGS
#define _SCL_SECURE_NO_WARNINGS
 
#include <vector>
#include <string>

#include <sstream>
 
#include <iostream>
 
 
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/function.hpp>
#include <boost/array.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/shared_array.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/ptr_container/ptr_map.hpp>
#include <boost/ptr_container/ptr_set.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/algorithm/string/join.hpp>
#include <boost/format.hpp>
#include <boost/date_time/gregorian/gregorian.hpp>
 
#include <boost/program_options.hpp>
 
#include <boost/tuple/tuple.hpp>
 
#include <boost/foreach.hpp>
 
#include "boost/filesystem.hpp" 
#include <iostream>          
 
using namespace std;
using boost::lexical_cast;
using boost::format;
using boost::shared_ptr;
 
boost::mutex log_mutex;
 
void Log(int level, const string& str)
{
	boost::mutex::scoped_lock l(log_mutex);
 
	cout << 
		boost::format("%d - %s") % level % str
		<< endl;
}
 
 
void f(int level, string s1, string s2)
{
	Log(level, s1 + string(" ") + s2);
}
 
typedef vector<shared_ptr<boost::thread> > UmVectorDeThreads;
 
UmVectorDeThreads Test_Threads()
{
#if 0
	boost::array<boost::thread, 32> threads;
	threads.at(2) = boost::thread(boost::bind(&f, "Eu programa aos sábados.", "E daí"));

#endif
 
	boost::array< shared_ptr<boost::thread>, 32> threads;
 
	for(unsigned int i = 0 ; i < threads.size() ; i++)
	{
		threads[i] = shared_ptr<boost::thread>(
			new boost::thread(
			boost::bind(&f, 2, "Eu programo aos sabados.", 
			lexical_cast<string>(i))));
	}
 
	//
	// ai...
	//
	for(boost::array< shared_ptr<boost::thread>, 32>::iterator i 
		= threads.begin() ; i != threads.end() ; ++i)
	{
 
	}
 
	BOOST_FOREACH(shared_ptr<boost::thread> t, threads)
	{
 
	}
 
	boost::thread t;
 
 
	UmVectorDeThreads threads2(threads.size());
 
	std::copy(threads.begin(), threads.end(), threads2.begin());
 
	return threads2;
}
 
void VamosEsperarAsThreads(UmVectorDeThreads& threads)
{
	BOOST_FOREACH(shared_ptr<boost::thread> t, threads)
	{
		t->join();
	}
}
 
void Test_FileSystem()
{
	using namespace boost::filesystem;          
	path p("c:\\temp\\abobrinha");
 
	for(path::iterator i = p.begin() ; i != p.end() ; ++i)
		cout << *i << endl;
}
 
 
void Test_STL()
{
	vector<string> v;
	list<string> l;
	map<int, string> m;
 
	for(int a = 0 ; a < 20 ; a++)
	{
		string nome = "Nome " + lexical_cast<string>(a);
		v.push_back(nome);
		m[a] = nome;
	}
 
	copy(v.begin(), v.end(), back_inserter(l));
 

	BOOST_FOREACH(const string& nome, v)
		cout << nome << endl;
 
	for_each(l.begin(), l.end(), boost::bind(&Log, 1, _1));
}
 
int main()
{
	UmVectorDeThreads threads = Test_Threads();
 
	Test_STL();
	Test_FileSystem();
 
	for_each(threads.begin(), threads.end(), 
		boost::bind(&boost::thread::join, _1));
 
	//
	// olha mamãe, sem desalocar memória
	//
	return 0;
}