Mercurial > projects > qtd
annotate qt/d2/qt/Signal.d @ 293:8627891e4556 signals
QList updates
| author | eldar |
|---|---|
| date | Fri, 13 Nov 2009 19:09:28 +0000 |
| parents | c9d1aac290e9 |
| children | 55ee4603365d |
| rev | line source |
|---|---|
| 1 | 1 /** |
| 2 * | |
| 3 * Copyright: Copyright QtD Team, 2008-2009 | |
| 4 * Authors: Max Samukha, Eldar Insafutdinov | |
| 5 * License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a> | |
| 6 * | |
| 7 * Copyright QtD Team, 2008-2009 | |
| 8 * Distributed under the Boost Software License, Version 1.0. | |
| 9 * (See accompanying file boost-license-1.0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
| 10 * | |
| 11 */ | |
| 16 | 12 module qt.Signal; |
| 1 | 13 |
| 14 public import qt.QGlobal; | |
| 288 | 15 import qt.qtd.MetaMarshall; |
| 16 | |
| 1 | 17 import core.stdc.stdlib : crealloc = realloc, cfree = free; |
| 18 import core.stdc.string : memmove; | |
| 19 import | |
| 188 | 20 core.thread, |
| 288 | 21 core.exception, |
| 22 std.algorithm; | |
| 1 | 23 |
| 288 | 24 public import |
| 25 std.typetuple, | |
| 26 std.traits, | |
| 27 std.conv, | |
| 28 std.string, | |
| 29 std.metastrings; | |
|
276
501128ac7a2c
signals cleaned up correctly on receiver destruction
maxter
parents:
268
diff
changeset
|
30 |
| 288 | 31 |
| 32 // returns name, arguments or tuple of the function depending on type parameter | |
| 33 enum {_Name, _Tuple, _Args} | |
| 34 string getFunc(int type)(string fullName) | |
|
276
501128ac7a2c
signals cleaned up correctly on receiver destruction
maxter
parents:
268
diff
changeset
|
35 { |
| 288 | 36 int pos = 0; |
| 37 foreach(i, c; fullName) | |
| 38 if (c == '(') | |
| 39 static if (type == _Tuple) | |
| 40 return fullName[i..$]; | |
| 41 else if (type == _Name) | |
| 42 return fullName[0..i]; | |
| 43 else if (type == _Args) | |
| 44 for(int j = fullName.length-1;; j--) | |
| 45 if(fullName[j] == ')') | |
| 46 return fullName[i+1 .. j]; | |
| 47 return null; | |
| 253 | 48 } |
| 1 | 49 |
| 288 | 50 /** The beast that takes string representation of function arguments |
| 51 * and returns an array of default values it doesn't check if arguments | |
| 52 * without default values follow the arguments with default values for | |
| 53 * simplicity. It is done by mixing in an delegate alias. | |
| 54 */ | |
| 55 string[] defaultValues(string signature) | |
| 1 | 56 { |
| 288 | 57 int braces = 0; |
| 58 bool inDefaultValue = false; | |
| 59 bool inStringLiteral = false; | |
| 60 string[] res; | |
| 61 int startValue = 0; | |
| 62 | |
| 63 if(strip(signature).length == 0) | |
| 64 return res; | |
| 1 | 65 |
| 288 | 66 foreach (i,c; signature) |
| 1 | 67 { |
| 288 | 68 if(!inStringLiteral) |
| 1 | 69 { |
| 288 | 70 if(c == '{' || c =='(') |
| 71 braces++; | |
| 72 else if(c == '}' || c ==')') | |
| 73 braces--; | |
|
276
501128ac7a2c
signals cleaned up correctly on receiver destruction
maxter
parents:
268
diff
changeset
|
74 } |
| 1 | 75 |
| 288 | 76 if(c == '\"' || c == '\'') |
|
276
501128ac7a2c
signals cleaned up correctly on receiver destruction
maxter
parents:
268
diff
changeset
|
77 { |
| 288 | 78 if (inStringLiteral) |
| 79 { | |
| 80 if(signature[i-1] != '\\') | |
| 81 inStringLiteral = false; | |
| 82 } | |
| 83 else | |
| 84 { | |
| 85 inStringLiteral = true; | |
|
276
501128ac7a2c
signals cleaned up correctly on receiver destruction
maxter
parents:
268
diff
changeset
|
86 } |
|
501128ac7a2c
signals cleaned up correctly on receiver destruction
maxter
parents:
268
diff
changeset
|
87 } |
|
501128ac7a2c
signals cleaned up correctly on receiver destruction
maxter
parents:
268
diff
changeset
|
88 |
| 288 | 89 if (!inStringLiteral && braces == 0) |
|
276
501128ac7a2c
signals cleaned up correctly on receiver destruction
maxter
parents:
268
diff
changeset
|
90 { |
| 288 | 91 if(c == '=') // found default value |
|
276
501128ac7a2c
signals cleaned up correctly on receiver destruction
maxter
parents:
268
diff
changeset
|
92 { |
| 288 | 93 inDefaultValue = true; |
| 94 startValue = i+1; | |
| 95 } | |
| 96 else if(c == ',') // next function argument | |
| 97 { | |
| 98 if (inDefaultValue) | |
|
276
501128ac7a2c
signals cleaned up correctly on receiver destruction
maxter
parents:
268
diff
changeset
|
99 { |
| 288 | 100 res ~= signature[startValue..i]; |
| 101 inDefaultValue = false; | |
|
276
501128ac7a2c
signals cleaned up correctly on receiver destruction
maxter
parents:
268
diff
changeset
|
102 } |
|
501128ac7a2c
signals cleaned up correctly on receiver destruction
maxter
parents:
268
diff
changeset
|
103 } |
|
501128ac7a2c
signals cleaned up correctly on receiver destruction
maxter
parents:
268
diff
changeset
|
104 } |
|
501128ac7a2c
signals cleaned up correctly on receiver destruction
maxter
parents:
268
diff
changeset
|
105 } |
|
501128ac7a2c
signals cleaned up correctly on receiver destruction
maxter
parents:
268
diff
changeset
|
106 |
| 288 | 107 if (inDefaultValue) |
| 108 res ~= signature[startValue..$]; | |
| 1 | 109 |
| 288 | 110 return res; |
| 1 | 111 } |
| 112 | |
| 288 | 113 int defaultValuesLength(string[] defVals) |
| 1 | 114 { |
| 288 | 115 return defVals.length; |
| 1 | 116 } |
| 117 | |
| 118 /** | |
| 278 | 119 New implementation. |
| 120 */ | |
| 121 | |
| 288 | 122 |
| 123 | |
| 124 // templates for extracting data from static meta-information of signals, slots or properties | |
| 289 | 125 // public alias TypeTuple!("name", index, OwnerClass, ArgTypes) __signal |
| 288 | 126 template MetaEntryName(source...) |
| 127 { | |
| 128 enum MetaEntryName = source[0]; // name of the metaentry is the first element | |
| 129 } | |
| 130 | |
| 131 template MetaEntryOwner(source...) | |
| 132 { | |
| 133 alias TupleWrapper!(source[2]).at[0] MetaEntryOwner; // class that owns the property is the third | |
| 134 // Compiler #BUG 3092 - evaluates MetaEntryOwner as a Tuple with one element | |
| 135 } | |
| 136 | |
| 137 template MetaEntryArgs(source...) | |
| 138 { | |
| 289 | 139 alias source[3 .. $] MetaEntryArgs; // arguments-tuple starts from the fourth position |
| 288 | 140 } |
|
282
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
141 |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
142 template TupleWrapper(A...) { alias A at; } |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
143 |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
144 template isDg(Dg) |
| 278 | 145 { |
|
282
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
146 enum isDg = is(Dg == delegate); |
| 278 | 147 } |
| 148 | |
|
282
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
149 template isFn(Fn) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
150 { |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
151 enum isFn = is(typeof(*Fn.init) == function); |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
152 } |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
153 |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
154 template isFnOrDg(Dg) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
155 { |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
156 enum isFnOrDg = isFn!(Dg) || isDg!(Dg); |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
157 } |
| 278 | 158 |
| 159 string joinArgs(A...)() | |
| 160 { | |
| 161 string res = ""; | |
| 162 static if(A.length) | |
| 163 { | |
| 164 res = A[0].stringof; | |
| 165 foreach(k; A[1..$]) | |
| 166 res ~= "," ~ k.stringof; | |
| 167 } | |
| 168 return res; | |
| 169 } | |
| 170 | |
|
282
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
171 template SlotPred(T1, T2) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
172 { |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
173 enum SlotPred = is(T1 : T2); |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
174 } |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
175 |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
176 template CheckSlot(alias Needle, alias Source) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
177 { |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
178 static if(Needle.at.length <= Source.at.length) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
179 enum CheckSlot = CheckArgs!(Needle, Source, SlotPred, 0).value; |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
180 else |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
181 enum CheckSlot = false; |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
182 } |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
183 |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
184 template SignalPred(T1, T2) |
| 278 | 185 { |
|
282
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
186 enum SignalPred = is(T1 == T2); |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
187 } |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
188 |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
189 template CheckSignal(alias Needle, alias Source) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
190 { |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
191 static if(Needle.at.length == Source.at.length) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
192 enum CheckSignal = CheckArgs!(Needle, Source, SignalPred, 0).value; |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
193 else |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
194 enum CheckSignal = false; |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
195 } |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
196 |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
197 template CheckArgs(alias Needle, alias Source, alias pred, int i) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
198 { |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
199 static if (i < Needle.at.length) |
| 278 | 200 { |
|
282
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
201 static if (pred!(Needle.at[i], Source.at[i])) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
202 enum value = CheckArgs!(Needle, Source, pred, i + 1).value; |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
203 else |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
204 enum value = false; |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
205 } |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
206 else |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
207 { |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
208 enum value = true; |
| 278 | 209 } |
| 210 } | |
| 211 | |
|
282
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
212 template SigByNamePred(string name, SlotArgs...) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
213 { |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
214 template SigByNamePred(source...) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
215 { |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
216 static if (source[0] == name) // only instantiate CheckSlot if names match |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
217 enum SigByNamePred = CheckSlot!(TupleWrapper!(SlotArgs), TupleWrapper!(source[2 .. $])); |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
218 else |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
219 enum SigByNamePred = false; |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
220 } |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
221 } |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
222 |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
223 template SigBySignPred(string name, SigArgs...) |
| 278 | 224 { |
|
282
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
225 template SigBySignPred(source...) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
226 { |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
227 static if (source[0] == name) // only instantiate CheckSignal if names match |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
228 enum SigBySignPred = CheckSignal!(TupleWrapper!(SigArgs), TupleWrapper!(source[2 .. $])); |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
229 else |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
230 enum SigBySignPred = false; |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
231 } |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
232 } |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
233 |
| 288 | 234 template ByOwner(Owner) |
| 235 { | |
| 236 template ByOwner(source...) | |
| 237 { | |
| 238 enum ByOwner = is(MetaEntryOwner!source == Owner); | |
| 239 } | |
| 240 } | |
| 241 | |
|
282
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
242 template staticSymbolName(string prefix, int id) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
243 { |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
244 const string staticSymbolName = prefix ~ ToString!(id); |
| 278 | 245 } |
| 246 | |
| 247 template signatureString(string name, A...) | |
| 248 { | |
| 249 const string signatureString = name ~ "(" ~ joinArgs!(A) ~ ")"; | |
| 250 } | |
| 251 | |
| 288 | 252 // recursive search in the static meta-information |
|
282
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
253 template findSymbolImpl(string prefix, C, int id, alias pred) |
| 278 | 254 { |
|
282
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
255 static if ( is(typeof(mixin("C." ~ staticSymbolName!(prefix, id)))) ) |
| 278 | 256 { |
|
282
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
257 mixin ("alias C." ~ staticSymbolName!(prefix, id) ~ " current;"); |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
258 static if (pred!current) |
| 278 | 259 alias current result; |
| 260 else | |
|
282
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
261 alias findSymbolImpl!(prefix, C, id + 1, pred).result result; |
| 278 | 262 } |
| 263 else | |
| 264 { | |
|
282
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
265 alias void result; |
| 278 | 266 } |
| 267 } | |
| 268 | |
|
282
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
269 template findSymbol(string prefix, C, alias pred) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
270 { |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
271 alias findSymbolImpl!(prefix, C, 0, pred).result findSymbol; |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
272 } |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
273 |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
274 template findSignal(C, string name, Receiver, SigArgs...) |
| 278 | 275 { |
|
282
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
276 alias TupleWrapper!(ParameterTypeTuple!Receiver) SlotArgsWr; |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
277 static if (SigArgs.length > 0) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
278 { |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
279 alias findSymbol!(signalPrefix, C, SigBySignPred!(name, SigArgs)) result; |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
280 static if (is(result == void)) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
281 static assert(0, "Signal " ~ name ~ "(" ~ joinArgs!SigArgs() ~ ") was not found."); |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
282 else |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
283 static if (!CheckSlot!(SlotArgsWr, TupleWrapper!(result[2 .. $]))) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
284 static assert(0, "Signature of slot is incompatible with signal " ~ name ~ "."); |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
285 } |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
286 else |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
287 { |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
288 alias findSymbol!(signalPrefix, C, SigByNamePred!(name, SlotArgsWr.at)) result; |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
289 static if (is(result == void)) |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
290 static assert(0, "Signal " ~ name ~ " was not found."); |
|
256ab6cb8e85
Signals look-up andNew syntax for connect. The old one will not work from now on. This will allow for the signals overload. Although changes are done for both D1 and D2 versions, D1 won't work because of compiler bugs. I am tired of waiting for fixes.
eldar
parents:
279
diff
changeset
|
291 } |
| 278 | 292 } |
| 293 | |
| 288 | 294 // recursive search in the static meta-information |
| 295 template findSymbolsImpl(string prefix, C, int id, alias pred) | |
| 296 { | |
| 297 static if ( is(typeof(mixin("C." ~ staticSymbolName!(prefix, id)))) ) | |
| 298 { | |
| 299 mixin ("alias C." ~ staticSymbolName!(prefix, id) ~ " current;"); | |
| 300 static if (pred!current) { | |
| 301 alias TupleWrapper!current subres; | |
| 302 // pragma(msg, toStringNow!id ~ " " ~ subres.stringof); | |
| 303 } else | |
| 304 alias TypeTuple!() subres; | |
| 305 alias TypeTuple!(subres, findSymbolsImpl!(prefix, C, id + 1, pred).result) result; | |
| 306 } | |
| 307 else | |
| 308 { | |
| 309 alias TypeTuple!() result; | |
| 310 } | |
| 311 } | |
| 312 | |
| 313 template findSymbols(string prefix, C, alias pred) | |
| 314 { | |
| 315 alias findSymbolsImpl!(prefix, C, 0, pred).result findSymbols; | |
| 316 } | |
| 317 | |
| 284 | 318 string __toString(long v) |
| 319 { | |
| 320 if (v == 0) | |
| 321 return "0"; | |
| 322 | |
| 323 string ret; | |
| 324 | |
| 325 bool neg; | |
| 326 if (v < 0) | |
| 327 { | |
| 328 neg = true; | |
| 329 v = -v; | |
| 330 } | |
| 331 | |
| 332 while (v != 0) | |
| 333 { | |
| 334 ret = cast(char)(v % 10 + '0') ~ ret; | |
| 335 v = cast(long)(v / 10); | |
| 336 } | |
| 337 | |
| 338 if (neg) | |
| 339 ret = "-" ~ ret; | |
| 340 | |
| 341 return ret; | |
| 342 } | |
| 343 | |
| 288 | 344 string convertSignalArguments(Args...)() |
| 345 { | |
| 346 // void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) }; | |
| 347 | |
| 348 string res = "void*[" ~ __toString(Args.length+1) ~ "] _a = [null"; | |
| 349 foreach(i, _; Args) | |
| 350 res ~= ", " ~ "cast(void*) &" ~ convertSignalArgument!(Args[i])("_t" ~ __toString(i)); | |
| 351 res ~= "];\n"; | |
| 352 return res; | |
| 353 } | |
| 354 | |
| 355 public string SignalEmitter(A...)(SignalType signalType, string name, string[] defVals, int localIndex) | |
| 284 | 356 { |
| 357 string fullArgs, args; | |
| 288 | 358 int defValsLength = defVals.length; |
| 359 string argsConversion = ""; | |
| 360 string argsPtr = "null"; | |
| 284 | 361 static if (A.length) |
| 362 { | |
| 288 | 363 while(A.length != defVals.length) |
| 364 defVals = "" ~ defVals; | |
| 365 | |
| 366 fullArgs = A[0].stringof ~ " _t0"; | |
| 367 if (defVals[0].length) | |
| 368 fullArgs ~= " = " ~ defVals[0]; | |
| 369 args = "_t0"; | |
| 284 | 370 foreach(i, _; A[1..$]) |
| 371 { | |
| 288 | 372 fullArgs ~= ", " ~ A[i+1].stringof ~ " _t" ~ __toString(i+1); |
| 373 if (defVals[i+1].length) | |
| 374 fullArgs ~= " = " ~ defVals[i+1]; | |
| 375 args ~= ", _t" ~ __toString(i+1); | |
| 284 | 376 } |
| 288 | 377 // build up conversion of signal args from D to C++ |
| 378 argsPtr = "_a.ptr"; | |
| 379 argsConversion = convertSignalArguments!(A)(); | |
| 284 | 380 } |
| 381 string attribute; | |
| 382 string sigName = name; | |
| 383 if (signalType == SignalType.BindQtSignal) | |
| 384 name ~= "_emit"; | |
| 385 else | |
| 386 attribute = "protected "; | |
| 288 | 387 |
| 388 string indexArgs = __toString(localIndex); | |
| 389 if(defValsLength > 0) | |
| 390 indexArgs ~= ", " ~ __toString(localIndex+defValsLength); | |
| 391 string str = attribute ~ "final void " ~ name ~ "(" ~ fullArgs ~ ") {\n" ~ argsConversion ~ "\n" | |
| 392 ~ " QMetaObject.activate(this, typeof(this).staticMetaObject, " ~ indexArgs ~ ", " ~ argsPtr ~ ");\n" | |
| 393 ~ "}\n"; // ~ | |
| 284 | 394 return str; |
| 395 } | |
| 278 | 396 /** ---------------- */ |
| 397 | |
| 398 | |
| 288 | 399 const string signalPrefix = "__signal"; |
| 400 const string slotPrefix = "__slot"; | |
| 284 | 401 |
| 402 enum SignalType | |
| 1 | 403 { |
| 284 | 404 BindQtSignal, |
| 288 | 405 NewSignal, |
| 406 NewSlot | |
| 284 | 407 } |
| 408 | |
| 288 | 409 template BindQtSignal(string fullName) |
| 1 | 410 { |
| 288 | 411 mixin MetaMethodImpl!(signalPrefix, 0, fullName, SignalType.BindQtSignal); |
| 1 | 412 } |
| 413 | |
| 288 | 414 template Signal(string fullName) |
| 1 | 415 { |
| 288 | 416 mixin MetaMethodImpl!(signalPrefix, 0, fullName, SignalType.NewSignal); |
| 417 } | |
| 1 | 418 |
| 288 | 419 template Slot(string fullName) |
| 420 { | |
| 421 mixin MetaMethodImpl!(slotPrefix, 0, fullName, SignalType.NewSlot); | |
| 1 | 422 } |
| 423 | |
| 288 | 424 template SignalImpl(int index, string fullName, SignalType signalType) |
| 1 | 425 { |
| 288 | 426 static if (is(typeof(mixin(typeof(this).stringof ~ "." ~ signalPrefix ~ ToString!(index))))) |
| 427 mixin SignalImpl!(index + 1, fullName, signalType); | |
| 428 else | |
| 1 | 429 { |
| 288 | 430 // pragma(msg, "alias void delegate" ~ getFunc!_Tuple(fullName) ~ " Dg;"); |
| 431 mixin("alias void delegate" ~ getFunc!_Tuple(fullName) ~ " Dg;"); | |
| 432 alias ParameterTypeTuple!(Dg) ArgTypes; | |
| 433 enum args = getFunc!_Args(fullName); | |
| 434 enum defVals = defaultValues(args); | |
| 435 enum defValsLength = defaultValuesLength(defVals); | |
| 1 | 436 |
| 288 | 437 // pragma (msg, SignalEmitter!(ArgTypes)(SignalType.NewSignal, getFunc!_Name(fullName), defVals, index)); |
| 438 mixin InsertMetaSignal!(fullName, index, defValsLength, ArgTypes); | |
| 439 // pragma (msg, ctfe_meta_signal!(ArgTypes)(fullName, index, defValsLength)); | |
| 440 } | |
| 441 } | |
| 442 template MetaMethodImpl(string metaPrefix, int index, string fullName, SignalType signalType) | |
| 443 { | |
| 444 static if (is(typeof(mixin(typeof(this).stringof ~ "." ~ metaPrefix ~ toStringNow!(index))))) | |
| 445 { | |
| 446 mixin MetaMethodImpl!(metaPrefix, index + 1, fullName, signalType); | |
| 447 } | |
| 448 else | |
| 1 | 449 { |
| 288 | 450 mixin("alias void delegate" ~ getFunc!_Tuple(fullName) ~ " Dg;"); |
| 451 alias ParameterTypeTuple!(Dg) ArgTypes; | |
| 452 enum args = getFunc!_Args(fullName); | |
| 453 enum defVals = defaultValues(args); | |
| 454 enum defValsLength = defaultValuesLength(defVals); | |
| 455 | |
| 456 static if (metaPrefix == signalPrefix) | |
| 457 { | |
| 458 // calculating local index of the signal | |
| 459 static if (typeof(this).stringof == "QObject") | |
| 460 enum localIndex = index; | |
| 461 else | |
| 462 mixin ("enum localIndex = index - 1 - lastSignalIndex_" ~ (typeof(super)).stringof ~ ";"); | |
| 463 | |
| 464 static if (signalType == SignalType.NewSignal) | |
| 465 { | |
| 293 | 466 // pragma (msg, SignalEmitter!(ArgTypes)(SignalType.NewSignal, getFunc!_Name(fullName), defVals, localIndex)); |
| 288 | 467 mixin (SignalEmitter!(ArgTypes)(SignalType.NewSignal, getFunc!_Name(fullName), defVals, localIndex)); |
| 468 } | |
| 469 } | |
| 289 | 470 mixin InsertMetaMethod!(fullName, metaPrefix, index, defValsLength, ArgTypes); |
| 288 | 471 // pragma (msg, ctfe_meta_signal!(ArgTypes)(fullName, index, defValsLength)); |
| 472 } | |
| 473 } | |
| 289 | 474 template InsertMetaMethod(string fullName, string metaPrefix, int index, int defValsCount, ArgTypes...) |
| 288 | 475 { |
| 289 | 476 static if(defValsCount >= 0) |
| 477 mixin("public alias TypeTuple!(\"" ~ getFunc!_Name(fullName) ~ "\", index, typeof(this), ArgTypes) " ~ metaPrefix ~ toStringNow!(index) ~ ";"); | |
| 288 | 478 static if(defValsCount > 0) |
| 289 | 479 mixin InsertMetaMethod!(fullName, metaPrefix, index+1, defValsCount-1, ArgTypes[0..$-1]); |
| 288 | 480 } |
| 1 | 481 |
| 482 | |
| 288 | 483 string signature_impl(T...)(string name) |
| 484 { | |
| 485 string res = name ~ "("; | |
| 486 foreach(i, _; T) | |
| 487 { | |
| 488 if(i > 0) | |
| 489 res ~= ","; | |
| 490 res ~= T[i].stringof; | |
| 491 } | |
| 492 res ~= ")"; | |
| 493 return res; | |
| 494 } | |
| 1 | 495 |
| 288 | 496 template signature(string name, T...) |
| 497 { | |
| 498 enum signature = signature_impl!(T)(name); | |
| 1 | 499 } |
| 288 | 500 |
| 501 template lastSignalIndex(T) | |
| 502 { | |
| 503 static if (T.stringof == "QObject") | |
| 504 enum lastSignalIndex = lastSignalIndexImpl!(T, 0); | |
| 505 else | |
| 506 mixin ("enum lastSignalIndex = lastSignalIndexImpl!(T, " ~ "T.lastSignalIndex_" ~ (BaseClassesTuple!(T)[0]).stringof ~ ");"); | |
| 507 } | |
| 508 | |
| 509 template lastSignalIndexImpl(T, int index) | |
| 510 { | |
| 511 static if (is(typeof(mixin("T." ~ signalPrefix ~ toStringNow!(index))))) | |
| 512 enum lastSignalIndexImpl = lastSignalIndexImpl!(T, index + 1); | |
| 513 else | |
| 514 enum lastSignalIndexImpl = index - 1; | |
| 515 } |