Configured basic setup.
Added in boost
Added Google's cityhash hash.
Implemented Niall's nasty 256 bit hash. Still need to add some timing.
Added some quick hash benchmarking code. It's fast, very fast, only 30% penalty over memcpy() for long runs.
Added aligned allocator override for STL containers for Hash256.
Moved 256 bit hash into Niall's utilities.
Moved boost up a directory.
Updated.
Converted one of the Boost.Graph samples into a CATCH unit test.
Broke out Boost.Graph unit test into generic test + modify bits.
TripleGit v0.01 is prototyped out. Just needs implementation filled in. I expect that to take many weeks.
Merge remote-tracking branch 'remotes/origin/master'

Conflicts:
	boost
It took far too long to figure out why boost::asio::io_service.post() was refusing to take a packaged_task<>, not helped by me being very tired ... :(

Anyway, added the world's simplest thread pool based on std::thread, boost::future (I needed the composability support due for C++14) and Boost.ASIO. Added a cached, lockfree, asynchronous ringbuffered entropy generator for super fast random id generation. Plus a unit test to make sure it all works.

Tomorrow comes the beginnings of an async file i/o abstraction based on a threadpool for POSIX, with an actual IOCP implementation for Windows. This should greatly ease the port to QNX's async i/o infrastructure, should that day ever come.
Implemented composable chainable futures when_all() and when_any() from http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3428.pdf
Got the beginnings of an async_file_io_dispatcher implementation.
Many fixes for GCC compatibility.
Added a bit of async i/o implementation.
Stupid scons is being a dick again ... I'll have to go look up how my other open source got source in src/* to work.
Good progress today, though it's taken a few days for the design to coalesce in my head ... async i/o implementation designs are always tricky, thank god I've implemented them before otherwise it takes weeks to bashing the head against the wall!

All async i/o ops are now batch ops which generate and return a unique id per op with a future to an async_io_handle. This lets you distinguish between uncompleted ops properly.

Broke out common parameters into separate C++ types and used those to overload and partially specialise template implementation of the async op completion dependency management. The new code is vastly more generic and reusable, and makes good use of variadic templates.

Finished off async posix compat implementations of mkdir, open, fsync and close.