utils_helper.hpp

// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_BASE_UTILS_HELPER_HPP_
#define GKO_PUBLIC_CORE_BASE_UTILS_HELPER_HPP_
 
 
#include <functional>
#include <memory>
#include <type_traits>
 
#include <ginkgo/core/base/exception.hpp>
#include <ginkgo/core/base/name_demangling.hpp>
#include <ginkgo/core/base/std_extensions.hpp>
#include <ginkgo/core/base/types.hpp>
 
 
#ifndef NDEBUG
#include <cstdio>
#endif  // NDEBUG
 
 
namespace gko {
 
 
class Executor;
 
 
template <typename T>
class ptr_param {
public:
    ptr_param(T* ptr) : ptr_{ptr} {}
 
    template <typename U,
              std::enable_if_t<std::is_base_of<T, U>::value>* = nullptr>
    ptr_param(const std::shared_ptr<U>& ptr) : ptr_param{ptr.get()}
    {}
 
    template <typename U, typename Deleter,
              std::enable_if_t<std::is_base_of<T, U>::value>* = nullptr>
    ptr_param(const std::unique_ptr<U, Deleter>& ptr) : ptr_param{ptr.get()}
    {}
 
    template <typename U,
              std::enable_if_t<std::is_base_of<T, U>::value>* = nullptr>
    ptr_param(const ptr_param<U>& ptr) : ptr_param{ptr.get()}
    {}
 
    ptr_param(const ptr_param&) = default;
 
    ptr_param(ptr_param&&) = default;
 
    T& operator*() const { return *ptr_; }
 
    T* operator->() const { return ptr_; }
 
    T* get() const { return ptr_; }
 
    explicit operator bool() const { return ptr_; }
 
    ptr_param& operator=(const ptr_param&) = delete;
 
    ptr_param& operator=(ptr_param&&) = delete;
 
private:
    T* ptr_;
};
 
 
namespace detail {
 
 
template <typename T>
using pointee =
    std::remove_reference_t<decltype(*std::declval<std::decay_t<T>>())>;
 
 
template <typename T, typename = void>
struct is_clonable_impl : std::false_type {};
 
template <typename T>
struct is_clonable_impl<T, xstd::void_t<decltype(std::declval<T>().clone())>>
    : std::true_type {};
 
template <typename T>
constexpr bool is_clonable()
{
    return is_clonable_impl<std::decay_t<T>>::value;
}
 
 
template <typename T, typename = void>
struct is_clonable_to_impl : std::false_type {};
 
template <typename T>
struct is_clonable_to_impl<
    T, xstd::void_t<decltype(std::declval<T>().clone(
           std::declval<std::shared_ptr<const Executor>>()))>>
    : std::true_type {};
 
template <typename T>
constexpr bool is_clonable_to()
{
    return is_clonable_to_impl<std::decay_t<T>>::value;
}
 
 
template <typename T>
struct have_ownership_impl : std::false_type {};
 
template <typename T, typename Deleter>
struct have_ownership_impl<std::unique_ptr<T, Deleter>> : std::true_type {};
 
template <typename T>
struct have_ownership_impl<std::shared_ptr<T>> : std::true_type {};
 
template <typename T>
using have_ownership_s = have_ownership_impl<std::decay_t<T>>;
 
template <typename T>
constexpr bool have_ownership()
{
    return have_ownership_s<T>::value;
}
 
 
template <typename Pointer>
using cloned_type =
    std::unique_ptr<typename std::remove_cv<pointee<Pointer>>::type>;
 
 
template <typename Pointer>
using shared_type = std::shared_ptr<pointee<Pointer>>;
 
 
}  // namespace detail
 
 
template <typename Pointer>
inline detail::cloned_type<Pointer> clone(const Pointer& p)
{
    static_assert(detail::is_clonable<detail::pointee<Pointer>>(),
                  "Object is not clonable");
    return detail::cloned_type<Pointer>(
        static_cast<typename std::remove_cv<detail::pointee<Pointer>>::type*>(
            p->clone().release()));
}
 
 
template <typename Pointer>
inline detail::cloned_type<Pointer> clone(std::shared_ptr<const Executor> exec,
                                          const Pointer& p)
{
    static_assert(detail::is_clonable_to<detail::pointee<Pointer>>(),
                  "Object is not clonable");
    return detail::cloned_type<Pointer>(
        static_cast<typename std::remove_cv<detail::pointee<Pointer>>::type*>(
            p->clone(std::move(exec)).release()));
}
 
 
template <typename OwningPointer>
inline detail::shared_type<OwningPointer> share(OwningPointer&& p)
{
    static_assert(detail::have_ownership<OwningPointer>(),
                  "OwningPointer does not have ownership of the object");
    static_assert(std::is_rvalue_reference<decltype(p)>::value,
                  "p must be an rvalue for this function to work");
    return detail::shared_type<OwningPointer>(std::move(p));
}
 
 
template <typename OwningPointer>
inline typename std::remove_reference<OwningPointer>::type&& give(
    OwningPointer&& p)
{
    static_assert(detail::have_ownership<OwningPointer>(),
                  "OwningPointer does not have ownership of the object");
    return std::move(p);
}
 
 
template <typename Pointer>
GKO_DEPRECATED("no longer necessary, just pass the object without lend")
inline typename std::enable_if<detail::have_ownership_s<Pointer>::value,
                               detail::pointee<Pointer>*>::type
    lend(const Pointer& p)
{
    return p.get();
}
 
template <typename Pointer>
GKO_DEPRECATED("no longer necessary, just pass the object without lend")
inline typename std::enable_if<!detail::have_ownership_s<Pointer>::value,
                               detail::pointee<Pointer>*>::type
    lend(const Pointer& p)
{
    return p;
}
 
 
template <typename T, typename U>
inline std::decay_t<T>* as(U* obj)
{
    if (auto p = dynamic_cast<std::decay_t<T>*>(obj)) {
        return p;
    } else {
        throw NotSupported(__FILE__, __LINE__,
                           std::string{"gko::as<"} +
                               name_demangling::get_type_name(typeid(T)) + ">",
                           name_demangling::get_type_name(typeid(*obj)));
    }
}
 
template <typename T, typename U>
inline const std::decay_t<T>* as(const U* obj)
{
    if (auto p = dynamic_cast<const std::decay_t<T>*>(obj)) {
        return p;
    } else {
        throw NotSupported(__FILE__, __LINE__,
                           std::string{"gko::as<"} +
                               name_demangling::get_type_name(typeid(T)) + ">",
                           name_demangling::get_type_name(typeid(*obj)));
    }
}
 
 
template <typename T, typename U>
inline std::decay_t<T>* as(ptr_param<U> obj)
{
    return as<T>(obj.get());
}
 
template <typename T, typename U>
inline const std::decay_t<T>* as(ptr_param<const U> obj)
{
    return as<T>(obj.get());
}
 
 
template <typename T, typename U>
inline std::unique_ptr<std::decay_t<T>> as(std::unique_ptr<U>&& obj)
{
    if (auto p = dynamic_cast<std::decay_t<T>*>(obj.get())) {
        obj.release();
        return std::unique_ptr<std::decay_t<T>>{p};
    } else {
        throw NotSupported(__FILE__, __LINE__, __func__,
                           name_demangling::get_type_name(typeid(*obj)));
    }
}
 
 
template <typename T, typename U>
inline std::shared_ptr<std::decay_t<T>> as(std::shared_ptr<U> obj)
{
    auto ptr = std::dynamic_pointer_cast<std::decay_t<T>>(obj);
    if (ptr) {
        return ptr;
    } else {
        throw NotSupported(__FILE__, __LINE__, __func__,
                           name_demangling::get_type_name(typeid(*obj)));
    }
}
 
 
template <typename T, typename U>
inline std::shared_ptr<const std::decay_t<T>> as(std::shared_ptr<const U> obj)
{
    auto ptr = std::dynamic_pointer_cast<const std::decay_t<T>>(obj);
    if (ptr) {
        return ptr;
    } else {
        throw NotSupported(__FILE__, __LINE__, __func__,
                           name_demangling::get_type_name(typeid(*obj)));
    }
}
 
 
template <typename T>
class null_deleter {
public:
    using pointer = T*;
 
    void operator()(pointer) const noexcept {}
};
 
// a specialization for arrays
template <typename T>
class null_deleter<T[]> {
public:
    using pointer = T[];
 
    void operator()(pointer) const noexcept {}
};
 
 
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_BASE_UTILS_HELPER_HPP_