variant_helpers.h

// SPDX-FileCopyrightText: © 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "utils/traits.h"
 
#include <QObject>
#include <QVariant>
 
namespace zrythm::utils
{
 
// Primary template (false for non-variant types)
template <typename T, typename Variant, typename = void>
struct is_in_variant : std::false_type
{
};
 
// Specialization for std::variant types
template <typename T, typename... Ts>
struct is_in_variant<
  T,
  std::variant<Ts...>,
  std::void_t<decltype (std::variant<Ts...> ())>>
    : std::bool_constant<(std::is_same_v<T, Ts> || ...)>
{
};
 
// Concept that checks that T is one of the types in Variant
template <typename T, typename Variant>
concept IsInVariant = is_in_variant<T, Variant>::value;
 
namespace detail_test
{
using MyVariant = std::variant<int, double, std::string>;
static_assert (IsInVariant<int, MyVariant>);    // Passes
static_assert (IsInVariant<double, MyVariant>); // Passes
static_assert (!IsInVariant<float, MyVariant>); // Fails (not in variant)
static_assert (!IsInVariant<int, int>);         // Fails (not a variant)
}
 
// Helper struct to merge multiple std::variant types
template <typename... Variants> struct merge_variants;
 
// Type alias for easier use of the merge_variants struct
template <typename... Variants>
using merge_variants_t = typename merge_variants<Variants...>::type;
 
// Base case: single variant, no merging needed
template <typename Variant> struct merge_variants<Variant>
{
  using type = Variant;
};
 
// Recursive case: merge two variants and continue with the rest
template <typename... Types1, typename... Types2, typename... Rest>
struct merge_variants<std::variant<Types1...>, std::variant<Types2...>, Rest...>
{
  // Merge the first two variants and recursively merge with the rest
  using type = merge_variants_t<std::variant<Types1..., Types2...>, Rest...>;
};
 
// Usage example:
// using Variant1 = std::variant<int, float>;
// using Variant2 = std::variant<char, double>;
// using MergedVariant = merge_variants_t<Variant1, Variant2>;
// MergedVariant is now std::variant<int, float, char, double>

template <typename Variant> struct to_reference_variant_impl;

template <typename... Ts> struct to_reference_variant_impl<std::variant<Ts...>>
{
  using type = std::variant<std::reference_wrapper<Ts>...>;
};

template <typename Variant>
using to_reference_variant = typename to_reference_variant_impl<Variant>::type;
 
// same for const ref
template <typename Variant> struct to_const_reference_variant_impl;
template <typename... Ts>
struct to_const_reference_variant_impl<std::variant<Ts...>>
{
  using type = std::variant<std::reference_wrapper<const Ts>...>;
};
template <typename Variant>
using to_const_reference_variant =
  typename to_const_reference_variant_impl<Variant>::type;

template <typename Variant> struct to_unique_ptr_variant_impl;

template <typename... Ts> struct to_unique_ptr_variant_impl<std::variant<Ts...>>
{
  using type = std::variant<std::unique_ptr<Ts>...>;
};

template <typename Variant>
using to_unique_ptr_variant = typename to_unique_ptr_variant_impl<Variant>::type;

template <typename Variant> struct to_pointer_variant_impl;

template <typename... Ts> struct to_pointer_variant_impl<std::variant<Ts...>>
{
  using type = std::variant<std::add_pointer_t<Ts>...>;
};

template <typename Variant>
using to_pointer_variant = typename to_pointer_variant_impl<Variant>::type;
 
namespace detail
{
 
template <typename Variant, typename Base, typename CastFn>
auto
convert_to_variant_impl (const Base * base_ptr, CastFn &&cast_fn) -> Variant
{
  if (!base_ptr)
    {
      return Variant{};
    }
 
  Variant result{};
 
  auto trycast = [&]<typename T> () {
    if (auto derived = cast_fn.template operator()<T> (base_ptr))
      {
        result = const_cast<T *> (derived);
        return true;
      }
    return false;
  };
 
  auto try_all_casts = [&]<typename... Ts> (std::variant<Ts...> *) {
    return (trycast.template operator()<std::remove_pointer_t<Ts>> () || ...);
  };
 
  if (!try_all_casts (static_cast<Variant *> (nullptr)))
    {
      throw std::runtime_error ("convert_to_variant: no matching type");
    }
 
  return result;
}
} // namespace detail

template <typename Variant, typename Base>
  requires std::is_pointer_v<std::variant_alternative_t<0, Variant>>
auto
convert_to_variant (const Base * base_ptr) -> Variant
{
  return detail::convert_to_variant_impl<Variant> (
    base_ptr,
    []<typename T> (const Base * p) { return dynamic_cast<const T *> (p); });
}

template <typename Variant, typename Base>
  requires std::is_pointer_v<std::variant_alternative_t<0, Variant>>
           && std::derived_from<Base, QObject>
auto
convert_to_variant_qobj (const Base * base_ptr) -> Variant
{
  return detail::convert_to_variant_impl<Variant> (
    base_ptr,
    []<typename T> (const Base * p) { return qobject_cast<const T *> (p); });
}

template <class... Ts> struct overload : Ts...
{
  using Ts::operator()...;
};

template <typename Variant, template <typename> class Wrapper>
struct wrap_variant_impl;

template <typename... Ts, template <typename> class Wrapper>
struct wrap_variant_impl<std::variant<Ts...>, Wrapper>
{
  using type = std::variant<Wrapper<Ts>...>;
};

template <typename Variant, template <typename> class Wrapper>
using wrap_variant_t = typename wrap_variant_impl<Variant, Wrapper>::type;
} // namespace zrythm::utils