icloneable.h

// SPDX-FileCopyrightText: © 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <memory>
#include <type_traits>
#include <variant>
#include <vector>
 
#include "utils/qt.h"
#include "utils/traits.h"
#include "utils/variant_helpers.h"
 
namespace zrythm::utils
{
 
enum class ObjectCloneType
{
  Snapshot,

  NewIdentity,
};

template <typename T>
concept CloneableObject =
  requires (T &obj, const T &other, ObjectCloneType clone_type) {
    { init_from (obj, other, clone_type) } -> std::same_as<void>;
  };
 
template <CloneableObject Derived, typename... Args>
std::unique_ptr<Derived>
clone_unique (
  const Derived  &obj,
  ObjectCloneType clone_type = ObjectCloneType::Snapshot,
  Args &&... args)
{
  std::unique_ptr<Derived> cloned;
  cloned = std::make_unique<Derived> (std::forward<Args> (args)...);
  init_from (*cloned, obj, clone_type);
  return cloned;
}
 
template <CloneableObject Derived, typename... Args>
std::shared_ptr<Derived>
clone_shared (
  const Derived  &obj,
  ObjectCloneType clone_type = ObjectCloneType::Snapshot,
  Args &&... args)
{
  std::shared_ptr<Derived> cloned;
  cloned = std::make_shared<Derived> (std::forward<Args> (args)...);
  init_from (*cloned, obj, clone_type);
  return cloned;
}
 
template <CloneableObject Derived, typename... Args>
Derived *
clone_raw_ptr (
  const Derived  &obj,
  ObjectCloneType clone_type = ObjectCloneType::Snapshot,
  Args &&... args)
{
  auto unique_ptr = clone_unique (obj, clone_type, std::forward<Args> (args)...);
  return unique_ptr.release ();
}
 
template <CloneableObject Derived, typename... Args>
Derived *
clone_qobject (
  const Derived  &obj,
  QObject *       parent,
  ObjectCloneType clone_type = ObjectCloneType::Snapshot,
  Args &&... args)
  requires utils::QObjectDerived<Derived>
{
  auto * cloned = clone_raw_ptr (obj, clone_type, std::forward<Args> (args)...);
  if (cloned)
    {
      cloned->setParent (parent);
    }
  return cloned;
}
 
template <CloneableObject Derived, typename... Args>
utils::QObjectUniquePtr<Derived>
clone_unique_qobject (
  const Derived  &obj,
  QObject *       parent,
  ObjectCloneType clone_type = ObjectCloneType::Snapshot,
  Args &&... args)
  requires utils::QObjectDerived<Derived>
{
  return utils::QObjectUniquePtr<Derived> (
    clone_qobject (obj, parent, clone_type, std::forward<Args> (args)...));
}

template <typename T>
concept CloneableDefaultInitializableObject =
  CloneableObject<T> && std::default_initializable<T>;

template <typename T, typename Base>
concept InheritsFromBase = std::is_base_of_v<Base, std::remove_pointer_t<T>>;

template <typename Variant, typename Base>
concept AllInheritFromBase = requires {
  []<typename... Ts> (std::variant<Ts...> *) {
    static_assert (
      (InheritsFromBase<Ts, Base> && ...),
      "All types in Variant must inherit from Base");
  }(static_cast<Variant *> (nullptr));
};

template <typename T, std::size_t N>
void
clone_unique_ptr_array (
  std::array<std::unique_ptr<T>, N>       &dest,
  const std::array<std::unique_ptr<T>, N> &src,
  ObjectCloneType clone_type = ObjectCloneType::Snapshot)
{
  for (size_t i = 0; i < N; ++i)
    {
      if (src[i])
        {
          if constexpr (CloneableDefaultInitializableObject<T>)
            {
              dest[i] =
                clone_unique (*src[i], clone_type = ObjectCloneType::Snapshot);
            }
          else
            {
              dest[i] = std::make_unique<T> (*src[i]);
            }
        }
      else
        {
          dest[i] = nullptr;
        }
    }
}

template <typename T, template <typename...> class Ptr>
void
clone_ptr_vector (
  std::vector<Ptr<T>>       &dest,
  const std::vector<Ptr<T>> &src,
  ObjectCloneType            clone_type = ObjectCloneType::Snapshot)
{
  dest.clear ();
  dest.reserve (src.size ());
 
  for (const auto &ptr : src)
    {
      if (ptr)
        {
          if constexpr (CloneableDefaultInitializableObject<T>)
            {
              if constexpr (std::is_same_v<Ptr<T>, std::unique_ptr<T>>)
                {
                  dest.push_back (clone_unique (
                    *ptr, clone_type = ObjectCloneType::Snapshot));
                }
              else if constexpr (std::is_same_v<Ptr<T>, std::shared_ptr<T>>)
                {
                  dest.push_back (clone_shared (
                    *ptr, clone_type = ObjectCloneType::Snapshot));
                }
            }
          else
            {
              if constexpr (std::is_same_v<Ptr<T>, std::unique_ptr<T>>)
                {
                  dest.push_back (std::make_unique<T> (*ptr));
                }
              else if constexpr (std::is_same_v<Ptr<T>, std::shared_ptr<T>>)
                {
                  dest.push_back (std::make_shared<T> (*ptr));
                }
            }
        }
      else
        {
          dest.push_back (nullptr);
        }
    }
}

template <typename Container>
void
clone_unique_ptr_container (
  Container       &dest,
  const Container &src,
  ObjectCloneType  clone_type = ObjectCloneType::Snapshot)
{
  if constexpr (StdArray<Container>)
    {
      clone_unique_ptr_array (dest, src, clone_type = ObjectCloneType::Snapshot);
    }
  else
    {
      clone_ptr_vector (dest, src, clone_type = ObjectCloneType::Snapshot);
    }
}
 
template <typename Container, typename Variant, typename Base>
  requires AllInheritFromBase<Variant, Base>
void
clone_variant_container (
  Container       &dest,
  const Container &src,
  ObjectCloneType  clone_type = ObjectCloneType::Snapshot)
{
  if constexpr (StdArray<Container>)
    {
      for (size_t i = 0; i < src.size (); ++i)
        {
          if (src[i])
            {
              dest[i] = clone_unique_with_variant<Variant, Base> (
                src[i].get (), clone_type = ObjectCloneType::Snapshot);
            }
          else
            {
              dest[i] = nullptr;
            }
        }
    }
  else
    {
      dest.clear ();
      dest.reserve (src.size ());
 
      for (const auto &ptr : src)
        {
          if (ptr)
            {
              dest.push_back (
                clone_unique_with_variant<Variant, Base> (
                  ptr.get (), clone_type = ObjectCloneType::Snapshot));
            }
          else
            {
              dest.push_back (nullptr);
            }
        }
    }
}

template <typename Variant, typename Container>
  requires AllInheritFromBase<Variant, typename Container::value_type::element_type>
void
clone_variant_container (
  Container       &dest,
  const Container &src,
  ObjectCloneType  clone_type = ObjectCloneType::Snapshot)
{
  using Base = typename Container::value_type::element_type;
 
  if constexpr (StdArray<Container>)
    {
      // Handle std::array
      for (size_t i = 0; i < src.size (); ++i)
        {
          if (src[i])
            {
              dest[i] = clone_unique_with_variant<Variant, Base> (
                src[i].get (), clone_type = ObjectCloneType::Snapshot);
            }
          else
            {
              dest[i] = nullptr;
            }
        }
    }
  else
    {
      // Handle std::vector or similar containers
      dest.clear ();
      dest.reserve (src.size ());
 
      for (const auto &ptr : src)
        {
          if (ptr)
            {
              dest.push_back (
                clone_unique_with_variant<Variant, Base> (
                  ptr.get (), clone_type = ObjectCloneType::Snapshot));
            }
          else
            {
              dest.push_back (nullptr);
            }
        }
    }
}
 
} // namespace zrythm::utils