Class RefPtr

dnn/include/megdnn/basic_types.h:409–457

};

class RefPtr {
    std::shared_ptr<void*> m_ref;
    size_t m_offset;
    bool m_mutable;

public:
    RefPtr() {
        m_ref = std::make_shared<void*>((void*)nullptr);
        m_offset = 0;
        m_mutable = true;
    }

    RefPtr(void* ref_ptr, const size_t offset = 0) {
        m_ref = std::make_shared<void*>(ref_ptr);
        m_offset = offset;
        m_mutable = true;
    }

    explicit RefPtr(
            std::shared_ptr<void*> ref_ptr, const size_t offset = 0,
            bool is_mutable = true) {
        m_ref = ref_ptr;
        m_offset = offset;
        m_mutable = is_mutable;
    }

    void* get_ptr() const {
        return static_cast<void*>(
                (*m_ref != NULL) ? static_cast<dt_byte*>(*m_ref) + m_offset : nullptr);
    }

    bool is_mutable() const { return m_mutable; }

    void reset(const void* ptr, size_t offset = 0);

    RefPtr& operator+=(size_t offset) {
        m_offset += offset;
        return *this;
    }

    bool operator==(const RefPtr& other) const {
        return *m_ref == *other.m_ref && m_offset == other.m_offset;
    }

    template <typename T>
    T* ptr() const {
        return static_cast<T*>(get_ptr());
    }
};

/**
 * \brief A simple encapsulation class for n-dimensional tensor.