Object.h

浏览该文件的文档.

#pragma once
 
#include "common/Assert.h"
 
#include <type_traits>
 
namespace eve
{
 
class Object;
template <typename T>
concept DerivedFromObject = std::is_base_of_v<eve::Object, T>;
 
class Object {
public:
    Object() { update = this; }
 
    void setUpdate(Object *update) {
        EV_PARAM_CHECK(update != nullptr, "replacement object must not be null");
        this->update = update;
    }
 
protected:
    virtual ~Object() {}
 
    template <typename T>
    friend class ref;
 
    bool isDirty() const { return this != update; }
    Object *getUpdate() const { return update; }
    
    void ref() { ++ref_count; }
    void unref() { if (--ref_count == 0) delete this; }
    
    Object* update;
    unsigned ref_count = 0;
};
 
 
template <typename T>
class ref {
public:
    static_assert( DerivedFromObject<T> );
 
    // Default constructor creates a null pointer.
    ref() : ptr(nullptr) {}
 
    // Constructor from a raw pointer.
    ref(T* ptr) : ptr(ptr) { ptr->ref(); }
 
    // Copy constructor.
    ref(const ref& other) : ptr(other.ptr) { ptr->ref(); }
 
    // Destructor. will call unref() on the object.
    ~ref() { ptr->unref(); }
 
    // Assignment operator. The old object will be unref() and the new one will be ref().
    ref& operator=(const ref& other) {
        if (ptr != other.ptr) {
            ptr->unref();
            ptr = other.ptr;
            ptr->ref();
        }
        return *this;
    }
 
    // Assignment operator from a raw pointer.
    ref& operator=(T* other) {
        if (ptr != other) {
            ptr->unref();
            ptr = other;
            ptr->ref();
        }
        return *this;
    }
 
    operator T*()    { checkDirty(); return ptr; }
    T* operator->()  { checkDirty(); return ptr; }
    T& operator*()   { checkDirty(); return *ptr; }
 
    T* get()  { checkDirty(); return ptr; }
protected:
    // getUpdate() returns the base Object*; the update contract guarantees
    // the replacement is actually a T*, so a downcast here is safe.
    void checkDirty() { if (ptr->isDirty()) ptr = static_cast<T*>(ptr->getUpdate()); }
 
    T* ptr;
};
 
 
} // namespace eve