serialization_shim.hpp

Go to the documentation of this file.

#ifndef MLPACK_CORE_UTIL_SERIALIZATION_SHIM_HPP
#define MLPACK_CORE_UTIL_SERIALIZATION_SHIM_HPP

#include <mlpack/core/util/sfinae_utility.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <type_traits>

namespace mlpack {
namespace data {

// This gives us a HasSerializeCheck<T, U> type (where U is a function pointer)
// we can use with SFINAE to catch when a type has a Serialize() function.
HAS_MEM_FUNC(Serialize, HasSerializeCheck);

// Don't call this with a non-class.  HasSerializeFunction::value is true if the
// type T has a static or non-static Serialize() function.
template<typename T>
struct HasSerializeFunction
{
  static const bool value =
      // Non-static version.
      HasSerializeCheck<T, void(T::*)(boost::archive::xml_oarchive&,
                                      const unsigned int)>::value ||
      // Static version.
      HasSerializeCheck<T, void(*)(boost::archive::xml_oarchive&,
                                   const unsigned int)>::value;
};

template<typename T>
struct HasSerialize
{
  // We have to handle the case where T isn't a class...
  typedef char yes[1];
  typedef char no [2];
  template<typename U, typename V, typename W> struct check;
  template<typename U> static yes& chk( // This matches classes.
      check<U,
            typename std::enable_if_t<std::is_class<U>::value>*,
            typename std::enable_if_t<HasSerializeFunction<U>::value>*>*);
  template<typename  > static no&  chk(...); // This matches non-classes.

  static const bool value = (sizeof(chk<T>(0)) == sizeof(yes));
};

// Declare the shims we need.
template<typename T> struct FirstShim;
template<typename T> struct FirstArrayShim;
template<typename T> struct FirstNormalArrayShim;
template<typename T> struct SecondShim;
template<typename T> struct SecondArrayShim;
template<typename T> struct SecondNormalArrayShim;
template<typename T> struct PointerShim;

template<typename T>
inline FirstShim<T> CreateNVP(
    T& t,
    const std::string& name,
    typename std::enable_if_t<HasSerialize<T>::value>* = 0)
{
  return FirstShim<T>(t, name);
}

template<typename T>
inline
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
const // Imitate the boost::serialization make_nvp() function.
#endif
boost::serialization::nvp<T> CreateNVP(
    T& t,
    const std::string& name,
    typename std::enable_if_t<!HasSerialize<T>::value>* = 0,
    typename std::enable_if_t<!std::is_pointer<T>::value>* = 0)
{
  return boost::serialization::make_nvp(name.c_str(), t);
}

template<typename T>
inline
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
const
#endif
boost::serialization::nvp<PointerShim<T>*> CreateNVP(
    T*& t,
    const std::string& name,
    typename std::enable_if_t<HasSerialize<T>::value>* = 0)
{
  return boost::serialization::make_nvp(name.c_str(),
      reinterpret_cast<PointerShim<T>*&>(t));
}

template<typename T>
inline
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
const
#endif
boost::serialization::nvp<T*> CreateNVP(
    T*& t,
    const std::string& name,
    typename std::enable_if_t<!HasSerialize<T>::value>* = 0)
{
  return boost::serialization::make_nvp(name.c_str(), t);
}

template<typename T>
inline FirstArrayShim<T> CreateArrayNVP(
    T* t,
    const size_t len,
    const std::string& name,
    typename std::enable_if_t<HasSerialize<T>::value>* = 0)
{
  return FirstArrayShim<T>(t, len, name);
}

template<typename T>
inline FirstNormalArrayShim<T> CreateArrayNVP(
    T* t,
    const size_t len,
    const std::string& name,
    typename std::enable_if_t<!HasSerialize<T>::value>* = 0)
{
  return FirstNormalArrayShim<T>(t, len, name);
}

template<typename T>
struct FirstShim
{
  FirstShim(T& t, const std::string& name) : t(t), name(name) { }

  T& t;
  const std::string& name;
};

template<typename T>
struct FirstArrayShim
{
  FirstArrayShim(T* t, const size_t len, const std::string& name) :
      t(t), len(len), name(name) { }

  T* t;
  const size_t len;
  const std::string& name;
};

template<typename T>
struct FirstNormalArrayShim
{
  FirstNormalArrayShim(T* t, const size_t len, const std::string& name) :
      t(t), len(len), name(name) { }

  T* t;
  const size_t len;
  const std::string& name;
};

template<typename T>
struct SecondShim
{
  SecondShim(T& t) : t(t) { }

  template<typename Archive>
  void serialize(Archive& ar, const unsigned int version)
  {
    t.Serialize(ar, version);
  }

  T& t;
};

template<typename T>
struct SecondArrayShim
{
  SecondArrayShim(T* t, const size_t len) : t(t), len(len) { }

  template<typename Archive>
  void serialize(Archive& ar, const unsigned int /* version */)
  {
    // Serialize each element, using the shims we already have.
    for (size_t i = 0; i < len; ++i)
      ar & CreateNVP(t[i], "item");
  }

  T* t;
  const size_t len;
};

template<typename T>
struct SecondNormalArrayShim
{
  SecondNormalArrayShim(T* t, const size_t len) : t(t), len(len) { }

  template<typename Archive>
  void serialize(Archive& ar, const unsigned int /* version */)
  {
    ar & boost::serialization::make_array(t, len);
  }

  T* t;
  const size_t len;
};

template<typename T>
struct PointerShim : public T { };

template<typename Archive, typename T>
Archive& operator<<(Archive& ar, FirstShim<T> t)
{
  SecondShim<T> sh(t.t);
  return (ar << boost::serialization::make_nvp(t.name.c_str(), sh));
}

template<typename Archive, typename T>
Archive& operator&(Archive& ar, FirstShim<T> t)
{
  SecondShim<T> sh(t.t);
  return (ar & boost::serialization::make_nvp(t.name.c_str(), sh));
}

template<typename Archive, typename T>
Archive& operator>>(Archive& ar, FirstShim<T> t)
{
  SecondShim<T> sh(t.t);
  return (ar >> boost::serialization::make_nvp(t.name.c_str(), sh));
}

template<typename Archive, typename T>
Archive& operator<<(Archive& ar, FirstArrayShim<T> t)
{
  SecondArrayShim<T> sh(t.t, t.len);
  return (ar << boost::serialization::make_nvp(t.name.c_str(), sh));
}

template<typename Archive, typename T>
Archive& operator&(Archive& ar, FirstArrayShim<T> t)
{
  SecondArrayShim<T> sh(t.t, t.len);
  return (ar & boost::serialization::make_nvp(t.name.c_str(), sh));
}

template<typename Archive, typename T>
Archive& operator>>(Archive& ar, FirstArrayShim<T> t)
{
  SecondArrayShim<T> sh(t.t, t.len);
  return (ar >> boost::serialization::make_nvp(t.name.c_str(), sh));
}

template<typename Archive, typename T>
Archive& operator<<(Archive& ar, FirstNormalArrayShim<T> t)
{
  SecondNormalArrayShim<T> sh(t.t, t.len);
  return (ar << boost::serialization::make_nvp(t.name.c_str(), sh));
}

template<typename Archive, typename T>
Archive& operator&(Archive& ar, FirstNormalArrayShim<T> t)
{
  SecondNormalArrayShim<T> sh(t.t, t.len);
  return (ar & boost::serialization::make_nvp(t.name.c_str(), sh));
}

template<typename Archive, typename T>
Archive& operator>>(Archive& ar, FirstNormalArrayShim<T> t)
{
  SecondNormalArrayShim<T> sh(t.t, t.len);
  return (ar >> boost::serialization::make_nvp(t.name.c_str(), sh));
}

} // namespace data
} // namespace mlpack

namespace boost {
namespace serialization {

template<typename Archive, typename T>
inline void serialize(Archive& ar,
                      mlpack::data::PointerShim<T>& t,
                      const BOOST_PFTO unsigned int version)
{
  T* tptr = reinterpret_cast<T*>(&t);
  tptr->Serialize(ar, version);
}

} // namespace serialization
} // namespace boost

#endif