Invoke.hpp

Go to the documentation of this file.

#pragma once
#include <Pothos/Config.hpp>
#include <type_traits>
#include <utility> //std::declval

namespace Pothos {
namespace serialization {

    class VersionType
    {
    public:
        VersionType(const unsigned int ver):
            ver(ver)
        {
            return;
        }

        operator const unsigned int &(void) const
        {
            return ver;
        }

        operator unsigned int &(void)
        {
            return ver;
        }

    private:
        unsigned int ver;
    };

    template <typename T, typename Archive>
    struct hasSerialize
    {
        template <typename U>
        static auto test(U* p) -> decltype(p->serialize(std::declval<Archive&>(), std::declval<const unsigned int>()));

        template <typename U>
        static auto test(...) -> std::false_type;

        using type = typename std::is_same<decltype(test<T>(nullptr)), void>::type;
        static const auto value = type::value;
    };

    template <typename Archive, typename T>
    typename std::enable_if<Archive::isSave::value>::type
    invokeSplit(Archive &ar, T &value, const unsigned int ver)
    {
        const VersionType vt(ver);
        save(ar, value, vt);
    }

    template <typename Archive, typename T>
    typename std::enable_if<!Archive::isSave::value>::type
    invokeSplit(Archive &ar, T &value, const unsigned int ver)
    {
        const VersionType vt(ver);
        load(ar, value, vt);
    }

    template <typename Archive, typename T>
    typename std::enable_if<!hasSerialize<T, Archive>::value>::type
    invokeSerialize(Archive &ar, T &value, const unsigned int ver)
    {
        const VersionType vt(ver);
        serialize(ar, value, vt);
    }

    template <typename Archive, typename T>
    typename std::enable_if<hasSerialize<T, Archive>::value>::type
    invokeSerialize(Archive &ar, T &value, const unsigned int ver)
    {
        value.serialize(ar, ver);
    }

} //namespace serialization
} //namespace Pothos