alloc.h

Go to the documentation of this file.

//
// Copyright 2016 - 2024 (C). Alex Robenko. All rights reserved.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 
 
#pragma once
 
#include <memory>
#include <type_traits>
#include <array>
#include <algorithm>
#include <limits>
 
#include "comms/Assert.h"
#include "comms/dispatch.h"
#include "comms/util/Tuple.h"
#include "comms/util/type_traits.h"
#include "comms/details/tag.h"
 
namespace comms
{
 
namespace util
{
 
namespace alloc
{
 
namespace details
{
 
template <typename TInterfaceType, typename TDefaultType>
struct DynMemoryDeleteHandler
{
    template <typename TObj>
    void handle(TObj& obj) const
    {
        using HandleTag =
            typename comms::util::LazyShallowConditional<
                std::is_void<TDefaultType>::value
            >::template Type<
                NoDefaultCastTag,
                DefaultCastCheckTag
            >;
 
        handleInternal(obj, HandleTag());
    }
 
private:
    template <typename... TParams>
    using NoDefaultCastTag = comms::details::tag::Tag1<>;
 
    template <typename... TParams>
    using DefaultCastCheckTag = comms::details::tag::Tag2<>;
 
    template <typename... TParams>
    using ForcedDefaultCastTag = comms::details::tag::Tag3<>;
 
    template <typename TObj, typename... TParams>
    void handleInternal(TObj& obj, NoDefaultCastTag<TParams...>) const
    {
        delete (&obj);
    }
 
    template <typename TObj, typename... TParams>
    void handleInternal(TObj& obj, ForcedDefaultCastTag<TParams...>) const
    {
        delete static_cast<TDefaultType*>(&obj);
    }
 
    template <typename TObj, typename... TParams>
    void handleInternal(TObj& obj, DefaultCastCheckTag<TParams...>) const
    {
        using ObjType = typename std::decay<decltype(obj)>::type;
        using Tag =
            typename comms::util::LazyShallowConditional<
                std::is_same<ObjType, TInterfaceType>::value
            >::template Type<
                ForcedDefaultCastTag,
                NoDefaultCastTag
            >;
        handleInternal(obj, Tag());
    }
 
};
 
template <typename TInterfaceType, typename TDefaultType>
struct InPlaceDeleteHandler
{
    template <typename TObj>
    void handle(TObj& obj) const
    {
        using HandleTag =
            typename comms::util::LazyShallowConditional<
                std::is_void<TDefaultType>::value
            >::template Type<
                NoDefaultCastTag,
                DefaultCastCheckTag
            >;
 
        handleInternal(obj, HandleTag());
    }
 
private:
    template <typename... TParams>
    using NoDefaultCastTag = comms::details::tag::Tag1<>;
 
    template <typename... TParams>
    using DefaultCastCheckTag = comms::details::tag::Tag2<>;
 
    template <typename... TParams>
    using ForcedDefaultCastTag = comms::details::tag::Tag3<>;
 
    template <typename TObj, typename... TParams>
    void handleInternal(TObj& obj, NoDefaultCastTag<TParams...>) const
    {
        static_cast<void>(obj);
        obj.~TObj();
    }
 
    template <typename TObj, typename... TParams>
    void handleInternal(TObj& obj, ForcedDefaultCastTag<TParams...>) const
    {
        static_cast<TDefaultType&>(obj).~TDefaultType();
    }
 
    template <typename TObj, typename... TParams>
    void handleInternal(TObj& obj, DefaultCastCheckTag<TParams...>) const
    {
        using ObjType = typename std::decay<decltype(obj)>::type;
        using Tag =
            typename comms::util::LazyShallowConditional<
                std::is_same<ObjType, TInterfaceType>::value
            >::template Type<
                ForcedDefaultCastTag,
                NoDefaultCastTag
            >;
        handleInternal(obj, Tag());
    }
};
 
template <
    typename TInterface,
    typename TAllMessages,
    typename TDeleteHandler,
    typename TId>
class NoVirtualDestructorDeleter
{
    static const unsigned InvalidIdx = std::numeric_limits<unsigned>::max();
public:
    NoVirtualDestructorDeleter() : id_(TId()), idx_(InvalidIdx) {}
    NoVirtualDestructorDeleter(TId id, unsigned idx) : id_(id), idx_(idx) {}
 
    void operator()(TInterface* obj)
    {
        COMMS_ASSERT(obj != nullptr);
        COMMS_ASSERT(idx_ != InvalidIdx);
        TDeleteHandler handler;
        comms::dispatchMsgStaticBinSearch<TAllMessages>(id_, idx_, *obj, handler);
    }
private:
    TId id_;
    unsigned idx_ = 0;
};
 
template <
    typename TInterface,
    typename TAllMessages,
    typename TDeleteHandler,
    typename TId>
class NoVirtualDestructorInPlaceDeleter : public
        NoVirtualDestructorDeleter<TInterface, TAllMessages, TDeleteHandler, TId>
{
    using Base = NoVirtualDestructorDeleter<TInterface, TAllMessages, TDeleteHandler, TId>;
    static const unsigned InvalidIdx = std::numeric_limits<unsigned>::max();
public:
    NoVirtualDestructorInPlaceDeleter() = default;
    NoVirtualDestructorInPlaceDeleter(TId id, unsigned idx, bool& allocated) : Base(id, idx), allocated_(&allocated) {}
 
    NoVirtualDestructorInPlaceDeleter(const NoVirtualDestructorInPlaceDeleter&) = delete;
    NoVirtualDestructorInPlaceDeleter(NoVirtualDestructorInPlaceDeleter&& other) :
        Base(std::move(other)),
        allocated_(other.allocated_)
    {
        other.allocated_ = nullptr;
    }
 
    ~NoVirtualDestructorInPlaceDeleter()
    {
    }
 
    NoVirtualDestructorInPlaceDeleter& operator=(const NoVirtualDestructorInPlaceDeleter&) = delete;
    NoVirtualDestructorInPlaceDeleter& operator=(NoVirtualDestructorInPlaceDeleter&& other)
    {
        if (reinterpret_cast<void*>(this) == reinterpret_cast<const void*>(&other)) {
            return *this;
        }
 
        Base::operator=(std::move(other));
        allocated_ = other.allocated_;
        other.allocated_ = nullptr;
        return *this;
    }
 
    void operator()(TInterface* obj)
    {
        COMMS_ASSERT(allocated_ != nullptr);
        COMMS_ASSERT(*allocated_);
        Base::operator()(obj);
        *allocated_ = false;
        allocated_ = nullptr;
    }
private:
    bool* allocated_ = nullptr;
};
 
template <typename T>
class InPlaceDeleter
{
    template<typename U>
    friend class InPlaceDeleter;
 
public:
    InPlaceDeleter(bool* allocated = nullptr)
        : allocated_(allocated)
    {
    }
 
    InPlaceDeleter(const InPlaceDeleter& other) = delete;
 
    template <typename U>
    InPlaceDeleter(InPlaceDeleter<U>&& other)
        : allocated_(other.allocated_)
    {
        static_assert(std::is_base_of<T, U>::value ||
                      std::is_base_of<U, T>::value ||
                      std::is_convertible<U, T>::value ||
                      std::is_convertible<T, U>::value ,
            "To make Deleter convertible, their template parameters "
            "must be convertible.");
 
        other.allocated_ = nullptr;
    }
 
    ~InPlaceDeleter() noexcept
    {
    }
 
    InPlaceDeleter& operator=(const InPlaceDeleter& other) = delete;
 
    template <typename U>
    InPlaceDeleter& operator=(InPlaceDeleter<U>&& other)
    {
        static_assert(std::is_base_of<T, U>::value ||
                      std::is_base_of<U, T>::value ||
                      std::is_convertible<U, T>::value ||
                      std::is_convertible<T, U>::value ,
            "To make Deleter convertible, their template parameters "
            "must be convertible.");
 
        if (reinterpret_cast<void*>(this) == reinterpret_cast<const void*>(&other)) {
            return *this;
        }
 
        COMMS_ASSERT(allocated_ == nullptr);
        allocated_ = other.allocated_;
        other.allocated_ = nullptr;
        return *this;
    }
 
    void operator()(T* obj) {
        COMMS_ASSERT(allocated_ != nullptr);
        COMMS_ASSERT(*allocated_);
        obj->~T();
        *allocated_ = false;
        allocated_ = nullptr;
    }
 
private:
    bool* allocated_ = nullptr;
};
 
 
}  // namespace details
 
template <typename TInterface>
class DynMemory
{
public:
    using Ptr = std::unique_ptr<TInterface>;
 
    template <typename TObj, typename... TArgs>
    static Ptr alloc(TArgs&&... args)
    {
        static_assert(std::is_base_of<TInterface, TObj>::value,
            "TObj does not inherit from TInterface");
        return Ptr(new TObj(std::forward<TArgs>(args)...));
    }
 
    template <typename TObj>
    static Ptr wrap(TObj* obj)
    {
        static_assert(std::is_base_of<TInterface, TObj>::value,
            "TObj does not inherit from TInterface");
        return Ptr(obj);
    }
 
    static constexpr bool canAllocate()
    {
        return true;
    }
};
 
template <typename TInterface, typename TAllMessages, typename TId, typename TDefaultType = void>
class DynMemoryNoVirtualDestructor
{
    using Deleter =
        details::NoVirtualDestructorDeleter<
            TInterface,
            TAllMessages,
            details::DynMemoryDeleteHandler<TInterface, TDefaultType>,
            TId>;
public:
    using Ptr = std::unique_ptr<TInterface, Deleter>;
 
    template <typename TObj, typename... TArgs>
    static Ptr alloc(TId id, unsigned idx, TArgs&&... args)
    {
        static_assert(std::is_base_of<TInterface, TObj>::value,
            "TObj does not inherit from TInterface");
        return Ptr(new TObj(std::forward<TArgs>(args)...), Deleter(id, idx));
    }
 
    static constexpr bool canAllocate()
    {
        return true;
    }
};
 
template <typename TInterface, typename TAllTypes>
class InPlaceSingle
{
public:
    using Ptr = std::unique_ptr<TInterface, details::InPlaceDeleter<TInterface> >;
 
    ~InPlaceSingle()
    {
        // Not supposed to be destructed while elemenent is still allocated
        COMMS_ASSERT(!allocated_);
    }
 
    template <typename TObj, typename... TArgs>
    Ptr alloc(TArgs&&... args)
    {
        if (allocated_) {
            return Ptr();
        }
 
        static_assert(std::is_base_of<TInterface, TObj>::value,
            "TObj does not inherit from TInterface");
 
        static_assert(comms::util::IsInTuple<TAllTypes>::template Type<TObj>::value, 
            "TObj must be in provided tuple of supported types");
 
        static_assert(
            std::has_virtual_destructor<TInterface>::value ||
            std::is_same<TInterface, TObj>::value,
            "TInterface is expected to have virtual destructor");
 
        static_assert(sizeof(TObj) <= sizeof(place_), "Object is too big");
 
        new (&place_) TObj(std::forward<TArgs>(args)...);
        Ptr obj(
            reinterpret_cast<TInterface*>(&place_),
            details::InPlaceDeleter<TInterface>(&allocated_));
        allocated_ = true;
        return obj;
    }
 
    bool allocated() const
    {
        return allocated_;
    }
 
    const void* allocAddr() const
    {
        return &place_;
    }
 
    template <typename TObj>
    Ptr wrap(TObj* obj)
    {
        if (obj == nullptr) {
            return Ptr();
        }
 
        static_assert(std::is_base_of<TInterface, TObj>::value,
            "TObj does not inherit from TInterface");
        COMMS_ASSERT(obj == reinterpret_cast<TInterface*>(&place_)); // Wrong object if fails
        COMMS_ASSERT(allocated_); // Error if not set
        return Ptr(
            reinterpret_cast<TInterface*>(&place_),
            details::InPlaceDeleter<TInterface>(&allocated_));
    }
 
    bool canAllocate() const
    {
        return !allocated_;
    }
 
private:
    using AlignedStorage = typename TupleAsAlignedUnion<TAllTypes>::Type;
 
    AlignedStorage place_;
    bool allocated_ = false;
 
};
 
template <
    typename TInterface,
    typename TAllocMessages,
    typename TOrigMessages,
    typename TId,
    typename TDefaultType = void>
class InPlaceSingleNoVirtualDestructor
{
    using Deleter =
        details::NoVirtualDestructorInPlaceDeleter<
            TInterface,
            TOrigMessages,
            details::InPlaceDeleteHandler<TInterface, TDefaultType>,
            TId>;
 
public:
    using Ptr = std::unique_ptr<TInterface, Deleter>;
 
    template <typename TObj, typename... TArgs>
    Ptr alloc(TId id, unsigned idx, TArgs&&... args)
    {
        if (allocated_) {
            return Ptr();
        }
 
        static_assert(std::is_base_of<TInterface, TObj>::value,
            "TObj does not inherit from TInterface");
 
        static_assert(comms::util::IsInTuple<TAllocMessages>::template Type<TObj>::value, ""
            "TObj must be in provided tuple of supported types");
 
        static_assert(sizeof(TObj) <= sizeof(place_), "Object is too big");
 
        new (&place_) TObj(std::forward<TArgs>(args)...);
        Ptr obj(
            reinterpret_cast<TInterface*>(&place_),
            Deleter(id, idx, allocated_));
        allocated_ = true;
        return obj;
    }
 
    bool allocated() const
    {
        return allocated_;
    }
 
    const void* allocAddr() const
    {
        return &place_;
    }
 
    bool canAllocate() const
    {
        return !allocated_;
    }
 
private:
    using AlignedStorage = typename TupleAsAlignedUnion<TAllocMessages>::Type;
 
    AlignedStorage place_;
    bool allocated_ = false;
 
};
 
template <typename TInterface, std::size_t TSize, typename TAllTypes = std::tuple<TInterface> >
class InPlacePool
{
    using PoolElem = InPlaceSingle<TInterface, TAllTypes>;
    using Pool = std::array<PoolElem, TSize>;
public:
 
    using Ptr = typename PoolElem::Ptr;
 
    template <typename TObj, typename... TArgs>
    Ptr alloc(TArgs&&... args)
    {
        auto iter = std::find_if(
            pool_.begin(), pool_.end(),
            [](const PoolElem& elem) -> bool
            {
                return !elem.allocated();
            });
 
        if (iter == pool_.end()) {
            return Ptr();
        }
 
        return iter->template alloc<TObj>(std::forward<TArgs>(args)...);
    }
 
    template <typename TObj>
    Ptr wrap(TObj* obj)
    {
        auto iter =
            std::find_if(
                pool_.begin(), pool_.end(),
                [obj](const PoolElem& elem) -> bool
                {
                    return elem.allocated() && (elem.allocAddr() == obj);
                });
 
        if (iter == pool_.end()) {
            return Ptr();
        }
 
        return iter->wrap(obj);
    }
 
private:
    Pool pool_;
};
 
namespace details
{
 
template <typename...>
struct InPlaceSingleDeepCondWrap
{
    template <typename TInterface, typename TAllTypes, typename...>
    using Type = comms::util::alloc::InPlaceSingle<TInterface, TAllTypes>;
};
 
template <typename...>
struct InPlaceSingleNoVirtualDestructorDeepCondWrap
{
    template <
        typename TInterface,
        typename TAllocMessages,
        typename TOrigMessages,
        typename TId,
        typename TDefaultType,
        typename...>
    using Type = 
        comms::util::alloc::InPlaceSingleNoVirtualDestructor<
            TInterface, 
            TAllocMessages,
            TOrigMessages,
            TId,
            TDefaultType
        >;
};
 
template <typename...>
struct DynMemoryDeepCondWrap
{
    template <typename TInterface, typename...>
    using Type = comms::util::alloc::DynMemory<TInterface>;
};
 
template <typename...>
struct DynMemoryNoVirtualDestructorDeepCondWrap
{
    template <
        typename TInterface, 
        typename TAllMessages, 
        typename TId, 
        typename TDefaultType,
        typename...
    >
    using Type = 
        comms::util::alloc::DynMemoryNoVirtualDestructor<
            TInterface,
            TAllMessages,
            TId, 
            TDefaultType
        >;
};
 
 
} // namespace details
 
}  // namespace alloc
 
}  // namespace util
 
}  // namespace comms