s11n.hpp

/* Copyright 2009-2017 Francesco Biscani (bluescarni@gmail.com)

This file is part of the Piranha library.

The Piranha library is free software; you can redistribute it and/or modify
it under the terms of either:

  * the GNU Lesser General Public License as published by the Free
    Software Foundation; either version 3 of the License, or (at your
    option) any later version.

or

  * the GNU General Public License as published by the Free Software
    Foundation; either version 3 of the License, or (at your option) any
    later version.

or both in parallel, as here.

The Piranha library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received copies of the GNU General Public License and the
GNU Lesser General Public License along with the Piranha library.  If not,
see https://www.gnu.org/licenses/. */

#ifndef PIRANHA_S11N_HPP
#define PIRANHA_S11N_HPP

// Common headers for serialization.
#include <boost/algorithm/string/predicate.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/iostreams/filtering_stream.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/serialization/split_free.hpp>
#include <boost/serialization/split_member.hpp>
#include <boost/serialization/string.hpp>
#include <boost/version.hpp>
#include <cstddef>
#include <fstream>
#include <ios>
#include <memory>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>

#include <piranha/detail/demangle.hpp>
#include <piranha/exceptions.hpp>
#include <piranha/is_key.hpp>
#include <piranha/safe_cast.hpp>
#include <piranha/symbol_utils.hpp>
#include <piranha/type_traits.hpp>

namespace piranha
{

inline namespace impl
{

// Scalar types directly supported by the all serialization libraries.
template <typename T>
using is_serialization_scalar
    = disjunction<std::is_same<char, T>, std::is_same<signed char, T>, std::is_same<unsigned char, T>,
                  std::is_same<short, T>, std::is_same<unsigned short, T>, std::is_same<int, T>,
                  std::is_same<unsigned, T>, std::is_same<long, T>, std::is_same<unsigned long, T>,
                  std::is_same<long long, T>, std::is_same<unsigned long long, T>, std::is_same<float, T>,
                  std::is_same<double, T>, std::is_same<bool, T>>;

// Implementation of the detection of boost saving archives.
namespace ibsa_impl
{

template <typename A>
using is_saving_t = typename A::is_saving;

template <typename A>
using is_loading_t = typename A::is_loading;

template <typename A, typename T>
using lshift_t = decltype(std::declval<A &>() << std::declval<const T &>());

template <typename A, typename T>
using and_t = decltype(std::declval<A &>() & std::declval<const T &>());

// NOTE: here it does not make much sense that the pointer is non-const, but we are going by the literal
// description in the boost archive concept.
template <typename A, typename T>
using save_binary_t = decltype(std::declval<A &>().save_binary(std::declval<T *>(), std::declval<std::size_t>()));

template <typename A, typename T>
using register_type_t = decltype(std::declval<A &>().template register_type<T>());

template <typename A>
using get_library_version_t = decltype(std::declval<const A &>().get_library_version());

struct helper;

template <typename A>
using get_helper_t_1 = decltype(std::declval<A &>().template get_helper<helper>());

template <typename A>
using get_helper_t_2 = decltype(std::declval<A &>().template get_helper<helper>(static_cast<void *>(nullptr)));

template <typename Archive, typename T>
using impl
    = conjunction<std::is_same<detected_t<is_saving_t, uncvref_t<Archive>>, boost::mpl::bool_<true>>,
                  std::is_same<detected_t<is_loading_t, uncvref_t<Archive>>, boost::mpl::bool_<false>>,
                  // NOTE: add lvalue ref instead of using Archive &, so we avoid a hard
                  // error if Archive is void.
                  std::is_same<detected_t<lshift_t, Archive, T>, addlref_t<Archive>>,
                  std::is_same<detected_t<and_t, Archive, T>, addlref_t<Archive>>,
                  is_detected<save_binary_t, Archive, unref_t<T>>, is_detected<register_type_t, Archive, uncvref_t<T>>,
                  // NOTE: the docs here mention that get_library_version() is supposed to
                  // return an unsigned integral type, but the boost archives apparently
                  // return a type which is implicitly convertible to some unsigned int.
                  // This seems to work and it should cover also the cases in which the
                  // return type is a real unsigned int.
                  std::is_convertible<detected_t<get_library_version_t, Archive>, unsigned long long>
#if BOOST_VERSION >= 105700
                  //  Helper support is available since 1.57.
                  ,
                  is_detected<get_helper_t_1, Archive>, is_detected<get_helper_t_2, Archive>
#endif
                  >;
}
}


template <typename Archive, typename T>
class is_boost_saving_archive
{
    static const bool implementation_defined = ibsa_impl::impl<Archive, T>::value;

public:
    static const bool value = implementation_defined;
};

template <typename Archive, typename T>
const bool is_boost_saving_archive<Archive, T>::value;

inline namespace impl
{

// Implementation of boost loading archive concept. We reuse some types from the ibsa_impl namespace.
namespace ibla_impl
{

template <typename A, typename T>
using rshift_t = decltype(std::declval<A &>() >> std::declval<T &>());

template <typename A, typename T>
using and_t = decltype(std::declval<A &>() & std::declval<T &>());

template <typename A, typename T>
using load_binary_t = decltype(std::declval<A &>().load_binary(std::declval<T *>(), std::declval<std::size_t>()));

template <typename A, typename T>
using reset_object_address_t
    = decltype(std::declval<A &>().reset_object_address(std::declval<T *>(), std::declval<T *>()));

template <typename A>
using delete_created_pointers_t = decltype(std::declval<A &>().delete_created_pointers());

template <typename Archive, typename T>
using impl = conjunction<
    std::is_same<detected_t<ibsa_impl::is_saving_t, uncvref_t<Archive>>, boost::mpl::bool_<false>>,
    std::is_same<detected_t<ibsa_impl::is_loading_t, uncvref_t<Archive>>, boost::mpl::bool_<true>>,
    std::is_same<detected_t<rshift_t, Archive, T>, addlref_t<Archive>>,
    std::is_same<detected_t<and_t, Archive, T>, addlref_t<Archive>>, is_detected<load_binary_t, Archive, unref_t<T>>,
    is_detected<ibsa_impl::register_type_t, Archive, uncvref_t<T>>,
    std::is_convertible<detected_t<ibsa_impl::get_library_version_t, Archive>, unsigned long long>,
    is_detected<reset_object_address_t, Archive, unref_t<T>>, is_detected<delete_created_pointers_t, Archive>
#if BOOST_VERSION >= 105700
    ,
    is_detected<ibsa_impl::get_helper_t_1, Archive>, is_detected<ibsa_impl::get_helper_t_2, Archive>
#endif
    >;
}
}


template <typename Archive, typename T>
class is_boost_loading_archive
{
    static const bool implementation_defined = ibla_impl::impl<Archive, T>::value;

public:
    static const bool value = implementation_defined;
};

template <typename Archive, typename T>
const bool is_boost_loading_archive<Archive, T>::value;


template <typename Archive, typename T>
struct boost_save_via_boost_api {

    void operator()(Archive &ar, const T &x) const
    {
        ar << x;
    }
};


template <typename Archive, typename T, typename = void>
struct boost_save_impl {
};

inline namespace impl
{

// Enabler for the arithmetic specialisation of boost_save().
template <typename Archive, typename T>
using boost_save_arithmetic_enabler =
    // NOTE: the check for non-constness of Archive is implicit in the saving archive concept.
    // NOTE: here we are relying on the fact that the Archive class correctly advertises the capability
    // to serialize arithmetic types. This is for instance *not* the case for Boost archives, which
    // accept every type (at the signature level), but since here we are concerned only with arithmetic
    // types (for which serialization is always available in Boost archives), it should not matter.
    enable_if_t<conjunction<is_boost_saving_archive<Archive, T>,
                            disjunction<is_serialization_scalar<T>, std::is_same<T, long double>>>::value>;
}


template <typename Archive, typename T>
struct boost_save_impl<Archive, T, boost_save_arithmetic_enabler<Archive, T>> : boost_save_via_boost_api<Archive, T> {
};

inline namespace impl
{

// Enabler for boost_save() for strings.
template <typename Archive>
using boost_save_string_enabler = enable_if_t<is_boost_saving_archive<Archive, std::string>::value>;
}


template <typename Archive>
struct boost_save_impl<Archive, std::string, boost_save_string_enabler<Archive>>
    : boost_save_via_boost_api<Archive, std::string> {
};

inline namespace impl
{

template <typename Archive, typename T>
using boost_save_impl_t = decltype(boost_save_impl<Archive, T>{}(std::declval<Archive &>(), std::declval<const T &>()));

// Enabler for boost_save().
template <typename Archive, typename T>
using boost_save_enabler
    = enable_if_t<conjunction<is_boost_saving_archive<Archive, T>, is_detected<boost_save_impl_t, Archive, T>>::value,
                  int>;
}


template <typename Archive, typename T, boost_save_enabler<Archive, T> = 0>
inline void boost_save(Archive &ar, const T &x)
{
    boost_save_impl<Archive, T>{}(ar, x);
}

inline namespace impl
{

template <typename A, typename T>
using boost_save_t = decltype(piranha::boost_save(std::declval<A &>(), std::declval<const T &>()));
}


template <typename Archive, typename T>
class has_boost_save
{
    static const bool implementation_defined = is_detected<boost_save_t, Archive, T>::value;

public:
    static const bool value = implementation_defined;
};

template <typename Archive, typename T>
const bool has_boost_save<Archive, T>::value;


template <typename Archive, typename T>
struct boost_load_via_boost_api {

    void operator()(Archive &ar, T &x) const
    {
        ar >> x;
    }
};


template <typename Archive, typename T, typename = void>
struct boost_load_impl {
};

inline namespace impl
{

// Enabler for the arithmetic specialisation of boost_load().
template <typename Archive, typename T>
using boost_load_arithmetic_enabler
    = enable_if_t<conjunction<is_boost_loading_archive<Archive, T>,
                              disjunction<is_serialization_scalar<T>, std::is_same<T, long double>>>::value>;
}


template <typename Archive, typename T>
struct boost_load_impl<Archive, T, boost_load_arithmetic_enabler<Archive, T>> : boost_load_via_boost_api<Archive, T> {
};

inline namespace impl
{

// Enabler for boost_load for strings.
template <typename Archive>
using boost_load_string_enabler = enable_if_t<is_boost_loading_archive<Archive, std::string>::value>;
}


template <typename Archive>
struct boost_load_impl<Archive, std::string, boost_load_string_enabler<Archive>>
    : boost_load_via_boost_api<Archive, std::string> {
};

inline namespace impl
{

template <typename Archive, typename T>
using boost_load_impl_t = decltype(boost_load_impl<Archive, T>{}(std::declval<Archive &>(), std::declval<T &>()));

// Enabler for boost_load().
template <typename Archive, typename T>
using boost_load_enabler
    = enable_if_t<conjunction<is_boost_loading_archive<Archive, T>, is_detected<boost_load_impl_t, Archive, T>>::value,
                  int>;
}


template <typename Archive, typename T, boost_load_enabler<Archive, T> = 0>
inline void boost_load(Archive &ar, T &x)
{
    boost_load_impl<Archive, T>{}(ar, x);
}

inline namespace impl
{

template <typename A, typename T>
using boost_load_t = decltype(piranha::boost_load(std::declval<A &>(), std::declval<T &>()));
}


template <typename Archive, typename T>
class has_boost_load
{
    static const bool implementation_defined = is_detected<boost_load_t, Archive, T>::value;

public:
    static const bool value = implementation_defined;
};

template <typename Archive, typename T>
const bool has_boost_load<Archive, T>::value;


template <typename Key>
struct boost_s11n_key_wrapper {
private:
    PIRANHA_TT_CHECK(is_key, Key);

public:

    explicit boost_s11n_key_wrapper(Key &k, const symbol_fset &ss)
        : m_key_m(std::addressof(k)), m_key_c(m_key_m), m_ss(ss)
    {
    }

    explicit boost_s11n_key_wrapper(const Key &k, const symbol_fset &ss)
        : m_key_m(nullptr), m_key_c(std::addressof(k)), m_ss(ss)
    {
    }

    Key &key()
    {
        if (unlikely(!m_key_m)) {
            piranha_throw(std::runtime_error, "trying to access the mutable key instance of a boost_s11n_key_wrapper "
                                              "that was constructed with a const key");
        }
        return *m_key_m;
    }

    const Key &key() const
    {
        return *m_key_c;
    }

    const symbol_fset &ss() const
    {
        return m_ss;
    }

private:
    Key *m_key_m;
    const Key *m_key_c;
    const symbol_fset &m_ss;
};
}

#include <piranha/config.hpp>

#if defined(PIRANHA_WITH_MSGPACK)

#include <msgpack.hpp>

#if MSGPACK_VERSION_MAJOR < 2

#error The minimum msgpack-c version supported is 2.

#endif

#include <algorithm>
#include <array>
#include <boost/iostreams/device/mapped_file.hpp>
#include <cmath>
#include <cstdint>
#include <ios>
#include <iterator>
#include <limits>
#include <locale>
#include <sstream>
#include <vector>

namespace piranha
{

// Fwd decls.
template <typename, typename>
class has_msgpack_pack;

template <typename>
class has_msgpack_convert;

inline namespace impl
{

// Wrapper for std stream classes for use in msgpack. The reason for this wrapper is that msgpack expects
// streams with a write(const char *, std::size_t) method, but in std streams the second param is std::streamsize
// (which is a signed int). Hence we wrap the write method to do the safe conversion from size_t to streamsize.
template <typename Stream>
struct msgpack_stream_wrapper : Stream {
    // Inherit ctors.
    using Stream::Stream;
    auto write(const typename Stream::char_type *p, std::size_t count)
        -> decltype(std::declval<Stream &>().write(p, std::streamsize(0)))
    {
        return static_cast<Stream *>(this)->write(p, safe_cast<std::streamsize>(count));
    }
};

template <typename T>
using msgpack_stream_write_t
    = decltype(std::declval<T &>().write(std::declval<const char *>(), std::declval<std::size_t>()));
}


template <typename T>
class is_msgpack_stream
{
    static const bool implementation_defined
        = conjunction<is_detected<msgpack_stream_write_t, T>, negation<std::is_reference<T>>,
                      negation<std::is_const<T>>>::value;

public:
    static const bool value = implementation_defined;
};

template <typename T>
const bool is_msgpack_stream<T>::value;


enum class msgpack_format {
    portable,
    binary
};


template <typename Stream, typename T, typename = void>
struct msgpack_pack_impl {
};

inline namespace impl
{

template <typename Stream, typename T>
using msgpack_scalar_enabler = enable_if_t<conjunction<is_msgpack_stream<Stream>, is_serialization_scalar<T>>::value>;
}


template <typename Stream, typename T>
struct msgpack_pack_impl<Stream, T, msgpack_scalar_enabler<Stream, T>> {

    void operator()(msgpack::packer<Stream> &packer, const T &x, msgpack_format) const
    {
        packer.pack(x);
    }
};

inline namespace impl
{

template <typename Stream>
using msgpack_ld_enabler
    = enable_if_t<conjunction<is_msgpack_stream<Stream>, has_msgpack_pack<Stream, std::string>>::value>;
}


template <typename Stream>
struct msgpack_pack_impl<Stream, long double, msgpack_ld_enabler<Stream>> {

    void operator()(msgpack::packer<Stream> &packer, const long double &x, msgpack_format f) const
    {
        if (f == msgpack_format::binary) {
            packer.pack_bin(sizeof(long double));
            packer.pack_bin_body(reinterpret_cast<const char *>(&x), sizeof(long double));
        } else {
            if (std::isnan(x)) {
                if (std::signbit(x)) {
                    msgpack_pack(packer, std::string("-nan"), f);
                } else {
                    msgpack_pack(packer, std::string("+nan"), f);
                }
            } else if (std::isinf(x)) {
                if (std::signbit(x)) {
                    msgpack_pack(packer, std::string("-inf"), f);
                } else {
                    msgpack_pack(packer, std::string("+inf"), f);
                }
            } else {
                std::ostringstream oss;
                // Make sure we are using the C locale.
                oss.imbue(std::locale::classic());
                // Use scientific format.
                oss << std::scientific;
                // http://stackoverflow.com/questions/554063/how-do-i-print-a-double-value-with-full-precision-using-cout
                // NOTE: this does not mean that the *exact* value of the long double is printed, just that the
                // value is recovered exactly if reloaded on the same machine. This is a compromise, as the exact
                // printing of the value in string form would take up hundreds of digits. On the other hand, there is a
                // similar situation also for float and double, as there is not guarantee that they conform to IEEE. In
                // the end it seems the only practical approach is to consider all floating-point types as approximate
                // values, subject to various platform/architecture vagaries.
                oss.precision(std::numeric_limits<long double>::max_digits10);
                oss << x;
                msgpack_pack(packer, oss.str(), f);
            }
        }
    }
};

inline namespace impl
{

template <typename Stream>
using msgpack_string_enabler = enable_if_t<is_msgpack_stream<Stream>::value>;
}


template <typename Stream>
struct msgpack_pack_impl<Stream, std::string, msgpack_string_enabler<Stream>> {

    void operator()(msgpack::packer<Stream> &packer, const std::string &s, msgpack_format) const
    {
        packer.pack(s);
    }
};

inline namespace impl
{

template <typename Stream, typename T>
using msgpack_pack_impl_t = decltype(msgpack_pack_impl<Stream, T>{}(
    std::declval<msgpack::packer<Stream> &>(), std::declval<const T &>(), std::declval<msgpack_format>()));

// Enabler for msgpack_pack.
template <typename Stream, typename T>
using msgpack_pack_enabler
    = enable_if_t<conjunction<is_msgpack_stream<Stream>, is_detected<msgpack_pack_impl_t, Stream, T>>::value, int>;
}


template <typename Stream, typename T, msgpack_pack_enabler<Stream, T> = 0>
inline void msgpack_pack(msgpack::packer<Stream> &packer, const T &x, msgpack_format f)
{
    msgpack_pack_impl<Stream, T>{}(packer, x, f);
}


template <typename T, typename = void>
struct msgpack_convert_impl {
};

inline namespace impl
{

template <typename T>
using msgpack_convert_scalar_enabler = enable_if_t<is_serialization_scalar<T>::value>;
}


template <typename T>
struct msgpack_convert_impl<T, msgpack_convert_scalar_enabler<T>> {

    void operator()(T &x, const msgpack::object &o, msgpack_format) const
    {
        o.convert(x);
    }
};


template <>
struct msgpack_convert_impl<std::string> {

    void operator()(std::string &s, const msgpack::object &o, msgpack_format) const
    {
        o.convert(s);
    }
};

inline namespace impl
{

template <typename T>
using msgpack_convert_impl_t = decltype(msgpack_convert_impl<T>{}(
    std::declval<T &>(), std::declval<const msgpack::object &>(), std::declval<msgpack_format>()));

// Enabler for msgpack_convert.
template <typename T>
using msgpack_convert_enabler
    = enable_if_t<conjunction<negation<std::is_const<T>>, is_detected<msgpack_convert_impl_t, T>>::value, int>;
}


template <typename T, msgpack_convert_enabler<T> = 0>
inline void msgpack_convert(T &x, const msgpack::object &o, msgpack_format f)
{
    msgpack_convert_impl<T>{}(x, o, f);
}

inline namespace impl
{

template <typename T>
using msgpack_convert_ld_enabler
    = enable_if_t<conjunction<std::is_same<T, long double>, has_msgpack_convert<std::string>>::value>;
}


template <typename T>
struct msgpack_convert_impl<T, msgpack_convert_ld_enabler<T>> {

    void operator()(long double &x, const msgpack::object &o, msgpack_format f) const
    {
        using lim = std::numeric_limits<long double>;
        if (f == msgpack_format::binary) {
            std::array<char, sizeof(long double)> tmp;
            o.convert(tmp);
            std::copy(tmp.begin(), tmp.end(), reinterpret_cast<char *>(&x));
        } else {
            PIRANHA_MAYBE_TLS std::string tmp;
            msgpack_convert(tmp, o, f);
            if (tmp == "+nan") {
                if (lim::has_quiet_NaN) {
                    x = std::copysign(lim::quiet_NaN(), 1.l);
                } else {
                    piranha_throw(std::invalid_argument, "cannot deserialize a NaN if the platform does not support "
                                                         "quiet NaNs");
                }
            } else if (tmp == "-nan") {
                if (lim::has_quiet_NaN) {
                    x = std::copysign(lim::quiet_NaN(), -1.l);
                } else {
                    piranha_throw(std::invalid_argument, "cannot deserialize a NaN if the platform does not support "
                                                         "quiet NaNs");
                }
            } else if (tmp == "+inf") {
                if (lim::has_infinity) {
                    x = lim::infinity();
                } else {
                    piranha_throw(std::invalid_argument, "infinities are not supported by the platform");
                }
            } else if (tmp == "-inf") {
                if (lim::has_infinity) {
                    x = std::copysign(lim::infinity(), -1.l);
                } else {
                    piranha_throw(std::invalid_argument, "infinities are not supported by the platform");
                }
            } else {
                std::istringstream iss;
                iss.imbue(std::locale::classic());
                // NOTE: is seems like the std::scientific format flag has an effect on input
                // streams as well. See the example here:
                // http://en.cppreference.com/w/cpp/io/manip/fixed
                iss >> std::scientific;
                iss.str(tmp);
                iss >> x;
                if (unlikely(iss.fail())) {
                    piranha_throw(std::invalid_argument, "failed to parse the string '" + tmp + "' as a long double");
                }
            }
        }
    }
};

inline namespace impl
{

template <typename Stream, typename T>
using msgpack_pack_t = decltype(piranha::msgpack_pack(std::declval<msgpack::packer<Stream> &>(),
                                                      std::declval<const T &>(), std::declval<msgpack_format>()));
}


template <typename Stream, typename T>
class has_msgpack_pack
{
    static const bool implementation_defined = is_detected<msgpack_pack_t, Stream, T>::value;

public:
    static const bool value = implementation_defined;
};

template <typename Stream, typename T>
const bool has_msgpack_pack<Stream, T>::value;

inline namespace impl
{

template <typename T>
using msgpack_convert_t = decltype(piranha::msgpack_convert(
    std::declval<T &>(), std::declval<const msgpack::object &>(), std::declval<msgpack_format>()));
}


template <typename T>
class has_msgpack_convert
{
    static const bool implementation_defined = is_detected<msgpack_convert_t, T>::value;

public:
    static const bool value = implementation_defined;
};

template <typename T>
const bool has_msgpack_convert<T>::value;

inline namespace impl
{

template <typename Stream, typename Key>
using key_msgpack_pack_t = decltype(std::declval<const Key &>().msgpack_pack(
    std::declval<msgpack::packer<Stream> &>(), std::declval<msgpack_format>(), std::declval<const symbol_fset &>()));
}


template <typename Stream, typename Key>
class key_has_msgpack_pack
{
    PIRANHA_TT_CHECK(is_key, uncvref_t<Key>);
    static const bool implementation_defined
        = conjunction<is_detected<key_msgpack_pack_t, Stream, Key>, is_msgpack_stream<Stream>>::value;

public:
    static const bool value = implementation_defined;
};

template <typename Stream, typename Key>
const bool key_has_msgpack_pack<Stream, Key>::value;

inline namespace impl
{

template <typename Key>
using key_msgpack_convert_t = decltype(std::declval<Key &>().msgpack_convert(
    std::declval<const msgpack::object &>(), std::declval<msgpack_format>(), std::declval<const symbol_fset &>()));
}


template <typename Key>
class key_has_msgpack_convert
{
    PIRANHA_TT_CHECK(is_key, uncvref_t<Key>);
    static const bool implementation_defined = is_detected<key_msgpack_convert_t, Key>::value;

public:
    static const bool value = implementation_defined;
};

template <typename Key>
const bool key_has_msgpack_convert<Key>::value;
}

#endif

#if defined(PIRANHA_WITH_ZLIB)

#include <boost/iostreams/filter/gzip.hpp>
#include <boost/iostreams/filter/zlib.hpp>

#define PIRANHA_ZLIB_CONDITIONAL(expr) expr

#else

#define PIRANHA_ZLIB_CONDITIONAL(expr) piranha_throw(not_implemented_error, "zlib support is not enabled")

#endif

#if defined(PIRANHA_WITH_BZIP2)

#include <boost/iostreams/filter/bzip2.hpp>

#define PIRANHA_BZIP2_CONDITIONAL(expr) expr

#else

#define PIRANHA_BZIP2_CONDITIONAL(expr) piranha_throw(not_implemented_error, "bzip2 support is not enabled")

#endif

namespace piranha
{


enum class data_format {

    boost_binary,

    boost_portable,

    msgpack_binary,

    msgpack_portable
};


enum class compression {
    none,
    bzip2,
    gzip,
    zlib
};

inline namespace impl
{

// NOTE: no need for ifdefs guards here, as the compression-specific stuff is hidden in the CompressionFilter type.
template <typename CompressionFilter, typename T>
inline void save_file_boost_compress_impl(const T &x, std::ofstream &ofile, data_format f)
{
    piranha_assert(f == data_format::boost_binary || f == data_format::boost_portable);
    // NOTE: there seem to be 2 choices here: stream or streambuf. The first does some formatting, while the second
    // one is "raw" but does not provide the stream interface (which is used, e.g., by msgpack). Since we always
    // open files in binary mode (as suggested by the Boost serialization library), this should not matter in the end.
    // Some resources:
    // http://stackoverflow.com/questions/1753469/how-to-hook-up-boost-serialization-iostreams-to-serialize-gzip-an-object-to
    // https://code.google.com/p/cloudobserver/wiki/TutorialsBoostIOstreams
    // http://stackoverflow.com/questions/8116541/what-exactly-is-streambuf-how-do-i-use-it
    // http://www.boost.org/doc/libs/1_46_1/libs/serialization/doc/special.html
    boost::iostreams::filtering_ostream out;
    out.push(CompressionFilter{});
    out.push(ofile);
    if (f == data_format::boost_binary) {
        boost::archive::binary_oarchive oa(out);
        boost_save(oa, x);
    } else {
        boost::archive::text_oarchive oa(out);
        boost_save(oa, x);
    }
}

// NOTE: the implementation is the specular of the above.
template <typename DecompressionFilter, typename T>
inline void load_file_boost_compress_impl(T &x, std::ifstream &ifile, data_format f)
{
    piranha_assert(f == data_format::boost_binary || f == data_format::boost_portable);
    boost::iostreams::filtering_istream in;
    in.push(DecompressionFilter{});
    in.push(ifile);
    if (f == data_format::boost_binary) {
        boost::archive::binary_iarchive ia(in);
        boost_load(ia, x);
    } else {
        boost::archive::text_iarchive ia(in);
        boost_load(ia, x);
    }
}

// Main save/load functions for Boost format.
template <typename T, enable_if_t<conjunction<has_boost_save<boost::archive::binary_oarchive, T>,
                                              has_boost_save<boost::archive::text_oarchive, T>>::value,
                                  int> = 0>
inline void save_file_boost_impl(const T &x, const std::string &filename, data_format f, compression c)
{
    namespace bi = boost::iostreams;
    // NOTE: always open in binary mode in order to avoid problems with special formatting in streams.
    std::ofstream ofile(filename, std::ios::out | std::ios::binary | std::ios::trunc);
    if (unlikely(!ofile.good())) {
        piranha_throw(std::runtime_error, "file '" + filename + "' could not be opened for saving");
    }
    switch (c) {
        case compression::bzip2:
            PIRANHA_BZIP2_CONDITIONAL(save_file_boost_compress_impl<bi::bzip2_compressor>(x, ofile, f));
            break;
        case compression::gzip:
            PIRANHA_ZLIB_CONDITIONAL(save_file_boost_compress_impl<bi::gzip_compressor>(x, ofile, f));
            break;
        case compression::zlib:
            PIRANHA_ZLIB_CONDITIONAL(save_file_boost_compress_impl<bi::zlib_compressor>(x, ofile, f));
            break;
        case compression::none:
            if (f == data_format::boost_binary) {
                boost::archive::binary_oarchive oa(ofile);
                boost_save(oa, x);
            } else {
                boost::archive::text_oarchive oa(ofile);
                boost_save(oa, x);
            }
    }
}

template <typename T, enable_if_t<disjunction<negation<has_boost_save<boost::archive::binary_oarchive, T>>,
                                              negation<has_boost_save<boost::archive::text_oarchive, T>>>::value,
                                  int> = 0>
inline void save_file_boost_impl(const T &, const std::string &, data_format, compression)
{
    piranha_throw(not_implemented_error,
                  "type '" + detail::demangle<T>() + "' does not support serialization via Boost");
}

template <typename T, enable_if_t<conjunction<has_boost_load<boost::archive::binary_iarchive, T>,
                                              has_boost_load<boost::archive::text_iarchive, T>>::value,
                                  int> = 0>
inline void load_file_boost_impl(T &x, const std::string &filename, data_format f, compression c)
{
    namespace bi = boost::iostreams;
    std::ifstream ifile(filename, std::ios::in | std::ios::binary);
    if (unlikely(!ifile.good())) {
        piranha_throw(std::runtime_error, "file '" + filename + "' could not be opened for loading");
    }
    switch (c) {
        case compression::bzip2:
            PIRANHA_BZIP2_CONDITIONAL(load_file_boost_compress_impl<bi::bzip2_decompressor>(x, ifile, f));
            break;
        case compression::gzip:
            PIRANHA_ZLIB_CONDITIONAL(load_file_boost_compress_impl<bi::gzip_decompressor>(x, ifile, f));
            break;
        case compression::zlib:
            PIRANHA_ZLIB_CONDITIONAL(load_file_boost_compress_impl<bi::zlib_decompressor>(x, ifile, f));
            break;
        case compression::none:
            if (f == data_format::boost_binary) {
                boost::archive::binary_iarchive ia(ifile);
                boost_load(ia, x);
            } else {
                boost::archive::text_iarchive ia(ifile);
                boost_load(ia, x);
            }
    }
}

template <typename T, enable_if_t<disjunction<negation<has_boost_load<boost::archive::binary_iarchive, T>>,
                                              negation<has_boost_load<boost::archive::text_iarchive, T>>>::value,
                                  int> = 0>
inline void load_file_boost_impl(T &, const std::string &, data_format, compression)
{
    piranha_throw(not_implemented_error,
                  "type '" + detail::demangle<T>() + "' does not support deserialization via Boost");
}

#if defined(PIRANHA_WITH_MSGPACK)

// Compressed load/save for msgpack.
template <typename CompressionFilter, typename T>
inline void save_file_msgpack_compress_impl(const T &x, msgpack_stream_wrapper<std::ofstream> &ofile, msgpack_format mf)
{
    msgpack_stream_wrapper<boost::iostreams::filtering_ostream> out;
    out.push(CompressionFilter{});
    out.push(ofile);
    msgpack::packer<decltype(out)> packer(out);
    msgpack_pack(packer, x, mf);
}

template <typename DecompressionFilter, typename T>
inline void load_file_msgpack_compress_impl(T &x, const std::string &filename, msgpack_format mf)
{
    std::ifstream ifile(filename, std::ios::in | std::ios::binary);
    if (unlikely(!ifile.good())) {
        piranha_throw(std::runtime_error, "file '" + filename + "' could not be opened for loading");
    }
    std::vector<char> vchar;
    boost::iostreams::filtering_istream in;
    in.push(DecompressionFilter{});
    in.push(ifile);
    std::copy(std::istreambuf_iterator<char>(in), std::istreambuf_iterator<char>(), std::back_inserter(vchar));
    auto oh = msgpack::unpack(vchar.data(), safe_cast<std::size_t>(vchar.size()));
    msgpack_convert(x, oh.get(), mf);
}

// Main msgpack load/save functions.
template <
    typename T,
    enable_if_t<conjunction<has_msgpack_pack<msgpack_stream_wrapper<std::ofstream>, T>,
                            has_msgpack_pack<msgpack_stream_wrapper<boost::iostreams::filtering_ostream>, T>>::value,
                int> = 0>
inline void save_file_msgpack_impl(const T &x, const std::string &filename, data_format f, compression c)
{
    namespace bi = boost::iostreams;
    const auto mf = (f == data_format::msgpack_binary) ? msgpack_format::binary : msgpack_format::portable;
    msgpack_stream_wrapper<std::ofstream> ofile(filename, std::ios::out | std::ios::binary | std::ios::trunc);
    if (unlikely(!ofile.good())) {
        piranha_throw(std::runtime_error, "file '" + filename + "' could not be opened for saving");
    }
    switch (c) {
        case compression::bzip2:
            PIRANHA_BZIP2_CONDITIONAL(save_file_msgpack_compress_impl<bi::bzip2_compressor>(x, ofile, mf));
            break;
        case compression::gzip:
            PIRANHA_ZLIB_CONDITIONAL(save_file_msgpack_compress_impl<bi::gzip_compressor>(x, ofile, mf));
            break;
        case compression::zlib:
            PIRANHA_ZLIB_CONDITIONAL(save_file_msgpack_compress_impl<bi::zlib_compressor>(x, ofile, mf));
            break;
        case compression::none: {
            msgpack::packer<decltype(ofile)> packer(ofile);
            msgpack_pack(packer, x, mf);
        }
    }
}

template <
    typename T,
    enable_if_t<
        disjunction<negation<has_msgpack_pack<msgpack_stream_wrapper<std::ofstream>, T>>,
                    negation<has_msgpack_pack<msgpack_stream_wrapper<boost::iostreams::filtering_ostream>, T>>>::value,
        int> = 0>
inline void save_file_msgpack_impl(const T &, const std::string &, data_format, compression)
{
    piranha_throw(not_implemented_error,
                  "type '" + detail::demangle<T>() + "' does not support serialization via msgpack");
}

template <typename T, enable_if_t<has_msgpack_convert<T>::value, int> = 0>
inline void load_file_msgpack_impl(T &x, const std::string &filename, data_format f, compression c)
{
    namespace bi = boost::iostreams;
    const auto mf = (f == data_format::msgpack_binary) ? msgpack_format::binary : msgpack_format::portable;
    switch (c) {
        case compression::bzip2:
            PIRANHA_BZIP2_CONDITIONAL(load_file_msgpack_compress_impl<bi::bzip2_decompressor>(x, filename, mf));
            break;
        case compression::gzip:
            PIRANHA_ZLIB_CONDITIONAL(load_file_msgpack_compress_impl<bi::gzip_decompressor>(x, filename, mf));
            break;
        case compression::zlib:
            PIRANHA_ZLIB_CONDITIONAL(load_file_msgpack_compress_impl<bi::zlib_decompressor>(x, filename, mf));
            break;
        case compression::none: {
            // NOTE: two-stage construction for exception handling.
            std::unique_ptr<bi::mapped_file> mmap;
            try {
                mmap.reset(new bi::mapped_file(filename, bi::mapped_file::readonly));
            } catch (...) {
                // NOTE: this is just to beautify a bit the error message, and we assume any error in the line
                // above results from being unable to open the file.
                piranha_throw(std::runtime_error, "file '" + filename + "' could not be opened for loading");
            }
            // NOTE: this might be superfluous, but better safe than sorry.
            if (unlikely(!mmap->is_open())) {
                piranha_throw(std::runtime_error, "file '" + filename + "' could not be opened for loading");
            }
            auto oh = msgpack::unpack(mmap->const_data(), safe_cast<std::size_t>(mmap->size()));
            msgpack_convert(x, oh.get(), mf);
        }
    }
}

template <typename T, enable_if_t<!has_msgpack_convert<T>::value, int> = 0>
inline void load_file_msgpack_impl(T &, const std::string &, data_format, compression)
{
    piranha_throw(not_implemented_error,
                  "type '" + detail::demangle<T>() + "' does not support deserialization via msgpack");
}

#else

// If msgpack is not available, just error out.
template <typename T>
inline void save_file_msgpack_impl(const T &, const std::string &, data_format, compression)
{
    piranha_throw(not_implemented_error, "msgpack support is not enabled");
}

template <typename T>
inline void load_file_msgpack_impl(T &, const std::string &, data_format, compression)
{
    piranha_throw(not_implemented_error, "msgpack support is not enabled");
}

#endif

// General enabler for load_file().
template <typename T>
using load_file_enabler = enable_if_t<!std::is_const<T>::value, int>;

// Utility to deduce compression and data format from a filename.
inline std::pair<compression, data_format> get_cdf_from_filename(std::string filename)
{
    const auto orig_fname = filename;
    compression c = compression::none;
    if (boost::ends_with(filename, ".bz2")) {
        c = compression::bzip2;
        filename.erase(filename.end() - 4, filename.end());
    } else if (boost::ends_with(filename, ".gz")) {
        c = compression::gzip;
        filename.erase(filename.end() - 3, filename.end());
    } else if (boost::ends_with(filename, ".zip")) {
        c = compression::zlib;
        filename.erase(filename.end() - 4, filename.end());
    }
    data_format f;
    if (boost::ends_with(filename, ".boostb")) {
        f = data_format::boost_binary;
    } else if (boost::ends_with(filename, ".boostp")) {
        f = data_format::boost_portable;
    } else if (boost::ends_with(filename, ".mpackb")) {
        f = data_format::msgpack_binary;
    } else if (boost::ends_with(filename, ".mpackp")) {
        f = data_format::msgpack_portable;
    } else {
        piranha_throw(std::invalid_argument,
                      "unable to deduce the data format from the filename '" + orig_fname
                          + "'. The filename must end with one of ['.boostb','.boostp','.mpackb','.mpackp'], "
                            "optionally followed by one of ['.bz2','gz','zip'].");
    }
    return std::make_pair(c, f);
}
}


template <typename T>
inline void save_file(const T &x, const std::string &filename, data_format f, compression c)
{
    if (f == data_format::boost_binary || f == data_format::boost_portable) {
        save_file_boost_impl(x, filename, f, c);
    } else if (f == data_format::msgpack_binary || f == data_format::msgpack_portable) {
        save_file_msgpack_impl(x, filename, f, c);
    }
}


template <typename T>
inline void save_file(const T &x, const std::string &filename)
{
    const auto p = get_cdf_from_filename(filename);
    save_file(x, filename, p.second, p.first);
}


template <typename T, load_file_enabler<T> = 0>
inline void load_file(T &x, const std::string &filename, data_format f, compression c)
{
    if (f == data_format::boost_binary || f == data_format::boost_portable) {
        load_file_boost_impl(x, filename, f, c);
    } else if (f == data_format::msgpack_binary || f == data_format::msgpack_portable) {
        load_file_msgpack_impl(x, filename, f, c);
    }
}


template <typename T, load_file_enabler<T> = 0>
inline void load_file(T &x, const std::string &filename)
{
    const auto p = get_cdf_from_filename(filename);
    load_file(x, filename, p.second, p.first);
}

inline namespace impl
{

#if defined(PIRANHA_WITH_MSGPACK)

// These typedefs are useful when checking the availability of boost save/load member functions, which
// we use fairly often to implement the _impl functors.
template <typename Stream, typename T>
using msgpack_pack_member_t = decltype(
    std::declval<const T &>().msgpack_pack(std::declval<msgpack::packer<Stream> &>(), std::declval<msgpack_format>()));

template <typename T>
using msgpack_convert_member_t = decltype(
    std::declval<T &>().msgpack_convert(std::declval<const msgpack::object &>(), std::declval<msgpack_format>()));

#endif

// Utility functions to serialize ranges and vector-like types.
template <typename Archive, typename It>
inline void boost_save_range(Archive &ar, It begin, It end)
{
    for (; begin != end; ++begin) {
        boost_save(ar, *begin);
    }
}

template <typename Archive, typename V>
inline void boost_save_vector(Archive &ar, const V &v)
{
    boost_save(ar, v.size());
    boost_save_range(ar, v.begin(), v.end());
}

template <typename Archive, typename It>
inline void boost_load_range(Archive &ar, It begin, It end)
{
    for (; begin != end; ++begin) {
        boost_load(ar, *begin);
    }
}

template <typename Archive, typename V>
inline void boost_load_vector(Archive &ar, V &v)
{
    typename V::size_type size;
    boost_load(ar, size);
    v.resize(size);
    boost_load_range(ar, v.begin(), v.end());
}

// Introduce also enablers to detect when we can use the vector save/load functions.
template <typename Archive, typename V, typename T = void>
using boost_save_vector_enabler = enable_if_t<
    conjunction<has_boost_save<Archive, typename V::value_type>, has_boost_save<Archive, typename V::size_type>>::value,
    T>;

template <typename Archive, typename V, typename T = void>
using boost_load_vector_enabler = enable_if_t<
    conjunction<has_boost_load<Archive, typename V::value_type>, has_boost_load<Archive, typename V::size_type>>::value,
    T>;

#if defined(PIRANHA_WITH_MSGPACK)

template <typename Stream, typename It, typename Size>
inline void msgpack_pack_range(msgpack::packer<Stream> &p, It begin, It end, Size s, msgpack_format f)
{
    p.pack_array(safe_cast<std::uint32_t>(s));
    for (; begin != end; ++begin) {
        msgpack_pack(p, *begin, f);
    }
}

template <typename Stream, typename V>
inline void msgpack_pack_vector(msgpack::packer<Stream> &p, const V &v, msgpack_format f)
{
    msgpack_pack_range(p, v.begin(), v.end(), v.size(), f);
}

// Convert the msgpack array in o to a vector of type V.
template <typename V>
inline void msgpack_convert_array(const msgpack::object &o, V &v, msgpack_format f)
{
    // First extract a vector of objects from o.
    PIRANHA_MAYBE_TLS std::vector<msgpack::object> tmp_obj;
    o.convert(tmp_obj);
    v.resize(safe_cast<decltype(v.size())>(tmp_obj.size()));
    for (decltype(v.size()) i = 0; i < v.size(); ++i) {
        piranha::msgpack_convert(v[i], tmp_obj[static_cast<decltype(v.size())>(i)], f);
    }
}

template <typename Stream, typename V, typename T = void>
using msgpack_pack_vector_enabler
    = enable_if_t<conjunction<is_msgpack_stream<Stream>, has_msgpack_pack<Stream, typename V::value_type>,
                              has_safe_cast<std::uint32_t, typename V::size_type>>::value,
                  T>;

template <typename V, typename T = void>
using msgpack_convert_array_enabler
    = enable_if_t<conjunction<has_safe_cast<typename V::size_type, typename std::vector<msgpack::object>::size_type>,
                              has_msgpack_convert<typename V::value_type>>::value,
                  T>;

#endif
}
}

#undef PIRANHA_ZLIB_CONDITIONAL

#undef PIRANHA_BZIP2_CONDITIONAL

#endif