memory_management.h

 
#pragma once
 
#include <system/object.h>
#include <system/smart_ptr.h>
#include <system/exceptions.h>
#include <system/iobjects_holder.h>
#include <system/details/objects_bag.h>
#include <type_traits>
 
#include <map>
#include <list>
 
namespace CodePorting { namespace Translator { namespace Cs2Cpp {
 
namespace Details {
 
 
template <size_t ObjectCount>
class ObjectsHolder final : public IObjectsHolder
{
public:
    template <typename ...Args, typename = std::enable_if_t<sizeof...(Args) == ObjectCount>>
    ObjectsHolder(const System::SmartPtr<Args>& ...args)
        : m_objects{ args... }
    {
    }
 
    ObjectsHolder(const ObjectsHolder&) = delete;
    ObjectsHolder& operator=(const ObjectsHolder&) = delete;
 
    void setObjectsMode(System::SmartPtrMode mode) final
    {
        for (int n = 1; n < ObjectCount; ++n)
        {
            m_objects[n].set_Mode(mode);
        }
    }
 
#if defined(__DBG_TOOLS)
    std::vector<int> getHoldObjectIds() const final
    {
        std::vector<int> res;
        for (int n = 1; n < ObjectCount; ++n)
        {
            res.push_back(System::Details::DbgTools::DBG_InstanceNo(m_objects[n].GetObjectOrNull()));
        }
 
        return res;
    }
#endif
 
private:
    System::SmartPtr<System::Object> m_objects[ObjectCount];
 
#ifdef ASPOSE_GET_SHARED_MEMBERS
    void GetSharedMembers(System::Object::shared_members_type& result) const override
    {
        System::Object::GetSharedMembers(result);
        for (auto& object : m_objects)
            result.Add("m_objects[]", object);
    }
#endif
 
#ifdef __DBG_FOR_EACH_MEMBER
public:
    void DBG_for_each_member(System::DBG::for_each_member_visitor &visitor) const override
    {
        visitor.add_self(this);
        System::DBG::for_each_of_Object(this, m_objects, visitor);
    }
    const char* DBG_class_name() const override { return "ObjectsHolder<T>"; }
#endif
 
    RTTI_INFO_TEMPLATE_CLASS(CodePorting::Translator::Cs2Cpp::Details::ObjectsHolder<ObjectCount>, System::BaseTypesInfo<System::Object>);
};
 
} // namespace Details
 
class MemoryManagement
{
public:
    using ObjectsBag = System::Details::ObjectsBag;
 
    template<typename T1, typename T2>
    static System::SmartPtr<typename T1::Pointee_> BindLifetime(const T1& target, const T2& owner)
    {
        static_assert(System::IsSmartPtr<T1>::value && System::IsSmartPtr<T2>::value, "Trying to bind lifetime for non-pointers");
        return System::SmartPtr<typename T1::Pointee_>(owner, target.get());
    }
 
    template<typename T1, typename T2>
    static typename std::enable_if<!std::is_reference<T1>::value, System::SmartPtr<typename T1::Pointee_>>::type BindLifetime(T1&& target, const T2& owner)
    {
        static_assert(System::IsSmartPtr<T1>::value && System::IsSmartPtr<T2>::value, "Trying to bind lifetime for non-pointers");
 
        if (target != nullptr && target->SharedCount() == 1)
            throw System::InvalidOperationException(u"Can not bind lifetime for a temporary target object");
 
        return System::SmartPtr<typename T1::Pointee_>(owner, target.get());
    }
 
    template <typename T, typename... Objects>
    static System::SmartPtr<typename T::Pointee_> ExtendLifetime(const T& target, const Objects&... objects)
    {
        static_assert(System::IsSmartPtr<T>::value, "Trying to bind lifetime for non-pointers");
 
        System::SmartPtr<System::Object> holder(new Details::ObjectsHolder<1 + sizeof...(objects)>(target, objects...));
        return System::SmartPtr<typename T::Pointee_>(holder, target.get());
    }
 
public:
    class PostponedHolders;
private:
    class PostponedHoldersRegistrar;
 
public:
    template <typename T, typename TObject>
    static System::SmartPtr<typename T::Pointee_>
        ExtendLifetimeAsWeakPostponed(const System::SharedPtr<System::Object>& key, const T& target, const TObject& object)
    {
        static_assert(System::IsSmartPtr<T>::value, "Trying to bind lifetime for non-pointers");
 
        System::SmartPtr<Details::IObjectsHolder> holder(
            new Details::ObjectsHolder<2>(target, object));
 
        auto* postpone_holder = PostponedHoldersRegistrar::inst().get(key);
        if (postpone_holder)
        {
            postpone_holder->addHolder(holder);
        }
 
        return System::SmartPtr<typename T::Pointee_>(holder, target.get());
    }
 
private:
    class PostponedHoldersRegistrar
    {
        friend class PostponedHolders;
 
        template <typename T, typename TObject>
        friend System::SmartPtr<typename T::Pointee_> MemoryManagement::ExtendLifetimeAsWeakPostponed(const System::SharedPtr<System::Object>&, const T&, const TObject&);
 
    private:
        static PostponedHoldersRegistrar & inst()
        {
            static PostponedHoldersRegistrar instance;
            return instance;
        }
 
        void reg(void *key, PostponedHolders *holder)
        {
            if (m_map_holders.end() != m_map_holders.find(key))
            {
                return;
            }
            
            m_map_holders.insert({key, holder});
        }
 
        void unreg(void *key)
        {
            m_map_holders.erase(key);
        }
 
        PostponedHolders * get(const System::SharedPtr<System::Object> &key)
        {
            auto it = m_map_holders.find(key.get());
            if (m_map_holders.end() == it)
            {
                return nullptr;
            }
            
            return it->second;
        }
 
    private:
        using map_holders = std::map<void*, PostponedHolders*>;
        map_holders m_map_holders;
    };
 
public:
    class PostponedHolders
    {
        template <typename T, typename TObject>
        friend System::SmartPtr<typename T::Pointee_> MemoryManagement::ExtendLifetimeAsWeakPostponed(const System::SharedPtr<System::Object>&, const T&, const TObject&);
 
    public:
        PostponedHolders(const System::SharedPtr<System::Object> & key)
            : m_key(key.get())
        {
            PostponedHoldersRegistrar::inst().reg(m_key, this);
        }
 
        ~PostponedHolders()
        {
            PostponedHoldersRegistrar::inst().unreg(m_key);
        }
 
    public:
        void switchToShared()
        {
            for (auto& holder : posponed_weak_holders)
            {
                holder->setObjectsMode(System::SmartPtrMode::Shared);
            }
            posponed_weak_holders.clear();
        }
 
    private:
        void addHolder(System::SharedPtr<Details::IObjectsHolder> &holder)
        {
            holder->setObjectsMode(System::SmartPtrMode::Weak);
            posponed_weak_holders.push_back(holder);
        }
 
    private:
        std::list<System::SharedPtr<Details::IObjectsHolder>> posponed_weak_holders;
        void* m_key;
    };
};
 
}}} // namespace CodePorting::Translator::Cs2Cpp