story_ptr.h

/* Copyright (c) 2024 Julian Benda
 *
 * This file is part of inkCPP which is released under MIT license.
 * See file LICENSE.txt or go to
 * https://github.com/JBenda/inkcpp for full license details.
 */
#pragma once
 
#include "system.h"
 
namespace ink::runtime
{
namespace internal
{
    struct ref_block {
        ref_block()
            : references(0)
            , valid(true)
        {
        }
 
        size_t references;
        bool   valid;
 
        static void remove_reference(ref_block*&);
    };
 
    class story_ptr_base
    {
    protected:
        story_ptr_base(internal::ref_block* story);
        story_ptr_base(internal::ref_block* story, internal::ref_block* instance);
        story_ptr_base(const story_ptr_base&);
 
        story_ptr_base& operator=(const story_ptr_base&) = delete;
 
        void add_reference();
        bool remove_reference();
 
        void set(const story_ptr_base& other);
 
        inline bool is_valid() const
        {
            return _story_block != nullptr && _instance_block != nullptr && _story_block->valid
                && _instance_block->valid;
        }
 
        inline bool is_story_valid() const { return _story_block != nullptr && _story_block->valid; }
 
    private:
        // reference block for the parent story
        ref_block* _story_block;
 
        // reference block for this pointer
        ref_block* _instance_block;
    };
} // namespace internal
 
template<typename T>
class story_ptr : public internal::story_ptr_base
{
public:
    story_ptr(T* ptr, internal::ref_block* story)
        : story_ptr_base(story)
        , _ptr(ptr)
    {
        add_reference();
    }
 
    template<typename U>
    story_ptr(T* ptr, const story_ptr<U>& other)
        : story_ptr_base(other)
        , _ptr(ptr)
    {
        add_reference();
    }
 
    story_ptr(T* ptr)
        : story_ptr_base(nullptr, nullptr)
        , _ptr(nullptr)
    {
        inkAssert(ptr == nullptr, "can not create story_ptr from existing pointer!");
    }
 
    // null constructor
    story_ptr()
        : story_ptr_base(nullptr, nullptr)
        , _ptr(nullptr)
    {
    }
 
    // destructor
    ~story_ptr();
 
    // == copy methods ==
    story_ptr(const story_ptr<T>& oth);
    story_ptr<T>& operator=(const story_ptr<T>& oth);
 
    // == casting ==
    template<typename U>
    story_ptr<U> cast()
    {
        // if cast fails, return null
#ifdef INK_ENABLE_RTTI
        U* casted = dynamic_cast<U*>(_ptr);
#else
        U* casted = reinterpret_cast<U*>(_ptr);
#endif
        if (casted == nullptr)
            return nullptr;
 
        // create new pointer with casted value but same instance blocks
        return story_ptr<U>(casted, *this);
    }
 
    // == equality ==
    inline bool operator==(const story_ptr<T>& other) { return _ptr == other._ptr; }
 
    // == validity ==
    bool is_valid() const { return story_ptr_base::is_valid() && _ptr; }
 
    inline operator bool() const { return is_valid(); }
 
    // === dereference operators ==
    inline T* get() { return is_valid() ? _ptr : nullptr; }
 
    inline const T* get() const { return is_valid() ? _ptr : nullptr; }
 
    inline T* operator->() { return get(); }
 
    inline const T* operator->() const { return get(); }
 
    inline T& operator*() { return *get(); }
 
    inline const T& operator*() const { return *get(); }
 
private:
    T* _ptr;
};
 
template<typename T>
story_ptr<T>::~story_ptr()
{
    if (remove_reference()) {
        delete _ptr;
        _ptr = nullptr;
    }
}
 
template<typename T>
story_ptr<T>::story_ptr(const story_ptr<T>& other)
    : story_ptr_base(other)
    , _ptr(other._ptr)
{
    add_reference();
}
 
template<typename T>
story_ptr<T>& story_ptr<T>::operator=(const story_ptr<T>& other)
{
    // Clear out any old data
    if (remove_reference()) {
        delete _ptr;
        _ptr = nullptr;
    }
 
    // Set pointers
    set(other);
    _ptr = other._ptr;
 
    // initialize
    add_reference();
 
    // return reference to self
    return *this;
}
} // namespace ink::runtime