src/common/Ref.h

/*
 * Copyright (c) 2014 Christian Schoenebeck
 *
 * http://www.linuxsampler.org
 *
 * This file is part of LinuxSampler and released under the same terms.
 * See README file for details.
 */

#ifndef LS_REF_H
#define LS_REF_H

#include <set>
#include <stdio.h>

// You may enable this while developing or at least when you encounter any kind
// of crashes or other misbehaviors in conjunction with Ref class guarded code.
// Enabling the following macro will add a bunch of sanity checks for easing
// debugging of such issues, however it comes with the cost that everything will
// be much slower.
#define LS_REF_ASSERT_MODE 0

#if LS_REF_ASSERT_MODE
# warning LS_REF_ASSERT_MODE is enabled which will decrease runtime efficiency!
#endif

// Enable this for VERY verbose debug messages for debbugging deep issues with
// Ref class.
#define LS_REF_VERBOSE_DEBUG_MSG 0

#if LS_REF_ASSERT_MODE
# include <assert.h>
#endif

namespace LinuxSampler {

    //TODO: make reference count increment/decrement thread safe

    template<typename T, typename T_BASE> class Ref;

    extern std::set<void*> _allRefPtrs;

    /**
     * Exists just for implementation detail purpose, you cannot use it
     * directly. Use its derived template class Ref instead.
     *
     * @see Ref
     */
    template<typename T_BASE>
    class RefBase {
    public:
        template<typename T_BASE1>
        class _RefCounter {
        public:
            _RefCounter(T_BASE1* p, int refs) :
                references(refs), ptr(p)
            {
                #if LS_REF_VERBOSE_DEBUG_MSG
                printf("Ref 0x%lx: new counter (refs=%d)\n", (long long)ptr, references);
                #endif
                #if LS_REF_ASSERT_MODE
                assert(p);
                assert(refs > 0);
                assert(!_allRefPtrs.count(p));
                _allRefPtrs.insert(p);
                #endif
            }

            virtual ~_RefCounter() {
                #if LS_REF_VERBOSE_DEBUG_MSG
                printf("Ref 0x%lx: counter destructor (refs=%d)\n", (long long)ptr, references);
                #endif
                fflush(stdout);
            }

            void retain() {
                references++;
                #if LS_REF_VERBOSE_DEBUG_MSG
                printf("Ref 0x%lx: retain (refs=%d)\n", (long long)ptr, references);
                #endif
            }

            void release() {
                if (!references) return;
                references--;
                #if LS_REF_VERBOSE_DEBUG_MSG
                printf("Ref 0x%lx: release (refs=%d)\n", (long long)ptr, references);
                #endif
                if (!references) deletePtr();
            }
        //protected:
            void deletePtr() {
                #if LS_REF_VERBOSE_DEBUG_MSG
                printf("RefCounter 0x%lx: deletePtr() (refs=%d)\n", (long long)ptr, references);
                #endif
                #if LS_REF_ASSERT_MODE
                assert(!references);
                _allRefPtrs.erase(ptr);
                #endif
                delete ptr;
                delete this;
            }

            int references;
            T_BASE1* ptr;
            //friend class ... todo
        };
        typedef _RefCounter<T_BASE> RefCounter;

        virtual ~RefBase() {
            if (refCounter) refCounter->release();
            refCounter = NULL;
        }

    //protected:
        RefCounter* refCounter;
        //friend class Ref<T_BASE, T_BASE>;

    protected:
        RefBase() : refCounter(NULL) {
            #if LS_REF_VERBOSE_DEBUG_MSG
            printf("(RefBase empty ctor)\n");
            #endif
        }
/*
        RefBase(RefCounter* rc) {
            refCounter = rc;
        }

        RefBase(const RefBase& r) {
            refCounter = r.refCounter;
            if (refCounter) refCounter->retain();
        }
*/
    };

    /**
     * Replicates a std::shared_ptr template class, to avoid a build requirement
     * of having a C++11 compliant compiler (std::shared_ptr was not part of the
     * C++03 standard).
     *
     * In contrast to the STL implementation though this implementation here
     * also supports copying references of derived, different types (in a type
     * safe manner). You can achieve that by providing a second template
     * argument (which is optional), for declaring a common subtype. For example
     * the following code would not compile:
     * @code
     * void example(UILabel* pLabel) {
     *     Ref<UILabel> lbl = pLabel;
     *     Ref<UIWidget> w = lbl; // compile error, incompatible Ref types
     *     w->resize(16,300);
     * }
     * @endcode
     * Whereas the following would work:
     * @code
     * void example(UILabel* pLabel) {
     *     Ref<UILabel,UIWidget> lbl = pLabel;
     *     Ref<UIWidget> w = lbl; // works (assuming that UILabel is a subclass of UIWidget)
     *     w->resize(16,300);
     * }
     * @endcode
     * Like the STL's std::shared_ptr, this class also emulates raw pointer
     * access and operators. With one addition: if used in the derived common
     * subtype manner as shown above, access to the actual data and boolean
     * operator will also check whether the underlying pointer (of the common
     * subclass) can actually be casted safely to the objects main type (first
     * template argument of this class). For example:
     * @code
     * void example(UILabel* pLabel) { // assuming pLabel is not NULL ...
     *     Ref<UILabel,UIWidget> lbl = pLabel;
     *     Ref<UIDialog,UIWidget> dlg = lbl;
     *     bool b1 = lbl; // will be true (assuming pLabel was not NULL)
     *     bool b2 = dlg; // will be false (assuming that UIDialog is not derived from UILabel)
     *     lbl->setText("foo"); // works
     *     dlg->showModal(); // would crash with -> operator providing a NULL pointer
     * }
     * @endcode
     * Like with std::shared_ptr you must be @b very cautious that you
     * initialize only one Ref class object directly with the same raw pointer.
     * If you forget this fundamental rule somewhere, your code will crash!
     * @code
     * UIWidget* ptr = new UIWidget();
     * Ref<UIWidget> w1 = ptr;
     * Ref<UIWidget> w2 = w1;  // this is OK, copy from a Ref object
     * Ref<UIWidget> w3 = ptr; // illegal! 2nd direct init from same raw pointer. This will crash!
     * @endcode
     * It would be possible to write an implementation of the Ref class that
     * could handle the case above as well without crashing, however it would be
     * too slow for practice. Because it would require a global lookup table
     * maintaining all memory pointers which are currently already guarded by
     * this class. Plus it would need an expensive synchronization to prevent
     * concurrent access on that global lookup table.
     */
    template<typename T, typename T_BASE = T>
    class Ref : public RefBase<T_BASE> {
    public:
        typedef RefBase<T_BASE> RefBaseT;
        typedef typename RefBase<T_BASE>::RefCounter RefCounter;
        
        Ref() : RefBaseT() {
            #if LS_REF_VERBOSE_DEBUG_MSG
            printf("Ref empty ctor Ref:0x%lx\n", (long long)this);
            #endif
        }

        Ref(const T_BASE* p) : RefBaseT() {
            #if LS_REF_VERBOSE_DEBUG_MSG
            printf("Ref base ptr ctor Ref:0x%lx <- p:0x%lx\n", (long long)this, (long long)p);
            #endif
            RefBaseT::refCounter = p ? new RefCounter((T_BASE*)p, 1) : NULL;
        }

        Ref(const T* p) : RefBaseT() {
            #if LS_REF_VERBOSE_DEBUG_MSG
            printf("Ref main ptr ctor Ref:0x%lx <- p:0x%lx\n", (long long)this, (long long)p);
            #endif
            RefBaseT::refCounter = p ? new RefCounter((T*)p, 1) : NULL;
        }

        Ref(const RefBaseT& r) : RefBaseT() {
            #if LS_REF_VERBOSE_DEBUG_MSG
            printf("Ref base ref ctor Ref:0x%lx <- Ref:0x%lx\n", (long long)this, (long long)&r);
            #endif
            RefBaseT::refCounter = r.refCounter;
            if (RefBaseT::refCounter)
                RefBaseT::refCounter->retain();
        }

        Ref(const Ref& r) : RefBaseT() {
            #if LS_REF_VERBOSE_DEBUG_MSG
            printf("Ref main ref ctor Ref:0x%lx <- Ref:0x%lx\n", (long long)this, (long long)&r);
            #endif
            RefBaseT::refCounter = r.refCounter;
            if (RefBaseT::refCounter)
                RefBaseT::refCounter->retain();
        }

        inline T* operator->() {
            return dynamic_cast<T*>( RefBaseT::refCounter->ptr );
        }

        inline const T* operator->() const {
            return dynamic_cast<const T*>( RefBaseT::refCounter->ptr );
        }

        inline T& operator*() {
            return *dynamic_cast<T*>( RefBaseT::refCounter->ptr );
        }

        inline const T& operator*() const {
            return *dynamic_cast<const T*>( RefBaseT::refCounter->ptr );
        }

        inline bool operator==(const RefBaseT& other) const {
            return RefBaseT::refCounter == other.refCounter;
        }

        inline bool operator!=(const RefBaseT& other) const {
            return RefBaseT::refCounter != other.refCounter;
        }

        inline operator bool() const {
            return RefBaseT::refCounter && RefBaseT::refCounter->ptr &&
                   dynamic_cast<const T*>( RefBaseT::refCounter->ptr );
        }

        inline bool operator!() const {
            return !( RefBaseT::refCounter && RefBaseT::refCounter->ptr &&
                      dynamic_cast<const T*>( RefBaseT::refCounter->ptr ) );
        }

/*
        inline operator RefBaseT&() {
            return *this;
        }
        
        inline operator const RefBaseT&() const {
            return *this;
        }
*/
        inline bool isEquivalent(const RefBaseT& other) const {
            if (static_cast<const RefBaseT*>(this) == &other)
                return true;
            return (RefBaseT::refCounter == other.refCounter);
        }

        inline bool isEquivalent(const T_BASE* const other) const {
            if (!other) return !RefBaseT::refCounter;
            if (!RefBaseT::refCounter) return false;
            return other == RefBaseT::refCounter->ptr;
        }

        Ref<T,T_BASE>& operator=(const RefBaseT& other) {
            #if LS_REF_VERBOSE_DEBUG_MSG
            printf("Ref base ref assignment Ref:0x%lx <- Ref:0x%lx\n", (long long)this, (long long)&other);
            #endif
            if (isEquivalent(other)) {
                #if LS_REF_VERBOSE_DEBUG_MSG
                printf("Ref 0x%lx WRN: equivalent ref assignment ignored.\n", (long long)this);
                #endif
                return *this;
            }
            if (RefBaseT::refCounter) {
                RefBaseT::refCounter->release();
                RefBaseT::refCounter = NULL;
            }
            RefBaseT::refCounter = other.refCounter;
            if (RefBaseT::refCounter)
                RefBaseT::refCounter->retain();
            return *this;
        }

        Ref<T,T_BASE>& operator=(const Ref<T,T_BASE>& other) {
            #if LS_REF_VERBOSE_DEBUG_MSG
            printf("Ref main ref assignment Ref:0x%lx <- Ref:0x%lx\n", (long long)this, (long long)&other);
            #endif
            if (isEquivalent(other)) {
                #if LS_REF_VERBOSE_DEBUG_MSG
                printf("Ref 0x%lx WRN: equivalent ref assignment ignored.\n", (long long)this);
                #endif
                return *this;
            }
            if (RefBaseT::refCounter) {
                RefBaseT::refCounter->release();
                RefBaseT::refCounter = NULL;
            }
            RefBaseT::refCounter = other.refCounter;
            if (RefBaseT::refCounter)
                RefBaseT::refCounter->retain();
            return *this;
        }

        Ref<T,T_BASE>& operator=(const T* p) {
            #if LS_REF_VERBOSE_DEBUG_MSG
            printf("Ref main ptr assignment Ref:0x%lx <- p:0x%lx\n", (long long)this, p);
            #endif
            if (isEquivalent(p)) {
                #if LS_REF_VERBOSE_DEBUG_MSG
                printf("Ref 0x%lx WRN: equivalent ptr assignment ignored.\n", (long long)this);
                #endif
                return *this;
            }
            if (RefBaseT::refCounter) {
                RefBaseT::refCounter->release();
                RefBaseT::refCounter = NULL;
            }
            RefBaseT::refCounter = p ? new RefCounter((T*)p, 1) : NULL;
            #if LS_REF_VERBOSE_DEBUG_MSG
            printf("Ref main ptr assignment done\n");
            #endif
            return *this;
        }

        Ref<T,T_BASE>& operator=(const T_BASE* p) {
            #if LS_REF_VERBOSE_DEBUG_MSG
            printf("Ref base ptr assignment Ref:0x%lx <- p:0x%lx\n", (long long)this, p);
            #endif
            if (isEquivalent(p)) {
                #if LS_REF_VERBOSE_DEBUG_MSG
                printf("Ref 0x%lx WRN: equivalent ptr assignment ignored.\n", (long long)this);
                #endif
                return *this;
            }
            if (RefBaseT::refCounter) {
                RefBaseT::refCounter->release();
                RefBaseT::refCounter = NULL;
            }
            RefBaseT::refCounter = p ? new RefCounter((T*)p, 1) : NULL;
            return *this;
        }
    };

} // namespace LinuxSampler

#endif // LS_REF_H
1	/*
2	* Copyright (c) 2014 Christian Schoenebeck
3	*
4	* http://www.linuxsampler.org
5	*
6	* This file is part of LinuxSampler and released under the same terms.
7	* See README file for details.
8	*/
9
10	#ifndef LS_REF_H
11	#define LS_REF_H
12
13	#include <set>
14	#include <stdio.h>
15
16	// You may enable this while developing or at least when you encounter any kind
17	// of crashes or other misbehaviors in conjunction with Ref class guarded code.
18	// Enabling the following macro will add a bunch of sanity checks for easing
19	// debugging of such issues, however it comes with the cost that everything will
20	// be much slower.
21	#define LS_REF_ASSERT_MODE 0
22
23	#if LS_REF_ASSERT_MODE
24	# warning LS_REF_ASSERT_MODE is enabled which will decrease runtime efficiency!
25	#endif
26
27	// Enable this for VERY verbose debug messages for debbugging deep issues with
28	// Ref class.
29	#define LS_REF_VERBOSE_DEBUG_MSG 0
30
31	#if LS_REF_ASSERT_MODE
32	# include <assert.h>
33	#endif
34
35	namespace LinuxSampler {
36
37	//TODO: make reference count increment/decrement thread safe
38
39	template<typename T, typename T_BASE> class Ref;
40
41	extern std::set<void*> _allRefPtrs;
42
43	/**
44	* Exists just for implementation detail purpose, you cannot use it
45	* directly. Use its derived template class Ref instead.
46	*
47	* @see Ref
48	*/
49	template<typename T_BASE>
50	class RefBase {
51	public:
52	template<typename T_BASE1>
53	class _RefCounter {
54	public:
55	_RefCounter(T_BASE1* p, int refs) :
56	references(refs), ptr(p)
57	{
58	#if LS_REF_VERBOSE_DEBUG_MSG
59	printf("Ref 0x%lx: new counter (refs=%d)\n", (long long)ptr, references);
60	#endif
61	#if LS_REF_ASSERT_MODE
62	assert(p);
63	assert(refs > 0);
64	assert(!_allRefPtrs.count(p));
65	_allRefPtrs.insert(p);
66	#endif
67	}
68
69	virtual ~_RefCounter() {
70	#if LS_REF_VERBOSE_DEBUG_MSG
71	printf("Ref 0x%lx: counter destructor (refs=%d)\n", (long long)ptr, references);
72	#endif
73	fflush(stdout);
74	}
75
76	void retain() {
77	references++;
78	#if LS_REF_VERBOSE_DEBUG_MSG
79	printf("Ref 0x%lx: retain (refs=%d)\n", (long long)ptr, references);
80	#endif
81	}
82
83	void release() {
84	if (!references) return;
85	references--;
86	#if LS_REF_VERBOSE_DEBUG_MSG
87	printf("Ref 0x%lx: release (refs=%d)\n", (long long)ptr, references);
88	#endif
89	if (!references) deletePtr();
90	}
91	//protected:
92	void deletePtr() {
93	#if LS_REF_VERBOSE_DEBUG_MSG
94	printf("RefCounter 0x%lx: deletePtr() (refs=%d)\n", (long long)ptr, references);
95	#endif
96	#if LS_REF_ASSERT_MODE
97	assert(!references);
98	_allRefPtrs.erase(ptr);
99	#endif
100	delete ptr;
101	delete this;
102	}
103
104	int references;
105	T_BASE1* ptr;
106	//friend class ... todo
107	};
108	typedef _RefCounter<T_BASE> RefCounter;
109
110	virtual ~RefBase() {
111	if (refCounter) refCounter->release();
112	refCounter = NULL;
113	}
114
115	//protected:
116	RefCounter* refCounter;
117	//friend class Ref<T_BASE, T_BASE>;
118
119	protected:
120	RefBase() : refCounter(NULL) {
121	#if LS_REF_VERBOSE_DEBUG_MSG
122	printf("(RefBase empty ctor)\n");
123	#endif
124	}
125	/*
126	RefBase(RefCounter* rc) {
127	refCounter = rc;
128	}
129
130	RefBase(const RefBase& r) {
131	refCounter = r.refCounter;
132	if (refCounter) refCounter->retain();
133	}
134	*/
135	};
136
137	/**
138	* Replicates a std::shared_ptr template class, to avoid a build requirement
139	* of having a C++11 compliant compiler (std::shared_ptr was not part of the
140	* C++03 standard).
141	*
142	* In contrast to the STL implementation though this implementation here
143	* also supports copying references of derived, different types (in a type
144	* safe manner). You can achieve that by providing a second template
145	* argument (which is optional), for declaring a common subtype. For example
146	* the following code would not compile:
147	* @code
148	* void example(UILabel* pLabel) {
149	* Ref<UILabel> lbl = pLabel;
150	* Ref<UIWidget> w = lbl; // compile error, incompatible Ref types
151	* w->resize(16,300);
152	* }
153	* @endcode
154	* Whereas the following would work:
155	* @code
156	* void example(UILabel* pLabel) {
157	* Ref<UILabel,UIWidget> lbl = pLabel;
158	* Ref<UIWidget> w = lbl; // works (assuming that UILabel is a subclass of UIWidget)
159	* w->resize(16,300);
160	* }
161	* @endcode
162	* Like the STL's std::shared_ptr, this class also emulates raw pointer
163	* access and operators. With one addition: if used in the derived common
164	* subtype manner as shown above, access to the actual data and boolean
165	* operator will also check whether the underlying pointer (of the common
166	* subclass) can actually be casted safely to the objects main type (first
167	* template argument of this class). For example:
168	* @code
169	* void example(UILabel* pLabel) { // assuming pLabel is not NULL ...
170	* Ref<UILabel,UIWidget> lbl = pLabel;
171	* Ref<UIDialog,UIWidget> dlg = lbl;
172	* bool b1 = lbl; // will be true (assuming pLabel was not NULL)
173	* bool b2 = dlg; // will be false (assuming that UIDialog is not derived from UILabel)
174	* lbl->setText("foo"); // works
175	* dlg->showModal(); // would crash with -> operator providing a NULL pointer
176	* }
177	* @endcode
178	* Like with std::shared_ptr you must be @b very cautious that you
179	* initialize only one Ref class object directly with the same raw pointer.
180	* If you forget this fundamental rule somewhere, your code will crash!
181	* @code
182	* UIWidget* ptr = new UIWidget();
183	* Ref<UIWidget> w1 = ptr;
184	* Ref<UIWidget> w2 = w1; // this is OK, copy from a Ref object
185	* Ref<UIWidget> w3 = ptr; // illegal! 2nd direct init from same raw pointer. This will crash!
186	* @endcode
187	* It would be possible to write an implementation of the Ref class that
188	* could handle the case above as well without crashing, however it would be
189	* too slow for practice. Because it would require a global lookup table
190	* maintaining all memory pointers which are currently already guarded by
191	* this class. Plus it would need an expensive synchronization to prevent
192	* concurrent access on that global lookup table.
193	*/
194	template<typename T, typename T_BASE = T>
195	class Ref : public RefBase<T_BASE> {
196	public:
197	typedef RefBase<T_BASE> RefBaseT;
198	typedef typename RefBase<T_BASE>::RefCounter RefCounter;
199
200	Ref() : RefBaseT() {
201	#if LS_REF_VERBOSE_DEBUG_MSG
202	printf("Ref empty ctor Ref:0x%lx\n", (long long)this);
203	#endif
204	}
205
206	Ref(const T_BASE* p) : RefBaseT() {
207	#if LS_REF_VERBOSE_DEBUG_MSG
208	printf("Ref base ptr ctor Ref:0x%lx <- p:0x%lx\n", (long long)this, (long long)p);
209	#endif
210	RefBaseT::refCounter = p ? new RefCounter((T_BASE*)p, 1) : NULL;
211	}
212
213	Ref(const T* p) : RefBaseT() {
214	#if LS_REF_VERBOSE_DEBUG_MSG
215	printf("Ref main ptr ctor Ref:0x%lx <- p:0x%lx\n", (long long)this, (long long)p);
216	#endif
217	RefBaseT::refCounter = p ? new RefCounter((T*)p, 1) : NULL;
218	}
219
220	Ref(const RefBaseT& r) : RefBaseT() {
221	#if LS_REF_VERBOSE_DEBUG_MSG
222	printf("Ref base ref ctor Ref:0x%lx <- Ref:0x%lx\n", (long long)this, (long long)&r);
223	#endif
224	RefBaseT::refCounter = r.refCounter;
225	if (RefBaseT::refCounter)
226	RefBaseT::refCounter->retain();
227	}
228
229	Ref(const Ref& r) : RefBaseT() {
230	#if LS_REF_VERBOSE_DEBUG_MSG
231	printf("Ref main ref ctor Ref:0x%lx <- Ref:0x%lx\n", (long long)this, (long long)&r);
232	#endif
233	RefBaseT::refCounter = r.refCounter;
234	if (RefBaseT::refCounter)
235	RefBaseT::refCounter->retain();
236	}
237
238	inline T* operator->() {
239	return dynamic_cast<T*>( RefBaseT::refCounter->ptr );
240	}
241
242	inline const T* operator->() const {
243	return dynamic_cast<const T*>( RefBaseT::refCounter->ptr );
244	}
245
246	inline T& operator*() {
247	return dynamic_cast<T>( RefBaseT::refCounter->ptr );
248	}
249
250	inline const T& operator*() const {
251	return dynamic_cast<const T>( RefBaseT::refCounter->ptr );
252	}
253
254	inline bool operator==(const RefBaseT& other) const {
255	return RefBaseT::refCounter == other.refCounter;
256	}
257
258	inline bool operator!=(const RefBaseT& other) const {
259	return RefBaseT::refCounter != other.refCounter;
260	}
261
262	inline operator bool() const {
263	return RefBaseT::refCounter && RefBaseT::refCounter->ptr &&
264	dynamic_cast<const T*>( RefBaseT::refCounter->ptr );
265	}
266
267	inline bool operator!() const {
268	return !( RefBaseT::refCounter && RefBaseT::refCounter->ptr &&
269	dynamic_cast<const T*>( RefBaseT::refCounter->ptr ) );
270	}
271
272	/*
273	inline operator RefBaseT&() {
274	return *this;
275	}
276
277	inline operator const RefBaseT&() const {
278	return *this;
279	}
280	*/
281	inline bool isEquivalent(const RefBaseT& other) const {
282	if (static_cast<const RefBaseT*>(this) == &other)
283	return true;
284	return (RefBaseT::refCounter == other.refCounter);
285	}
286
287	inline bool isEquivalent(const T_BASE* const other) const {
288	if (!other) return !RefBaseT::refCounter;
289	if (!RefBaseT::refCounter) return false;
290	return other == RefBaseT::refCounter->ptr;
291	}
292
293	Ref<T,T_BASE>& operator=(const RefBaseT& other) {
294	#if LS_REF_VERBOSE_DEBUG_MSG
295	printf("Ref base ref assignment Ref:0x%lx <- Ref:0x%lx\n", (long long)this, (long long)&other);
296	#endif
297	if (isEquivalent(other)) {
298	#if LS_REF_VERBOSE_DEBUG_MSG
299	printf("Ref 0x%lx WRN: equivalent ref assignment ignored.\n", (long long)this);
300	#endif
301	return *this;
302	}
303	if (RefBaseT::refCounter) {
304	RefBaseT::refCounter->release();
305	RefBaseT::refCounter = NULL;
306	}
307	RefBaseT::refCounter = other.refCounter;
308	if (RefBaseT::refCounter)
309	RefBaseT::refCounter->retain();
310	return *this;
311	}
312
313	Ref<T,T_BASE>& operator=(const Ref<T,T_BASE>& other) {
314	#if LS_REF_VERBOSE_DEBUG_MSG
315	printf("Ref main ref assignment Ref:0x%lx <- Ref:0x%lx\n", (long long)this, (long long)&other);
316	#endif
317	if (isEquivalent(other)) {
318	#if LS_REF_VERBOSE_DEBUG_MSG
319	printf("Ref 0x%lx WRN: equivalent ref assignment ignored.\n", (long long)this);
320	#endif
321	return *this;
322	}
323	if (RefBaseT::refCounter) {
324	RefBaseT::refCounter->release();
325	RefBaseT::refCounter = NULL;
326	}
327	RefBaseT::refCounter = other.refCounter;
328	if (RefBaseT::refCounter)
329	RefBaseT::refCounter->retain();
330	return *this;
331	}
332
333	Ref<T,T_BASE>& operator=(const T* p) {
334	#if LS_REF_VERBOSE_DEBUG_MSG
335	printf("Ref main ptr assignment Ref:0x%lx <- p:0x%lx\n", (long long)this, p);
336	#endif
337	if (isEquivalent(p)) {
338	#if LS_REF_VERBOSE_DEBUG_MSG
339	printf("Ref 0x%lx WRN: equivalent ptr assignment ignored.\n", (long long)this);
340	#endif
341	return *this;
342	}
343	if (RefBaseT::refCounter) {
344	RefBaseT::refCounter->release();
345	RefBaseT::refCounter = NULL;
346	}
347	RefBaseT::refCounter = p ? new RefCounter((T*)p, 1) : NULL;
348	#if LS_REF_VERBOSE_DEBUG_MSG
349	printf("Ref main ptr assignment done\n");
350	#endif
351	return *this;
352	}
353
354	Ref<T,T_BASE>& operator=(const T_BASE* p) {
355	#if LS_REF_VERBOSE_DEBUG_MSG
356	printf("Ref base ptr assignment Ref:0x%lx <- p:0x%lx\n", (long long)this, p);
357	#endif
358	if (isEquivalent(p)) {
359	#if LS_REF_VERBOSE_DEBUG_MSG
360	printf("Ref 0x%lx WRN: equivalent ptr assignment ignored.\n", (long long)this);
361	#endif
362	return *this;
363	}
364	if (RefBaseT::refCounter) {
365	RefBaseT::refCounter->release();
366	RefBaseT::refCounter = NULL;
367	}
368	RefBaseT::refCounter = p ? new RefCounter((T*)p, 1) : NULL;
369	return *this;
370	}
371	};
372
373	} // namespace LinuxSampler
374
375	#endif // LS_REF_H