#include <boost/archive/detail/common_oarchive.hpp>
#include <boost/archive/detail/register_archive.hpp>

namespace hasher
{

template <typename Hasher>
class oarchive : public boost::archive::detail::common_oarchive< oarchive<Hasher> >
{
    friend class boost::archive::save_access;

public:
    oarchive()
    {}

    std::size_t get()
    {
        return static_cast<std::size_t>(h);
    }

    template <typename T>
    void save_override(const T& data, long /* version */)
    {
        boost::archive::save(*this->This(), data);
    }

    void save(int value)
    {
        h.append(std::addressof(value), sizeof(value));
    }

    // Ignore these
    void save_override(const boost::archive::version_type, int) {}
    void save_override(const boost::archive::object_id_type, int) {}
    void save_override(const boost::archive::object_reference_type, int) {}
    void save_override(const boost::archive::class_id_type, int) {}
    void save_override(const boost::archive::class_id_optional_type, int) {}
    void save_override(const boost::archive::class_id_reference_type, int) {}
    void save_override(const boost::archive::tracking_type, int) {}
    void save_override(const boost::archive::class_name_type&, int) {}

private:
    Hasher h;
};


class fnv1a
{
    std::intmax_t state_ = 14695981039346656037u;
public:
    void append(void const* key, std::size_t len) noexcept
    {
        unsigned char const* p = static_cast<unsigned char const*>(key);
        unsigned char const* const e = p + len;
        for (; p < e; ++p)
            state_ = (state_ ^ *p) * 1099511628211u;
    }

    explicit operator std::size_t() noexcept
    {
        return state_;
    }
};

} // namespace hasher

#include <boost/serialization/split_free.hpp>
namespace boost
{
namespace serialization
{

template <typename Archive, typename T1, typename T2>
void save(Archive& archive,
          const std::pair<T1, T2>& data,
          const unsigned int /* version */)
{
    archive << data.first;
    archive << data.second;
}

template <typename Archive, typename T1, typename T2>
void serialize(Archive& archive, 
               std::pair<T1, T2>& data,
               const unsigned int version)
{
    boost::serialization::split_free(archive, data, version);
}

} // namespace serialization
} // namespace boost

#include <vector>
#include <tuple>

class X
{
    std::pair<short, unsigned char> alpha;

public:
    X()
        : alpha{1999, 1}
    {
    }

    template<typename T>
    void serialize(T& archive, const unsigned int)
    {
        // archive & alpha;
    }
    template<typename T>
    void serialize(hasher::oarchive<T>& archive, const unsigned int)
    {
        archive & alpha;
    }
};

#include <iostream>
#include <boost/serialization/serialization.hpp>

int main(int argc, char *argv[])
{
    X x;
    hasher::oarchive<hasher::fnv1a> archive;
    archive << x; // Succeeds
    archive << 42 << x; // Fails
    std::size_t result = archive.get();
    std::cout << result << std::endl;
    return 0;
}