default_serialize.h

Go to the documentation of this file.

/*
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Rene Schmieding
*
* Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MIO_IO_DEFAULT_SERIALIZE_H_
#define MIO_IO_DEFAULT_SERIALIZE_H_
 
#include "memilio/io/io.h"
 
#include <tuple>
 
namespace mio
{
 
template <class ValueType>
struct NamedRef {
    using Reference = ValueType&;
 
    const char* name;
    Reference value;
 
    explicit NamedRef(const char* n, Reference v)
        : name(n)
        , value(v)
    {
    }
};
 
namespace details
{
template <class IOObject, class Member>
void add_named_ref(IOObject& obj, const NamedRef<Member> named_ref)
{
    obj.add_element(named_ref.name, named_ref.value);
}
 
template <class IOContext, class... Members>
void default_serialize_impl(IOContext& io, const char* name, const NamedRef<Members>... named_refs)
{
    auto obj = io.create_object(name);
    (add_named_ref(obj, named_refs), ...);
}
 
template <class IOObject, class Member>
IOResult<Member> expect_named_ref(IOObject& obj, const NamedRef<Member> named_ref)
{
    return obj.expect_element(named_ref.name, Tag<Member>{});
}
 
template <class IOContext, class DefaultSerializable, class... Members>
IOResult<DefaultSerializable> default_deserialize_impl(IOContext& io, DefaultSerializable& a, const char* name,
                                                       NamedRef<Members>... named_refs)
{
    auto obj = io.expect_object(name);
 
    // we cannot use expect_named_ref directly in apply, as function arguments have no guarantueed order of evaluation
    std::tuple<IOResult<Members>...> results{expect_named_ref(obj, named_refs)...};
 
    return apply(
        io,
        [&a, &named_refs...](const Members&... result_values) {
            // if all results are successfully deserialized, they are unpacked into result_values
            // then all class variables are overwritten (via the named_refs) with these values
            ((named_refs.value = result_values), ...);
            return a;
        },
        results);
}
 
} // namespace details
 
template <class... ValueTypes>
struct Members {
    // allow other Members access to the private constructor
    template <class...>
    friend struct Members;
 
    Members(const char* class_name)
        : name(class_name)
        , named_refs()
    {
    }
 
    template <class T>
    [[nodiscard]] Members<ValueTypes..., T> add(const char* member_name, T& member)
    {
        return Members<ValueTypes..., T>{name, std::tuple_cat(named_refs, std::tuple(NamedRef{member_name, member}))};
    }
 
    const char* name; 
    std::tuple<NamedRef<ValueTypes>...> named_refs; 
 
private:
    Members(const char* class_name, std::tuple<NamedRef<ValueTypes>...> named_references)
        : name(class_name)
        , named_refs(named_references)
    {
    }
};
 
template <class T>
struct DefaultFactory {
    static T create()
    {
        return T{};
    }
};
 
template <class T, class IOContext>
concept IsDefaultSerializable = requires(T t) {
    t.default_serialize();
    !HasSerialize<T, IOContext>;
};
 
template <class T, class IOContext>
concept IsDefaultDeserializable = requires(T t) {
    t.default_serialize();
    !HasDeserialize<T, IOContext>;
};
 
template <class IOContext, IsDefaultSerializable<IOContext> T>
void serialize_internal(IOContext& io, const T& a)
{
    // Note that the following const_cast is safe as long as we do not modify members.
    const auto members = const_cast<T&>(a).default_serialize();
    // unpack members and serialize
    std::apply(
        [&io, &members](auto... named_refs) {
            details::default_serialize_impl(io, members.name, named_refs...);
        },
        members.named_refs);
}
 
template <class IOContext, IsDefaultDeserializable<IOContext> T>
IOResult<T> deserialize_internal(IOContext& io, Tag<T> tag)
{
    mio::unused(tag);
    T a          = DefaultFactory<T>::create();
    auto members = a.default_serialize();
    // unpack members and deserialize
    return std::apply(
        [&io, &members, &a](auto... named_refs) {
            return details::default_deserialize_impl(io, a, members.name, named_refs...);
        },
        members.named_refs);
}
 
} // namespace mio
 
#endif // MIO_IO_DEFAULT_SERIALIZE_H_