Add a prepare() hook to Loader

Also add an overload of finish() which is called even when an exception
occurs and receives a bool parameter to indicate if loading was
successful.

Change most remaining uses of std::list to std::vector

Make the conversion operator of Symbol explicit

Fix incorrect type in a range-for loop

Add std:: qualifier to nullptr_t

Make move constructors explicitly declared for MSVC's benefit

When exporting classes it wants to export all the special members, even
if some of them are invalid due to the types of data members.  A user-
declared move constructor disables the implicit copy constructor so
things will work correctly.

Copy loader context to auxiliary loaders

Make PackSource use vector<unique_ptr<T>> instead of list<T>

Consequently it's no longer copyable.

Use the auto type in a few places that were missed previously

Introduce an improved interface for loading sub-objects

Objects can now be created dynamically and stored in a collection.
Hierarchical names are automatically generated for stored objects.

The old load_sub function will be deprecated at some point.

Simplify DynamicObjectLoader with an if constexpr

Use standard smart pointers for memory management

Collection and related classes now use std::unique_ptr to make ownership
transfers explicit.

Convert typedefs to using declarations

Don't delete the temporary file while it's in use

That doesn't work on Windows.

Use FS::get_temp_dir to get the temporary directory

Remove a vestigial file

Use default member initializers in datatool

This also fixes one uninitialized flag.

Get source from the parser if there's no current statement

Binary format is loaded directly, without statement structures.

Refactor handling of actions in Loader

Auxiliary loaders now work with the binary format and the flow control
structures are more clear in general.

Export a couple more things in the API

Update Variant API usage

Update .gitignore to include build products on Windows

Use Msp::getenv

Move the definition of Input's operator bool to the header

The class should be considered as internal, but Parser invokes the bool
conversion from its own.  This avoids having to export Input.

Remove unnecessary destructor declarations

Noexcept is the default since C++11.

Decorate things which should be visible to users of the library

Disable the templated constructor of Value if the source type is Value

Microsoft's std::vector uses a T & (without const) for copying, which
resolves to the templated constructor instead of the copy constructor
unless the former is disabled for that signature.

Use correct delete operator in RawData

Use explicit lengths in builtin data initialization

This allows adding binary files which may contain embedded nul bytes.

Cosmetic changes

Use size_t for memory buffer sizes

Recognize and handle raw data files in the data tool

Shuffle some names around in the data tool

Add a function to detect raw data signature

Add a class for loading raw bulk data

Remove the obsolete LoadableTypeRegistry class

Use the override specifier to mark overridden virtual functions

Use variadic templates and forwarding references for better flexibility

Use default member initializers for constant initial values

Mark empty constructors and destructors as defaulted

Add missing includes

Use plain function pointer instead of std::function

The lambda ended up having no captures, so this works.

Explicitly convert regex match to boolean

Use nullptr instead of 0 for pointers

Make boolean conversion operators explicit

Tweak DynamicObjectLoader to make it extensible

Subclasses can now override te type handler and access the object without
clearing it, for example to perform some custom initialization after the
object has been created.

Remove unnecessary capture from a lambda

Also call finish on auxiliary loaders

Return the object from DynamicObjectLoader::store_object

This provides an easy way to both store the object and also use it.

Avoid inconsistent state in Collection if a notify function throws

Change remaining fixed-size integers to standard types

Add support for storing the loaded object in DynamicObjectLoader

This allows the object to be stored in the collection using its actual
type rather than the base class.

Redesign Collection's creator and notify mechanisms to be more generic

They now allow any functors, including lambdas.

Add a class for loading dynamically typed objects

Fix incorrect order of memcpy args

Remove unnecessary header

Force correct conversion of symbols

MSVC attempts to use the conversion operator in Symbol rather than
Value's constructor.

Use C++11 features to manipulate containers

Use metaprogramming constructs from std

Perform bit conversion using standard-sanctioned memcpy method

The compiler should be able to optimize it away.

Use <cstdint> in BinFloat

Require C++11 for building

Bump version for upcoming changes

Add a mechanism for collections to be notified when an item is added

Remove some long-deprecated things

Reserve enough storage for the output in base64_decode

Add support for base64-encoded strings in text format

They're much more efficient both space and decoding wise than using C
escapes to encode binary data.

Deprecate LoadableTypeRegistry

The general-purpose TypeRegistry in mspcore solves the same problems
better.

Report locations of errors through multiple levels of referenced files

Minor style/typo fixes

Make Loader::ActionMap delete the actions

This ensures actions in shared action maps are deleted as well

Turn Statement into a struct

Implement proper copy semantics

All classes are now either safe to copy or are marked noncopyable.

Make the File reference in PackSource::Object const

Fix an incorrect condition for throwing an exception

Null actions are allowed, so only throw if there was no match.

Add find functions to Collection

Support custom action maps in loader classes

This makes it possible to implement a persistent action map which is
only initialized once the first time a particular class is used.

Support loader functions with bound first argument

This allows more flexibility in defining dynamic keywords.  Only
available with C++11.

Support N-ary loader functions if compiling in C++11 mode

Allow non-loadable types in collections

Custom collection classes may wish to provide objects of such types
through creator functions.

Update a SFINAE construct

Prefer vector over list

Throw an exception if trying to load a nonexistent file

Collection::open_raw returns a null pointer in this case so it must be
checked.

Add support for generating .cpp files for BuiltinSource

Use IO::BufferedFile in the packer component of datatool

Add a utility for registering types for loading

Somewhat ironically Collection can't use this because it has much more
complex requirements.

Allow modifying existing types in a collection

Annotate deprecated identifiers as such

Use a larger buffer size when transferring pack contents

Respect the TMPDIR environment variable when creating data packs

Prefer exact type match when looking for Loader actions

Previosuly the first matching action in alphabetical signature order was
taken, which causes a float overload to be chosen for an int value even
if an int overload was also available.

Add a test case for Loader overload resolution

Update Collection terminology

Mostly in test cases but there was one lingering reference to "future"
objects in the actual header as well.

Fix test cases so they compile again

Add more flexible versions of the load function

Firstly there's a variadic version of the basic load function.  Secondly
and perhaps more importantly there are versions which can load an object
from a file stored in a collection.  All of these are only implemented
for C++11 for now, since supporting the old version seems increasingly
irrelevant.

Move NeedsCollection into its own header and adjust for new Sfinae struct

Use automatic base detection when parsing integers

Add a missing include

Add a source class for builtin data

Provide access to the keyword of the current statement