utils.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_UTILS_HPP_
#define GKO_CORE_BASE_UTILS_HPP_


#include <ginkgo/core/base/exception.hpp>
#include <ginkgo/core/base/std_extensions.hpp>
#include <ginkgo/core/base/types.hpp>


#include <functional>
#include <memory>
#include <type_traits>


#ifndef NDEBUG
#include <cstdio>
#endif  // NDEBUG


namespace gko {


class Executor;


namespace detail {


template <typename T>
struct pointee_impl {};

template <typename T>
struct pointee_impl<T *> {
    using type = T;
};

template <typename T, typename Deleter>
struct pointee_impl<std::unique_ptr<T, Deleter>> {
    using type = T;
};

template <typename T>
struct pointee_impl<std::shared_ptr<T>> {
    using type = T;
};

template <typename T>
using pointee = typename pointee_impl<typename std::decay<T>::type>::type;


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<typename std::decay<T>::type>::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<typename std::decay<T>::type>::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>
constexpr bool have_ownership()
{
    return have_ownership_impl<typename std::decay<T>::type>::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");
    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>
inline typename std::enable_if<detail::have_ownership<Pointer>(),
                               detail::pointee<Pointer> *>::type
lend(const Pointer &p)
{
    return p.get();
}

template <typename Pointer>
inline typename std::enable_if<!detail::have_ownership<Pointer>(),
                               detail::pointee<Pointer> *>::type
lend(const Pointer &p)
{
    return p;
}


template <typename T, typename U>
inline typename std::decay<T>::type *as(U *obj)
{
    if (auto p = dynamic_cast<typename std::decay<T>::type *>(obj)) {
        return p;
    } else {
        throw NotSupported(__FILE__, __LINE__, __func__, typeid(obj).name());
    }
}

template <typename T, typename U>
inline const typename std::decay<T>::type *as(const U *obj)
{
    if (auto p = dynamic_cast<const typename std::decay<T>::type *>(obj)) {
        return p;
    } else {
        throw NotSupported(__FILE__, __LINE__, __func__, typeid(obj).name());
    }
}


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


template <typename T>
class copy_back_deleter {
public:
    using pointer = T *;

    copy_back_deleter(pointer original) : original_{original} {}

    void operator()(pointer ptr) const
    {
        original_->copy_from(ptr);
        delete ptr;
    }

private:
    pointer original_;
};


// specialization for constant objects, no need to copy back something that
// cannot change
template <typename T>
class copy_back_deleter<const T> {
public:
    using pointer = const T *;
    copy_back_deleter(pointer original) : original_{original} {}

    void operator()(pointer ptr) const { delete ptr; }

private:
    pointer original_;
};


template <typename T>
class temporary_clone {
public:
    using value_type = T;
    using pointer = T *;

    explicit temporary_clone(std::shared_ptr<const Executor> exec, pointer ptr)
    {
        if (ptr->get_executor() == exec) {
            // just use the object we already have
            handle_ = handle_type(ptr, [](pointer) {});
        } else {
            // clone the object to the new executor and make sure it's copied
            // back before we delete it
            handle_ = handle_type(gko::clone(std::move(exec), ptr).release(),
                                  copy_back_deleter<T>(ptr));
        }
    }

    T *get() const { return handle_.get(); }

    T *operator->() const { return handle_.get(); }

private:
    // std::function deleter allows to decide the (type of) deleter at runtime
    using handle_type = std::unique_ptr<T, std::function<void(T *)>>;

    handle_type handle_;
};


template <typename T>
temporary_clone<T> make_temporary_clone(std::shared_ptr<const Executor> exec,
                                        T *ptr)
{
    return temporary_clone<T>(std::move(exec), ptr);
}


}  // namespace gko


#endif  // GKO_CORE_BASE_UTILS_HPP_