ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/callback.h
(Generate patch)

Comparing rxvt-unicode/src/callback.h (file contents):
Revision 1.2 by pcg, Sat Jan 17 01:20:01 2004 UTC vs.
Revision 1.3 by pcg, Fri Feb 13 12:16:21 2004 UTC

… …
30template<class R> 30template<class R>
31class callback0 { 31class callback0 {
32 struct object { }; 32 struct object { };
33 33
34 void *obj; 34 void *obj;
35 R (object::*meth)(); 35 R (object::*meth) ();
36 36
37 /* a proxy is a kind of recipe on how to call a specific class method */ 37 /* a proxy is a kind of recipe on how to call a specific class method */
38 struct proxy_base { 38 struct proxy_base {
39 virtual R call (void *obj, R (object::*meth)()) = 0; 39 virtual R call (void *obj, R (object::*meth) ()) = 0;
40 }; 40 };
41 template<class O1, class O2> 41 template<class O1, class O2>
42 struct proxy : proxy_base { 42 struct proxy : proxy_base {
43 virtual R call (void *obj, R (object::*meth)()) 43 virtual R call (void *obj, R (object::*meth) ())
44 { 44 {
45 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)()>(meth))) 45 ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) ()> (meth)))
46 (); 46 ();
47 } 47 }
48 }; 48 };
49 49
50 proxy_base *prxy; 50 proxy_base *prxy;
51 51
52public: 52public:
53 template<class O1, class O2> 53 template<class O1, class O2>
54 callback0 (O1 *object, R (O2::*method)()) 54 callback0 (O1 *object, R (O2::*method) ())
55 { 55 {
56 static proxy<O1,O2> p; 56 static proxy<O1,O2> p;
57 obj = reinterpret_cast<void *>(object); 57 obj = reinterpret_cast<void *> (object);
58 meth = reinterpret_cast<R (object::*)()>(method); 58 meth = reinterpret_cast<R (object::*) ()> (method);
59 prxy = &p; 59 prxy = &p;
60 } 60 }
61 61
62 R call() const 62 R call () const
63 { 63 {
64 return prxy->call (obj, meth); 64 return prxy->call (obj, meth);
65 } 65 }
66 66
67 R operator ()() const 67 R operator () () const
68 { 68 {
69 return call (); 69 return call ();
70 } 70 }
71}; 71};
72 72
73template<class R, class A1> 73template<class R, class A1>
74class callback1 { 74class callback1 {
75 struct object { }; 75 struct object { };
76 76
77 void *obj; 77 void *obj;
78 R (object::*meth)(A1); 78 R (object::*meth) (A1);
79 79
80 /* a proxy is a kind of recipe on how to call a specific class method */ 80 /* a proxy is a kind of recipe on how to call a specific class method */
81 struct proxy_base { 81 struct proxy_base {
82 virtual R call (void *obj, R (object::*meth)(A1), A1 a1) = 0; 82 virtual R call (void *obj, R (object::*meth) (A1), A1 a1) = 0;
83 }; 83 };
84 template<class O1, class O2> 84 template<class O1, class O2>
85 struct proxy : proxy_base { 85 struct proxy : proxy_base {
86 virtual R call (void *obj, R (object::*meth)(A1), A1 a1) 86 virtual R call (void *obj, R (object::*meth) (A1), A1 a1)
87 { 87 {
88 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1)>(meth))) 88 ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1)> (meth)))
89 (a1); 89 (a1);
90 } 90 }
91 }; 91 };
92 92
93 proxy_base *prxy; 93 proxy_base *prxy;
94 94
95public: 95public:
96 template<class O1, class O2> 96 template<class O1, class O2>
97 callback1 (O1 *object, R (O2::*method)(A1)) 97 callback1 (O1 *object, R (O2::*method) (A1))
98 { 98 {
99 static proxy<O1,O2> p; 99 static proxy<O1,O2> p;
100 obj = reinterpret_cast<void *>(object); 100 obj = reinterpret_cast<void *> (object);
101 meth = reinterpret_cast<R (object::*)(A1)>(method); 101 meth = reinterpret_cast<R (object::*) (A1)> (method);
102 prxy = &p; 102 prxy = &p;
103 } 103 }
104 104
105 R call(A1 a1) const 105 R call (A1 a1) const
106 { 106 {
107 return prxy->call (obj, meth, a1); 107 return prxy->call (obj, meth, a1);
108 } 108 }
109 109
110 R operator ()(A1 a1) const 110 R operator () (A1 a1) const
111 { 111 {
112 return call (a1); 112 return call (a1);
113 } 113 }
114}; 114};
115 115
116template<class R, class A1, class A2> 116template<class R, class A1, class A2>
117class callback2 { 117class callback2 {
118 struct object { }; 118 struct object { };
119 119
120 void *obj; 120 void *obj;
121 R (object::*meth)(A1, A2); 121 R (object::*meth) (A1, A2);
122 122
123 /* a proxy is a kind of recipe on how to call a specific class method */ 123 /* a proxy is a kind of recipe on how to call a specific class method */
124 struct proxy_base { 124 struct proxy_base {
125 virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) = 0; 125 virtual R call (void *obj, R (object::*meth) (A1, A2), A1 a1, A2 a2) = 0;
126 }; 126 };
127 template<class O1, class O2> 127 template<class O1, class O2>
128 struct proxy : proxy_base { 128 struct proxy : proxy_base {
129 virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) 129 virtual R call (void *obj, R (object::*meth) (A1, A2), A1 a1, A2 a2)
130 { 130 {
131 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2)>(meth))) 131 ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2)> (meth)))
132 (a1, a2); 132 (a1, a2);
133 } 133 }
134 }; 134 };
135 135
136 proxy_base *prxy; 136 proxy_base *prxy;
137 137
138public: 138public:
139 template<class O1, class O2> 139 template<class O1, class O2>
140 callback2 (O1 *object, R (O2::*method)(A1, A2)) 140 callback2 (O1 *object, R (O2::*method) (A1, A2))
141 { 141 {
142 static proxy<O1,O2> p; 142 static proxy<O1,O2> p;
143 obj = reinterpret_cast<void *>(object); 143 obj = reinterpret_cast<void *> (object);
144 meth = reinterpret_cast<R (object::*)(A1, A2)>(method); 144 meth = reinterpret_cast<R (object::*) (A1, A2)> (method);
145 prxy = &p; 145 prxy = &p;
146 } 146 }
147 147
148 R call(A1 a1, A2 a2) const 148 R call (A1 a1, A2 a2) const
149 { 149 {
150 return prxy->call (obj, meth, a1, a2); 150 return prxy->call (obj, meth, a1, a2);
151 } 151 }
152 152
153 R operator ()(A1 a1, A2 a2) const 153 R operator () (A1 a1, A2 a2) const
154 { 154 {
155 return call (a1, a2); 155 return call (a1, a2);
156 } 156 }
157}; 157};
158 158
159template<class R, class A1, class A2, class A3> 159template<class R, class A1, class A2, class A3>
160class callback3 { 160class callback3 {
161 struct object { }; 161 struct object { };
162 162
163 void *obj; 163 void *obj;
164 R (object::*meth)(A1, A2, A3); 164 R (object::*meth) (A1, A2, A3);
165 165
166 /* a proxy is a kind of recipe on how to call a specific class method */ 166 /* a proxy is a kind of recipe on how to call a specific class method */
167 struct proxy_base { 167 struct proxy_base {
168 virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) = 0; 168 virtual R call (void *obj, R (object::*meth) (A1, A2, A3), A1 a1, A2 a2, A3 a3) = 0;
169 }; 169 };
170 template<class O1, class O2> 170 template<class O1, class O2>
171 struct proxy : proxy_base { 171 struct proxy : proxy_base {
172 virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) 172 virtual R call (void *obj, R (object::*meth) (A1, A2, A3), A1 a1, A2 a2, A3 a3)
173 { 173 {
174 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3)>(meth))) 174 ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2, A3)> (meth)))
175 (a1, a2, a3); 175 (a1, a2, a3);
176 } 176 }
177 }; 177 };
178 178
179 proxy_base *prxy; 179 proxy_base *prxy;
180 180
181public: 181public:
182 template<class O1, class O2> 182 template<class O1, class O2>
183 callback3 (O1 *object, R (O2::*method)(A1, A2, A3)) 183 callback3 (O1 *object, R (O2::*method) (A1, A2, A3))
184 { 184 {
185 static proxy<O1,O2> p; 185 static proxy<O1,O2> p;
186 obj = reinterpret_cast<void *>(object); 186 obj = reinterpret_cast<void *> (object);
187 meth = reinterpret_cast<R (object::*)(A1, A2, A3)>(method); 187 meth = reinterpret_cast<R (object::*) (A1, A2, A3)> (method);
188 prxy = &p; 188 prxy = &p;
189 } 189 }
190 190
191 R call(A1 a1, A2 a2, A3 a3) const 191 R call (A1 a1, A2 a2, A3 a3) const
192 { 192 {
193 return prxy->call (obj, meth, a1, a2, a3); 193 return prxy->call (obj, meth, a1, a2, a3);
194 } 194 }
195 195
196 R operator ()(A1 a1, A2 a2, A3 a3) const 196 R operator () (A1 a1, A2 a2, A3 a3) const
197 { 197 {
198 return call (a1, a2, a3); 198 return call (a1, a2, a3);
199 } 199 }
200}; 200};
201 201
202template<class R, class A1, class A2, class A3, class A4> 202template<class R, class A1, class A2, class A3, class A4>
203class callback4 { 203class callback4 {
204 struct object { }; 204 struct object { };
205 205
206 void *obj; 206 void *obj;
207 R (object::*meth)(A1, A2, A3, A4); 207 R (object::*meth) (A1, A2, A3, A4);
208 208
209 /* a proxy is a kind of recipe on how to call a specific class method */ 209 /* a proxy is a kind of recipe on how to call a specific class method */
210 struct proxy_base { 210 struct proxy_base {
211 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) = 0; 211 virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) = 0;
212 }; 212 };
213 template<class O1, class O2> 213 template<class O1, class O2>
214 struct proxy : proxy_base { 214 struct proxy : proxy_base {
215 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) 215 virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4)
216 { 216 {
217 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4)>(meth))) 217 ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2, A3, A4)> (meth)))
218 (a1, a2, a3, a4); 218 (a1, a2, a3, a4);
219 } 219 }
220 }; 220 };
221 221
222 proxy_base *prxy; 222 proxy_base *prxy;
223 223
224public: 224public:
225 template<class O1, class O2> 225 template<class O1, class O2>
226 callback4 (O1 *object, R (O2::*method)(A1, A2, A3, A4)) 226 callback4 (O1 *object, R (O2::*method) (A1, A2, A3, A4))
227 { 227 {
228 static proxy<O1,O2> p; 228 static proxy<O1,O2> p;
229 obj = reinterpret_cast<void *>(object); 229 obj = reinterpret_cast<void *> (object);
230 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4)>(method); 230 meth = reinterpret_cast<R (object::*) (A1, A2, A3, A4)> (method);
231 prxy = &p; 231 prxy = &p;
232 } 232 }
233 233
234 R call(A1 a1, A2 a2, A3 a3, A4 a4) const 234 R call (A1 a1, A2 a2, A3 a3, A4 a4) const
235 { 235 {
236 return prxy->call (obj, meth, a1, a2, a3, a4); 236 return prxy->call (obj, meth, a1, a2, a3, a4);
237 } 237 }
238 238
239 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const 239 R operator () (A1 a1, A2 a2, A3 a3, A4 a4) const
240 { 240 {
241 return call (a1, a2, a3, a4); 241 return call (a1, a2, a3, a4);
242 } 242 }
243}; 243};
244 244
245template<class R, class A1, class A2, class A3, class A4, class A5> 245template<class R, class A1, class A2, class A3, class A4, class A5>
246class callback5 { 246class callback5 {
247 struct object { }; 247 struct object { };
248 248
249 void *obj; 249 void *obj;
250 R (object::*meth)(A1, A2, A3, A4, A5); 250 R (object::*meth) (A1, A2, A3, A4, A5);
251 251
252 /* a proxy is a kind of recipe on how to call a specific class method */ 252 /* a proxy is a kind of recipe on how to call a specific class method */
253 struct proxy_base { 253 struct proxy_base {
254 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) = 0; 254 virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) = 0;
255 }; 255 };
256 template<class O1, class O2> 256 template<class O1, class O2>
257 struct proxy : proxy_base { 257 struct proxy : proxy_base {
258 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) 258 virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
259 { 259 {
260 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5)>(meth))) 260 ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2, A3, A4, A5)> (meth)))
261 (a1, a2, a3, a4, a5); 261 (a1, a2, a3, a4, a5);
262 } 262 }
263 }; 263 };
264 264
265 proxy_base *prxy; 265 proxy_base *prxy;
266 266
267public: 267public:
268 template<class O1, class O2> 268 template<class O1, class O2>
269 callback5 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5)) 269 callback5 (O1 *object, R (O2::*method) (A1, A2, A3, A4, A5))
270 { 270 {
271 static proxy<O1,O2> p; 271 static proxy<O1,O2> p;
272 obj = reinterpret_cast<void *>(object); 272 obj = reinterpret_cast<void *> (object);
273 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5)>(method); 273 meth = reinterpret_cast<R (object::*) (A1, A2, A3, A4, A5)> (method);
274 prxy = &p; 274 prxy = &p;
275 } 275 }
276 276
277 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const 277 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
278 { 278 {
279 return prxy->call (obj, meth, a1, a2, a3, a4, a5); 279 return prxy->call (obj, meth, a1, a2, a3, a4, a5);
280 } 280 }
281 281
282 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const 282 R operator () (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
283 { 283 {
284 return call (a1, a2, a3, a4, a5); 284 return call (a1, a2, a3, a4, a5);
285 } 285 }
286}; 286};
287 287
288template<class R, class A1, class A2, class A3, class A4, class A5, class A6> 288template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
289class callback6 { 289class callback6 {
290 struct object { }; 290 struct object { };
291 291
292 void *obj; 292 void *obj;
293 R (object::*meth)(A1, A2, A3, A4, A5, A6); 293 R (object::*meth) (A1, A2, A3, A4, A5, A6);
294 294
295 /* a proxy is a kind of recipe on how to call a specific class method */ 295 /* a proxy is a kind of recipe on how to call a specific class method */
296 struct proxy_base { 296 struct proxy_base {
297 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) = 0; 297 virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) = 0;
298 }; 298 };
299 template<class O1, class O2> 299 template<class O1, class O2>
300 struct proxy : proxy_base { 300 struct proxy : proxy_base {
301 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) 301 virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
302 { 302 {
303 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6)>(meth))) 303 ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2, A3, A4, A5, A6)> (meth)))
304 (a1, a2, a3, a4, a5, a6); 304 (a1, a2, a3, a4, a5, a6);
305 } 305 }
306 }; 306 };
307 307
308 proxy_base *prxy; 308 proxy_base *prxy;
309 309
310public: 310public:
311 template<class O1, class O2> 311 template<class O1, class O2>
312 callback6 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6)) 312 callback6 (O1 *object, R (O2::*method) (A1, A2, A3, A4, A5, A6))
313 { 313 {
314 static proxy<O1,O2> p; 314 static proxy<O1,O2> p;
315 obj = reinterpret_cast<void *>(object); 315 obj = reinterpret_cast<void *> (object);
316 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6)>(method); 316 meth = reinterpret_cast<R (object::*) (A1, A2, A3, A4, A5, A6)> (method);
317 prxy = &p; 317 prxy = &p;
318 } 318 }
319 319
320 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const 320 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
321 { 321 {
322 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6); 322 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6);
323 } 323 }
324 324
325 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const 325 R operator () (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
326 { 326 {
327 return call (a1, a2, a3, a4, a5, a6); 327 return call (a1, a2, a3, a4, a5, a6);
328 } 328 }
329}; 329};
330 330
331template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7> 331template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
332class callback7 { 332class callback7 {
333 struct object { }; 333 struct object { };
334 334
335 void *obj; 335 void *obj;
336 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7); 336 R (object::*meth) (A1, A2, A3, A4, A5, A6, A7);
337 337
338 /* a proxy is a kind of recipe on how to call a specific class method */ 338 /* a proxy is a kind of recipe on how to call a specific class method */
339 struct proxy_base { 339 struct proxy_base {
340 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) = 0; 340 virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) = 0;
341 }; 341 };
342 template<class O1, class O2> 342 template<class O1, class O2>
343 struct proxy : proxy_base { 343 struct proxy : proxy_base {
344 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) 344 virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
345 { 345 {
346 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7)>(meth))) 346 ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2, A3, A4, A5, A6, A7)> (meth)))
347 (a1, a2, a3, a4, a5, a6, a7); 347 (a1, a2, a3, a4, a5, a6, a7);
348 } 348 }
349 }; 349 };
350 350
351 proxy_base *prxy; 351 proxy_base *prxy;
352 352
353public: 353public:
354 template<class O1, class O2> 354 template<class O1, class O2>
355 callback7 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7)) 355 callback7 (O1 *object, R (O2::*method) (A1, A2, A3, A4, A5, A6, A7))
356 { 356 {
357 static proxy<O1,O2> p; 357 static proxy<O1,O2> p;
358 obj = reinterpret_cast<void *>(object); 358 obj = reinterpret_cast<void *> (object);
359 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7)>(method); 359 meth = reinterpret_cast<R (object::*) (A1, A2, A3, A4, A5, A6, A7)> (method);
360 prxy = &p; 360 prxy = &p;
361 } 361 }
362 362
363 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const 363 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
364 { 364 {
365 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7); 365 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7);
366 } 366 }
367 367
368 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const 368 R operator () (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
369 { 369 {
370 return call (a1, a2, a3, a4, a5, a6, a7); 370 return call (a1, a2, a3, a4, a5, a6, a7);
371 } 371 }
372}; 372};
373 373

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines