Diff to HTML by rtfpessoa

Files changed (12) 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. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_Bluetooth.cpp +0 -55
  8. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_Capture.cpp +0 -55
  9. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_IPNetwork.cpp +0 -55
  10. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_MessageControl.cpp +0 -1088
  11. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_SecureShellServer.cpp +0 -55
  12. Release/ThunderInterfaces/interfaces/generated/ProxyStubs_SwitchBoard.cpp +0 -55
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
- }
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
- }