parameter_set.h Source File

CPP API: parameter_set.h Source File
CPP API
 /* 
 * Copyright (C) 2020-2026 MEmilio
 *
 * Authors: Jan Kleinert, Daniel Abele
 *
 * 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_UTILS_PARAMETER_SET_H
 #define MIO_UTILS_PARAMETER_SET_H
  
 #include "memilio/io/io.h"
  
 #include <tuple>
 #include <utility>
 #include <type_traits>
  
 namespace mio
 {
  
 namespace details
 {
  
 //helpers for get_default
 template <class X, class = void, class... Args>
 struct has_get_default_member_function : std::false_type {
 };
  
 template <class T, class... Args>
 struct has_get_default_member_function<T, std::void_t<decltype(T::get_default(std::declval<Args>()...))>, Args...>
     : std::true_type {
 };
  
 } // namespace details
  
 template <class T, class... Args>
 using has_get_default_member_function = details::has_get_default_member_function<T, void, Args...>;
  
 template <class Tag>
 struct ParameterTagTraits {
     using Type = typename Tag::Type;
  
     //get_default either with get_default member function or fallback on default constructor
     template <class Dummy = Tag, class... Ts>
     static std::enable_if_t<has_get_default_member_function<Dummy, Ts...>::value, Type> get_default(Ts&&... args)
     {
         return Tag::get_default(std::forward<Ts>(args)...);
     }
  
     template <class Dummy = Tag, class... Ts>
     static std::enable_if_t<
         !has_get_default_member_function<Dummy, Ts...>::value && std::is_default_constructible<Type>::value, Type>
     get_default(Ts&&...)
     {
         return Type{};
     }
 };
  
 namespace details
 {
 //stores a parameter and tags it so it can be unambiguously found in a tuple
 template <class TagT>
 class TaggedParameter
 {
 public:
     using Tag    = TagT;
     using Traits = ParameterTagTraits<Tag>;
     using Type   = typename Traits::Type;
  
     template <class... Ts, class Dummy1 = void,
               class = std::enable_if_t<std::is_constructible<Type, Ts...>::value, Dummy1>>
     TaggedParameter(Ts&&... args)
         : m_value(std::forward<Ts>(args)...)
     {
     }
  
     operator Type&()
     {
         return get();
     }
  
     operator const Type&() const
     {
         return get();
     }
  
     const Type& get() const
     {
         return m_value;
     }
  
     Type& get()
     {
         return m_value;
     }
  
     template <class T>
     bool operator==(const TaggedParameter<T>& other) const
     {
         return m_value == other.m_value;
     }
  
     template <class T>
     bool operator!=(const TaggedParameter<T>& other) const
     {
         return m_value != other.m_value;
     }
  
 private:
     Type m_value;
 };
  
 //defines value = true if predicate defines value=true for all types in parameter pack
 template <template <class...> class Pred, class... Tail>
 struct AllOf;
  
 template <template <class...> class Pred>
 struct AllOf<Pred> : public std::true_type {
 };
  
 template <template <class...> class Pred, class Head, class... Tail>
 struct AllOf<Pred, Head, Tail...> {
     static const constexpr bool value = Pred<Head>::value && AllOf<Pred, Tail...>::value;
 };
  
 //defines value = true if predicate defines value=true for any type in parameter pack
 template <template <class...> class Pred, class... Tail>
 struct AnyOf;
  
 template <template <class...> class Pred>
 struct AnyOf<Pred> : public std::false_type {
 };
  
 template <template <class...> class Pred, class Head, class... Tail>
 struct AnyOf<Pred, Head, Tail...> {
     static const constexpr bool value = Pred<Head>::value || AnyOf<Pred, Tail...>::value;
 };
  
 //for X = template<T1, T2> X => BindTail<X, A>::type<B> = X<B, A>
 template <template <class...> class F, class... Tail>
 struct BindTail {
     template <class... Head>
     struct type : F<Head..., Tail...> {
     };
     //according to the standard, this must be a real type, can't be an alias of F.
     //An alias is immediately replaced and discarded when the compiler sees it, but this could leave the template F with some
     //parameters bound and some free, which is not allowed. A struct that derives from F is persistent during compilation.
 };
  
 //for template<T1, T2> X => BindHead<X, A>::type<B> = X<A, B>
 template <template <class...> class F, class... Head>
 struct BindHead {
     template <class... Tail>
     struct type : F<Head..., Tail...> {
     };
     //can't be an alias, see BindTail
 };
  
 } // namespace details
  
 struct NoDefaultInit {
 };
  
 template <typename T>
 using is_no_default_init_tag = std::is_same<NoDefaultInit, T>;
  
 template <class... Tags>
 class ParameterSet
 {
 public:
     template <
         class Dummy = void,
         class = std::enable_if_t<details::AllOf<std::is_default_constructible, typename Tags::Type...>::value, Dummy>>
     explicit ParameterSet(NoDefaultInit)
     {
     }
  
     template <class Dummy = void,
               class       = std::enable_if_t<
                         details::AllOf<has_get_default_member_function, ParameterTagTraits<Tags>...>::value, Dummy>>
     ParameterSet()
         : m_tup(ParameterTagTraits<Tags>::get_default()...)
     {
     }
  
     template <
         class T1, class... TN,
         class = std::enable_if_t<
             // Avoid erroneous template deduction for T1=ParameterSet as this constructor could falsely be considered
             // as a copy constructor for non-const lvalue references.
             !std::is_same_v<std::decay_t<T1>, ParameterSet> &&
             details::AllOf<details::BindTail<has_get_default_member_function, T1, TN...>::template type,
                            ParameterTagTraits<Tags>...>::value>>
     explicit ParameterSet(T1&& arg1, TN&&... argn)
         : m_tup(ParameterTagTraits<Tags>::get_default(arg1, argn...)...)
     {
     }
  
     template <class Tag>
     const typename ParameterTagTraits<Tag>::Type& get() const
     {
         return std::get<details::TaggedParameter<Tag>>(m_tup).get();
     }
  
     template <class Tag>
     typename ParameterTagTraits<Tag>::Type& get()
     {
         return std::get<details::TaggedParameter<Tag>>(m_tup).get();
     }
  
     template <class Tag>
     void set(const typename ParameterTagTraits<Tag>::Type& value)
     {
         get<Tag>() = value;
     }
  
     template <class Tag, class T>
     void set(T&& arg)
     {
         get<Tag>() = std::forward<T>(arg);
     }
  
     template <class Tag, class... T>
     std::enable_if_t<has_get_default_member_function<ParameterTagTraits<Tag>, T...>::value, void> set_default(T&&... ts)
     {
         get<Tag>() = ParameterTagTraits<Tag>::get_default(std::forward<T>(ts)...);
     }
  
     static constexpr size_t size()
     {
         return sizeof...(Tags);
     }
  
     bool operator==(const ParameterSet& b) const
     {
         return m_tup == b.m_tup;
     }
  
     bool operator!=(const ParameterSet& b) const
     {
         return m_tup != b.m_tup;
     }
  
     template <class IOContext>
     void serialize(IOContext& io) const
     {
         auto obj = io.create_object("ParameterSet");
         foreach (*this, [&obj](auto& p, auto t) mutable {
             using Tag = decltype(t);
             obj.add_element(Tag::name(), p);
         })
             ;
     }
  
 private:
     template <class Dummy = void, class = std::enable_if_t<(sizeof...(Tags) > 0), Dummy>, class = Dummy>
     ParameterSet(const typename Tags::Type&... t)
         : m_tup(t...)
     {
     }
  
     //entry to recursively deserialize all parameters in the ParameterSet
     //IOContext: serializer
     //IOObject: object that stores the serialized ParameterSet
     //Rs: IOResult<T> for each Parameter Tag that has already been deserialized
     template <class IOContext, class IOObject, class... Rs,
               std::enable_if_t<(sizeof...(Rs) < sizeof...(Tags)), void*> = nullptr>
     static IOResult<ParameterSet> deserialize_recursive(IOContext& io, IOObject& obj, Rs&&... rs)
     {
         //read current parameter, append result to results of previous parameters, recurse to next parameter
         using TaggedParameter = std::tuple_element_t<sizeof...(Rs), decltype(ParameterSet::m_tup)>;
         auto r = obj.expect_element(TaggedParameter::Tag::name(), mio::Tag<typename TaggedParameter::Type>{});
         return deserialize_recursive(io, obj, std::forward<Rs>(rs)..., std::move(r));
     }
  
     //end of recursion to deserialize parameters in the ParameterSet
     template <class IOContext, class IOObject, class... Rs,
               std::enable_if_t<(sizeof...(Rs) == sizeof...(Tags)), void*> = nullptr>
     static IOResult<ParameterSet> deserialize_recursive(IOContext& io, IOObject& /*obj*/, Rs&&... rs)
     {
         //one result for each parameters, so no more parameters to read
         //expand results, build finished ParameterSet, stop recursion
         return mio::apply(
             io,
             [](const typename Tags::Type&... t) {
                 return ParameterSet(t...);
             },
             std::forward<Rs>(rs)...);
     }
  
 public:
     template <class IOContext>
     static IOResult<ParameterSet> deserialize(IOContext& io)
     {
         auto obj = io.expect_object("ParameterSet");
         return deserialize_recursive(io, obj);
     }
  
 private:
     std::tuple<details::TaggedParameter<Tags>...> m_tup;
 };
  
 namespace details
 {
 //helpers for ParameterTag
 template <size_t I, class ParamSet>
 struct ParameterTag;
  
 template <size_t I, class Head, class... Tail>
 struct ParameterTag<I, ParameterSet<Head, Tail...>> : public ParameterTag<I - 1, ParameterSet<Tail...>> {
 };
  
 template <class Head, class... Tail>
 struct ParameterTag<0, ParameterSet<Head, Tail...>> {
     using Type = Head;
 };
 } // namespace details
  
 template <size_t I, class ParamSet>
 using ParameterTag = details::ParameterTag<I, ParamSet>;
  
 template <size_t I, class ParamSet>
 using ParameterTagT = typename ParameterTag<I, ParamSet>::Type;
  
 namespace details
 {
 //helpers for foreach
 template <class... Tail, class Params, class F>
 std::enable_if_t<sizeof...(Tail) == 0, void> foreach_impl(Params&&, F)
 {
 }
  
 template <class Head, class... Tail, class Params, class F>
 void foreach_impl(Params&& p, F f)
 {
     f(p.template get<Head>(), Head{});
     foreach_impl<Tail...>(p, f);
 }
  
 template <class Params, size_t... Tail, class F>
 std::enable_if_t<sizeof...(Tail) == 0, void> foreach_tag_impl(F, std::index_sequence<Tail...>)
 {
 }
  
 template <class Params, size_t Head, size_t... Tail, class F>
 void foreach_tag_impl(F f, std::index_sequence<Head, Tail...>)
 {
     f(ParameterTagT<Head, Params>{});
     foreach_tag_impl<Params, Tail...>(f, std::index_sequence<Tail...>{});
 }
 } // namespace details
  
 template <class Params, class F>
 void foreach_tag(F f)
 {
     details::foreach_tag_impl<Params>(f, std::make_index_sequence<Params::size()>{});
 }
  
 template <class F, class... Tags>
 void foreach (const ParameterSet<Tags...>& p, F f)
 {
     details::foreach_impl<Tags...>(p, f);
 }
  
 template <class F, class... Tags>
 void foreach (ParameterSet<Tags...>& p, F f)
 {
     details::foreach_impl<Tags...>(p, f);
 }
  
 } // namespace mio
  
 #endif // MIO_UTILS_PARAMETER_SET_H