Diff to HTML by rtfpessoa

Files changed (18) hide show
  1. Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_Bluetooth.cpp +0 -50
  2. Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_Capture.cpp +0 -50
  3. Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_IPNetwork.cpp +0 -50
  4. Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_MessageControl.cpp +0 -667
  5. Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_SecureShellServer.cpp +0 -50
  6. Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_SwitchBoard.cpp +0 -50
  7. Debug/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_Benchmark.cpp +753 -0
  8. Debug/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_BenchmarkPayload.cpp +1199 -0
  9. Debug/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_TestPlugin.cpp +323 -0
  10. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_Bluetooth.cpp +0 -55
  11. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_Capture.cpp +0 -55
  12. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_IPNetwork.cpp +0 -55
  13. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_MessageControl.cpp +0 -1088
  14. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_SecureShellServer.cpp +0 -55
  15. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_SwitchBoard.cpp +0 -55
  16. Release/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_Benchmark.cpp +1203 -0
  17. Release/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_BenchmarkPayload.cpp +1995 -0
  18. Release/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_TestPlugin.cpp +493 -0
Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_Bluetooth.cpp CHANGED
@@ -1,50 +0,0 @@
1
- //
2
- // generated automatically from "IBluetooth.h"
3
- //
4
- // implements COM-RPC proxy stubs for:
5
- //
6
-
7
- #include "Module.h"
8
- #include "IBluetooth.h"
9
-
10
- #include <com/com.h>
11
-
12
- namespace Thunder {
13
-
14
- namespace ProxyStubs {
15
-
16
- PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
17
- PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
18
-
19
- // -----------------------------------------------------------------
20
- // STUBS
21
- // -----------------------------------------------------------------
22
-
23
- // -----------------------------------------------------------------
24
- // PROXIES
25
- // -----------------------------------------------------------------
26
-
27
- POP_WARNING()
28
- POP_WARNING()
29
-
30
- // -----------------------------------------------------------------
31
- // REGISTRATION
32
- // -----------------------------------------------------------------
33
- namespace {
34
-
35
-
36
- static class Instantiation {
37
- public:
38
- Instantiation()
39
- {
40
- }
41
- ~Instantiation()
42
- {
43
- }
44
- } ProxyStubRegistration;
45
-
46
- } // namespace
47
-
48
- } // namespace ProxyStubs
49
-
50
- }
Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_Capture.cpp CHANGED
@@ -1,50 +0,0 @@
1
- //
2
- // generated automatically from "ICapture.h"
3
- //
4
- // implements COM-RPC proxy stubs for:
5
- //
6
-
7
- #include "Module.h"
8
- #include "ICapture.h"
9
-
10
- #include <com/com.h>
11
-
12
- namespace Thunder {
13
-
14
- namespace ProxyStubs {
15
-
16
- PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
17
- PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
18
-
19
- // -----------------------------------------------------------------
20
- // STUBS
21
- // -----------------------------------------------------------------
22
-
23
- // -----------------------------------------------------------------
24
- // PROXIES
25
- // -----------------------------------------------------------------
26
-
27
- POP_WARNING()
28
- POP_WARNING()
29
-
30
- // -----------------------------------------------------------------
31
- // REGISTRATION
32
- // -----------------------------------------------------------------
33
- namespace {
34
-
35
-
36
- static class Instantiation {
37
- public:
38
- Instantiation()
39
- {
40
- }
41
- ~Instantiation()
42
- {
43
- }
44
- } ProxyStubRegistration;
45
-
46
- } // namespace
47
-
48
- } // namespace ProxyStubs
49
-
50
- }
Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_IPNetwork.cpp CHANGED
@@ -1,50 +0,0 @@
1
- //
2
- // generated automatically from "IIPNetwork.h"
3
- //
4
- // implements COM-RPC proxy stubs for:
5
- //
6
-
7
- #include "Module.h"
8
- #include "IIPNetwork.h"
9
-
10
- #include <com/com.h>
11
-
12
- namespace Thunder {
13
-
14
- namespace ProxyStubs {
15
-
16
- PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
17
- PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
18
-
19
- // -----------------------------------------------------------------
20
- // STUBS
21
- // -----------------------------------------------------------------
22
-
23
- // -----------------------------------------------------------------
24
- // PROXIES
25
- // -----------------------------------------------------------------
26
-
27
- POP_WARNING()
28
- POP_WARNING()
29
-
30
- // -----------------------------------------------------------------
31
- // REGISTRATION
32
- // -----------------------------------------------------------------
33
- namespace {
34
-
35
-
36
- static class Instantiation {
37
- public:
38
- Instantiation()
39
- {
40
- }
41
- ~Instantiation()
42
- {
43
- }
44
- } ProxyStubRegistration;
45
-
46
- } // namespace
47
-
48
- } // namespace ProxyStubs
49
-
50
- }
Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_MessageControl.cpp CHANGED
@@ -1,667 +0,0 @@
1
- //
2
- // generated automatically from "IMessageControl.h"
3
- //
4
- // implements COM-RPC proxy stubs for:
5
- // - class RPC::IIteratorType<typename ELEMENT, const uint32_t INTERFACE_ID> [with ELEMENT = Exchange::IMessageControl::Control, INTERFACE_ID = Exchange::ID_MESSAGE_CONTROL_ITERATOR] [[iterator]]
6
- // - class RPC::IIteratorType<typename ELEMENT, const uint32_t INTERFACE_ID> [with ELEMENT = string, INTERFACE_ID = RPC::ID_STRINGITERATOR] [[iterator]]
7
- // - class Exchange::IMessageControl
8
- //
9
-
10
- #include "Module.h"
11
- #include "IMessageControl.h"
12
-
13
- #include <com/com.h>
14
-
15
- namespace Thunder {
16
-
17
- namespace ProxyStubs {
18
-
19
- PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
20
- PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
21
-
22
- // -----------------------------------------------------------------
23
- // STUBS
24
- // -----------------------------------------------------------------
25
-
26
- //
27
- // RPC::IIteratorTypeInstance_675a6ff7e5671893 interface stub definitions
28
- //
29
- // Methods:
30
- // (0) virtual bool Next(Exchange::IMessageControl::Control&) = 0
31
- // (1) virtual bool Previous(Exchange::IMessageControl::Control&) = 0
32
- // (2) virtual void Reset(const uint32_t) = 0
33
- // (3) virtual bool IsValid() const = 0
34
- // (4) virtual uint32_t Count() const = 0
35
- // (5) virtual Exchange::IMessageControl::Control Current() const = 0
36
- //
37
-
38
- static ProxyStub::MethodHandler RPCIteratorTypeInstance_675a6ff7e5671893StubMethods[] = {
39
- // (0) virtual bool Next(Exchange::IMessageControl::Control&) = 0
40
- //
41
- [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
42
- using interface = RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>;
43
-
44
- interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
45
- ASSERT(implementation != nullptr);
46
-
47
- Exchange::IMessageControl::Control _info{};
48
-
49
- bool result = implementation->Next(_info);
50
-
51
- RPC::Data::Frame::Writer writer(message->Response().Writer());
52
- writer.Boolean(result);
53
- writer.Number<Exchange::IMessageControl::messagetype>(_info.type);
54
- writer.Text(_info.category);
55
- writer.Text(_info.module);
56
- writer.Boolean(_info.enabled);
57
- },
58
-
59
- // (1) virtual bool Previous(Exchange::IMessageControl::Control&) = 0
60
- //
61
- [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
62
- using interface = RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>;
63
-
64
- interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
65
- ASSERT(implementation != nullptr);
66
-
67
- Exchange::IMessageControl::Control _info{};
68
-
69
- bool result = implementation->Previous(_info);
70
-
71
- RPC::Data::Frame::Writer writer(message->Response().Writer());
72
- writer.Boolean(result);
73
- writer.Number<Exchange::IMessageControl::messagetype>(_info.type);
74
- writer.Text(_info.category);
75
- writer.Text(_info.module);
76
- writer.Boolean(_info.enabled);
77
- },
78
-
79
- // (2) virtual void Reset(const uint32_t) = 0
80
- //
81
- [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
82
- using interface = RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>;
83
-
84
- interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
85
- ASSERT(implementation != nullptr);
86
-
87
- RPC::Data::Frame::Reader reader(message->Parameters().Reader());
88
- const uint32_t _position = reader.Number<uint32_t>();
89
-
90
- implementation->Reset(_position);
91
- },
92
-
93
- // (3) virtual bool IsValid() const = 0
94
- //
95
- [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
96
- using interface = RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>;
97
-
98
- const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
99
- ASSERT(implementation != nullptr);
100
-
101
- bool result = implementation->IsValid();
102
-
103
- RPC::Data::Frame::Writer writer(message->Response().Writer());
104
- writer.Boolean(result);
105
- },
106
-
107
- // (4) virtual uint32_t Count() const = 0
108
- //
109
- [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
110
- using interface = RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>;
111
-
112
- const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
113
- ASSERT(implementation != nullptr);
114
-
115
- uint32_t result = implementation->Count();
116
-
117
- RPC::Data::Frame::Writer writer(message->Response().Writer());
118
- writer.Number<uint32_t>(result);
119
- },
120
-
121
- // (5) virtual Exchange::IMessageControl::Control Current() const = 0
122
- //
123
- [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
124
- using interface = RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>;
125
-
126
- const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
127
- ASSERT(implementation != nullptr);
128
-
129
- Exchange::IMessageControl::Control result = implementation->Current();
130
-
131
- RPC::Data::Frame::Writer writer(message->Response().Writer());
132
- writer.Number<Exchange::IMessageControl::messagetype>(result.type);
133
- writer.Text(result.category);
134
- writer.Text(result.module);
135
- writer.Boolean(result.enabled);
136
- }
137
- , nullptr
138
- }; // RPCIteratorTypeInstance_675a6ff7e5671893StubMethods
139
-
140
- //
141
- // RPC::IIteratorTypeInstance_b3acff3685df4032 interface stub definitions
142
- //
143
- // Methods:
144
- // (0) virtual bool Next(string&) = 0
145
- // (1) virtual bool Previous(string&) = 0
146
- // (2) virtual void Reset(const uint32_t) = 0
147
- // (3) virtual bool IsValid() const = 0
148
- // (4) virtual uint32_t Count() const = 0
149
- // (5) virtual string Current() const = 0
150
- //
151
-
152
- static ProxyStub::MethodHandler RPCIteratorTypeInstance_b3acff3685df4032StubMethods[] = {
153
- // (0) virtual bool Next(string&) = 0
154
- //
155
- [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
156
- using interface = RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>;
157
-
158
- interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
159
- ASSERT(implementation != nullptr);
160
-
161
- string _info{};
162
-
163
- bool result = implementation->Next(_info);
164
-
165
- RPC::Data::Frame::Writer writer(message->Response().Writer());
166
- writer.Boolean(result);
167
- writer.Text(_info);
168
- },
169
-
170
- // (1) virtual bool Previous(string&) = 0
171
- //
172
- [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
173
- using interface = RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>;
174
-
175
- interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
176
- ASSERT(implementation != nullptr);
177
-
178
- string _info{};
179
-
180
- bool result = implementation->Previous(_info);
181
-
182
- RPC::Data::Frame::Writer writer(message->Response().Writer());
183
- writer.Boolean(result);
184
- writer.Text(_info);
185
- },
186
-
187
- // (2) virtual void Reset(const uint32_t) = 0
188
- //
189
- [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
190
- using interface = RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>;
191
-
192
- interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
193
- ASSERT(implementation != nullptr);
194
-
195
- RPC::Data::Frame::Reader reader(message->Parameters().Reader());
196
- const uint32_t _position = reader.Number<uint32_t>();
197
-
198
- implementation->Reset(_position);
199
- },
200
-
201
- // (3) virtual bool IsValid() const = 0
202
- //
203
- [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
204
- using interface = RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>;
205
-
206
- const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
207
- ASSERT(implementation != nullptr);
208
-
209
- bool result = implementation->IsValid();
210
-
211
- RPC::Data::Frame::Writer writer(message->Response().Writer());
212
- writer.Boolean(result);
213
- },
214
-
215
- // (4) virtual uint32_t Count() const = 0
216
- //
217
- [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
218
- using interface = RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>;
219
-
220
- const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
221
- ASSERT(implementation != nullptr);
222
-
223
- uint32_t result = implementation->Count();
224
-
225
- RPC::Data::Frame::Writer writer(message->Response().Writer());
226
- writer.Number<uint32_t>(result);
227
- },
228
-
229
- // (5) virtual string Current() const = 0
230
- //
231
- [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
232
- using interface = RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>;
233
-
234
- const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
235
- ASSERT(implementation != nullptr);
236
-
237
- string result = implementation->Current();
238
-
239
- RPC::Data::Frame::Writer writer(message->Response().Writer());
240
- writer.Text(result);
241
- }
242
- , nullptr
243
- }; // RPCIteratorTypeInstance_b3acff3685df4032StubMethods
244
-
245
- //
246
- // Exchange::IMessageControl interface stub definitions
247
- //
248
- // Methods:
249
- // (0) virtual Core::hresult Enable(const Exchange::IMessageControl::messagetype, const string&, const string&, const bool) = 0
250
- // (1) virtual Core::hresult Modules(Exchange::IMessageControl::IStringIterator*&) const = 0
251
- // (2) virtual Core::hresult Controls(const string&, Exchange::IMessageControl::IControlIterator*&) const = 0
252
- //
253
-
254
- static ProxyStub::MethodHandler ExchangeMessageControlStubMethods[] = {
255
- // (0) virtual Core::hresult Enable(const Exchange::IMessageControl::messagetype, const string&, const string&, const bool) = 0
256
- //
257
- [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
258
- Exchange::IMessageControl* implementation = reinterpret_cast<Exchange::IMessageControl*>(message->Parameters().Implementation());
259
- ASSERT(implementation != nullptr);
260
-
261
- RPC::Data::Frame::Reader reader(message->Parameters().Reader());
262
- const Exchange::IMessageControl::messagetype _type = reader.Number<Exchange::IMessageControl::messagetype>();
263
- const string _category = reader.Text();
264
- const string _module = reader.Text();
265
- const bool _enabled = reader.Boolean();
266
-
267
- Core::hresult result = implementation->Enable(_type, static_cast<const string&>(_category), static_cast<const string&>(_module), _enabled);
268
-
269
- RPC::Data::Frame::Writer writer(message->Response().Writer());
270
- writer.Number<Core::hresult>(result);
271
- },
272
-
273
- // (1) virtual Core::hresult Modules(Exchange::IMessageControl::IStringIterator*&) const = 0
274
- //
275
- [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
276
- const Exchange::IMessageControl* implementation = reinterpret_cast<const Exchange::IMessageControl*>(message->Parameters().Implementation());
277
- ASSERT(implementation != nullptr);
278
-
279
- Exchange::IMessageControl::IStringIterator* _modules{};
280
-
281
- Core::hresult result = implementation->Modules(_modules);
282
-
283
- RPC::Data::Frame::Writer writer(message->Response().Writer());
284
- writer.Number<Core::hresult>(result);
285
- writer.Number<Core::instance_id>(RPC::instance_cast(_modules));
286
-
287
- RPC::Administrator::Instance().RegisterInterface(channel, _modules);
288
- },
289
-
290
- // (2) virtual Core::hresult Controls(const string&, Exchange::IMessageControl::IControlIterator*&) const = 0
291
- //
292
- [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
293
- const Exchange::IMessageControl* implementation = reinterpret_cast<const Exchange::IMessageControl*>(message->Parameters().Implementation());
294
- ASSERT(implementation != nullptr);
295
-
296
- RPC::Data::Frame::Reader reader(message->Parameters().Reader());
297
- const string _module = reader.Text();
298
-
299
- Exchange::IMessageControl::IControlIterator* _control{};
300
-
301
- Core::hresult result = implementation->Controls(static_cast<const string&>(_module), _control);
302
-
303
- RPC::Data::Frame::Writer writer(message->Response().Writer());
304
- writer.Number<Core::hresult>(result);
305
- writer.Number<Core::instance_id>(RPC::instance_cast(_control));
306
-
307
- RPC::Administrator::Instance().RegisterInterface(channel, _control);
308
- }
309
- , nullptr
310
- }; // ExchangeMessageControlStubMethods
311
-
312
- // -----------------------------------------------------------------
313
- // PROXIES
314
- // -----------------------------------------------------------------
315
-
316
- //
317
- // RPC::IIteratorTypeInstance_675a6ff7e5671893 interface proxy definitions
318
- //
319
- // Methods:
320
- // (0) virtual bool Next(Exchange::IMessageControl::Control&) = 0
321
- // (1) virtual bool Previous(Exchange::IMessageControl::Control&) = 0
322
- // (2) virtual void Reset(const uint32_t) = 0
323
- // (3) virtual bool IsValid() const = 0
324
- // (4) virtual uint32_t Count() const = 0
325
- // (5) virtual Exchange::IMessageControl::Control Current() const = 0
326
- //
327
-
328
- class RPCIteratorTypeInstance_675a6ff7e5671893Proxy final : public ProxyStub::UnknownProxyType<RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>> {
329
- public:
330
- RPCIteratorTypeInstance_675a6ff7e5671893Proxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
331
- : BaseClass(channel, implementation, otherSideInformed)
332
- {
333
- }
334
-
335
- bool Next(Exchange::IMessageControl::Control& _info) override
336
- {
337
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
338
-
339
- bool result{};
340
-
341
- const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
342
- if (hresult == Core::ERROR_NONE) {
343
- RPC::Data::Frame::Reader reader(message->Response().Reader());
344
- result = reader.Boolean();
345
- _info.type = reader.Number<Exchange::IMessageControl::messagetype>();
346
- _info.category = reader.Text();
347
- _info.module = reader.Text();
348
- _info.enabled = reader.Boolean();
349
- } else {
350
- ASSERT((hresult & COM_ERROR) != 0);
351
- }
352
-
353
- return (result);
354
- }
355
-
356
- bool Previous(Exchange::IMessageControl::Control& _info) override
357
- {
358
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
359
-
360
- bool result{};
361
-
362
- const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
363
- if (hresult == Core::ERROR_NONE) {
364
- RPC::Data::Frame::Reader reader(message->Response().Reader());
365
- result = reader.Boolean();
366
- _info.type = reader.Number<Exchange::IMessageControl::messagetype>();
367
- _info.category = reader.Text();
368
- _info.module = reader.Text();
369
- _info.enabled = reader.Boolean();
370
- } else {
371
- ASSERT((hresult & COM_ERROR) != 0);
372
- }
373
-
374
- return (result);
375
- }
376
-
377
- void Reset(const uint32_t _position) override
378
- {
379
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
380
-
381
- RPC::Data::Frame::Writer writer(message->Parameters().Writer());
382
- writer.Number<uint32_t>(_position);
383
-
384
- static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
385
- }
386
-
387
- bool IsValid() const override
388
- {
389
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
390
-
391
- bool result{};
392
-
393
- const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
394
- if (hresult == Core::ERROR_NONE) {
395
- RPC::Data::Frame::Reader reader(message->Response().Reader());
396
- result = reader.Boolean();
397
- } else {
398
- ASSERT((hresult & COM_ERROR) != 0);
399
- }
400
-
401
- return (result);
402
- }
403
-
404
- uint32_t Count() const override
405
- {
406
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(4));
407
-
408
- uint32_t result{};
409
-
410
- const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
411
- if (hresult == Core::ERROR_NONE) {
412
- RPC::Data::Frame::Reader reader(message->Response().Reader());
413
- result = reader.Number<uint32_t>();
414
- } else {
415
- ASSERT((hresult & COM_ERROR) != 0);
416
- }
417
-
418
- return (result);
419
- }
420
-
421
- Exchange::IMessageControl::Control Current() const override
422
- {
423
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(5));
424
-
425
- Exchange::IMessageControl::Control result{};
426
-
427
- const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
428
- if (hresult == Core::ERROR_NONE) {
429
- RPC::Data::Frame::Reader reader(message->Response().Reader());
430
- result.type = reader.Number<Exchange::IMessageControl::messagetype>();
431
- result.category = reader.Text();
432
- result.module = reader.Text();
433
- result.enabled = reader.Boolean();
434
- } else {
435
- ASSERT((hresult & COM_ERROR) != 0);
436
- }
437
-
438
- return (result);
439
- }
440
-
441
- }; // class RPCIteratorTypeInstance_675a6ff7e5671893Proxy
442
-
443
- //
444
- // RPC::IIteratorTypeInstance_b3acff3685df4032 interface proxy definitions
445
- //
446
- // Methods:
447
- // (0) virtual bool Next(string&) = 0
448
- // (1) virtual bool Previous(string&) = 0
449
- // (2) virtual void Reset(const uint32_t) = 0
450
- // (3) virtual bool IsValid() const = 0
451
- // (4) virtual uint32_t Count() const = 0
452
- // (5) virtual string Current() const = 0
453
- //
454
-
455
- class RPCIteratorTypeInstance_b3acff3685df4032Proxy final : public ProxyStub::UnknownProxyType<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>> {
456
- public:
457
- RPCIteratorTypeInstance_b3acff3685df4032Proxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
458
- : BaseClass(channel, implementation, otherSideInformed)
459
- {
460
- }
461
-
462
- bool Next(string& _info) override
463
- {
464
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
465
-
466
- bool result{};
467
-
468
- const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
469
- if (hresult == Core::ERROR_NONE) {
470
- RPC::Data::Frame::Reader reader(message->Response().Reader());
471
- result = reader.Boolean();
472
- _info = reader.Text();
473
- } else {
474
- ASSERT((hresult & COM_ERROR) != 0);
475
- }
476
-
477
- return (result);
478
- }
479
-
480
- bool Previous(string& _info) override
481
- {
482
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
483
-
484
- bool result{};
485
-
486
- const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
487
- if (hresult == Core::ERROR_NONE) {
488
- RPC::Data::Frame::Reader reader(message->Response().Reader());
489
- result = reader.Boolean();
490
- _info = reader.Text();
491
- } else {
492
- ASSERT((hresult & COM_ERROR) != 0);
493
- }
494
-
495
- return (result);
496
- }
497
-
498
- void Reset(const uint32_t _position) override
499
- {
500
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
501
-
502
- RPC::Data::Frame::Writer writer(message->Parameters().Writer());
503
- writer.Number<uint32_t>(_position);
504
-
505
- static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
506
- }
507
-
508
- bool IsValid() const override
509
- {
510
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
511
-
512
- bool result{};
513
-
514
- const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
515
- if (hresult == Core::ERROR_NONE) {
516
- RPC::Data::Frame::Reader reader(message->Response().Reader());
517
- result = reader.Boolean();
518
- } else {
519
- ASSERT((hresult & COM_ERROR) != 0);
520
- }
521
-
522
- return (result);
523
- }
524
-
525
- uint32_t Count() const override
526
- {
527
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(4));
528
-
529
- uint32_t result{};
530
-
531
- const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
532
- if (hresult == Core::ERROR_NONE) {
533
- RPC::Data::Frame::Reader reader(message->Response().Reader());
534
- result = reader.Number<uint32_t>();
535
- } else {
536
- ASSERT((hresult & COM_ERROR) != 0);
537
- }
538
-
539
- return (result);
540
- }
541
-
542
- string Current() const override
543
- {
544
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(5));
545
-
546
- string result{};
547
-
548
- const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
549
- if (hresult == Core::ERROR_NONE) {
550
- RPC::Data::Frame::Reader reader(message->Response().Reader());
551
- result = reader.Text();
552
- } else {
553
- ASSERT((hresult & COM_ERROR) != 0);
554
- }
555
-
556
- return (result);
557
- }
558
-
559
- }; // class RPCIteratorTypeInstance_b3acff3685df4032Proxy
560
-
561
- //
562
- // Exchange::IMessageControl interface proxy definitions
563
- //
564
- // Methods:
565
- // (0) virtual Core::hresult Enable(const Exchange::IMessageControl::messagetype, const string&, const string&, const bool) = 0
566
- // (1) virtual Core::hresult Modules(Exchange::IMessageControl::IStringIterator*&) const = 0
567
- // (2) virtual Core::hresult Controls(const string&, Exchange::IMessageControl::IControlIterator*&) const = 0
568
- //
569
-
570
- class ExchangeMessageControlProxy final : public ProxyStub::UnknownProxyType<Exchange::IMessageControl> {
571
- public:
572
- ExchangeMessageControlProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
573
- : BaseClass(channel, implementation, otherSideInformed)
574
- {
575
- }
576
-
577
- Core::hresult Enable(const Exchange::IMessageControl::messagetype _type, const string& _category, const string& _module, const bool _enabled) override
578
- {
579
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
580
-
581
- RPC::Data::Frame::Writer writer(message->Parameters().Writer());
582
- writer.Number<Exchange::IMessageControl::messagetype>(_type);
583
- writer.Text(_category);
584
- writer.Text(_module);
585
- writer.Boolean(_enabled);
586
-
587
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
588
- if (hresult == Core::ERROR_NONE) {
589
- RPC::Data::Frame::Reader reader(message->Response().Reader());
590
- hresult = reader.Number<Core::hresult>();
591
- } else {
592
- ASSERT((hresult & COM_ERROR) != 0);
593
- }
594
-
595
- return (hresult);
596
- }
597
-
598
- Core::hresult Modules(Exchange::IMessageControl::IStringIterator*& _modules) const override
599
- {
600
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
601
-
602
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
603
- if (hresult == Core::ERROR_NONE) {
604
- RPC::Data::Frame::Reader reader(message->Response().Reader());
605
- hresult = reader.Number<Core::hresult>();
606
- _modules = reinterpret_cast<Exchange::IMessageControl::IStringIterator*>(static_cast<const ProxyStub::UnknownProxy&>(*this).Interface(reader.Number<Core::instance_id>(), Exchange::IMessageControl::IStringIterator::ID));
607
- } else {
608
- ASSERT((hresult & COM_ERROR) != 0);
609
- }
610
-
611
- return (hresult);
612
- }
613
-
614
- Core::hresult Controls(const string& _module, Exchange::IMessageControl::IControlIterator*& _control) const override
615
- {
616
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
617
-
618
- RPC::Data::Frame::Writer writer(message->Parameters().Writer());
619
- writer.Text(_module);
620
-
621
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
622
- if (hresult == Core::ERROR_NONE) {
623
- RPC::Data::Frame::Reader reader(message->Response().Reader());
624
- hresult = reader.Number<Core::hresult>();
625
- _control = reinterpret_cast<Exchange::IMessageControl::IControlIterator*>(static_cast<const ProxyStub::UnknownProxy&>(*this).Interface(reader.Number<Core::instance_id>(), Exchange::IMessageControl::IControlIterator::ID));
626
- } else {
627
- ASSERT((hresult & COM_ERROR) != 0);
628
- }
629
-
630
- return (hresult);
631
- }
632
-
633
- }; // class ExchangeMessageControlProxy
634
-
635
- POP_WARNING()
636
- POP_WARNING()
637
-
638
- // -----------------------------------------------------------------
639
- // REGISTRATION
640
- // -----------------------------------------------------------------
641
- namespace {
642
-
643
- typedef ProxyStub::UnknownStubType<RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>, RPCIteratorTypeInstance_675a6ff7e5671893StubMethods> RPCIteratorTypeInstance_675a6ff7e5671893Stub;
644
- typedef ProxyStub::UnknownStubType<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>, RPCIteratorTypeInstance_b3acff3685df4032StubMethods> RPCIteratorTypeInstance_b3acff3685df4032Stub;
645
- typedef ProxyStub::UnknownStubType<Exchange::IMessageControl, ExchangeMessageControlStubMethods> ExchangeMessageControlStub;
646
-
647
- static class Instantiation {
648
- public:
649
- Instantiation()
650
- {
651
- RPC::Administrator::Instance().Announce<RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>, RPCIteratorTypeInstance_675a6ff7e5671893Proxy, RPCIteratorTypeInstance_675a6ff7e5671893Stub>();
652
- RPC::Administrator::Instance().Announce<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>, RPCIteratorTypeInstance_b3acff3685df4032Proxy, RPCIteratorTypeInstance_b3acff3685df4032Stub>();
653
- RPC::Administrator::Instance().Announce<Exchange::IMessageControl, ExchangeMessageControlProxy, ExchangeMessageControlStub>();
654
- }
655
- ~Instantiation()
656
- {
657
- RPC::Administrator::Instance().Recall<RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>>();
658
- RPC::Administrator::Instance().Recall<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>();
659
- RPC::Administrator::Instance().Recall<Exchange::IMessageControl>();
660
- }
661
- } ProxyStubRegistration;
662
-
663
- } // namespace
664
-
665
- } // namespace ProxyStubs
666
-
667
- }
Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_SecureShellServer.cpp CHANGED
@@ -1,50 +0,0 @@
1
- //
2
- // generated automatically from "ISecureShellServer.h"
3
- //
4
- // implements COM-RPC proxy stubs for:
5
- //
6
-
7
- #include "Module.h"
8
- #include "ISecureShellServer.h"
9
-
10
- #include <com/com.h>
11
-
12
- namespace Thunder {
13
-
14
- namespace ProxyStubs {
15
-
16
- PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
17
- PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
18
-
19
- // -----------------------------------------------------------------
20
- // STUBS
21
- // -----------------------------------------------------------------
22
-
23
- // -----------------------------------------------------------------
24
- // PROXIES
25
- // -----------------------------------------------------------------
26
-
27
- POP_WARNING()
28
- POP_WARNING()
29
-
30
- // -----------------------------------------------------------------
31
- // REGISTRATION
32
- // -----------------------------------------------------------------
33
- namespace {
34
-
35
-
36
- static class Instantiation {
37
- public:
38
- Instantiation()
39
- {
40
- }
41
- ~Instantiation()
42
- {
43
- }
44
- } ProxyStubRegistration;
45
-
46
- } // namespace
47
-
48
- } // namespace ProxyStubs
49
-
50
- }
Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_SwitchBoard.cpp CHANGED
@@ -1,50 +0,0 @@
1
- //
2
- // generated automatically from "ISwitchBoard.h"
3
- //
4
- // implements COM-RPC proxy stubs for:
5
- //
6
-
7
- #include "Module.h"
8
- #include "ISwitchBoard.h"
9
-
10
- #include <com/com.h>
11
-
12
- namespace Thunder {
13
-
14
- namespace ProxyStubs {
15
-
16
- PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
17
- PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
18
-
19
- // -----------------------------------------------------------------
20
- // STUBS
21
- // -----------------------------------------------------------------
22
-
23
- // -----------------------------------------------------------------
24
- // PROXIES
25
- // -----------------------------------------------------------------
26
-
27
- POP_WARNING()
28
- POP_WARNING()
29
-
30
- // -----------------------------------------------------------------
31
- // REGISTRATION
32
- // -----------------------------------------------------------------
33
- namespace {
34
-
35
-
36
- static class Instantiation {
37
- public:
38
- Instantiation()
39
- {
40
- }
41
- ~Instantiation()
42
- {
43
- }
44
- } ProxyStubRegistration;
45
-
46
- } // namespace
47
-
48
- } // namespace ProxyStubs
49
-
50
- }
Debug/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_Benchmark.cpp CHANGED
@@ -0,0 +1,753 @@
1
+ //
2
+ // generated automatically from "IBenchmark.h"
3
+ //
4
+ // implements COM-RPC proxy stubs for:
5
+ // - class RPC::IIteratorType<typename ELEMENT, const uint32_t INTERFACE_ID> [with ELEMENT = QualityAssurance::IBenchmark::BenchmarkResult, INTERFACE_ID = QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR] [[iterator]]
6
+ // - class QualityAssurance::IBenchmark
7
+ // - class QualityAssurance::IBenchmark::INotification
8
+ //
9
+
10
+ #include "Module.h"
11
+ #include "IBenchmark.h"
12
+
13
+ #include <com/com.h>
14
+
15
+ namespace Thunder {
16
+
17
+ namespace ProxyStubs {
18
+
19
+ PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
20
+ PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
21
+
22
+ // -----------------------------------------------------------------
23
+ // STUBS
24
+ // -----------------------------------------------------------------
25
+
26
+ //
27
+ // RPC::IIteratorTypeInstance_d47fe5f746e372d7 interface stub definitions
28
+ //
29
+ // Methods:
30
+ // (0) virtual bool Next(QualityAssurance::IBenchmark::BenchmarkResult&) = 0
31
+ // (1) virtual bool Previous(QualityAssurance::IBenchmark::BenchmarkResult&) = 0
32
+ // (2) virtual void Reset(const uint32_t) = 0
33
+ // (3) virtual bool IsValid() const = 0
34
+ // (4) virtual uint32_t Count() const = 0
35
+ // (5) virtual QualityAssurance::IBenchmark::BenchmarkResult Current() const = 0
36
+ //
37
+
38
+ static ProxyStub::MethodHandler RPCIteratorTypeInstance_d47fe5f746e372d7StubMethods[] = {
39
+ // (0) virtual bool Next(QualityAssurance::IBenchmark::BenchmarkResult&) = 0
40
+ //
41
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
42
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>;
43
+
44
+ interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
45
+ ASSERT(implementation != nullptr);
46
+
47
+ QualityAssurance::IBenchmark::BenchmarkResult _info{};
48
+
49
+ bool result = implementation->Next(_info);
50
+
51
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
52
+ writer.Boolean(result);
53
+ writer.Text(_info.apiName);
54
+ writer.Number<uint32_t>(_info.iterations);
55
+ writer.Number<uint64_t>(_info.roundTrip.minNs);
56
+ writer.Number<uint64_t>(_info.roundTrip.avgNs);
57
+ writer.Number<uint64_t>(_info.roundTrip.maxNs);
58
+ writer.Number<uint64_t>(_info.roundTrip.stddevNs);
59
+ writer.Number<uint64_t>(_info.memory.residentBefore);
60
+ writer.Number<uint64_t>(_info.memory.residentAfter);
61
+ writer.Number<uint64_t>(_info.memory.allocatedBefore);
62
+ writer.Number<uint64_t>(_info.memory.allocatedAfter);
63
+ writer.Boolean(_info.passed);
64
+ writer.Boolean(_info.failureReason.IsSet());
65
+ if (_info.failureReason.IsSet() == true) {
66
+ writer.Number<QualityAssurance::IBenchmark::FailureReason>(_info.failureReason.Value());
67
+ }
68
+ },
69
+
70
+ // (1) virtual bool Previous(QualityAssurance::IBenchmark::BenchmarkResult&) = 0
71
+ //
72
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
73
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>;
74
+
75
+ interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
76
+ ASSERT(implementation != nullptr);
77
+
78
+ QualityAssurance::IBenchmark::BenchmarkResult _info{};
79
+
80
+ bool result = implementation->Previous(_info);
81
+
82
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
83
+ writer.Boolean(result);
84
+ writer.Text(_info.apiName);
85
+ writer.Number<uint32_t>(_info.iterations);
86
+ writer.Number<uint64_t>(_info.roundTrip.minNs);
87
+ writer.Number<uint64_t>(_info.roundTrip.avgNs);
88
+ writer.Number<uint64_t>(_info.roundTrip.maxNs);
89
+ writer.Number<uint64_t>(_info.roundTrip.stddevNs);
90
+ writer.Number<uint64_t>(_info.memory.residentBefore);
91
+ writer.Number<uint64_t>(_info.memory.residentAfter);
92
+ writer.Number<uint64_t>(_info.memory.allocatedBefore);
93
+ writer.Number<uint64_t>(_info.memory.allocatedAfter);
94
+ writer.Boolean(_info.passed);
95
+ writer.Boolean(_info.failureReason.IsSet());
96
+ if (_info.failureReason.IsSet() == true) {
97
+ writer.Number<QualityAssurance::IBenchmark::FailureReason>(_info.failureReason.Value());
98
+ }
99
+ },
100
+
101
+ // (2) virtual void Reset(const uint32_t) = 0
102
+ //
103
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
104
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>;
105
+
106
+ interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
107
+ ASSERT(implementation != nullptr);
108
+
109
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
110
+ const uint32_t _position = reader.Number<uint32_t>();
111
+
112
+ implementation->Reset(_position);
113
+ },
114
+
115
+ // (3) virtual bool IsValid() const = 0
116
+ //
117
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
118
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>;
119
+
120
+ const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
121
+ ASSERT(implementation != nullptr);
122
+
123
+ bool result = implementation->IsValid();
124
+
125
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
126
+ writer.Boolean(result);
127
+ },
128
+
129
+ // (4) virtual uint32_t Count() const = 0
130
+ //
131
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
132
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>;
133
+
134
+ const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
135
+ ASSERT(implementation != nullptr);
136
+
137
+ uint32_t result = implementation->Count();
138
+
139
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
140
+ writer.Number<uint32_t>(result);
141
+ },
142
+
143
+ // (5) virtual QualityAssurance::IBenchmark::BenchmarkResult Current() const = 0
144
+ //
145
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
146
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>;
147
+
148
+ const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
149
+ ASSERT(implementation != nullptr);
150
+
151
+ QualityAssurance::IBenchmark::BenchmarkResult result = implementation->Current();
152
+
153
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
154
+ writer.Text(result.apiName);
155
+ writer.Number<uint32_t>(result.iterations);
156
+ writer.Number<uint64_t>(result.roundTrip.minNs);
157
+ writer.Number<uint64_t>(result.roundTrip.avgNs);
158
+ writer.Number<uint64_t>(result.roundTrip.maxNs);
159
+ writer.Number<uint64_t>(result.roundTrip.stddevNs);
160
+ writer.Number<uint64_t>(result.memory.residentBefore);
161
+ writer.Number<uint64_t>(result.memory.residentAfter);
162
+ writer.Number<uint64_t>(result.memory.allocatedBefore);
163
+ writer.Number<uint64_t>(result.memory.allocatedAfter);
164
+ writer.Boolean(result.passed);
165
+ writer.Boolean(result.failureReason.IsSet());
166
+ if (result.failureReason.IsSet() == true) {
167
+ writer.Number<QualityAssurance::IBenchmark::FailureReason>(result.failureReason.Value());
168
+ }
169
+ }
170
+ , nullptr
171
+ }; // RPCIteratorTypeInstance_d47fe5f746e372d7StubMethods
172
+
173
+ //
174
+ // QualityAssurance::IBenchmark interface stub definitions
175
+ //
176
+ // Methods:
177
+ // (0) virtual Core::hresult Trigger(const uint32_t) = 0
178
+ // (1) virtual Core::hresult CollectData(QualityAssurance::IBenchmark::IBenchmarkResultIterator*&) const = 0
179
+ // (2) virtual Core::hresult LatencyThreshold(const uint32_t) = 0
180
+ // (3) virtual Core::hresult LatencyThreshold(uint32_t&) const = 0
181
+ // (4) virtual Core::hresult MemoryThreshold(const uint64_t) = 0
182
+ // (5) virtual Core::hresult MemoryThreshold(uint64_t&) const = 0
183
+ // (6) virtual Core::hresult Register(QualityAssurance::IBenchmark::INotification*) = 0
184
+ // (7) virtual Core::hresult Unregister(QualityAssurance::IBenchmark::INotification*) = 0
185
+ //
186
+
187
+ static ProxyStub::MethodHandler QualityAssuranceBenchmarkStubMethods[] = {
188
+ // (0) virtual Core::hresult Trigger(const uint32_t) = 0
189
+ //
190
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
191
+ QualityAssurance::IBenchmark* implementation = reinterpret_cast<QualityAssurance::IBenchmark*>(message->Parameters().Implementation());
192
+ ASSERT(implementation != nullptr);
193
+
194
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
195
+ const uint32_t _iterations = reader.Number<uint32_t>();
196
+
197
+ Core::hresult result = implementation->Trigger(_iterations);
198
+
199
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
200
+ writer.Number<Core::hresult>(result);
201
+ },
202
+
203
+ // (1) virtual Core::hresult CollectData(QualityAssurance::IBenchmark::IBenchmarkResultIterator*&) const = 0
204
+ //
205
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
206
+ const QualityAssurance::IBenchmark* implementation = reinterpret_cast<const QualityAssurance::IBenchmark*>(message->Parameters().Implementation());
207
+ ASSERT(implementation != nullptr);
208
+
209
+ QualityAssurance::IBenchmark::IBenchmarkResultIterator* _report{};
210
+
211
+ Core::hresult result = implementation->CollectData(_report);
212
+
213
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
214
+ writer.Number<Core::hresult>(result);
215
+ writer.Number<Core::instance_id>(RPC::instance_cast(_report));
216
+
217
+ RPC::Administrator::Instance().RegisterInterface(channel, _report);
218
+ },
219
+
220
+ // (2) virtual Core::hresult LatencyThreshold(const uint32_t) = 0
221
+ //
222
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
223
+ QualityAssurance::IBenchmark* implementation = reinterpret_cast<QualityAssurance::IBenchmark*>(message->Parameters().Implementation());
224
+ ASSERT(implementation != nullptr);
225
+
226
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
227
+ const uint32_t _maxLatencyDeviationPct = reader.Number<uint32_t>();
228
+
229
+ Core::hresult result = implementation->LatencyThreshold(_maxLatencyDeviationPct);
230
+
231
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
232
+ writer.Number<Core::hresult>(result);
233
+ },
234
+
235
+ // (3) virtual Core::hresult LatencyThreshold(uint32_t&) const = 0
236
+ //
237
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
238
+ const QualityAssurance::IBenchmark* implementation = reinterpret_cast<const QualityAssurance::IBenchmark*>(message->Parameters().Implementation());
239
+ ASSERT(implementation != nullptr);
240
+
241
+ uint32_t _maxLatencyDeviationPct{};
242
+
243
+ Core::hresult result = implementation->LatencyThreshold(_maxLatencyDeviationPct);
244
+
245
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
246
+ writer.Number<Core::hresult>(result);
247
+ writer.Number<uint32_t>(_maxLatencyDeviationPct);
248
+ },
249
+
250
+ // (4) virtual Core::hresult MemoryThreshold(const uint64_t) = 0
251
+ //
252
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
253
+ QualityAssurance::IBenchmark* implementation = reinterpret_cast<QualityAssurance::IBenchmark*>(message->Parameters().Implementation());
254
+ ASSERT(implementation != nullptr);
255
+
256
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
257
+ const uint64_t _maxMemoryGrowthBytes = reader.Number<uint64_t>();
258
+
259
+ Core::hresult result = implementation->MemoryThreshold(_maxMemoryGrowthBytes);
260
+
261
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
262
+ writer.Number<Core::hresult>(result);
263
+ },
264
+
265
+ // (5) virtual Core::hresult MemoryThreshold(uint64_t&) const = 0
266
+ //
267
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
268
+ const QualityAssurance::IBenchmark* implementation = reinterpret_cast<const QualityAssurance::IBenchmark*>(message->Parameters().Implementation());
269
+ ASSERT(implementation != nullptr);
270
+
271
+ uint64_t _maxMemoryGrowthBytes{};
272
+
273
+ Core::hresult result = implementation->MemoryThreshold(_maxMemoryGrowthBytes);
274
+
275
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
276
+ writer.Number<Core::hresult>(result);
277
+ writer.Number<uint64_t>(_maxMemoryGrowthBytes);
278
+ },
279
+
280
+ // (6) virtual Core::hresult Register(QualityAssurance::IBenchmark::INotification*) = 0
281
+ //
282
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
283
+ QualityAssurance::IBenchmark* implementation = reinterpret_cast<QualityAssurance::IBenchmark*>(message->Parameters().Implementation());
284
+ ASSERT(implementation != nullptr);
285
+
286
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
287
+ Core::instance_id _sinkInstanceId__ = reader.Number<Core::instance_id>();
288
+
289
+ QualityAssurance::IBenchmark::INotification* _sink{};
290
+ ProxyStub::UnknownProxy* _sinkProxy__ = nullptr;
291
+ if (_sinkInstanceId__ != 0) {
292
+ _sinkProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _sinkInstanceId__, false, _sink);
293
+ ASSERT((_sink != nullptr) && (_sinkProxy__ != nullptr));
294
+ }
295
+
296
+ Core::hresult result = implementation->Register(_sink);
297
+
298
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
299
+ writer.Number<Core::hresult>(result);
300
+
301
+ if (_sinkProxy__ != nullptr) {
302
+ RPC::Administrator::Instance().Release(_sinkProxy__, message->Response());
303
+ }
304
+ },
305
+
306
+ // (7) virtual Core::hresult Unregister(QualityAssurance::IBenchmark::INotification*) = 0
307
+ //
308
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
309
+ QualityAssurance::IBenchmark* implementation = reinterpret_cast<QualityAssurance::IBenchmark*>(message->Parameters().Implementation());
310
+ ASSERT(implementation != nullptr);
311
+
312
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
313
+ Core::instance_id _sinkInstanceId__ = reader.Number<Core::instance_id>();
314
+
315
+ QualityAssurance::IBenchmark::INotification* _sink{};
316
+ ProxyStub::UnknownProxy* _sinkProxy__ = nullptr;
317
+ if (_sinkInstanceId__ != 0) {
318
+ _sinkProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _sinkInstanceId__, false, _sink);
319
+ ASSERT((_sink != nullptr) && (_sinkProxy__ != nullptr));
320
+ }
321
+
322
+ Core::hresult result = implementation->Unregister(_sink);
323
+
324
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
325
+ writer.Number<Core::hresult>(result);
326
+
327
+ if (_sinkProxy__ != nullptr) {
328
+ RPC::Administrator::Instance().Release(_sinkProxy__, message->Response());
329
+ }
330
+ }
331
+ , nullptr
332
+ }; // QualityAssuranceBenchmarkStubMethods
333
+
334
+ //
335
+ // QualityAssurance::IBenchmark::INotification interface stub definitions
336
+ //
337
+ // Methods:
338
+ // (0) virtual void PerformanceCheckCompleted() = 0
339
+ //
340
+
341
+ static ProxyStub::MethodHandler QualityAssuranceBenchmarkNotificationStubMethods[] = {
342
+ // (0) virtual void PerformanceCheckCompleted() = 0
343
+ //
344
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
345
+ QualityAssurance::IBenchmark::INotification* implementation = reinterpret_cast<QualityAssurance::IBenchmark::INotification*>(message->Parameters().Implementation());
346
+ ASSERT(implementation != nullptr);
347
+
348
+ implementation->PerformanceCheckCompleted();
349
+ }
350
+ , nullptr
351
+ }; // QualityAssuranceBenchmarkNotificationStubMethods
352
+
353
+ // -----------------------------------------------------------------
354
+ // PROXIES
355
+ // -----------------------------------------------------------------
356
+
357
+ //
358
+ // RPC::IIteratorTypeInstance_d47fe5f746e372d7 interface proxy definitions
359
+ //
360
+ // Methods:
361
+ // (0) virtual bool Next(QualityAssurance::IBenchmark::BenchmarkResult&) = 0
362
+ // (1) virtual bool Previous(QualityAssurance::IBenchmark::BenchmarkResult&) = 0
363
+ // (2) virtual void Reset(const uint32_t) = 0
364
+ // (3) virtual bool IsValid() const = 0
365
+ // (4) virtual uint32_t Count() const = 0
366
+ // (5) virtual QualityAssurance::IBenchmark::BenchmarkResult Current() const = 0
367
+ //
368
+
369
+ class RPCIteratorTypeInstance_d47fe5f746e372d7Proxy final : public ProxyStub::UnknownProxyType<RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>> {
370
+ public:
371
+ RPCIteratorTypeInstance_d47fe5f746e372d7Proxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
372
+ : BaseClass(channel, implementation, otherSideInformed)
373
+ {
374
+ }
375
+
376
+ bool Next(QualityAssurance::IBenchmark::BenchmarkResult& _info) override
377
+ {
378
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
379
+
380
+ bool result{};
381
+
382
+ const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
383
+ if (hresult == Core::ERROR_NONE) {
384
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
385
+ result = reader.Boolean();
386
+ _info.apiName = reader.Text();
387
+ _info.iterations = reader.Number<uint32_t>();
388
+ _info.roundTrip.minNs = reader.Number<uint64_t>();
389
+ _info.roundTrip.avgNs = reader.Number<uint64_t>();
390
+ _info.roundTrip.maxNs = reader.Number<uint64_t>();
391
+ _info.roundTrip.stddevNs = reader.Number<uint64_t>();
392
+ _info.memory.residentBefore = reader.Number<uint64_t>();
393
+ _info.memory.residentAfter = reader.Number<uint64_t>();
394
+ _info.memory.allocatedBefore = reader.Number<uint64_t>();
395
+ _info.memory.allocatedAfter = reader.Number<uint64_t>();
396
+ _info.passed = reader.Boolean();
397
+ if (reader.Boolean() == true) {
398
+ _info.failureReason = reader.Number<QualityAssurance::IBenchmark::FailureReason>();
399
+ }
400
+ } else {
401
+ ASSERT((hresult & COM_ERROR) != 0);
402
+ }
403
+
404
+ return (result);
405
+ }
406
+
407
+ bool Previous(QualityAssurance::IBenchmark::BenchmarkResult& _info) override
408
+ {
409
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
410
+
411
+ bool result{};
412
+
413
+ const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
414
+ if (hresult == Core::ERROR_NONE) {
415
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
416
+ result = reader.Boolean();
417
+ _info.apiName = reader.Text();
418
+ _info.iterations = reader.Number<uint32_t>();
419
+ _info.roundTrip.minNs = reader.Number<uint64_t>();
420
+ _info.roundTrip.avgNs = reader.Number<uint64_t>();
421
+ _info.roundTrip.maxNs = reader.Number<uint64_t>();
422
+ _info.roundTrip.stddevNs = reader.Number<uint64_t>();
423
+ _info.memory.residentBefore = reader.Number<uint64_t>();
424
+ _info.memory.residentAfter = reader.Number<uint64_t>();
425
+ _info.memory.allocatedBefore = reader.Number<uint64_t>();
426
+ _info.memory.allocatedAfter = reader.Number<uint64_t>();
427
+ _info.passed = reader.Boolean();
428
+ if (reader.Boolean() == true) {
429
+ _info.failureReason = reader.Number<QualityAssurance::IBenchmark::FailureReason>();
430
+ }
431
+ } else {
432
+ ASSERT((hresult & COM_ERROR) != 0);
433
+ }
434
+
435
+ return (result);
436
+ }
437
+
438
+ void Reset(const uint32_t _position) override
439
+ {
440
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
441
+
442
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
443
+ writer.Number<uint32_t>(_position);
444
+
445
+ static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
446
+ }
447
+
448
+ bool IsValid() const override
449
+ {
450
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
451
+
452
+ bool result{};
453
+
454
+ const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
455
+ if (hresult == Core::ERROR_NONE) {
456
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
457
+ result = reader.Boolean();
458
+ } else {
459
+ ASSERT((hresult & COM_ERROR) != 0);
460
+ }
461
+
462
+ return (result);
463
+ }
464
+
465
+ uint32_t Count() const override
466
+ {
467
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(4));
468
+
469
+ uint32_t result{};
470
+
471
+ const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
472
+ if (hresult == Core::ERROR_NONE) {
473
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
474
+ result = reader.Number<uint32_t>();
475
+ } else {
476
+ ASSERT((hresult & COM_ERROR) != 0);
477
+ }
478
+
479
+ return (result);
480
+ }
481
+
482
+ QualityAssurance::IBenchmark::BenchmarkResult Current() const override
483
+ {
484
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(5));
485
+
486
+ QualityAssurance::IBenchmark::BenchmarkResult result{};
487
+
488
+ const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
489
+ if (hresult == Core::ERROR_NONE) {
490
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
491
+ result.apiName = reader.Text();
492
+ result.iterations = reader.Number<uint32_t>();
493
+ result.roundTrip.minNs = reader.Number<uint64_t>();
494
+ result.roundTrip.avgNs = reader.Number<uint64_t>();
495
+ result.roundTrip.maxNs = reader.Number<uint64_t>();
496
+ result.roundTrip.stddevNs = reader.Number<uint64_t>();
497
+ result.memory.residentBefore = reader.Number<uint64_t>();
498
+ result.memory.residentAfter = reader.Number<uint64_t>();
499
+ result.memory.allocatedBefore = reader.Number<uint64_t>();
500
+ result.memory.allocatedAfter = reader.Number<uint64_t>();
501
+ result.passed = reader.Boolean();
502
+ if (reader.Boolean() == true) {
503
+ result.failureReason = reader.Number<QualityAssurance::IBenchmark::FailureReason>();
504
+ }
505
+ } else {
506
+ ASSERT((hresult & COM_ERROR) != 0);
507
+ }
508
+
509
+ return (result);
510
+ }
511
+
512
+ }; // class RPCIteratorTypeInstance_d47fe5f746e372d7Proxy
513
+
514
+ //
515
+ // QualityAssurance::IBenchmark interface proxy definitions
516
+ //
517
+ // Methods:
518
+ // (0) virtual Core::hresult Trigger(const uint32_t) = 0
519
+ // (1) virtual Core::hresult CollectData(QualityAssurance::IBenchmark::IBenchmarkResultIterator*&) const = 0
520
+ // (2) virtual Core::hresult LatencyThreshold(const uint32_t) = 0
521
+ // (3) virtual Core::hresult LatencyThreshold(uint32_t&) const = 0
522
+ // (4) virtual Core::hresult MemoryThreshold(const uint64_t) = 0
523
+ // (5) virtual Core::hresult MemoryThreshold(uint64_t&) const = 0
524
+ // (6) virtual Core::hresult Register(QualityAssurance::IBenchmark::INotification*) = 0
525
+ // (7) virtual Core::hresult Unregister(QualityAssurance::IBenchmark::INotification*) = 0
526
+ //
527
+
528
+ class QualityAssuranceBenchmarkProxy final : public ProxyStub::UnknownProxyType<QualityAssurance::IBenchmark> {
529
+ public:
530
+ QualityAssuranceBenchmarkProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
531
+ : BaseClass(channel, implementation, otherSideInformed)
532
+ {
533
+ }
534
+
535
+ Core::hresult Trigger(const uint32_t _iterations) override
536
+ {
537
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
538
+
539
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
540
+ writer.Number<uint32_t>(_iterations);
541
+
542
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
543
+ if (hresult == Core::ERROR_NONE) {
544
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
545
+ hresult = reader.Number<Core::hresult>();
546
+ } else {
547
+ ASSERT((hresult & COM_ERROR) != 0);
548
+ }
549
+
550
+ return (hresult);
551
+ }
552
+
553
+ Core::hresult CollectData(QualityAssurance::IBenchmark::IBenchmarkResultIterator*& _report) const override
554
+ {
555
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
556
+
557
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
558
+ if (hresult == Core::ERROR_NONE) {
559
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
560
+ hresult = reader.Number<Core::hresult>();
561
+ _report = reinterpret_cast<QualityAssurance::IBenchmark::IBenchmarkResultIterator*>(static_cast<const ProxyStub::UnknownProxy&>(*this).Interface(reader.Number<Core::instance_id>(), QualityAssurance::IBenchmark::IBenchmarkResultIterator::ID));
562
+ } else {
563
+ ASSERT((hresult & COM_ERROR) != 0);
564
+ }
565
+
566
+ return (hresult);
567
+ }
568
+
569
+ Core::hresult LatencyThreshold(const uint32_t _maxLatencyDeviationPct) override
570
+ {
571
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
572
+
573
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
574
+ writer.Number<uint32_t>(_maxLatencyDeviationPct);
575
+
576
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
577
+ if (hresult == Core::ERROR_NONE) {
578
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
579
+ hresult = reader.Number<Core::hresult>();
580
+ } else {
581
+ ASSERT((hresult & COM_ERROR) != 0);
582
+ }
583
+
584
+ return (hresult);
585
+ }
586
+
587
+ Core::hresult LatencyThreshold(uint32_t& _maxLatencyDeviationPct) const override
588
+ {
589
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
590
+
591
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
592
+ if (hresult == Core::ERROR_NONE) {
593
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
594
+ hresult = reader.Number<Core::hresult>();
595
+ _maxLatencyDeviationPct = reader.Number<uint32_t>();
596
+ } else {
597
+ ASSERT((hresult & COM_ERROR) != 0);
598
+ }
599
+
600
+ return (hresult);
601
+ }
602
+
603
+ Core::hresult MemoryThreshold(const uint64_t _maxMemoryGrowthBytes) override
604
+ {
605
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(4));
606
+
607
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
608
+ writer.Number<uint64_t>(_maxMemoryGrowthBytes);
609
+
610
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
611
+ if (hresult == Core::ERROR_NONE) {
612
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
613
+ hresult = reader.Number<Core::hresult>();
614
+ } else {
615
+ ASSERT((hresult & COM_ERROR) != 0);
616
+ }
617
+
618
+ return (hresult);
619
+ }
620
+
621
+ Core::hresult MemoryThreshold(uint64_t& _maxMemoryGrowthBytes) const override
622
+ {
623
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(5));
624
+
625
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
626
+ if (hresult == Core::ERROR_NONE) {
627
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
628
+ hresult = reader.Number<Core::hresult>();
629
+ _maxMemoryGrowthBytes = reader.Number<uint64_t>();
630
+ } else {
631
+ ASSERT((hresult & COM_ERROR) != 0);
632
+ }
633
+
634
+ return (hresult);
635
+ }
636
+
637
+ Core::hresult Register(QualityAssurance::IBenchmark::INotification* _sink) override
638
+ {
639
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(6));
640
+
641
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
642
+ writer.Number<Core::instance_id>(RPC::instance_cast(_sink));
643
+
644
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
645
+ if (hresult == Core::ERROR_NONE) {
646
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
647
+ hresult = reader.Number<Core::hresult>();
648
+
649
+ _Complete(reader);
650
+ } else {
651
+ ASSERT((hresult & COM_ERROR) != 0);
652
+ }
653
+
654
+ return (hresult);
655
+ }
656
+
657
+ Core::hresult Unregister(QualityAssurance::IBenchmark::INotification* _sink) override
658
+ {
659
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(7));
660
+
661
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
662
+ writer.Number<Core::instance_id>(RPC::instance_cast(_sink));
663
+
664
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
665
+ if (hresult == Core::ERROR_NONE) {
666
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
667
+ hresult = reader.Number<Core::hresult>();
668
+
669
+ _Complete(reader);
670
+ } else {
671
+ ASSERT((hresult & COM_ERROR) != 0);
672
+ }
673
+
674
+ return (hresult);
675
+ }
676
+
677
+ private:
678
+ uint32_t _Complete(RPC::Data::Frame::Reader& reader) const
679
+ {
680
+ uint32_t result = Core::ERROR_NONE;
681
+
682
+ while (reader.HasData() == true) {
683
+ const Core::instance_id implementation = reader.Number<Core::instance_id>();
684
+ ASSERT(implementation != 0);
685
+
686
+ const uint32_t id = reader.Number<uint32_t>();
687
+ const RPC::Data::Output::mode how = reader.Number<RPC::Data::Output::mode>();
688
+
689
+ result = static_cast<const ProxyStub::UnknownProxy&>(*this).Complete(implementation, id, how);
690
+ if (result != Core::ERROR_NONE) { return (COM_ERROR | result); }
691
+ }
692
+
693
+ return (result);
694
+ }
695
+
696
+ }; // class QualityAssuranceBenchmarkProxy
697
+
698
+ //
699
+ // QualityAssurance::IBenchmark::INotification interface proxy definitions
700
+ //
701
+ // Methods:
702
+ // (0) virtual void PerformanceCheckCompleted() = 0
703
+ //
704
+
705
+ class QualityAssuranceBenchmarkNotificationProxy final : public ProxyStub::UnknownProxyType<QualityAssurance::IBenchmark::INotification> {
706
+ public:
707
+ QualityAssuranceBenchmarkNotificationProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
708
+ : BaseClass(channel, implementation, otherSideInformed)
709
+ {
710
+ }
711
+
712
+ void PerformanceCheckCompleted() override
713
+ {
714
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
715
+
716
+ static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
717
+ }
718
+
719
+ }; // class QualityAssuranceBenchmarkNotificationProxy
720
+
721
+ POP_WARNING()
722
+ POP_WARNING()
723
+
724
+ // -----------------------------------------------------------------
725
+ // REGISTRATION
726
+ // -----------------------------------------------------------------
727
+ namespace {
728
+
729
+ typedef ProxyStub::UnknownStubType<RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>, RPCIteratorTypeInstance_d47fe5f746e372d7StubMethods> RPCIteratorTypeInstance_d47fe5f746e372d7Stub;
730
+ typedef ProxyStub::UnknownStubType<QualityAssurance::IBenchmark, QualityAssuranceBenchmarkStubMethods> QualityAssuranceBenchmarkStub;
731
+ typedef ProxyStub::UnknownStubType<QualityAssurance::IBenchmark::INotification, QualityAssuranceBenchmarkNotificationStubMethods> QualityAssuranceBenchmarkNotificationStub;
732
+
733
+ static class Instantiation {
734
+ public:
735
+ Instantiation()
736
+ {
737
+ RPC::Administrator::Instance().Announce<RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>, RPCIteratorTypeInstance_d47fe5f746e372d7Proxy, RPCIteratorTypeInstance_d47fe5f746e372d7Stub>();
738
+ RPC::Administrator::Instance().Announce<QualityAssurance::IBenchmark, QualityAssuranceBenchmarkProxy, QualityAssuranceBenchmarkStub>();
739
+ RPC::Administrator::Instance().Announce<QualityAssurance::IBenchmark::INotification, QualityAssuranceBenchmarkNotificationProxy, QualityAssuranceBenchmarkNotificationStub>();
740
+ }
741
+ ~Instantiation()
742
+ {
743
+ RPC::Administrator::Instance().Recall<RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>>();
744
+ RPC::Administrator::Instance().Recall<QualityAssurance::IBenchmark>();
745
+ RPC::Administrator::Instance().Recall<QualityAssurance::IBenchmark::INotification>();
746
+ }
747
+ } ProxyStubRegistration;
748
+
749
+ } // namespace
750
+
751
+ } // namespace ProxyStubs
752
+
753
+ }
Debug/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_BenchmarkPayload.cpp CHANGED
@@ -0,0 +1,1199 @@
1
+ //
2
+ // generated automatically from "IBenchmarkPayload.h"
3
+ //
4
+ // implements COM-RPC proxy stubs for:
5
+ // - class RPC::IIteratorType<typename ELEMENT, const uint32_t INTERFACE_ID> [with ELEMENT = QualityAssurance::IBenchmarkPayload::PayloadType, INTERFACE_ID = QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR] [[iterator]]
6
+ // - class QualityAssurance::IBenchmarkPayload
7
+ //
8
+
9
+ #include "Module.h"
10
+ #include "IBenchmarkPayload.h"
11
+
12
+ #include <com/com.h>
13
+
14
+ namespace Thunder {
15
+
16
+ namespace ProxyStubs {
17
+
18
+ PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
19
+ PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
20
+
21
+ // -----------------------------------------------------------------
22
+ // STUBS
23
+ // -----------------------------------------------------------------
24
+
25
+ //
26
+ // RPC::IIteratorTypeInstance_05353879ce17b341 interface stub definitions
27
+ //
28
+ // Methods:
29
+ // (0) virtual bool Next(QualityAssurance::IBenchmarkPayload::PayloadType&) = 0
30
+ // (1) virtual bool Previous(QualityAssurance::IBenchmarkPayload::PayloadType&) = 0
31
+ // (2) virtual void Reset(const uint32_t) = 0
32
+ // (3) virtual bool IsValid() const = 0
33
+ // (4) virtual uint32_t Count() const = 0
34
+ // (5) virtual QualityAssurance::IBenchmarkPayload::PayloadType Current() const = 0
35
+ //
36
+
37
+ static ProxyStub::MethodHandler RPCIteratorTypeInstance_05353879ce17b341StubMethods[] = {
38
+ // (0) virtual bool Next(QualityAssurance::IBenchmarkPayload::PayloadType&) = 0
39
+ //
40
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
41
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>;
42
+
43
+ interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
44
+ ASSERT(implementation != nullptr);
45
+
46
+ QualityAssurance::IBenchmarkPayload::PayloadType _info{};
47
+
48
+ bool result = implementation->Next(_info);
49
+
50
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
51
+ writer.Boolean(result);
52
+ writer.Number<QualityAssurance::IBenchmarkPayload::PayloadType>(_info);
53
+ },
54
+
55
+ // (1) virtual bool Previous(QualityAssurance::IBenchmarkPayload::PayloadType&) = 0
56
+ //
57
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
58
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>;
59
+
60
+ interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
61
+ ASSERT(implementation != nullptr);
62
+
63
+ QualityAssurance::IBenchmarkPayload::PayloadType _info{};
64
+
65
+ bool result = implementation->Previous(_info);
66
+
67
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
68
+ writer.Boolean(result);
69
+ writer.Number<QualityAssurance::IBenchmarkPayload::PayloadType>(_info);
70
+ },
71
+
72
+ // (2) virtual void Reset(const uint32_t) = 0
73
+ //
74
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
75
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>;
76
+
77
+ interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
78
+ ASSERT(implementation != nullptr);
79
+
80
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
81
+ const uint32_t _position = reader.Number<uint32_t>();
82
+
83
+ implementation->Reset(_position);
84
+ },
85
+
86
+ // (3) virtual bool IsValid() const = 0
87
+ //
88
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
89
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>;
90
+
91
+ const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
92
+ ASSERT(implementation != nullptr);
93
+
94
+ bool result = implementation->IsValid();
95
+
96
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
97
+ writer.Boolean(result);
98
+ },
99
+
100
+ // (4) virtual uint32_t Count() const = 0
101
+ //
102
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
103
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>;
104
+
105
+ const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
106
+ ASSERT(implementation != nullptr);
107
+
108
+ uint32_t result = implementation->Count();
109
+
110
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
111
+ writer.Number<uint32_t>(result);
112
+ },
113
+
114
+ // (5) virtual QualityAssurance::IBenchmarkPayload::PayloadType Current() const = 0
115
+ //
116
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
117
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>;
118
+
119
+ const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
120
+ ASSERT(implementation != nullptr);
121
+
122
+ QualityAssurance::IBenchmarkPayload::PayloadType result = implementation->Current();
123
+
124
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
125
+ writer.Number<QualityAssurance::IBenchmarkPayload::PayloadType>(result);
126
+ }
127
+ , nullptr
128
+ }; // RPCIteratorTypeInstance_05353879ce17b341StubMethods
129
+
130
+ //
131
+ // QualityAssurance::IBenchmarkPayload interface stub definitions
132
+ //
133
+ // Methods:
134
+ // (0) virtual Core::hresult GetPayloadTypes(QualityAssurance::IBenchmarkPayload::IPayloadTypeIterator*&) const = 0
135
+ // (1) virtual Core::hresult SendUint16(const uint16_t) = 0
136
+ // (2) virtual Core::hresult SendUint32(const uint32_t) = 0
137
+ // (3) virtual Core::hresult SendUint64(const uint64_t) = 0
138
+ // (4) virtual Core::hresult SendBool(const bool) = 0
139
+ // (5) virtual Core::hresult SendFloat(const float) = 0
140
+ // (6) virtual Core::hresult SendDouble(const double) = 0
141
+ // (7) virtual Core::hresult SendString(const string&) = 0
142
+ // (8) virtual Core::hresult SendSampleData(const QualityAssurance::IBenchmarkPayload::SampleData&) = 0
143
+ // (9) virtual Core::hresult SendNoPayload() = 0
144
+ // (10) virtual Core::hresult SendBuffer(const uint16_t, const uint8_t*) = 0
145
+ // (11) virtual Core::hresult SendUint32Vector(const std::vector<uint32_t>&) = 0
146
+ // (12) virtual Core::hresult SendReceiveUint16(const uint16_t, uint16_t&) const = 0
147
+ // (13) virtual Core::hresult SendReceiveUint32(const uint32_t, uint32_t&) const = 0
148
+ // (14) virtual Core::hresult SendReceiveUint64(const uint64_t, uint64_t&) const = 0
149
+ // (15) virtual Core::hresult SendReceiveBool(const bool, bool&) const = 0
150
+ // (16) virtual Core::hresult SendReceiveFloat(const float, float&) const = 0
151
+ // (17) virtual Core::hresult SendReceiveDouble(const double, double&) const = 0
152
+ // (18) virtual Core::hresult SendReceiveString(const string&, string&) const = 0
153
+ // (19) virtual Core::hresult SendReceiveSampleData(const QualityAssurance::IBenchmarkPayload::SampleData&, QualityAssurance::IBenchmarkPayload::SampleData&) const = 0
154
+ // (20) virtual Core::hresult SendReceiveBuffer(uint16_t&, uint8_t*) const = 0
155
+ // (21) virtual Core::hresult SendReceiveUint32Vector(const std::vector<uint32_t>&, std::vector<uint32_t>&) const = 0
156
+ // (22) virtual Core::hresult Add(const uint32_t, const uint32_t, uint32_t&) const = 0
157
+ //
158
+
159
+ static ProxyStub::MethodHandler QualityAssuranceBenchmarkPayloadStubMethods[] = {
160
+ // (0) virtual Core::hresult GetPayloadTypes(QualityAssurance::IBenchmarkPayload::IPayloadTypeIterator*&) const = 0
161
+ //
162
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
163
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
164
+ ASSERT(implementation != nullptr);
165
+
166
+ QualityAssurance::IBenchmarkPayload::IPayloadTypeIterator* _types{};
167
+
168
+ Core::hresult result = implementation->GetPayloadTypes(_types);
169
+
170
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
171
+ writer.Number<Core::hresult>(result);
172
+ writer.Number<Core::instance_id>(RPC::instance_cast(_types));
173
+
174
+ RPC::Administrator::Instance().RegisterInterface(channel, _types);
175
+ },
176
+
177
+ // (1) virtual Core::hresult SendUint16(const uint16_t) = 0
178
+ //
179
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
180
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
181
+ ASSERT(implementation != nullptr);
182
+
183
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
184
+ const uint16_t _value = reader.Number<uint16_t>();
185
+
186
+ Core::hresult result = implementation->SendUint16(_value);
187
+
188
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
189
+ writer.Number<Core::hresult>(result);
190
+ },
191
+
192
+ // (2) virtual Core::hresult SendUint32(const uint32_t) = 0
193
+ //
194
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
195
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
196
+ ASSERT(implementation != nullptr);
197
+
198
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
199
+ const uint32_t _value = reader.Number<uint32_t>();
200
+
201
+ Core::hresult result = implementation->SendUint32(_value);
202
+
203
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
204
+ writer.Number<Core::hresult>(result);
205
+ },
206
+
207
+ // (3) virtual Core::hresult SendUint64(const uint64_t) = 0
208
+ //
209
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
210
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
211
+ ASSERT(implementation != nullptr);
212
+
213
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
214
+ const uint64_t _value = reader.Number<uint64_t>();
215
+
216
+ Core::hresult result = implementation->SendUint64(_value);
217
+
218
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
219
+ writer.Number<Core::hresult>(result);
220
+ },
221
+
222
+ // (4) virtual Core::hresult SendBool(const bool) = 0
223
+ //
224
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
225
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
226
+ ASSERT(implementation != nullptr);
227
+
228
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
229
+ const bool _value = reader.Boolean();
230
+
231
+ Core::hresult result = implementation->SendBool(_value);
232
+
233
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
234
+ writer.Number<Core::hresult>(result);
235
+ },
236
+
237
+ // (5) virtual Core::hresult SendFloat(const float) = 0
238
+ //
239
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
240
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
241
+ ASSERT(implementation != nullptr);
242
+
243
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
244
+ const float _value = reader.Number<float>();
245
+
246
+ Core::hresult result = implementation->SendFloat(_value);
247
+
248
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
249
+ writer.Number<Core::hresult>(result);
250
+ },
251
+
252
+ // (6) virtual Core::hresult SendDouble(const double) = 0
253
+ //
254
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
255
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
256
+ ASSERT(implementation != nullptr);
257
+
258
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
259
+ const double _value = reader.Number<double>();
260
+
261
+ Core::hresult result = implementation->SendDouble(_value);
262
+
263
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
264
+ writer.Number<Core::hresult>(result);
265
+ },
266
+
267
+ // (7) virtual Core::hresult SendString(const string&) = 0
268
+ //
269
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
270
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
271
+ ASSERT(implementation != nullptr);
272
+
273
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
274
+ const string _value = reader.Text();
275
+
276
+ Core::hresult result = implementation->SendString(static_cast<const string&>(_value));
277
+
278
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
279
+ writer.Number<Core::hresult>(result);
280
+ },
281
+
282
+ // (8) virtual Core::hresult SendSampleData(const QualityAssurance::IBenchmarkPayload::SampleData&) = 0
283
+ //
284
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
285
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
286
+ ASSERT(implementation != nullptr);
287
+
288
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
289
+ QualityAssurance::IBenchmarkPayload::SampleData _data{};
290
+ _data.id = reader.Number<uint32_t>();
291
+ _data.value = reader.Number<uint32_t>();
292
+ _data.name = reader.Text();
293
+
294
+ Core::hresult result = implementation->SendSampleData(static_cast<const QualityAssurance::IBenchmarkPayload::SampleData&>(_data));
295
+
296
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
297
+ writer.Number<Core::hresult>(result);
298
+ },
299
+
300
+ // (9) virtual Core::hresult SendNoPayload() = 0
301
+ //
302
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
303
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
304
+ ASSERT(implementation != nullptr);
305
+
306
+ Core::hresult result = implementation->SendNoPayload();
307
+
308
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
309
+ writer.Number<Core::hresult>(result);
310
+ },
311
+
312
+ // (10) virtual Core::hresult SendBuffer(const uint16_t, const uint8_t*) = 0
313
+ //
314
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
315
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
316
+ ASSERT(implementation != nullptr);
317
+
318
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
319
+ const uint8_t* _buffer{};
320
+ const uint16_t _bufferSize = reader.LockBuffer<uint16_t>(_buffer);
321
+ reader.UnlockBuffer(_bufferSize);
322
+
323
+ Core::hresult result = implementation->SendBuffer(_bufferSize, _buffer);
324
+
325
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
326
+ writer.Number<Core::hresult>(result);
327
+ },
328
+
329
+ // (11) virtual Core::hresult SendUint32Vector(const std::vector<uint32_t>&) = 0
330
+ //
331
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
332
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
333
+ ASSERT(implementation != nullptr);
334
+
335
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
336
+ std::vector<uint32_t> _data{};
337
+ uint16_t _dataSize = reader.Number<uint16_t>();
338
+ ASSERT((_dataSize >= 1) && (_dataSize <= 1024));
339
+ _data.reserve(_dataSize);
340
+ for (uint16_t i = 0; i < _dataSize; i++) {
341
+ uint32_t _dataItem = reader.Number<uint32_t>();
342
+ _data.push_back(std::move(_dataItem));
343
+ }
344
+
345
+ Core::hresult result = implementation->SendUint32Vector(static_cast<const std::vector<uint32_t>&>(_data));
346
+
347
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
348
+ writer.Number<Core::hresult>(result);
349
+ },
350
+
351
+ // (12) virtual Core::hresult SendReceiveUint16(const uint16_t, uint16_t&) const = 0
352
+ //
353
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
354
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
355
+ ASSERT(implementation != nullptr);
356
+
357
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
358
+ const uint16_t _input = reader.Number<uint16_t>();
359
+
360
+ uint16_t _output{};
361
+
362
+ Core::hresult result = implementation->SendReceiveUint16(_input, _output);
363
+
364
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
365
+ writer.Number<Core::hresult>(result);
366
+ writer.Number<uint16_t>(_output);
367
+ },
368
+
369
+ // (13) virtual Core::hresult SendReceiveUint32(const uint32_t, uint32_t&) const = 0
370
+ //
371
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
372
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
373
+ ASSERT(implementation != nullptr);
374
+
375
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
376
+ const uint32_t _input = reader.Number<uint32_t>();
377
+
378
+ uint32_t _output{};
379
+
380
+ Core::hresult result = implementation->SendReceiveUint32(_input, _output);
381
+
382
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
383
+ writer.Number<Core::hresult>(result);
384
+ writer.Number<uint32_t>(_output);
385
+ },
386
+
387
+ // (14) virtual Core::hresult SendReceiveUint64(const uint64_t, uint64_t&) const = 0
388
+ //
389
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
390
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
391
+ ASSERT(implementation != nullptr);
392
+
393
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
394
+ const uint64_t _input = reader.Number<uint64_t>();
395
+
396
+ uint64_t _output{};
397
+
398
+ Core::hresult result = implementation->SendReceiveUint64(_input, _output);
399
+
400
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
401
+ writer.Number<Core::hresult>(result);
402
+ writer.Number<uint64_t>(_output);
403
+ },
404
+
405
+ // (15) virtual Core::hresult SendReceiveBool(const bool, bool&) const = 0
406
+ //
407
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
408
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
409
+ ASSERT(implementation != nullptr);
410
+
411
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
412
+ const bool _input = reader.Boolean();
413
+
414
+ bool _output{};
415
+
416
+ Core::hresult result = implementation->SendReceiveBool(_input, _output);
417
+
418
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
419
+ writer.Number<Core::hresult>(result);
420
+ writer.Boolean(_output);
421
+ },
422
+
423
+ // (16) virtual Core::hresult SendReceiveFloat(const float, float&) const = 0
424
+ //
425
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
426
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
427
+ ASSERT(implementation != nullptr);
428
+
429
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
430
+ const float _input = reader.Number<float>();
431
+
432
+ float _output{};
433
+
434
+ Core::hresult result = implementation->SendReceiveFloat(_input, _output);
435
+
436
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
437
+ writer.Number<Core::hresult>(result);
438
+ writer.Number<float>(_output);
439
+ },
440
+
441
+ // (17) virtual Core::hresult SendReceiveDouble(const double, double&) const = 0
442
+ //
443
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
444
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
445
+ ASSERT(implementation != nullptr);
446
+
447
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
448
+ const double _input = reader.Number<double>();
449
+
450
+ double _output{};
451
+
452
+ Core::hresult result = implementation->SendReceiveDouble(_input, _output);
453
+
454
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
455
+ writer.Number<Core::hresult>(result);
456
+ writer.Number<double>(_output);
457
+ },
458
+
459
+ // (18) virtual Core::hresult SendReceiveString(const string&, string&) const = 0
460
+ //
461
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
462
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
463
+ ASSERT(implementation != nullptr);
464
+
465
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
466
+ const string _input = reader.Text();
467
+
468
+ string _output{};
469
+
470
+ Core::hresult result = implementation->SendReceiveString(static_cast<const string&>(_input), _output);
471
+
472
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
473
+ writer.Number<Core::hresult>(result);
474
+ writer.Text(_output);
475
+ },
476
+
477
+ // (19) virtual Core::hresult SendReceiveSampleData(const QualityAssurance::IBenchmarkPayload::SampleData&, QualityAssurance::IBenchmarkPayload::SampleData&) const = 0
478
+ //
479
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
480
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
481
+ ASSERT(implementation != nullptr);
482
+
483
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
484
+ QualityAssurance::IBenchmarkPayload::SampleData _input{};
485
+ _input.id = reader.Number<uint32_t>();
486
+ _input.value = reader.Number<uint32_t>();
487
+ _input.name = reader.Text();
488
+
489
+ QualityAssurance::IBenchmarkPayload::SampleData _output{};
490
+
491
+ Core::hresult result = implementation->SendReceiveSampleData(static_cast<const QualityAssurance::IBenchmarkPayload::SampleData&>(_input), _output);
492
+
493
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
494
+ writer.Number<Core::hresult>(result);
495
+ writer.Number<uint32_t>(_output.id);
496
+ writer.Number<uint32_t>(_output.value);
497
+ writer.Text(_output.name);
498
+ },
499
+
500
+ // (20) virtual Core::hresult SendReceiveBuffer(uint16_t&, uint8_t*) const = 0
501
+ //
502
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
503
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
504
+ ASSERT(implementation != nullptr);
505
+
506
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
507
+ uint8_t* _buffer{};
508
+ uint16_t _bufferSize = reader.LockBuffer<uint16_t>(const_cast<const uint8_t*&>(_buffer));
509
+ reader.UnlockBuffer(_bufferSize);
510
+
511
+
512
+ Core::hresult result = implementation->SendReceiveBuffer(_bufferSize, _buffer);
513
+
514
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
515
+ writer.Number<Core::hresult>(result);
516
+ writer.Buffer<uint16_t>((_buffer == nullptr? 0 : _bufferSize), _buffer);
517
+ writer.Number<uint16_t>(_bufferSize);
518
+ },
519
+
520
+ // (21) virtual Core::hresult SendReceiveUint32Vector(const std::vector<uint32_t>&, std::vector<uint32_t>&) const = 0
521
+ //
522
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
523
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
524
+ ASSERT(implementation != nullptr);
525
+
526
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
527
+ std::vector<uint32_t> _input{};
528
+ uint16_t _inputSize = reader.Number<uint16_t>();
529
+ ASSERT((_inputSize >= 1) && (_inputSize <= 1024));
530
+ _input.reserve(_inputSize);
531
+ for (uint16_t i = 0; i < _inputSize; i++) {
532
+ uint32_t _inputItem = reader.Number<uint32_t>();
533
+ _input.push_back(std::move(_inputItem));
534
+ }
535
+
536
+ std::vector<uint32_t> _output{};
537
+
538
+ Core::hresult result = implementation->SendReceiveUint32Vector(static_cast<const std::vector<uint32_t>&>(_input), _output);
539
+
540
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
541
+ writer.Number<Core::hresult>(result);
542
+ writer.Number<uint16_t>(_output.size());
543
+ for (uint16_t i = 0; i < _output.size(); i++) {
544
+ writer.Number<uint32_t>(_output[i]);
545
+ }
546
+ },
547
+
548
+ // (22) virtual Core::hresult Add(const uint32_t, const uint32_t, uint32_t&) const = 0
549
+ //
550
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
551
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
552
+ ASSERT(implementation != nullptr);
553
+
554
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
555
+ const uint32_t _a = reader.Number<uint32_t>();
556
+ const uint32_t _b = reader.Number<uint32_t>();
557
+
558
+ uint32_t _result{};
559
+
560
+ Core::hresult result = implementation->Add(_a, _b, _result);
561
+
562
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
563
+ writer.Number<Core::hresult>(result);
564
+ writer.Number<uint32_t>(_result);
565
+ }
566
+ , nullptr
567
+ }; // QualityAssuranceBenchmarkPayloadStubMethods
568
+
569
+ // -----------------------------------------------------------------
570
+ // PROXIES
571
+ // -----------------------------------------------------------------
572
+
573
+ //
574
+ // RPC::IIteratorTypeInstance_05353879ce17b341 interface proxy definitions
575
+ //
576
+ // Methods:
577
+ // (0) virtual bool Next(QualityAssurance::IBenchmarkPayload::PayloadType&) = 0
578
+ // (1) virtual bool Previous(QualityAssurance::IBenchmarkPayload::PayloadType&) = 0
579
+ // (2) virtual void Reset(const uint32_t) = 0
580
+ // (3) virtual bool IsValid() const = 0
581
+ // (4) virtual uint32_t Count() const = 0
582
+ // (5) virtual QualityAssurance::IBenchmarkPayload::PayloadType Current() const = 0
583
+ //
584
+
585
+ class RPCIteratorTypeInstance_05353879ce17b341Proxy final : public ProxyStub::UnknownProxyType<RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>> {
586
+ public:
587
+ RPCIteratorTypeInstance_05353879ce17b341Proxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
588
+ : BaseClass(channel, implementation, otherSideInformed)
589
+ {
590
+ }
591
+
592
+ bool Next(QualityAssurance::IBenchmarkPayload::PayloadType& _info) override
593
+ {
594
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
595
+
596
+ bool result{};
597
+
598
+ const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
599
+ if (hresult == Core::ERROR_NONE) {
600
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
601
+ result = reader.Boolean();
602
+ _info = reader.Number<QualityAssurance::IBenchmarkPayload::PayloadType>();
603
+ } else {
604
+ ASSERT((hresult & COM_ERROR) != 0);
605
+ }
606
+
607
+ return (result);
608
+ }
609
+
610
+ bool Previous(QualityAssurance::IBenchmarkPayload::PayloadType& _info) override
611
+ {
612
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
613
+
614
+ bool result{};
615
+
616
+ const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
617
+ if (hresult == Core::ERROR_NONE) {
618
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
619
+ result = reader.Boolean();
620
+ _info = reader.Number<QualityAssurance::IBenchmarkPayload::PayloadType>();
621
+ } else {
622
+ ASSERT((hresult & COM_ERROR) != 0);
623
+ }
624
+
625
+ return (result);
626
+ }
627
+
628
+ void Reset(const uint32_t _position) override
629
+ {
630
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
631
+
632
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
633
+ writer.Number<uint32_t>(_position);
634
+
635
+ static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
636
+ }
637
+
638
+ bool IsValid() const override
639
+ {
640
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
641
+
642
+ bool result{};
643
+
644
+ const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
645
+ if (hresult == Core::ERROR_NONE) {
646
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
647
+ result = reader.Boolean();
648
+ } else {
649
+ ASSERT((hresult & COM_ERROR) != 0);
650
+ }
651
+
652
+ return (result);
653
+ }
654
+
655
+ uint32_t Count() const override
656
+ {
657
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(4));
658
+
659
+ uint32_t result{};
660
+
661
+ const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
662
+ if (hresult == Core::ERROR_NONE) {
663
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
664
+ result = reader.Number<uint32_t>();
665
+ } else {
666
+ ASSERT((hresult & COM_ERROR) != 0);
667
+ }
668
+
669
+ return (result);
670
+ }
671
+
672
+ QualityAssurance::IBenchmarkPayload::PayloadType Current() const override
673
+ {
674
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(5));
675
+
676
+ QualityAssurance::IBenchmarkPayload::PayloadType result{};
677
+
678
+ const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
679
+ if (hresult == Core::ERROR_NONE) {
680
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
681
+ result = reader.Number<QualityAssurance::IBenchmarkPayload::PayloadType>();
682
+ } else {
683
+ ASSERT((hresult & COM_ERROR) != 0);
684
+ }
685
+
686
+ return (result);
687
+ }
688
+
689
+ }; // class RPCIteratorTypeInstance_05353879ce17b341Proxy
690
+
691
+ //
692
+ // QualityAssurance::IBenchmarkPayload interface proxy definitions
693
+ //
694
+ // Methods:
695
+ // (0) virtual Core::hresult GetPayloadTypes(QualityAssurance::IBenchmarkPayload::IPayloadTypeIterator*&) const = 0
696
+ // (1) virtual Core::hresult SendUint16(const uint16_t) = 0
697
+ // (2) virtual Core::hresult SendUint32(const uint32_t) = 0
698
+ // (3) virtual Core::hresult SendUint64(const uint64_t) = 0
699
+ // (4) virtual Core::hresult SendBool(const bool) = 0
700
+ // (5) virtual Core::hresult SendFloat(const float) = 0
701
+ // (6) virtual Core::hresult SendDouble(const double) = 0
702
+ // (7) virtual Core::hresult SendString(const string&) = 0
703
+ // (8) virtual Core::hresult SendSampleData(const QualityAssurance::IBenchmarkPayload::SampleData&) = 0
704
+ // (9) virtual Core::hresult SendNoPayload() = 0
705
+ // (10) virtual Core::hresult SendBuffer(const uint16_t, const uint8_t*) = 0
706
+ // (11) virtual Core::hresult SendUint32Vector(const std::vector<uint32_t>&) = 0
707
+ // (12) virtual Core::hresult SendReceiveUint16(const uint16_t, uint16_t&) const = 0
708
+ // (13) virtual Core::hresult SendReceiveUint32(const uint32_t, uint32_t&) const = 0
709
+ // (14) virtual Core::hresult SendReceiveUint64(const uint64_t, uint64_t&) const = 0
710
+ // (15) virtual Core::hresult SendReceiveBool(const bool, bool&) const = 0
711
+ // (16) virtual Core::hresult SendReceiveFloat(const float, float&) const = 0
712
+ // (17) virtual Core::hresult SendReceiveDouble(const double, double&) const = 0
713
+ // (18) virtual Core::hresult SendReceiveString(const string&, string&) const = 0
714
+ // (19) virtual Core::hresult SendReceiveSampleData(const QualityAssurance::IBenchmarkPayload::SampleData&, QualityAssurance::IBenchmarkPayload::SampleData&) const = 0
715
+ // (20) virtual Core::hresult SendReceiveBuffer(uint16_t&, uint8_t*) const = 0
716
+ // (21) virtual Core::hresult SendReceiveUint32Vector(const std::vector<uint32_t>&, std::vector<uint32_t>&) const = 0
717
+ // (22) virtual Core::hresult Add(const uint32_t, const uint32_t, uint32_t&) const = 0
718
+ //
719
+
720
+ class QualityAssuranceBenchmarkPayloadProxy final : public ProxyStub::UnknownProxyType<QualityAssurance::IBenchmarkPayload> {
721
+ public:
722
+ QualityAssuranceBenchmarkPayloadProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
723
+ : BaseClass(channel, implementation, otherSideInformed)
724
+ {
725
+ }
726
+
727
+ Core::hresult GetPayloadTypes(QualityAssurance::IBenchmarkPayload::IPayloadTypeIterator*& _types) const override
728
+ {
729
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
730
+
731
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
732
+ if (hresult == Core::ERROR_NONE) {
733
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
734
+ hresult = reader.Number<Core::hresult>();
735
+ _types = reinterpret_cast<QualityAssurance::IBenchmarkPayload::IPayloadTypeIterator*>(static_cast<const ProxyStub::UnknownProxy&>(*this).Interface(reader.Number<Core::instance_id>(), QualityAssurance::IBenchmarkPayload::IPayloadTypeIterator::ID));
736
+ } else {
737
+ ASSERT((hresult & COM_ERROR) != 0);
738
+ }
739
+
740
+ return (hresult);
741
+ }
742
+
743
+ Core::hresult SendUint16(const uint16_t _value) override
744
+ {
745
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
746
+
747
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
748
+ writer.Number<uint16_t>(_value);
749
+
750
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
751
+ if (hresult == Core::ERROR_NONE) {
752
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
753
+ hresult = reader.Number<Core::hresult>();
754
+ } else {
755
+ ASSERT((hresult & COM_ERROR) != 0);
756
+ }
757
+
758
+ return (hresult);
759
+ }
760
+
761
+ Core::hresult SendUint32(const uint32_t _value) override
762
+ {
763
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
764
+
765
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
766
+ writer.Number<uint32_t>(_value);
767
+
768
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
769
+ if (hresult == Core::ERROR_NONE) {
770
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
771
+ hresult = reader.Number<Core::hresult>();
772
+ } else {
773
+ ASSERT((hresult & COM_ERROR) != 0);
774
+ }
775
+
776
+ return (hresult);
777
+ }
778
+
779
+ Core::hresult SendUint64(const uint64_t _value) override
780
+ {
781
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
782
+
783
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
784
+ writer.Number<uint64_t>(_value);
785
+
786
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
787
+ if (hresult == Core::ERROR_NONE) {
788
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
789
+ hresult = reader.Number<Core::hresult>();
790
+ } else {
791
+ ASSERT((hresult & COM_ERROR) != 0);
792
+ }
793
+
794
+ return (hresult);
795
+ }
796
+
797
+ Core::hresult SendBool(const bool _value) override
798
+ {
799
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(4));
800
+
801
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
802
+ writer.Boolean(_value);
803
+
804
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
805
+ if (hresult == Core::ERROR_NONE) {
806
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
807
+ hresult = reader.Number<Core::hresult>();
808
+ } else {
809
+ ASSERT((hresult & COM_ERROR) != 0);
810
+ }
811
+
812
+ return (hresult);
813
+ }
814
+
815
+ Core::hresult SendFloat(const float _value) override
816
+ {
817
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(5));
818
+
819
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
820
+ writer.Number<float>(_value);
821
+
822
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
823
+ if (hresult == Core::ERROR_NONE) {
824
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
825
+ hresult = reader.Number<Core::hresult>();
826
+ } else {
827
+ ASSERT((hresult & COM_ERROR) != 0);
828
+ }
829
+
830
+ return (hresult);
831
+ }
832
+
833
+ Core::hresult SendDouble(const double _value) override
834
+ {
835
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(6));
836
+
837
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
838
+ writer.Number<double>(_value);
839
+
840
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
841
+ if (hresult == Core::ERROR_NONE) {
842
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
843
+ hresult = reader.Number<Core::hresult>();
844
+ } else {
845
+ ASSERT((hresult & COM_ERROR) != 0);
846
+ }
847
+
848
+ return (hresult);
849
+ }
850
+
851
+ Core::hresult SendString(const string& _value) override
852
+ {
853
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(7));
854
+
855
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
856
+ writer.Text(_value);
857
+
858
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
859
+ if (hresult == Core::ERROR_NONE) {
860
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
861
+ hresult = reader.Number<Core::hresult>();
862
+ } else {
863
+ ASSERT((hresult & COM_ERROR) != 0);
864
+ }
865
+
866
+ return (hresult);
867
+ }
868
+
869
+ Core::hresult SendSampleData(const QualityAssurance::IBenchmarkPayload::SampleData& _data) override
870
+ {
871
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(8));
872
+
873
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
874
+ writer.Number<uint32_t>(_data.id);
875
+ writer.Number<uint32_t>(_data.value);
876
+ writer.Text(_data.name);
877
+
878
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
879
+ if (hresult == Core::ERROR_NONE) {
880
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
881
+ hresult = reader.Number<Core::hresult>();
882
+ } else {
883
+ ASSERT((hresult & COM_ERROR) != 0);
884
+ }
885
+
886
+ return (hresult);
887
+ }
888
+
889
+ Core::hresult SendNoPayload() override
890
+ {
891
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(9));
892
+
893
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
894
+ if (hresult == Core::ERROR_NONE) {
895
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
896
+ hresult = reader.Number<Core::hresult>();
897
+ } else {
898
+ ASSERT((hresult & COM_ERROR) != 0);
899
+ }
900
+
901
+ return (hresult);
902
+ }
903
+
904
+ Core::hresult SendBuffer(const uint16_t _bufferSize, const uint8_t* _buffer) override
905
+ {
906
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(10));
907
+
908
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
909
+ writer.Buffer<uint16_t>(_bufferSize, _buffer);
910
+
911
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
912
+ if (hresult == Core::ERROR_NONE) {
913
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
914
+ hresult = reader.Number<Core::hresult>();
915
+ } else {
916
+ ASSERT((hresult & COM_ERROR) != 0);
917
+ }
918
+
919
+ return (hresult);
920
+ }
921
+
922
+ Core::hresult SendUint32Vector(const std::vector<uint32_t>& _data) override
923
+ {
924
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(11));
925
+
926
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
927
+ writer.Number<uint16_t>(_data.size());
928
+ for (uint16_t i = 0; i < _data.size(); i++) {
929
+ writer.Number<uint32_t>(_data[i]);
930
+ }
931
+
932
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
933
+ if (hresult == Core::ERROR_NONE) {
934
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
935
+ hresult = reader.Number<Core::hresult>();
936
+ } else {
937
+ ASSERT((hresult & COM_ERROR) != 0);
938
+ }
939
+
940
+ return (hresult);
941
+ }
942
+
943
+ Core::hresult SendReceiveUint16(const uint16_t _input, uint16_t& _output) const override
944
+ {
945
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(12));
946
+
947
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
948
+ writer.Number<uint16_t>(_input);
949
+
950
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
951
+ if (hresult == Core::ERROR_NONE) {
952
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
953
+ hresult = reader.Number<Core::hresult>();
954
+ _output = reader.Number<uint16_t>();
955
+ } else {
956
+ ASSERT((hresult & COM_ERROR) != 0);
957
+ }
958
+
959
+ return (hresult);
960
+ }
961
+
962
+ Core::hresult SendReceiveUint32(const uint32_t _input, uint32_t& _output) const override
963
+ {
964
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(13));
965
+
966
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
967
+ writer.Number<uint32_t>(_input);
968
+
969
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
970
+ if (hresult == Core::ERROR_NONE) {
971
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
972
+ hresult = reader.Number<Core::hresult>();
973
+ _output = reader.Number<uint32_t>();
974
+ } else {
975
+ ASSERT((hresult & COM_ERROR) != 0);
976
+ }
977
+
978
+ return (hresult);
979
+ }
980
+
981
+ Core::hresult SendReceiveUint64(const uint64_t _input, uint64_t& _output) const override
982
+ {
983
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(14));
984
+
985
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
986
+ writer.Number<uint64_t>(_input);
987
+
988
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
989
+ if (hresult == Core::ERROR_NONE) {
990
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
991
+ hresult = reader.Number<Core::hresult>();
992
+ _output = reader.Number<uint64_t>();
993
+ } else {
994
+ ASSERT((hresult & COM_ERROR) != 0);
995
+ }
996
+
997
+ return (hresult);
998
+ }
999
+
1000
+ Core::hresult SendReceiveBool(const bool _input, bool& _output) const override
1001
+ {
1002
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(15));
1003
+
1004
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1005
+ writer.Boolean(_input);
1006
+
1007
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1008
+ if (hresult == Core::ERROR_NONE) {
1009
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1010
+ hresult = reader.Number<Core::hresult>();
1011
+ _output = reader.Boolean();
1012
+ } else {
1013
+ ASSERT((hresult & COM_ERROR) != 0);
1014
+ }
1015
+
1016
+ return (hresult);
1017
+ }
1018
+
1019
+ Core::hresult SendReceiveFloat(const float _input, float& _output) const override
1020
+ {
1021
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(16));
1022
+
1023
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1024
+ writer.Number<float>(_input);
1025
+
1026
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1027
+ if (hresult == Core::ERROR_NONE) {
1028
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1029
+ hresult = reader.Number<Core::hresult>();
1030
+ _output = reader.Number<float>();
1031
+ } else {
1032
+ ASSERT((hresult & COM_ERROR) != 0);
1033
+ }
1034
+
1035
+ return (hresult);
1036
+ }
1037
+
1038
+ Core::hresult SendReceiveDouble(const double _input, double& _output) const override
1039
+ {
1040
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(17));
1041
+
1042
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1043
+ writer.Number<double>(_input);
1044
+
1045
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1046
+ if (hresult == Core::ERROR_NONE) {
1047
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1048
+ hresult = reader.Number<Core::hresult>();
1049
+ _output = reader.Number<double>();
1050
+ } else {
1051
+ ASSERT((hresult & COM_ERROR) != 0);
1052
+ }
1053
+
1054
+ return (hresult);
1055
+ }
1056
+
1057
+ Core::hresult SendReceiveString(const string& _input, string& _output) const override
1058
+ {
1059
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(18));
1060
+
1061
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1062
+ writer.Text(_input);
1063
+
1064
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1065
+ if (hresult == Core::ERROR_NONE) {
1066
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1067
+ hresult = reader.Number<Core::hresult>();
1068
+ _output = reader.Text();
1069
+ } else {
1070
+ ASSERT((hresult & COM_ERROR) != 0);
1071
+ }
1072
+
1073
+ return (hresult);
1074
+ }
1075
+
1076
+ Core::hresult SendReceiveSampleData(const QualityAssurance::IBenchmarkPayload::SampleData& _input, QualityAssurance::IBenchmarkPayload::SampleData& _output) const override
1077
+ {
1078
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(19));
1079
+
1080
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1081
+ writer.Number<uint32_t>(_input.id);
1082
+ writer.Number<uint32_t>(_input.value);
1083
+ writer.Text(_input.name);
1084
+
1085
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1086
+ if (hresult == Core::ERROR_NONE) {
1087
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1088
+ hresult = reader.Number<Core::hresult>();
1089
+ _output.id = reader.Number<uint32_t>();
1090
+ _output.value = reader.Number<uint32_t>();
1091
+ _output.name = reader.Text();
1092
+ } else {
1093
+ ASSERT((hresult & COM_ERROR) != 0);
1094
+ }
1095
+
1096
+ return (hresult);
1097
+ }
1098
+
1099
+ Core::hresult SendReceiveBuffer(uint16_t& _bufferSize, uint8_t* _buffer) const override
1100
+ {
1101
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(20));
1102
+
1103
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1104
+ writer.Buffer<uint16_t>(_bufferSize, _buffer);
1105
+
1106
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1107
+ if (hresult == Core::ERROR_NONE) {
1108
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1109
+ hresult = reader.Number<Core::hresult>();
1110
+ reader.Buffer<uint16_t>(_bufferSize, _buffer);
1111
+ _bufferSize = reader.Number<uint16_t>();
1112
+ } else {
1113
+ ASSERT((hresult & COM_ERROR) != 0);
1114
+ }
1115
+
1116
+ return (hresult);
1117
+ }
1118
+
1119
+ Core::hresult SendReceiveUint32Vector(const std::vector<uint32_t>& _input, std::vector<uint32_t>& _output) const override
1120
+ {
1121
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(21));
1122
+
1123
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1124
+ writer.Number<uint16_t>(_input.size());
1125
+ for (uint16_t i = 0; i < _input.size(); i++) {
1126
+ writer.Number<uint32_t>(_input[i]);
1127
+ }
1128
+
1129
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1130
+ if (hresult == Core::ERROR_NONE) {
1131
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1132
+ hresult = reader.Number<Core::hresult>();
1133
+ uint16_t _outputSize{};
1134
+ _outputSize = reader.Number<uint16_t>();
1135
+ _output.reserve(_outputSize);
1136
+ for (uint16_t i = 0; i < _outputSize; i++) {
1137
+ uint32_t _outputItem{};
1138
+ _outputItem = reader.Number<uint32_t>();
1139
+ _output.push_back(std::move(_outputItem));
1140
+ }
1141
+ } else {
1142
+ ASSERT((hresult & COM_ERROR) != 0);
1143
+ }
1144
+
1145
+ return (hresult);
1146
+ }
1147
+
1148
+ Core::hresult Add(const uint32_t _a, const uint32_t _b, uint32_t& _result) const override
1149
+ {
1150
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(22));
1151
+
1152
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1153
+ writer.Number<uint32_t>(_a);
1154
+ writer.Number<uint32_t>(_b);
1155
+
1156
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1157
+ if (hresult == Core::ERROR_NONE) {
1158
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1159
+ hresult = reader.Number<Core::hresult>();
1160
+ _result = reader.Number<uint32_t>();
1161
+ } else {
1162
+ ASSERT((hresult & COM_ERROR) != 0);
1163
+ }
1164
+
1165
+ return (hresult);
1166
+ }
1167
+
1168
+ }; // class QualityAssuranceBenchmarkPayloadProxy
1169
+
1170
+ POP_WARNING()
1171
+ POP_WARNING()
1172
+
1173
+ // -----------------------------------------------------------------
1174
+ // REGISTRATION
1175
+ // -----------------------------------------------------------------
1176
+ namespace {
1177
+
1178
+ typedef ProxyStub::UnknownStubType<RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>, RPCIteratorTypeInstance_05353879ce17b341StubMethods> RPCIteratorTypeInstance_05353879ce17b341Stub;
1179
+ typedef ProxyStub::UnknownStubType<QualityAssurance::IBenchmarkPayload, QualityAssuranceBenchmarkPayloadStubMethods> QualityAssuranceBenchmarkPayloadStub;
1180
+
1181
+ static class Instantiation {
1182
+ public:
1183
+ Instantiation()
1184
+ {
1185
+ RPC::Administrator::Instance().Announce<RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>, RPCIteratorTypeInstance_05353879ce17b341Proxy, RPCIteratorTypeInstance_05353879ce17b341Stub>();
1186
+ RPC::Administrator::Instance().Announce<QualityAssurance::IBenchmarkPayload, QualityAssuranceBenchmarkPayloadProxy, QualityAssuranceBenchmarkPayloadStub>();
1187
+ }
1188
+ ~Instantiation()
1189
+ {
1190
+ RPC::Administrator::Instance().Recall<RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>>();
1191
+ RPC::Administrator::Instance().Recall<QualityAssurance::IBenchmarkPayload>();
1192
+ }
1193
+ } ProxyStubRegistration;
1194
+
1195
+ } // namespace
1196
+
1197
+ } // namespace ProxyStubs
1198
+
1199
+ }
Debug/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_TestPlugin.cpp CHANGED
@@ -0,0 +1,323 @@
1
+ //
2
+ // generated automatically from "ITestPlugin.h"
3
+ //
4
+ // implements COM-RPC proxy stubs for:
5
+ // - class QualityAssurance::ITestPlugin
6
+ // - class QualityAssurance::ITestPlugin::INotification
7
+ //
8
+
9
+ #include "Module.h"
10
+ #include "ITestPlugin.h"
11
+
12
+ #include <com/com.h>
13
+
14
+ namespace Thunder {
15
+
16
+ namespace ProxyStubs {
17
+
18
+ PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
19
+ PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
20
+
21
+ // -----------------------------------------------------------------
22
+ // STUBS
23
+ // -----------------------------------------------------------------
24
+
25
+ //
26
+ // QualityAssurance::ITestPlugin interface stub definitions
27
+ //
28
+ // Methods:
29
+ // (0) virtual Core::hresult Register(QualityAssurance::ITestPlugin::INotification*) = 0
30
+ // (1) virtual Core::hresult Unregister(QualityAssurance::ITestPlugin::INotification*) = 0
31
+ // (2) virtual Core::hresult Echo(const string&, string&) = 0
32
+ // (3) virtual Core::hresult Greet(const string&, string&) = 0
33
+ //
34
+
35
+ static ProxyStub::MethodHandler QualityAssuranceTestPluginStubMethods[] = {
36
+ // (0) virtual Core::hresult Register(QualityAssurance::ITestPlugin::INotification*) = 0
37
+ //
38
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
39
+ QualityAssurance::ITestPlugin* implementation = reinterpret_cast<QualityAssurance::ITestPlugin*>(message->Parameters().Implementation());
40
+ ASSERT(implementation != nullptr);
41
+
42
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
43
+ Core::instance_id _notificationInstanceId__ = reader.Number<Core::instance_id>();
44
+
45
+ QualityAssurance::ITestPlugin::INotification* _notification{};
46
+ ProxyStub::UnknownProxy* _notificationProxy__ = nullptr;
47
+ if (_notificationInstanceId__ != 0) {
48
+ _notificationProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _notificationInstanceId__, false, _notification);
49
+ ASSERT((_notification != nullptr) && (_notificationProxy__ != nullptr));
50
+ }
51
+
52
+ Core::hresult result = implementation->Register(_notification);
53
+
54
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
55
+ writer.Number<Core::hresult>(result);
56
+
57
+ if (_notificationProxy__ != nullptr) {
58
+ RPC::Administrator::Instance().Release(_notificationProxy__, message->Response());
59
+ }
60
+ },
61
+
62
+ // (1) virtual Core::hresult Unregister(QualityAssurance::ITestPlugin::INotification*) = 0
63
+ //
64
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
65
+ QualityAssurance::ITestPlugin* implementation = reinterpret_cast<QualityAssurance::ITestPlugin*>(message->Parameters().Implementation());
66
+ ASSERT(implementation != nullptr);
67
+
68
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
69
+ Core::instance_id _notificationInstanceId__ = reader.Number<Core::instance_id>();
70
+
71
+ QualityAssurance::ITestPlugin::INotification* _notification{};
72
+ ProxyStub::UnknownProxy* _notificationProxy__ = nullptr;
73
+ if (_notificationInstanceId__ != 0) {
74
+ _notificationProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _notificationInstanceId__, false, _notification);
75
+ ASSERT((_notification != nullptr) && (_notificationProxy__ != nullptr));
76
+ }
77
+
78
+ Core::hresult result = implementation->Unregister(_notification);
79
+
80
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
81
+ writer.Number<Core::hresult>(result);
82
+
83
+ if (_notificationProxy__ != nullptr) {
84
+ RPC::Administrator::Instance().Release(_notificationProxy__, message->Response());
85
+ }
86
+ },
87
+
88
+ // (2) virtual Core::hresult Echo(const string&, string&) = 0
89
+ //
90
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
91
+ QualityAssurance::ITestPlugin* implementation = reinterpret_cast<QualityAssurance::ITestPlugin*>(message->Parameters().Implementation());
92
+ ASSERT(implementation != nullptr);
93
+
94
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
95
+ const string _input = reader.Text();
96
+
97
+ string _output{};
98
+
99
+ Core::hresult result = implementation->Echo(static_cast<const string&>(_input), _output);
100
+
101
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
102
+ writer.Number<Core::hresult>(result);
103
+ writer.Text(_output);
104
+ },
105
+
106
+ // (3) virtual Core::hresult Greet(const string&, string&) = 0
107
+ //
108
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
109
+ QualityAssurance::ITestPlugin* implementation = reinterpret_cast<QualityAssurance::ITestPlugin*>(message->Parameters().Implementation());
110
+ ASSERT(implementation != nullptr);
111
+
112
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
113
+ const string _name = reader.Text();
114
+
115
+ string _message{};
116
+
117
+ Core::hresult result = implementation->Greet(static_cast<const string&>(_name), _message);
118
+
119
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
120
+ writer.Number<Core::hresult>(result);
121
+ writer.Text(_message);
122
+ }
123
+ , nullptr
124
+ }; // QualityAssuranceTestPluginStubMethods
125
+
126
+ //
127
+ // QualityAssurance::ITestPlugin::INotification interface stub definitions
128
+ //
129
+ // Methods:
130
+ // (0) virtual void OnGreeting(const string&) = 0
131
+ //
132
+
133
+ static ProxyStub::MethodHandler QualityAssuranceTestPluginNotificationStubMethods[] = {
134
+ // (0) virtual void OnGreeting(const string&) = 0
135
+ //
136
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
137
+ QualityAssurance::ITestPlugin::INotification* implementation = reinterpret_cast<QualityAssurance::ITestPlugin::INotification*>(message->Parameters().Implementation());
138
+ ASSERT(implementation != nullptr);
139
+
140
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
141
+ const string _message = reader.Text();
142
+
143
+ implementation->OnGreeting(static_cast<const string&>(_message));
144
+ }
145
+ , nullptr
146
+ }; // QualityAssuranceTestPluginNotificationStubMethods
147
+
148
+ // -----------------------------------------------------------------
149
+ // PROXIES
150
+ // -----------------------------------------------------------------
151
+
152
+ //
153
+ // QualityAssurance::ITestPlugin interface proxy definitions
154
+ //
155
+ // Methods:
156
+ // (0) virtual Core::hresult Register(QualityAssurance::ITestPlugin::INotification*) = 0
157
+ // (1) virtual Core::hresult Unregister(QualityAssurance::ITestPlugin::INotification*) = 0
158
+ // (2) virtual Core::hresult Echo(const string&, string&) = 0
159
+ // (3) virtual Core::hresult Greet(const string&, string&) = 0
160
+ //
161
+
162
+ class QualityAssuranceTestPluginProxy final : public ProxyStub::UnknownProxyType<QualityAssurance::ITestPlugin> {
163
+ public:
164
+ QualityAssuranceTestPluginProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
165
+ : BaseClass(channel, implementation, otherSideInformed)
166
+ {
167
+ }
168
+
169
+ Core::hresult Register(QualityAssurance::ITestPlugin::INotification* _notification) override
170
+ {
171
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
172
+
173
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
174
+ writer.Number<Core::instance_id>(RPC::instance_cast(_notification));
175
+
176
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
177
+ if (hresult == Core::ERROR_NONE) {
178
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
179
+ hresult = reader.Number<Core::hresult>();
180
+
181
+ _Complete(reader);
182
+ } else {
183
+ ASSERT((hresult & COM_ERROR) != 0);
184
+ }
185
+
186
+ return (hresult);
187
+ }
188
+
189
+ Core::hresult Unregister(QualityAssurance::ITestPlugin::INotification* _notification) override
190
+ {
191
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
192
+
193
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
194
+ writer.Number<Core::instance_id>(RPC::instance_cast(_notification));
195
+
196
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
197
+ if (hresult == Core::ERROR_NONE) {
198
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
199
+ hresult = reader.Number<Core::hresult>();
200
+
201
+ _Complete(reader);
202
+ } else {
203
+ ASSERT((hresult & COM_ERROR) != 0);
204
+ }
205
+
206
+ return (hresult);
207
+ }
208
+
209
+ Core::hresult Echo(const string& _input, string& _output) override
210
+ {
211
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
212
+
213
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
214
+ writer.Text(_input);
215
+
216
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
217
+ if (hresult == Core::ERROR_NONE) {
218
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
219
+ hresult = reader.Number<Core::hresult>();
220
+ _output = reader.Text();
221
+ } else {
222
+ ASSERT((hresult & COM_ERROR) != 0);
223
+ }
224
+
225
+ return (hresult);
226
+ }
227
+
228
+ Core::hresult Greet(const string& _name, string& _message) override
229
+ {
230
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
231
+
232
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
233
+ writer.Text(_name);
234
+
235
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
236
+ if (hresult == Core::ERROR_NONE) {
237
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
238
+ hresult = reader.Number<Core::hresult>();
239
+ _message = reader.Text();
240
+ } else {
241
+ ASSERT((hresult & COM_ERROR) != 0);
242
+ }
243
+
244
+ return (hresult);
245
+ }
246
+
247
+ private:
248
+ uint32_t _Complete(RPC::Data::Frame::Reader& reader) const
249
+ {
250
+ uint32_t result = Core::ERROR_NONE;
251
+
252
+ while (reader.HasData() == true) {
253
+ const Core::instance_id implementation = reader.Number<Core::instance_id>();
254
+ ASSERT(implementation != 0);
255
+
256
+ const uint32_t id = reader.Number<uint32_t>();
257
+ const RPC::Data::Output::mode how = reader.Number<RPC::Data::Output::mode>();
258
+
259
+ result = static_cast<const ProxyStub::UnknownProxy&>(*this).Complete(implementation, id, how);
260
+ if (result != Core::ERROR_NONE) { return (COM_ERROR | result); }
261
+ }
262
+
263
+ return (result);
264
+ }
265
+
266
+ }; // class QualityAssuranceTestPluginProxy
267
+
268
+ //
269
+ // QualityAssurance::ITestPlugin::INotification interface proxy definitions
270
+ //
271
+ // Methods:
272
+ // (0) virtual void OnGreeting(const string&) = 0
273
+ //
274
+
275
+ class QualityAssuranceTestPluginNotificationProxy final : public ProxyStub::UnknownProxyType<QualityAssurance::ITestPlugin::INotification> {
276
+ public:
277
+ QualityAssuranceTestPluginNotificationProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
278
+ : BaseClass(channel, implementation, otherSideInformed)
279
+ {
280
+ }
281
+
282
+ void OnGreeting(const string& _message) override
283
+ {
284
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
285
+
286
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
287
+ writer.Text(_message);
288
+
289
+ static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
290
+ }
291
+
292
+ }; // class QualityAssuranceTestPluginNotificationProxy
293
+
294
+ POP_WARNING()
295
+ POP_WARNING()
296
+
297
+ // -----------------------------------------------------------------
298
+ // REGISTRATION
299
+ // -----------------------------------------------------------------
300
+ namespace {
301
+
302
+ typedef ProxyStub::UnknownStubType<QualityAssurance::ITestPlugin, QualityAssuranceTestPluginStubMethods> QualityAssuranceTestPluginStub;
303
+ typedef ProxyStub::UnknownStubType<QualityAssurance::ITestPlugin::INotification, QualityAssuranceTestPluginNotificationStubMethods> QualityAssuranceTestPluginNotificationStub;
304
+
305
+ static class Instantiation {
306
+ public:
307
+ Instantiation()
308
+ {
309
+ RPC::Administrator::Instance().Announce<QualityAssurance::ITestPlugin, QualityAssuranceTestPluginProxy, QualityAssuranceTestPluginStub>();
310
+ RPC::Administrator::Instance().Announce<QualityAssurance::ITestPlugin::INotification, QualityAssuranceTestPluginNotificationProxy, QualityAssuranceTestPluginNotificationStub>();
311
+ }
312
+ ~Instantiation()
313
+ {
314
+ RPC::Administrator::Instance().Recall<QualityAssurance::ITestPlugin>();
315
+ RPC::Administrator::Instance().Recall<QualityAssurance::ITestPlugin::INotification>();
316
+ }
317
+ } ProxyStubRegistration;
318
+
319
+ } // namespace
320
+
321
+ } // namespace ProxyStubs
322
+
323
+ }
Release/ThunderInterfaces/interfaces/generated/ProxyStubs_Bluetooth.cpp CHANGED
@@ -1,55 +0,0 @@
1
- //
2
- // generated automatically from "IBluetooth.h"
3
- //
4
- // implements COM-RPC proxy stubs for:
5
- //
6
- // secure code enabled:
7
- // - instance verification enabled
8
- // - range verification enabled
9
- // - frame coherency verification enabled
10
- //
11
-
12
- #include "Module.h"
13
- #include "IBluetooth.h"
14
-
15
- #include <com/com.h>
16
-
17
- namespace Thunder {
18
-
19
- namespace ProxyStubs {
20
-
21
- PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
22
- PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
23
-
24
- // -----------------------------------------------------------------
25
- // STUBS
26
- // -----------------------------------------------------------------
27
-
28
- // -----------------------------------------------------------------
29
- // PROXIES
30
- // -----------------------------------------------------------------
31
-
32
- POP_WARNING()
33
- POP_WARNING()
34
-
35
- // -----------------------------------------------------------------
36
- // REGISTRATION
37
- // -----------------------------------------------------------------
38
- namespace {
39
-
40
-
41
- static class Instantiation {
42
- public:
43
- Instantiation()
44
- {
45
- }
46
- ~Instantiation()
47
- {
48
- }
49
- } ProxyStubRegistration;
50
-
51
- } // namespace
52
-
53
- } // namespace ProxyStubs
54
-
55
- }
Release/ThunderInterfaces/interfaces/generated/ProxyStubs_Capture.cpp CHANGED
@@ -1,55 +0,0 @@
1
- //
2
- // generated automatically from "ICapture.h"
3
- //
4
- // implements COM-RPC proxy stubs for:
5
- //
6
- // secure code enabled:
7
- // - instance verification enabled
8
- // - range verification enabled
9
- // - frame coherency verification enabled
10
- //
11
-
12
- #include "Module.h"
13
- #include "ICapture.h"
14
-
15
- #include <com/com.h>
16
-
17
- namespace Thunder {
18
-
19
- namespace ProxyStubs {
20
-
21
- PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
22
- PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
23
-
24
- // -----------------------------------------------------------------
25
- // STUBS
26
- // -----------------------------------------------------------------
27
-
28
- // -----------------------------------------------------------------
29
- // PROXIES
30
- // -----------------------------------------------------------------
31
-
32
- POP_WARNING()
33
- POP_WARNING()
34
-
35
- // -----------------------------------------------------------------
36
- // REGISTRATION
37
- // -----------------------------------------------------------------
38
- namespace {
39
-
40
-
41
- static class Instantiation {
42
- public:
43
- Instantiation()
44
- {
45
- }
46
- ~Instantiation()
47
- {
48
- }
49
- } ProxyStubRegistration;
50
-
51
- } // namespace
52
-
53
- } // namespace ProxyStubs
54
-
55
- }
Release/ThunderInterfaces/interfaces/generated/ProxyStubs_IPNetwork.cpp CHANGED
@@ -1,55 +0,0 @@
1
- //
2
- // generated automatically from "IIPNetwork.h"
3
- //
4
- // implements COM-RPC proxy stubs for:
5
- //
6
- // secure code enabled:
7
- // - instance verification enabled
8
- // - range verification enabled
9
- // - frame coherency verification enabled
10
- //
11
-
12
- #include "Module.h"
13
- #include "IIPNetwork.h"
14
-
15
- #include <com/com.h>
16
-
17
- namespace Thunder {
18
-
19
- namespace ProxyStubs {
20
-
21
- PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
22
- PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
23
-
24
- // -----------------------------------------------------------------
25
- // STUBS
26
- // -----------------------------------------------------------------
27
-
28
- // -----------------------------------------------------------------
29
- // PROXIES
30
- // -----------------------------------------------------------------
31
-
32
- POP_WARNING()
33
- POP_WARNING()
34
-
35
- // -----------------------------------------------------------------
36
- // REGISTRATION
37
- // -----------------------------------------------------------------
38
- namespace {
39
-
40
-
41
- static class Instantiation {
42
- public:
43
- Instantiation()
44
- {
45
- }
46
- ~Instantiation()
47
- {
48
- }
49
- } ProxyStubRegistration;
50
-
51
- } // namespace
52
-
53
- } // namespace ProxyStubs
54
-
55
- }
Release/ThunderInterfaces/interfaces/generated/ProxyStubs_MessageControl.cpp CHANGED
@@ -1,1088 +0,0 @@
1
- //
2
- // generated automatically from "IMessageControl.h"
3
- //
4
- // implements COM-RPC proxy stubs for:
5
- // - class RPC::IIteratorType<typename ELEMENT, const uint32_t INTERFACE_ID> [with ELEMENT = Exchange::IMessageControl::Control, INTERFACE_ID = Exchange::ID_MESSAGE_CONTROL_ITERATOR] [[iterator]]
6
- // - class RPC::IIteratorType<typename ELEMENT, const uint32_t INTERFACE_ID> [with ELEMENT = string, INTERFACE_ID = RPC::ID_STRINGITERATOR] [[iterator]]
7
- // - class Exchange::IMessageControl
8
- //
9
- // secure code enabled:
10
- // - instance verification enabled
11
- // - range verification enabled
12
- // - frame coherency verification enabled
13
- //
14
-
15
- #include "Module.h"
16
- #include "IMessageControl.h"
17
-
18
- #include <com/com.h>
19
-
20
- namespace Thunder {
21
-
22
- namespace ProxyStubs {
23
-
24
- PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
25
- PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
26
-
27
- // -----------------------------------------------------------------
28
- // STUBS
29
- // -----------------------------------------------------------------
30
-
31
- //
32
- // RPC::IIteratorTypeInstance_675a6ff7e5671893 interface stub definitions
33
- //
34
- // Methods:
35
- // (0) virtual bool Next(Exchange::IMessageControl::Control&) = 0
36
- // (1) virtual bool Previous(Exchange::IMessageControl::Control&) = 0
37
- // (2) virtual void Reset(const uint32_t) = 0
38
- // (3) virtual bool IsValid() const = 0
39
- // (4) virtual uint32_t Count() const = 0
40
- // (5) virtual Exchange::IMessageControl::Control Current() const = 0
41
- //
42
-
43
- static ProxyStub::MethodHandler RPCIteratorTypeInstance_675a6ff7e5671893StubMethods[] = {
44
- // (0) virtual bool Next(Exchange::IMessageControl::Control&) = 0
45
- //
46
- [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
47
- Core::hresult hresult = Core::ERROR_NONE;
48
-
49
- hresult = [&]() -> Core::hresult {
50
- using interface = RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>;
51
-
52
- if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
53
-
54
- interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
55
- ASSERT(implementation != nullptr);
56
- if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
57
-
58
- Exchange::IMessageControl::Control _info{};
59
-
60
- bool result = implementation->Next(_info);
61
-
62
- RPC::Data::Frame::Writer writer(message->Response().Writer());
63
- writer.Boolean(result);
64
- writer.Number<Exchange::IMessageControl::messagetype>(_info.type);
65
- writer.Text(_info.category);
66
- writer.Text(_info.module);
67
- writer.Boolean(_info.enabled);
68
-
69
- return (Core::ERROR_NONE);
70
- } ();
71
-
72
- if (hresult != Core::ERROR_NONE) {
73
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>::ID, 0, hresult);
74
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
75
- }
76
- },
77
-
78
- // (1) virtual bool Previous(Exchange::IMessageControl::Control&) = 0
79
- //
80
- [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
81
- Core::hresult hresult = Core::ERROR_NONE;
82
-
83
- hresult = [&]() -> Core::hresult {
84
- using interface = RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>;
85
-
86
- if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
87
-
88
- interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
89
- ASSERT(implementation != nullptr);
90
- if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
91
-
92
- Exchange::IMessageControl::Control _info{};
93
-
94
- bool result = implementation->Previous(_info);
95
-
96
- RPC::Data::Frame::Writer writer(message->Response().Writer());
97
- writer.Boolean(result);
98
- writer.Number<Exchange::IMessageControl::messagetype>(_info.type);
99
- writer.Text(_info.category);
100
- writer.Text(_info.module);
101
- writer.Boolean(_info.enabled);
102
-
103
- return (Core::ERROR_NONE);
104
- } ();
105
-
106
- if (hresult != Core::ERROR_NONE) {
107
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>::ID, 1, hresult);
108
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
109
- }
110
- },
111
-
112
- // (2) virtual void Reset(const uint32_t) = 0
113
- //
114
- [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
115
- Core::hresult hresult = Core::ERROR_NONE;
116
-
117
- hresult = [&]() -> Core::hresult {
118
- using interface = RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>;
119
-
120
- if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
121
-
122
- interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
123
- ASSERT(implementation != nullptr);
124
- if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
125
-
126
- RPC::Data::Frame::Reader reader(message->Parameters().Reader());
127
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
128
- const uint32_t _position = reader.Number<uint32_t>();
129
-
130
- implementation->Reset(_position);
131
-
132
- return (Core::ERROR_NONE);
133
- } ();
134
-
135
- if (hresult != Core::ERROR_NONE) {
136
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>::ID, 2, hresult);
137
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
138
- }
139
- },
140
-
141
- // (3) virtual bool IsValid() const = 0
142
- //
143
- [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
144
- Core::hresult hresult = Core::ERROR_NONE;
145
-
146
- hresult = [&]() -> Core::hresult {
147
- using interface = RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>;
148
-
149
- if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
150
-
151
- const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
152
- ASSERT(implementation != nullptr);
153
- if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
154
-
155
- bool result = implementation->IsValid();
156
-
157
- RPC::Data::Frame::Writer writer(message->Response().Writer());
158
- writer.Boolean(result);
159
-
160
- return (Core::ERROR_NONE);
161
- } ();
162
-
163
- if (hresult != Core::ERROR_NONE) {
164
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>::ID, 3, hresult);
165
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
166
- }
167
- },
168
-
169
- // (4) virtual uint32_t Count() const = 0
170
- //
171
- [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
172
- Core::hresult hresult = Core::ERROR_NONE;
173
-
174
- hresult = [&]() -> Core::hresult {
175
- using interface = RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>;
176
-
177
- if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
178
-
179
- const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
180
- ASSERT(implementation != nullptr);
181
- if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
182
-
183
- uint32_t result = implementation->Count();
184
-
185
- RPC::Data::Frame::Writer writer(message->Response().Writer());
186
- writer.Number<uint32_t>(result);
187
-
188
- return (Core::ERROR_NONE);
189
- } ();
190
-
191
- if (hresult != Core::ERROR_NONE) {
192
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>::ID, 4, hresult);
193
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
194
- }
195
- },
196
-
197
- // (5) virtual Exchange::IMessageControl::Control Current() const = 0
198
- //
199
- [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
200
- Core::hresult hresult = Core::ERROR_NONE;
201
-
202
- hresult = [&]() -> Core::hresult {
203
- using interface = RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>;
204
-
205
- if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
206
-
207
- const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
208
- ASSERT(implementation != nullptr);
209
- if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
210
-
211
- Exchange::IMessageControl::Control result = implementation->Current();
212
-
213
- RPC::Data::Frame::Writer writer(message->Response().Writer());
214
- writer.Number<Exchange::IMessageControl::messagetype>(result.type);
215
- writer.Text(result.category);
216
- writer.Text(result.module);
217
- writer.Boolean(result.enabled);
218
-
219
- return (Core::ERROR_NONE);
220
- } ();
221
-
222
- if (hresult != Core::ERROR_NONE) {
223
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>::ID, 5, hresult);
224
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
225
- }
226
- }
227
- , nullptr
228
- }; // RPCIteratorTypeInstance_675a6ff7e5671893StubMethods
229
-
230
- //
231
- // RPC::IIteratorTypeInstance_b3acff3685df4032 interface stub definitions
232
- //
233
- // Methods:
234
- // (0) virtual bool Next(string&) = 0
235
- // (1) virtual bool Previous(string&) = 0
236
- // (2) virtual void Reset(const uint32_t) = 0
237
- // (3) virtual bool IsValid() const = 0
238
- // (4) virtual uint32_t Count() const = 0
239
- // (5) virtual string Current() const = 0
240
- //
241
-
242
- static ProxyStub::MethodHandler RPCIteratorTypeInstance_b3acff3685df4032StubMethods[] = {
243
- // (0) virtual bool Next(string&) = 0
244
- //
245
- [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
246
- Core::hresult hresult = Core::ERROR_NONE;
247
-
248
- hresult = [&]() -> Core::hresult {
249
- using interface = RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>;
250
-
251
- if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
252
-
253
- interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
254
- ASSERT(implementation != nullptr);
255
- if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
256
-
257
- string _info{};
258
-
259
- bool result = implementation->Next(_info);
260
-
261
- RPC::Data::Frame::Writer writer(message->Response().Writer());
262
- writer.Boolean(result);
263
- writer.Text(_info);
264
-
265
- return (Core::ERROR_NONE);
266
- } ();
267
-
268
- if (hresult != Core::ERROR_NONE) {
269
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>::ID, 0, hresult);
270
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
271
- }
272
- },
273
-
274
- // (1) virtual bool Previous(string&) = 0
275
- //
276
- [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
277
- Core::hresult hresult = Core::ERROR_NONE;
278
-
279
- hresult = [&]() -> Core::hresult {
280
- using interface = RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>;
281
-
282
- if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
283
-
284
- interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
285
- ASSERT(implementation != nullptr);
286
- if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
287
-
288
- string _info{};
289
-
290
- bool result = implementation->Previous(_info);
291
-
292
- RPC::Data::Frame::Writer writer(message->Response().Writer());
293
- writer.Boolean(result);
294
- writer.Text(_info);
295
-
296
- return (Core::ERROR_NONE);
297
- } ();
298
-
299
- if (hresult != Core::ERROR_NONE) {
300
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>::ID, 1, hresult);
301
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
302
- }
303
- },
304
-
305
- // (2) virtual void Reset(const uint32_t) = 0
306
- //
307
- [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
308
- Core::hresult hresult = Core::ERROR_NONE;
309
-
310
- hresult = [&]() -> Core::hresult {
311
- using interface = RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>;
312
-
313
- if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
314
-
315
- interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
316
- ASSERT(implementation != nullptr);
317
- if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
318
-
319
- RPC::Data::Frame::Reader reader(message->Parameters().Reader());
320
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
321
- const uint32_t _position = reader.Number<uint32_t>();
322
-
323
- implementation->Reset(_position);
324
-
325
- return (Core::ERROR_NONE);
326
- } ();
327
-
328
- if (hresult != Core::ERROR_NONE) {
329
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>::ID, 2, hresult);
330
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
331
- }
332
- },
333
-
334
- // (3) virtual bool IsValid() const = 0
335
- //
336
- [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
337
- Core::hresult hresult = Core::ERROR_NONE;
338
-
339
- hresult = [&]() -> Core::hresult {
340
- using interface = RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>;
341
-
342
- if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
343
-
344
- const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
345
- ASSERT(implementation != nullptr);
346
- if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
347
-
348
- bool result = implementation->IsValid();
349
-
350
- RPC::Data::Frame::Writer writer(message->Response().Writer());
351
- writer.Boolean(result);
352
-
353
- return (Core::ERROR_NONE);
354
- } ();
355
-
356
- if (hresult != Core::ERROR_NONE) {
357
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>::ID, 3, hresult);
358
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
359
- }
360
- },
361
-
362
- // (4) virtual uint32_t Count() const = 0
363
- //
364
- [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
365
- Core::hresult hresult = Core::ERROR_NONE;
366
-
367
- hresult = [&]() -> Core::hresult {
368
- using interface = RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>;
369
-
370
- if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
371
-
372
- const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
373
- ASSERT(implementation != nullptr);
374
- if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
375
-
376
- uint32_t result = implementation->Count();
377
-
378
- RPC::Data::Frame::Writer writer(message->Response().Writer());
379
- writer.Number<uint32_t>(result);
380
-
381
- return (Core::ERROR_NONE);
382
- } ();
383
-
384
- if (hresult != Core::ERROR_NONE) {
385
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>::ID, 4, hresult);
386
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
387
- }
388
- },
389
-
390
- // (5) virtual string Current() const = 0
391
- //
392
- [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
393
- Core::hresult hresult = Core::ERROR_NONE;
394
-
395
- hresult = [&]() -> Core::hresult {
396
- using interface = RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>;
397
-
398
- if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
399
-
400
- const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
401
- ASSERT(implementation != nullptr);
402
- if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
403
-
404
- string result = implementation->Current();
405
-
406
- RPC::Data::Frame::Writer writer(message->Response().Writer());
407
- writer.Text(result);
408
-
409
- return (Core::ERROR_NONE);
410
- } ();
411
-
412
- if (hresult != Core::ERROR_NONE) {
413
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>::ID, 5, hresult);
414
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
415
- }
416
- }
417
- , nullptr
418
- }; // RPCIteratorTypeInstance_b3acff3685df4032StubMethods
419
-
420
- //
421
- // Exchange::IMessageControl interface stub definitions
422
- //
423
- // Methods:
424
- // (0) virtual Core::hresult Enable(const Exchange::IMessageControl::messagetype, const string&, const string&, const bool) = 0
425
- // (1) virtual Core::hresult Modules(Exchange::IMessageControl::IStringIterator*&) const = 0
426
- // (2) virtual Core::hresult Controls(const string&, Exchange::IMessageControl::IControlIterator*&) const = 0
427
- //
428
-
429
- static ProxyStub::MethodHandler ExchangeMessageControlStubMethods[] = {
430
- // (0) virtual Core::hresult Enable(const Exchange::IMessageControl::messagetype, const string&, const string&, const bool) = 0
431
- //
432
- [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
433
- Core::hresult hresult = Core::ERROR_NONE;
434
-
435
- hresult = [&]() -> Core::hresult {
436
- if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
437
-
438
- Exchange::IMessageControl* implementation = reinterpret_cast<Exchange::IMessageControl*>(message->Parameters().Implementation());
439
- ASSERT(implementation != nullptr);
440
- if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), Exchange::IMessageControl::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
441
-
442
- RPC::Data::Frame::Reader reader(message->Parameters().Reader());
443
- if (reader.Length() < (Core::RealSize<Exchange::IMessageControl::messagetype>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
444
- const Exchange::IMessageControl::messagetype _type = reader.Number<Exchange::IMessageControl::messagetype>();
445
- if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
446
- const uint16_t _categoryPeekedLen__ = reader.PeekNumber<uint16_t>();
447
- if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _categoryPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
448
- const string _category = reader.Text();
449
- if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
450
- const uint16_t _modulePeekedLen__ = reader.PeekNumber<uint16_t>();
451
- if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _modulePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
452
- const string _module = reader.Text();
453
- if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
454
- const bool _enabled = reader.Boolean();
455
-
456
- Core::hresult result = implementation->Enable(_type, static_cast<const string&>(_category), static_cast<const string&>(_module), _enabled);
457
-
458
- RPC::Data::Frame::Writer writer(message->Response().Writer());
459
- writer.Number<Core::hresult>(result);
460
-
461
- return (Core::ERROR_NONE);
462
- } ();
463
-
464
- if (hresult != Core::ERROR_NONE) {
465
- RPC::Data::Frame::Writer writer(message->Response().Writer());
466
- writer.Number<uint32_t>(hresult);
467
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IMessageControl::ID, 0, hresult);
468
- }
469
- },
470
-
471
- // (1) virtual Core::hresult Modules(Exchange::IMessageControl::IStringIterator*&) const = 0
472
- //
473
- [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
474
- Core::hresult hresult = Core::ERROR_NONE;
475
-
476
- hresult = [&]() -> Core::hresult {
477
- if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
478
-
479
- const Exchange::IMessageControl* implementation = reinterpret_cast<const Exchange::IMessageControl*>(message->Parameters().Implementation());
480
- ASSERT(implementation != nullptr);
481
- if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), Exchange::IMessageControl::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
482
-
483
- Exchange::IMessageControl::IStringIterator* _modules{};
484
-
485
- Core::hresult result = implementation->Modules(_modules);
486
-
487
- RPC::Data::Frame::Writer writer(message->Response().Writer());
488
- writer.Number<Core::hresult>(result);
489
- writer.Number<Core::instance_id>(RPC::instance_cast(_modules));
490
-
491
- RPC::Administrator::Instance().RegisterInterface(channel, _modules);
492
-
493
- return (Core::ERROR_NONE);
494
- } ();
495
-
496
- if (hresult != Core::ERROR_NONE) {
497
- RPC::Data::Frame::Writer writer(message->Response().Writer());
498
- writer.Number<uint32_t>(hresult);
499
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IMessageControl::ID, 1, hresult);
500
- }
501
- },
502
-
503
- // (2) virtual Core::hresult Controls(const string&, Exchange::IMessageControl::IControlIterator*&) const = 0
504
- //
505
- [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
506
- Core::hresult hresult = Core::ERROR_NONE;
507
-
508
- hresult = [&]() -> Core::hresult {
509
- if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
510
-
511
- const Exchange::IMessageControl* implementation = reinterpret_cast<const Exchange::IMessageControl*>(message->Parameters().Implementation());
512
- ASSERT(implementation != nullptr);
513
- if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), Exchange::IMessageControl::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
514
-
515
- RPC::Data::Frame::Reader reader(message->Parameters().Reader());
516
- if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
517
- const uint16_t _modulePeekedLen__ = reader.PeekNumber<uint16_t>();
518
- if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _modulePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
519
- const string _module = reader.Text();
520
-
521
- Exchange::IMessageControl::IControlIterator* _control{};
522
-
523
- Core::hresult result = implementation->Controls(static_cast<const string&>(_module), _control);
524
-
525
- RPC::Data::Frame::Writer writer(message->Response().Writer());
526
- writer.Number<Core::hresult>(result);
527
- writer.Number<Core::instance_id>(RPC::instance_cast(_control));
528
-
529
- RPC::Administrator::Instance().RegisterInterface(channel, _control);
530
-
531
- return (Core::ERROR_NONE);
532
- } ();
533
-
534
- if (hresult != Core::ERROR_NONE) {
535
- RPC::Data::Frame::Writer writer(message->Response().Writer());
536
- writer.Number<uint32_t>(hresult);
537
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IMessageControl::ID, 2, hresult);
538
- }
539
- }
540
- , nullptr
541
- }; // ExchangeMessageControlStubMethods
542
-
543
- // -----------------------------------------------------------------
544
- // PROXIES
545
- // -----------------------------------------------------------------
546
-
547
- //
548
- // RPC::IIteratorTypeInstance_675a6ff7e5671893 interface proxy definitions
549
- //
550
- // Methods:
551
- // (0) virtual bool Next(Exchange::IMessageControl::Control&) = 0
552
- // (1) virtual bool Previous(Exchange::IMessageControl::Control&) = 0
553
- // (2) virtual void Reset(const uint32_t) = 0
554
- // (3) virtual bool IsValid() const = 0
555
- // (4) virtual uint32_t Count() const = 0
556
- // (5) virtual Exchange::IMessageControl::Control Current() const = 0
557
- //
558
-
559
- class RPCIteratorTypeInstance_675a6ff7e5671893Proxy final : public ProxyStub::UnknownProxyType<RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>> {
560
- public:
561
- RPCIteratorTypeInstance_675a6ff7e5671893Proxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
562
- : BaseClass(channel, implementation, otherSideInformed)
563
- {
564
- }
565
-
566
- bool Next(Exchange::IMessageControl::Control& _info) override
567
- {
568
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
569
-
570
- bool result{};
571
-
572
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
573
- if (hresult == Core::ERROR_NONE) {
574
- hresult = [&]() -> Core::hresult {
575
- RPC::Data::Frame::Reader reader(message->Response().Reader());
576
- if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
577
- result = reader.Boolean();
578
- if (reader.Length() < (Core::RealSize<Exchange::IMessageControl::messagetype>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
579
- _info.type = reader.Number<Exchange::IMessageControl::messagetype>();
580
- if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
581
- const uint16_t _info_categoryPeekedLen__ = reader.PeekNumber<uint16_t>();
582
- if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_categoryPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
583
- _info.category = reader.Text();
584
- if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
585
- const uint16_t _info_modulePeekedLen__ = reader.PeekNumber<uint16_t>();
586
- if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_modulePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
587
- _info.module = reader.Text();
588
- if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
589
- _info.enabled = reader.Boolean();
590
-
591
- return (Core::ERROR_NONE);
592
- } ();
593
- } else {
594
- ASSERT((hresult & COM_ERROR) != 0);
595
- }
596
-
597
- if ((hresult & COM_ERROR) != 0) {
598
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>::ID, 0, hresult);
599
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
600
- }
601
-
602
- return (result);
603
- }
604
-
605
- bool Previous(Exchange::IMessageControl::Control& _info) override
606
- {
607
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
608
-
609
- bool result{};
610
-
611
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
612
- if (hresult == Core::ERROR_NONE) {
613
- hresult = [&]() -> Core::hresult {
614
- RPC::Data::Frame::Reader reader(message->Response().Reader());
615
- if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
616
- result = reader.Boolean();
617
- if (reader.Length() < (Core::RealSize<Exchange::IMessageControl::messagetype>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
618
- _info.type = reader.Number<Exchange::IMessageControl::messagetype>();
619
- if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
620
- const uint16_t _info_categoryPeekedLen__ = reader.PeekNumber<uint16_t>();
621
- if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_categoryPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
622
- _info.category = reader.Text();
623
- if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
624
- const uint16_t _info_modulePeekedLen__ = reader.PeekNumber<uint16_t>();
625
- if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_modulePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
626
- _info.module = reader.Text();
627
- if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
628
- _info.enabled = reader.Boolean();
629
-
630
- return (Core::ERROR_NONE);
631
- } ();
632
- } else {
633
- ASSERT((hresult & COM_ERROR) != 0);
634
- }
635
-
636
- if ((hresult & COM_ERROR) != 0) {
637
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>::ID, 1, hresult);
638
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
639
- }
640
-
641
- return (result);
642
- }
643
-
644
- void Reset(const uint32_t _position) override
645
- {
646
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
647
-
648
- RPC::Data::Frame::Writer writer(message->Parameters().Writer());
649
- writer.Number<uint32_t>(_position);
650
-
651
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
652
- if (hresult == Core::ERROR_NONE) {
653
- hresult = [&]() -> Core::hresult {
654
-
655
- return (Core::ERROR_NONE);
656
- } ();
657
- } else {
658
- ASSERT((hresult & COM_ERROR) != 0);
659
- }
660
-
661
- if ((hresult & COM_ERROR) != 0) {
662
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>::ID, 2, hresult);
663
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
664
- }
665
- }
666
-
667
- bool IsValid() const override
668
- {
669
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
670
-
671
- bool result{};
672
-
673
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
674
- if (hresult == Core::ERROR_NONE) {
675
- hresult = [&]() -> Core::hresult {
676
- RPC::Data::Frame::Reader reader(message->Response().Reader());
677
- if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
678
- result = reader.Boolean();
679
-
680
- return (Core::ERROR_NONE);
681
- } ();
682
- } else {
683
- ASSERT((hresult & COM_ERROR) != 0);
684
- }
685
-
686
- if ((hresult & COM_ERROR) != 0) {
687
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>::ID, 3, hresult);
688
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
689
- }
690
-
691
- return (result);
692
- }
693
-
694
- uint32_t Count() const override
695
- {
696
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(4));
697
-
698
- uint32_t result{};
699
-
700
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
701
- if (hresult == Core::ERROR_NONE) {
702
- hresult = [&]() -> Core::hresult {
703
- RPC::Data::Frame::Reader reader(message->Response().Reader());
704
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
705
- result = reader.Number<uint32_t>();
706
-
707
- return (Core::ERROR_NONE);
708
- } ();
709
- } else {
710
- ASSERT((hresult & COM_ERROR) != 0);
711
- }
712
-
713
- if ((hresult & COM_ERROR) != 0) {
714
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>::ID, 4, hresult);
715
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
716
- }
717
-
718
- return (result);
719
- }
720
-
721
- Exchange::IMessageControl::Control Current() const override
722
- {
723
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(5));
724
-
725
- Exchange::IMessageControl::Control result{};
726
-
727
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
728
- if (hresult == Core::ERROR_NONE) {
729
- hresult = [&]() -> Core::hresult {
730
- RPC::Data::Frame::Reader reader(message->Response().Reader());
731
- if (reader.Length() < (Core::RealSize<Exchange::IMessageControl::messagetype>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
732
- result.type = reader.Number<Exchange::IMessageControl::messagetype>();
733
- if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
734
- const uint16_t result_categoryPeekedLen__ = reader.PeekNumber<uint16_t>();
735
- if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + result_categoryPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
736
- result.category = reader.Text();
737
- if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
738
- const uint16_t result_modulePeekedLen__ = reader.PeekNumber<uint16_t>();
739
- if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + result_modulePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
740
- result.module = reader.Text();
741
- if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
742
- result.enabled = reader.Boolean();
743
-
744
- return (Core::ERROR_NONE);
745
- } ();
746
- } else {
747
- ASSERT((hresult & COM_ERROR) != 0);
748
- }
749
-
750
- if ((hresult & COM_ERROR) != 0) {
751
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>::ID, 5, hresult);
752
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
753
- }
754
-
755
- return (result);
756
- }
757
-
758
- }; // class RPCIteratorTypeInstance_675a6ff7e5671893Proxy
759
-
760
- //
761
- // RPC::IIteratorTypeInstance_b3acff3685df4032 interface proxy definitions
762
- //
763
- // Methods:
764
- // (0) virtual bool Next(string&) = 0
765
- // (1) virtual bool Previous(string&) = 0
766
- // (2) virtual void Reset(const uint32_t) = 0
767
- // (3) virtual bool IsValid() const = 0
768
- // (4) virtual uint32_t Count() const = 0
769
- // (5) virtual string Current() const = 0
770
- //
771
-
772
- class RPCIteratorTypeInstance_b3acff3685df4032Proxy final : public ProxyStub::UnknownProxyType<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>> {
773
- public:
774
- RPCIteratorTypeInstance_b3acff3685df4032Proxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
775
- : BaseClass(channel, implementation, otherSideInformed)
776
- {
777
- }
778
-
779
- bool Next(string& _info) override
780
- {
781
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
782
-
783
- bool result{};
784
-
785
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
786
- if (hresult == Core::ERROR_NONE) {
787
- hresult = [&]() -> Core::hresult {
788
- RPC::Data::Frame::Reader reader(message->Response().Reader());
789
- if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
790
- result = reader.Boolean();
791
- if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
792
- const uint16_t _infoPeekedLen__ = reader.PeekNumber<uint16_t>();
793
- if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _infoPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
794
- _info = reader.Text();
795
-
796
- return (Core::ERROR_NONE);
797
- } ();
798
- } else {
799
- ASSERT((hresult & COM_ERROR) != 0);
800
- }
801
-
802
- if ((hresult & COM_ERROR) != 0) {
803
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>::ID, 0, hresult);
804
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
805
- }
806
-
807
- return (result);
808
- }
809
-
810
- bool Previous(string& _info) override
811
- {
812
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
813
-
814
- bool result{};
815
-
816
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
817
- if (hresult == Core::ERROR_NONE) {
818
- hresult = [&]() -> Core::hresult {
819
- RPC::Data::Frame::Reader reader(message->Response().Reader());
820
- if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
821
- result = reader.Boolean();
822
- if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
823
- const uint16_t _infoPeekedLen__ = reader.PeekNumber<uint16_t>();
824
- if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _infoPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
825
- _info = reader.Text();
826
-
827
- return (Core::ERROR_NONE);
828
- } ();
829
- } else {
830
- ASSERT((hresult & COM_ERROR) != 0);
831
- }
832
-
833
- if ((hresult & COM_ERROR) != 0) {
834
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>::ID, 1, hresult);
835
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
836
- }
837
-
838
- return (result);
839
- }
840
-
841
- void Reset(const uint32_t _position) override
842
- {
843
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
844
-
845
- RPC::Data::Frame::Writer writer(message->Parameters().Writer());
846
- writer.Number<uint32_t>(_position);
847
-
848
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
849
- if (hresult == Core::ERROR_NONE) {
850
- hresult = [&]() -> Core::hresult {
851
-
852
- return (Core::ERROR_NONE);
853
- } ();
854
- } else {
855
- ASSERT((hresult & COM_ERROR) != 0);
856
- }
857
-
858
- if ((hresult & COM_ERROR) != 0) {
859
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>::ID, 2, hresult);
860
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
861
- }
862
- }
863
-
864
- bool IsValid() const override
865
- {
866
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
867
-
868
- bool result{};
869
-
870
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
871
- if (hresult == Core::ERROR_NONE) {
872
- hresult = [&]() -> Core::hresult {
873
- RPC::Data::Frame::Reader reader(message->Response().Reader());
874
- if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
875
- result = reader.Boolean();
876
-
877
- return (Core::ERROR_NONE);
878
- } ();
879
- } else {
880
- ASSERT((hresult & COM_ERROR) != 0);
881
- }
882
-
883
- if ((hresult & COM_ERROR) != 0) {
884
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>::ID, 3, hresult);
885
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
886
- }
887
-
888
- return (result);
889
- }
890
-
891
- uint32_t Count() const override
892
- {
893
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(4));
894
-
895
- uint32_t result{};
896
-
897
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
898
- if (hresult == Core::ERROR_NONE) {
899
- hresult = [&]() -> Core::hresult {
900
- RPC::Data::Frame::Reader reader(message->Response().Reader());
901
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
902
- result = reader.Number<uint32_t>();
903
-
904
- return (Core::ERROR_NONE);
905
- } ();
906
- } else {
907
- ASSERT((hresult & COM_ERROR) != 0);
908
- }
909
-
910
- if ((hresult & COM_ERROR) != 0) {
911
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>::ID, 4, hresult);
912
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
913
- }
914
-
915
- return (result);
916
- }
917
-
918
- string Current() const override
919
- {
920
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(5));
921
-
922
- string result{};
923
-
924
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
925
- if (hresult == Core::ERROR_NONE) {
926
- hresult = [&]() -> Core::hresult {
927
- RPC::Data::Frame::Reader reader(message->Response().Reader());
928
- if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
929
- const uint16_t resultPeekedLen__ = reader.PeekNumber<uint16_t>();
930
- if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + resultPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
931
- result = reader.Text();
932
-
933
- return (Core::ERROR_NONE);
934
- } ();
935
- } else {
936
- ASSERT((hresult & COM_ERROR) != 0);
937
- }
938
-
939
- if ((hresult & COM_ERROR) != 0) {
940
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>::ID, 5, hresult);
941
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
942
- }
943
-
944
- return (result);
945
- }
946
-
947
- }; // class RPCIteratorTypeInstance_b3acff3685df4032Proxy
948
-
949
- //
950
- // Exchange::IMessageControl interface proxy definitions
951
- //
952
- // Methods:
953
- // (0) virtual Core::hresult Enable(const Exchange::IMessageControl::messagetype, const string&, const string&, const bool) = 0
954
- // (1) virtual Core::hresult Modules(Exchange::IMessageControl::IStringIterator*&) const = 0
955
- // (2) virtual Core::hresult Controls(const string&, Exchange::IMessageControl::IControlIterator*&) const = 0
956
- //
957
-
958
- class ExchangeMessageControlProxy final : public ProxyStub::UnknownProxyType<Exchange::IMessageControl> {
959
- public:
960
- ExchangeMessageControlProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
961
- : BaseClass(channel, implementation, otherSideInformed)
962
- {
963
- }
964
-
965
- Core::hresult Enable(const Exchange::IMessageControl::messagetype _type, const string& _category, const string& _module, const bool _enabled) override
966
- {
967
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
968
-
969
- RPC::Data::Frame::Writer writer(message->Parameters().Writer());
970
- writer.Number<Exchange::IMessageControl::messagetype>(_type);
971
- writer.Text(_category);
972
- writer.Text(_module);
973
- writer.Boolean(_enabled);
974
-
975
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
976
- if (hresult == Core::ERROR_NONE) {
977
- hresult = [&]() -> Core::hresult {
978
- RPC::Data::Frame::Reader reader(message->Response().Reader());
979
- if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
980
- hresult = reader.Number<Core::hresult>();
981
-
982
- return (hresult);
983
- } ();
984
- } else {
985
- ASSERT((hresult & COM_ERROR) != 0);
986
- }
987
-
988
- if ((hresult & COM_ERROR) != 0) {
989
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", Exchange::IMessageControl::ID, 0, hresult);
990
- }
991
-
992
- return (hresult);
993
- }
994
-
995
- Core::hresult Modules(Exchange::IMessageControl::IStringIterator*& _modules) const override
996
- {
997
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
998
-
999
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1000
- if (hresult == Core::ERROR_NONE) {
1001
- hresult = [&]() -> Core::hresult {
1002
- RPC::Data::Frame::Reader reader(message->Response().Reader());
1003
- if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1004
- hresult = reader.Number<Core::hresult>();
1005
- if ((hresult & COM_ERROR) == 0) {
1006
- _modules = reinterpret_cast<Exchange::IMessageControl::IStringIterator*>(static_cast<const ProxyStub::UnknownProxy&>(*this).Interface(reader.Number<Core::instance_id>(), Exchange::IMessageControl::IStringIterator::ID));
1007
- }
1008
-
1009
- return (hresult);
1010
- } ();
1011
- } else {
1012
- ASSERT((hresult & COM_ERROR) != 0);
1013
- }
1014
-
1015
- if ((hresult & COM_ERROR) != 0) {
1016
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", Exchange::IMessageControl::ID, 1, hresult);
1017
- }
1018
-
1019
- return (hresult);
1020
- }
1021
-
1022
- Core::hresult Controls(const string& _module, Exchange::IMessageControl::IControlIterator*& _control) const override
1023
- {
1024
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
1025
-
1026
- RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1027
- writer.Text(_module);
1028
-
1029
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1030
- if (hresult == Core::ERROR_NONE) {
1031
- hresult = [&]() -> Core::hresult {
1032
- RPC::Data::Frame::Reader reader(message->Response().Reader());
1033
- if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1034
- hresult = reader.Number<Core::hresult>();
1035
- if ((hresult & COM_ERROR) == 0) {
1036
- _control = reinterpret_cast<Exchange::IMessageControl::IControlIterator*>(static_cast<const ProxyStub::UnknownProxy&>(*this).Interface(reader.Number<Core::instance_id>(), Exchange::IMessageControl::IControlIterator::ID));
1037
- }
1038
-
1039
- return (hresult);
1040
- } ();
1041
- } else {
1042
- ASSERT((hresult & COM_ERROR) != 0);
1043
- }
1044
-
1045
- if ((hresult & COM_ERROR) != 0) {
1046
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", Exchange::IMessageControl::ID, 2, hresult);
1047
- }
1048
-
1049
- return (hresult);
1050
- }
1051
-
1052
- }; // class ExchangeMessageControlProxy
1053
-
1054
- POP_WARNING()
1055
- POP_WARNING()
1056
-
1057
- // -----------------------------------------------------------------
1058
- // REGISTRATION
1059
- // -----------------------------------------------------------------
1060
- namespace {
1061
-
1062
- typedef ProxyStub::UnknownStubType<RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>, RPCIteratorTypeInstance_675a6ff7e5671893StubMethods> RPCIteratorTypeInstance_675a6ff7e5671893Stub;
1063
- typedef ProxyStub::UnknownStubType<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>, RPCIteratorTypeInstance_b3acff3685df4032StubMethods> RPCIteratorTypeInstance_b3acff3685df4032Stub;
1064
- typedef ProxyStub::UnknownStubType<Exchange::IMessageControl, ExchangeMessageControlStubMethods> ExchangeMessageControlStub;
1065
-
1066
- static class Instantiation {
1067
- public:
1068
- Instantiation()
1069
- {
1070
- const RPC::SecureProxyStubType security = static_cast<RPC::SecureProxyStubType>(static_cast<std::underlying_type<RPC::SecureProxyStubType>::type>(RPC::SecureProxyStubType::PROXYSTUBS_SECURITY_SECURE) | static_cast<std::underlying_type<RPC::SecureProxyStubType>::type>(RPC::SecureProxyStubType::PROXYSTUBS_SECURITY_COHERENT));
1071
-
1072
- RPC::Administrator::Instance().Announce<RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>, RPCIteratorTypeInstance_675a6ff7e5671893Proxy, RPCIteratorTypeInstance_675a6ff7e5671893Stub>(security);
1073
- RPC::Administrator::Instance().Announce<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>, RPCIteratorTypeInstance_b3acff3685df4032Proxy, RPCIteratorTypeInstance_b3acff3685df4032Stub>(security);
1074
- RPC::Administrator::Instance().Announce<Exchange::IMessageControl, ExchangeMessageControlProxy, ExchangeMessageControlStub>(security);
1075
- }
1076
- ~Instantiation()
1077
- {
1078
- RPC::Administrator::Instance().Recall<RPC::IIteratorType<Exchange::IMessageControl::Control, Exchange::ID_MESSAGE_CONTROL_ITERATOR>>();
1079
- RPC::Administrator::Instance().Recall<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>();
1080
- RPC::Administrator::Instance().Recall<Exchange::IMessageControl>();
1081
- }
1082
- } ProxyStubRegistration;
1083
-
1084
- } // namespace
1085
-
1086
- } // namespace ProxyStubs
1087
-
1088
- }
Release/ThunderInterfaces/interfaces/generated/ProxyStubs_SecureShellServer.cpp CHANGED
@@ -1,55 +0,0 @@
1
- //
2
- // generated automatically from "ISecureShellServer.h"
3
- //
4
- // implements COM-RPC proxy stubs for:
5
- //
6
- // secure code enabled:
7
- // - instance verification enabled
8
- // - range verification enabled
9
- // - frame coherency verification enabled
10
- //
11
-
12
- #include "Module.h"
13
- #include "ISecureShellServer.h"
14
-
15
- #include <com/com.h>
16
-
17
- namespace Thunder {
18
-
19
- namespace ProxyStubs {
20
-
21
- PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
22
- PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
23
-
24
- // -----------------------------------------------------------------
25
- // STUBS
26
- // -----------------------------------------------------------------
27
-
28
- // -----------------------------------------------------------------
29
- // PROXIES
30
- // -----------------------------------------------------------------
31
-
32
- POP_WARNING()
33
- POP_WARNING()
34
-
35
- // -----------------------------------------------------------------
36
- // REGISTRATION
37
- // -----------------------------------------------------------------
38
- namespace {
39
-
40
-
41
- static class Instantiation {
42
- public:
43
- Instantiation()
44
- {
45
- }
46
- ~Instantiation()
47
- {
48
- }
49
- } ProxyStubRegistration;
50
-
51
- } // namespace
52
-
53
- } // namespace ProxyStubs
54
-
55
- }
Release/ThunderInterfaces/interfaces/generated/ProxyStubs_SwitchBoard.cpp CHANGED
@@ -1,55 +0,0 @@
1
- //
2
- // generated automatically from "ISwitchBoard.h"
3
- //
4
- // implements COM-RPC proxy stubs for:
5
- //
6
- // secure code enabled:
7
- // - instance verification enabled
8
- // - range verification enabled
9
- // - frame coherency verification enabled
10
- //
11
-
12
- #include "Module.h"
13
- #include "ISwitchBoard.h"
14
-
15
- #include <com/com.h>
16
-
17
- namespace Thunder {
18
-
19
- namespace ProxyStubs {
20
-
21
- PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
22
- PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
23
-
24
- // -----------------------------------------------------------------
25
- // STUBS
26
- // -----------------------------------------------------------------
27
-
28
- // -----------------------------------------------------------------
29
- // PROXIES
30
- // -----------------------------------------------------------------
31
-
32
- POP_WARNING()
33
- POP_WARNING()
34
-
35
- // -----------------------------------------------------------------
36
- // REGISTRATION
37
- // -----------------------------------------------------------------
38
- namespace {
39
-
40
-
41
- static class Instantiation {
42
- public:
43
- Instantiation()
44
- {
45
- }
46
- ~Instantiation()
47
- {
48
- }
49
- } ProxyStubRegistration;
50
-
51
- } // namespace
52
-
53
- } // namespace ProxyStubs
54
-
55
- }
Release/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_Benchmark.cpp CHANGED
@@ -0,0 +1,1203 @@
1
+ //
2
+ // generated automatically from "IBenchmark.h"
3
+ //
4
+ // implements COM-RPC proxy stubs for:
5
+ // - class RPC::IIteratorType<typename ELEMENT, const uint32_t INTERFACE_ID> [with ELEMENT = QualityAssurance::IBenchmark::BenchmarkResult, INTERFACE_ID = QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR] [[iterator]]
6
+ // - class QualityAssurance::IBenchmark
7
+ // - class QualityAssurance::IBenchmark::INotification
8
+ //
9
+ // secure code enabled:
10
+ // - instance verification enabled
11
+ // - range verification enabled
12
+ // - frame coherency verification enabled
13
+ //
14
+
15
+ #include "Module.h"
16
+ #include "IBenchmark.h"
17
+
18
+ #include <com/com.h>
19
+
20
+ namespace Thunder {
21
+
22
+ namespace ProxyStubs {
23
+
24
+ PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
25
+ PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
26
+
27
+ // -----------------------------------------------------------------
28
+ // STUBS
29
+ // -----------------------------------------------------------------
30
+
31
+ //
32
+ // RPC::IIteratorTypeInstance_d47fe5f746e372d7 interface stub definitions
33
+ //
34
+ // Methods:
35
+ // (0) virtual bool Next(QualityAssurance::IBenchmark::BenchmarkResult&) = 0
36
+ // (1) virtual bool Previous(QualityAssurance::IBenchmark::BenchmarkResult&) = 0
37
+ // (2) virtual void Reset(const uint32_t) = 0
38
+ // (3) virtual bool IsValid() const = 0
39
+ // (4) virtual uint32_t Count() const = 0
40
+ // (5) virtual QualityAssurance::IBenchmark::BenchmarkResult Current() const = 0
41
+ //
42
+
43
+ static ProxyStub::MethodHandler RPCIteratorTypeInstance_d47fe5f746e372d7StubMethods[] = {
44
+ // (0) virtual bool Next(QualityAssurance::IBenchmark::BenchmarkResult&) = 0
45
+ //
46
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
47
+ Core::hresult hresult = Core::ERROR_NONE;
48
+
49
+ hresult = [&]() -> Core::hresult {
50
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>;
51
+
52
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
53
+
54
+ interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
55
+ ASSERT(implementation != nullptr);
56
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
57
+
58
+ QualityAssurance::IBenchmark::BenchmarkResult _info{};
59
+
60
+ bool result = implementation->Next(_info);
61
+
62
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
63
+ writer.Boolean(result);
64
+ writer.Text(_info.apiName);
65
+ writer.Number<uint32_t>(_info.iterations);
66
+ writer.Number<uint64_t>(_info.roundTrip.minNs);
67
+ writer.Number<uint64_t>(_info.roundTrip.avgNs);
68
+ writer.Number<uint64_t>(_info.roundTrip.maxNs);
69
+ writer.Number<uint64_t>(_info.roundTrip.stddevNs);
70
+ writer.Number<uint64_t>(_info.memory.residentBefore);
71
+ writer.Number<uint64_t>(_info.memory.residentAfter);
72
+ writer.Number<uint64_t>(_info.memory.allocatedBefore);
73
+ writer.Number<uint64_t>(_info.memory.allocatedAfter);
74
+ writer.Boolean(_info.passed);
75
+ writer.Boolean(_info.failureReason.IsSet());
76
+ if (_info.failureReason.IsSet() == true) {
77
+ writer.Number<QualityAssurance::IBenchmark::FailureReason>(_info.failureReason.Value());
78
+ }
79
+
80
+ return (Core::ERROR_NONE);
81
+ } ();
82
+
83
+ if (hresult != Core::ERROR_NONE) {
84
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>::ID, 0, hresult);
85
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
86
+ }
87
+ },
88
+
89
+ // (1) virtual bool Previous(QualityAssurance::IBenchmark::BenchmarkResult&) = 0
90
+ //
91
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
92
+ Core::hresult hresult = Core::ERROR_NONE;
93
+
94
+ hresult = [&]() -> Core::hresult {
95
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>;
96
+
97
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
98
+
99
+ interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
100
+ ASSERT(implementation != nullptr);
101
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
102
+
103
+ QualityAssurance::IBenchmark::BenchmarkResult _info{};
104
+
105
+ bool result = implementation->Previous(_info);
106
+
107
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
108
+ writer.Boolean(result);
109
+ writer.Text(_info.apiName);
110
+ writer.Number<uint32_t>(_info.iterations);
111
+ writer.Number<uint64_t>(_info.roundTrip.minNs);
112
+ writer.Number<uint64_t>(_info.roundTrip.avgNs);
113
+ writer.Number<uint64_t>(_info.roundTrip.maxNs);
114
+ writer.Number<uint64_t>(_info.roundTrip.stddevNs);
115
+ writer.Number<uint64_t>(_info.memory.residentBefore);
116
+ writer.Number<uint64_t>(_info.memory.residentAfter);
117
+ writer.Number<uint64_t>(_info.memory.allocatedBefore);
118
+ writer.Number<uint64_t>(_info.memory.allocatedAfter);
119
+ writer.Boolean(_info.passed);
120
+ writer.Boolean(_info.failureReason.IsSet());
121
+ if (_info.failureReason.IsSet() == true) {
122
+ writer.Number<QualityAssurance::IBenchmark::FailureReason>(_info.failureReason.Value());
123
+ }
124
+
125
+ return (Core::ERROR_NONE);
126
+ } ();
127
+
128
+ if (hresult != Core::ERROR_NONE) {
129
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>::ID, 1, hresult);
130
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
131
+ }
132
+ },
133
+
134
+ // (2) virtual void Reset(const uint32_t) = 0
135
+ //
136
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
137
+ Core::hresult hresult = Core::ERROR_NONE;
138
+
139
+ hresult = [&]() -> Core::hresult {
140
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>;
141
+
142
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
143
+
144
+ interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
145
+ ASSERT(implementation != nullptr);
146
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
147
+
148
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
149
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
150
+ const uint32_t _position = reader.Number<uint32_t>();
151
+
152
+ implementation->Reset(_position);
153
+
154
+ return (Core::ERROR_NONE);
155
+ } ();
156
+
157
+ if (hresult != Core::ERROR_NONE) {
158
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>::ID, 2, hresult);
159
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
160
+ }
161
+ },
162
+
163
+ // (3) virtual bool IsValid() const = 0
164
+ //
165
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
166
+ Core::hresult hresult = Core::ERROR_NONE;
167
+
168
+ hresult = [&]() -> Core::hresult {
169
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>;
170
+
171
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
172
+
173
+ const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
174
+ ASSERT(implementation != nullptr);
175
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
176
+
177
+ bool result = implementation->IsValid();
178
+
179
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
180
+ writer.Boolean(result);
181
+
182
+ return (Core::ERROR_NONE);
183
+ } ();
184
+
185
+ if (hresult != Core::ERROR_NONE) {
186
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>::ID, 3, hresult);
187
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
188
+ }
189
+ },
190
+
191
+ // (4) virtual uint32_t Count() const = 0
192
+ //
193
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
194
+ Core::hresult hresult = Core::ERROR_NONE;
195
+
196
+ hresult = [&]() -> Core::hresult {
197
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>;
198
+
199
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
200
+
201
+ const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
202
+ ASSERT(implementation != nullptr);
203
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
204
+
205
+ uint32_t result = implementation->Count();
206
+
207
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
208
+ writer.Number<uint32_t>(result);
209
+
210
+ return (Core::ERROR_NONE);
211
+ } ();
212
+
213
+ if (hresult != Core::ERROR_NONE) {
214
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>::ID, 4, hresult);
215
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
216
+ }
217
+ },
218
+
219
+ // (5) virtual QualityAssurance::IBenchmark::BenchmarkResult Current() const = 0
220
+ //
221
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
222
+ Core::hresult hresult = Core::ERROR_NONE;
223
+
224
+ hresult = [&]() -> Core::hresult {
225
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>;
226
+
227
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
228
+
229
+ const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
230
+ ASSERT(implementation != nullptr);
231
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
232
+
233
+ QualityAssurance::IBenchmark::BenchmarkResult result = implementation->Current();
234
+
235
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
236
+ writer.Text(result.apiName);
237
+ writer.Number<uint32_t>(result.iterations);
238
+ writer.Number<uint64_t>(result.roundTrip.minNs);
239
+ writer.Number<uint64_t>(result.roundTrip.avgNs);
240
+ writer.Number<uint64_t>(result.roundTrip.maxNs);
241
+ writer.Number<uint64_t>(result.roundTrip.stddevNs);
242
+ writer.Number<uint64_t>(result.memory.residentBefore);
243
+ writer.Number<uint64_t>(result.memory.residentAfter);
244
+ writer.Number<uint64_t>(result.memory.allocatedBefore);
245
+ writer.Number<uint64_t>(result.memory.allocatedAfter);
246
+ writer.Boolean(result.passed);
247
+ writer.Boolean(result.failureReason.IsSet());
248
+ if (result.failureReason.IsSet() == true) {
249
+ writer.Number<QualityAssurance::IBenchmark::FailureReason>(result.failureReason.Value());
250
+ }
251
+
252
+ return (Core::ERROR_NONE);
253
+ } ();
254
+
255
+ if (hresult != Core::ERROR_NONE) {
256
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>::ID, 5, hresult);
257
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
258
+ }
259
+ }
260
+ , nullptr
261
+ }; // RPCIteratorTypeInstance_d47fe5f746e372d7StubMethods
262
+
263
+ //
264
+ // QualityAssurance::IBenchmark interface stub definitions
265
+ //
266
+ // Methods:
267
+ // (0) virtual Core::hresult Trigger(const uint32_t) = 0
268
+ // (1) virtual Core::hresult CollectData(QualityAssurance::IBenchmark::IBenchmarkResultIterator*&) const = 0
269
+ // (2) virtual Core::hresult LatencyThreshold(const uint32_t) = 0
270
+ // (3) virtual Core::hresult LatencyThreshold(uint32_t&) const = 0
271
+ // (4) virtual Core::hresult MemoryThreshold(const uint64_t) = 0
272
+ // (5) virtual Core::hresult MemoryThreshold(uint64_t&) const = 0
273
+ // (6) virtual Core::hresult Register(QualityAssurance::IBenchmark::INotification*) = 0
274
+ // (7) virtual Core::hresult Unregister(QualityAssurance::IBenchmark::INotification*) = 0
275
+ //
276
+
277
+ static ProxyStub::MethodHandler QualityAssuranceBenchmarkStubMethods[] = {
278
+ // (0) virtual Core::hresult Trigger(const uint32_t) = 0
279
+ //
280
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
281
+ Core::hresult hresult = Core::ERROR_NONE;
282
+
283
+ hresult = [&]() -> Core::hresult {
284
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
285
+
286
+ QualityAssurance::IBenchmark* implementation = reinterpret_cast<QualityAssurance::IBenchmark*>(message->Parameters().Implementation());
287
+ ASSERT(implementation != nullptr);
288
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmark::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
289
+
290
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
291
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
292
+ const uint32_t _iterations = reader.Number<uint32_t>();
293
+
294
+ Core::hresult result = implementation->Trigger(_iterations);
295
+
296
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
297
+ writer.Number<Core::hresult>(result);
298
+
299
+ return (Core::ERROR_NONE);
300
+ } ();
301
+
302
+ if (hresult != Core::ERROR_NONE) {
303
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
304
+ writer.Number<uint32_t>(hresult);
305
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::ID, 0, hresult);
306
+ }
307
+ },
308
+
309
+ // (1) virtual Core::hresult CollectData(QualityAssurance::IBenchmark::IBenchmarkResultIterator*&) const = 0
310
+ //
311
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
312
+ Core::hresult hresult = Core::ERROR_NONE;
313
+
314
+ hresult = [&]() -> Core::hresult {
315
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
316
+
317
+ const QualityAssurance::IBenchmark* implementation = reinterpret_cast<const QualityAssurance::IBenchmark*>(message->Parameters().Implementation());
318
+ ASSERT(implementation != nullptr);
319
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmark::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
320
+
321
+ QualityAssurance::IBenchmark::IBenchmarkResultIterator* _report{};
322
+
323
+ Core::hresult result = implementation->CollectData(_report);
324
+
325
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
326
+ writer.Number<Core::hresult>(result);
327
+ writer.Number<Core::instance_id>(RPC::instance_cast(_report));
328
+
329
+ RPC::Administrator::Instance().RegisterInterface(channel, _report);
330
+
331
+ return (Core::ERROR_NONE);
332
+ } ();
333
+
334
+ if (hresult != Core::ERROR_NONE) {
335
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
336
+ writer.Number<uint32_t>(hresult);
337
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::ID, 1, hresult);
338
+ }
339
+ },
340
+
341
+ // (2) virtual Core::hresult LatencyThreshold(const uint32_t) = 0
342
+ //
343
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
344
+ Core::hresult hresult = Core::ERROR_NONE;
345
+
346
+ hresult = [&]() -> Core::hresult {
347
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
348
+
349
+ QualityAssurance::IBenchmark* implementation = reinterpret_cast<QualityAssurance::IBenchmark*>(message->Parameters().Implementation());
350
+ ASSERT(implementation != nullptr);
351
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmark::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
352
+
353
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
354
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
355
+ const uint32_t _maxLatencyDeviationPct = reader.Number<uint32_t>();
356
+
357
+ Core::hresult result = implementation->LatencyThreshold(_maxLatencyDeviationPct);
358
+
359
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
360
+ writer.Number<Core::hresult>(result);
361
+
362
+ return (Core::ERROR_NONE);
363
+ } ();
364
+
365
+ if (hresult != Core::ERROR_NONE) {
366
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
367
+ writer.Number<uint32_t>(hresult);
368
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::ID, 2, hresult);
369
+ }
370
+ },
371
+
372
+ // (3) virtual Core::hresult LatencyThreshold(uint32_t&) const = 0
373
+ //
374
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
375
+ Core::hresult hresult = Core::ERROR_NONE;
376
+
377
+ hresult = [&]() -> Core::hresult {
378
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
379
+
380
+ const QualityAssurance::IBenchmark* implementation = reinterpret_cast<const QualityAssurance::IBenchmark*>(message->Parameters().Implementation());
381
+ ASSERT(implementation != nullptr);
382
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmark::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
383
+
384
+ uint32_t _maxLatencyDeviationPct{};
385
+
386
+ Core::hresult result = implementation->LatencyThreshold(_maxLatencyDeviationPct);
387
+
388
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
389
+ writer.Number<Core::hresult>(result);
390
+ writer.Number<uint32_t>(_maxLatencyDeviationPct);
391
+
392
+ return (Core::ERROR_NONE);
393
+ } ();
394
+
395
+ if (hresult != Core::ERROR_NONE) {
396
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
397
+ writer.Number<uint32_t>(hresult);
398
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::ID, 3, hresult);
399
+ }
400
+ },
401
+
402
+ // (4) virtual Core::hresult MemoryThreshold(const uint64_t) = 0
403
+ //
404
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
405
+ Core::hresult hresult = Core::ERROR_NONE;
406
+
407
+ hresult = [&]() -> Core::hresult {
408
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
409
+
410
+ QualityAssurance::IBenchmark* implementation = reinterpret_cast<QualityAssurance::IBenchmark*>(message->Parameters().Implementation());
411
+ ASSERT(implementation != nullptr);
412
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmark::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
413
+
414
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
415
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
416
+ const uint64_t _maxMemoryGrowthBytes = reader.Number<uint64_t>();
417
+
418
+ Core::hresult result = implementation->MemoryThreshold(_maxMemoryGrowthBytes);
419
+
420
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
421
+ writer.Number<Core::hresult>(result);
422
+
423
+ return (Core::ERROR_NONE);
424
+ } ();
425
+
426
+ if (hresult != Core::ERROR_NONE) {
427
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
428
+ writer.Number<uint32_t>(hresult);
429
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::ID, 4, hresult);
430
+ }
431
+ },
432
+
433
+ // (5) virtual Core::hresult MemoryThreshold(uint64_t&) const = 0
434
+ //
435
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
436
+ Core::hresult hresult = Core::ERROR_NONE;
437
+
438
+ hresult = [&]() -> Core::hresult {
439
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
440
+
441
+ const QualityAssurance::IBenchmark* implementation = reinterpret_cast<const QualityAssurance::IBenchmark*>(message->Parameters().Implementation());
442
+ ASSERT(implementation != nullptr);
443
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmark::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
444
+
445
+ uint64_t _maxMemoryGrowthBytes{};
446
+
447
+ Core::hresult result = implementation->MemoryThreshold(_maxMemoryGrowthBytes);
448
+
449
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
450
+ writer.Number<Core::hresult>(result);
451
+ writer.Number<uint64_t>(_maxMemoryGrowthBytes);
452
+
453
+ return (Core::ERROR_NONE);
454
+ } ();
455
+
456
+ if (hresult != Core::ERROR_NONE) {
457
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
458
+ writer.Number<uint32_t>(hresult);
459
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::ID, 5, hresult);
460
+ }
461
+ },
462
+
463
+ // (6) virtual Core::hresult Register(QualityAssurance::IBenchmark::INotification*) = 0
464
+ //
465
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
466
+ Core::hresult hresult = Core::ERROR_NONE;
467
+
468
+ hresult = [&]() -> Core::hresult {
469
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
470
+
471
+ QualityAssurance::IBenchmark* implementation = reinterpret_cast<QualityAssurance::IBenchmark*>(message->Parameters().Implementation());
472
+ ASSERT(implementation != nullptr);
473
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmark::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
474
+
475
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
476
+ if (reader.Length() < (sizeof(Core::instance_id))) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
477
+ Core::instance_id _sinkInstanceId__ = reader.Number<Core::instance_id>();
478
+
479
+ QualityAssurance::IBenchmark::INotification* _sink{};
480
+ ProxyStub::UnknownProxy* _sinkProxy__ = nullptr;
481
+ if (_sinkInstanceId__ != 0) {
482
+ _sinkProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _sinkInstanceId__, false, _sink);
483
+ ASSERT((_sink != nullptr) && (_sinkProxy__ != nullptr));
484
+ if ((_sink == nullptr) || (_sinkProxy__ == nullptr)) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
485
+ }
486
+
487
+ Core::hresult result = implementation->Register(_sink);
488
+
489
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
490
+ writer.Number<Core::hresult>(result);
491
+
492
+ if (_sinkProxy__ != nullptr) {
493
+ RPC::Administrator::Instance().Release(_sinkProxy__, message->Response());
494
+ }
495
+
496
+ return (Core::ERROR_NONE);
497
+ } ();
498
+
499
+ if (hresult != Core::ERROR_NONE) {
500
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
501
+ writer.Number<uint32_t>(hresult);
502
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::ID, 6, hresult);
503
+ }
504
+ },
505
+
506
+ // (7) virtual Core::hresult Unregister(QualityAssurance::IBenchmark::INotification*) = 0
507
+ //
508
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
509
+ Core::hresult hresult = Core::ERROR_NONE;
510
+
511
+ hresult = [&]() -> Core::hresult {
512
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
513
+
514
+ QualityAssurance::IBenchmark* implementation = reinterpret_cast<QualityAssurance::IBenchmark*>(message->Parameters().Implementation());
515
+ ASSERT(implementation != nullptr);
516
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmark::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
517
+
518
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
519
+ if (reader.Length() < (sizeof(Core::instance_id))) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
520
+ Core::instance_id _sinkInstanceId__ = reader.Number<Core::instance_id>();
521
+
522
+ QualityAssurance::IBenchmark::INotification* _sink{};
523
+ ProxyStub::UnknownProxy* _sinkProxy__ = nullptr;
524
+ if (_sinkInstanceId__ != 0) {
525
+ _sinkProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _sinkInstanceId__, false, _sink);
526
+ ASSERT((_sink != nullptr) && (_sinkProxy__ != nullptr));
527
+ if ((_sink == nullptr) || (_sinkProxy__ == nullptr)) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
528
+ }
529
+
530
+ Core::hresult result = implementation->Unregister(_sink);
531
+
532
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
533
+ writer.Number<Core::hresult>(result);
534
+
535
+ if (_sinkProxy__ != nullptr) {
536
+ RPC::Administrator::Instance().Release(_sinkProxy__, message->Response());
537
+ }
538
+
539
+ return (Core::ERROR_NONE);
540
+ } ();
541
+
542
+ if (hresult != Core::ERROR_NONE) {
543
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
544
+ writer.Number<uint32_t>(hresult);
545
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::ID, 7, hresult);
546
+ }
547
+ }
548
+ , nullptr
549
+ }; // QualityAssuranceBenchmarkStubMethods
550
+
551
+ //
552
+ // QualityAssurance::IBenchmark::INotification interface stub definitions
553
+ //
554
+ // Methods:
555
+ // (0) virtual void PerformanceCheckCompleted() = 0
556
+ //
557
+
558
+ static ProxyStub::MethodHandler QualityAssuranceBenchmarkNotificationStubMethods[] = {
559
+ // (0) virtual void PerformanceCheckCompleted() = 0
560
+ //
561
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
562
+ Core::hresult hresult = Core::ERROR_NONE;
563
+
564
+ hresult = [&]() -> Core::hresult {
565
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
566
+
567
+ QualityAssurance::IBenchmark::INotification* implementation = reinterpret_cast<QualityAssurance::IBenchmark::INotification*>(message->Parameters().Implementation());
568
+ ASSERT(implementation != nullptr);
569
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmark::INotification::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
570
+
571
+ implementation->PerformanceCheckCompleted();
572
+
573
+ return (Core::ERROR_NONE);
574
+ } ();
575
+
576
+ if (hresult != Core::ERROR_NONE) {
577
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::INotification::ID, 0, hresult);
578
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
579
+ }
580
+ }
581
+ , nullptr
582
+ }; // QualityAssuranceBenchmarkNotificationStubMethods
583
+
584
+ // -----------------------------------------------------------------
585
+ // PROXIES
586
+ // -----------------------------------------------------------------
587
+
588
+ //
589
+ // RPC::IIteratorTypeInstance_d47fe5f746e372d7 interface proxy definitions
590
+ //
591
+ // Methods:
592
+ // (0) virtual bool Next(QualityAssurance::IBenchmark::BenchmarkResult&) = 0
593
+ // (1) virtual bool Previous(QualityAssurance::IBenchmark::BenchmarkResult&) = 0
594
+ // (2) virtual void Reset(const uint32_t) = 0
595
+ // (3) virtual bool IsValid() const = 0
596
+ // (4) virtual uint32_t Count() const = 0
597
+ // (5) virtual QualityAssurance::IBenchmark::BenchmarkResult Current() const = 0
598
+ //
599
+
600
+ class RPCIteratorTypeInstance_d47fe5f746e372d7Proxy final : public ProxyStub::UnknownProxyType<RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>> {
601
+ public:
602
+ RPCIteratorTypeInstance_d47fe5f746e372d7Proxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
603
+ : BaseClass(channel, implementation, otherSideInformed)
604
+ {
605
+ }
606
+
607
+ bool Next(QualityAssurance::IBenchmark::BenchmarkResult& _info) override
608
+ {
609
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
610
+
611
+ bool result{};
612
+
613
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
614
+ if (hresult == Core::ERROR_NONE) {
615
+ hresult = [&]() -> Core::hresult {
616
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
617
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
618
+ result = reader.Boolean();
619
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
620
+ const uint16_t _info_apiNamePeekedLen__ = reader.PeekNumber<uint16_t>();
621
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_apiNamePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
622
+ _info.apiName = reader.Text();
623
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
624
+ _info.iterations = reader.Number<uint32_t>();
625
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
626
+ _info.roundTrip.minNs = reader.Number<uint64_t>();
627
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
628
+ _info.roundTrip.avgNs = reader.Number<uint64_t>();
629
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
630
+ _info.roundTrip.maxNs = reader.Number<uint64_t>();
631
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
632
+ _info.roundTrip.stddevNs = reader.Number<uint64_t>();
633
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
634
+ _info.memory.residentBefore = reader.Number<uint64_t>();
635
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
636
+ _info.memory.residentAfter = reader.Number<uint64_t>();
637
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
638
+ _info.memory.allocatedBefore = reader.Number<uint64_t>();
639
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
640
+ _info.memory.allocatedAfter = reader.Number<uint64_t>();
641
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
642
+ _info.passed = reader.Boolean();
643
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
644
+ if (reader.Boolean() == true) {
645
+ if (reader.Length() < (Core::RealSize<QualityAssurance::IBenchmark::FailureReason>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
646
+ _info.failureReason = reader.Number<QualityAssurance::IBenchmark::FailureReason>();
647
+ }
648
+
649
+ return (Core::ERROR_NONE);
650
+ } ();
651
+ } else {
652
+ ASSERT((hresult & COM_ERROR) != 0);
653
+ }
654
+
655
+ if ((hresult & COM_ERROR) != 0) {
656
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>::ID, 0, hresult);
657
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
658
+ }
659
+
660
+ return (result);
661
+ }
662
+
663
+ bool Previous(QualityAssurance::IBenchmark::BenchmarkResult& _info) override
664
+ {
665
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
666
+
667
+ bool result{};
668
+
669
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
670
+ if (hresult == Core::ERROR_NONE) {
671
+ hresult = [&]() -> Core::hresult {
672
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
673
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
674
+ result = reader.Boolean();
675
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
676
+ const uint16_t _info_apiNamePeekedLen__ = reader.PeekNumber<uint16_t>();
677
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _info_apiNamePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
678
+ _info.apiName = reader.Text();
679
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
680
+ _info.iterations = reader.Number<uint32_t>();
681
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
682
+ _info.roundTrip.minNs = reader.Number<uint64_t>();
683
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
684
+ _info.roundTrip.avgNs = reader.Number<uint64_t>();
685
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
686
+ _info.roundTrip.maxNs = reader.Number<uint64_t>();
687
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
688
+ _info.roundTrip.stddevNs = reader.Number<uint64_t>();
689
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
690
+ _info.memory.residentBefore = reader.Number<uint64_t>();
691
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
692
+ _info.memory.residentAfter = reader.Number<uint64_t>();
693
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
694
+ _info.memory.allocatedBefore = reader.Number<uint64_t>();
695
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
696
+ _info.memory.allocatedAfter = reader.Number<uint64_t>();
697
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
698
+ _info.passed = reader.Boolean();
699
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
700
+ if (reader.Boolean() == true) {
701
+ if (reader.Length() < (Core::RealSize<QualityAssurance::IBenchmark::FailureReason>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
702
+ _info.failureReason = reader.Number<QualityAssurance::IBenchmark::FailureReason>();
703
+ }
704
+
705
+ return (Core::ERROR_NONE);
706
+ } ();
707
+ } else {
708
+ ASSERT((hresult & COM_ERROR) != 0);
709
+ }
710
+
711
+ if ((hresult & COM_ERROR) != 0) {
712
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>::ID, 1, hresult);
713
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
714
+ }
715
+
716
+ return (result);
717
+ }
718
+
719
+ void Reset(const uint32_t _position) override
720
+ {
721
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
722
+
723
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
724
+ writer.Number<uint32_t>(_position);
725
+
726
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
727
+ if (hresult == Core::ERROR_NONE) {
728
+ hresult = [&]() -> Core::hresult {
729
+
730
+ return (Core::ERROR_NONE);
731
+ } ();
732
+ } else {
733
+ ASSERT((hresult & COM_ERROR) != 0);
734
+ }
735
+
736
+ if ((hresult & COM_ERROR) != 0) {
737
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>::ID, 2, hresult);
738
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
739
+ }
740
+ }
741
+
742
+ bool IsValid() const override
743
+ {
744
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
745
+
746
+ bool result{};
747
+
748
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
749
+ if (hresult == Core::ERROR_NONE) {
750
+ hresult = [&]() -> Core::hresult {
751
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
752
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
753
+ result = reader.Boolean();
754
+
755
+ return (Core::ERROR_NONE);
756
+ } ();
757
+ } else {
758
+ ASSERT((hresult & COM_ERROR) != 0);
759
+ }
760
+
761
+ if ((hresult & COM_ERROR) != 0) {
762
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>::ID, 3, hresult);
763
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
764
+ }
765
+
766
+ return (result);
767
+ }
768
+
769
+ uint32_t Count() const override
770
+ {
771
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(4));
772
+
773
+ uint32_t result{};
774
+
775
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
776
+ if (hresult == Core::ERROR_NONE) {
777
+ hresult = [&]() -> Core::hresult {
778
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
779
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
780
+ result = reader.Number<uint32_t>();
781
+
782
+ return (Core::ERROR_NONE);
783
+ } ();
784
+ } else {
785
+ ASSERT((hresult & COM_ERROR) != 0);
786
+ }
787
+
788
+ if ((hresult & COM_ERROR) != 0) {
789
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>::ID, 4, hresult);
790
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
791
+ }
792
+
793
+ return (result);
794
+ }
795
+
796
+ QualityAssurance::IBenchmark::BenchmarkResult Current() const override
797
+ {
798
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(5));
799
+
800
+ QualityAssurance::IBenchmark::BenchmarkResult result{};
801
+
802
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
803
+ if (hresult == Core::ERROR_NONE) {
804
+ hresult = [&]() -> Core::hresult {
805
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
806
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
807
+ const uint16_t result_apiNamePeekedLen__ = reader.PeekNumber<uint16_t>();
808
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + result_apiNamePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
809
+ result.apiName = reader.Text();
810
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
811
+ result.iterations = reader.Number<uint32_t>();
812
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
813
+ result.roundTrip.minNs = reader.Number<uint64_t>();
814
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
815
+ result.roundTrip.avgNs = reader.Number<uint64_t>();
816
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
817
+ result.roundTrip.maxNs = reader.Number<uint64_t>();
818
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
819
+ result.roundTrip.stddevNs = reader.Number<uint64_t>();
820
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
821
+ result.memory.residentBefore = reader.Number<uint64_t>();
822
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
823
+ result.memory.residentAfter = reader.Number<uint64_t>();
824
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
825
+ result.memory.allocatedBefore = reader.Number<uint64_t>();
826
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
827
+ result.memory.allocatedAfter = reader.Number<uint64_t>();
828
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
829
+ result.passed = reader.Boolean();
830
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
831
+ if (reader.Boolean() == true) {
832
+ if (reader.Length() < (Core::RealSize<QualityAssurance::IBenchmark::FailureReason>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
833
+ result.failureReason = reader.Number<QualityAssurance::IBenchmark::FailureReason>();
834
+ }
835
+
836
+ return (Core::ERROR_NONE);
837
+ } ();
838
+ } else {
839
+ ASSERT((hresult & COM_ERROR) != 0);
840
+ }
841
+
842
+ if ((hresult & COM_ERROR) != 0) {
843
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>::ID, 5, hresult);
844
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
845
+ }
846
+
847
+ return (result);
848
+ }
849
+
850
+ }; // class RPCIteratorTypeInstance_d47fe5f746e372d7Proxy
851
+
852
+ //
853
+ // QualityAssurance::IBenchmark interface proxy definitions
854
+ //
855
+ // Methods:
856
+ // (0) virtual Core::hresult Trigger(const uint32_t) = 0
857
+ // (1) virtual Core::hresult CollectData(QualityAssurance::IBenchmark::IBenchmarkResultIterator*&) const = 0
858
+ // (2) virtual Core::hresult LatencyThreshold(const uint32_t) = 0
859
+ // (3) virtual Core::hresult LatencyThreshold(uint32_t&) const = 0
860
+ // (4) virtual Core::hresult MemoryThreshold(const uint64_t) = 0
861
+ // (5) virtual Core::hresult MemoryThreshold(uint64_t&) const = 0
862
+ // (6) virtual Core::hresult Register(QualityAssurance::IBenchmark::INotification*) = 0
863
+ // (7) virtual Core::hresult Unregister(QualityAssurance::IBenchmark::INotification*) = 0
864
+ //
865
+
866
+ class QualityAssuranceBenchmarkProxy final : public ProxyStub::UnknownProxyType<QualityAssurance::IBenchmark> {
867
+ public:
868
+ QualityAssuranceBenchmarkProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
869
+ : BaseClass(channel, implementation, otherSideInformed)
870
+ {
871
+ }
872
+
873
+ Core::hresult Trigger(const uint32_t _iterations) override
874
+ {
875
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
876
+
877
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
878
+ writer.Number<uint32_t>(_iterations);
879
+
880
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
881
+ if (hresult == Core::ERROR_NONE) {
882
+ hresult = [&]() -> Core::hresult {
883
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
884
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
885
+ hresult = reader.Number<Core::hresult>();
886
+
887
+ return (hresult);
888
+ } ();
889
+ } else {
890
+ ASSERT((hresult & COM_ERROR) != 0);
891
+ }
892
+
893
+ if ((hresult & COM_ERROR) != 0) {
894
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::ID, 0, hresult);
895
+ }
896
+
897
+ return (hresult);
898
+ }
899
+
900
+ Core::hresult CollectData(QualityAssurance::IBenchmark::IBenchmarkResultIterator*& _report) const override
901
+ {
902
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
903
+
904
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
905
+ if (hresult == Core::ERROR_NONE) {
906
+ hresult = [&]() -> Core::hresult {
907
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
908
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
909
+ hresult = reader.Number<Core::hresult>();
910
+ if ((hresult & COM_ERROR) == 0) {
911
+ _report = reinterpret_cast<QualityAssurance::IBenchmark::IBenchmarkResultIterator*>(static_cast<const ProxyStub::UnknownProxy&>(*this).Interface(reader.Number<Core::instance_id>(), QualityAssurance::IBenchmark::IBenchmarkResultIterator::ID));
912
+ }
913
+
914
+ return (hresult);
915
+ } ();
916
+ } else {
917
+ ASSERT((hresult & COM_ERROR) != 0);
918
+ }
919
+
920
+ if ((hresult & COM_ERROR) != 0) {
921
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::ID, 1, hresult);
922
+ }
923
+
924
+ return (hresult);
925
+ }
926
+
927
+ Core::hresult LatencyThreshold(const uint32_t _maxLatencyDeviationPct) override
928
+ {
929
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
930
+
931
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
932
+ writer.Number<uint32_t>(_maxLatencyDeviationPct);
933
+
934
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
935
+ if (hresult == Core::ERROR_NONE) {
936
+ hresult = [&]() -> Core::hresult {
937
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
938
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
939
+ hresult = reader.Number<Core::hresult>();
940
+
941
+ return (hresult);
942
+ } ();
943
+ } else {
944
+ ASSERT((hresult & COM_ERROR) != 0);
945
+ }
946
+
947
+ if ((hresult & COM_ERROR) != 0) {
948
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::ID, 2, hresult);
949
+ }
950
+
951
+ return (hresult);
952
+ }
953
+
954
+ Core::hresult LatencyThreshold(uint32_t& _maxLatencyDeviationPct) const override
955
+ {
956
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
957
+
958
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
959
+ if (hresult == Core::ERROR_NONE) {
960
+ hresult = [&]() -> Core::hresult {
961
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
962
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
963
+ hresult = reader.Number<Core::hresult>();
964
+ if ((hresult & COM_ERROR) == 0) {
965
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
966
+ _maxLatencyDeviationPct = reader.Number<uint32_t>();
967
+ }
968
+
969
+ return (hresult);
970
+ } ();
971
+ } else {
972
+ ASSERT((hresult & COM_ERROR) != 0);
973
+ }
974
+
975
+ if ((hresult & COM_ERROR) != 0) {
976
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::ID, 3, hresult);
977
+ }
978
+
979
+ return (hresult);
980
+ }
981
+
982
+ Core::hresult MemoryThreshold(const uint64_t _maxMemoryGrowthBytes) override
983
+ {
984
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(4));
985
+
986
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
987
+ writer.Number<uint64_t>(_maxMemoryGrowthBytes);
988
+
989
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
990
+ if (hresult == Core::ERROR_NONE) {
991
+ hresult = [&]() -> Core::hresult {
992
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
993
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
994
+ hresult = reader.Number<Core::hresult>();
995
+
996
+ return (hresult);
997
+ } ();
998
+ } else {
999
+ ASSERT((hresult & COM_ERROR) != 0);
1000
+ }
1001
+
1002
+ if ((hresult & COM_ERROR) != 0) {
1003
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::ID, 4, hresult);
1004
+ }
1005
+
1006
+ return (hresult);
1007
+ }
1008
+
1009
+ Core::hresult MemoryThreshold(uint64_t& _maxMemoryGrowthBytes) const override
1010
+ {
1011
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(5));
1012
+
1013
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1014
+ if (hresult == Core::ERROR_NONE) {
1015
+ hresult = [&]() -> Core::hresult {
1016
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1017
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1018
+ hresult = reader.Number<Core::hresult>();
1019
+ if ((hresult & COM_ERROR) == 0) {
1020
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1021
+ _maxMemoryGrowthBytes = reader.Number<uint64_t>();
1022
+ }
1023
+
1024
+ return (hresult);
1025
+ } ();
1026
+ } else {
1027
+ ASSERT((hresult & COM_ERROR) != 0);
1028
+ }
1029
+
1030
+ if ((hresult & COM_ERROR) != 0) {
1031
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::ID, 5, hresult);
1032
+ }
1033
+
1034
+ return (hresult);
1035
+ }
1036
+
1037
+ Core::hresult Register(QualityAssurance::IBenchmark::INotification* _sink) override
1038
+ {
1039
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(6));
1040
+
1041
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1042
+ writer.Number<Core::instance_id>(RPC::instance_cast(_sink));
1043
+
1044
+ const RPC::InstanceRecord passedInstances[] = { { RPC::instance_cast(_sink), QualityAssurance::IBenchmark::INotification::ID }, { 0, 0 } };
1045
+ static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(passedInstances);
1046
+
1047
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1048
+ if (hresult == Core::ERROR_NONE) {
1049
+ hresult = [&]() -> Core::hresult {
1050
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1051
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1052
+ hresult = reader.Number<Core::hresult>();
1053
+
1054
+ const uint32_t completeResult__ = _Complete(reader);
1055
+ if (completeResult__ != Core::ERROR_NONE) { return (completeResult__); }
1056
+
1057
+ return (hresult);
1058
+ } ();
1059
+ } else {
1060
+ ASSERT((hresult & COM_ERROR) != 0);
1061
+ }
1062
+
1063
+ if ((hresult & COM_ERROR) != 0) {
1064
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::ID, 6, hresult);
1065
+ }
1066
+
1067
+ static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(nullptr);
1068
+
1069
+ return (hresult);
1070
+ }
1071
+
1072
+ Core::hresult Unregister(QualityAssurance::IBenchmark::INotification* _sink) override
1073
+ {
1074
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(7));
1075
+
1076
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1077
+ writer.Number<Core::instance_id>(RPC::instance_cast(_sink));
1078
+
1079
+ const RPC::InstanceRecord passedInstances[] = { { RPC::instance_cast(_sink), QualityAssurance::IBenchmark::INotification::ID }, { 0, 0 } };
1080
+ static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(passedInstances);
1081
+
1082
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1083
+ if (hresult == Core::ERROR_NONE) {
1084
+ hresult = [&]() -> Core::hresult {
1085
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1086
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1087
+ hresult = reader.Number<Core::hresult>();
1088
+
1089
+ const uint32_t completeResult__ = _Complete(reader);
1090
+ if (completeResult__ != Core::ERROR_NONE) { return (completeResult__); }
1091
+
1092
+ return (hresult);
1093
+ } ();
1094
+ } else {
1095
+ ASSERT((hresult & COM_ERROR) != 0);
1096
+ }
1097
+
1098
+ if ((hresult & COM_ERROR) != 0) {
1099
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::ID, 7, hresult);
1100
+ }
1101
+
1102
+ static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(nullptr);
1103
+
1104
+ return (hresult);
1105
+ }
1106
+
1107
+ private:
1108
+ uint32_t _Complete(RPC::Data::Frame::Reader& reader) const
1109
+ {
1110
+ uint32_t result = Core::ERROR_NONE;
1111
+
1112
+ while (reader.HasData() == true) {
1113
+ const size_t entrySize = (sizeof(Core::instance_id) + sizeof(uint32_t) + sizeof(RPC::Data::Output::mode));
1114
+ if (reader.Length() < entrySize) { result = (COM_ERROR | Core::ERROR_READ_ERROR); break; }
1115
+
1116
+ const Core::instance_id implementation = reader.Number<Core::instance_id>();
1117
+ ASSERT(implementation != 0);
1118
+
1119
+ const uint32_t id = reader.Number<uint32_t>();
1120
+ const RPC::Data::Output::mode how = reader.Number<RPC::Data::Output::mode>();
1121
+
1122
+ if (RPC::Administrator::Instance().IsValid(static_cast<const ProxyStub::UnknownProxy&>(*this).Channel(), implementation, id) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
1123
+
1124
+ result = static_cast<const ProxyStub::UnknownProxy&>(*this).Complete(implementation, id, how);
1125
+ if (result != Core::ERROR_NONE) { return (COM_ERROR | result); }
1126
+ }
1127
+
1128
+ return (result);
1129
+ }
1130
+
1131
+ }; // class QualityAssuranceBenchmarkProxy
1132
+
1133
+ //
1134
+ // QualityAssurance::IBenchmark::INotification interface proxy definitions
1135
+ //
1136
+ // Methods:
1137
+ // (0) virtual void PerformanceCheckCompleted() = 0
1138
+ //
1139
+
1140
+ class QualityAssuranceBenchmarkNotificationProxy final : public ProxyStub::UnknownProxyType<QualityAssurance::IBenchmark::INotification> {
1141
+ public:
1142
+ QualityAssuranceBenchmarkNotificationProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
1143
+ : BaseClass(channel, implementation, otherSideInformed)
1144
+ {
1145
+ }
1146
+
1147
+ void PerformanceCheckCompleted() override
1148
+ {
1149
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
1150
+
1151
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1152
+ if (hresult == Core::ERROR_NONE) {
1153
+ hresult = [&]() -> Core::hresult {
1154
+
1155
+ return (Core::ERROR_NONE);
1156
+ } ();
1157
+ } else {
1158
+ ASSERT((hresult & COM_ERROR) != 0);
1159
+ }
1160
+
1161
+ if ((hresult & COM_ERROR) != 0) {
1162
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmark::INotification::ID, 0, hresult);
1163
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
1164
+ }
1165
+ }
1166
+
1167
+ }; // class QualityAssuranceBenchmarkNotificationProxy
1168
+
1169
+ POP_WARNING()
1170
+ POP_WARNING()
1171
+
1172
+ // -----------------------------------------------------------------
1173
+ // REGISTRATION
1174
+ // -----------------------------------------------------------------
1175
+ namespace {
1176
+
1177
+ typedef ProxyStub::UnknownStubType<RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>, RPCIteratorTypeInstance_d47fe5f746e372d7StubMethods> RPCIteratorTypeInstance_d47fe5f746e372d7Stub;
1178
+ typedef ProxyStub::UnknownStubType<QualityAssurance::IBenchmark, QualityAssuranceBenchmarkStubMethods> QualityAssuranceBenchmarkStub;
1179
+ typedef ProxyStub::UnknownStubType<QualityAssurance::IBenchmark::INotification, QualityAssuranceBenchmarkNotificationStubMethods> QualityAssuranceBenchmarkNotificationStub;
1180
+
1181
+ static class Instantiation {
1182
+ public:
1183
+ Instantiation()
1184
+ {
1185
+ const RPC::SecureProxyStubType security = static_cast<RPC::SecureProxyStubType>(static_cast<std::underlying_type<RPC::SecureProxyStubType>::type>(RPC::SecureProxyStubType::PROXYSTUBS_SECURITY_SECURE) | static_cast<std::underlying_type<RPC::SecureProxyStubType>::type>(RPC::SecureProxyStubType::PROXYSTUBS_SECURITY_COHERENT));
1186
+
1187
+ RPC::Administrator::Instance().Announce<RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>, RPCIteratorTypeInstance_d47fe5f746e372d7Proxy, RPCIteratorTypeInstance_d47fe5f746e372d7Stub>(security);
1188
+ RPC::Administrator::Instance().Announce<QualityAssurance::IBenchmark, QualityAssuranceBenchmarkProxy, QualityAssuranceBenchmarkStub>(security);
1189
+ RPC::Administrator::Instance().Announce<QualityAssurance::IBenchmark::INotification, QualityAssuranceBenchmarkNotificationProxy, QualityAssuranceBenchmarkNotificationStub>(security);
1190
+ }
1191
+ ~Instantiation()
1192
+ {
1193
+ RPC::Administrator::Instance().Recall<RPC::IIteratorType<QualityAssurance::IBenchmark::BenchmarkResult, QualityAssurance::ID_BENCHMARK_RESULT_ITERATOR>>();
1194
+ RPC::Administrator::Instance().Recall<QualityAssurance::IBenchmark>();
1195
+ RPC::Administrator::Instance().Recall<QualityAssurance::IBenchmark::INotification>();
1196
+ }
1197
+ } ProxyStubRegistration;
1198
+
1199
+ } // namespace
1200
+
1201
+ } // namespace ProxyStubs
1202
+
1203
+ }
Release/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_BenchmarkPayload.cpp CHANGED
@@ -0,0 +1,1995 @@
1
+ //
2
+ // generated automatically from "IBenchmarkPayload.h"
3
+ //
4
+ // implements COM-RPC proxy stubs for:
5
+ // - class RPC::IIteratorType<typename ELEMENT, const uint32_t INTERFACE_ID> [with ELEMENT = QualityAssurance::IBenchmarkPayload::PayloadType, INTERFACE_ID = QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR] [[iterator]]
6
+ // - class QualityAssurance::IBenchmarkPayload
7
+ //
8
+ // secure code enabled:
9
+ // - instance verification enabled
10
+ // - range verification enabled
11
+ // - frame coherency verification enabled
12
+ //
13
+
14
+ #include "Module.h"
15
+ #include "IBenchmarkPayload.h"
16
+
17
+ #include <com/com.h>
18
+
19
+ namespace Thunder {
20
+
21
+ namespace ProxyStubs {
22
+
23
+ PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
24
+ PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
25
+
26
+ // -----------------------------------------------------------------
27
+ // STUBS
28
+ // -----------------------------------------------------------------
29
+
30
+ //
31
+ // RPC::IIteratorTypeInstance_05353879ce17b341 interface stub definitions
32
+ //
33
+ // Methods:
34
+ // (0) virtual bool Next(QualityAssurance::IBenchmarkPayload::PayloadType&) = 0
35
+ // (1) virtual bool Previous(QualityAssurance::IBenchmarkPayload::PayloadType&) = 0
36
+ // (2) virtual void Reset(const uint32_t) = 0
37
+ // (3) virtual bool IsValid() const = 0
38
+ // (4) virtual uint32_t Count() const = 0
39
+ // (5) virtual QualityAssurance::IBenchmarkPayload::PayloadType Current() const = 0
40
+ //
41
+
42
+ static ProxyStub::MethodHandler RPCIteratorTypeInstance_05353879ce17b341StubMethods[] = {
43
+ // (0) virtual bool Next(QualityAssurance::IBenchmarkPayload::PayloadType&) = 0
44
+ //
45
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
46
+ Core::hresult hresult = Core::ERROR_NONE;
47
+
48
+ hresult = [&]() -> Core::hresult {
49
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>;
50
+
51
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
52
+
53
+ interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
54
+ ASSERT(implementation != nullptr);
55
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
56
+
57
+ QualityAssurance::IBenchmarkPayload::PayloadType _info{};
58
+
59
+ bool result = implementation->Next(_info);
60
+
61
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
62
+ writer.Boolean(result);
63
+ writer.Number<QualityAssurance::IBenchmarkPayload::PayloadType>(_info);
64
+
65
+ return (Core::ERROR_NONE);
66
+ } ();
67
+
68
+ if (hresult != Core::ERROR_NONE) {
69
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>::ID, 0, hresult);
70
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
71
+ }
72
+ },
73
+
74
+ // (1) virtual bool Previous(QualityAssurance::IBenchmarkPayload::PayloadType&) = 0
75
+ //
76
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
77
+ Core::hresult hresult = Core::ERROR_NONE;
78
+
79
+ hresult = [&]() -> Core::hresult {
80
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>;
81
+
82
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
83
+
84
+ interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
85
+ ASSERT(implementation != nullptr);
86
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
87
+
88
+ QualityAssurance::IBenchmarkPayload::PayloadType _info{};
89
+
90
+ bool result = implementation->Previous(_info);
91
+
92
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
93
+ writer.Boolean(result);
94
+ writer.Number<QualityAssurance::IBenchmarkPayload::PayloadType>(_info);
95
+
96
+ return (Core::ERROR_NONE);
97
+ } ();
98
+
99
+ if (hresult != Core::ERROR_NONE) {
100
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>::ID, 1, hresult);
101
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
102
+ }
103
+ },
104
+
105
+ // (2) virtual void Reset(const uint32_t) = 0
106
+ //
107
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
108
+ Core::hresult hresult = Core::ERROR_NONE;
109
+
110
+ hresult = [&]() -> Core::hresult {
111
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>;
112
+
113
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
114
+
115
+ interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
116
+ ASSERT(implementation != nullptr);
117
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
118
+
119
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
120
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
121
+ const uint32_t _position = reader.Number<uint32_t>();
122
+
123
+ implementation->Reset(_position);
124
+
125
+ return (Core::ERROR_NONE);
126
+ } ();
127
+
128
+ if (hresult != Core::ERROR_NONE) {
129
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>::ID, 2, hresult);
130
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
131
+ }
132
+ },
133
+
134
+ // (3) virtual bool IsValid() const = 0
135
+ //
136
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
137
+ Core::hresult hresult = Core::ERROR_NONE;
138
+
139
+ hresult = [&]() -> Core::hresult {
140
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>;
141
+
142
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
143
+
144
+ const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
145
+ ASSERT(implementation != nullptr);
146
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
147
+
148
+ bool result = implementation->IsValid();
149
+
150
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
151
+ writer.Boolean(result);
152
+
153
+ return (Core::ERROR_NONE);
154
+ } ();
155
+
156
+ if (hresult != Core::ERROR_NONE) {
157
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>::ID, 3, hresult);
158
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
159
+ }
160
+ },
161
+
162
+ // (4) virtual uint32_t Count() const = 0
163
+ //
164
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
165
+ Core::hresult hresult = Core::ERROR_NONE;
166
+
167
+ hresult = [&]() -> Core::hresult {
168
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>;
169
+
170
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
171
+
172
+ const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
173
+ ASSERT(implementation != nullptr);
174
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
175
+
176
+ uint32_t result = implementation->Count();
177
+
178
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
179
+ writer.Number<uint32_t>(result);
180
+
181
+ return (Core::ERROR_NONE);
182
+ } ();
183
+
184
+ if (hresult != Core::ERROR_NONE) {
185
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>::ID, 4, hresult);
186
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
187
+ }
188
+ },
189
+
190
+ // (5) virtual QualityAssurance::IBenchmarkPayload::PayloadType Current() const = 0
191
+ //
192
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
193
+ Core::hresult hresult = Core::ERROR_NONE;
194
+
195
+ hresult = [&]() -> Core::hresult {
196
+ using interface = RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>;
197
+
198
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
199
+
200
+ const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
201
+ ASSERT(implementation != nullptr);
202
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), interface::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
203
+
204
+ QualityAssurance::IBenchmarkPayload::PayloadType result = implementation->Current();
205
+
206
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
207
+ writer.Number<QualityAssurance::IBenchmarkPayload::PayloadType>(result);
208
+
209
+ return (Core::ERROR_NONE);
210
+ } ();
211
+
212
+ if (hresult != Core::ERROR_NONE) {
213
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>::ID, 5, hresult);
214
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
215
+ }
216
+ }
217
+ , nullptr
218
+ }; // RPCIteratorTypeInstance_05353879ce17b341StubMethods
219
+
220
+ //
221
+ // QualityAssurance::IBenchmarkPayload interface stub definitions
222
+ //
223
+ // Methods:
224
+ // (0) virtual Core::hresult GetPayloadTypes(QualityAssurance::IBenchmarkPayload::IPayloadTypeIterator*&) const = 0
225
+ // (1) virtual Core::hresult SendUint16(const uint16_t) = 0
226
+ // (2) virtual Core::hresult SendUint32(const uint32_t) = 0
227
+ // (3) virtual Core::hresult SendUint64(const uint64_t) = 0
228
+ // (4) virtual Core::hresult SendBool(const bool) = 0
229
+ // (5) virtual Core::hresult SendFloat(const float) = 0
230
+ // (6) virtual Core::hresult SendDouble(const double) = 0
231
+ // (7) virtual Core::hresult SendString(const string&) = 0
232
+ // (8) virtual Core::hresult SendSampleData(const QualityAssurance::IBenchmarkPayload::SampleData&) = 0
233
+ // (9) virtual Core::hresult SendNoPayload() = 0
234
+ // (10) virtual Core::hresult SendBuffer(const uint16_t, const uint8_t*) = 0
235
+ // (11) virtual Core::hresult SendUint32Vector(const std::vector<uint32_t>&) = 0
236
+ // (12) virtual Core::hresult SendReceiveUint16(const uint16_t, uint16_t&) const = 0
237
+ // (13) virtual Core::hresult SendReceiveUint32(const uint32_t, uint32_t&) const = 0
238
+ // (14) virtual Core::hresult SendReceiveUint64(const uint64_t, uint64_t&) const = 0
239
+ // (15) virtual Core::hresult SendReceiveBool(const bool, bool&) const = 0
240
+ // (16) virtual Core::hresult SendReceiveFloat(const float, float&) const = 0
241
+ // (17) virtual Core::hresult SendReceiveDouble(const double, double&) const = 0
242
+ // (18) virtual Core::hresult SendReceiveString(const string&, string&) const = 0
243
+ // (19) virtual Core::hresult SendReceiveSampleData(const QualityAssurance::IBenchmarkPayload::SampleData&, QualityAssurance::IBenchmarkPayload::SampleData&) const = 0
244
+ // (20) virtual Core::hresult SendReceiveBuffer(uint16_t&, uint8_t*) const = 0
245
+ // (21) virtual Core::hresult SendReceiveUint32Vector(const std::vector<uint32_t>&, std::vector<uint32_t>&) const = 0
246
+ // (22) virtual Core::hresult Add(const uint32_t, const uint32_t, uint32_t&) const = 0
247
+ //
248
+
249
+ static ProxyStub::MethodHandler QualityAssuranceBenchmarkPayloadStubMethods[] = {
250
+ // (0) virtual Core::hresult GetPayloadTypes(QualityAssurance::IBenchmarkPayload::IPayloadTypeIterator*&) const = 0
251
+ //
252
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
253
+ Core::hresult hresult = Core::ERROR_NONE;
254
+
255
+ hresult = [&]() -> Core::hresult {
256
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
257
+
258
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
259
+ ASSERT(implementation != nullptr);
260
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
261
+
262
+ QualityAssurance::IBenchmarkPayload::IPayloadTypeIterator* _types{};
263
+
264
+ Core::hresult result = implementation->GetPayloadTypes(_types);
265
+
266
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
267
+ writer.Number<Core::hresult>(result);
268
+ writer.Number<Core::instance_id>(RPC::instance_cast(_types));
269
+
270
+ RPC::Administrator::Instance().RegisterInterface(channel, _types);
271
+
272
+ return (Core::ERROR_NONE);
273
+ } ();
274
+
275
+ if (hresult != Core::ERROR_NONE) {
276
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
277
+ writer.Number<uint32_t>(hresult);
278
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 0, hresult);
279
+ }
280
+ },
281
+
282
+ // (1) virtual Core::hresult SendUint16(const uint16_t) = 0
283
+ //
284
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
285
+ Core::hresult hresult = Core::ERROR_NONE;
286
+
287
+ hresult = [&]() -> Core::hresult {
288
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
289
+
290
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
291
+ ASSERT(implementation != nullptr);
292
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
293
+
294
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
295
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
296
+ const uint16_t _value = reader.Number<uint16_t>();
297
+
298
+ Core::hresult result = implementation->SendUint16(_value);
299
+
300
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
301
+ writer.Number<Core::hresult>(result);
302
+
303
+ return (Core::ERROR_NONE);
304
+ } ();
305
+
306
+ if (hresult != Core::ERROR_NONE) {
307
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
308
+ writer.Number<uint32_t>(hresult);
309
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 1, hresult);
310
+ }
311
+ },
312
+
313
+ // (2) virtual Core::hresult SendUint32(const uint32_t) = 0
314
+ //
315
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
316
+ Core::hresult hresult = Core::ERROR_NONE;
317
+
318
+ hresult = [&]() -> Core::hresult {
319
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
320
+
321
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
322
+ ASSERT(implementation != nullptr);
323
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
324
+
325
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
326
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
327
+ const uint32_t _value = reader.Number<uint32_t>();
328
+
329
+ Core::hresult result = implementation->SendUint32(_value);
330
+
331
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
332
+ writer.Number<Core::hresult>(result);
333
+
334
+ return (Core::ERROR_NONE);
335
+ } ();
336
+
337
+ if (hresult != Core::ERROR_NONE) {
338
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
339
+ writer.Number<uint32_t>(hresult);
340
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 2, hresult);
341
+ }
342
+ },
343
+
344
+ // (3) virtual Core::hresult SendUint64(const uint64_t) = 0
345
+ //
346
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
347
+ Core::hresult hresult = Core::ERROR_NONE;
348
+
349
+ hresult = [&]() -> Core::hresult {
350
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
351
+
352
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
353
+ ASSERT(implementation != nullptr);
354
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
355
+
356
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
357
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
358
+ const uint64_t _value = reader.Number<uint64_t>();
359
+
360
+ Core::hresult result = implementation->SendUint64(_value);
361
+
362
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
363
+ writer.Number<Core::hresult>(result);
364
+
365
+ return (Core::ERROR_NONE);
366
+ } ();
367
+
368
+ if (hresult != Core::ERROR_NONE) {
369
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
370
+ writer.Number<uint32_t>(hresult);
371
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 3, hresult);
372
+ }
373
+ },
374
+
375
+ // (4) virtual Core::hresult SendBool(const bool) = 0
376
+ //
377
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
378
+ Core::hresult hresult = Core::ERROR_NONE;
379
+
380
+ hresult = [&]() -> Core::hresult {
381
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
382
+
383
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
384
+ ASSERT(implementation != nullptr);
385
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
386
+
387
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
388
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
389
+ const bool _value = reader.Boolean();
390
+
391
+ Core::hresult result = implementation->SendBool(_value);
392
+
393
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
394
+ writer.Number<Core::hresult>(result);
395
+
396
+ return (Core::ERROR_NONE);
397
+ } ();
398
+
399
+ if (hresult != Core::ERROR_NONE) {
400
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
401
+ writer.Number<uint32_t>(hresult);
402
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 4, hresult);
403
+ }
404
+ },
405
+
406
+ // (5) virtual Core::hresult SendFloat(const float) = 0
407
+ //
408
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
409
+ Core::hresult hresult = Core::ERROR_NONE;
410
+
411
+ hresult = [&]() -> Core::hresult {
412
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
413
+
414
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
415
+ ASSERT(implementation != nullptr);
416
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
417
+
418
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
419
+ if (reader.Length() < (Core::RealSize<float>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
420
+ const float _value = reader.Number<float>();
421
+
422
+ Core::hresult result = implementation->SendFloat(_value);
423
+
424
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
425
+ writer.Number<Core::hresult>(result);
426
+
427
+ return (Core::ERROR_NONE);
428
+ } ();
429
+
430
+ if (hresult != Core::ERROR_NONE) {
431
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
432
+ writer.Number<uint32_t>(hresult);
433
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 5, hresult);
434
+ }
435
+ },
436
+
437
+ // (6) virtual Core::hresult SendDouble(const double) = 0
438
+ //
439
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
440
+ Core::hresult hresult = Core::ERROR_NONE;
441
+
442
+ hresult = [&]() -> Core::hresult {
443
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
444
+
445
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
446
+ ASSERT(implementation != nullptr);
447
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
448
+
449
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
450
+ if (reader.Length() < (Core::RealSize<double>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
451
+ const double _value = reader.Number<double>();
452
+
453
+ Core::hresult result = implementation->SendDouble(_value);
454
+
455
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
456
+ writer.Number<Core::hresult>(result);
457
+
458
+ return (Core::ERROR_NONE);
459
+ } ();
460
+
461
+ if (hresult != Core::ERROR_NONE) {
462
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
463
+ writer.Number<uint32_t>(hresult);
464
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 6, hresult);
465
+ }
466
+ },
467
+
468
+ // (7) virtual Core::hresult SendString(const string&) = 0
469
+ //
470
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
471
+ Core::hresult hresult = Core::ERROR_NONE;
472
+
473
+ hresult = [&]() -> Core::hresult {
474
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
475
+
476
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
477
+ ASSERT(implementation != nullptr);
478
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
479
+
480
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
481
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
482
+ const uint16_t _valuePeekedLen__ = reader.PeekNumber<uint16_t>();
483
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _valuePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
484
+ const string _value = reader.Text();
485
+
486
+ Core::hresult result = implementation->SendString(static_cast<const string&>(_value));
487
+
488
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
489
+ writer.Number<Core::hresult>(result);
490
+
491
+ return (Core::ERROR_NONE);
492
+ } ();
493
+
494
+ if (hresult != Core::ERROR_NONE) {
495
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
496
+ writer.Number<uint32_t>(hresult);
497
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 7, hresult);
498
+ }
499
+ },
500
+
501
+ // (8) virtual Core::hresult SendSampleData(const QualityAssurance::IBenchmarkPayload::SampleData&) = 0
502
+ //
503
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
504
+ Core::hresult hresult = Core::ERROR_NONE;
505
+
506
+ hresult = [&]() -> Core::hresult {
507
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
508
+
509
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
510
+ ASSERT(implementation != nullptr);
511
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
512
+
513
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
514
+ QualityAssurance::IBenchmarkPayload::SampleData _data{};
515
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
516
+ _data.id = reader.Number<uint32_t>();
517
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
518
+ _data.value = reader.Number<uint32_t>();
519
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
520
+ const uint16_t _data_namePeekedLen__ = reader.PeekNumber<uint16_t>();
521
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _data_namePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
522
+ _data.name = reader.Text();
523
+
524
+ Core::hresult result = implementation->SendSampleData(static_cast<const QualityAssurance::IBenchmarkPayload::SampleData&>(_data));
525
+
526
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
527
+ writer.Number<Core::hresult>(result);
528
+
529
+ return (Core::ERROR_NONE);
530
+ } ();
531
+
532
+ if (hresult != Core::ERROR_NONE) {
533
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
534
+ writer.Number<uint32_t>(hresult);
535
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 8, hresult);
536
+ }
537
+ },
538
+
539
+ // (9) virtual Core::hresult SendNoPayload() = 0
540
+ //
541
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
542
+ Core::hresult hresult = Core::ERROR_NONE;
543
+
544
+ hresult = [&]() -> Core::hresult {
545
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
546
+
547
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
548
+ ASSERT(implementation != nullptr);
549
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
550
+
551
+ Core::hresult result = implementation->SendNoPayload();
552
+
553
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
554
+ writer.Number<Core::hresult>(result);
555
+
556
+ return (Core::ERROR_NONE);
557
+ } ();
558
+
559
+ if (hresult != Core::ERROR_NONE) {
560
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
561
+ writer.Number<uint32_t>(hresult);
562
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 9, hresult);
563
+ }
564
+ },
565
+
566
+ // (10) virtual Core::hresult SendBuffer(const uint16_t, const uint8_t*) = 0
567
+ //
568
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
569
+ Core::hresult hresult = Core::ERROR_NONE;
570
+
571
+ hresult = [&]() -> Core::hresult {
572
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
573
+
574
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
575
+ ASSERT(implementation != nullptr);
576
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
577
+
578
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
579
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
580
+ const uint16_t _bufferPeekedLen__ = reader.PeekNumber<uint16_t>();
581
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _bufferPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
582
+ const uint8_t* _buffer{};
583
+ const uint16_t _bufferSize = reader.LockBuffer<uint16_t>(_buffer);
584
+ reader.UnlockBuffer(_bufferSize);
585
+
586
+ Core::hresult result = implementation->SendBuffer(_bufferSize, _buffer);
587
+
588
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
589
+ writer.Number<Core::hresult>(result);
590
+
591
+ return (Core::ERROR_NONE);
592
+ } ();
593
+
594
+ if (hresult != Core::ERROR_NONE) {
595
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
596
+ writer.Number<uint32_t>(hresult);
597
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 10, hresult);
598
+ }
599
+ },
600
+
601
+ // (11) virtual Core::hresult SendUint32Vector(const std::vector<uint32_t>&) = 0
602
+ //
603
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
604
+ Core::hresult hresult = Core::ERROR_NONE;
605
+
606
+ hresult = [&]() -> Core::hresult {
607
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
608
+
609
+ QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
610
+ ASSERT(implementation != nullptr);
611
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
612
+
613
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
614
+ std::vector<uint32_t> _data{};
615
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
616
+ uint16_t _dataSize = reader.Number<uint16_t>();
617
+ ASSERT((_dataSize >= 1) && (_dataSize <= 1024));
618
+ if (!((_dataSize >= 1) && (_dataSize <= 1024))) { return (COM_ERROR | Core::ERROR_INVALID_RANGE); }
619
+ _data.reserve(_dataSize);
620
+ for (uint16_t i = 0; i < _dataSize; i++) {
621
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
622
+ uint32_t _dataItem = reader.Number<uint32_t>();
623
+ _data.push_back(std::move(_dataItem));
624
+ }
625
+
626
+ Core::hresult result = implementation->SendUint32Vector(static_cast<const std::vector<uint32_t>&>(_data));
627
+
628
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
629
+ writer.Number<Core::hresult>(result);
630
+
631
+ return (Core::ERROR_NONE);
632
+ } ();
633
+
634
+ if (hresult != Core::ERROR_NONE) {
635
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
636
+ writer.Number<uint32_t>(hresult);
637
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 11, hresult);
638
+ }
639
+ },
640
+
641
+ // (12) virtual Core::hresult SendReceiveUint16(const uint16_t, uint16_t&) const = 0
642
+ //
643
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
644
+ Core::hresult hresult = Core::ERROR_NONE;
645
+
646
+ hresult = [&]() -> Core::hresult {
647
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
648
+
649
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
650
+ ASSERT(implementation != nullptr);
651
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
652
+
653
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
654
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
655
+ const uint16_t _input = reader.Number<uint16_t>();
656
+
657
+ uint16_t _output{};
658
+
659
+ Core::hresult result = implementation->SendReceiveUint16(_input, _output);
660
+
661
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
662
+ writer.Number<Core::hresult>(result);
663
+ writer.Number<uint16_t>(_output);
664
+
665
+ return (Core::ERROR_NONE);
666
+ } ();
667
+
668
+ if (hresult != Core::ERROR_NONE) {
669
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
670
+ writer.Number<uint32_t>(hresult);
671
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 12, hresult);
672
+ }
673
+ },
674
+
675
+ // (13) virtual Core::hresult SendReceiveUint32(const uint32_t, uint32_t&) const = 0
676
+ //
677
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
678
+ Core::hresult hresult = Core::ERROR_NONE;
679
+
680
+ hresult = [&]() -> Core::hresult {
681
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
682
+
683
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
684
+ ASSERT(implementation != nullptr);
685
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
686
+
687
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
688
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
689
+ const uint32_t _input = reader.Number<uint32_t>();
690
+
691
+ uint32_t _output{};
692
+
693
+ Core::hresult result = implementation->SendReceiveUint32(_input, _output);
694
+
695
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
696
+ writer.Number<Core::hresult>(result);
697
+ writer.Number<uint32_t>(_output);
698
+
699
+ return (Core::ERROR_NONE);
700
+ } ();
701
+
702
+ if (hresult != Core::ERROR_NONE) {
703
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
704
+ writer.Number<uint32_t>(hresult);
705
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 13, hresult);
706
+ }
707
+ },
708
+
709
+ // (14) virtual Core::hresult SendReceiveUint64(const uint64_t, uint64_t&) const = 0
710
+ //
711
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
712
+ Core::hresult hresult = Core::ERROR_NONE;
713
+
714
+ hresult = [&]() -> Core::hresult {
715
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
716
+
717
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
718
+ ASSERT(implementation != nullptr);
719
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
720
+
721
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
722
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
723
+ const uint64_t _input = reader.Number<uint64_t>();
724
+
725
+ uint64_t _output{};
726
+
727
+ Core::hresult result = implementation->SendReceiveUint64(_input, _output);
728
+
729
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
730
+ writer.Number<Core::hresult>(result);
731
+ writer.Number<uint64_t>(_output);
732
+
733
+ return (Core::ERROR_NONE);
734
+ } ();
735
+
736
+ if (hresult != Core::ERROR_NONE) {
737
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
738
+ writer.Number<uint32_t>(hresult);
739
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 14, hresult);
740
+ }
741
+ },
742
+
743
+ // (15) virtual Core::hresult SendReceiveBool(const bool, bool&) const = 0
744
+ //
745
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
746
+ Core::hresult hresult = Core::ERROR_NONE;
747
+
748
+ hresult = [&]() -> Core::hresult {
749
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
750
+
751
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
752
+ ASSERT(implementation != nullptr);
753
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
754
+
755
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
756
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
757
+ const bool _input = reader.Boolean();
758
+
759
+ bool _output{};
760
+
761
+ Core::hresult result = implementation->SendReceiveBool(_input, _output);
762
+
763
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
764
+ writer.Number<Core::hresult>(result);
765
+ writer.Boolean(_output);
766
+
767
+ return (Core::ERROR_NONE);
768
+ } ();
769
+
770
+ if (hresult != Core::ERROR_NONE) {
771
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
772
+ writer.Number<uint32_t>(hresult);
773
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 15, hresult);
774
+ }
775
+ },
776
+
777
+ // (16) virtual Core::hresult SendReceiveFloat(const float, float&) const = 0
778
+ //
779
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
780
+ Core::hresult hresult = Core::ERROR_NONE;
781
+
782
+ hresult = [&]() -> Core::hresult {
783
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
784
+
785
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
786
+ ASSERT(implementation != nullptr);
787
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
788
+
789
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
790
+ if (reader.Length() < (Core::RealSize<float>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
791
+ const float _input = reader.Number<float>();
792
+
793
+ float _output{};
794
+
795
+ Core::hresult result = implementation->SendReceiveFloat(_input, _output);
796
+
797
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
798
+ writer.Number<Core::hresult>(result);
799
+ writer.Number<float>(_output);
800
+
801
+ return (Core::ERROR_NONE);
802
+ } ();
803
+
804
+ if (hresult != Core::ERROR_NONE) {
805
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
806
+ writer.Number<uint32_t>(hresult);
807
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 16, hresult);
808
+ }
809
+ },
810
+
811
+ // (17) virtual Core::hresult SendReceiveDouble(const double, double&) const = 0
812
+ //
813
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
814
+ Core::hresult hresult = Core::ERROR_NONE;
815
+
816
+ hresult = [&]() -> Core::hresult {
817
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
818
+
819
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
820
+ ASSERT(implementation != nullptr);
821
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
822
+
823
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
824
+ if (reader.Length() < (Core::RealSize<double>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
825
+ const double _input = reader.Number<double>();
826
+
827
+ double _output{};
828
+
829
+ Core::hresult result = implementation->SendReceiveDouble(_input, _output);
830
+
831
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
832
+ writer.Number<Core::hresult>(result);
833
+ writer.Number<double>(_output);
834
+
835
+ return (Core::ERROR_NONE);
836
+ } ();
837
+
838
+ if (hresult != Core::ERROR_NONE) {
839
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
840
+ writer.Number<uint32_t>(hresult);
841
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 17, hresult);
842
+ }
843
+ },
844
+
845
+ // (18) virtual Core::hresult SendReceiveString(const string&, string&) const = 0
846
+ //
847
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
848
+ Core::hresult hresult = Core::ERROR_NONE;
849
+
850
+ hresult = [&]() -> Core::hresult {
851
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
852
+
853
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
854
+ ASSERT(implementation != nullptr);
855
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
856
+
857
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
858
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
859
+ const uint16_t _inputPeekedLen__ = reader.PeekNumber<uint16_t>();
860
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _inputPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
861
+ const string _input = reader.Text();
862
+
863
+ string _output{};
864
+
865
+ Core::hresult result = implementation->SendReceiveString(static_cast<const string&>(_input), _output);
866
+
867
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
868
+ writer.Number<Core::hresult>(result);
869
+ writer.Text(_output);
870
+
871
+ return (Core::ERROR_NONE);
872
+ } ();
873
+
874
+ if (hresult != Core::ERROR_NONE) {
875
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
876
+ writer.Number<uint32_t>(hresult);
877
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 18, hresult);
878
+ }
879
+ },
880
+
881
+ // (19) virtual Core::hresult SendReceiveSampleData(const QualityAssurance::IBenchmarkPayload::SampleData&, QualityAssurance::IBenchmarkPayload::SampleData&) const = 0
882
+ //
883
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
884
+ Core::hresult hresult = Core::ERROR_NONE;
885
+
886
+ hresult = [&]() -> Core::hresult {
887
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
888
+
889
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
890
+ ASSERT(implementation != nullptr);
891
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
892
+
893
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
894
+ QualityAssurance::IBenchmarkPayload::SampleData _input{};
895
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
896
+ _input.id = reader.Number<uint32_t>();
897
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
898
+ _input.value = reader.Number<uint32_t>();
899
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
900
+ const uint16_t _input_namePeekedLen__ = reader.PeekNumber<uint16_t>();
901
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _input_namePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
902
+ _input.name = reader.Text();
903
+
904
+ QualityAssurance::IBenchmarkPayload::SampleData _output{};
905
+
906
+ Core::hresult result = implementation->SendReceiveSampleData(static_cast<const QualityAssurance::IBenchmarkPayload::SampleData&>(_input), _output);
907
+
908
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
909
+ writer.Number<Core::hresult>(result);
910
+ writer.Number<uint32_t>(_output.id);
911
+ writer.Number<uint32_t>(_output.value);
912
+ writer.Text(_output.name);
913
+
914
+ return (Core::ERROR_NONE);
915
+ } ();
916
+
917
+ if (hresult != Core::ERROR_NONE) {
918
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
919
+ writer.Number<uint32_t>(hresult);
920
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 19, hresult);
921
+ }
922
+ },
923
+
924
+ // (20) virtual Core::hresult SendReceiveBuffer(uint16_t&, uint8_t*) const = 0
925
+ //
926
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
927
+ Core::hresult hresult = Core::ERROR_NONE;
928
+
929
+ hresult = [&]() -> Core::hresult {
930
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
931
+
932
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
933
+ ASSERT(implementation != nullptr);
934
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
935
+
936
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
937
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
938
+ const uint16_t _bufferPeekedLen__ = reader.PeekNumber<uint16_t>();
939
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _bufferPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
940
+ uint8_t* _buffer{};
941
+ uint16_t _bufferSize = reader.LockBuffer<uint16_t>(const_cast<const uint8_t*&>(_buffer));
942
+ reader.UnlockBuffer(_bufferSize);
943
+
944
+
945
+ Core::hresult result = implementation->SendReceiveBuffer(_bufferSize, _buffer);
946
+
947
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
948
+ writer.Number<Core::hresult>(result);
949
+ writer.Buffer<uint16_t>((_buffer == nullptr? 0 : _bufferSize), _buffer);
950
+ writer.Number<uint16_t>(_bufferSize);
951
+
952
+ return (Core::ERROR_NONE);
953
+ } ();
954
+
955
+ if (hresult != Core::ERROR_NONE) {
956
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
957
+ writer.Number<uint32_t>(hresult);
958
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 20, hresult);
959
+ }
960
+ },
961
+
962
+ // (21) virtual Core::hresult SendReceiveUint32Vector(const std::vector<uint32_t>&, std::vector<uint32_t>&) const = 0
963
+ //
964
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
965
+ Core::hresult hresult = Core::ERROR_NONE;
966
+
967
+ hresult = [&]() -> Core::hresult {
968
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
969
+
970
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
971
+ ASSERT(implementation != nullptr);
972
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
973
+
974
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
975
+ std::vector<uint32_t> _input{};
976
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
977
+ uint16_t _inputSize = reader.Number<uint16_t>();
978
+ ASSERT((_inputSize >= 1) && (_inputSize <= 1024));
979
+ if (!((_inputSize >= 1) && (_inputSize <= 1024))) { return (COM_ERROR | Core::ERROR_INVALID_RANGE); }
980
+ _input.reserve(_inputSize);
981
+ for (uint16_t i = 0; i < _inputSize; i++) {
982
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
983
+ uint32_t _inputItem = reader.Number<uint32_t>();
984
+ _input.push_back(std::move(_inputItem));
985
+ }
986
+
987
+ std::vector<uint32_t> _output{};
988
+
989
+ Core::hresult result = implementation->SendReceiveUint32Vector(static_cast<const std::vector<uint32_t>&>(_input), _output);
990
+
991
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
992
+ writer.Number<Core::hresult>(result);
993
+ writer.Number<uint16_t>(_output.size());
994
+ for (uint16_t i = 0; i < _output.size(); i++) {
995
+ writer.Number<uint32_t>(_output[i]);
996
+ }
997
+
998
+ return (Core::ERROR_NONE);
999
+ } ();
1000
+
1001
+ if (hresult != Core::ERROR_NONE) {
1002
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
1003
+ writer.Number<uint32_t>(hresult);
1004
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 21, hresult);
1005
+ }
1006
+ },
1007
+
1008
+ // (22) virtual Core::hresult Add(const uint32_t, const uint32_t, uint32_t&) const = 0
1009
+ //
1010
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
1011
+ Core::hresult hresult = Core::ERROR_NONE;
1012
+
1013
+ hresult = [&]() -> Core::hresult {
1014
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1015
+
1016
+ const QualityAssurance::IBenchmarkPayload* implementation = reinterpret_cast<const QualityAssurance::IBenchmarkPayload*>(message->Parameters().Implementation());
1017
+ ASSERT(implementation != nullptr);
1018
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::IBenchmarkPayload::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
1019
+
1020
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
1021
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1022
+ const uint32_t _a = reader.Number<uint32_t>();
1023
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1024
+ const uint32_t _b = reader.Number<uint32_t>();
1025
+
1026
+ uint32_t _result{};
1027
+
1028
+ Core::hresult result = implementation->Add(_a, _b, _result);
1029
+
1030
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
1031
+ writer.Number<Core::hresult>(result);
1032
+ writer.Number<uint32_t>(_result);
1033
+
1034
+ return (Core::ERROR_NONE);
1035
+ } ();
1036
+
1037
+ if (hresult != Core::ERROR_NONE) {
1038
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
1039
+ writer.Number<uint32_t>(hresult);
1040
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 22, hresult);
1041
+ }
1042
+ }
1043
+ , nullptr
1044
+ }; // QualityAssuranceBenchmarkPayloadStubMethods
1045
+
1046
+ // -----------------------------------------------------------------
1047
+ // PROXIES
1048
+ // -----------------------------------------------------------------
1049
+
1050
+ //
1051
+ // RPC::IIteratorTypeInstance_05353879ce17b341 interface proxy definitions
1052
+ //
1053
+ // Methods:
1054
+ // (0) virtual bool Next(QualityAssurance::IBenchmarkPayload::PayloadType&) = 0
1055
+ // (1) virtual bool Previous(QualityAssurance::IBenchmarkPayload::PayloadType&) = 0
1056
+ // (2) virtual void Reset(const uint32_t) = 0
1057
+ // (3) virtual bool IsValid() const = 0
1058
+ // (4) virtual uint32_t Count() const = 0
1059
+ // (5) virtual QualityAssurance::IBenchmarkPayload::PayloadType Current() const = 0
1060
+ //
1061
+
1062
+ class RPCIteratorTypeInstance_05353879ce17b341Proxy final : public ProxyStub::UnknownProxyType<RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>> {
1063
+ public:
1064
+ RPCIteratorTypeInstance_05353879ce17b341Proxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
1065
+ : BaseClass(channel, implementation, otherSideInformed)
1066
+ {
1067
+ }
1068
+
1069
+ bool Next(QualityAssurance::IBenchmarkPayload::PayloadType& _info) override
1070
+ {
1071
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
1072
+
1073
+ bool result{};
1074
+
1075
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1076
+ if (hresult == Core::ERROR_NONE) {
1077
+ hresult = [&]() -> Core::hresult {
1078
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1079
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1080
+ result = reader.Boolean();
1081
+ if (reader.Length() < (Core::RealSize<QualityAssurance::IBenchmarkPayload::PayloadType>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1082
+ _info = reader.Number<QualityAssurance::IBenchmarkPayload::PayloadType>();
1083
+
1084
+ return (Core::ERROR_NONE);
1085
+ } ();
1086
+ } else {
1087
+ ASSERT((hresult & COM_ERROR) != 0);
1088
+ }
1089
+
1090
+ if ((hresult & COM_ERROR) != 0) {
1091
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>::ID, 0, hresult);
1092
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
1093
+ }
1094
+
1095
+ return (result);
1096
+ }
1097
+
1098
+ bool Previous(QualityAssurance::IBenchmarkPayload::PayloadType& _info) override
1099
+ {
1100
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
1101
+
1102
+ bool result{};
1103
+
1104
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1105
+ if (hresult == Core::ERROR_NONE) {
1106
+ hresult = [&]() -> Core::hresult {
1107
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1108
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1109
+ result = reader.Boolean();
1110
+ if (reader.Length() < (Core::RealSize<QualityAssurance::IBenchmarkPayload::PayloadType>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1111
+ _info = reader.Number<QualityAssurance::IBenchmarkPayload::PayloadType>();
1112
+
1113
+ return (Core::ERROR_NONE);
1114
+ } ();
1115
+ } else {
1116
+ ASSERT((hresult & COM_ERROR) != 0);
1117
+ }
1118
+
1119
+ if ((hresult & COM_ERROR) != 0) {
1120
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>::ID, 1, hresult);
1121
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
1122
+ }
1123
+
1124
+ return (result);
1125
+ }
1126
+
1127
+ void Reset(const uint32_t _position) override
1128
+ {
1129
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
1130
+
1131
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1132
+ writer.Number<uint32_t>(_position);
1133
+
1134
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1135
+ if (hresult == Core::ERROR_NONE) {
1136
+ hresult = [&]() -> Core::hresult {
1137
+
1138
+ return (Core::ERROR_NONE);
1139
+ } ();
1140
+ } else {
1141
+ ASSERT((hresult & COM_ERROR) != 0);
1142
+ }
1143
+
1144
+ if ((hresult & COM_ERROR) != 0) {
1145
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>::ID, 2, hresult);
1146
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
1147
+ }
1148
+ }
1149
+
1150
+ bool IsValid() const override
1151
+ {
1152
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
1153
+
1154
+ bool result{};
1155
+
1156
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1157
+ if (hresult == Core::ERROR_NONE) {
1158
+ hresult = [&]() -> Core::hresult {
1159
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1160
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1161
+ result = reader.Boolean();
1162
+
1163
+ return (Core::ERROR_NONE);
1164
+ } ();
1165
+ } else {
1166
+ ASSERT((hresult & COM_ERROR) != 0);
1167
+ }
1168
+
1169
+ if ((hresult & COM_ERROR) != 0) {
1170
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>::ID, 3, hresult);
1171
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
1172
+ }
1173
+
1174
+ return (result);
1175
+ }
1176
+
1177
+ uint32_t Count() const override
1178
+ {
1179
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(4));
1180
+
1181
+ uint32_t result{};
1182
+
1183
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1184
+ if (hresult == Core::ERROR_NONE) {
1185
+ hresult = [&]() -> Core::hresult {
1186
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1187
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1188
+ result = reader.Number<uint32_t>();
1189
+
1190
+ return (Core::ERROR_NONE);
1191
+ } ();
1192
+ } else {
1193
+ ASSERT((hresult & COM_ERROR) != 0);
1194
+ }
1195
+
1196
+ if ((hresult & COM_ERROR) != 0) {
1197
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>::ID, 4, hresult);
1198
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
1199
+ }
1200
+
1201
+ return (result);
1202
+ }
1203
+
1204
+ QualityAssurance::IBenchmarkPayload::PayloadType Current() const override
1205
+ {
1206
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(5));
1207
+
1208
+ QualityAssurance::IBenchmarkPayload::PayloadType result{};
1209
+
1210
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1211
+ if (hresult == Core::ERROR_NONE) {
1212
+ hresult = [&]() -> Core::hresult {
1213
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1214
+ if (reader.Length() < (Core::RealSize<QualityAssurance::IBenchmarkPayload::PayloadType>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1215
+ result = reader.Number<QualityAssurance::IBenchmarkPayload::PayloadType>();
1216
+
1217
+ return (Core::ERROR_NONE);
1218
+ } ();
1219
+ } else {
1220
+ ASSERT((hresult & COM_ERROR) != 0);
1221
+ }
1222
+
1223
+ if ((hresult & COM_ERROR) != 0) {
1224
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>::ID, 5, hresult);
1225
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
1226
+ }
1227
+
1228
+ return (result);
1229
+ }
1230
+
1231
+ }; // class RPCIteratorTypeInstance_05353879ce17b341Proxy
1232
+
1233
+ //
1234
+ // QualityAssurance::IBenchmarkPayload interface proxy definitions
1235
+ //
1236
+ // Methods:
1237
+ // (0) virtual Core::hresult GetPayloadTypes(QualityAssurance::IBenchmarkPayload::IPayloadTypeIterator*&) const = 0
1238
+ // (1) virtual Core::hresult SendUint16(const uint16_t) = 0
1239
+ // (2) virtual Core::hresult SendUint32(const uint32_t) = 0
1240
+ // (3) virtual Core::hresult SendUint64(const uint64_t) = 0
1241
+ // (4) virtual Core::hresult SendBool(const bool) = 0
1242
+ // (5) virtual Core::hresult SendFloat(const float) = 0
1243
+ // (6) virtual Core::hresult SendDouble(const double) = 0
1244
+ // (7) virtual Core::hresult SendString(const string&) = 0
1245
+ // (8) virtual Core::hresult SendSampleData(const QualityAssurance::IBenchmarkPayload::SampleData&) = 0
1246
+ // (9) virtual Core::hresult SendNoPayload() = 0
1247
+ // (10) virtual Core::hresult SendBuffer(const uint16_t, const uint8_t*) = 0
1248
+ // (11) virtual Core::hresult SendUint32Vector(const std::vector<uint32_t>&) = 0
1249
+ // (12) virtual Core::hresult SendReceiveUint16(const uint16_t, uint16_t&) const = 0
1250
+ // (13) virtual Core::hresult SendReceiveUint32(const uint32_t, uint32_t&) const = 0
1251
+ // (14) virtual Core::hresult SendReceiveUint64(const uint64_t, uint64_t&) const = 0
1252
+ // (15) virtual Core::hresult SendReceiveBool(const bool, bool&) const = 0
1253
+ // (16) virtual Core::hresult SendReceiveFloat(const float, float&) const = 0
1254
+ // (17) virtual Core::hresult SendReceiveDouble(const double, double&) const = 0
1255
+ // (18) virtual Core::hresult SendReceiveString(const string&, string&) const = 0
1256
+ // (19) virtual Core::hresult SendReceiveSampleData(const QualityAssurance::IBenchmarkPayload::SampleData&, QualityAssurance::IBenchmarkPayload::SampleData&) const = 0
1257
+ // (20) virtual Core::hresult SendReceiveBuffer(uint16_t&, uint8_t*) const = 0
1258
+ // (21) virtual Core::hresult SendReceiveUint32Vector(const std::vector<uint32_t>&, std::vector<uint32_t>&) const = 0
1259
+ // (22) virtual Core::hresult Add(const uint32_t, const uint32_t, uint32_t&) const = 0
1260
+ //
1261
+
1262
+ class QualityAssuranceBenchmarkPayloadProxy final : public ProxyStub::UnknownProxyType<QualityAssurance::IBenchmarkPayload> {
1263
+ public:
1264
+ QualityAssuranceBenchmarkPayloadProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
1265
+ : BaseClass(channel, implementation, otherSideInformed)
1266
+ {
1267
+ }
1268
+
1269
+ Core::hresult GetPayloadTypes(QualityAssurance::IBenchmarkPayload::IPayloadTypeIterator*& _types) const override
1270
+ {
1271
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
1272
+
1273
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1274
+ if (hresult == Core::ERROR_NONE) {
1275
+ hresult = [&]() -> Core::hresult {
1276
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1277
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1278
+ hresult = reader.Number<Core::hresult>();
1279
+ if ((hresult & COM_ERROR) == 0) {
1280
+ _types = reinterpret_cast<QualityAssurance::IBenchmarkPayload::IPayloadTypeIterator*>(static_cast<const ProxyStub::UnknownProxy&>(*this).Interface(reader.Number<Core::instance_id>(), QualityAssurance::IBenchmarkPayload::IPayloadTypeIterator::ID));
1281
+ }
1282
+
1283
+ return (hresult);
1284
+ } ();
1285
+ } else {
1286
+ ASSERT((hresult & COM_ERROR) != 0);
1287
+ }
1288
+
1289
+ if ((hresult & COM_ERROR) != 0) {
1290
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 0, hresult);
1291
+ }
1292
+
1293
+ return (hresult);
1294
+ }
1295
+
1296
+ Core::hresult SendUint16(const uint16_t _value) override
1297
+ {
1298
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
1299
+
1300
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1301
+ writer.Number<uint16_t>(_value);
1302
+
1303
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1304
+ if (hresult == Core::ERROR_NONE) {
1305
+ hresult = [&]() -> Core::hresult {
1306
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1307
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1308
+ hresult = reader.Number<Core::hresult>();
1309
+
1310
+ return (hresult);
1311
+ } ();
1312
+ } else {
1313
+ ASSERT((hresult & COM_ERROR) != 0);
1314
+ }
1315
+
1316
+ if ((hresult & COM_ERROR) != 0) {
1317
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 1, hresult);
1318
+ }
1319
+
1320
+ return (hresult);
1321
+ }
1322
+
1323
+ Core::hresult SendUint32(const uint32_t _value) override
1324
+ {
1325
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
1326
+
1327
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1328
+ writer.Number<uint32_t>(_value);
1329
+
1330
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1331
+ if (hresult == Core::ERROR_NONE) {
1332
+ hresult = [&]() -> Core::hresult {
1333
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1334
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1335
+ hresult = reader.Number<Core::hresult>();
1336
+
1337
+ return (hresult);
1338
+ } ();
1339
+ } else {
1340
+ ASSERT((hresult & COM_ERROR) != 0);
1341
+ }
1342
+
1343
+ if ((hresult & COM_ERROR) != 0) {
1344
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 2, hresult);
1345
+ }
1346
+
1347
+ return (hresult);
1348
+ }
1349
+
1350
+ Core::hresult SendUint64(const uint64_t _value) override
1351
+ {
1352
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
1353
+
1354
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1355
+ writer.Number<uint64_t>(_value);
1356
+
1357
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1358
+ if (hresult == Core::ERROR_NONE) {
1359
+ hresult = [&]() -> Core::hresult {
1360
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1361
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1362
+ hresult = reader.Number<Core::hresult>();
1363
+
1364
+ return (hresult);
1365
+ } ();
1366
+ } else {
1367
+ ASSERT((hresult & COM_ERROR) != 0);
1368
+ }
1369
+
1370
+ if ((hresult & COM_ERROR) != 0) {
1371
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 3, hresult);
1372
+ }
1373
+
1374
+ return (hresult);
1375
+ }
1376
+
1377
+ Core::hresult SendBool(const bool _value) override
1378
+ {
1379
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(4));
1380
+
1381
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1382
+ writer.Boolean(_value);
1383
+
1384
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1385
+ if (hresult == Core::ERROR_NONE) {
1386
+ hresult = [&]() -> Core::hresult {
1387
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1388
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1389
+ hresult = reader.Number<Core::hresult>();
1390
+
1391
+ return (hresult);
1392
+ } ();
1393
+ } else {
1394
+ ASSERT((hresult & COM_ERROR) != 0);
1395
+ }
1396
+
1397
+ if ((hresult & COM_ERROR) != 0) {
1398
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 4, hresult);
1399
+ }
1400
+
1401
+ return (hresult);
1402
+ }
1403
+
1404
+ Core::hresult SendFloat(const float _value) override
1405
+ {
1406
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(5));
1407
+
1408
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1409
+ writer.Number<float>(_value);
1410
+
1411
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1412
+ if (hresult == Core::ERROR_NONE) {
1413
+ hresult = [&]() -> Core::hresult {
1414
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1415
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1416
+ hresult = reader.Number<Core::hresult>();
1417
+
1418
+ return (hresult);
1419
+ } ();
1420
+ } else {
1421
+ ASSERT((hresult & COM_ERROR) != 0);
1422
+ }
1423
+
1424
+ if ((hresult & COM_ERROR) != 0) {
1425
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 5, hresult);
1426
+ }
1427
+
1428
+ return (hresult);
1429
+ }
1430
+
1431
+ Core::hresult SendDouble(const double _value) override
1432
+ {
1433
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(6));
1434
+
1435
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1436
+ writer.Number<double>(_value);
1437
+
1438
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1439
+ if (hresult == Core::ERROR_NONE) {
1440
+ hresult = [&]() -> Core::hresult {
1441
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1442
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1443
+ hresult = reader.Number<Core::hresult>();
1444
+
1445
+ return (hresult);
1446
+ } ();
1447
+ } else {
1448
+ ASSERT((hresult & COM_ERROR) != 0);
1449
+ }
1450
+
1451
+ if ((hresult & COM_ERROR) != 0) {
1452
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 6, hresult);
1453
+ }
1454
+
1455
+ return (hresult);
1456
+ }
1457
+
1458
+ Core::hresult SendString(const string& _value) override
1459
+ {
1460
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(7));
1461
+
1462
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1463
+ writer.Text(_value);
1464
+
1465
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1466
+ if (hresult == Core::ERROR_NONE) {
1467
+ hresult = [&]() -> Core::hresult {
1468
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1469
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1470
+ hresult = reader.Number<Core::hresult>();
1471
+
1472
+ return (hresult);
1473
+ } ();
1474
+ } else {
1475
+ ASSERT((hresult & COM_ERROR) != 0);
1476
+ }
1477
+
1478
+ if ((hresult & COM_ERROR) != 0) {
1479
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 7, hresult);
1480
+ }
1481
+
1482
+ return (hresult);
1483
+ }
1484
+
1485
+ Core::hresult SendSampleData(const QualityAssurance::IBenchmarkPayload::SampleData& _data) override
1486
+ {
1487
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(8));
1488
+
1489
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1490
+ writer.Number<uint32_t>(_data.id);
1491
+ writer.Number<uint32_t>(_data.value);
1492
+ writer.Text(_data.name);
1493
+
1494
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1495
+ if (hresult == Core::ERROR_NONE) {
1496
+ hresult = [&]() -> Core::hresult {
1497
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1498
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1499
+ hresult = reader.Number<Core::hresult>();
1500
+
1501
+ return (hresult);
1502
+ } ();
1503
+ } else {
1504
+ ASSERT((hresult & COM_ERROR) != 0);
1505
+ }
1506
+
1507
+ if ((hresult & COM_ERROR) != 0) {
1508
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 8, hresult);
1509
+ }
1510
+
1511
+ return (hresult);
1512
+ }
1513
+
1514
+ Core::hresult SendNoPayload() override
1515
+ {
1516
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(9));
1517
+
1518
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1519
+ if (hresult == Core::ERROR_NONE) {
1520
+ hresult = [&]() -> Core::hresult {
1521
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1522
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1523
+ hresult = reader.Number<Core::hresult>();
1524
+
1525
+ return (hresult);
1526
+ } ();
1527
+ } else {
1528
+ ASSERT((hresult & COM_ERROR) != 0);
1529
+ }
1530
+
1531
+ if ((hresult & COM_ERROR) != 0) {
1532
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 9, hresult);
1533
+ }
1534
+
1535
+ return (hresult);
1536
+ }
1537
+
1538
+ Core::hresult SendBuffer(const uint16_t _bufferSize, const uint8_t* _buffer) override
1539
+ {
1540
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(10));
1541
+
1542
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1543
+ writer.Buffer<uint16_t>(_bufferSize, _buffer);
1544
+
1545
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1546
+ if (hresult == Core::ERROR_NONE) {
1547
+ hresult = [&]() -> Core::hresult {
1548
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1549
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1550
+ hresult = reader.Number<Core::hresult>();
1551
+
1552
+ return (hresult);
1553
+ } ();
1554
+ } else {
1555
+ ASSERT((hresult & COM_ERROR) != 0);
1556
+ }
1557
+
1558
+ if ((hresult & COM_ERROR) != 0) {
1559
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 10, hresult);
1560
+ }
1561
+
1562
+ return (hresult);
1563
+ }
1564
+
1565
+ Core::hresult SendUint32Vector(const std::vector<uint32_t>& _data) override
1566
+ {
1567
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(11));
1568
+
1569
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1570
+ writer.Number<uint16_t>(_data.size());
1571
+ for (uint16_t i = 0; i < _data.size(); i++) {
1572
+ writer.Number<uint32_t>(_data[i]);
1573
+ }
1574
+
1575
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1576
+ if (hresult == Core::ERROR_NONE) {
1577
+ hresult = [&]() -> Core::hresult {
1578
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1579
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1580
+ hresult = reader.Number<Core::hresult>();
1581
+
1582
+ return (hresult);
1583
+ } ();
1584
+ } else {
1585
+ ASSERT((hresult & COM_ERROR) != 0);
1586
+ }
1587
+
1588
+ if ((hresult & COM_ERROR) != 0) {
1589
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 11, hresult);
1590
+ }
1591
+
1592
+ return (hresult);
1593
+ }
1594
+
1595
+ Core::hresult SendReceiveUint16(const uint16_t _input, uint16_t& _output) const override
1596
+ {
1597
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(12));
1598
+
1599
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1600
+ writer.Number<uint16_t>(_input);
1601
+
1602
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1603
+ if (hresult == Core::ERROR_NONE) {
1604
+ hresult = [&]() -> Core::hresult {
1605
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1606
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1607
+ hresult = reader.Number<Core::hresult>();
1608
+ if ((hresult & COM_ERROR) == 0) {
1609
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1610
+ _output = reader.Number<uint16_t>();
1611
+ }
1612
+
1613
+ return (hresult);
1614
+ } ();
1615
+ } else {
1616
+ ASSERT((hresult & COM_ERROR) != 0);
1617
+ }
1618
+
1619
+ if ((hresult & COM_ERROR) != 0) {
1620
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 12, hresult);
1621
+ }
1622
+
1623
+ return (hresult);
1624
+ }
1625
+
1626
+ Core::hresult SendReceiveUint32(const uint32_t _input, uint32_t& _output) const override
1627
+ {
1628
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(13));
1629
+
1630
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1631
+ writer.Number<uint32_t>(_input);
1632
+
1633
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1634
+ if (hresult == Core::ERROR_NONE) {
1635
+ hresult = [&]() -> Core::hresult {
1636
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1637
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1638
+ hresult = reader.Number<Core::hresult>();
1639
+ if ((hresult & COM_ERROR) == 0) {
1640
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1641
+ _output = reader.Number<uint32_t>();
1642
+ }
1643
+
1644
+ return (hresult);
1645
+ } ();
1646
+ } else {
1647
+ ASSERT((hresult & COM_ERROR) != 0);
1648
+ }
1649
+
1650
+ if ((hresult & COM_ERROR) != 0) {
1651
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 13, hresult);
1652
+ }
1653
+
1654
+ return (hresult);
1655
+ }
1656
+
1657
+ Core::hresult SendReceiveUint64(const uint64_t _input, uint64_t& _output) const override
1658
+ {
1659
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(14));
1660
+
1661
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1662
+ writer.Number<uint64_t>(_input);
1663
+
1664
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1665
+ if (hresult == Core::ERROR_NONE) {
1666
+ hresult = [&]() -> Core::hresult {
1667
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1668
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1669
+ hresult = reader.Number<Core::hresult>();
1670
+ if ((hresult & COM_ERROR) == 0) {
1671
+ if (reader.Length() < (Core::RealSize<uint64_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1672
+ _output = reader.Number<uint64_t>();
1673
+ }
1674
+
1675
+ return (hresult);
1676
+ } ();
1677
+ } else {
1678
+ ASSERT((hresult & COM_ERROR) != 0);
1679
+ }
1680
+
1681
+ if ((hresult & COM_ERROR) != 0) {
1682
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 14, hresult);
1683
+ }
1684
+
1685
+ return (hresult);
1686
+ }
1687
+
1688
+ Core::hresult SendReceiveBool(const bool _input, bool& _output) const override
1689
+ {
1690
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(15));
1691
+
1692
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1693
+ writer.Boolean(_input);
1694
+
1695
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1696
+ if (hresult == Core::ERROR_NONE) {
1697
+ hresult = [&]() -> Core::hresult {
1698
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1699
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1700
+ hresult = reader.Number<Core::hresult>();
1701
+ if ((hresult & COM_ERROR) == 0) {
1702
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1703
+ _output = reader.Boolean();
1704
+ }
1705
+
1706
+ return (hresult);
1707
+ } ();
1708
+ } else {
1709
+ ASSERT((hresult & COM_ERROR) != 0);
1710
+ }
1711
+
1712
+ if ((hresult & COM_ERROR) != 0) {
1713
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 15, hresult);
1714
+ }
1715
+
1716
+ return (hresult);
1717
+ }
1718
+
1719
+ Core::hresult SendReceiveFloat(const float _input, float& _output) const override
1720
+ {
1721
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(16));
1722
+
1723
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1724
+ writer.Number<float>(_input);
1725
+
1726
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1727
+ if (hresult == Core::ERROR_NONE) {
1728
+ hresult = [&]() -> Core::hresult {
1729
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1730
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1731
+ hresult = reader.Number<Core::hresult>();
1732
+ if ((hresult & COM_ERROR) == 0) {
1733
+ if (reader.Length() < (Core::RealSize<float>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1734
+ _output = reader.Number<float>();
1735
+ }
1736
+
1737
+ return (hresult);
1738
+ } ();
1739
+ } else {
1740
+ ASSERT((hresult & COM_ERROR) != 0);
1741
+ }
1742
+
1743
+ if ((hresult & COM_ERROR) != 0) {
1744
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 16, hresult);
1745
+ }
1746
+
1747
+ return (hresult);
1748
+ }
1749
+
1750
+ Core::hresult SendReceiveDouble(const double _input, double& _output) const override
1751
+ {
1752
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(17));
1753
+
1754
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1755
+ writer.Number<double>(_input);
1756
+
1757
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1758
+ if (hresult == Core::ERROR_NONE) {
1759
+ hresult = [&]() -> Core::hresult {
1760
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1761
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1762
+ hresult = reader.Number<Core::hresult>();
1763
+ if ((hresult & COM_ERROR) == 0) {
1764
+ if (reader.Length() < (Core::RealSize<double>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1765
+ _output = reader.Number<double>();
1766
+ }
1767
+
1768
+ return (hresult);
1769
+ } ();
1770
+ } else {
1771
+ ASSERT((hresult & COM_ERROR) != 0);
1772
+ }
1773
+
1774
+ if ((hresult & COM_ERROR) != 0) {
1775
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 17, hresult);
1776
+ }
1777
+
1778
+ return (hresult);
1779
+ }
1780
+
1781
+ Core::hresult SendReceiveString(const string& _input, string& _output) const override
1782
+ {
1783
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(18));
1784
+
1785
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1786
+ writer.Text(_input);
1787
+
1788
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1789
+ if (hresult == Core::ERROR_NONE) {
1790
+ hresult = [&]() -> Core::hresult {
1791
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1792
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1793
+ hresult = reader.Number<Core::hresult>();
1794
+ if ((hresult & COM_ERROR) == 0) {
1795
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1796
+ const uint16_t _outputPeekedLen__ = reader.PeekNumber<uint16_t>();
1797
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _outputPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1798
+ _output = reader.Text();
1799
+ }
1800
+
1801
+ return (hresult);
1802
+ } ();
1803
+ } else {
1804
+ ASSERT((hresult & COM_ERROR) != 0);
1805
+ }
1806
+
1807
+ if ((hresult & COM_ERROR) != 0) {
1808
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 18, hresult);
1809
+ }
1810
+
1811
+ return (hresult);
1812
+ }
1813
+
1814
+ Core::hresult SendReceiveSampleData(const QualityAssurance::IBenchmarkPayload::SampleData& _input, QualityAssurance::IBenchmarkPayload::SampleData& _output) const override
1815
+ {
1816
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(19));
1817
+
1818
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1819
+ writer.Number<uint32_t>(_input.id);
1820
+ writer.Number<uint32_t>(_input.value);
1821
+ writer.Text(_input.name);
1822
+
1823
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1824
+ if (hresult == Core::ERROR_NONE) {
1825
+ hresult = [&]() -> Core::hresult {
1826
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1827
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1828
+ hresult = reader.Number<Core::hresult>();
1829
+ if ((hresult & COM_ERROR) == 0) {
1830
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1831
+ _output.id = reader.Number<uint32_t>();
1832
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1833
+ _output.value = reader.Number<uint32_t>();
1834
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1835
+ const uint16_t _output_namePeekedLen__ = reader.PeekNumber<uint16_t>();
1836
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _output_namePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1837
+ _output.name = reader.Text();
1838
+ }
1839
+
1840
+ return (hresult);
1841
+ } ();
1842
+ } else {
1843
+ ASSERT((hresult & COM_ERROR) != 0);
1844
+ }
1845
+
1846
+ if ((hresult & COM_ERROR) != 0) {
1847
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 19, hresult);
1848
+ }
1849
+
1850
+ return (hresult);
1851
+ }
1852
+
1853
+ Core::hresult SendReceiveBuffer(uint16_t& _bufferSize, uint8_t* _buffer) const override
1854
+ {
1855
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(20));
1856
+
1857
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1858
+ writer.Buffer<uint16_t>(_bufferSize, _buffer);
1859
+
1860
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1861
+ if (hresult == Core::ERROR_NONE) {
1862
+ hresult = [&]() -> Core::hresult {
1863
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1864
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1865
+ hresult = reader.Number<Core::hresult>();
1866
+ if ((hresult & COM_ERROR) == 0) {
1867
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1868
+ const uint16_t _bufferPeekedLen__ = reader.PeekNumber<uint16_t>();
1869
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _bufferPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1870
+ reader.Buffer<uint16_t>(_bufferSize, _buffer);
1871
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1872
+ _bufferSize = reader.Number<uint16_t>();
1873
+ }
1874
+
1875
+ return (hresult);
1876
+ } ();
1877
+ } else {
1878
+ ASSERT((hresult & COM_ERROR) != 0);
1879
+ }
1880
+
1881
+ if ((hresult & COM_ERROR) != 0) {
1882
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 20, hresult);
1883
+ }
1884
+
1885
+ return (hresult);
1886
+ }
1887
+
1888
+ Core::hresult SendReceiveUint32Vector(const std::vector<uint32_t>& _input, std::vector<uint32_t>& _output) const override
1889
+ {
1890
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(21));
1891
+
1892
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1893
+ writer.Number<uint16_t>(_input.size());
1894
+ for (uint16_t i = 0; i < _input.size(); i++) {
1895
+ writer.Number<uint32_t>(_input[i]);
1896
+ }
1897
+
1898
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1899
+ if (hresult == Core::ERROR_NONE) {
1900
+ hresult = [&]() -> Core::hresult {
1901
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1902
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1903
+ hresult = reader.Number<Core::hresult>();
1904
+ if ((hresult & COM_ERROR) == 0) {
1905
+ uint16_t _outputSize{};
1906
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1907
+ _outputSize = reader.Number<uint16_t>();
1908
+ _output.reserve(_outputSize);
1909
+ for (uint16_t i = 0; i < _outputSize; i++) {
1910
+ uint32_t _outputItem{};
1911
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1912
+ _outputItem = reader.Number<uint32_t>();
1913
+ _output.push_back(std::move(_outputItem));
1914
+ }
1915
+ }
1916
+
1917
+ return (hresult);
1918
+ } ();
1919
+ } else {
1920
+ ASSERT((hresult & COM_ERROR) != 0);
1921
+ }
1922
+
1923
+ if ((hresult & COM_ERROR) != 0) {
1924
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 21, hresult);
1925
+ }
1926
+
1927
+ return (hresult);
1928
+ }
1929
+
1930
+ Core::hresult Add(const uint32_t _a, const uint32_t _b, uint32_t& _result) const override
1931
+ {
1932
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(22));
1933
+
1934
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1935
+ writer.Number<uint32_t>(_a);
1936
+ writer.Number<uint32_t>(_b);
1937
+
1938
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1939
+ if (hresult == Core::ERROR_NONE) {
1940
+ hresult = [&]() -> Core::hresult {
1941
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1942
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1943
+ hresult = reader.Number<Core::hresult>();
1944
+ if ((hresult & COM_ERROR) == 0) {
1945
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1946
+ _result = reader.Number<uint32_t>();
1947
+ }
1948
+
1949
+ return (hresult);
1950
+ } ();
1951
+ } else {
1952
+ ASSERT((hresult & COM_ERROR) != 0);
1953
+ }
1954
+
1955
+ if ((hresult & COM_ERROR) != 0) {
1956
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::IBenchmarkPayload::ID, 22, hresult);
1957
+ }
1958
+
1959
+ return (hresult);
1960
+ }
1961
+
1962
+ }; // class QualityAssuranceBenchmarkPayloadProxy
1963
+
1964
+ POP_WARNING()
1965
+ POP_WARNING()
1966
+
1967
+ // -----------------------------------------------------------------
1968
+ // REGISTRATION
1969
+ // -----------------------------------------------------------------
1970
+ namespace {
1971
+
1972
+ typedef ProxyStub::UnknownStubType<RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>, RPCIteratorTypeInstance_05353879ce17b341StubMethods> RPCIteratorTypeInstance_05353879ce17b341Stub;
1973
+ typedef ProxyStub::UnknownStubType<QualityAssurance::IBenchmarkPayload, QualityAssuranceBenchmarkPayloadStubMethods> QualityAssuranceBenchmarkPayloadStub;
1974
+
1975
+ static class Instantiation {
1976
+ public:
1977
+ Instantiation()
1978
+ {
1979
+ const RPC::SecureProxyStubType security = static_cast<RPC::SecureProxyStubType>(static_cast<std::underlying_type<RPC::SecureProxyStubType>::type>(RPC::SecureProxyStubType::PROXYSTUBS_SECURITY_SECURE) | static_cast<std::underlying_type<RPC::SecureProxyStubType>::type>(RPC::SecureProxyStubType::PROXYSTUBS_SECURITY_COHERENT));
1980
+
1981
+ RPC::Administrator::Instance().Announce<RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>, RPCIteratorTypeInstance_05353879ce17b341Proxy, RPCIteratorTypeInstance_05353879ce17b341Stub>(security);
1982
+ RPC::Administrator::Instance().Announce<QualityAssurance::IBenchmarkPayload, QualityAssuranceBenchmarkPayloadProxy, QualityAssuranceBenchmarkPayloadStub>(security);
1983
+ }
1984
+ ~Instantiation()
1985
+ {
1986
+ RPC::Administrator::Instance().Recall<RPC::IIteratorType<QualityAssurance::IBenchmarkPayload::PayloadType, QualityAssurance::ID_BENCHMARK_PAYLOADTYPE_ITERATOR>>();
1987
+ RPC::Administrator::Instance().Recall<QualityAssurance::IBenchmarkPayload>();
1988
+ }
1989
+ } ProxyStubRegistration;
1990
+
1991
+ } // namespace
1992
+
1993
+ } // namespace ProxyStubs
1994
+
1995
+ }
Release/ThunderInterfaces/qa_interfaces/qa_generated/ProxyStubs_TestPlugin.cpp CHANGED
@@ -0,0 +1,493 @@
1
+ //
2
+ // generated automatically from "ITestPlugin.h"
3
+ //
4
+ // implements COM-RPC proxy stubs for:
5
+ // - class QualityAssurance::ITestPlugin
6
+ // - class QualityAssurance::ITestPlugin::INotification
7
+ //
8
+ // secure code enabled:
9
+ // - instance verification enabled
10
+ // - range verification enabled
11
+ // - frame coherency verification enabled
12
+ //
13
+
14
+ #include "Module.h"
15
+ #include "ITestPlugin.h"
16
+
17
+ #include <com/com.h>
18
+
19
+ namespace Thunder {
20
+
21
+ namespace ProxyStubs {
22
+
23
+ PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
24
+ PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
25
+
26
+ // -----------------------------------------------------------------
27
+ // STUBS
28
+ // -----------------------------------------------------------------
29
+
30
+ //
31
+ // QualityAssurance::ITestPlugin interface stub definitions
32
+ //
33
+ // Methods:
34
+ // (0) virtual Core::hresult Register(QualityAssurance::ITestPlugin::INotification*) = 0
35
+ // (1) virtual Core::hresult Unregister(QualityAssurance::ITestPlugin::INotification*) = 0
36
+ // (2) virtual Core::hresult Echo(const string&, string&) = 0
37
+ // (3) virtual Core::hresult Greet(const string&, string&) = 0
38
+ //
39
+
40
+ static ProxyStub::MethodHandler QualityAssuranceTestPluginStubMethods[] = {
41
+ // (0) virtual Core::hresult Register(QualityAssurance::ITestPlugin::INotification*) = 0
42
+ //
43
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
44
+ Core::hresult hresult = Core::ERROR_NONE;
45
+
46
+ hresult = [&]() -> Core::hresult {
47
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
48
+
49
+ QualityAssurance::ITestPlugin* implementation = reinterpret_cast<QualityAssurance::ITestPlugin*>(message->Parameters().Implementation());
50
+ ASSERT(implementation != nullptr);
51
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::ITestPlugin::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
52
+
53
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
54
+ if (reader.Length() < (sizeof(Core::instance_id))) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
55
+ Core::instance_id _notificationInstanceId__ = reader.Number<Core::instance_id>();
56
+
57
+ QualityAssurance::ITestPlugin::INotification* _notification{};
58
+ ProxyStub::UnknownProxy* _notificationProxy__ = nullptr;
59
+ if (_notificationInstanceId__ != 0) {
60
+ _notificationProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _notificationInstanceId__, false, _notification);
61
+ ASSERT((_notification != nullptr) && (_notificationProxy__ != nullptr));
62
+ if ((_notification == nullptr) || (_notificationProxy__ == nullptr)) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
63
+ }
64
+
65
+ Core::hresult result = implementation->Register(_notification);
66
+
67
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
68
+ writer.Number<Core::hresult>(result);
69
+
70
+ if (_notificationProxy__ != nullptr) {
71
+ RPC::Administrator::Instance().Release(_notificationProxy__, message->Response());
72
+ }
73
+
74
+ return (Core::ERROR_NONE);
75
+ } ();
76
+
77
+ if (hresult != Core::ERROR_NONE) {
78
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
79
+ writer.Number<uint32_t>(hresult);
80
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::ITestPlugin::ID, 0, hresult);
81
+ }
82
+ },
83
+
84
+ // (1) virtual Core::hresult Unregister(QualityAssurance::ITestPlugin::INotification*) = 0
85
+ //
86
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
87
+ Core::hresult hresult = Core::ERROR_NONE;
88
+
89
+ hresult = [&]() -> Core::hresult {
90
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
91
+
92
+ QualityAssurance::ITestPlugin* implementation = reinterpret_cast<QualityAssurance::ITestPlugin*>(message->Parameters().Implementation());
93
+ ASSERT(implementation != nullptr);
94
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::ITestPlugin::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
95
+
96
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
97
+ if (reader.Length() < (sizeof(Core::instance_id))) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
98
+ Core::instance_id _notificationInstanceId__ = reader.Number<Core::instance_id>();
99
+
100
+ QualityAssurance::ITestPlugin::INotification* _notification{};
101
+ ProxyStub::UnknownProxy* _notificationProxy__ = nullptr;
102
+ if (_notificationInstanceId__ != 0) {
103
+ _notificationProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _notificationInstanceId__, false, _notification);
104
+ ASSERT((_notification != nullptr) && (_notificationProxy__ != nullptr));
105
+ if ((_notification == nullptr) || (_notificationProxy__ == nullptr)) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
106
+ }
107
+
108
+ Core::hresult result = implementation->Unregister(_notification);
109
+
110
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
111
+ writer.Number<Core::hresult>(result);
112
+
113
+ if (_notificationProxy__ != nullptr) {
114
+ RPC::Administrator::Instance().Release(_notificationProxy__, message->Response());
115
+ }
116
+
117
+ return (Core::ERROR_NONE);
118
+ } ();
119
+
120
+ if (hresult != Core::ERROR_NONE) {
121
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
122
+ writer.Number<uint32_t>(hresult);
123
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::ITestPlugin::ID, 1, hresult);
124
+ }
125
+ },
126
+
127
+ // (2) virtual Core::hresult Echo(const string&, string&) = 0
128
+ //
129
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
130
+ Core::hresult hresult = Core::ERROR_NONE;
131
+
132
+ hresult = [&]() -> Core::hresult {
133
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
134
+
135
+ QualityAssurance::ITestPlugin* implementation = reinterpret_cast<QualityAssurance::ITestPlugin*>(message->Parameters().Implementation());
136
+ ASSERT(implementation != nullptr);
137
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::ITestPlugin::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
138
+
139
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
140
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
141
+ const uint16_t _inputPeekedLen__ = reader.PeekNumber<uint16_t>();
142
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _inputPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
143
+ const string _input = reader.Text();
144
+
145
+ string _output{};
146
+
147
+ Core::hresult result = implementation->Echo(static_cast<const string&>(_input), _output);
148
+
149
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
150
+ writer.Number<Core::hresult>(result);
151
+ writer.Text(_output);
152
+
153
+ return (Core::ERROR_NONE);
154
+ } ();
155
+
156
+ if (hresult != Core::ERROR_NONE) {
157
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
158
+ writer.Number<uint32_t>(hresult);
159
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::ITestPlugin::ID, 2, hresult);
160
+ }
161
+ },
162
+
163
+ // (3) virtual Core::hresult Greet(const string&, string&) = 0
164
+ //
165
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
166
+ Core::hresult hresult = Core::ERROR_NONE;
167
+
168
+ hresult = [&]() -> Core::hresult {
169
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
170
+
171
+ QualityAssurance::ITestPlugin* implementation = reinterpret_cast<QualityAssurance::ITestPlugin*>(message->Parameters().Implementation());
172
+ ASSERT(implementation != nullptr);
173
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::ITestPlugin::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
174
+
175
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
176
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
177
+ const uint16_t _namePeekedLen__ = reader.PeekNumber<uint16_t>();
178
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _namePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
179
+ const string _name = reader.Text();
180
+
181
+ string _message{};
182
+
183
+ Core::hresult result = implementation->Greet(static_cast<const string&>(_name), _message);
184
+
185
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
186
+ writer.Number<Core::hresult>(result);
187
+ writer.Text(_message);
188
+
189
+ return (Core::ERROR_NONE);
190
+ } ();
191
+
192
+ if (hresult != Core::ERROR_NONE) {
193
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
194
+ writer.Number<uint32_t>(hresult);
195
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::ITestPlugin::ID, 3, hresult);
196
+ }
197
+ }
198
+ , nullptr
199
+ }; // QualityAssuranceTestPluginStubMethods
200
+
201
+ //
202
+ // QualityAssurance::ITestPlugin::INotification interface stub definitions
203
+ //
204
+ // Methods:
205
+ // (0) virtual void OnGreeting(const string&) = 0
206
+ //
207
+
208
+ static ProxyStub::MethodHandler QualityAssuranceTestPluginNotificationStubMethods[] = {
209
+ // (0) virtual void OnGreeting(const string&) = 0
210
+ //
211
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
212
+ Core::hresult hresult = Core::ERROR_NONE;
213
+
214
+ hresult = [&]() -> Core::hresult {
215
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
216
+
217
+ QualityAssurance::ITestPlugin::INotification* implementation = reinterpret_cast<QualityAssurance::ITestPlugin::INotification*>(message->Parameters().Implementation());
218
+ ASSERT(implementation != nullptr);
219
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), QualityAssurance::ITestPlugin::INotification::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
220
+
221
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
222
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
223
+ const uint16_t _messagePeekedLen__ = reader.PeekNumber<uint16_t>();
224
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _messagePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
225
+ const string _message = reader.Text();
226
+
227
+ implementation->OnGreeting(static_cast<const string&>(_message));
228
+
229
+ return (Core::ERROR_NONE);
230
+ } ();
231
+
232
+ if (hresult != Core::ERROR_NONE) {
233
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::ITestPlugin::INotification::ID, 0, hresult);
234
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
235
+ }
236
+ }
237
+ , nullptr
238
+ }; // QualityAssuranceTestPluginNotificationStubMethods
239
+
240
+ // -----------------------------------------------------------------
241
+ // PROXIES
242
+ // -----------------------------------------------------------------
243
+
244
+ //
245
+ // QualityAssurance::ITestPlugin interface proxy definitions
246
+ //
247
+ // Methods:
248
+ // (0) virtual Core::hresult Register(QualityAssurance::ITestPlugin::INotification*) = 0
249
+ // (1) virtual Core::hresult Unregister(QualityAssurance::ITestPlugin::INotification*) = 0
250
+ // (2) virtual Core::hresult Echo(const string&, string&) = 0
251
+ // (3) virtual Core::hresult Greet(const string&, string&) = 0
252
+ //
253
+
254
+ class QualityAssuranceTestPluginProxy final : public ProxyStub::UnknownProxyType<QualityAssurance::ITestPlugin> {
255
+ public:
256
+ QualityAssuranceTestPluginProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
257
+ : BaseClass(channel, implementation, otherSideInformed)
258
+ {
259
+ }
260
+
261
+ Core::hresult Register(QualityAssurance::ITestPlugin::INotification* _notification) override
262
+ {
263
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
264
+
265
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
266
+ writer.Number<Core::instance_id>(RPC::instance_cast(_notification));
267
+
268
+ const RPC::InstanceRecord passedInstances[] = { { RPC::instance_cast(_notification), QualityAssurance::ITestPlugin::INotification::ID }, { 0, 0 } };
269
+ static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(passedInstances);
270
+
271
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
272
+ if (hresult == Core::ERROR_NONE) {
273
+ hresult = [&]() -> Core::hresult {
274
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
275
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
276
+ hresult = reader.Number<Core::hresult>();
277
+
278
+ const uint32_t completeResult__ = _Complete(reader);
279
+ if (completeResult__ != Core::ERROR_NONE) { return (completeResult__); }
280
+
281
+ return (hresult);
282
+ } ();
283
+ } else {
284
+ ASSERT((hresult & COM_ERROR) != 0);
285
+ }
286
+
287
+ if ((hresult & COM_ERROR) != 0) {
288
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::ITestPlugin::ID, 0, hresult);
289
+ }
290
+
291
+ static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(nullptr);
292
+
293
+ return (hresult);
294
+ }
295
+
296
+ Core::hresult Unregister(QualityAssurance::ITestPlugin::INotification* _notification) override
297
+ {
298
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
299
+
300
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
301
+ writer.Number<Core::instance_id>(RPC::instance_cast(_notification));
302
+
303
+ const RPC::InstanceRecord passedInstances[] = { { RPC::instance_cast(_notification), QualityAssurance::ITestPlugin::INotification::ID }, { 0, 0 } };
304
+ static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(passedInstances);
305
+
306
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
307
+ if (hresult == Core::ERROR_NONE) {
308
+ hresult = [&]() -> Core::hresult {
309
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
310
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
311
+ hresult = reader.Number<Core::hresult>();
312
+
313
+ const uint32_t completeResult__ = _Complete(reader);
314
+ if (completeResult__ != Core::ERROR_NONE) { return (completeResult__); }
315
+
316
+ return (hresult);
317
+ } ();
318
+ } else {
319
+ ASSERT((hresult & COM_ERROR) != 0);
320
+ }
321
+
322
+ if ((hresult & COM_ERROR) != 0) {
323
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::ITestPlugin::ID, 1, hresult);
324
+ }
325
+
326
+ static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(nullptr);
327
+
328
+ return (hresult);
329
+ }
330
+
331
+ Core::hresult Echo(const string& _input, string& _output) override
332
+ {
333
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
334
+
335
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
336
+ writer.Text(_input);
337
+
338
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
339
+ if (hresult == Core::ERROR_NONE) {
340
+ hresult = [&]() -> Core::hresult {
341
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
342
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
343
+ hresult = reader.Number<Core::hresult>();
344
+ if ((hresult & COM_ERROR) == 0) {
345
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
346
+ const uint16_t _outputPeekedLen__ = reader.PeekNumber<uint16_t>();
347
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _outputPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
348
+ _output = reader.Text();
349
+ }
350
+
351
+ return (hresult);
352
+ } ();
353
+ } else {
354
+ ASSERT((hresult & COM_ERROR) != 0);
355
+ }
356
+
357
+ if ((hresult & COM_ERROR) != 0) {
358
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::ITestPlugin::ID, 2, hresult);
359
+ }
360
+
361
+ return (hresult);
362
+ }
363
+
364
+ Core::hresult Greet(const string& _name, string& _message) override
365
+ {
366
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
367
+
368
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
369
+ writer.Text(_name);
370
+
371
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
372
+ if (hresult == Core::ERROR_NONE) {
373
+ hresult = [&]() -> Core::hresult {
374
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
375
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
376
+ hresult = reader.Number<Core::hresult>();
377
+ if ((hresult & COM_ERROR) == 0) {
378
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
379
+ const uint16_t _messagePeekedLen__ = reader.PeekNumber<uint16_t>();
380
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _messagePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
381
+ _message = reader.Text();
382
+ }
383
+
384
+ return (hresult);
385
+ } ();
386
+ } else {
387
+ ASSERT((hresult & COM_ERROR) != 0);
388
+ }
389
+
390
+ if ((hresult & COM_ERROR) != 0) {
391
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::ITestPlugin::ID, 3, hresult);
392
+ }
393
+
394
+ return (hresult);
395
+ }
396
+
397
+ private:
398
+ uint32_t _Complete(RPC::Data::Frame::Reader& reader) const
399
+ {
400
+ uint32_t result = Core::ERROR_NONE;
401
+
402
+ while (reader.HasData() == true) {
403
+ const size_t entrySize = (sizeof(Core::instance_id) + sizeof(uint32_t) + sizeof(RPC::Data::Output::mode));
404
+ if (reader.Length() < entrySize) { result = (COM_ERROR | Core::ERROR_READ_ERROR); break; }
405
+
406
+ const Core::instance_id implementation = reader.Number<Core::instance_id>();
407
+ ASSERT(implementation != 0);
408
+
409
+ const uint32_t id = reader.Number<uint32_t>();
410
+ const RPC::Data::Output::mode how = reader.Number<RPC::Data::Output::mode>();
411
+
412
+ if (RPC::Administrator::Instance().IsValid(static_cast<const ProxyStub::UnknownProxy&>(*this).Channel(), implementation, id) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
413
+
414
+ result = static_cast<const ProxyStub::UnknownProxy&>(*this).Complete(implementation, id, how);
415
+ if (result != Core::ERROR_NONE) { return (COM_ERROR | result); }
416
+ }
417
+
418
+ return (result);
419
+ }
420
+
421
+ }; // class QualityAssuranceTestPluginProxy
422
+
423
+ //
424
+ // QualityAssurance::ITestPlugin::INotification interface proxy definitions
425
+ //
426
+ // Methods:
427
+ // (0) virtual void OnGreeting(const string&) = 0
428
+ //
429
+
430
+ class QualityAssuranceTestPluginNotificationProxy final : public ProxyStub::UnknownProxyType<QualityAssurance::ITestPlugin::INotification> {
431
+ public:
432
+ QualityAssuranceTestPluginNotificationProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
433
+ : BaseClass(channel, implementation, otherSideInformed)
434
+ {
435
+ }
436
+
437
+ void OnGreeting(const string& _message) override
438
+ {
439
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
440
+
441
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
442
+ writer.Text(_message);
443
+
444
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
445
+ if (hresult == Core::ERROR_NONE) {
446
+ hresult = [&]() -> Core::hresult {
447
+
448
+ return (Core::ERROR_NONE);
449
+ } ();
450
+ } else {
451
+ ASSERT((hresult & COM_ERROR) != 0);
452
+ }
453
+
454
+ if ((hresult & COM_ERROR) != 0) {
455
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", QualityAssurance::ITestPlugin::INotification::ID, 0, hresult);
456
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
457
+ }
458
+ }
459
+
460
+ }; // class QualityAssuranceTestPluginNotificationProxy
461
+
462
+ POP_WARNING()
463
+ POP_WARNING()
464
+
465
+ // -----------------------------------------------------------------
466
+ // REGISTRATION
467
+ // -----------------------------------------------------------------
468
+ namespace {
469
+
470
+ typedef ProxyStub::UnknownStubType<QualityAssurance::ITestPlugin, QualityAssuranceTestPluginStubMethods> QualityAssuranceTestPluginStub;
471
+ typedef ProxyStub::UnknownStubType<QualityAssurance::ITestPlugin::INotification, QualityAssuranceTestPluginNotificationStubMethods> QualityAssuranceTestPluginNotificationStub;
472
+
473
+ static class Instantiation {
474
+ public:
475
+ Instantiation()
476
+ {
477
+ const RPC::SecureProxyStubType security = static_cast<RPC::SecureProxyStubType>(static_cast<std::underlying_type<RPC::SecureProxyStubType>::type>(RPC::SecureProxyStubType::PROXYSTUBS_SECURITY_SECURE) | static_cast<std::underlying_type<RPC::SecureProxyStubType>::type>(RPC::SecureProxyStubType::PROXYSTUBS_SECURITY_COHERENT));
478
+
479
+ RPC::Administrator::Instance().Announce<QualityAssurance::ITestPlugin, QualityAssuranceTestPluginProxy, QualityAssuranceTestPluginStub>(security);
480
+ RPC::Administrator::Instance().Announce<QualityAssurance::ITestPlugin::INotification, QualityAssuranceTestPluginNotificationProxy, QualityAssuranceTestPluginNotificationStub>(security);
481
+ }
482
+ ~Instantiation()
483
+ {
484
+ RPC::Administrator::Instance().Recall<QualityAssurance::ITestPlugin>();
485
+ RPC::Administrator::Instance().Recall<QualityAssurance::ITestPlugin::INotification>();
486
+ }
487
+ } ProxyStubRegistration;
488
+
489
+ } // namespace
490
+
491
+ } // namespace ProxyStubs
492
+
493
+ }