#include <iostream>
#include <exception>
#include <string>
#include <algorithm>

#include <tbb/parallel_for.h>
#include <tbb/blocked_range.h>

static const size_t N = 23;

class SubStringFinder
{
	const std::string str;
	size_t *max_array;
	size_t *pos_array;

public: 
	void operator() ( const tbb::blocked_range<size_t>& r ) const
	{
		std::cout << "gs:" << r.grainsize() << " b:" << r.begin() << " e:" << r.end() << std::endl;
		std::cout.flush();
		for ( size_t i = r.begin(); i != r.end(); ++i )
		{
			size_t max_size = 0, max_pos = 0;
			for (size_t j = 0; j < str.size(); ++j)
				if (j != i)
				{
					size_t limit = str.size()-std::max(i,j);
					for (size_t k = 0; k < limit; ++k)
					{
						if (str[i + k] != str[j + k])
							break;
						if (k > max_size)
						{
							max_size = k;
							max_pos = j;
						}
					}
				}
				max_array[i] = max_size;
				pos_array[i] = max_pos;
		}
	}
	
	SubStringFinder(std::string &s, size_t *m, size_t *p) 
		: str(s), max_array(m), pos_array(p)
	{ }
};

int test()
{
	std::string str[N] = { std::string("a"), std::string("b") };

	for (size_t i = 2; i < N; ++i)
		str[i] = str[i-1]+str[i-2];
	std::string &to_scan = str[N-1];
	size_t num_elem = to_scan.size();

	size_t *max = new size_t[num_elem];
	size_t *pos = new size_t[num_elem];

	tbb::parallel_for( tbb::blocked_range<size_t>(0, num_elem ),
		SubStringFinder( to_scan, max, pos ) );

	for (size_t i = 0; i < num_elem; ++i)
		std::cout << " " << max[i] << "(" << pos[i] << ")" << std::endl;
	delete[] pos;
	delete[] max;
	return 0;
}

class copy_tracker
{
	int v;
public:
	copy_tracker()
		: v(0)
	{
		std::cout << "copy_tracker::copy_tracker()" << std::endl;
	}

	copy_tracker( copy_tracker& c )
		: v( c.v )
	{
		std::cout << "copy_tracker::copy_tracker( copy_tracker& c )" << std::endl;
	}

	void echo()
	{
		std::cout << v << std::endl;
	}
};

copy_tracker copy_tracker_by_value()
{
	return copy_tracker();
}

copy_tracker copy_tracker_by_value2()
{
	return copy_tracker_by_value();
}

void test_copy_tracker()
{
	volatile copy_tracker o = copy_tracker_by_value2();

}

int test_flowgraph()
{
	return 0;
}

int main ( void )
{try{

	test();

	test_copy_tracker();
	return 0;
}
catch ( const std::exception& e )
{
	std::cerr << std::endl
			<< "std::exception(\"" << e.what() << "\")." << std::endl;
}
catch ( ... )
{
	std::cerr  << std::endl
			<< "unknown exception." << std::endl;
}}