polymorphic_object.hpp

/*******************************<GINKGO LICENSE>******************************
Copyright (c) 2017-2019, the Ginkgo authors
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

3. Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
******************************<GINKGO LICENSE>*******************************/

#ifndef GKO_CORE_BASE_POLYMORPHIC_OBJECT_HPP_
#define GKO_CORE_BASE_POLYMORPHIC_OBJECT_HPP_


#include <ginkgo/core/base/executor.hpp>
#include <ginkgo/core/base/utils.hpp>
#include <ginkgo/core/log/logger.hpp>


namespace gko {


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;
    }

    PolymorphicObject *copy_from(std::unique_ptr<PolymorphicObject> other)
    {
        this->template log<log::Logger::polymorphic_object_copy_started>(
            exec_.get(), other.get(), this);
        auto copied = this->copy_from_impl(std::move(other));
        this->template log<log::Logger::polymorphic_object_copy_completed>(
            exec_.get(), other.get(), this);
        return copied;
    }

    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)}
    {}

    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 *clear_impl() = 0;

private:
    std::shared_ptr<const Executor> exec_;
};


template <typename AbstactObject, typename PolymorphicBase = PolymorphicObject>
class EnableAbstractPolymorphicObject : public PolymorphicBase {
public:
    using PolymorphicBase::PolymorphicBase;

    std::unique_ptr<AbstactObject> create_default(
        std::shared_ptr<const Executor> exec) const
    {
        return std::unique_ptr<AbstactObject>{static_cast<AbstactObject *>(
            this->create_default_impl(std::move(exec)).release())};
    }

    std::unique_ptr<AbstactObject> create_default() const
    {
        return this->create_default(this->get_executor());
    }

    std::unique_ptr<AbstactObject> 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<AbstactObject> clone() const
    {
        return this->clone(this->get_executor());
    }

    AbstactObject *copy_from(const PolymorphicObject *other)
    {
        return static_cast<AbstactObject *>(this->copy_from_impl(other));
    }

    AbstactObject *copy_from(std::unique_ptr<PolymorphicObject> other)
    {
        return static_cast<AbstactObject *>(
            this->copy_from_impl(std::move(other)));
    }

    AbstactObject *clear()
    {
        return static_cast<AbstactObject *>(this->clear_impl());
    }
};


#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;

    virtual void move_to(result_type *result) = 0;
};


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) {
        return {obj_as_r, [](R *) {}};
    } else {
        auto copy = R::create(exec);
        as<ConvertibleTo<xstd::decay_t<R>>>(obj)->convert_to(lend(copy));
        return {copy.release(), std::default_delete<R>{}};
    }
}


}  // 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 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
    {
        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 *clear_impl() override
    {
        *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;

    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_CORE_BASE_POLYMORPHIC_OBJECT_HPP_