make_tuple_heap.h

Go to the documentation of this file.

#ifndef _MAKE_TUPLE_HEAP_H
#define _MAKE_TUPLE_HEAP_H
 
// @see https://github.com/endurodave/DelegateMQ
// David Lafreniere, Aug 2020.
 
 
#include <tuple>
#include <list>
#include <memory>
#include <type_traits>
#include "DelegateOpt.h"
 
namespace dmq 
{
// std::shared_ptr reference arguments are not allowed with asynchronous delegates as the behavior is 
// undefined. In other words:
// void MyFunc(std::shared_ptr<T> data)     // Ok!
// void MyFunc(std::shared_ptr<T>* data)    // Error if DelegateAsync or DelegateSpAsync target!
template<class T>
struct is_shared_ptr : std::false_type {};
 
template<class T>
struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {};
 
template<class T>
struct is_shared_ptr<std::shared_ptr<T>&> : std::true_type {};
 
template<class T>
struct is_shared_ptr<const std::shared_ptr<T>&> : std::true_type {};
 
template<class T>
struct is_shared_ptr<std::shared_ptr<T>*> : std::true_type {};
 
template<class T>
struct is_shared_ptr<const std::shared_ptr<T>*> : std::true_type {};
 
template<class T>
struct is_unique_ptr : std::false_type {};
 
template<class T>
struct is_unique_ptr<std::unique_ptr<T>> : std::true_type {};
   
class heap_arg_deleter_base
{
public:
    virtual ~heap_arg_deleter_base() = default;
 
    XALLOCATOR
};
 
template<typename T>
class heap_arg_deleter : public heap_arg_deleter_base
{
public:
    heap_arg_deleter(T& arg) : m_arg(arg) { }
    virtual ~heap_arg_deleter() {
        xdelete(&m_arg);
    }
private:
    T& m_arg;
};
 
template<typename T>
class heap_arg_deleter<T*> : public heap_arg_deleter_base
{
public:
    heap_arg_deleter(T* arg) : m_arg(arg) { }
    virtual ~heap_arg_deleter() {
        xdelete(m_arg);
    }
private:
    T* m_arg;
};
 
template<typename T>
class heap_arg_deleter<T**> : public heap_arg_deleter_base
{
public:
    // Capture the original inner pointer at construction so the destructor always
    // frees the xnew'd copy, regardless of whether the target function overwrites
    // *arg (e.g. an outgoing-argument pattern like (*s) = new T).
    heap_arg_deleter(T** arg) : m_arg(arg), m_inner(*arg) {}
    virtual ~heap_arg_deleter() {
        xdelete(m_inner);   // free the original xnew'd inner copy (may be nullptr)
        xdelete(m_arg);     // free the outer pointer storage
    }
private:
    T** m_arg;
    T*  m_inner;  // original value of *arg at dispatch time
};
 
template <typename Arg, typename... TupleElem>
auto tuple_append(xlist<std::shared_ptr<heap_arg_deleter_base>>& heapArgs, const std::tuple<TupleElem...> &tup, Arg** arg)
{
    Arg** heap_arg = nullptr;
 
    // Check if arg is nullptr or *arg is nullptr
    if (arg != nullptr && *arg != nullptr) {
        // Allocate memory for heap_arg and copy the value
        heap_arg = xnew<Arg*>();
        if (!heap_arg) {
            BAD_ALLOC();
        }
 
        *heap_arg = xnew<Arg>(**arg);
        if (!*heap_arg) {
            xdelete(heap_arg);
            BAD_ALLOC();
        }
    }
    else {
        // If arg is nullptr or *arg is nullptr, create heap_arg as nullptr
        heap_arg = xnew<Arg*>(nullptr);
        if (!heap_arg) {
            BAD_ALLOC();
        }
    }
    auto deleter = xmake_shared<heap_arg_deleter<Arg**>>(heap_arg);
    if (!deleter) {
        xdelete(*heap_arg);
        xdelete(heap_arg);
        BAD_ALLOC();
    }
 
#if !defined(__cpp_exceptions) || defined(DMQ_ASSERTS)
    heapArgs.push_back(deleter);
    return std::tuple_cat(tup, std::make_tuple(heap_arg));
#else
    try {
        heapArgs.push_back(deleter);
        return std::tuple_cat(tup, std::make_tuple(heap_arg));
    }
    catch (const std::bad_alloc&) {
        BAD_ALLOC();
        throw;
    }
#endif
}
 
template <typename Arg, typename... TupleElem>
auto tuple_append(xlist<std::shared_ptr<heap_arg_deleter_base>>& heapArgs, const std::tuple<TupleElem...> &tup, Arg* arg)
{
    Arg* heap_arg = nullptr;
    if (arg != nullptr) {
        heap_arg = xnew<Arg>(*arg);
        if (!heap_arg) {
            BAD_ALLOC();
        }
    }
    auto deleter = xmake_shared<heap_arg_deleter<Arg*>>(heap_arg);
    if (!deleter) {
        xdelete(heap_arg);
        BAD_ALLOC();
    }
 
#if !defined(__cpp_exceptions) || defined(DMQ_ASSERTS)
    heapArgs.push_back(deleter);
    return std::tuple_cat(tup, std::make_tuple(heap_arg));
#else
    try {
        heapArgs.push_back(deleter);
        return std::tuple_cat(tup, std::make_tuple(heap_arg));
    }
    catch (const std::bad_alloc&) {
        BAD_ALLOC();
        throw;
    }
#endif
}
 
template <typename Arg, typename... TupleElem>
auto tuple_append(xlist<std::shared_ptr<heap_arg_deleter_base>>& heapArgs, const std::tuple<TupleElem...> &tup, Arg& arg)
{
    Arg* heap_arg = xnew<Arg>(arg);
    if (!heap_arg) {
        BAD_ALLOC();
    }
    auto deleter = xmake_shared<heap_arg_deleter<Arg*>>(heap_arg);
    if (!deleter) {
        xdelete(heap_arg);
        BAD_ALLOC();
    }
 
#if !defined(__cpp_exceptions) || defined(DMQ_ASSERTS)
    heapArgs.push_back(deleter);
 
    auto temp = std::make_tuple(std::forward_as_tuple(*heap_arg));  // Dereference heap_arg when creating tuple element
    auto new_type = std::get<0>(temp);
    return std::tuple_cat(tup, new_type);
#else
    try {
        heapArgs.push_back(deleter);
 
        auto temp = std::make_tuple(std::forward_as_tuple(*heap_arg));  // Dereference heap_arg when creating tuple element
        auto new_type = std::get<0>(temp);
        return std::tuple_cat(tup, new_type);
    }
    catch (const std::bad_alloc&) {
        BAD_ALLOC();
        throw;
    }
#endif
}
 
template<typename... Ts>
auto make_tuple_heap(xlist<std::shared_ptr<heap_arg_deleter_base>>& heapArgs, std::tuple<Ts...> tup)
{
    (void)heapArgs;
    return tup;
}
 
template<typename Arg1, typename... Args, typename... Ts>
auto make_tuple_heap(xlist<std::shared_ptr<heap_arg_deleter_base>>& heapArgs, std::tuple<Ts...> tup, Arg1 arg1, Args... args)
{
    static_assert(!(
        (is_shared_ptr<Arg1>::value && (std::is_lvalue_reference_v<Arg1> || std::is_pointer_v<Arg1>))),
        "std::shared_ptr reference argument not allowed");
    static_assert(!std::is_same<Arg1, void*>::value, "void* argument not allowed");
 
    auto new_tup = tuple_append(heapArgs, tup, arg1);
    return make_tuple_heap(heapArgs, new_tup, args...);
}
 
}
 
#endif