temporary_conversion.hpp

// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_BASE_TEMPORARY_CONVERSION_HPP_
#define GKO_PUBLIC_CORE_BASE_TEMPORARY_CONVERSION_HPP_
 
 
#include <memory>
#include <tuple>
#include <type_traits>
 
 
#include <ginkgo/core/base/lin_op.hpp>
#include <ginkgo/core/base/utils.hpp>
 
 
namespace gko {
namespace detail {
 
 
template <typename CopyType, typename OrigType>
class convert_back_deleter {
public:
    using pointer = CopyType*;
    using original_pointer = OrigType*;
 
    convert_back_deleter(original_pointer original) : original_{original} {}
 
    void operator()(pointer ptr) const
    {
        ptr->convert_to(original_);
        delete ptr;
    }
 
private:
    original_pointer original_;
};
 
// specialization for constant objects, no need to convert back something that
// cannot change
template <typename CopyType, typename OrigType>
class convert_back_deleter<const CopyType, const OrigType> {
public:
    using pointer = const CopyType*;
    using original_pointer = const OrigType*;
    convert_back_deleter(original_pointer) {}
 
    void operator()(pointer ptr) const { delete ptr; }
};
 
 
template <typename TargetType>
struct conversion_target_helper {
    template <typename SourceType,
              typename = std::enable_if_t<std::is_base_of<
                  ConvertibleTo<TargetType>, SourceType>::value>>
    static std::unique_ptr<TargetType> create_empty(const SourceType* source)
    {
        return TargetType::create(source->get_executor());
    }
};
 
 
template <typename... ConversionCandidates>
struct conversion_helper {
    template <typename TargetType, typename MaybeConstLinOp>
    static std::unique_ptr<TargetType, std::function<void(TargetType*)>>
    convert(MaybeConstLinOp* obj)
    {
        return convert_impl<TargetType, MaybeConstLinOp,
                            ConversionCandidates...>(obj);
    }
 
    template <typename TargetType, typename MaybeConstLinOp,
              typename FirstCandidate, typename... TrailingCandidates>
    static std::unique_ptr<TargetType, std::function<void(TargetType*)>>
    convert_impl(MaybeConstLinOp* obj)
    {
        // make candidate_type conditionally const based on whether obj is const
        using candidate_type =
            std::conditional_t<std::is_const<MaybeConstLinOp>::value,
                               const FirstCandidate, FirstCandidate>;
        candidate_type* cast_obj{};
        if ((cast_obj = dynamic_cast<candidate_type*>(obj))) {
            // if the cast is successful, obj is of dynamic type candidate_type
            // so we can convert from this type to TargetType
            auto converted = conversion_target_helper<
                std::remove_cv_t<TargetType>>::create_empty(cast_obj);
            cast_obj->convert_to(converted);
            // Make sure ConvertibleTo<TargetType> is available and symmetric
            static_assert(
                std::is_base_of<ConvertibleTo<std::remove_cv_t<TargetType>>,
                                FirstCandidate>::value,
                "ConvertibleTo not implemented");
            static_assert(std::is_base_of<ConvertibleTo<FirstCandidate>,
                                          TargetType>::value,
                          "ConvertibleTo not symmetric");
            return {converted.release(),
                    convert_back_deleter<TargetType, candidate_type>{cast_obj}};
        } else {
            // else try the remaining candidates
            return conversion_helper<TrailingCandidates...>::template convert<
                TargetType>(obj);
        }
    }
};
 
template <>
struct conversion_helper<> {
    template <typename T, typename MaybeConstLinOp>
    static std::unique_ptr<T, std::function<void(T*)>> convert(
        MaybeConstLinOp* obj)
    {
        // return nullptr if no previous candidates matched
        return {nullptr, null_deleter<T>{}};
    }
};
 
 
template <typename T>
class temporary_conversion {
public:
    using value_type = T;
    using pointer = T*;
    using lin_op_type =
        std::conditional_t<std::is_const<T>::value, const LinOp, LinOp>;
 
    template <typename... ConversionCandidates>
    static temporary_conversion create(ptr_param<lin_op_type> ptr)
    {
        T* cast_ptr{};
        if ((cast_ptr = dynamic_cast<T*>(ptr.get()))) {
            return handle_type{cast_ptr, null_deleter<T>{}};
        } else {
            return conversion_helper<ConversionCandidates...>::template convert<
                T>(ptr.get());
        }
    }
 
    T* get() const { return handle_.get(); }
 
    T* operator->() const { return handle_.get(); }
 
    explicit operator bool() { return static_cast<bool>(handle_); }
 
private:
    // std::function deleter allows to decide the (type of) deleter at
    // runtime
    using handle_type = std::unique_ptr<T, std::function<void(T*)>>;
 
    temporary_conversion(handle_type handle) : handle_{std::move(handle)} {}
 
    handle_type handle_;
};
 
 
}  // namespace detail
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_BASE_TEMPORARY_CONVERSION_HPP_