Resource Pool

Implemented a resource pool as a generic class -- Pool<T>.

The pool allows exclusive resources to be acquired and released in a thread safe manner.  If the pool does not have enough of a certain resource -- either because there's nothing currently in the pool or because all other resources are currently acquired -- it will call a user-supplied callback to obtain another resource.  It will do this until it reaches a configurable maximum (which may be unlimited), at which point incoming threads will block until a resource becomes available.
Scope Guard Addition

Added the ability to disengage a scope guard.  This prevents the scope guard's callback from being invoked when it goes out of scope.
MySQL Data Provider Rewrite

Entirely rewrote the MySQL Data Provider.  The old one was nowhere near as clean as I would've wanted, and had bugs -- segmentation faults et cetera -- that would crop up occasionally.  I suspect it was due to shoddy handling of prepared statement data structures, but the code wasn't worth debugging so I'll never know for sure.

The biggest problem was that its wrappers for the MySQL functions/data structures weren't clean or generic enough to prevent vast swathes of code from being reused, so many functions were almost literally copy/pastes of each other.

In rewriting I rectified this by writing a wrapper for the MYSQL_BIND structure that's comprehensive for my needs -- any code interacting with the MYSQL_BIND structure is 1-2 lines, rather than 10 or more as was previously common.

Rather than writing code to manage the connection pool directly, I offloaded that responsibility to the Pool<T> template class, a much better separation of responsibilities.

Rather than interacting with the MYSQL and MYSQL_STMT structures directly, I wrapped both of them -- in the Connection and PreparedStatement classes, respectively -- which -- for the majority of the code -- eliminated the need for messy and unwieldly branches on return codes.  Instead -- in true C++ style -- RAII and exceptions are used to handle errors.

I wrote wrappers that deal with the most common/repetitive tasks.  Because of the improved MYSQL_BIND wrapper, I was able to write a wrapper that transformed most of the functions that issue DML queries into a single line each.  The improved bind wrapper also removed repetitive code checking sizes and fiddling with pointers to extract strings/blobs -- that's all handled in a single function in get_buffer.cpp.

I also rewrote the GetDataProvider method to use C++ std::fstream instead of the CRT file I/O functions, and to be cleaner/better broken up overall.

Fiddled with the dp.mk makefile a bit beyond simply updating the files that are built.  It didn't make sense for the libmysqlclient library to be assigned to the DP_LIB variable, since not only is it only used in one place, the idea of the data provider paradigm is that data providers may be built ontop of many different sources -- not just MySQL.

Changed the DataProvider interface over to using purpose-written structures for containing information from its GetInfo method, as is the norm throughout the rest of the code base.
Data Provider Information Provider Update

Updated the data provider information provider to reflect the changes to the DataProvider interface.

I had to rename the module's class from DataProviderInfo to DPInfo, because one of the structures that the DataProvider uses to transport information has that name.
Merge branch 'mysql_rewrite'

Rewrote the MySQL data provider because it was a total mess (and had bugs).

Tweaked the DataProvider interface slightly to be more consistent with the style/patterns used throughout the rest of the project.