ptr.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef COMMON_PTR_H
#define COMMON_PTR_H

#include "common/scummsys.h"
#include "common/noncopyable.h"
#include "common/safe-bool.h"
#include "common/types.h"

/* For nullptr_t */
#include <cstddef>

namespace Common {

class BasePtrTrackerInternal {
public:
    typedef int RefValue;

    BasePtrTrackerInternal() : _weakRefCount(1), _strongRefCount(1) {}
    virtual ~BasePtrTrackerInternal() {}

    void incWeak() {
        _weakRefCount++;
    }

    void decWeak() {
        if (--_weakRefCount == 0)
            delete this;
    }

    void incStrong() {
        _strongRefCount++;
    }

    void decStrong() {
        if (--_strongRefCount == 0) {
            destructObject();
            decWeak();
        }
    }

    bool isAlive() const {
        return _strongRefCount > 0;
    }

    RefValue getStrongCount() const {
        return _strongRefCount;
    }

protected:
    virtual void destructObject() = 0;

private:
    RefValue _weakRefCount; // Weak ref count + 1 if object ref count > 0
    RefValue _strongRefCount;
};

template<class T>
class BasePtrTrackerImpl : public BasePtrTrackerInternal {
public:
    BasePtrTrackerImpl(T *ptr) : _ptr(ptr) {}

protected:
    void destructObject() override {
        STATIC_ASSERT(sizeof(T) > 0, SharedPtr_cannot_delete_incomplete_type);
        delete _ptr;
    }

    T *_ptr;
};

template<class T, class DL>
class BasePtrTrackerDeletionImpl : public BasePtrTrackerInternal {
public:
    BasePtrTrackerDeletionImpl(T *ptr, DL d) : _ptr(ptr), _deleter(d) {}

private:
    void destructObject() override {
        _deleter(_ptr);
    }

    T *_ptr;
    DL _deleter;
};

template<class T>
class WeakPtr;

template<class T>
class SharedPtr : public SafeBool<SharedPtr<T> > {
    template<class T2>
    friend class WeakPtr;
    template<class T2>
    friend class SharedPtr;
public:
    // Invariant: If _tracker is non-null, then the object is alive
    typedef T *PointerType;
    typedef T &ReferenceType;
    typedef BasePtrTrackerInternal::RefValue RefValue;

    SharedPtr() : _pointer(nullptr), _tracker(nullptr) {
    }

    SharedPtr(std::nullptr_t) : _pointer(nullptr), _tracker(nullptr) {
    }

    ~SharedPtr() {
        if (_tracker)
            _tracker->decStrong();
    }

    template<class T2>
    explicit SharedPtr(T2 *p) : _pointer(p), _tracker(p ? (new BasePtrTrackerImpl<T2>(p)) : nullptr) {
    }

    template<class T2, class DL>
    SharedPtr(T2 *p, DL d) : _pointer(p), _tracker(p ? (new BasePtrTrackerDeletionImpl<T2, DL>(p, d)) : nullptr) {
    }

    SharedPtr(const SharedPtr<T> &r) : _pointer(r._pointer), _tracker(r._tracker) {
        if (_tracker)
            _tracker->incStrong();
    }

    template<class T2>
    SharedPtr(const SharedPtr<T2> &r) : _pointer(r._pointer), _tracker(r._tracker) {
        if (_tracker)
            _tracker->incStrong();
    }

    template<class T2>
    explicit SharedPtr(const WeakPtr<T2> &r) : _pointer(nullptr), _tracker(nullptr) {
        if (r._tracker && r._tracker->isAlive()) {
            _pointer = r._pointer;
            _tracker = r._tracker;
            _tracker->incStrong();
        }
    }

    SharedPtr &operator=(const SharedPtr &r) {
        reset(r);
        return *this;
    }

    template<class T2>
    SharedPtr &operator=(const SharedPtr<T2> &r) {
        reset(r);
        return *this;
    }

    T &operator*() const { assert(_pointer); return *_pointer; }
    T *operator->() const { assert(_pointer); return _pointer; }

    PointerType get() const { return _pointer; }

    template<class T2>
    bool operator==(const SharedPtr<T2> &r) const {
        return _pointer == r.get();
    }

    template<class T2>
    bool operator!=(const SharedPtr<T2> &r) const {
        return _pointer != r.get();
    }

    bool operator==(std::nullptr_t) const {
        return _pointer == nullptr;
    }

    bool operator!=(std::nullptr_t) const {
        return _pointer != nullptr;
    }

    bool operator_bool() const {
        return _pointer != nullptr;
    }

    int refCount() const {
        if (_tracker == nullptr)
            return 0;
        return _tracker->getStrongCount();
    }

    bool unique() const {
        return refCount() == 1;
    }

    void reset() {
        if (_tracker)
            _tracker->decStrong();
        _tracker = nullptr;
        _pointer = nullptr;
    }

    template<class T2>
    void reset(const SharedPtr<T2> &r) {
        BasePtrTrackerInternal *oldTracker = _tracker;

        _pointer = r._pointer;
        _tracker = r._tracker;

        if (_tracker)
            _tracker->incStrong();
        if (oldTracker)
            oldTracker->decStrong();
    }

    template<class T2>
    void reset(const WeakPtr<T2> &r) {
        BasePtrTrackerInternal *oldTracker = _tracker;

        if (r._tracker && r._tracker->isAlive()) {
            _tracker = r._tracker;
            _pointer = r._pointer;
            _tracker->incStrong();
        } else {
            _tracker = nullptr;
            _pointer = nullptr;
        }

        if (oldTracker)
            oldTracker->decStrong();
    }

    void reset(T *ptr) {
        if (_tracker)
            _tracker->decStrong();

        _pointer = ptr;
        _tracker = new BasePtrTrackerImpl<T>(ptr);
    }

    template<class T2>
    SharedPtr<T2> staticCast() const {
        return SharedPtr<T2>(static_cast<T2 *>(_pointer), _tracker);
    }

    template<class T2>
    SharedPtr<T2> dynamicCast() const {
        return SharedPtr<T2>(dynamic_cast<T2 *>(_pointer), _tracker);
    }

    template<class T2>
    SharedPtr<T2> constCast() const {
        return SharedPtr<T2>(const_cast<T2 *>(_pointer), _tracker);
    }

    template<class T2>
    SharedPtr<T2> reinterpretCast() const {
        return SharedPtr<T2>(reinterpret_cast<T2 *>(_pointer), _tracker);
    }

private:
    SharedPtr(T *pointer, BasePtrTrackerInternal *tracker) : _pointer(pointer), _tracker(tracker) {
        if (tracker)
            tracker->incStrong();
    }

    T *_pointer;
    BasePtrTrackerInternal *_tracker;
};



template<class T>
class WeakPtr {
    template<class T2>
    friend class WeakPtr;
    template<class T2>
    friend class SharedPtr;
public:
    WeakPtr() : _pointer(nullptr), _tracker(nullptr) {
    }

    WeakPtr(std::nullptr_t) : _pointer(nullptr), _tracker(nullptr) {
    }

    WeakPtr(const WeakPtr<T> &r) : _pointer(r._pointer), _tracker(r._tracker) {
        if (_tracker)
            _tracker->incWeak();
    }

    ~WeakPtr() {
        if (_tracker)
            _tracker->decWeak();
    }

    template<class T2>
    WeakPtr(const WeakPtr<T2> &r) : _pointer(r._pointer), _tracker(r._tracker) {
        if (_tracker)
            _tracker->incWeak();
    }

    template<class T2>
    WeakPtr(const SharedPtr<T2> &r) : _pointer(r._pointer), _tracker(r._tracker) {
        if (_tracker)
            _tracker->incWeak();
    }

    template<class T2>
    WeakPtr<T2> staticCast() const {
        return WeakPtr<T2>(expired() ? nullptr : static_cast<T2 *>(_pointer), _tracker);
    }

    template<class T2>
    WeakPtr<T2> dynamicCast() const {
        return WeakPtr<T2>(expired() ? nullptr : dynamic_cast<T2 *>(_pointer), _tracker);
    }

    template<class T2>
    WeakPtr<T2> constCast() const {
        return WeakPtr<T2>(expired() ? nullptr : const_cast<T2 *>(_pointer), _tracker);
    }

    template<class T2>
    WeakPtr<T2> reinterpretCast() const {
        return WeakPtr<T2>(expired() ? nullptr : reinterpret_cast<T2 *>(_pointer), _tracker);
    }

    SharedPtr<T> lock() const {
        return SharedPtr<T>(*this);
    }

    int refCount() const {
        if (_tracker == nullptr)
            return 0;
        return _tracker->getStrongCount();
    }

    bool expired() const {
        return _tracker == nullptr || _tracker->getStrongCount() == 0;
    }

    template<class T2>
    bool owner_before(const WeakPtr<T2>& other) const {
        return _tracker < other._tracker;
    }

    template<class T2>
    bool owner_before(const SharedPtr<T2> &other) const {
        return _tracker < other._tracker;
    }

    WeakPtr<T> &operator=(const WeakPtr<T> &r) {
        reset(r);
        return *this;
    }

    template<class T2>
    WeakPtr<T> &operator=(const WeakPtr<T2> &r) {
        reset(r);
        return *this;
    }

    template<class T2>
    WeakPtr<T> &operator=(const SharedPtr<T2> &r) {
        reset(r);
        return *this;
    }

    void reset() {
        if (_tracker)
            _tracker->decWeak();
        _tracker = nullptr;
        _pointer = nullptr;
    }

    template<class T2>
    void reset(const SharedPtr<T2> &r) {
        BasePtrTrackerInternal *oldTracker = _tracker;

        _pointer = r._pointer;
        _tracker = r._tracker;

        if (_tracker)
            _tracker->incWeak();
        if (oldTracker)
            oldTracker->decWeak();
    }

    template<class T2>
    void reset(const WeakPtr<T2> &r) {
        BasePtrTrackerInternal *oldTracker = _tracker;

        _pointer = r._pointer;
        _tracker = r._tracker;

        if (_tracker)
            _tracker->incWeak();
        if (oldTracker)
            oldTracker->decWeak();
    }

private:
    WeakPtr(T *pointer, BasePtrTrackerInternal *tracker) : _pointer(pointer), _tracker(tracker) {
        if (tracker)
            tracker->incWeak();
    }

    T *_pointer;
    BasePtrTrackerInternal *_tracker;
};

template <typename T>
struct DefaultDeleter {
    inline void operator()(T *object) {
        STATIC_ASSERT(sizeof(T) > 0, cannot_delete_incomplete_type);
        delete object;
    }
};

template <typename T>
struct ArrayDeleter {
    inline void operator()(T *object) {
        STATIC_ASSERT(sizeof(T) > 0, cannot_delete_incomplete_type);
        delete[] object;
    }
};

template<typename T, class DL = DefaultDeleter<T> >
class ScopedPtr : private NonCopyable, public SafeBool<ScopedPtr<T, DL> > {
    template<class T2, class DL2>
    friend class ScopedPtr;
public:
    typedef T ValueType;
    typedef T *PointerType;
    typedef T &ReferenceType;

    explicit ScopedPtr(PointerType o = nullptr) : _pointer(o) {}
    ScopedPtr(std::nullptr_t) : _pointer(nullptr) {}

    template<class T2>
    ScopedPtr(ScopedPtr<T2> &&o) : _pointer(o._pointer) {
        o._pointer = nullptr;
        }

    ReferenceType operator*() const { return *_pointer; }
    PointerType operator->() const { return _pointer; }

    bool operator_bool() const { return _pointer != nullptr; }

    ~ScopedPtr() {
        DL()(_pointer);
    }

    void reset(PointerType o = nullptr) {
        DL()(_pointer);
        _pointer = o;
    }

    ScopedPtr &operator=(std::nullptr_t) {
        reset(nullptr);
    }

    template<class T2>
    ScopedPtr &operator=(ScopedPtr<T2> &&other) {
        PointerType oldPointer = _pointer;
        _pointer = other._pointer;
        other._pointer = nullptr;
        DL()(oldPointer);
        return *this;
    }

    PointerType get() const { return _pointer; }

    PointerType release() {
        PointerType r = _pointer;
        _pointer = nullptr;
        return r;
    }

private:
    PointerType _pointer;
};

template<typename T, class DL = DefaultDeleter<T> >
class DisposablePtr : private NonCopyable, public SafeBool<DisposablePtr<T, DL> > {
public:
    typedef T  ValueType;
    typedef T *PointerType;
    typedef T &ReferenceType;

    explicit DisposablePtr(PointerType o, DisposeAfterUse::Flag dispose) : _pointer(o), _dispose(dispose), _shared() {}
    explicit DisposablePtr(SharedPtr<T> o) : _pointer(o.get()), _dispose(DisposeAfterUse::NO), _shared(o) {}
    DisposablePtr(DisposablePtr<T, DL>&& o) : _pointer(o._pointer), _dispose(o._dispose), _shared(o._shared) {
        o._pointer = nullptr;
        o._dispose = DisposeAfterUse::NO;
        o._shared.reset();
    }

    ~DisposablePtr() {
        if (_dispose) DL()(_pointer);
    }

    ReferenceType operator*() const { return *_pointer; }
    PointerType operator->() const { return _pointer; }

    bool operator_bool() const { return _pointer != nullptr; }

    void reset(PointerType o, DisposeAfterUse::Flag dispose) {
        if (_dispose) DL()(_pointer);
        _pointer = o;
        _dispose = dispose;
        _shared.reset();
    }

    void reset() {
        reset(nullptr, DisposeAfterUse::NO);
    }

    template <class T2>
    bool isDynamicallyCastable() {
        return dynamic_cast<T2 *>(_pointer) != nullptr;
    }

    /* Destroys the smart pointer while returning a pointer to
       assign to a new object.
     */
    template <class T2, class DL2 = DefaultDeleter<T2> >
    DisposablePtr<T2, DL2> moveAndDynamicCast() {
        DisposablePtr<T2, DL2> ret(nullptr, DisposeAfterUse::NO);
        ret._pointer = dynamic_cast<T2 *>(_pointer);
        ret._dispose = _dispose;
        ret._shared = _shared.template dynamicCast<T2>();
        _pointer = nullptr;
        _dispose = DisposeAfterUse::NO;
        _shared.reset();
        return ret;
    }

    PointerType get() const { return _pointer; }

    template <class T2, class DL2>
    friend class DisposablePtr;

private:
    DisposablePtr() : _pointer(nullptr), _dispose(DisposeAfterUse::NO), _shared() {}
    PointerType           _pointer;
    DisposeAfterUse::Flag _dispose;
    SharedPtr<T>          _shared;
    bool                  _isvalid;
};


#if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM) || defined(_M_ARM64))

template<class T>
class UnalignedPtr {
public:
    UnalignedPtr();
    UnalignedPtr(__unaligned T *ptr);

    T load() const;
    void store(const T &value) const;

private:
    __unaligned T *_ptr;
};

template<class T>
UnalignedPtr<T>::UnalignedPtr() : _ptr(nullptr) {
}

template<class T>
UnalignedPtr<T>::UnalignedPtr(__unaligned T *ptr) : _ptr(ptr) {
}

template<class T>
T UnalignedPtr<T>::load() const {
    return *_ptr;
}

template<class T>
void UnalignedPtr<T>::store(const T &value) const {
    *_ptr = value;
}

#else

template<class T>
class UnalignedPtr {
public:
    UnalignedPtr();
    UnalignedPtr(T *ptr);

    T load() const;
    void store(const T &value) const;

private:
    void *_ptr;
};

template<class T>
UnalignedPtr<T>::UnalignedPtr() : _ptr(nullptr) {
}

template<class T>
UnalignedPtr<T>::UnalignedPtr(T *ptr) : _ptr(ptr) {
}

template<class T>
T UnalignedPtr<T>::load() const {
    T result;
    memcpy(&result, _ptr, sizeof(T));
    return result;
}

template<class T>
void UnalignedPtr<T>::store(const T &value) const {
    memcpy(_ptr, &value, sizeof(T));
}

#endif

} // End of namespace Common

#endif