Mercurial > projects > qtd

comparison d2/qtd/QMetaTypeImpl.d @ 372:a032df77b6ab

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Simple debug helper. Unittests. Meta-object for polymorphic non-QObjects
author Max Samukha <maxter@spambox.com>
date Thu, 08 Jul 2010 17:19:05 +0300
parents bcbfffef4f9e
children b64ca517a6b7
comparison
equal deleted inserted replaced
370:7fd4b69378bf 372:a032df77b6ab
17 { 17 {
18 void[] array; 18 void[] array;
19 } 19 }
20 20
21 /** 21 /**
22 */ 22 Default implementation of constructors/destructors
23 registered with Qt when qtd_qRegisterMetaType is called
24 for a T.
25
26 For Ts that are passed-by-reference objects, we follow Qt's convention and
27 allocate/copy references, not objects. To override this behavior,
28 supply qtd_qRegisterMetaType with a custom constructor/destructor implementation.
29 */
23 template MetaTypeOps(T) 30 template MetaTypeOps(T)
24 { 31 {
25 // Note that in case of byref objects we follow Qt's convention and
26 // allocate/copy references, not objects.
27 static void* construct(void* copy) 32 static void* construct(void* copy)
28 { 33 {
29 auto T* p = cast(T*)GC.malloc(T.sizeof); 34 auto T* p = cast(T*)GC.malloc(T.sizeof);
30 if (!p) 35 if (!p)
31 onOutOfMemoryError(); 36 onOutOfMemoryError();
49 return p; 54 return p;
50 } 55 }
51 56
52 static void destroy(void* ptr) 57 static void destroy(void* ptr)
53 { 58 {
54 // Run destructors for value types. Let the GC reclaim the memory. 59 // Run destructors for structs. Let the GC reclaim the memory.
55 static if (is(T == struct) && __traits(compiles, T.__dtor)) 60 static if (is(T == struct) && __traits(compiles, T.__dtor))
56 (cast(T*)ptr).__dtor; 61 (cast(T*)ptr).__dtor;
57 } 62 }
58 } 63 }
59 64
61 */ 66 */
62 template MetaTypeStreamOps(T) 67 template MetaTypeStreamOps(T)
63 { 68 {
64 void save(QDataStream ds, const void* data) 69 void save(QDataStream ds, const void* data)
65 { 70 {
66 writeln("Saving ", ds.__nativeId, " ", data);
67 } 71 }
68 72
69 void load(QDataStream ds, void* data) 73 void load(QDataStream ds, void* data)
70 { 74 {
71 writeln("Loading ", ds.__nativeId, " ", data); 75 }
72 } 76 }
73 } 77
74 78 // TODO: only GNU C++ x86 is supported
75 // TODO: only GNU C++ is supported
76 private template typeOpShim(alias op) 79 private template typeOpShim(alias op)
77 { 80 {
78 extern(C) void typeOpShim() 81 extern(C) void typeOpShim()
79 { 82 {
80 asm 83 asm
95 int qRegisterMetaType(T, alias ops = MetaTypeOps)(string name = null) 98 int qRegisterMetaType(T, alias ops = MetaTypeOps)(string name = null)
96 { 99 {
97 if (!name.length) 100 if (!name.length)
98 name = typeid(T).toString; //TODO: use compile time full name 101 name = typeid(T).toString; //TODO: use compile time full name
99 102
100 return qtd_registerType(toStringz(name), &typeOpShim!(ops!T.destroy), &typeOpShim!(ops!T.construct)); 103 return qtd_QMetaType_registerType(toStringz(name), &typeOpShim!(ops!T.destroy), &typeOpShim!(ops!T.construct));
101 } 104 }
102 105
103 version (QtdUnittest) 106 version (QtdUnittest)
104 { 107 {
105 unittest 108 unittest
106 { 109 {
110 /+
107 static class A 111 static class A
108 { 112 {
109 int x; 113 int x;
110 } 114 }
111 115
187 191
188 auto paa2 = cast(int[int]*)QMetaType.construct(aaId, &aa); 192 auto paa2 = cast(int[int]*)QMetaType.construct(aaId, &aa);
189 assert(paa2 !is &aa); 193 assert(paa2 !is &aa);
190 assert(*paa2 == aa); 194 assert(*paa2 == aa);
191 QMetaType.destroy(aaId, paa); 195 QMetaType.destroy(aaId, paa);
196 +/
192 } 197 }
193 } 198 }
194 199
195 200
196 // COMPILER BUG: cannot put this inside qRegisterMetaTypeStreamOperators 201 // COMPILER BUG: cannot put this inside qRegisterMetaTypeStreamOperators
221 if (!name.length) 226 if (!name.length)
222 name = typeid(T).toString; 227 name = typeid(T).toString;
223 228
224 static void save(void* ds, const void* data) 229 static void save(void* ds, const void* data)
225 { 230 {
226 scope dataStream = new QDataStream(ds, QtdObjectFlags.nativeOwnership); 231 scope dataStream = new QDataStream(ds, QtdObjectInitFlags.onStack);
227 ops!T.save(dataStream, data); 232 ops!T.save(dataStream, data);
228 } 233 }
229 234
230 static void load(void* ds, void* data) 235 static void load(void* ds, void* data)
231 { 236 {
232 scope dataStream = new QDataStream(ds, QtdObjectFlags.nativeOwnership); 237 scope dataStream = new QDataStream(ds, QtdObjectInitFlags.onStack);
233 ops!T.load(dataStream, data); 238 ops!T.load(dataStream, data);
234 } 239 }
235 240
236 qtd_registerStreamOperators(toStringz(name), &streamOpShim!save, &streamOpShim!load); 241 qtd_QMetaType_registerStreamOperators(toStringz(name), &streamOpShim!save, &streamOpShim!load);
237 } 242 }
238 243
239 /** 244 extern(C)
240 */ 245 {
241 private extern(C) 246 void qtd_QMetaType_registerStreamOperators(in char *typeName, VoidFunc saveOp, VoidFunc loadOp);
242 { 247 int qtd_QMetaType_registerType(in char* namePtr, VoidFunc ctor, VoidFunc dtor);
243 void qtd_registerStreamOperators(in char *typeName, VoidFunc saveOp, VoidFunc loadOp);
244 int qtd_registerType(in char* namePtr, VoidFunc ctor, VoidFunc dtor);
245 int qtd_QMetaType_type_nativepointerchar(in char* typeName0); 248 int qtd_QMetaType_type_nativepointerchar(in char* typeName0);
246 } 249 }
247