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() { 
        delete &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() { 
        delete 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() {
        delete *m_arg;
        delete m_arg;
    }
private:
    T** m_arg;
};
 
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 = new(std::nothrow) Arg * ();
        if (!heap_arg) {
            BAD_ALLOC();
        }
            
        *heap_arg = new(std::nothrow) Arg(**arg);
        if (!*heap_arg) {
            delete heap_arg;
            BAD_ALLOC();
        }
    }
    else {
        // If arg is nullptr or *arg is nullptr, create heap_arg as nullptr
        heap_arg = new(std::nothrow) Arg * (nullptr);
        if (!heap_arg) {
            BAD_ALLOC();
        }
    }
    std::shared_ptr<heap_arg_deleter_base> deleter(new(std::nothrow) heap_arg_deleter<Arg**>(heap_arg));
    if (!deleter) {
        BAD_ALLOC();
    }
    try {
        heapArgs.push_back(deleter);
        return std::tuple_cat(tup, std::make_tuple(heap_arg));
    } 
    catch (const std::bad_alloc&) {
        BAD_ALLOC();
        throw;
    }
}
 
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 = new(std::nothrow) Arg(*arg);  // Only create a new Arg if arg is not nullptr
        if (!heap_arg) {
            BAD_ALLOC();
        }
    }
    std::shared_ptr<heap_arg_deleter_base> deleter(new(std::nothrow) heap_arg_deleter<Arg*>(heap_arg));
    if (!deleter) {
        BAD_ALLOC();
    }
    try {
        heapArgs.push_back(deleter);
        return std::tuple_cat(tup, std::make_tuple(heap_arg));
    }
    catch (const std::bad_alloc&) {
        BAD_ALLOC();
        throw;
    }
}
 
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 = new(std::nothrow) Arg(arg);
    if (!heap_arg) {
        BAD_ALLOC();
    }
    std::shared_ptr<heap_arg_deleter_base> deleter(new(std::nothrow) heap_arg_deleter<Arg*>(heap_arg));
    if (!deleter) {
        BAD_ALLOC();
    }
    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;
    }
}
 
template<typename... Ts>
auto make_tuple_heap(xlist<std::shared_ptr<heap_arg_deleter_base>>& heapArgs, std::tuple<Ts...> tup)
{
    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