polymorphic_object.hpp

// SPDX-FileCopyrightText: 2017 - 2024 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::unique_ptr<PolymorphicObject> create_default(
        std::shared_ptr<const Executor> exec) const
    {
        this->template log<log::Logger::polymorphic_object_create_started>(
            exec_.get(), this);
        auto created = this->create_default_impl(std::move(exec));
        this->template log<log::Logger::polymorphic_object_create_completed>(
            exec_.get(), this, created.get());
        return created;
    }
 
    std::unique_ptr<PolymorphicObject> create_default() const
    {
        return this->create_default(exec_);
    }
 
    std::unique_ptr<PolymorphicObject> clone(
        std::shared_ptr<const Executor> exec) const
    {
        auto new_op = this->create_default(exec);
        new_op->copy_from(this);
        return new_op;
    }
 
    std::unique_ptr<PolymorphicObject> clone() const
    {
        return this->clone(exec_);
    }
 
    PolymorphicObject* copy_from(const PolymorphicObject* other)
    {
        this->template log<log::Logger::polymorphic_object_copy_started>(
            exec_.get(), other, this);
        auto copied = this->copy_from_impl(other);
        this->template log<log::Logger::polymorphic_object_copy_completed>(
            exec_.get(), other, this);
        return copied;
    }
 
    template <typename Derived, typename Deleter>
    GKO_DEPRECATED(
        "This function will be removed in a future release, the replacement "
        "will copy instead of move. If a move is intended, use move_from "
        "instead.")
    std::enable_if_t<
        std::is_base_of<PolymorphicObject, std::decay_t<Derived>>::value,
        PolymorphicObject>* copy_from(std::unique_ptr<Derived, Deleter>&& other)
    {
        this->template log<log::Logger::polymorphic_object_move_started>(
            exec_.get(), other.get(), this);
        auto copied = this->copy_from_impl(std::move(other));
        this->template log<log::Logger::polymorphic_object_move_completed>(
            exec_.get(), other.get(), this);
        return copied;
    }
 
    template <typename Derived, typename Deleter>
    std::enable_if_t<
        std::is_base_of<PolymorphicObject, std::decay_t<Derived>>::value,
        PolymorphicObject>*
    copy_from(const std::unique_ptr<Derived, Deleter>& other)
    {
        return this->copy_from(other.get());
    }
 
    PolymorphicObject* copy_from(
        const std::shared_ptr<const PolymorphicObject>& other)
    {
        return this->copy_from(other.get());
    }
 
    PolymorphicObject* move_from(ptr_param<PolymorphicObject> other)
    {
        this->template log<log::Logger::polymorphic_object_move_started>(
            exec_.get(), other.get(), this);
        auto moved = this->move_from_impl(other.get());
        this->template log<log::Logger::polymorphic_object_move_completed>(
            exec_.get(), other.get(), this);
        return moved;
    }
 
    PolymorphicObject* clear() { return this->clear_impl(); }
 
    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;
    }
 
    virtual std::unique_ptr<PolymorphicObject> create_default_impl(
        std::shared_ptr<const Executor> exec) const = 0;
 
    virtual PolymorphicObject* copy_from_impl(
        const PolymorphicObject* other) = 0;
 
    virtual PolymorphicObject* copy_from_impl(
        std::unique_ptr<PolymorphicObject> other) = 0;
 
    virtual PolymorphicObject* move_from_impl(PolymorphicObject* other) = 0;
 
    virtual PolymorphicObject* move_from_impl(
        std::unique_ptr<PolymorphicObject> other) = 0;
 
    virtual PolymorphicObject* clear_impl() = 0;
 
private:
    std::shared_ptr<const Executor> exec_;
};
 
 
template <typename AbstractObject, typename PolymorphicBase = PolymorphicObject>
class EnableAbstractPolymorphicObject : public PolymorphicBase {
public:
    using PolymorphicBase::PolymorphicBase;
 
    std::unique_ptr<AbstractObject> create_default(
        std::shared_ptr<const Executor> exec) const
    {
        return std::unique_ptr<AbstractObject>{static_cast<AbstractObject*>(
            this->PolymorphicBase::create_default(std::move(exec)).release())};
    }
 
    std::unique_ptr<AbstractObject> create_default() const
    {
        return std::unique_ptr<AbstractObject>{static_cast<AbstractObject*>(
            this->PolymorphicBase::create_default().release())};
    }
 
    std::unique_ptr<AbstractObject> clone(
        std::shared_ptr<const Executor> exec) const
    {
        return std::unique_ptr<AbstractObject>{static_cast<AbstractObject*>(
            this->PolymorphicBase::clone(std::move(exec)).release())};
    }
 
    std::unique_ptr<AbstractObject> clone() const
    {
        return std::unique_ptr<AbstractObject>{static_cast<AbstractObject*>(
            this->PolymorphicBase::clone().release())};
    }
 
    AbstractObject* copy_from(const PolymorphicObject* other)
    {
        return static_cast<AbstractObject*>(
            this->PolymorphicBase::copy_from(other));
    }
 
    template <typename Derived>
    GKO_DEPRECATED(
        "This function will be removed in a future release, the replacement "
        "will copy instead of move. If a move in intended, use move_to "
        "instead.")
    std::enable_if_t<
        std::is_base_of<PolymorphicObject, std::decay_t<Derived>>::value,
        AbstractObject>* copy_from(std::unique_ptr<Derived>&& other)
    {
        return static_cast<AbstractObject*>(
            this->PolymorphicBase::copy_from(std::move(other)));
    }
 
    template <typename Derived>
    std::enable_if_t<
        std::is_base_of<PolymorphicObject, std::decay_t<Derived>>::value,
        AbstractObject>*
    copy_from(const std::unique_ptr<Derived>& other)
    {
        return copy_from(other.get());
    }
 
    AbstractObject* copy_from(
        const std::shared_ptr<const PolymorphicObject>& other)
    {
        return copy_from(other.get());
    }
 
    AbstractObject* move_from(ptr_param<PolymorphicObject> other)
    {
        return static_cast<AbstractObject*>(
            this->PolymorphicBase::move_from(other.get()));
    }
 
    AbstractObject* clear()
    {
        return static_cast<AbstractObject*>(this->PolymorphicBase::clear());
    }
};
 
 
#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);
}
 
 
template <typename ConcreteObject, typename PolymorphicBase = PolymorphicObject>
class EnablePolymorphicObject
    : public EnableAbstractPolymorphicObject<ConcreteObject, PolymorphicBase> {
protected:
    using EnableAbstractPolymorphicObject<
        ConcreteObject, PolymorphicBase>::EnableAbstractPolymorphicObject;
 
    std::unique_ptr<PolymorphicObject> create_default_impl(
        std::shared_ptr<const Executor> exec) const override
    {
        if constexpr (std::is_base_of_v<
                          experimental::distributed::DistributedBase,
                          ConcreteObject>) {
            return std::unique_ptr<ConcreteObject>{
                new ConcreteObject(exec, self()->get_communicator())};
        } else {
            return std::unique_ptr<ConcreteObject>{new ConcreteObject(exec)};
        }
    }
 
    PolymorphicObject* copy_from_impl(const PolymorphicObject* other) override
    {
        as<ConvertibleTo<ConcreteObject>>(other)->convert_to(self());
        return this;
    }
 
    PolymorphicObject* copy_from_impl(
        std::unique_ptr<PolymorphicObject> other) override
    {
        as<ConvertibleTo<ConcreteObject>>(other.get())->move_to(self());
        return this;
    }
 
    PolymorphicObject* move_from_impl(PolymorphicObject* other) override
    {
        as<ConvertibleTo<ConcreteObject>>(other)->move_to(self());
        return this;
    }
 
    PolymorphicObject* move_from_impl(
        std::unique_ptr<PolymorphicObject> other) override
    {
        as<ConvertibleTo<ConcreteObject>>(other.get())->move_to(self());
        return this;
    }
 
    PolymorphicObject* clear_impl() override
    {
        if constexpr (std::is_base_of_v<
                          experimental::distributed::DistributedBase,
                          ConcreteObject>) {
            *self() = ConcreteObject{this->get_executor(),
                                     self()->get_communicator()};
        } else {
            *self() = ConcreteObject{this->get_executor()};
        }
        return this;
    }
 
private:
    GKO_ENABLE_SELF(ConcreteObject);
};
 
 
template <typename ConcreteType, typename ResultType = ConcreteType>
class EnablePolymorphicAssignment : public ConvertibleTo<ResultType> {
public:
    using result_type = ResultType;
    using ConvertibleTo<result_type>::convert_to;
    using ConvertibleTo<result_type>::move_to;
 
    void convert_to(result_type* result) const override { *result = *self(); }
 
    void move_to(result_type* result) override { *result = std::move(*self()); }
 
private:
    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_