polymorphic_object.hpp

// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_BASE_POLYMORPHIC_OBJECT_HPP_
#define GKO_PUBLIC_CORE_BASE_POLYMORPHIC_OBJECT_HPP_
 
 
#include <memory>
#include <type_traits>
 
#include <ginkgo/core/base/executor.hpp>
#include <ginkgo/core/base/utils.hpp>
#include <ginkgo/core/log/logger.hpp>
 
 
namespace gko {
namespace experimental {
namespace distributed {
 
 
class DistributedBase;
 
 
}  // namespace distributed
}  // namespace experimental
 
 
class PolymorphicObject : public log::EnableLogging<PolymorphicObject> {
public:
    virtual ~PolymorphicObject()
    {
        this->template log<log::Logger::polymorphic_object_deleted>(exec_.get(),
                                                                    this);
    }
 
    // preserve the executor of the object
    PolymorphicObject& operator=(const PolymorphicObject&) { return *this; }
 
    std::shared_ptr<const Executor> get_executor() const noexcept
    {
        return exec_;
    }
 
protected:
    // This method is defined as protected since a polymorphic object should not
    // be created using their constructor directly, but by creating an
    // std::unique_ptr to it. Defining the constructor as protected keeps these
    // access rights when inheriting the constructor.
    explicit PolymorphicObject(std::shared_ptr<const Executor> exec)
        : exec_{std::move(exec)}
    {}
 
    // preserve the executor of the object
    explicit PolymorphicObject(const PolymorphicObject& other)
    {
        *this = other;
    }
 
private:
    std::shared_ptr<const Executor> exec_;
};
 
 
#define GKO_ENABLE_SELF(_type)                                   \
    _type* self() noexcept { return static_cast<_type*>(this); } \
                                                                 \
    const _type* self() const noexcept                           \
    {                                                            \
        return static_cast<const _type*>(this);                  \
    }
 
 
template <typename ResultType>
class ConvertibleTo {
public:
    using result_type = ResultType;
 
    virtual ~ConvertibleTo() = default;
 
    virtual void convert_to(result_type* result) const = 0;
 
    void convert_to(ptr_param<result_type> result) const
    {
        convert_to(result.get());
    }
 
    virtual void move_to(result_type* result) = 0;
 
    void move_to(ptr_param<result_type> result) { move_to(result.get()); }
};
 
 
namespace detail {
 
 
template <typename R, typename T>
std::unique_ptr<R, std::function<void(R*)>> copy_and_convert_to_impl(
    std::shared_ptr<const Executor> exec, T* obj)
{
    auto obj_as_r = dynamic_cast<R*>(obj);
    if (obj_as_r != nullptr && obj->get_executor() == exec) {
        // FIXME: this breaks lifetimes
        return {obj_as_r, [](R*) {}};
    } else {
        auto copy = R::create(exec);
        as<ConvertibleTo<std::decay_t<R>>>(obj)->convert_to(copy);
        return {copy.release(), std::default_delete<R>{}};
    }
}
 
 
template <typename R, typename T>
std::shared_ptr<R> copy_and_convert_to_impl(
    std::shared_ptr<const Executor> exec, std::shared_ptr<T> obj)
{
    auto obj_as_r = std::dynamic_pointer_cast<R>(obj);
    if (obj_as_r != nullptr && obj->get_executor() == exec) {
        return obj_as_r;
    } else {
        auto copy = R::create(exec);
        as<ConvertibleTo<std::decay_t<R>>>(obj.get())->convert_to(copy);
        return {std::move(copy)};
    }
}
 
 
}  // namespace detail
 
 
template <typename R, typename T>
std::unique_ptr<R, std::function<void(R*)>> copy_and_convert_to(
    std::shared_ptr<const Executor> exec, T* obj)
{
    return detail::copy_and_convert_to_impl<R>(std::move(exec), obj);
}
 
 
template <typename R, typename T>
std::unique_ptr<const R, std::function<void(const R*)>> copy_and_convert_to(
    std::shared_ptr<const Executor> exec, const T* obj)
{
    return detail::copy_and_convert_to_impl<const R>(std::move(exec), obj);
}
 
 
template <typename R, typename T>
std::shared_ptr<R> copy_and_convert_to(std::shared_ptr<const Executor> exec,
                                       std::shared_ptr<T> obj)
{
    return detail::copy_and_convert_to_impl<R>(std::move(exec), obj);
}
 
 
template <typename R, typename T>
std::shared_ptr<const R> copy_and_convert_to(
    std::shared_ptr<const Executor> exec, std::shared_ptr<const T> obj)
{
    return detail::copy_and_convert_to_impl<const R>(std::move(exec), obj);
}
 
 
class Cloneable {
public:
    virtual ~Cloneable() = default;
 
    [[nodiscard]] std::unique_ptr<Cloneable> clone(
        std::shared_ptr<const Executor> exec) const
    {
        return this->clone_impl(std::move(exec));
    }
 
    [[nodiscard]] std::unique_ptr<Cloneable> clone() const
    {
        return this->clone_impl();
    }
 
    Cloneable* copy_from(ptr_param<const Cloneable> other)
    {
        auto copied = this->copy_from_impl(other.get());
        return copied;
    }
 
    Cloneable* move_from(ptr_param<Cloneable> other)
    {
        auto moved = this->move_from_impl(other.get());
        return moved;
    }
 
    [[nodiscard]] std::unique_ptr<Cloneable> create_default(
        std::shared_ptr<const Executor> exec) const
    {
        return this->create_default_impl(std::move(exec));
    }
 
    [[nodiscard]] std::unique_ptr<Cloneable> create_default() const
    {
        return this->create_default_impl();
    }
 
protected:
    virtual Cloneable* copy_from_impl(const Cloneable* other) = 0;
 
    virtual Cloneable* copy_from_impl(std::unique_ptr<Cloneable> other) = 0;
 
    virtual Cloneable* move_from_impl(Cloneable* other) = 0;
 
    virtual Cloneable* move_from_impl(std::unique_ptr<Cloneable> other) = 0;
 
    [[nodiscard]] virtual std::unique_ptr<Cloneable> clone_impl(
        std::shared_ptr<const Executor> exec) const = 0;
 
    [[nodiscard]] virtual std::unique_ptr<Cloneable> clone_impl() const = 0;
 
    [[nodiscard]] virtual std::unique_ptr<Cloneable> create_default_impl()
        const = 0;
 
    [[nodiscard]] virtual std::unique_ptr<Cloneable> create_default_impl(
        std::shared_ptr<const Executor> exec) const = 0;
};
 
 
template <typename ConcreteType>
class EnableCloneable : public ConvertibleTo<ConcreteType>, public Cloneable {
public:
    using result_type = ConcreteType;
    using ConvertibleTo<result_type>::convert_to;
    using ConvertibleTo<result_type>::move_to;
 
    [[nodiscard]] std::unique_ptr<ConcreteType> clone(
        std::shared_ptr<const Executor> exec) const
    {
        return as<ConcreteType>(this->clone_impl(std::move(exec)));
    }
 
    [[nodiscard]] std::unique_ptr<ConcreteType> clone() const
    {
        return as<ConcreteType>(this->clone_impl());
    }
 
    void convert_to(result_type* result) const override { *result = *self(); }
 
    void move_to(result_type* result) override { *result = std::move(*self()); }
 
    [[nodiscard]] std::unique_ptr<ConcreteType> create_default() const
    {
        return as<ConcreteType>(this->create_default_impl());
    }
 
    [[nodiscard]] std::unique_ptr<ConcreteType> create_default(
        std::shared_ptr<const Executor> exec) const
    {
        return as<ConcreteType>(this->create_default_impl(std::move(exec)));
    }
 
protected:
    Cloneable* copy_from_impl(const Cloneable* other) override
    {
        self()->template log<log::Logger::polymorphic_object_copy_started>(
            self()->get_executor().get(),
            dynamic_cast<const PolymorphicObject*>(other),
            dynamic_cast<const PolymorphicObject*>(this));
        as<ConvertibleTo<ConcreteType>>(other)->convert_to(self());
        self()->template log<log::Logger::polymorphic_object_copy_completed>(
            self()->get_executor().get(),
            dynamic_cast<const PolymorphicObject*>(other),
            dynamic_cast<const PolymorphicObject*>(this));
        return this;
    }
 
    Cloneable* copy_from_impl(std::unique_ptr<Cloneable> other) override
    {
        self()->template log<log::Logger::polymorphic_object_copy_started>(
            self()->get_executor().get(),
            dynamic_cast<const PolymorphicObject*>(other.get()),
            dynamic_cast<const PolymorphicObject*>(this));
        as<ConvertibleTo<ConcreteType>>(other.get())->convert_to(self());
        self()->template log<log::Logger::polymorphic_object_copy_completed>(
            self()->get_executor().get(),
            dynamic_cast<const PolymorphicObject*>(other.get()),
            dynamic_cast<const PolymorphicObject*>(this));
        return this;
    }
 
    Cloneable* move_from_impl(Cloneable* other) override
    {
        self()->template log<log::Logger::polymorphic_object_move_started>(
            self()->get_executor().get(),
            dynamic_cast<const PolymorphicObject*>(other),
            dynamic_cast<const PolymorphicObject*>(this));
        as<ConvertibleTo<ConcreteType>>(other)->move_to(self());
        self()->template log<log::Logger::polymorphic_object_move_completed>(
            self()->get_executor().get(),
            dynamic_cast<const PolymorphicObject*>(other),
            dynamic_cast<const PolymorphicObject*>(this));
        return this;
    }
 
    Cloneable* move_from_impl(std::unique_ptr<Cloneable> other) override
    {
        self()->template log<log::Logger::polymorphic_object_move_started>(
            self()->get_executor().get(),
            dynamic_cast<const PolymorphicObject*>(other.get()),
            dynamic_cast<const PolymorphicObject*>(this));
        as<ConvertibleTo<ConcreteType>>(other.get())->move_to(self());
        self()->template log<log::Logger::polymorphic_object_move_completed>(
            self()->get_executor().get(),
            dynamic_cast<const PolymorphicObject*>(other.get()),
            dynamic_cast<const PolymorphicObject*>(this));
        return this;
    }
 
    [[nodiscard]] std::unique_ptr<Cloneable> clone_impl(
        std::shared_ptr<const Executor> exec) const override
    {
        auto new_op = self()->create_default(exec);
        new_op->copy_from(this);
        return new_op;
    }
 
    [[nodiscard]] std::unique_ptr<Cloneable> clone_impl() const override
    {
        return this->clone_impl(self()->get_executor());
    }
 
    [[nodiscard]] std::unique_ptr<Cloneable> create_default_impl()
        const override
    {
        return this->create_default_impl(self()->get_executor());
    }
 
    [[nodiscard]] std::unique_ptr<Cloneable> create_default_impl(
        std::shared_ptr<const Executor> exec) const override
    {
        if constexpr (std::is_base_of_v<
                          experimental::distributed::DistributedBase,
                          ConcreteType>) {
            return std::unique_ptr<ConcreteType>(
                new ConcreteType(std::move(exec), self()->get_communicator()));
        } else {
            return std::unique_ptr<ConcreteType>(
                new ConcreteType(std::move(exec)));
        }
    }
 
    GKO_ENABLE_SELF(ConcreteType);
};
 
 
template <typename ConcreteType>
class EnableCreateMethod {
public:
    template <typename... Args>
    static std::unique_ptr<ConcreteType> create(Args&&... args)
    {
        return std::unique_ptr<ConcreteType>(
            new ConcreteType(std::forward<Args>(args)...));
    }
};
 
 
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_BASE_POLYMORPHIC_OBJECT_HPP_