Update of /cvsroot/mahogany/M/include
In directory sc8-pr-cvs1:/tmp/cvs-serv18801/include
Modified Files:
MObject.h pointers.h
Log Message:
Resolved cyclic ref counting in LineBook and brought WeakRef to usable state
Index: MObject.h
===================================================================
RCS file: /cvsroot/mahogany/M/include/MObject.h,v
retrieving revision 1.30
retrieving revision 1.31
diff -b -u -2 -r1.30 -r1.31
--- MObject.h 9 Oct 2003 16:39:09 -0000 1.30
+++ MObject.h 16 Oct 2003 10:29:22 -0000 1.31
@@ -16,5 +16,4 @@
#define MOBJECT_H
-class WeakRefCounter;
class MObjectRC;
@@ -26,6 +25,8 @@
extern void RefCounterDecrement(MObjectRC *pointer);
extern void RefCounterAssign(MObjectRC *target,MObjectRC *source);
-extern WeakRefCounter *WeakRefAdd(MObjectRC *pointer);
-extern void WeakRefDeleted(WeakRefCounter *counter);
+extern void WeakRefIncrement(MObjectRC *pointer);
+extern void WeakRefDecrement(MObjectRC *pointer);
+extern void WeakRefAssign(MObjectRC *target,MObjectRC *source);
+extern bool WeakRefExpired(const MObjectRC *pointer);
// ----------------------------------------------------------------------------
@@ -149,5 +150,5 @@
MObjectRC();
#else
- MObjectRC() { m_nRef = 1; m_weak = 0; }
+ MObjectRC() { m_nRef = 1; m_weakRef = 0; }
#endif
@@ -181,5 +182,13 @@
{ MOcheck(); wxASSERT(m_nRef > 0); m_nRef++; }
virtual bool DecRef()
- { MOcheck(); if ( --m_nRef ) return TRUE; delete this; return FALSE; }
+ {
+ MOcheck();
+ if ( --m_nRef )
+ return TRUE;
+ this->~MObjectRC();
+ if( !m_weakRef )
+ ::operator delete(this);
+ return FALSE;
+ }
#endif ///debug/release
@@ -187,5 +196,5 @@
//// dtor is protected because only DecRef() can delete us
virtual ~MObjectRC()
- { MOcheck(); wxASSERT(m_nRef == 0); WeakRefDeleted(m_weak); }
+ { MOcheck(); wxASSERT(m_nRef == 0); }
//// return the reference count:
size_t GetNRef(void) const { return m_nRef; }
@@ -197,6 +206,10 @@
// Support for WeakRef
- friend WeakRefCounter *WeakRefAdd(MObjectRC *pointer);
- WeakRefCounter *m_weak;
+ friend void WeakRefIncrement(MObjectRC *pointer);
+ friend void WeakRefDecrement(MObjectRC *pointer);
+ friend void WeakRefAssign(MObjectRC *target,MObjectRC *source);
+ friend bool WeakRefExpired(const MObjectRC *pointer);
+
+ size_t m_weakRef; // Delay call to ::operator delete() while > 0
};
Index: pointers.h
===================================================================
RCS file: /cvsroot/mahogany/M/include/pointers.h,v
retrieving revision 1.5
retrieving revision 1.6
diff -b -u -2 -r1.5 -r1.6
--- pointers.h 9 Oct 2003 16:39:09 -0000 1.5
+++ pointers.h 16 Oct 2003 10:29:22 -0000 1.6
@@ -16,8 +16,4 @@
#define M_POINTERS_H
-class WeakRefCounter;
-
-extern void WeakRefRemove(WeakRefCounter *counter);
-
/**
An MObjectRC-based smart pointer implementation.
@@ -60,5 +56,5 @@
@param pointer the pointer to take ownership of, may be NULL
*/
- RefCounter(T *pointer) { m_pointer = pointer; }
+ explicit RefCounter(T *pointer) { m_pointer = pointer; }
/**
@@ -109,4 +105,10 @@
}
+ void Attach(T *pointer)
+ {
+ RefCounterDecrement(m_pointer);
+ m_pointer = pointer;
+ }
+
/**
Releases ownership of the held pointer and returns it.
@@ -123,4 +125,11 @@
}
+ static RefCounter<T> Convert(T *pointer)
+ {
+ RefCounter<T> result;
+ result.AttachAndIncRef(pointer);
+ return result;
+ }
+
/// Expects object that has not been IncRef-ed yet, don't use if possible
void AttachAndIncRef(T *pointer)
@@ -138,28 +147,47 @@
// and WeakRef goes in the opposite direction. WeakRef (seems that it)
// contains NULL if all RefCounter instances are gone (and the object
-// is deleted).
-template <class ClassName>
+// is deleted). WeakRef is a bit inefficient. That's why you should
+// always convert it to RefCounter when you want to use object it points to.
+template <class T>
class WeakRef
{
public:
- WeakRef() { InitNull(); }
- WeakRef(RefCounter<ClassName> pointer) { Init(pointer); }
- ~WeakRef() { Destroy(); }
+ WeakRef() : m_pointer(NULL) {}
+ WeakRef(const WeakRef<T> ©)
+ : m_pointer(copy.m_pointer)
+ { WeakRefIncrement(m_pointer); }
+ ~WeakRef() { WeakRefDecrement(m_pointer); }
+
+ WeakRef(RefCounter<T> pointer)
+ : m_pointer(pointer.Get())
+ { WeakRefIncrement(m_pointer); }
-private:
- // not implemented
- WeakRef<ClassName> operator=(const WeakRef<ClassName> ©) { return *this; }
- WeakRef(const WeakRef<ClassName> ©) {}
+ WeakRef<T>& operator=(const WeakRef<T> ©)
+ {
+ WeakRefAssign(m_pointer,copy.m_pointer);
+ m_pointer = copy.m_pointer;
+ return *this;
+ }
+
+ WeakRef<T>& operator=(RefCounter<T> pointer)
+ {
+ m_pointer = pointer.Get();
+ WeakRefIncrement(m_pointer);
+ return *this;
+ }
+
+ bool Expired() const { return WeakRefExpired(m_pointer); }
- void InitNull() { m_pointer = 0; m_counter = 0; }
- void Init(RefCounter<ClassName> pointer)
+ RefCounter<T> Get() const
{
- m_pointer = static_cast<ClassName *>(pointer);
- m_counter = WeakRefAdd(m_pointer);
+ RefCounter<T> result;
+ result.AttachAndIncRef(Expired() ? NULL : m_pointer);
+ return result;
}
- void Destroy() { WeakRefRemove(m_counter); }
- ClassName *m_pointer;
- WeakRefCounter *m_counter;
+ operator RefCounter<T>() const { return Get(); }
+
+private:
+ T *m_pointer;
};
@@ -198,5 +226,5 @@
// Use instead of forward declaration to make RefCounter and WeakRef
-// instantiable without knowledge that ClassName derives from MObjectRC.
+// instantiable without knowledge that T derives from MObjectRC.
#define DECLARE_REF_COUNTER(T) \
class T; \
@@ -204,5 +232,8 @@
extern void RefCounterDecrement(T *pointer); \
extern void RefCounterAssign(T *target,T *source); \
- extern WeakRefCounter *WeakRefAdd(T *pointer);
+ extern void WeakRefIncrement(T *pointer); \
+ extern void WeakRefDecrement(T *pointer); \
+ extern void WeakRefAssign(T *target,T *source); \
+ extern bool WeakRefExpired(const T *pointer);
@@ -219,6 +250,15 @@
static_cast<MObjectRC *>(source)); \
} \
- extern WeakRefCounter *WeakRefAdd(T *pointer) \
- { return WeakRefAdd(static_cast<MObjectRC *>(pointer)); }
+ extern void WeakRefIncrement(T *pointer) \
+ { WeakRefIncrement(static_cast<MObjectRC *>(pointer)); } \
+ extern void WeakRefDecrement(T *pointer) \
+ { WeakRefDecrement(static_cast<MObjectRC *>(pointer)); } \
+ extern void WeakRefAssign(T *target,T *source) \
+ { \
+ WeakRefAssign(static_cast<MObjectRC *>(target), \
+ static_cast<MObjectRC *>(source)); \
+ } \
+ extern bool WeakRefExpired(const T *pointer) \
+ { return WeakRefExpired(static_cast<const MObjectRC *>(pointer)); } \
-------------------------------------------------------
This SF.net email is sponsored by: SF.net Giveback Program.
SourceForge.net hosts over 70,000 Open Source Projects.
See the people who have HELPED US provide better services:
Click here: http://sourceforge.net/supporters.php
_______________________________________________
Mahogany-cvsupdates mailing list
[EMAIL PROTECTED]
https://lists.sourceforge.net/lists/listinfo/mahogany-cvsupdates
