projects/qtd: qt/d1/qt/QtdObject.d comparison

comparison qt/d1/qt/QtdObject.d @ 261:8f7bb7fc3123 lifetime

Preparing for a better world

author	maxter
date	Mon, 21 Sep 2009 13:11:04 +0000
parents	b5773ccab07d
children	90131f64c9c9

comparison

equal deleted inserted replaced

-:b5773ccab07d
+:8f7bb7fc3123
 enum QtdObjectFlags : ubyte
 {
 none,
 // The native object will not be deleted when the wrapper is deleted
-skipNativeDelete          = 0b0001,
+skipNativeDelete          = 0b0_0001,
-skipDDelete               = 0b0010,
+// The wrapper will not be deleted when the native object is deleted
-hasDId                    = 0b0100,
+skipDDelete               = 0b0_0010,
-stackAllocated            = 0b1000
+// D object reference is stored in the shell
-/+
+hasDId                    = 0b0_0100,
-// The will be deleted when is goes out of scope. Implies skipNativeDelete
+// The wrapper is allocated on thread-local stack and destroyed at the end of the scope
-scoped                    = 0x08
+stackAllocated            = 0b0_1000
-+/
+// It is a QObject
+isQObject                 = 0b1_0000
 }
 class MetaObject
 {
 alias typeof(this) This;
 private
 {
 MetaObject _base;
 ClassInfo _classInfo;
 }
 //COMPILER BUG: not accessible from QMetaObject
 protected
 {
 this(QtdMetaObjectBase base)
 {
 super(base);
 }
-void construct(T : QtdObject, Concrete = T)()
+void construct(T : QtdObject)()
 {
 super.construct!(T);
 _createWrapper = &T.__createWrapper;
 }
 }
-/++
-Meta-object for polymorphic Qt classes.
-+/
 final class QtdMetaObject : QtdMetaObjectBase
 {
 alias typeof(this) This;
 private void* _typeId;
 return static_cast!(QtdObject)(_createWrapper(nativeId, flags));
 }
 }
+class IdMappings
+{
+private void* _data;
+this()
+{
+}
+void add(void* nativeId, void* dId)
+{
+}
+void remove(void* dId)
+{
+}
+void* opIndex[void* nativeId]
+{
+}
+~this()
+{
+free(_data);
+}
+}
 abstract class QtdObjectBase
 {
 alias typeof(this) This;
 void* __nativeId;
 QtdObjectFlags __flags;
 new (size_t size, QtdObjectFlags flags = QtdObjectFlags.none)
 {
 return flags & QtdObjectFlags.stackAllocated ? __stackAlloc.alloc(size) :
 GC.malloc(size, GC.BlkAttr.FINALIZE);
 }
 this(void* nativeId, QtdObjectFlags flags = QtdObjectFlags.none)
 {
 __nativeId = nativeId;
 __flags = flags;
 debug(QtdVerbose) __print("D wrapper constructed");
 }
 debug(QtdVerbose)
 {
 {
 debug(QtdVerbose) __print("In QtdObjectBase destructor");
 if (!(__flags & QtdObjectFlags.skipNativeDelete))
 {
+// Avoid deleting the wrapper twice
 __flags |= QtdObjectFlags.skipDDelete;
 debug(QtdVerbose) __print("About to call native delete");
 __deleteNative;
 }
 }
 }
 // Base class for by-reference objects
 abstract class QtdObject : QtdObjectBase
 {
 private
 {
 typeof(this) __next, __prev;
+ubyte __nativeRef_;
 static typeof(this) __root;
-}
-/++
-Use this method instead of 'is' operator to check if two D objects
-wrap the same native object.
-+/
-bool isSame(QtdObject other)
-{
-return __nativeId == other.__nativeId;
 }
 mixin SignalHandlerOps;
 this(void* nativeId, QtdObjectFlags flags)
 {
 super (nativeId, flags);
-if (!(flags & QtdObjectFlags.skipNativeDelete))
-__pin;
+if (!(flags & QtdObjectFlags.isQObject) && !(flags & QtdObjectFlags.hasDId))
-}
+__addIdMapping;
+}
-final void __pin()
-{
+void __addIdMapping() {}
-debug(QtdVerbose) __print("Pinning");
+void __removeIdMapping() {}
-__next = __root;
+final void __nativeRef()
-__root = this;
+{
-if (__next)
+assert (__nativeRef_ < 255);
-__next.__prev = this;
-}
+if (!__nativeRef_)
+{
-final void __unpin()
+__next = __root;
-{
+__root = this;
-debug(QtdVerbose) __print("Unpinning");
+if (__next)
+__next.__prev = this;
-if (__prev)
+}
-__prev.__next = __next;
+__nativeRef_++;
-else
-__root = __next;
+debug(QtdVerbose) __print("Native ref incremented");
+}
-if (__next)
-__next.__prev = __prev;
+final void __nativeDeref()
-}
+{
+assert (__nativeRef > 0);
-void __nativeOwnership(bool value)
+__nativeRef_--;
-{
-if (value)
+if (!__nativeRef_)
 {
-assert (!(__flags & QtdObjectFlags.skipNativeDelete));
+if (__prev)
-__flags |= QtdObjectFlags.skipNativeDelete;
+__prev.__next = __next;
-__unpin;
+else
-}
+__root = __next;
-else
-{
+if (__next)
-assert (__flags & QtdObjectFlags.skipNativeDelete);
+__next.__prev = __prev;
-__flags = __flags &= ~QtdObjectFlags.skipNativeDelete;
+}
-__pin;
-}
+debug(QtdVerbose) __print("Native ref decremented");
 }
 ~this()
 {
-debug(QtdVerbose) __print("In QtdObject destructor");
+if (!(__flags & QtdObjectFlags.isQObject) && !(__flags & QtdObjectFlags.hasDId))
+__removeMapping;
-if (__prev || __root is this)
-__unpin;
+if (__nativeRef_)
-}
+{
-}
+if (__nativeRef_ > 1)
+{
-/++
+debug(QtdVerbose) __print("Native ref is greater then 1 when deleting the object");
-+/
+__nativeRef_ = 1;
-void dispose(QtdObjectBase obj)
+}
-{
+__nativeDeref;
-obj.__flags &= ~QtdObjectFlags.skipNativeDelete;
+}
-delete obj;
+}
 }
 // Called from shell destructors
 extern(C) void qtd_delete_d_object(void* dId)
 {
 // Avoid deleting native object twice
 obj.__flags |= QtdObjectFlags.skipNativeDelete;
 delete obj;
 }
 }
+extern(C) void qtd_native_ref(void* dId)
+{
+(cast(QtdObject)dId).__nativeRef;
+}
+extern(C) void qtd_native_deref(void* dId)
+{
+(cast(QtdObject)dId).__nativeDeref;
+}

Mercurial > projects > qtd

comparison qt/d1/qt/QtdObject.d @ 261:8f7bb7fc3123 lifetime