tb_hybrid_owned_pointer.hpp

 
#ifndef TurtleBrains_HybridOwnedPointer_hpp
#define TurtleBrains_HybridOwnedPointer_hpp
 
#include <turtle_brains/core/tb_configuration.hpp>
#include <turtle_brains/core/debug/tb_debug_logger.hpp>
 
#include <memory>
 
namespace TurtleBrains::Core
{
 
    template<typename Type> class HybridOwnedPointer
    {
    public:
        enum class Ownership { Managed, Referenced };
 
        //static HybridOwnedPointer MakeReferenced(Type& value)
        //{
        //  return HybridOwnedPointer(&value, Ownership::Referenced);
        //}
 
        //template<class... _Types> static HybridOwnedPointer MakeManaged(_Types&&... arguments)
        //{
        //  return HybridOwnedPointer(new Type(std::forward<_Types>(arguments)...), Ownership::Managed);
        //}
 
        explicit HybridOwnedPointer(void) :
            mManaged(nullptr),
            mObject(nullptr)
        {
        }
 
        HybridOwnedPointer(Type* object, const Ownership ownership) :
            mManaged((Ownership::Managed == ownership) ? object : nullptr),
            mObject(object)
        {
            tb_error_if(mManaged.get() != nullptr && mManaged.get() != mObject, "tbInternalError: ctor Expected Managed and Object to match.");
 
            tb_debug_log_if(kIsDebugging, "HybridOwnedPointer(" << ((nullptr == mManaged) ? "Referenced" : "Managed") << ") ctor for: " <<
                static_cast<const void*>(this) << "   with obj: " << static_cast<const void*>(mObject) << "  type: " <<
                ((nullptr == mObject) ? "nullptr" : typeid(*mObject).name()));
        }
 
        HybridOwnedPointer(std::unique_ptr<Type>&& typePointer) :
            mManaged(std::move(typePointer)),
            mObject(mManaged.get())
        {
            tb_error_if(mManaged.get() != nullptr && mManaged.get() != mObject, "tbInternalError: ctor Expected Managed and Object to match.");
 
            tb_debug_log_if(kIsDebugging, "HybridOwnedPointer(" << ((nullptr == mManaged) ? "Referenced" : "Managed") << ") ctor for: " <<
                static_cast<const void*>(this) << "   with obj: " << static_cast<const void*>(mObject) << "  type: " <<
                ((nullptr == mObject) ? "nullptr" : typeid(*mObject).name()));
        }
 
        HybridOwnedPointer(HybridOwnedPointer&& other) noexcept :
            mManaged(std::move(other.mManaged)),
            mObject(std::move(other.mObject))
        {
            tb_error_if(mManaged.get() != nullptr && mManaged.get() != mObject, "tbInternalError: mtor Expected Managed and Object to match.");
 
            tb_debug_log_if(kIsDebugging, "HybridOwnedPointer(" << ((nullptr == mManaged) ? "Referenced" : "Managed") << ") MoveCtor for: " <<
                static_cast<const void*>(this) << "   with obj: " << static_cast<const void*>(mObject) << "  type: " <<
                ((nullptr == mObject) ? "nullptr" : typeid(*mObject).name()));
 
            other.mObject = nullptr;
            other.mManaged = nullptr;
        }
 
        HybridOwnedPointer& operator=(HybridOwnedPointer&& other) noexcept
        {
            mManaged = std::move(other.mManaged);
            mObject = std::move(other.mObject);
 
            tb_error_if(mManaged.get() != nullptr && mManaged.get() != mObject, "tbInternalError: =&& Expected Managed and Object to match.");
 
            other.mObject = nullptr;
            other.mManaged = nullptr;
 
            tb_debug_log_if(kIsDebugging, "HybridOwnedPointer(" << ((nullptr == mManaged) ? "Referenced" : "Managed") << ") MoveAssign for: " <<
                static_cast<const void*>(this) << "   with obj: " << static_cast<const void*>(mObject) << "  type: " <<
                ((nullptr == mObject) ? "nullptr" : typeid(*mObject).name()));
 
            return *this;
        }
 
        ~HybridOwnedPointer(void)
        {
            tb_error_if(mManaged.get() != nullptr && mManaged.get() != mObject, "tbInternalError: dtor Expected Managed and Object to match.");
 
            tb_debug_log_if(kIsDebugging, "HybridOwnedPointer(" << ((nullptr == mManaged) ? "Referenced" : "Managed") << ") dtor for: " <<
                static_cast<const void*>(this) << "   with obj: " << static_cast<const void*>(mObject) << "  type: " <<
                ((nullptr == mObject) ? "nullptr" : typeid(*mObject).name()));
        }
 
        const Type* operator->(void) const { return mObject; }
        Type* operator->(void) { return mObject; }
 
        const Type& operator*(void) const { return *mObject; }
        Type& operator*(void) { return *mObject; }
 
        bool operator==(const Type* other) const { return mObject == other; }
        friend bool operator==(const Type* other, const HybridOwnedPointer& hybrid) { return hybrid.mObject == other; }
 
    private:
        HybridOwnedPointer(const HybridOwnedPointer& other) = delete;
        HybridOwnedPointer& operator=(const HybridOwnedPointer& other) = delete;
 
        std::unique_ptr<Type> mManaged;
        Type* mObject;
        static const bool kIsDebugging = false;
    };
 
}; /* namespace TurtleBrains::Core */
 
namespace tbCore = TurtleBrains::Core;
 
#endif /* TurtleBrains_HybridOwnedPointer_hpp */