polymorphic_impl.hpp

/*
  Copyright (c) 2013, Randolph Voorhies, Shane Grant
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of cereal nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/* This code is heavily inspired by the boost serialization implementation by the following authors

   (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
   Use, modification and distribution is subject to the Boost Software
   License, Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt)

    See http://www.boost.org for updates, documentation, and revision history.

   (C) Copyright 2006 David Abrahams - http://www.boost.org.

   See /boost/serialization/export.hpp and /boost/archive/detail/register_archive.hpp for their
   implementation.
*/
#ifndef CEREAL_DETAILS_POLYMORPHIC_IMPL_HPP_
#define CEREAL_DETAILS_POLYMORPHIC_IMPL_HPP_

#include <cereal/details/static_object.hpp>
#include <cereal/types/memory.hpp>
#include <cereal/types/string.hpp>
#include <typeindex>
#include <map>


#define CEREAL_BIND_TO_ARCHIVES(T)                           \
    namespace cereal {                                       \
    namespace detail {                                       \
    template<>                                               \
    struct init_binding<T> {                                 \
        static bind_to_archives<T> const & b;                \
    };                                                       \
    bind_to_archives<T> const & init_binding<T>::b =         \
        ::cereal::detail::StaticObject<                      \
            bind_to_archives<T >                             \
        >::getInstance().bind();                             \
    }} // end namespaces

namespace cereal
{
  namespace detail
  {
    template <class T>
    struct binding_name {};


    template <class Archive>
    struct OutputBindingMap
    {

      typedef std::function<void(void*, void const *)> Serializer;

      struct Serializers
      {
        Serializer shared_ptr, 
                   unique_ptr; 
      };

      std::map<std::type_index, Serializers> map;
    };


    template <class Archive>
    struct InputBindingMap
    {

      typedef std::function<void(void*, std::shared_ptr<void> & )> SharedSerializer;
      typedef std::function<void(void*, std::unique_ptr<void> & )> UniqueSerializer;

      struct Serializers
      {
        SharedSerializer shared_ptr; 
        UniqueSerializer unique_ptr; 
      };

      std::map<std::string, Serializers> map;
    };

    template<class T> struct EmptyDeleter { void operator()(T *) const {} };

    // forward decls for archives from cereal.hpp
    struct InputArchiveBase;
    struct OutputArchiveBase;


    template <class Archive, class T> struct InputBindingCreator
    {
      InputBindingCreator()
      {
        typename InputBindingMap<Archive>::Serializers serializers;

        serializers.shared_ptr =
          [](void * arptr, std::shared_ptr<void> & dptr)
          {
            Archive & ar = *static_cast<Archive*>(arptr);
            std::shared_ptr<T> ptr;

            ar( ::cereal::memory_detail::make_ptr_wrapper(ptr) );

            dptr = ptr;
          };

        serializers.unique_ptr =
          [](void * arptr, std::unique_ptr<void> & dptr)
          {
            Archive & ar = *static_cast<Archive*>(arptr);
            std::unique_ptr<T> ptr;

            ar( ::cereal::memory_detail::make_ptr_wrapper(ptr) );

            dptr.reset(ptr.release());
          };

        StaticObject<InputBindingMap<Archive>>::getInstance().map.insert( { std::string(binding_name<T>::name()), serializers } );
      }
    };


    template <class Archive, class T> struct OutputBindingCreator
    {
      static void writeMetadata(Archive & ar)
      {
        // Register the polymorphic type name with the archive, and get the id
        char const * name = binding_name<T>::name();
        std::uint32_t id = ar.registerPolymorphicType(name);

        // Serialize the id
        ar( _CEREAL_NVP("polymorphic_id", id) );

        // If the msb of the id is 1, then the type name is new, and we should serialize it
        if( id & detail::msb_32bit )
        {
          std::string namestring(name);
          ar( _CEREAL_NVP("polymorphic_name", namestring) );
        }
      }

      OutputBindingCreator()
      {
        typename OutputBindingMap<Archive>::Serializers serializers;

        serializers.shared_ptr =
          [](void * arptr, void const * dptr)
          {
            Archive & ar = *static_cast<Archive*>(arptr);

            writeMetadata(ar);

            std::shared_ptr<T const> const ptr(static_cast<T const *>(dptr), EmptyDeleter<T const>());

            ar( _CEREAL_NVP("ptr_wrapper", memory_detail::make_ptr_wrapper(ptr)) );
          };

        serializers.unique_ptr =
          [](void * arptr, void const * dptr)
          {
            Archive & ar = *static_cast<Archive*>(arptr);

            writeMetadata(ar);

            std::unique_ptr<T const, EmptyDeleter<T const>> const ptr(static_cast<T const *>(dptr));

            ar( _CEREAL_NVP("ptr_wrapper", memory_detail::make_ptr_wrapper(ptr)) );
          };

        StaticObject<OutputBindingMap<Archive>>::getInstance().map.insert( {std::type_index(typeid(T)), serializers} );
      }
    };

    struct adl_tag {};

    template <class Archive, class T>
    struct create_bindings
    {
        static const InputBindingCreator<Archive, T> &
        load(std::true_type)
        {
          return cereal::detail::StaticObject<InputBindingCreator<Archive, T>>::getInstance();
        }

        static const OutputBindingCreator<Archive, T> &
        save(std::true_type)
        {
          return cereal::detail::StaticObject<OutputBindingCreator<Archive, T>>::getInstance();
        }

        inline static void load(std::false_type) {}
        inline static void save(std::false_type) {}
    };

    template <void(*)()>
    struct instantiate_function {};

    template <class Archive, class T>
    struct polymorphic_serialization_support
    {
      static void instantiate();
      typedef instantiate_function<instantiate> unused;
    };

    // instantiate implementation
    template <class Archive, class T>
    void polymorphic_serialization_support<Archive,T>::instantiate()
    {
        create_bindings<Archive,T>::save( std::is_base_of<detail::OutputArchiveBase, Archive>() );

        create_bindings<Archive,T>::load( std::is_base_of<detail::InputArchiveBase, Archive>() );
    }


    template <class T>
    struct bind_to_archives
    {
      void bind(std::false_type) const
      {
        instantiate_polymorphic_binding( (T*)0, 0, adl_tag{} );
      }

      void bind(std::true_type) const
      { }


      bind_to_archives const & bind() const
      {
        bind( std::is_abstract<T>() );
        return *this;
      }
    };

    template <class T>
    struct init_binding;


    template <class T>
    void instantiate_polymorphic_binding( T*, int, adl_tag ) {};
  } // namespace detail
} // namespace cereal

#endif // CEREAL_DETAILS_POLYMORPHIC_IMPL_HPP_