Mercurial > projects > qtd
annotate qt/d2/qt/Signal.d @ 288:f9559a957be9 signals
new signals and slots implementation
| author | eldar |
|---|---|
| date | Sun, 08 Nov 2009 19:28:01 +0000 |
| parents | 1f6923c8cba0 |
| children | c9d1aac290e9 |
| 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 // need this to mark static metamethods-info whether it's generated by presence of default args | |
| 124 enum DefaultArgs | |
| 125 { | |
| 126 None, Start, Continue | |
| 127 } | |
| 128 | |
| 129 // templates for extracting data from static meta-information of signals, slots or properties | |
| 130 // public alias TypeTuple!("name", index, OwnerClass, DefaultArgs.Start, ArgTypes) __signal | |
| 131 template MetaEntryName(source...) | |
| 132 { | |
| 133 enum MetaEntryName = source[0]; // name of the metaentry is the first element | |
| 134 } | |
| 135 | |
| 136 template MetaEntryOwner(source...) | |
| 137 { | |
| 138 alias TupleWrapper!(source[2]).at[0] MetaEntryOwner; // class that owns the property is the third | |
| 139 // Compiler #BUG 3092 - evaluates MetaEntryOwner as a Tuple with one element | |
| 140 } | |
| 141 | |
| 142 template MetaEntryArgs(source...) | |
| 143 { | |
| 144 alias source[4 .. $] MetaEntryArgs; // arguments-tuple starts from the fourth position | |
| 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 |
|
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
|
147 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
|
148 |
|
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 isDg(Dg) |
| 278 | 150 { |
|
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
|
151 enum isDg = is(Dg == delegate); |
| 278 | 152 } |
| 153 | |
|
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
|
154 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
|
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 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
|
157 } |
|
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
|
158 |
|
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
|
159 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
|
160 { |
|
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
|
161 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
|
162 } |
| 278 | 163 |
| 164 string joinArgs(A...)() | |
| 165 { | |
| 166 string res = ""; | |
| 167 static if(A.length) | |
| 168 { | |
| 169 res = A[0].stringof; | |
| 170 foreach(k; A[1..$]) | |
| 171 res ~= "," ~ k.stringof; | |
| 172 } | |
| 173 return res; | |
| 174 } | |
| 175 | |
|
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
|
176 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
|
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 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
|
179 } |
|
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 |
|
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 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
|
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 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
|
184 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
|
185 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
|
186 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
|
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 SignalPred(T1, T2) |
| 278 | 190 { |
|
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
|
191 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
|
192 } |
|
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 |
|
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 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
|
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 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
|
197 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
|
198 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
|
199 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
|
200 } |
|
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 |
|
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 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
|
203 { |
|
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 static if (i < Needle.at.length) |
| 278 | 205 { |
|
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
|
206 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
|
207 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
|
208 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
|
209 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
|
210 } |
|
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
|
211 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
|
212 { |
|
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 enum value = true; |
| 278 | 214 } |
| 215 } | |
| 216 | |
|
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
|
217 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
|
218 { |
|
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 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
|
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 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
|
222 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
|
223 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
|
224 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
|
225 } |
|
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 |
|
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 template SigBySignPred(string name, SigArgs...) |
| 278 | 229 { |
|
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
|
230 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
|
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 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
|
233 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
|
234 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
|
235 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
|
236 } |
|
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
|
237 } |
|
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
|
238 |
| 288 | 239 template ByOwner(Owner) |
| 240 { | |
| 241 template ByOwner(source...) | |
| 242 { | |
| 243 enum ByOwner = is(MetaEntryOwner!source == Owner); | |
| 244 } | |
| 245 } | |
| 246 | |
|
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
|
247 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
|
248 { |
|
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
|
249 const string staticSymbolName = prefix ~ ToString!(id); |
| 278 | 250 } |
| 251 | |
| 252 template signatureString(string name, A...) | |
| 253 { | |
| 254 const string signatureString = name ~ "(" ~ joinArgs!(A) ~ ")"; | |
| 255 } | |
| 256 | |
| 288 | 257 // 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
|
258 template findSymbolImpl(string prefix, C, int id, alias pred) |
| 278 | 259 { |
|
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
|
260 static if ( is(typeof(mixin("C." ~ staticSymbolName!(prefix, id)))) ) |
| 278 | 261 { |
|
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
|
262 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
|
263 static if (pred!current) |
| 278 | 264 alias current result; |
| 265 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
|
266 alias findSymbolImpl!(prefix, C, id + 1, pred).result result; |
| 278 | 267 } |
| 268 else | |
| 269 { | |
|
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
|
270 alias void result; |
| 278 | 271 } |
| 272 } | |
| 273 | |
|
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
|
274 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
|
275 { |
|
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 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
|
277 } |
|
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 template findSignal(C, string name, Receiver, SigArgs...) |
| 278 | 280 { |
|
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
|
281 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
|
282 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
|
283 { |
|
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 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
|
285 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
|
286 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
|
287 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
|
288 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
|
289 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
|
290 } |
|
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 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
|
292 { |
|
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
|
293 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
|
294 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
|
295 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
|
296 } |
| 278 | 297 } |
| 298 | |
| 288 | 299 // recursive search in the static meta-information |
| 300 template findSymbolsImpl(string prefix, C, int id, alias pred) | |
| 301 { | |
| 302 static if ( is(typeof(mixin("C." ~ staticSymbolName!(prefix, id)))) ) | |
| 303 { | |
| 304 mixin ("alias C." ~ staticSymbolName!(prefix, id) ~ " current;"); | |
| 305 static if (pred!current) { | |
| 306 alias TupleWrapper!current subres; | |
| 307 // pragma(msg, toStringNow!id ~ " " ~ subres.stringof); | |
| 308 } else | |
| 309 alias TypeTuple!() subres; | |
| 310 alias TypeTuple!(subres, findSymbolsImpl!(prefix, C, id + 1, pred).result) result; | |
| 311 } | |
| 312 else | |
| 313 { | |
| 314 alias TypeTuple!() result; | |
| 315 } | |
| 316 } | |
| 317 | |
| 318 template findSymbols(string prefix, C, alias pred) | |
| 319 { | |
| 320 alias findSymbolsImpl!(prefix, C, 0, pred).result findSymbols; | |
| 321 } | |
| 322 | |
| 284 | 323 string __toString(long v) |
| 324 { | |
| 325 if (v == 0) | |
| 326 return "0"; | |
| 327 | |
| 328 string ret; | |
| 329 | |
| 330 bool neg; | |
| 331 if (v < 0) | |
| 332 { | |
| 333 neg = true; | |
| 334 v = -v; | |
| 335 } | |
| 336 | |
| 337 while (v != 0) | |
| 338 { | |
| 339 ret = cast(char)(v % 10 + '0') ~ ret; | |
| 340 v = cast(long)(v / 10); | |
| 341 } | |
| 342 | |
| 343 if (neg) | |
| 344 ret = "-" ~ ret; | |
| 345 | |
| 346 return ret; | |
| 347 } | |
| 348 | |
| 288 | 349 string convertSignalArguments(Args...)() |
| 350 { | |
| 351 // void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) }; | |
| 352 | |
| 353 string res = "void*[" ~ __toString(Args.length+1) ~ "] _a = [null"; | |
| 354 foreach(i, _; Args) | |
| 355 res ~= ", " ~ "cast(void*) &" ~ convertSignalArgument!(Args[i])("_t" ~ __toString(i)); | |
| 356 res ~= "];\n"; | |
| 357 return res; | |
| 358 } | |
| 359 | |
| 360 public string SignalEmitter(A...)(SignalType signalType, string name, string[] defVals, int localIndex) | |
| 284 | 361 { |
| 362 string fullArgs, args; | |
| 288 | 363 int defValsLength = defVals.length; |
| 364 string argsConversion = ""; | |
| 365 string argsPtr = "null"; | |
| 284 | 366 static if (A.length) |
| 367 { | |
| 288 | 368 while(A.length != defVals.length) |
| 369 defVals = "" ~ defVals; | |
| 370 | |
| 371 fullArgs = A[0].stringof ~ " _t0"; | |
| 372 if (defVals[0].length) | |
| 373 fullArgs ~= " = " ~ defVals[0]; | |
| 374 args = "_t0"; | |
| 284 | 375 foreach(i, _; A[1..$]) |
| 376 { | |
| 288 | 377 fullArgs ~= ", " ~ A[i+1].stringof ~ " _t" ~ __toString(i+1); |
| 378 if (defVals[i+1].length) | |
| 379 fullArgs ~= " = " ~ defVals[i+1]; | |
| 380 args ~= ", _t" ~ __toString(i+1); | |
| 284 | 381 } |
| 288 | 382 // build up conversion of signal args from D to C++ |
| 383 argsPtr = "_a.ptr"; | |
| 384 argsConversion = convertSignalArguments!(A)(); | |
| 284 | 385 } |
| 386 string attribute; | |
| 387 string sigName = name; | |
| 388 if (signalType == SignalType.BindQtSignal) | |
| 389 name ~= "_emit"; | |
| 390 else | |
| 391 attribute = "protected "; | |
| 288 | 392 |
| 393 string indexArgs = __toString(localIndex); | |
| 394 if(defValsLength > 0) | |
| 395 indexArgs ~= ", " ~ __toString(localIndex+defValsLength); | |
| 396 string str = attribute ~ "final void " ~ name ~ "(" ~ fullArgs ~ ") {\n" ~ argsConversion ~ "\n" | |
| 397 ~ " QMetaObject.activate(this, typeof(this).staticMetaObject, " ~ indexArgs ~ ", " ~ argsPtr ~ ");\n" | |
| 398 ~ "}\n"; // ~ | |
| 284 | 399 return str; |
| 400 } | |
| 278 | 401 /** ---------------- */ |
| 402 | |
| 403 | |
| 288 | 404 const string signalPrefix = "__signal"; |
| 405 const string slotPrefix = "__slot"; | |
| 284 | 406 |
| 407 enum SignalType | |
| 1 | 408 { |
| 284 | 409 BindQtSignal, |
| 288 | 410 NewSignal, |
| 411 NewSlot | |
| 284 | 412 } |
| 413 | |
| 288 | 414 template BindQtSignal(string fullName) |
| 1 | 415 { |
| 288 | 416 mixin MetaMethodImpl!(signalPrefix, 0, fullName, SignalType.BindQtSignal); |
| 1 | 417 } |
| 418 | |
| 288 | 419 template Signal(string fullName) |
| 1 | 420 { |
| 288 | 421 mixin MetaMethodImpl!(signalPrefix, 0, fullName, SignalType.NewSignal); |
| 422 } | |
| 1 | 423 |
| 288 | 424 template Slot(string fullName) |
| 425 { | |
| 426 mixin MetaMethodImpl!(slotPrefix, 0, fullName, SignalType.NewSlot); | |
| 1 | 427 } |
| 428 | |
| 288 | 429 template SignalImpl(int index, string fullName, SignalType signalType) |
| 1 | 430 { |
| 288 | 431 static if (is(typeof(mixin(typeof(this).stringof ~ "." ~ signalPrefix ~ ToString!(index))))) |
| 432 mixin SignalImpl!(index + 1, fullName, signalType); | |
| 433 else | |
| 1 | 434 { |
| 288 | 435 // pragma(msg, "alias void delegate" ~ getFunc!_Tuple(fullName) ~ " Dg;"); |
| 436 mixin("alias void delegate" ~ getFunc!_Tuple(fullName) ~ " Dg;"); | |
| 437 alias ParameterTypeTuple!(Dg) ArgTypes; | |
| 438 enum args = getFunc!_Args(fullName); | |
| 439 enum defVals = defaultValues(args); | |
| 440 enum defValsLength = defaultValuesLength(defVals); | |
| 1 | 441 |
| 288 | 442 // pragma (msg, SignalEmitter!(ArgTypes)(SignalType.NewSignal, getFunc!_Name(fullName), defVals, index)); |
| 443 mixin InsertMetaSignal!(fullName, index, defValsLength, ArgTypes); | |
| 444 // pragma (msg, ctfe_meta_signal!(ArgTypes)(fullName, index, defValsLength)); | |
| 445 } | |
| 446 } | |
| 447 template MetaMethodImpl(string metaPrefix, int index, string fullName, SignalType signalType) | |
| 448 { | |
| 449 static if (is(typeof(mixin(typeof(this).stringof ~ "." ~ metaPrefix ~ toStringNow!(index))))) | |
| 450 { | |
| 451 mixin MetaMethodImpl!(metaPrefix, index + 1, fullName, signalType); | |
| 452 } | |
| 453 else | |
| 1 | 454 { |
| 288 | 455 mixin("alias void delegate" ~ getFunc!_Tuple(fullName) ~ " Dg;"); |
| 456 alias ParameterTypeTuple!(Dg) ArgTypes; | |
| 457 enum args = getFunc!_Args(fullName); | |
| 458 enum defVals = defaultValues(args); | |
| 459 enum defValsLength = defaultValuesLength(defVals); | |
| 460 | |
| 461 static if (metaPrefix == signalPrefix) | |
| 462 { | |
| 463 // calculating local index of the signal | |
| 464 static if (typeof(this).stringof == "QObject") | |
| 465 enum localIndex = index; | |
| 466 else | |
| 467 mixin ("enum localIndex = index - 1 - lastSignalIndex_" ~ (typeof(super)).stringof ~ ";"); | |
| 468 | |
| 469 static if (signalType == SignalType.NewSignal) | |
| 470 { | |
| 471 pragma (msg, SignalEmitter!(ArgTypes)(SignalType.NewSignal, getFunc!_Name(fullName), defVals, localIndex)); | |
| 472 mixin (SignalEmitter!(ArgTypes)(SignalType.NewSignal, getFunc!_Name(fullName), defVals, localIndex)); | |
| 473 } | |
| 474 } | |
| 475 mixin InsertMetaMethod!(fullName, metaPrefix, index, defValsLength, DefaultArgs.Start, ArgTypes); | |
| 476 // pragma (msg, ctfe_meta_signal!(ArgTypes)(fullName, index, defValsLength)); | |
| 477 } | |
| 478 } | |
| 479 template InsertMetaMethod(string fullName, string metaPrefix, int index, int defValsCount, DefaultArgs defArgsInitFlag, ArgTypes...) | |
| 480 { | |
| 481 // this identifies if metamethod is was generated by the presence of default args or not | |
| 482 static if(defValsCount > 0) | |
| 483 { | |
| 484 static if (defArgsInitFlag == DefaultArgs.Start) | |
| 485 enum defValsFlag = DefaultArgs.Start; | |
| 486 else | |
| 487 enum defValsFlag = DefaultArgs.Continue; | |
| 1 | 488 } |
| 288 | 489 else |
| 490 { | |
| 491 static if (defArgsInitFlag == DefaultArgs.Start) | |
| 492 enum defValsFlag = DefaultArgs.None; | |
| 493 else | |
| 494 enum defValsFlag = DefaultArgs.Continue; | |
| 495 } | |
| 496 static if(defValsCount >= 0) | |
| 497 mixin("public alias TypeTuple!(\"" ~ getFunc!_Name(fullName) ~ "\", index, typeof(this), defValsFlag, ArgTypes) " ~ metaPrefix ~ toStringNow!(index) ~ ";"); | |
| 498 static if(defValsCount > 0) | |
| 499 mixin InsertMetaMethod!(fullName, metaPrefix, index+1, defValsCount-1, DefaultArgs.Continue, ArgTypes[0..$-1]); | |
| 500 } | |
| 1 | 501 |
| 502 | |
| 288 | 503 string signature_impl(T...)(string name) |
| 504 { | |
| 505 string res = name ~ "("; | |
| 506 foreach(i, _; T) | |
| 507 { | |
| 508 if(i > 0) | |
| 509 res ~= ","; | |
| 510 res ~= T[i].stringof; | |
| 511 } | |
| 512 res ~= ")"; | |
| 513 return res; | |
| 514 } | |
| 1 | 515 |
| 288 | 516 template signature(string name, T...) |
| 517 { | |
| 518 enum signature = signature_impl!(T)(name); | |
| 1 | 519 } |
| 288 | 520 |
| 521 template lastSignalIndex(T) | |
| 522 { | |
| 523 static if (T.stringof == "QObject") | |
| 524 enum lastSignalIndex = lastSignalIndexImpl!(T, 0); | |
| 525 else | |
| 526 mixin ("enum lastSignalIndex = lastSignalIndexImpl!(T, " ~ "T.lastSignalIndex_" ~ (BaseClassesTuple!(T)[0]).stringof ~ ");"); | |
| 527 } | |
| 528 | |
| 529 template lastSignalIndexImpl(T, int index) | |
| 530 { | |
| 531 static if (is(typeof(mixin("T." ~ signalPrefix ~ toStringNow!(index))))) | |
| 532 enum lastSignalIndexImpl = lastSignalIndexImpl!(T, index + 1); | |
| 533 else | |
| 534 enum lastSignalIndexImpl = index - 1; | |
| 535 } |