#include <future>
#include <iostream>
#include <chrono>

int main()
{
	using namespace std::chrono_literals;

	auto printHi = []()
	{
		std::this_thread::sleep_for(500ms);
		auto tId = std::this_thread::get_id();

		std::cout << "Hello from " << tId << "\n";
	};

	printHi();

	auto fut = std::async(std::launch::async, printHi);


	return 0;
}

auto fut = std::async(std::launch::async, printHi);

#include <future>
#include <iostream>
#include <chrono>

int main()
{
	using namespace std::chrono_literals;

	auto printHi = []()
	{
		auto tId = std::this_thread::get_id();
		std::cout << "Hello from " << tId << "\n";
	};

	printHi();

	auto fut = std::async(std::launch::deferred, printHi);

	std::cout << "Waiting 2 seconds...\n";
	std::this_thread::sleep_for(2s);
	std::cout << "Calling for deferred\n";

	fut.get();



	return 0;
}

#include <future>
#include <iostream>
#include <chrono>

using namespace std::chrono_literals;
using MyHash = unsigned long long;

struct HasherWaiter
{
	std::future<MyHash> operator()(std::string name)
	{
		mHashingFuture = std::async(std::launch::async, [&]()
			{
				std::this_thread::sleep_for(5s);
				std::hash<std::string> h;
				auto hash = (MyHash)h(name);

				mPromise.set_value(hash);
			});

		return mPromise.get_future();
	}


private:
	std::future<void> mHashingFuture;
	std::promise<MyHash> mPromise;
};

int main()
{
	HasherWaiter hahser;

	auto future = hahser("Hello World");


	while (!future._Is_ready())
	{
		std::this_thread::sleep_for(500ms);
		std::cout << "Waiting for hash...\n";
	}

	std::cout << "Hash is " << future.get() << "\n";


	return 0;
}

#include <future>
#include <iostream>
#include <chrono>

int RectangleArea(int width, int height) { return width * height; }

struct Calculator
{
	Calculator() : mTask(std::bind(RectangleArea, 55, 22)) { }

	std::future<int> CalculateArea()
	{
		mTask();
		return mTask.get_future();
	}

private:
	std::packaged_task<int()> mTask;
};

int main()
{
	Calculator calc;
	auto result = calc.CalculateArea();

	std::cout << "Area: " << result.get() << "\n";

	return 0;
}

#include <iostream>
#include <experimental/coroutine>
#include <experimental/generator>
#include <coroutine>

std::experimental::generator<int> WalkTo(int n) noexcept
{
	auto i = 0;
	while (i < n)
	{
		co_yield i;
		i++;
	}
}

int main()
{
	auto g = WalkTo(5);
	auto itr = g.begin();

	std::cout << *itr << "\n";
	itr++;
	std::cout << *itr << "\n";
	itr++;
	std::cout << *itr << "\n";
	itr++;

	return 0;
}

#include <iostream>
#include <chrono>
#include <future>
#include <windows.h>    // Windows Threadpool API

using namespace std;
using namespace std::literals;

// operator overload.
// co_await can't use primitive type parameter.
auto operator co_await(chrono::system_clock::duration duration)
{
	using namespace std::experimental;

	// Awaitable must implements 3 function.
	//  - bool await_ready();
	//  - auto await_suspend();
	//  - T    await_resume();
	class awaiter
	{
		static
			void CALLBACK TimerCallback(PTP_CALLBACK_INSTANCE,
				void* Context,
				PTP_TIMER)
		{
			// Callback Thread will resume the function
			coroutine_handle<>::from_address(Context).resume();
		}
		PTP_TIMER timer = nullptr;
		chrono::system_clock::duration duration;
	public:

		explicit
			awaiter(chrono::system_clock::duration d) : duration(d)
		{}
		~awaiter() {
			if (timer) CloseThreadpoolTimer(timer);
		}

		// If not ready (`false`), invoke `await_suspend`
		// If ready (`true`), go to `await_resume` directly.
		bool await_ready() const
		{
			return duration.count() <= 0;
		}

		// Return might be ignored.
		bool await_suspend(coroutine_handle<> resume_cb)
		{
			int64_t relative_count = -duration.count();
			timer = CreateThreadpoolTimer(TimerCallback,
				resume_cb.address(),
				nullptr);
			// Set the timer and then suspend...
			SetThreadpoolTimer(timer, (PFILETIME)&relative_count, 0, 0);
			return timer != 0;
		}

		// Return T type's value after resumed.
		// T can be `void`.
		void await_resume() {}

	};
	return awaiter{ duration };
}

// Resumable Function
future<void> test()
{
	cout << this_thread::get_id() << ": sleeping…\n";

	// await for 5 seconds ...
	co_await 5000ms;

	cout << this_thread::get_id() << ": woke up\n";
}

// This is normal subroutine
void usecase()
{
	test().get();
	cout << this_thread::get_id() << ": back in main\n";
}

int main()
{
	usecase();
	return 0;
}