Fixes#47
When we detect a shared_ptr being loaded in load_and_allocate that
also is of a type that derives from enable_shared_from_this, extra
work is done to save the state of the enable_shared_from_this before
the user gets to meddle with it via placement new inside of
cereal::allocate. State is restored after getting back from the user.
Compiles but not stable yet, no interface to use Any within cereal yet. Will be kept internal and not exposed for use
outside of whatever the load/store names will be.
Adding some macros for specialization in case people feel like
typing less scary looking template specialization code.
Modified static assert to remind people that specialization exists.
See issue #25
Moving code around a bit, allocate is now in access.hpp which seems
to make a bit more sense. Exception is now in helpers.hpp.
It is now possible to use a cereal::allocate<T> object to directly
access member variables or functions after it has been initialized.
Accessing them before initialization will throw as will performing
a double initialization.
see #46
Won't have time to finish this one right now, but this solution should work well.
1) Realized there was no reason to do the deferring thing, we just register immediately after
allocation and use that pointer, so got rid of some overhead in code/time on regular shared_ptr loads.
2) For cases with no default constructor the interface will be changing slightly. Instead of having the
user do both the allocation and initialization, the user will only be responsible for the initialization.
This works as follows:
We allocate std::aligned_storage big enough for the type and pack it into a shared_ptr for the proper type with
a custom deleter to correctly call the proper destructors. We'll wrap up this raw pointer in a new class called
cereal::allocation (or similar) which will now be passed along with the archive as a reference to the load and
allocate function. The user now loads up their data as before using the archive, and then instead of performing
a raw call to operator new, they pass all of their arguments to the operator() of the cereal::allocation object
which then performs a placement new into the aligned_storage (transparent to the user). Should resolve the circular
reference problem too.
to handle circular nested shared pointer references, we split registration
for an id into a pre and post portion, where pre marks it as being dirty and
post marks it clean (valid). if we are loading up a reference to something that is
in the progress of being loaded (a nested case), we defer our load until it is no longer
dirty and perform the load afer the post condition happens.
load_and_allocate did not properly enter into the 'data' NVP that the
ptr_wrapper creates for unique/shared ptr. When loading these types,
we now go through a wrapper struct to force entry into an extra node to
resolve this issue.
Changes to unittests are for an issue compiling with g++-4.7.3 under
Ubuntu where steady_clock::now() is not defined for some reason
closes#38
Added a preprocessor define CEREAL_OLDER_GCC that exists if using
any GCC 4.7.x or earlier. If this is defined some type traits change to
our original solution (prior to VS compatible), which is probably what we'd switch
to if VS ever gets around to fully supporting SFINAE and constexpr.
In map and set, as well as in unit tests, use insert instead of emplace for 4.7.x.
-Convert to int with constexpr in reader/writer to avoid
always false comparison error in gcc 4.7.3
-make clean now removes visual studio sandbox if built
-fixes to traits for 4.7, still more to do there
see #38
See issue #17
Somewhere along the way we've also broken our ability to compile with GCC 4.7.3. We'll have to decide if we care about
supporting 4.7.3 or not. The changes that break this are:
-there is no emplace in std::map (or related) in 4.7.3
-there are some enable_ifs in rapidjson's writer.h that are always false (which is fine), but
GCC 4.7.3 doesn't like this
Separating actual boost transition layer (operator&, <<, >>) with the versioning
stuff, which is now a feature of cereal on its own.
Moving macro for defining version information into cereal.hpp to make it visible.
Added code level (doxygen) documentation for these features
See issue #22
Simple case of making these functions for the rest of the output archive serialization functions and then adding it to
load. Progress towards issue #8.
Remaining things to do: Modify cereal.hpp to properly choose between
versioned and non-versioned functions and place entries in the set of
versioned types as appropriate.
