object.h 5.28 KB
Newer Older
Wenzel Jakob's avatar
Wenzel Jakob committed
1
2
3
4
#if !defined(__OBJECT_H)
#define __OBJECT_H

#include <atomic>
Dean Moldovan's avatar
Dean Moldovan committed
5
#include "constructor_stats.h"
Wenzel Jakob's avatar
Wenzel Jakob committed
6
7
8
9
10

/// Reference counted object base class
class Object {
public:
    /// Default constructor
11
    Object() { print_default_created(this); }
Wenzel Jakob's avatar
Wenzel Jakob committed
12
13

    /// Copy constructor
14
    Object(const Object &) : m_refCount(0) { print_copy_created(this); }
Wenzel Jakob's avatar
Wenzel Jakob committed
15

16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
    /// Return the current reference count
    int getRefCount() const { return m_refCount; };

    /// Increase the object's reference count by one
    void incRef() const { ++m_refCount; }

    /** \brief Decrease the reference count of
     * the object and possibly deallocate it.
     *
     * The object will automatically be deallocated once
     * the reference count reaches zero.
     */
    void decRef(bool dealloc = true) const {
        --m_refCount;
        if (m_refCount == 0 && dealloc)
Wenzel Jakob's avatar
Wenzel Jakob committed
31
32
            delete this;
        else if (m_refCount < 0)
33
            throw std::runtime_error("Internal error: reference count < 0!");
Wenzel Jakob's avatar
Wenzel Jakob committed
34
35
36
37
    }

    virtual std::string toString() const = 0;
protected:
38
39
40
41
    /** \brief Virtual protected deconstructor.
     * (Will only be called by \ref ref)
     */
    virtual ~Object() { print_destroyed(this); }
Wenzel Jakob's avatar
Wenzel Jakob committed
42
43
44
45
private:
    mutable std::atomic<int> m_refCount { 0 };
};

46
47
48
49
50
51
// Tag class used to track constructions of ref objects.  When we track constructors, below, we
// track and print out the actual class (e.g. ref<MyObject>), and *also* add a fake tracker for
// ref_tag.  This lets us check that the total number of ref<Anything> constructors/destructors is
// correct without having to check each individual ref<Whatever> type individually.
class ref_tag {};

Wenzel Jakob's avatar
Wenzel Jakob committed
52
53
54
55
56
57
58
59
60
61
62
63
/**
 * \brief Reference counting helper
 *
 * The \a ref refeference template is a simple wrapper to store a
 * pointer to an object. It takes care of increasing and decreasing
 * the reference count of the object. When the last reference goes
 * out of scope, the associated object will be deallocated.
 *
 * \ingroup libcore
 */
template <typename T> class ref {
public:
64
    /// Create a nullptr reference
65
    ref() : m_ptr(nullptr) { print_default_created(this); track_default_created((ref_tag*) this); }
Wenzel Jakob's avatar
Wenzel Jakob committed
66
67

    /// Construct a reference from a pointer
68
69
    ref(T *ptr) : m_ptr(ptr) {
        if (m_ptr) ((Object *) m_ptr)->incRef();
70
71
72

        print_created(this, "from pointer", m_ptr); track_created((ref_tag*) this, "from pointer");

73
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
74

75
    /// Copy constructor
Wenzel Jakob's avatar
Wenzel Jakob committed
76
77
78
    ref(const ref &r) : m_ptr(r.m_ptr) {
        if (m_ptr)
            ((Object *) m_ptr)->incRef();
79
80

        print_copy_created(this, "with pointer", m_ptr); track_copy_created((ref_tag*) this);
Wenzel Jakob's avatar
Wenzel Jakob committed
81
82
83
    }

    /// Move constructor
84
    ref(ref &&r) noexcept : m_ptr(r.m_ptr) {
Wenzel Jakob's avatar
Wenzel Jakob committed
85
        r.m_ptr = nullptr;
86
87

        print_move_created(this, "with pointer", m_ptr); track_move_created((ref_tag*) this);
Wenzel Jakob's avatar
Wenzel Jakob committed
88
89
90
91
92
93
    }

    /// Destroy this reference
    ~ref() {
        if (m_ptr)
            ((Object *) m_ptr)->decRef();
94
95

        print_destroyed(this); track_destroyed((ref_tag*) this);
Wenzel Jakob's avatar
Wenzel Jakob committed
96
97
98
    }

    /// Move another reference into the current one
99
    ref &operator=(ref &&r) noexcept {
100
101
        print_move_assigned(this, "pointer", r.m_ptr); track_move_assigned((ref_tag*) this);

102
103
104
105
106
107
108
109
110
111
112
        if (*this == r)
            return *this;
        if (m_ptr)
            ((Object *) m_ptr)->decRef();
        m_ptr = r.m_ptr;
        r.m_ptr = nullptr;
        return *this;
    }

    /// Overwrite this reference with another reference
    ref& operator=(const ref& r) {
113
114
        print_copy_assigned(this, "pointer", r.m_ptr); track_copy_assigned((ref_tag*) this);

115
116
117
118
119
120
121
122
123
124
125
126
        if (m_ptr == r.m_ptr)
            return *this;
        if (m_ptr)
            ((Object *) m_ptr)->decRef();
        m_ptr = r.m_ptr;
        if (m_ptr)
            ((Object *) m_ptr)->incRef();
        return *this;
    }

    /// Overwrite this reference with a pointer to another object
    ref& operator=(T *ptr) {
127
128
        print_values(this, "assigned pointer"); track_values((ref_tag*) this, "assigned pointer");

129
130
131
132
133
134
135
136
137
        if (m_ptr == ptr)
            return *this;
        if (m_ptr)
            ((Object *) m_ptr)->decRef();
        m_ptr = ptr;
        if (m_ptr)
            ((Object *) m_ptr)->incRef();
        return *this;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
138

139
140
    /// Compare this reference with another reference
    bool operator==(const ref &r) const { return m_ptr == r.m_ptr; }
Wenzel Jakob's avatar
Wenzel Jakob committed
141

142
143
    /// Compare this reference with another reference
    bool operator!=(const ref &r) const { return m_ptr != r.m_ptr; }
Wenzel Jakob's avatar
Wenzel Jakob committed
144

145
146
    /// Compare this reference with a pointer
    bool operator==(const T* ptr) const { return m_ptr == ptr; }
Wenzel Jakob's avatar
Wenzel Jakob committed
147

148
149
    /// Compare this reference with a pointer
    bool operator!=(const T* ptr) const { return m_ptr != ptr; }
Wenzel Jakob's avatar
Wenzel Jakob committed
150

151
152
    /// Access the object referenced by this reference
    T* operator->() { return m_ptr; }
Wenzel Jakob's avatar
Wenzel Jakob committed
153

154
155
    /// Access the object referenced by this reference
    const T* operator->() const { return m_ptr; }
Wenzel Jakob's avatar
Wenzel Jakob committed
156

157
158
    /// Return a C++ reference to the referenced object
    T& operator*() { return *m_ptr; }
Wenzel Jakob's avatar
Wenzel Jakob committed
159

160
161
    /// Return a const C++ reference to the referenced object
    const T& operator*() const { return *m_ptr; }
Wenzel Jakob's avatar
Wenzel Jakob committed
162

163
164
    /// Return a pointer to the referenced object
    operator T* () { return m_ptr; }
Wenzel Jakob's avatar
Wenzel Jakob committed
165

166
    /// Return a const pointer to the referenced object
167
    T* get_ptr() { return m_ptr; }
Wenzel Jakob's avatar
Wenzel Jakob committed
168

169
    /// Return a pointer to the referenced object
170
    const T* get_ptr() const { return m_ptr; }
Wenzel Jakob's avatar
Wenzel Jakob committed
171
private:
172
    T *m_ptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
173
174
175
};

#endif /* __OBJECT_H */