Diff to HTML by rtfpessoa

Files changed (6) hide show
  1. {baseline → generated}/Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_ContentProtection.cpp +143 -76
  2. {baseline → generated}/Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_MessageControl.cpp +0 -667
  3. {baseline → generated}/Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_MessagingControl.cpp +667 -0
  4. {baseline → generated}/Release/ThunderInterfaces/interfaces/generated/ProxyStubs_ContentProtection.cpp +202 -91
  5. {baseline → generated}/Release/ThunderInterfaces/interfaces/generated/ProxyStubs_MessageControl.cpp +0 -1088
  6. {baseline → generated}/Release/ThunderInterfaces/interfaces/generated/ProxyStubs_MessagingControl.cpp +1088 -0
{baseline → generated}/Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_ContentProtection.cpp RENAMED
@@ -2,10 +2,11 @@
2
2
  // generated automatically from "IContentProtection.h"
3
3
  //
4
4
  // implements COM-RPC proxy stubs for:
5
5
  // - class Exchange::IContentProtection
6
6
  // - class Exchange::IContentProtection::INotification
7
+ // - class Exchange::IErrorToString
7
8
  //
8
9
 
9
10
  #include "Module.h"
10
11
  #include "IContentProtection.h"
11
12
 
@@ -24,22 +25,22 @@
24
25
 
25
26
  //
26
27
  // Exchange::IContentProtection interface stub definitions
27
28
  //
28
29
  // Methods:
29
- // (0) virtual uint32_t Register(Exchange::IContentProtection::INotification*) = 0
30
- // (1) virtual uint32_t Unregister(Exchange::IContentProtection::INotification*) = 0
31
- // (2) virtual uint32_t OpenDrmSession(const string&, const string&, Exchange::IContentProtection::KeySystem, const string&, const string&, uint32_t&, string&) = 0
32
- // (3) virtual uint32_t SetDrmSessionState(uint32_t, Exchange::IContentProtection::State) = 0
33
- // (4) virtual uint32_t UpdateDrmSession(uint32_t, const string&, const string&, string&) = 0
34
- // (5) virtual uint32_t CloseDrmSession(uint32_t, string&) = 0
35
- // (6) virtual uint32_t ShowWatermark(uint32_t, bool, const uint8_t) = 0
36
- // (7) virtual uint32_t SetPlaybackPosition(uint32_t, int32_t, signed long) = 0
30
+ // (0) virtual Core::hresult Register(Exchange::IContentProtection::INotification*) = 0
31
+ // (1) virtual Core::hresult Unregister(Exchange::IContentProtection::INotification*) = 0
32
+ // (2) virtual Core::hresult OpenDrmSession(const string&, const string&, Exchange::IContentProtection::KeySystem, const string&, const string&, string&, string&) = 0
33
+ // (3) virtual Core::hresult SetDrmSessionState(const string&, Exchange::IContentProtection::State) = 0
34
+ // (4) virtual Core::hresult UpdateDrmSession(const string&, const string&, const string&, string&) = 0
35
+ // (5) virtual Core::hresult CloseDrmSession(const string&, string&) = 0
36
+ // (6) virtual Core::hresult ShowWatermark(const string&, bool, const uint8_t) = 0
37
+ // (7) virtual Core::hresult SetPlaybackPosition(const string&, int32_t, signed long) = 0
37
38
  //
38
39
 
39
40
  static ProxyStub::MethodHandler ExchangeContentProtectionStubMethods[] = {
40
- // (0) virtual uint32_t Register(Exchange::IContentProtection::INotification*) = 0
41
+ // (0) virtual Core::hresult Register(Exchange::IContentProtection::INotification*) = 0
41
42
  //
42
43
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
43
44
  Exchange::IContentProtection* implementation = reinterpret_cast<Exchange::IContentProtection*>(message->Parameters().Implementation());
44
45
  ASSERT(implementation != nullptr);
45
46
 
@@ -51,21 +52,21 @@
51
52
  if (_notificationInstanceId__ != 0) {
52
53
  _notificationProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _notificationInstanceId__, false, _notification);
53
54
  ASSERT((_notification != nullptr) && (_notificationProxy__ != nullptr));
54
55
  }
55
56
 
56
- uint32_t result = implementation->Register(_notification);
57
+ Core::hresult result = implementation->Register(_notification);
57
58
 
58
59
  RPC::Data::Frame::Writer writer(message->Response().Writer());
59
- writer.Number<uint32_t>(result);
60
+ writer.Number<Core::hresult>(result);
60
61
 
61
62
  if (_notificationProxy__ != nullptr) {
62
63
  RPC::Administrator::Instance().Release(_notificationProxy__, message->Response());
63
64
  }
64
65
  },
65
66
 
66
- // (1) virtual uint32_t Unregister(Exchange::IContentProtection::INotification*) = 0
67
+ // (1) virtual Core::hresult Unregister(Exchange::IContentProtection::INotification*) = 0
67
68
  //
68
69
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
69
70
  Exchange::IContentProtection* implementation = reinterpret_cast<Exchange::IContentProtection*>(message->Parameters().Implementation());
70
71
  ASSERT(implementation != nullptr);
71
72
 
@@ -77,21 +78,21 @@
77
78
  if (_notificationInstanceId__ != 0) {
78
79
  _notificationProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _notificationInstanceId__, false, _notification);
79
80
  ASSERT((_notification != nullptr) && (_notificationProxy__ != nullptr));
80
81
  }
81
82
 
82
- uint32_t result = implementation->Unregister(_notification);
83
+ Core::hresult result = implementation->Unregister(_notification);
83
84
 
84
85
  RPC::Data::Frame::Writer writer(message->Response().Writer());
85
- writer.Number<uint32_t>(result);
86
+ writer.Number<Core::hresult>(result);
86
87
 
87
88
  if (_notificationProxy__ != nullptr) {
88
89
  RPC::Administrator::Instance().Release(_notificationProxy__, message->Response());
89
90
  }
90
91
  },
91
92
 
92
- // (2) virtual uint32_t OpenDrmSession(const string&, const string&, Exchange::IContentProtection::KeySystem, const string&, const string&, uint32_t&, string&) = 0
93
+ // (2) virtual Core::hresult OpenDrmSession(const string&, const string&, Exchange::IContentProtection::KeySystem, const string&, const string&, string&, string&) = 0
93
94
  //
94
95
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
95
96
  Exchange::IContentProtection* implementation = reinterpret_cast<Exchange::IContentProtection*>(message->Parameters().Implementation());
96
97
  ASSERT(implementation != nullptr);
97
98
 
@@ -100,204 +101,232 @@
100
101
  const string _appId = reader.Text();
101
102
  Exchange::IContentProtection::KeySystem _keySystem = reader.Number<Exchange::IContentProtection::KeySystem>();
102
103
  const string _licenseRequest = reader.Text();
103
104
  const string _initData = reader.Text();
104
105
 
105
- uint32_t _sessionId{};
106
+ string _sessionId{};
106
107
  string _response{};
107
108
 
108
- uint32_t result = implementation->OpenDrmSession(static_cast<const string&>(_clientId), static_cast<const string&>(_appId), _keySystem, static_cast<const string&>(_licenseRequest), static_cast<const string&>(_initData), _sessionId, _response);
109
+ Core::hresult result = implementation->OpenDrmSession(static_cast<const string&>(_clientId), static_cast<const string&>(_appId), _keySystem, static_cast<const string&>(_licenseRequest), static_cast<const string&>(_initData), _sessionId, _response);
109
110
 
110
111
  RPC::Data::Frame::Writer writer(message->Response().Writer());
111
- writer.Number<uint32_t>(result);
112
- writer.Number<uint32_t>(_sessionId);
112
+ writer.Number<Core::hresult>(result);
113
+ writer.Text(_sessionId);
113
114
  writer.Text(_response);
114
115
  },
115
116
 
116
- // (3) virtual uint32_t SetDrmSessionState(uint32_t, Exchange::IContentProtection::State) = 0
117
+ // (3) virtual Core::hresult SetDrmSessionState(const string&, Exchange::IContentProtection::State) = 0
117
118
  //
118
119
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
119
120
  Exchange::IContentProtection* implementation = reinterpret_cast<Exchange::IContentProtection*>(message->Parameters().Implementation());
120
121
  ASSERT(implementation != nullptr);
121
122
 
122
123
  RPC::Data::Frame::Reader reader(message->Parameters().Reader());
123
- uint32_t _sessionId = reader.Number<uint32_t>();
124
+ const string _sessionId = reader.Text();
124
125
  Exchange::IContentProtection::State _sessionState = reader.Number<Exchange::IContentProtection::State>();
125
126
 
126
- uint32_t result = implementation->SetDrmSessionState(_sessionId, _sessionState);
127
+ Core::hresult result = implementation->SetDrmSessionState(static_cast<const string&>(_sessionId), _sessionState);
127
128
 
128
129
  RPC::Data::Frame::Writer writer(message->Response().Writer());
129
- writer.Number<uint32_t>(result);
130
+ writer.Number<Core::hresult>(result);
130
131
  },
131
132
 
132
- // (4) virtual uint32_t UpdateDrmSession(uint32_t, const string&, const string&, string&) = 0
133
+ // (4) virtual Core::hresult UpdateDrmSession(const string&, const string&, const string&, string&) = 0
133
134
  //
134
135
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
135
136
  Exchange::IContentProtection* implementation = reinterpret_cast<Exchange::IContentProtection*>(message->Parameters().Implementation());
136
137
  ASSERT(implementation != nullptr);
137
138
 
138
139
  RPC::Data::Frame::Reader reader(message->Parameters().Reader());
139
- uint32_t _sessionId = reader.Number<uint32_t>();
140
+ const string _sessionId = reader.Text();
140
141
  const string _licenseRequest = reader.Text();
141
142
  const string _initData = reader.Text();
142
143
 
143
144
  string _response{};
144
145
 
145
- uint32_t result = implementation->UpdateDrmSession(_sessionId, static_cast<const string&>(_licenseRequest), static_cast<const string&>(_initData), _response);
146
+ Core::hresult result = implementation->UpdateDrmSession(static_cast<const string&>(_sessionId), static_cast<const string&>(_licenseRequest), static_cast<const string&>(_initData), _response);
146
147
 
147
148
  RPC::Data::Frame::Writer writer(message->Response().Writer());
148
- writer.Number<uint32_t>(result);
149
+ writer.Number<Core::hresult>(result);
149
150
  writer.Text(_response);
150
151
  },
151
152
 
152
- // (5) virtual uint32_t CloseDrmSession(uint32_t, string&) = 0
153
+ // (5) virtual Core::hresult CloseDrmSession(const string&, string&) = 0
153
154
  //
154
155
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
155
156
  Exchange::IContentProtection* implementation = reinterpret_cast<Exchange::IContentProtection*>(message->Parameters().Implementation());
156
157
  ASSERT(implementation != nullptr);
157
158
 
158
159
  RPC::Data::Frame::Reader reader(message->Parameters().Reader());
159
- uint32_t _sessionId = reader.Number<uint32_t>();
160
+ const string _sessionId = reader.Text();
160
161
 
161
162
  string _response{};
162
163
 
163
- uint32_t result = implementation->CloseDrmSession(_sessionId, _response);
164
+ Core::hresult result = implementation->CloseDrmSession(static_cast<const string&>(_sessionId), _response);
164
165
 
165
166
  RPC::Data::Frame::Writer writer(message->Response().Writer());
166
- writer.Number<uint32_t>(result);
167
+ writer.Number<Core::hresult>(result);
167
168
  writer.Text(_response);
168
169
  },
169
170
 
170
- // (6) virtual uint32_t ShowWatermark(uint32_t, bool, const uint8_t) = 0
171
+ // (6) virtual Core::hresult ShowWatermark(const string&, bool, const uint8_t) = 0
171
172
  //
172
173
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
173
174
  Exchange::IContentProtection* implementation = reinterpret_cast<Exchange::IContentProtection*>(message->Parameters().Implementation());
174
175
  ASSERT(implementation != nullptr);
175
176
 
176
177
  RPC::Data::Frame::Reader reader(message->Parameters().Reader());
177
- uint32_t _sessionId = reader.Number<uint32_t>();
178
+ const string _sessionId = reader.Text();
178
179
  bool _show = reader.Boolean();
179
180
  const uint8_t _opacityLevel = reader.Number<uint8_t>();
180
181
  ASSERT((_opacityLevel >= 0) && (_opacityLevel <= 100));
181
182
 
182
- uint32_t result = implementation->ShowWatermark(_sessionId, _show, _opacityLevel);
183
+ Core::hresult result = implementation->ShowWatermark(static_cast<const string&>(_sessionId), _show, _opacityLevel);
183
184
 
184
185
  RPC::Data::Frame::Writer writer(message->Response().Writer());
185
- writer.Number<uint32_t>(result);
186
+ writer.Number<Core::hresult>(result);
186
187
  },
187
188
 
188
- // (7) virtual uint32_t SetPlaybackPosition(uint32_t, int32_t, signed long) = 0
189
+ // (7) virtual Core::hresult SetPlaybackPosition(const string&, int32_t, signed long) = 0
189
190
  //
190
191
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
191
192
  Exchange::IContentProtection* implementation = reinterpret_cast<Exchange::IContentProtection*>(message->Parameters().Implementation());
192
193
  ASSERT(implementation != nullptr);
193
194
 
194
195
  RPC::Data::Frame::Reader reader(message->Parameters().Reader());
195
- uint32_t _sessionId = reader.Number<uint32_t>();
196
+ const string _sessionId = reader.Text();
196
197
  int32_t _speed = reader.Number<int32_t>();
197
198
  signed long _position = reader.Number<signed long>();
198
199
 
199
- uint32_t result = implementation->SetPlaybackPosition(_sessionId, _speed, _position);
200
+ Core::hresult result = implementation->SetPlaybackPosition(static_cast<const string&>(_sessionId), _speed, _position);
200
201
 
201
202
  RPC::Data::Frame::Writer writer(message->Response().Writer());
202
- writer.Number<uint32_t>(result);
203
+ writer.Number<Core::hresult>(result);
203
204
  }
204
205
  , nullptr
205
206
  }; // ExchangeContentProtectionStubMethods
206
207
 
207
208
  //
208
209
  // Exchange::IContentProtection::INotification interface stub definitions
209
210
  //
210
211
  // Methods:
211
- // (0) virtual void WatermarkStatusChanged(uint32_t, const string&, const Exchange::IContentProtection::INotification::Status&) = 0
212
+ // (0) virtual void WatermarkStatusChanged(const string&, const string&, const Exchange::IContentProtection::INotification::Status&) = 0
212
213
  //
213
214
 
214
215
  static ProxyStub::MethodHandler ExchangeContentProtectionNotificationStubMethods[] = {
215
- // (0) virtual void WatermarkStatusChanged(uint32_t, const string&, const Exchange::IContentProtection::INotification::Status&) = 0
216
+ // (0) virtual void WatermarkStatusChanged(const string&, const string&, const Exchange::IContentProtection::INotification::Status&) = 0
216
217
  //
217
218
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
218
219
  Exchange::IContentProtection::INotification* implementation = reinterpret_cast<Exchange::IContentProtection::INotification*>(message->Parameters().Implementation());
219
220
  ASSERT(implementation != nullptr);
220
221
 
221
222
  RPC::Data::Frame::Reader reader(message->Parameters().Reader());
222
- uint32_t _sessionId = reader.Number<uint32_t>();
223
+ const string _sessionId = reader.Text();
223
224
  const string _appId = reader.Text();
224
225
  Exchange::IContentProtection::INotification::Status _status{};
225
226
  _status.state = reader.Number<Exchange::IContentProtection::INotification::Status::State>();
226
227
  _status.failureReason = reader.Number<int32_t>();
227
228
 
228
- implementation->WatermarkStatusChanged(_sessionId, static_cast<const string&>(_appId), static_cast<const Exchange::IContentProtection::INotification::Status&>(_status));
229
+ implementation->WatermarkStatusChanged(static_cast<const string&>(_sessionId), static_cast<const string&>(_appId), static_cast<const Exchange::IContentProtection::INotification::Status&>(_status));
229
230
  }
230
231
  , nullptr
231
232
  }; // ExchangeContentProtectionNotificationStubMethods
232
233
 
234
+ //
235
+ // Exchange::IErrorToString interface stub definitions
236
+ //
237
+ // Methods:
238
+ // (0) virtual Core::hresult ErrorToString(const int32_t, string&) const = 0
239
+ //
240
+
241
+ static ProxyStub::MethodHandler ExchangeErrorToStringStubMethods[] = {
242
+ // (0) virtual Core::hresult ErrorToString(const int32_t, string&) const = 0
243
+ //
244
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
245
+ const Exchange::IErrorToString* implementation = reinterpret_cast<const Exchange::IErrorToString*>(message->Parameters().Implementation());
246
+ ASSERT(implementation != nullptr);
247
+
248
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
249
+ const int32_t _code = reader.Number<int32_t>();
250
+
251
+ string _result{};
252
+
253
+ Core::hresult result = implementation->ErrorToString(_code, _result);
254
+
255
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
256
+ writer.Number<Core::hresult>(result);
257
+ writer.Text(_result);
258
+ }
259
+ , nullptr
260
+ }; // ExchangeErrorToStringStubMethods
261
+
233
262
  // -----------------------------------------------------------------
234
263
  // PROXIES
235
264
  // -----------------------------------------------------------------
236
265
 
237
266
  //
238
267
  // Exchange::IContentProtection interface proxy definitions
239
268
  //
240
269
  // Methods:
241
- // (0) virtual uint32_t Register(Exchange::IContentProtection::INotification*) = 0
242
- // (1) virtual uint32_t Unregister(Exchange::IContentProtection::INotification*) = 0
243
- // (2) virtual uint32_t OpenDrmSession(const string&, const string&, Exchange::IContentProtection::KeySystem, const string&, const string&, uint32_t&, string&) = 0
244
- // (3) virtual uint32_t SetDrmSessionState(uint32_t, Exchange::IContentProtection::State) = 0
245
- // (4) virtual uint32_t UpdateDrmSession(uint32_t, const string&, const string&, string&) = 0
246
- // (5) virtual uint32_t CloseDrmSession(uint32_t, string&) = 0
247
- // (6) virtual uint32_t ShowWatermark(uint32_t, bool, const uint8_t) = 0
248
- // (7) virtual uint32_t SetPlaybackPosition(uint32_t, int32_t, signed long) = 0
270
+ // (0) virtual Core::hresult Register(Exchange::IContentProtection::INotification*) = 0
271
+ // (1) virtual Core::hresult Unregister(Exchange::IContentProtection::INotification*) = 0
272
+ // (2) virtual Core::hresult OpenDrmSession(const string&, const string&, Exchange::IContentProtection::KeySystem, const string&, const string&, string&, string&) = 0
273
+ // (3) virtual Core::hresult SetDrmSessionState(const string&, Exchange::IContentProtection::State) = 0
274
+ // (4) virtual Core::hresult UpdateDrmSession(const string&, const string&, const string&, string&) = 0
275
+ // (5) virtual Core::hresult CloseDrmSession(const string&, string&) = 0
276
+ // (6) virtual Core::hresult ShowWatermark(const string&, bool, const uint8_t) = 0
277
+ // (7) virtual Core::hresult SetPlaybackPosition(const string&, int32_t, signed long) = 0
249
278
  //
250
279
 
251
280
  class ExchangeContentProtectionProxy final : public ProxyStub::UnknownProxyType<Exchange::IContentProtection> {
252
281
  public:
253
282
  ExchangeContentProtectionProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
254
283
  : BaseClass(channel, implementation, otherSideInformed)
255
284
  {
256
285
  }
257
286
 
258
- uint32_t Register(Exchange::IContentProtection::INotification* _notification) override
287
+ Core::hresult Register(Exchange::IContentProtection::INotification* _notification) override
259
288
  {
260
289
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
261
290
 
262
291
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
263
292
  writer.Number<Core::instance_id>(RPC::instance_cast(_notification));
264
293
 
265
294
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
266
295
  if (hresult == Core::ERROR_NONE) {
267
296
  RPC::Data::Frame::Reader reader(message->Response().Reader());
268
- hresult = reader.Number<uint32_t>();
297
+ hresult = reader.Number<Core::hresult>();
269
298
 
270
299
  _Complete(reader);
271
300
  } else {
272
301
  ASSERT((hresult & COM_ERROR) != 0);
273
302
  }
274
303
 
275
304
  return (hresult);
276
305
  }
277
306
 
278
- uint32_t Unregister(Exchange::IContentProtection::INotification* _notification) override
307
+ Core::hresult Unregister(Exchange::IContentProtection::INotification* _notification) override
279
308
  {
280
309
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
281
310
 
282
311
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
283
312
  writer.Number<Core::instance_id>(RPC::instance_cast(_notification));
284
313
 
285
314
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
286
315
  if (hresult == Core::ERROR_NONE) {
287
316
  RPC::Data::Frame::Reader reader(message->Response().Reader());
288
- hresult = reader.Number<uint32_t>();
317
+ hresult = reader.Number<Core::hresult>();
289
318
 
290
319
  _Complete(reader);
291
320
  } else {
292
321
  ASSERT((hresult & COM_ERROR) != 0);
293
322
  }
294
323
 
295
324
  return (hresult);
296
325
  }
297
326
 
298
- uint32_t OpenDrmSession(const string& _clientId, const string& _appId, Exchange::IContentProtection::KeySystem _keySystem, const string& _licenseRequest, const string& _initData, uint32_t& _sessionId, string& _response) override
327
+ Core::hresult OpenDrmSession(const string& _clientId, const string& _appId, Exchange::IContentProtection::KeySystem _keySystem, const string& _licenseRequest, const string& _initData, string& _sessionId, string& _response) override
299
328
  {
300
329
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
301
330
 
302
331
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
303
332
  writer.Text(_clientId);
@@ -307,112 +336,112 @@
307
336
  writer.Text(_initData);
308
337
 
309
338
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
310
339
  if (hresult == Core::ERROR_NONE) {
311
340
  RPC::Data::Frame::Reader reader(message->Response().Reader());
312
- hresult = reader.Number<uint32_t>();
313
- _sessionId = reader.Number<uint32_t>();
341
+ hresult = reader.Number<Core::hresult>();
342
+ _sessionId = reader.Text();
314
343
  _response = reader.Text();
315
344
  } else {
316
345
  ASSERT((hresult & COM_ERROR) != 0);
317
346
  }
318
347
 
319
348
  return (hresult);
320
349
  }
321
350
 
322
- uint32_t SetDrmSessionState(uint32_t _sessionId, Exchange::IContentProtection::State _sessionState) override
351
+ Core::hresult SetDrmSessionState(const string& _sessionId, Exchange::IContentProtection::State _sessionState) override
323
352
  {
324
353
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
325
354
 
326
355
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
327
- writer.Number<uint32_t>(_sessionId);
356
+ writer.Text(_sessionId);
328
357
  writer.Number<Exchange::IContentProtection::State>(_sessionState);
329
358
 
330
359
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
331
360
  if (hresult == Core::ERROR_NONE) {
332
361
  RPC::Data::Frame::Reader reader(message->Response().Reader());
333
- hresult = reader.Number<uint32_t>();
362
+ hresult = reader.Number<Core::hresult>();
334
363
  } else {
335
364
  ASSERT((hresult & COM_ERROR) != 0);
336
365
  }
337
366
 
338
367
  return (hresult);
339
368
  }
340
369
 
341
- uint32_t UpdateDrmSession(uint32_t _sessionId, const string& _licenseRequest, const string& _initData, string& _response) override
370
+ Core::hresult UpdateDrmSession(const string& _sessionId, const string& _licenseRequest, const string& _initData, string& _response) override
342
371
  {
343
372
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(4));
344
373
 
345
374
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
346
- writer.Number<uint32_t>(_sessionId);
375
+ writer.Text(_sessionId);
347
376
  writer.Text(_licenseRequest);
348
377
  writer.Text(_initData);
349
378
 
350
379
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
351
380
  if (hresult == Core::ERROR_NONE) {
352
381
  RPC::Data::Frame::Reader reader(message->Response().Reader());
353
- hresult = reader.Number<uint32_t>();
382
+ hresult = reader.Number<Core::hresult>();
354
383
  _response = reader.Text();
355
384
  } else {
356
385
  ASSERT((hresult & COM_ERROR) != 0);
357
386
  }
358
387
 
359
388
  return (hresult);
360
389
  }
361
390
 
362
- uint32_t CloseDrmSession(uint32_t _sessionId, string& _response) override
391
+ Core::hresult CloseDrmSession(const string& _sessionId, string& _response) override
363
392
  {
364
393
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(5));
365
394
 
366
395
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
367
- writer.Number<uint32_t>(_sessionId);
396
+ writer.Text(_sessionId);
368
397
 
369
398
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
370
399
  if (hresult == Core::ERROR_NONE) {
371
400
  RPC::Data::Frame::Reader reader(message->Response().Reader());
372
- hresult = reader.Number<uint32_t>();
401
+ hresult = reader.Number<Core::hresult>();
373
402
  _response = reader.Text();
374
403
  } else {
375
404
  ASSERT((hresult & COM_ERROR) != 0);
376
405
  }
377
406
 
378
407
  return (hresult);
379
408
  }
380
409
 
381
- uint32_t ShowWatermark(uint32_t _sessionId, bool _show, const uint8_t _opacityLevel) override
410
+ Core::hresult ShowWatermark(const string& _sessionId, bool _show, const uint8_t _opacityLevel) override
382
411
  {
383
412
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(6));
384
413
 
385
414
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
386
- writer.Number<uint32_t>(_sessionId);
415
+ writer.Text(_sessionId);
387
416
  writer.Boolean(_show);
388
417
  writer.Number<uint8_t>(_opacityLevel);
389
418
 
390
419
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
391
420
  if (hresult == Core::ERROR_NONE) {
392
421
  RPC::Data::Frame::Reader reader(message->Response().Reader());
393
- hresult = reader.Number<uint32_t>();
422
+ hresult = reader.Number<Core::hresult>();
394
423
  } else {
395
424
  ASSERT((hresult & COM_ERROR) != 0);
396
425
  }
397
426
 
398
427
  return (hresult);
399
428
  }
400
429
 
401
- uint32_t SetPlaybackPosition(uint32_t _sessionId, int32_t _speed, signed long _position) override
430
+ Core::hresult SetPlaybackPosition(const string& _sessionId, int32_t _speed, signed long _position) override
402
431
  {
403
432
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(7));
404
433
 
405
434
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
406
- writer.Number<uint32_t>(_sessionId);
435
+ writer.Text(_sessionId);
407
436
  writer.Number<int32_t>(_speed);
408
437
  writer.Number<signed long>(_position);
409
438
 
410
439
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
411
440
  if (hresult == Core::ERROR_NONE) {
412
441
  RPC::Data::Frame::Reader reader(message->Response().Reader());
413
- hresult = reader.Number<uint32_t>();
442
+ hresult = reader.Number<Core::hresult>();
414
443
  } else {
415
444
  ASSERT((hresult & COM_ERROR) != 0);
416
445
  }
417
446
 
418
447
  return (hresult);
@@ -441,57 +470,95 @@
441
470
 
442
471
  //
443
472
  // Exchange::IContentProtection::INotification interface proxy definitions
444
473
  //
445
474
  // Methods:
446
- // (0) virtual void WatermarkStatusChanged(uint32_t, const string&, const Exchange::IContentProtection::INotification::Status&) = 0
475
+ // (0) virtual void WatermarkStatusChanged(const string&, const string&, const Exchange::IContentProtection::INotification::Status&) = 0
447
476
  //
448
477
 
449
478
  class ExchangeContentProtectionNotificationProxy final : public ProxyStub::UnknownProxyType<Exchange::IContentProtection::INotification> {
450
479
  public:
451
480
  ExchangeContentProtectionNotificationProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
452
481
  : BaseClass(channel, implementation, otherSideInformed)
453
482
  {
454
483
  }
455
484
 
456
- void WatermarkStatusChanged(uint32_t _sessionId, const string& _appId, const Exchange::IContentProtection::INotification::Status& _status) override
485
+ void WatermarkStatusChanged(const string& _sessionId, const string& _appId, const Exchange::IContentProtection::INotification::Status& _status) override
457
486
  {
458
487
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
459
488
 
460
489
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
461
- writer.Number<uint32_t>(_sessionId);
490
+ writer.Text(_sessionId);
462
491
  writer.Text(_appId);
463
492
  writer.Number<Exchange::IContentProtection::INotification::Status::State>(_status.state);
464
493
  writer.Number<int32_t>(_status.failureReason);
465
494
 
466
495
  static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
467
496
  }
468
497
 
469
498
  }; // class ExchangeContentProtectionNotificationProxy
470
499
 
500
+ //
501
+ // Exchange::IErrorToString interface proxy definitions
502
+ //
503
+ // Methods:
504
+ // (0) virtual Core::hresult ErrorToString(const int32_t, string&) const = 0
505
+ //
506
+
507
+ class ExchangeErrorToStringProxy final : public ProxyStub::UnknownProxyType<Exchange::IErrorToString> {
508
+ public:
509
+ ExchangeErrorToStringProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
510
+ : BaseClass(channel, implementation, otherSideInformed)
511
+ {
512
+ }
513
+
514
+ Core::hresult ErrorToString(const int32_t _code, string& _result) const override
515
+ {
516
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
517
+
518
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
519
+ writer.Number<int32_t>(_code);
520
+
521
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
522
+ if (hresult == Core::ERROR_NONE) {
523
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
524
+ hresult = reader.Number<Core::hresult>();
525
+ _result = reader.Text();
526
+ } else {
527
+ ASSERT((hresult & COM_ERROR) != 0);
528
+ }
529
+
530
+ return (hresult);
531
+ }
532
+
533
+ }; // class ExchangeErrorToStringProxy
534
+
471
535
  POP_WARNING()
472
536
  POP_WARNING()
473
537
 
474
538
  // -----------------------------------------------------------------
475
539
  // REGISTRATION
476
540
  // -----------------------------------------------------------------
477
541
  namespace {
478
542
 
479
543
  typedef ProxyStub::UnknownStubType<Exchange::IContentProtection, ExchangeContentProtectionStubMethods> ExchangeContentProtectionStub;
480
544
  typedef ProxyStub::UnknownStubType<Exchange::IContentProtection::INotification, ExchangeContentProtectionNotificationStubMethods> ExchangeContentProtectionNotificationStub;
545
+ typedef ProxyStub::UnknownStubType<Exchange::IErrorToString, ExchangeErrorToStringStubMethods> ExchangeErrorToStringStub;
481
546
 
482
547
  static class Instantiation {
483
548
  public:
484
549
  Instantiation()
485
550
  {
486
551
  RPC::Administrator::Instance().Announce<Exchange::IContentProtection, ExchangeContentProtectionProxy, ExchangeContentProtectionStub>();
487
552
  RPC::Administrator::Instance().Announce<Exchange::IContentProtection::INotification, ExchangeContentProtectionNotificationProxy, ExchangeContentProtectionNotificationStub>();
553
+ RPC::Administrator::Instance().Announce<Exchange::IErrorToString, ExchangeErrorToStringProxy, ExchangeErrorToStringStub>();
488
554
  }
489
555
  ~Instantiation()
490
556
  {
491
557
  RPC::Administrator::Instance().Recall<Exchange::IContentProtection>();
492
558
  RPC::Administrator::Instance().Recall<Exchange::IContentProtection::INotification>();
559
+ RPC::Administrator::Instance().Recall<Exchange::IErrorToString>();
493
560
  }
494
561
  } ProxyStubRegistration;
495
562
 
496
563
  } // namespace
497
564
 
{baseline → generated}/Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_MessageControl.cpp RENAMED
@@ -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
- }
{baseline → generated}/Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_MessagingControl.cpp RENAMED
@@ -0,0 +1,667 @@
1
+ //
2
+ // generated automatically from "IMessagingControl.h"
3
+ //
4
+ // implements COM-RPC proxy stubs for:
5
+ // - class RPC::IIteratorType<typename ELEMENT, const uint32_t INTERFACE_ID> [with ELEMENT = Exchange::IMessagingControl::Control, INTERFACE_ID = Exchange::ID_MESSAGING_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::IMessagingControl
8
+ //
9
+
10
+ #include "Module.h"
11
+ #include "IMessagingControl.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_e1375fa4d7fa7ef4 interface stub definitions
28
+ //
29
+ // Methods:
30
+ // (0) virtual bool Next(Exchange::IMessagingControl::Control&) = 0
31
+ // (1) virtual bool Previous(Exchange::IMessagingControl::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::IMessagingControl::Control Current() const = 0
36
+ //
37
+
38
+ static ProxyStub::MethodHandler RPCIteratorTypeInstance_e1375fa4d7fa7ef4StubMethods[] = {
39
+ // (0) virtual bool Next(Exchange::IMessagingControl::Control&) = 0
40
+ //
41
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
42
+ using interface = RPC::IIteratorType<Exchange::IMessagingControl::Control, Exchange::ID_MESSAGING_CONTROL_ITERATOR>;
43
+
44
+ interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
45
+ ASSERT(implementation != nullptr);
46
+
47
+ Exchange::IMessagingControl::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::IMessagingControl::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::IMessagingControl::Control&) = 0
60
+ //
61
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
62
+ using interface = RPC::IIteratorType<Exchange::IMessagingControl::Control, Exchange::ID_MESSAGING_CONTROL_ITERATOR>;
63
+
64
+ interface* implementation = reinterpret_cast<interface*>(message->Parameters().Implementation());
65
+ ASSERT(implementation != nullptr);
66
+
67
+ Exchange::IMessagingControl::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::IMessagingControl::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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::Control Current() const = 0
122
+ //
123
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
124
+ using interface = RPC::IIteratorType<Exchange::IMessagingControl::Control, Exchange::ID_MESSAGING_CONTROL_ITERATOR>;
125
+
126
+ const interface* implementation = reinterpret_cast<const interface*>(message->Parameters().Implementation());
127
+ ASSERT(implementation != nullptr);
128
+
129
+ Exchange::IMessagingControl::Control result = implementation->Current();
130
+
131
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
132
+ writer.Number<Exchange::IMessagingControl::messagetype>(result.type);
133
+ writer.Text(result.category);
134
+ writer.Text(result.module);
135
+ writer.Boolean(result.enabled);
136
+ }
137
+ , nullptr
138
+ }; // RPCIteratorTypeInstance_e1375fa4d7fa7ef4StubMethods
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::IMessagingControl interface stub definitions
247
+ //
248
+ // Methods:
249
+ // (0) virtual Core::hresult Enable(const Exchange::IMessagingControl::messagetype, const string&, const string&, const bool) = 0
250
+ // (1) virtual Core::hresult Modules(Exchange::IMessagingControl::IStringIterator*&) const = 0
251
+ // (2) virtual Core::hresult Controls(const string&, Exchange::IMessagingControl::IControlIterator*&) const = 0
252
+ //
253
+
254
+ static ProxyStub::MethodHandler ExchangeMessagingControlStubMethods[] = {
255
+ // (0) virtual Core::hresult Enable(const Exchange::IMessagingControl::messagetype, const string&, const string&, const bool) = 0
256
+ //
257
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
258
+ Exchange::IMessagingControl* implementation = reinterpret_cast<Exchange::IMessagingControl*>(message->Parameters().Implementation());
259
+ ASSERT(implementation != nullptr);
260
+
261
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
262
+ const Exchange::IMessagingControl::messagetype _type = reader.Number<Exchange::IMessagingControl::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::IMessagingControl::IStringIterator*&) const = 0
274
+ //
275
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
276
+ const Exchange::IMessagingControl* implementation = reinterpret_cast<const Exchange::IMessagingControl*>(message->Parameters().Implementation());
277
+ ASSERT(implementation != nullptr);
278
+
279
+ Exchange::IMessagingControl::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::IMessagingControl::IControlIterator*&) const = 0
291
+ //
292
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
293
+ const Exchange::IMessagingControl* implementation = reinterpret_cast<const Exchange::IMessagingControl*>(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::IMessagingControl::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
+ }; // ExchangeMessagingControlStubMethods
311
+
312
+ // -----------------------------------------------------------------
313
+ // PROXIES
314
+ // -----------------------------------------------------------------
315
+
316
+ //
317
+ // RPC::IIteratorTypeInstance_e1375fa4d7fa7ef4 interface proxy definitions
318
+ //
319
+ // Methods:
320
+ // (0) virtual bool Next(Exchange::IMessagingControl::Control&) = 0
321
+ // (1) virtual bool Previous(Exchange::IMessagingControl::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::IMessagingControl::Control Current() const = 0
326
+ //
327
+
328
+ class RPCIteratorTypeInstance_e1375fa4d7fa7ef4Proxy final : public ProxyStub::UnknownProxyType<RPC::IIteratorType<Exchange::IMessagingControl::Control, Exchange::ID_MESSAGING_CONTROL_ITERATOR>> {
329
+ public:
330
+ RPCIteratorTypeInstance_e1375fa4d7fa7ef4Proxy(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::IMessagingControl::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::IMessagingControl::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::IMessagingControl::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::IMessagingControl::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::IMessagingControl::Control Current() const override
422
+ {
423
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(5));
424
+
425
+ Exchange::IMessagingControl::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::IMessagingControl::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_e1375fa4d7fa7ef4Proxy
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::IMessagingControl interface proxy definitions
563
+ //
564
+ // Methods:
565
+ // (0) virtual Core::hresult Enable(const Exchange::IMessagingControl::messagetype, const string&, const string&, const bool) = 0
566
+ // (1) virtual Core::hresult Modules(Exchange::IMessagingControl::IStringIterator*&) const = 0
567
+ // (2) virtual Core::hresult Controls(const string&, Exchange::IMessagingControl::IControlIterator*&) const = 0
568
+ //
569
+
570
+ class ExchangeMessagingControlProxy final : public ProxyStub::UnknownProxyType<Exchange::IMessagingControl> {
571
+ public:
572
+ ExchangeMessagingControlProxy(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::IMessagingControl::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::IMessagingControl::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::IMessagingControl::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::IMessagingControl::IStringIterator*>(static_cast<const ProxyStub::UnknownProxy&>(*this).Interface(reader.Number<Core::instance_id>(), Exchange::IMessagingControl::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::IMessagingControl::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::IMessagingControl::IControlIterator*>(static_cast<const ProxyStub::UnknownProxy&>(*this).Interface(reader.Number<Core::instance_id>(), Exchange::IMessagingControl::IControlIterator::ID));
626
+ } else {
627
+ ASSERT((hresult & COM_ERROR) != 0);
628
+ }
629
+
630
+ return (hresult);
631
+ }
632
+
633
+ }; // class ExchangeMessagingControlProxy
634
+
635
+ POP_WARNING()
636
+ POP_WARNING()
637
+
638
+ // -----------------------------------------------------------------
639
+ // REGISTRATION
640
+ // -----------------------------------------------------------------
641
+ namespace {
642
+
643
+ typedef ProxyStub::UnknownStubType<RPC::IIteratorType<Exchange::IMessagingControl::Control, Exchange::ID_MESSAGING_CONTROL_ITERATOR>, RPCIteratorTypeInstance_e1375fa4d7fa7ef4StubMethods> RPCIteratorTypeInstance_e1375fa4d7fa7ef4Stub;
644
+ typedef ProxyStub::UnknownStubType<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>, RPCIteratorTypeInstance_b3acff3685df4032StubMethods> RPCIteratorTypeInstance_b3acff3685df4032Stub;
645
+ typedef ProxyStub::UnknownStubType<Exchange::IMessagingControl, ExchangeMessagingControlStubMethods> ExchangeMessagingControlStub;
646
+
647
+ static class Instantiation {
648
+ public:
649
+ Instantiation()
650
+ {
651
+ RPC::Administrator::Instance().Announce<RPC::IIteratorType<Exchange::IMessagingControl::Control, Exchange::ID_MESSAGING_CONTROL_ITERATOR>, RPCIteratorTypeInstance_e1375fa4d7fa7ef4Proxy, RPCIteratorTypeInstance_e1375fa4d7fa7ef4Stub>();
652
+ RPC::Administrator::Instance().Announce<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>, RPCIteratorTypeInstance_b3acff3685df4032Proxy, RPCIteratorTypeInstance_b3acff3685df4032Stub>();
653
+ RPC::Administrator::Instance().Announce<Exchange::IMessagingControl, ExchangeMessagingControlProxy, ExchangeMessagingControlStub>();
654
+ }
655
+ ~Instantiation()
656
+ {
657
+ RPC::Administrator::Instance().Recall<RPC::IIteratorType<Exchange::IMessagingControl::Control, Exchange::ID_MESSAGING_CONTROL_ITERATOR>>();
658
+ RPC::Administrator::Instance().Recall<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>();
659
+ RPC::Administrator::Instance().Recall<Exchange::IMessagingControl>();
660
+ }
661
+ } ProxyStubRegistration;
662
+
663
+ } // namespace
664
+
665
+ } // namespace ProxyStubs
666
+
667
+ }
{baseline → generated}/Release/ThunderInterfaces/interfaces/generated/ProxyStubs_ContentProtection.cpp RENAMED
@@ -2,10 +2,11 @@
2
2
  // generated automatically from "IContentProtection.h"
3
3
  //
4
4
  // implements COM-RPC proxy stubs for:
5
5
  // - class Exchange::IContentProtection
6
6
  // - class Exchange::IContentProtection::INotification
7
+ // - class Exchange::IErrorToString
7
8
  //
8
9
  // secure code enabled:
9
10
  // - instance verification enabled
10
11
  // - range verification enabled
11
12
  // - frame coherency verification enabled
@@ -29,22 +30,22 @@
29
30
 
30
31
  //
31
32
  // Exchange::IContentProtection interface stub definitions
32
33
  //
33
34
  // Methods:
34
- // (0) virtual uint32_t Register(Exchange::IContentProtection::INotification*) = 0
35
- // (1) virtual uint32_t Unregister(Exchange::IContentProtection::INotification*) = 0
36
- // (2) virtual uint32_t OpenDrmSession(const string&, const string&, Exchange::IContentProtection::KeySystem, const string&, const string&, uint32_t&, string&) = 0
37
- // (3) virtual uint32_t SetDrmSessionState(uint32_t, Exchange::IContentProtection::State) = 0
38
- // (4) virtual uint32_t UpdateDrmSession(uint32_t, const string&, const string&, string&) = 0
39
- // (5) virtual uint32_t CloseDrmSession(uint32_t, string&) = 0
40
- // (6) virtual uint32_t ShowWatermark(uint32_t, bool, const uint8_t) = 0
41
- // (7) virtual uint32_t SetPlaybackPosition(uint32_t, int32_t, signed long) = 0
35
+ // (0) virtual Core::hresult Register(Exchange::IContentProtection::INotification*) = 0
36
+ // (1) virtual Core::hresult Unregister(Exchange::IContentProtection::INotification*) = 0
37
+ // (2) virtual Core::hresult OpenDrmSession(const string&, const string&, Exchange::IContentProtection::KeySystem, const string&, const string&, string&, string&) = 0
38
+ // (3) virtual Core::hresult SetDrmSessionState(const string&, Exchange::IContentProtection::State) = 0
39
+ // (4) virtual Core::hresult UpdateDrmSession(const string&, const string&, const string&, string&) = 0
40
+ // (5) virtual Core::hresult CloseDrmSession(const string&, string&) = 0
41
+ // (6) virtual Core::hresult ShowWatermark(const string&, bool, const uint8_t) = 0
42
+ // (7) virtual Core::hresult SetPlaybackPosition(const string&, int32_t, signed long) = 0
42
43
  //
43
44
 
44
45
  static ProxyStub::MethodHandler ExchangeContentProtectionStubMethods[] = {
45
- // (0) virtual uint32_t Register(Exchange::IContentProtection::INotification*) = 0
46
+ // (0) virtual Core::hresult Register(Exchange::IContentProtection::INotification*) = 0
46
47
  //
47
48
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
48
49
  Core::hresult hresult = Core::ERROR_NONE;
49
50
 
50
51
  hresult = [&]() -> Core::hresult {
@@ -64,14 +65,14 @@
64
65
  _notificationProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _notificationInstanceId__, false, _notification);
65
66
  ASSERT((_notification != nullptr) && (_notificationProxy__ != nullptr));
66
67
  if ((_notification == nullptr) || (_notificationProxy__ == nullptr)) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
67
68
  }
68
69
 
69
- uint32_t result = implementation->Register(_notification);
70
+ Core::hresult result = implementation->Register(_notification);
70
71
 
71
72
  RPC::Data::Frame::Writer writer(message->Response().Writer());
72
- writer.Number<uint32_t>(result);
73
+ writer.Number<Core::hresult>(result);
73
74
 
74
75
  if (_notificationProxy__ != nullptr) {
75
76
  RPC::Administrator::Instance().Release(_notificationProxy__, message->Response());
76
77
  }
77
78
 
@@ -83,11 +84,11 @@
83
84
  writer.Number<uint32_t>(hresult);
84
85
  fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IContentProtection::ID, 0, hresult);
85
86
  }
86
87
  },
87
88
 
88
- // (1) virtual uint32_t Unregister(Exchange::IContentProtection::INotification*) = 0
89
+ // (1) virtual Core::hresult Unregister(Exchange::IContentProtection::INotification*) = 0
89
90
  //
90
91
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
91
92
  Core::hresult hresult = Core::ERROR_NONE;
92
93
 
93
94
  hresult = [&]() -> Core::hresult {
@@ -107,14 +108,14 @@
107
108
  _notificationProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _notificationInstanceId__, false, _notification);
108
109
  ASSERT((_notification != nullptr) && (_notificationProxy__ != nullptr));
109
110
  if ((_notification == nullptr) || (_notificationProxy__ == nullptr)) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
110
111
  }
111
112
 
112
- uint32_t result = implementation->Unregister(_notification);
113
+ Core::hresult result = implementation->Unregister(_notification);
113
114
 
114
115
  RPC::Data::Frame::Writer writer(message->Response().Writer());
115
- writer.Number<uint32_t>(result);
116
+ writer.Number<Core::hresult>(result);
116
117
 
117
118
  if (_notificationProxy__ != nullptr) {
118
119
  RPC::Administrator::Instance().Release(_notificationProxy__, message->Response());
119
120
  }
120
121
 
@@ -126,11 +127,11 @@
126
127
  writer.Number<uint32_t>(hresult);
127
128
  fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IContentProtection::ID, 1, hresult);
128
129
  }
129
130
  },
130
131
 
131
- // (2) virtual uint32_t OpenDrmSession(const string&, const string&, Exchange::IContentProtection::KeySystem, const string&, const string&, uint32_t&, string&) = 0
132
+ // (2) virtual Core::hresult OpenDrmSession(const string&, const string&, Exchange::IContentProtection::KeySystem, const string&, const string&, string&, string&) = 0
132
133
  //
133
134
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
134
135
  Core::hresult hresult = Core::ERROR_NONE;
135
136
 
136
137
  hresult = [&]() -> Core::hresult {
@@ -158,18 +159,18 @@
158
159
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
159
160
  const uint16_t _initDataPeekedLen__ = reader.PeekNumber<uint16_t>();
160
161
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _initDataPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
161
162
  const string _initData = reader.Text();
162
163
 
163
- uint32_t _sessionId{};
164
+ string _sessionId{};
164
165
  string _response{};
165
166
 
166
- uint32_t result = implementation->OpenDrmSession(static_cast<const string&>(_clientId), static_cast<const string&>(_appId), _keySystem, static_cast<const string&>(_licenseRequest), static_cast<const string&>(_initData), _sessionId, _response);
167
+ Core::hresult result = implementation->OpenDrmSession(static_cast<const string&>(_clientId), static_cast<const string&>(_appId), _keySystem, static_cast<const string&>(_licenseRequest), static_cast<const string&>(_initData), _sessionId, _response);
167
168
 
168
169
  RPC::Data::Frame::Writer writer(message->Response().Writer());
169
- writer.Number<uint32_t>(result);
170
- writer.Number<uint32_t>(_sessionId);
170
+ writer.Number<Core::hresult>(result);
171
+ writer.Text(_sessionId);
171
172
  writer.Text(_response);
172
173
 
173
174
  return (Core::ERROR_NONE);
174
175
  } ();
175
176
 
@@ -178,11 +179,11 @@
178
179
  writer.Number<uint32_t>(hresult);
179
180
  fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IContentProtection::ID, 2, hresult);
180
181
  }
181
182
  },
182
183
 
183
- // (3) virtual uint32_t SetDrmSessionState(uint32_t, Exchange::IContentProtection::State) = 0
184
+ // (3) virtual Core::hresult SetDrmSessionState(const string&, Exchange::IContentProtection::State) = 0
184
185
  //
185
186
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
186
187
  Core::hresult hresult = Core::ERROR_NONE;
187
188
 
188
189
  hresult = [&]() -> Core::hresult {
@@ -191,19 +192,21 @@
191
192
  Exchange::IContentProtection* implementation = reinterpret_cast<Exchange::IContentProtection*>(message->Parameters().Implementation());
192
193
  ASSERT(implementation != nullptr);
193
194
  if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), Exchange::IContentProtection::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
194
195
 
195
196
  RPC::Data::Frame::Reader reader(message->Parameters().Reader());
196
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
197
- uint32_t _sessionId = reader.Number<uint32_t>();
197
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
198
+ const uint16_t _sessionIdPeekedLen__ = reader.PeekNumber<uint16_t>();
199
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _sessionIdPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
200
+ const string _sessionId = reader.Text();
198
201
  if (reader.Length() < (Core::RealSize<Exchange::IContentProtection::State>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
199
202
  Exchange::IContentProtection::State _sessionState = reader.Number<Exchange::IContentProtection::State>();
200
203
 
201
- uint32_t result = implementation->SetDrmSessionState(_sessionId, _sessionState);
204
+ Core::hresult result = implementation->SetDrmSessionState(static_cast<const string&>(_sessionId), _sessionState);
202
205
 
203
206
  RPC::Data::Frame::Writer writer(message->Response().Writer());
204
- writer.Number<uint32_t>(result);
207
+ writer.Number<Core::hresult>(result);
205
208
 
206
209
  return (Core::ERROR_NONE);
207
210
  } ();
208
211
 
209
212
  if (hresult != Core::ERROR_NONE) {
@@ -211,11 +214,11 @@
211
214
  writer.Number<uint32_t>(hresult);
212
215
  fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IContentProtection::ID, 3, hresult);
213
216
  }
214
217
  },
215
218
 
216
- // (4) virtual uint32_t UpdateDrmSession(uint32_t, const string&, const string&, string&) = 0
219
+ // (4) virtual Core::hresult UpdateDrmSession(const string&, const string&, const string&, string&) = 0
217
220
  //
218
221
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
219
222
  Core::hresult hresult = Core::ERROR_NONE;
220
223
 
221
224
  hresult = [&]() -> Core::hresult {
@@ -224,12 +227,14 @@
224
227
  Exchange::IContentProtection* implementation = reinterpret_cast<Exchange::IContentProtection*>(message->Parameters().Implementation());
225
228
  ASSERT(implementation != nullptr);
226
229
  if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), Exchange::IContentProtection::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
227
230
 
228
231
  RPC::Data::Frame::Reader reader(message->Parameters().Reader());
229
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
230
- uint32_t _sessionId = reader.Number<uint32_t>();
232
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
233
+ const uint16_t _sessionIdPeekedLen__ = reader.PeekNumber<uint16_t>();
234
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _sessionIdPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
235
+ const string _sessionId = reader.Text();
231
236
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
232
237
  const uint16_t _licenseRequestPeekedLen__ = reader.PeekNumber<uint16_t>();
233
238
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _licenseRequestPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
234
239
  const string _licenseRequest = reader.Text();
235
240
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
@@ -237,14 +242,14 @@
237
242
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _initDataPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
238
243
  const string _initData = reader.Text();
239
244
 
240
245
  string _response{};
241
246
 
242
- uint32_t result = implementation->UpdateDrmSession(_sessionId, static_cast<const string&>(_licenseRequest), static_cast<const string&>(_initData), _response);
247
+ Core::hresult result = implementation->UpdateDrmSession(static_cast<const string&>(_sessionId), static_cast<const string&>(_licenseRequest), static_cast<const string&>(_initData), _response);
243
248
 
244
249
  RPC::Data::Frame::Writer writer(message->Response().Writer());
245
- writer.Number<uint32_t>(result);
250
+ writer.Number<Core::hresult>(result);
246
251
  writer.Text(_response);
247
252
 
248
253
  return (Core::ERROR_NONE);
249
254
  } ();
250
255
 
@@ -253,11 +258,11 @@
253
258
  writer.Number<uint32_t>(hresult);
254
259
  fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IContentProtection::ID, 4, hresult);
255
260
  }
256
261
  },
257
262
 
258
- // (5) virtual uint32_t CloseDrmSession(uint32_t, string&) = 0
263
+ // (5) virtual Core::hresult CloseDrmSession(const string&, string&) = 0
259
264
  //
260
265
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
261
266
  Core::hresult hresult = Core::ERROR_NONE;
262
267
 
263
268
  hresult = [&]() -> Core::hresult {
@@ -266,19 +271,21 @@
266
271
  Exchange::IContentProtection* implementation = reinterpret_cast<Exchange::IContentProtection*>(message->Parameters().Implementation());
267
272
  ASSERT(implementation != nullptr);
268
273
  if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), Exchange::IContentProtection::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
269
274
 
270
275
  RPC::Data::Frame::Reader reader(message->Parameters().Reader());
271
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
272
- uint32_t _sessionId = reader.Number<uint32_t>();
276
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
277
+ const uint16_t _sessionIdPeekedLen__ = reader.PeekNumber<uint16_t>();
278
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _sessionIdPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
279
+ const string _sessionId = reader.Text();
273
280
 
274
281
  string _response{};
275
282
 
276
- uint32_t result = implementation->CloseDrmSession(_sessionId, _response);
283
+ Core::hresult result = implementation->CloseDrmSession(static_cast<const string&>(_sessionId), _response);
277
284
 
278
285
  RPC::Data::Frame::Writer writer(message->Response().Writer());
279
- writer.Number<uint32_t>(result);
286
+ writer.Number<Core::hresult>(result);
280
287
  writer.Text(_response);
281
288
 
282
289
  return (Core::ERROR_NONE);
283
290
  } ();
284
291
 
@@ -287,11 +294,11 @@
287
294
  writer.Number<uint32_t>(hresult);
288
295
  fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IContentProtection::ID, 5, hresult);
289
296
  }
290
297
  },
291
298
 
292
- // (6) virtual uint32_t ShowWatermark(uint32_t, bool, const uint8_t) = 0
299
+ // (6) virtual Core::hresult ShowWatermark(const string&, bool, const uint8_t) = 0
293
300
  //
294
301
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
295
302
  Core::hresult hresult = Core::ERROR_NONE;
296
303
 
297
304
  hresult = [&]() -> Core::hresult {
@@ -300,23 +307,25 @@
300
307
  Exchange::IContentProtection* implementation = reinterpret_cast<Exchange::IContentProtection*>(message->Parameters().Implementation());
301
308
  ASSERT(implementation != nullptr);
302
309
  if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), Exchange::IContentProtection::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
303
310
 
304
311
  RPC::Data::Frame::Reader reader(message->Parameters().Reader());
305
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
306
- uint32_t _sessionId = reader.Number<uint32_t>();
312
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
313
+ const uint16_t _sessionIdPeekedLen__ = reader.PeekNumber<uint16_t>();
314
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _sessionIdPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
315
+ const string _sessionId = reader.Text();
307
316
  if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
308
317
  bool _show = reader.Boolean();
309
318
  if (reader.Length() < (Core::RealSize<uint8_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
310
319
  const uint8_t _opacityLevel = reader.Number<uint8_t>();
311
320
  ASSERT((_opacityLevel >= 0) && (_opacityLevel <= 100));
312
321
  if (!((_opacityLevel >= 0) && (_opacityLevel <= 100))) { return (COM_ERROR | Core::ERROR_INVALID_RANGE); }
313
322
 
314
- uint32_t result = implementation->ShowWatermark(_sessionId, _show, _opacityLevel);
323
+ Core::hresult result = implementation->ShowWatermark(static_cast<const string&>(_sessionId), _show, _opacityLevel);
315
324
 
316
325
  RPC::Data::Frame::Writer writer(message->Response().Writer());
317
- writer.Number<uint32_t>(result);
326
+ writer.Number<Core::hresult>(result);
318
327
 
319
328
  return (Core::ERROR_NONE);
320
329
  } ();
321
330
 
322
331
  if (hresult != Core::ERROR_NONE) {
@@ -324,11 +333,11 @@
324
333
  writer.Number<uint32_t>(hresult);
325
334
  fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IContentProtection::ID, 6, hresult);
326
335
  }
327
336
  },
328
337
 
329
- // (7) virtual uint32_t SetPlaybackPosition(uint32_t, int32_t, signed long) = 0
338
+ // (7) virtual Core::hresult SetPlaybackPosition(const string&, int32_t, signed long) = 0
330
339
  //
331
340
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
332
341
  Core::hresult hresult = Core::ERROR_NONE;
333
342
 
334
343
  hresult = [&]() -> Core::hresult {
@@ -337,21 +346,23 @@
337
346
  Exchange::IContentProtection* implementation = reinterpret_cast<Exchange::IContentProtection*>(message->Parameters().Implementation());
338
347
  ASSERT(implementation != nullptr);
339
348
  if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), Exchange::IContentProtection::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
340
349
 
341
350
  RPC::Data::Frame::Reader reader(message->Parameters().Reader());
342
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
343
- uint32_t _sessionId = reader.Number<uint32_t>();
351
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
352
+ const uint16_t _sessionIdPeekedLen__ = reader.PeekNumber<uint16_t>();
353
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _sessionIdPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
354
+ const string _sessionId = reader.Text();
344
355
  if (reader.Length() < (Core::RealSize<int32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
345
356
  int32_t _speed = reader.Number<int32_t>();
346
357
  if (reader.Length() < (Core::RealSize<signed long>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
347
358
  signed long _position = reader.Number<signed long>();
348
359
 
349
- uint32_t result = implementation->SetPlaybackPosition(_sessionId, _speed, _position);
360
+ Core::hresult result = implementation->SetPlaybackPosition(static_cast<const string&>(_sessionId), _speed, _position);
350
361
 
351
362
  RPC::Data::Frame::Writer writer(message->Response().Writer());
352
- writer.Number<uint32_t>(result);
363
+ writer.Number<Core::hresult>(result);
353
364
 
354
365
  return (Core::ERROR_NONE);
355
366
  } ();
356
367
 
357
368
  if (hresult != Core::ERROR_NONE) {
@@ -365,15 +376,15 @@
365
376
 
366
377
  //
367
378
  // Exchange::IContentProtection::INotification interface stub definitions
368
379
  //
369
380
  // Methods:
370
- // (0) virtual void WatermarkStatusChanged(uint32_t, const string&, const Exchange::IContentProtection::INotification::Status&) = 0
381
+ // (0) virtual void WatermarkStatusChanged(const string&, const string&, const Exchange::IContentProtection::INotification::Status&) = 0
371
382
  //
372
383
 
373
384
  static ProxyStub::MethodHandler ExchangeContentProtectionNotificationStubMethods[] = {
374
- // (0) virtual void WatermarkStatusChanged(uint32_t, const string&, const Exchange::IContentProtection::INotification::Status&) = 0
385
+ // (0) virtual void WatermarkStatusChanged(const string&, const string&, const Exchange::IContentProtection::INotification::Status&) = 0
375
386
  //
376
387
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
377
388
  Core::hresult hresult = Core::ERROR_NONE;
378
389
 
379
390
  hresult = [&]() -> Core::hresult {
@@ -382,23 +393,25 @@
382
393
  Exchange::IContentProtection::INotification* implementation = reinterpret_cast<Exchange::IContentProtection::INotification*>(message->Parameters().Implementation());
383
394
  ASSERT(implementation != nullptr);
384
395
  if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), Exchange::IContentProtection::INotification::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
385
396
 
386
397
  RPC::Data::Frame::Reader reader(message->Parameters().Reader());
387
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
388
- uint32_t _sessionId = reader.Number<uint32_t>();
398
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
399
+ const uint16_t _sessionIdPeekedLen__ = reader.PeekNumber<uint16_t>();
400
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _sessionIdPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
401
+ const string _sessionId = reader.Text();
389
402
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
390
403
  const uint16_t _appIdPeekedLen__ = reader.PeekNumber<uint16_t>();
391
404
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _appIdPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
392
405
  const string _appId = reader.Text();
393
406
  Exchange::IContentProtection::INotification::Status _status{};
394
407
  if (reader.Length() < (Core::RealSize<Exchange::IContentProtection::INotification::Status::State>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
395
408
  _status.state = reader.Number<Exchange::IContentProtection::INotification::Status::State>();
396
409
  if (reader.Length() < (Core::RealSize<int32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
397
410
  _status.failureReason = reader.Number<int32_t>();
398
411
 
399
- implementation->WatermarkStatusChanged(_sessionId, static_cast<const string&>(_appId), static_cast<const Exchange::IContentProtection::INotification::Status&>(_status));
412
+ implementation->WatermarkStatusChanged(static_cast<const string&>(_sessionId), static_cast<const string&>(_appId), static_cast<const Exchange::IContentProtection::INotification::Status&>(_status));
400
413
 
401
414
  return (Core::ERROR_NONE);
402
415
  } ();
403
416
 
404
417
  if (hresult != Core::ERROR_NONE) {
@@ -407,36 +420,80 @@
407
420
  }
408
421
  }
409
422
  , nullptr
410
423
  }; // ExchangeContentProtectionNotificationStubMethods
411
424
 
425
+ //
426
+ // Exchange::IErrorToString interface stub definitions
427
+ //
428
+ // Methods:
429
+ // (0) virtual Core::hresult ErrorToString(const int32_t, string&) const = 0
430
+ //
431
+
432
+ static ProxyStub::MethodHandler ExchangeErrorToStringStubMethods[] = {
433
+ // (0) virtual Core::hresult ErrorToString(const int32_t, string&) const = 0
434
+ //
435
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
436
+ Core::hresult hresult = Core::ERROR_NONE;
437
+
438
+ hresult = [&]() -> Core::hresult {
439
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
440
+
441
+ const Exchange::IErrorToString* implementation = reinterpret_cast<const Exchange::IErrorToString*>(message->Parameters().Implementation());
442
+ ASSERT(implementation != nullptr);
443
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), Exchange::IErrorToString::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
444
+
445
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
446
+ if (reader.Length() < (Core::RealSize<int32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
447
+ const int32_t _code = reader.Number<int32_t>();
448
+
449
+ string _result{};
450
+
451
+ Core::hresult result = implementation->ErrorToString(_code, _result);
452
+
453
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
454
+ writer.Number<Core::hresult>(result);
455
+ writer.Text(_result);
456
+
457
+ return (Core::ERROR_NONE);
458
+ } ();
459
+
460
+ if (hresult != Core::ERROR_NONE) {
461
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
462
+ writer.Number<uint32_t>(hresult);
463
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IErrorToString::ID, 0, hresult);
464
+ }
465
+ }
466
+ , nullptr
467
+ }; // ExchangeErrorToStringStubMethods
468
+
412
469
  // -----------------------------------------------------------------
413
470
  // PROXIES
414
471
  // -----------------------------------------------------------------
415
472
 
416
473
  //
417
474
  // Exchange::IContentProtection interface proxy definitions
418
475
  //
419
476
  // Methods:
420
- // (0) virtual uint32_t Register(Exchange::IContentProtection::INotification*) = 0
421
- // (1) virtual uint32_t Unregister(Exchange::IContentProtection::INotification*) = 0
422
- // (2) virtual uint32_t OpenDrmSession(const string&, const string&, Exchange::IContentProtection::KeySystem, const string&, const string&, uint32_t&, string&) = 0
423
- // (3) virtual uint32_t SetDrmSessionState(uint32_t, Exchange::IContentProtection::State) = 0
424
- // (4) virtual uint32_t UpdateDrmSession(uint32_t, const string&, const string&, string&) = 0
425
- // (5) virtual uint32_t CloseDrmSession(uint32_t, string&) = 0
426
- // (6) virtual uint32_t ShowWatermark(uint32_t, bool, const uint8_t) = 0
427
- // (7) virtual uint32_t SetPlaybackPosition(uint32_t, int32_t, signed long) = 0
477
+ // (0) virtual Core::hresult Register(Exchange::IContentProtection::INotification*) = 0
478
+ // (1) virtual Core::hresult Unregister(Exchange::IContentProtection::INotification*) = 0
479
+ // (2) virtual Core::hresult OpenDrmSession(const string&, const string&, Exchange::IContentProtection::KeySystem, const string&, const string&, string&, string&) = 0
480
+ // (3) virtual Core::hresult SetDrmSessionState(const string&, Exchange::IContentProtection::State) = 0
481
+ // (4) virtual Core::hresult UpdateDrmSession(const string&, const string&, const string&, string&) = 0
482
+ // (5) virtual Core::hresult CloseDrmSession(const string&, string&) = 0
483
+ // (6) virtual Core::hresult ShowWatermark(const string&, bool, const uint8_t) = 0
484
+ // (7) virtual Core::hresult SetPlaybackPosition(const string&, int32_t, signed long) = 0
428
485
  //
429
486
 
430
487
  class ExchangeContentProtectionProxy final : public ProxyStub::UnknownProxyType<Exchange::IContentProtection> {
431
488
  public:
432
489
  ExchangeContentProtectionProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
433
490
  : BaseClass(channel, implementation, otherSideInformed)
434
491
  {
435
492
  }
436
493
 
437
- uint32_t Register(Exchange::IContentProtection::INotification* _notification) override
494
+ Core::hresult Register(Exchange::IContentProtection::INotification* _notification) override
438
495
  {
439
496
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
440
497
 
441
498
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
442
499
  writer.Number<Core::instance_id>(RPC::instance_cast(_notification));
@@ -446,12 +503,12 @@
446
503
 
447
504
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
448
505
  if (hresult == Core::ERROR_NONE) {
449
506
  hresult = [&]() -> Core::hresult {
450
507
  RPC::Data::Frame::Reader reader(message->Response().Reader());
451
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
452
- hresult = reader.Number<uint32_t>();
508
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
509
+ hresult = reader.Number<Core::hresult>();
453
510
 
454
511
  const uint32_t completeResult__ = _Complete(reader);
455
512
  if (completeResult__ != Core::ERROR_NONE) { return (completeResult__); }
456
513
 
457
514
  return (hresult);
@@ -467,11 +524,11 @@
467
524
  static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(nullptr);
468
525
 
469
526
  return (hresult);
470
527
  }
471
528
 
472
- uint32_t Unregister(Exchange::IContentProtection::INotification* _notification) override
529
+ Core::hresult Unregister(Exchange::IContentProtection::INotification* _notification) override
473
530
  {
474
531
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
475
532
 
476
533
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
477
534
  writer.Number<Core::instance_id>(RPC::instance_cast(_notification));
@@ -481,12 +538,12 @@
481
538
 
482
539
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
483
540
  if (hresult == Core::ERROR_NONE) {
484
541
  hresult = [&]() -> Core::hresult {
485
542
  RPC::Data::Frame::Reader reader(message->Response().Reader());
486
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
487
- hresult = reader.Number<uint32_t>();
543
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
544
+ hresult = reader.Number<Core::hresult>();
488
545
 
489
546
  const uint32_t completeResult__ = _Complete(reader);
490
547
  if (completeResult__ != Core::ERROR_NONE) { return (completeResult__); }
491
548
 
492
549
  return (hresult);
@@ -502,11 +559,11 @@
502
559
  static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(nullptr);
503
560
 
504
561
  return (hresult);
505
562
  }
506
563
 
507
- uint32_t OpenDrmSession(const string& _clientId, const string& _appId, Exchange::IContentProtection::KeySystem _keySystem, const string& _licenseRequest, const string& _initData, uint32_t& _sessionId, string& _response) override
564
+ Core::hresult OpenDrmSession(const string& _clientId, const string& _appId, Exchange::IContentProtection::KeySystem _keySystem, const string& _licenseRequest, const string& _initData, string& _sessionId, string& _response) override
508
565
  {
509
566
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
510
567
 
511
568
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
512
569
  writer.Text(_clientId);
@@ -517,15 +574,17 @@
517
574
 
518
575
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
519
576
  if (hresult == Core::ERROR_NONE) {
520
577
  hresult = [&]() -> Core::hresult {
521
578
  RPC::Data::Frame::Reader reader(message->Response().Reader());
522
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
523
- hresult = reader.Number<uint32_t>();
579
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
580
+ hresult = reader.Number<Core::hresult>();
524
581
  if ((hresult & COM_ERROR) == 0) {
525
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
526
- _sessionId = reader.Number<uint32_t>();
582
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
583
+ const uint16_t _sessionIdPeekedLen__ = reader.PeekNumber<uint16_t>();
584
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _sessionIdPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
585
+ _sessionId = reader.Text();
527
586
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
528
587
  const uint16_t _responsePeekedLen__ = reader.PeekNumber<uint16_t>();
529
588
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _responsePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
530
589
  _response = reader.Text();
531
590
  }
@@ -541,24 +600,24 @@
541
600
  }
542
601
 
543
602
  return (hresult);
544
603
  }
545
604
 
546
- uint32_t SetDrmSessionState(uint32_t _sessionId, Exchange::IContentProtection::State _sessionState) override
605
+ Core::hresult SetDrmSessionState(const string& _sessionId, Exchange::IContentProtection::State _sessionState) override
547
606
  {
548
607
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
549
608
 
550
609
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
551
- writer.Number<uint32_t>(_sessionId);
610
+ writer.Text(_sessionId);
552
611
  writer.Number<Exchange::IContentProtection::State>(_sessionState);
553
612
 
554
613
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
555
614
  if (hresult == Core::ERROR_NONE) {
556
615
  hresult = [&]() -> Core::hresult {
557
616
  RPC::Data::Frame::Reader reader(message->Response().Reader());
558
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
559
- hresult = reader.Number<uint32_t>();
617
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
618
+ hresult = reader.Number<Core::hresult>();
560
619
 
561
620
  return (hresult);
562
621
  } ();
563
622
  } else {
564
623
  ASSERT((hresult & COM_ERROR) != 0);
@@ -569,25 +628,25 @@
569
628
  }
570
629
 
571
630
  return (hresult);
572
631
  }
573
632
 
574
- uint32_t UpdateDrmSession(uint32_t _sessionId, const string& _licenseRequest, const string& _initData, string& _response) override
633
+ Core::hresult UpdateDrmSession(const string& _sessionId, const string& _licenseRequest, const string& _initData, string& _response) override
575
634
  {
576
635
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(4));
577
636
 
578
637
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
579
- writer.Number<uint32_t>(_sessionId);
638
+ writer.Text(_sessionId);
580
639
  writer.Text(_licenseRequest);
581
640
  writer.Text(_initData);
582
641
 
583
642
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
584
643
  if (hresult == Core::ERROR_NONE) {
585
644
  hresult = [&]() -> Core::hresult {
586
645
  RPC::Data::Frame::Reader reader(message->Response().Reader());
587
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
588
- hresult = reader.Number<uint32_t>();
646
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
647
+ hresult = reader.Number<Core::hresult>();
589
648
  if ((hresult & COM_ERROR) == 0) {
590
649
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
591
650
  const uint16_t _responsePeekedLen__ = reader.PeekNumber<uint16_t>();
592
651
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _responsePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
593
652
  _response = reader.Text();
@@ -604,23 +663,23 @@
604
663
  }
605
664
 
606
665
  return (hresult);
607
666
  }
608
667
 
609
- uint32_t CloseDrmSession(uint32_t _sessionId, string& _response) override
668
+ Core::hresult CloseDrmSession(const string& _sessionId, string& _response) override
610
669
  {
611
670
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(5));
612
671
 
613
672
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
614
- writer.Number<uint32_t>(_sessionId);
673
+ writer.Text(_sessionId);
615
674
 
616
675
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
617
676
  if (hresult == Core::ERROR_NONE) {
618
677
  hresult = [&]() -> Core::hresult {
619
678
  RPC::Data::Frame::Reader reader(message->Response().Reader());
620
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
621
- hresult = reader.Number<uint32_t>();
679
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
680
+ hresult = reader.Number<Core::hresult>();
622
681
  if ((hresult & COM_ERROR) == 0) {
623
682
  if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
624
683
  const uint16_t _responsePeekedLen__ = reader.PeekNumber<uint16_t>();
625
684
  if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _responsePeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
626
685
  _response = reader.Text();
@@ -637,25 +696,25 @@
637
696
  }
638
697
 
639
698
  return (hresult);
640
699
  }
641
700
 
642
- uint32_t ShowWatermark(uint32_t _sessionId, bool _show, const uint8_t _opacityLevel) override
701
+ Core::hresult ShowWatermark(const string& _sessionId, bool _show, const uint8_t _opacityLevel) override
643
702
  {
644
703
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(6));
645
704
 
646
705
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
647
- writer.Number<uint32_t>(_sessionId);
706
+ writer.Text(_sessionId);
648
707
  writer.Boolean(_show);
649
708
  writer.Number<uint8_t>(_opacityLevel);
650
709
 
651
710
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
652
711
  if (hresult == Core::ERROR_NONE) {
653
712
  hresult = [&]() -> Core::hresult {
654
713
  RPC::Data::Frame::Reader reader(message->Response().Reader());
655
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
656
- hresult = reader.Number<uint32_t>();
714
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
715
+ hresult = reader.Number<Core::hresult>();
657
716
 
658
717
  return (hresult);
659
718
  } ();
660
719
  } else {
661
720
  ASSERT((hresult & COM_ERROR) != 0);
@@ -666,25 +725,25 @@
666
725
  }
667
726
 
668
727
  return (hresult);
669
728
  }
670
729
 
671
- uint32_t SetPlaybackPosition(uint32_t _sessionId, int32_t _speed, signed long _position) override
730
+ Core::hresult SetPlaybackPosition(const string& _sessionId, int32_t _speed, signed long _position) override
672
731
  {
673
732
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(7));
674
733
 
675
734
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
676
- writer.Number<uint32_t>(_sessionId);
735
+ writer.Text(_sessionId);
677
736
  writer.Number<int32_t>(_speed);
678
737
  writer.Number<signed long>(_position);
679
738
 
680
739
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
681
740
  if (hresult == Core::ERROR_NONE) {
682
741
  hresult = [&]() -> Core::hresult {
683
742
  RPC::Data::Frame::Reader reader(message->Response().Reader());
684
- if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
685
- hresult = reader.Number<uint32_t>();
743
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
744
+ hresult = reader.Number<Core::hresult>();
686
745
 
687
746
  return (hresult);
688
747
  } ();
689
748
  } else {
690
749
  ASSERT((hresult & COM_ERROR) != 0);
@@ -725,26 +784,26 @@
725
784
 
726
785
  //
727
786
  // Exchange::IContentProtection::INotification interface proxy definitions
728
787
  //
729
788
  // Methods:
730
- // (0) virtual void WatermarkStatusChanged(uint32_t, const string&, const Exchange::IContentProtection::INotification::Status&) = 0
789
+ // (0) virtual void WatermarkStatusChanged(const string&, const string&, const Exchange::IContentProtection::INotification::Status&) = 0
731
790
  //
732
791
 
733
792
  class ExchangeContentProtectionNotificationProxy final : public ProxyStub::UnknownProxyType<Exchange::IContentProtection::INotification> {
734
793
  public:
735
794
  ExchangeContentProtectionNotificationProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
736
795
  : BaseClass(channel, implementation, otherSideInformed)
737
796
  {
738
797
  }
739
798
 
740
- void WatermarkStatusChanged(uint32_t _sessionId, const string& _appId, const Exchange::IContentProtection::INotification::Status& _status) override
799
+ void WatermarkStatusChanged(const string& _sessionId, const string& _appId, const Exchange::IContentProtection::INotification::Status& _status) override
741
800
  {
742
801
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
743
802
 
744
803
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
745
- writer.Number<uint32_t>(_sessionId);
804
+ writer.Text(_sessionId);
746
805
  writer.Text(_appId);
747
806
  writer.Number<Exchange::IContentProtection::INotification::Status::State>(_status.state);
748
807
  writer.Number<int32_t>(_status.failureReason);
749
808
 
750
809
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
@@ -763,34 +822,86 @@
763
822
  }
764
823
  }
765
824
 
766
825
  }; // class ExchangeContentProtectionNotificationProxy
767
826
 
827
+ //
828
+ // Exchange::IErrorToString interface proxy definitions
829
+ //
830
+ // Methods:
831
+ // (0) virtual Core::hresult ErrorToString(const int32_t, string&) const = 0
832
+ //
833
+
834
+ class ExchangeErrorToStringProxy final : public ProxyStub::UnknownProxyType<Exchange::IErrorToString> {
835
+ public:
836
+ ExchangeErrorToStringProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
837
+ : BaseClass(channel, implementation, otherSideInformed)
838
+ {
839
+ }
840
+
841
+ Core::hresult ErrorToString(const int32_t _code, string& _result) const override
842
+ {
843
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
844
+
845
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
846
+ writer.Number<int32_t>(_code);
847
+
848
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
849
+ if (hresult == Core::ERROR_NONE) {
850
+ hresult = [&]() -> Core::hresult {
851
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
852
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
853
+ hresult = reader.Number<Core::hresult>();
854
+ if ((hresult & COM_ERROR) == 0) {
855
+ if (reader.Length() < (Core::RealSize<uint16_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
856
+ const uint16_t _resultPeekedLen__ = reader.PeekNumber<uint16_t>();
857
+ if (reader.Length() < (static_cast<uint32_t>(Core::RealSize<uint16_t>()) + _resultPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
858
+ _result = reader.Text();
859
+ }
860
+
861
+ return (hresult);
862
+ } ();
863
+ } else {
864
+ ASSERT((hresult & COM_ERROR) != 0);
865
+ }
866
+
867
+ if ((hresult & COM_ERROR) != 0) {
868
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", Exchange::IErrorToString::ID, 0, hresult);
869
+ }
870
+
871
+ return (hresult);
872
+ }
873
+
874
+ }; // class ExchangeErrorToStringProxy
875
+
768
876
  POP_WARNING()
769
877
  POP_WARNING()
770
878
 
771
879
  // -----------------------------------------------------------------
772
880
  // REGISTRATION
773
881
  // -----------------------------------------------------------------
774
882
  namespace {
775
883
 
776
884
  typedef ProxyStub::UnknownStubType<Exchange::IContentProtection, ExchangeContentProtectionStubMethods> ExchangeContentProtectionStub;
777
885
  typedef ProxyStub::UnknownStubType<Exchange::IContentProtection::INotification, ExchangeContentProtectionNotificationStubMethods> ExchangeContentProtectionNotificationStub;
886
+ typedef ProxyStub::UnknownStubType<Exchange::IErrorToString, ExchangeErrorToStringStubMethods> ExchangeErrorToStringStub;
778
887
 
779
888
  static class Instantiation {
780
889
  public:
781
890
  Instantiation()
782
891
  {
783
892
  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));
784
893
 
785
894
  RPC::Administrator::Instance().Announce<Exchange::IContentProtection, ExchangeContentProtectionProxy, ExchangeContentProtectionStub>(security);
786
895
  RPC::Administrator::Instance().Announce<Exchange::IContentProtection::INotification, ExchangeContentProtectionNotificationProxy, ExchangeContentProtectionNotificationStub>(security);
896
+ RPC::Administrator::Instance().Announce<Exchange::IErrorToString, ExchangeErrorToStringProxy, ExchangeErrorToStringStub>(security);
787
897
  }
788
898
  ~Instantiation()
789
899
  {
790
900
  RPC::Administrator::Instance().Recall<Exchange::IContentProtection>();
791
901
  RPC::Administrator::Instance().Recall<Exchange::IContentProtection::INotification>();
902
+ RPC::Administrator::Instance().Recall<Exchange::IErrorToString>();
792
903
  }
793
904
  } ProxyStubRegistration;
794
905
 
795
906
  } // namespace
796
907
 
{baseline → generated}/Release/ThunderInterfaces/interfaces/generated/ProxyStubs_MessageControl.cpp RENAMED
@@ -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
- }
{baseline → generated}/Release/ThunderInterfaces/interfaces/generated/ProxyStubs_MessagingControl.cpp RENAMED
@@ -0,0 +1,1088 @@
1
+ //
2
+ // generated automatically from "IMessagingControl.h"
3
+ //
4
+ // implements COM-RPC proxy stubs for:
5
+ // - class RPC::IIteratorType<typename ELEMENT, const uint32_t INTERFACE_ID> [with ELEMENT = Exchange::IMessagingControl::Control, INTERFACE_ID = Exchange::ID_MESSAGING_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::IMessagingControl
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 "IMessagingControl.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_e1375fa4d7fa7ef4 interface stub definitions
33
+ //
34
+ // Methods:
35
+ // (0) virtual bool Next(Exchange::IMessagingControl::Control&) = 0
36
+ // (1) virtual bool Previous(Exchange::IMessagingControl::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::IMessagingControl::Control Current() const = 0
41
+ //
42
+
43
+ static ProxyStub::MethodHandler RPCIteratorTypeInstance_e1375fa4d7fa7ef4StubMethods[] = {
44
+ // (0) virtual bool Next(Exchange::IMessagingControl::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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::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::IMessagingControl::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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::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::IMessagingControl::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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::Control, Exchange::ID_MESSAGING_CONTROL_ITERATOR>::ID, 4, hresult);
193
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
194
+ }
195
+ },
196
+
197
+ // (5) virtual Exchange::IMessagingControl::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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::Control result = implementation->Current();
212
+
213
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
214
+ writer.Number<Exchange::IMessagingControl::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::IMessagingControl::Control, Exchange::ID_MESSAGING_CONTROL_ITERATOR>::ID, 5, hresult);
224
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
225
+ }
226
+ }
227
+ , nullptr
228
+ }; // RPCIteratorTypeInstance_e1375fa4d7fa7ef4StubMethods
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::IMessagingControl interface stub definitions
422
+ //
423
+ // Methods:
424
+ // (0) virtual Core::hresult Enable(const Exchange::IMessagingControl::messagetype, const string&, const string&, const bool) = 0
425
+ // (1) virtual Core::hresult Modules(Exchange::IMessagingControl::IStringIterator*&) const = 0
426
+ // (2) virtual Core::hresult Controls(const string&, Exchange::IMessagingControl::IControlIterator*&) const = 0
427
+ //
428
+
429
+ static ProxyStub::MethodHandler ExchangeMessagingControlStubMethods[] = {
430
+ // (0) virtual Core::hresult Enable(const Exchange::IMessagingControl::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::IMessagingControl* implementation = reinterpret_cast<Exchange::IMessagingControl*>(message->Parameters().Implementation());
439
+ ASSERT(implementation != nullptr);
440
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), Exchange::IMessagingControl::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::IMessagingControl::messagetype>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
444
+ const Exchange::IMessagingControl::messagetype _type = reader.Number<Exchange::IMessagingControl::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::IMessagingControl::ID, 0, hresult);
468
+ }
469
+ },
470
+
471
+ // (1) virtual Core::hresult Modules(Exchange::IMessagingControl::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::IMessagingControl* implementation = reinterpret_cast<const Exchange::IMessagingControl*>(message->Parameters().Implementation());
480
+ ASSERT(implementation != nullptr);
481
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), Exchange::IMessagingControl::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
482
+
483
+ Exchange::IMessagingControl::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::IMessagingControl::ID, 1, hresult);
500
+ }
501
+ },
502
+
503
+ // (2) virtual Core::hresult Controls(const string&, Exchange::IMessagingControl::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::IMessagingControl* implementation = reinterpret_cast<const Exchange::IMessagingControl*>(message->Parameters().Implementation());
512
+ ASSERT(implementation != nullptr);
513
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), Exchange::IMessagingControl::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::IMessagingControl::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::IMessagingControl::ID, 2, hresult);
538
+ }
539
+ }
540
+ , nullptr
541
+ }; // ExchangeMessagingControlStubMethods
542
+
543
+ // -----------------------------------------------------------------
544
+ // PROXIES
545
+ // -----------------------------------------------------------------
546
+
547
+ //
548
+ // RPC::IIteratorTypeInstance_e1375fa4d7fa7ef4 interface proxy definitions
549
+ //
550
+ // Methods:
551
+ // (0) virtual bool Next(Exchange::IMessagingControl::Control&) = 0
552
+ // (1) virtual bool Previous(Exchange::IMessagingControl::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::IMessagingControl::Control Current() const = 0
557
+ //
558
+
559
+ class RPCIteratorTypeInstance_e1375fa4d7fa7ef4Proxy final : public ProxyStub::UnknownProxyType<RPC::IIteratorType<Exchange::IMessagingControl::Control, Exchange::ID_MESSAGING_CONTROL_ITERATOR>> {
560
+ public:
561
+ RPCIteratorTypeInstance_e1375fa4d7fa7ef4Proxy(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::IMessagingControl::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::IMessagingControl::messagetype>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
579
+ _info.type = reader.Number<Exchange::IMessagingControl::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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::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::IMessagingControl::messagetype>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
618
+ _info.type = reader.Number<Exchange::IMessagingControl::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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::Control, Exchange::ID_MESSAGING_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::IMessagingControl::Control Current() const override
722
+ {
723
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(5));
724
+
725
+ Exchange::IMessagingControl::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::IMessagingControl::messagetype>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
732
+ result.type = reader.Number<Exchange::IMessagingControl::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::IMessagingControl::Control, Exchange::ID_MESSAGING_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_e1375fa4d7fa7ef4Proxy
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::IMessagingControl interface proxy definitions
951
+ //
952
+ // Methods:
953
+ // (0) virtual Core::hresult Enable(const Exchange::IMessagingControl::messagetype, const string&, const string&, const bool) = 0
954
+ // (1) virtual Core::hresult Modules(Exchange::IMessagingControl::IStringIterator*&) const = 0
955
+ // (2) virtual Core::hresult Controls(const string&, Exchange::IMessagingControl::IControlIterator*&) const = 0
956
+ //
957
+
958
+ class ExchangeMessagingControlProxy final : public ProxyStub::UnknownProxyType<Exchange::IMessagingControl> {
959
+ public:
960
+ ExchangeMessagingControlProxy(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::IMessagingControl::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::IMessagingControl::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::IMessagingControl::ID, 0, hresult);
990
+ }
991
+
992
+ return (hresult);
993
+ }
994
+
995
+ Core::hresult Modules(Exchange::IMessagingControl::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::IMessagingControl::IStringIterator*>(static_cast<const ProxyStub::UnknownProxy&>(*this).Interface(reader.Number<Core::instance_id>(), Exchange::IMessagingControl::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::IMessagingControl::ID, 1, hresult);
1017
+ }
1018
+
1019
+ return (hresult);
1020
+ }
1021
+
1022
+ Core::hresult Controls(const string& _module, Exchange::IMessagingControl::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::IMessagingControl::IControlIterator*>(static_cast<const ProxyStub::UnknownProxy&>(*this).Interface(reader.Number<Core::instance_id>(), Exchange::IMessagingControl::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::IMessagingControl::ID, 2, hresult);
1047
+ }
1048
+
1049
+ return (hresult);
1050
+ }
1051
+
1052
+ }; // class ExchangeMessagingControlProxy
1053
+
1054
+ POP_WARNING()
1055
+ POP_WARNING()
1056
+
1057
+ // -----------------------------------------------------------------
1058
+ // REGISTRATION
1059
+ // -----------------------------------------------------------------
1060
+ namespace {
1061
+
1062
+ typedef ProxyStub::UnknownStubType<RPC::IIteratorType<Exchange::IMessagingControl::Control, Exchange::ID_MESSAGING_CONTROL_ITERATOR>, RPCIteratorTypeInstance_e1375fa4d7fa7ef4StubMethods> RPCIteratorTypeInstance_e1375fa4d7fa7ef4Stub;
1063
+ typedef ProxyStub::UnknownStubType<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>, RPCIteratorTypeInstance_b3acff3685df4032StubMethods> RPCIteratorTypeInstance_b3acff3685df4032Stub;
1064
+ typedef ProxyStub::UnknownStubType<Exchange::IMessagingControl, ExchangeMessagingControlStubMethods> ExchangeMessagingControlStub;
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::IMessagingControl::Control, Exchange::ID_MESSAGING_CONTROL_ITERATOR>, RPCIteratorTypeInstance_e1375fa4d7fa7ef4Proxy, RPCIteratorTypeInstance_e1375fa4d7fa7ef4Stub>(security);
1073
+ RPC::Administrator::Instance().Announce<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>, RPCIteratorTypeInstance_b3acff3685df4032Proxy, RPCIteratorTypeInstance_b3acff3685df4032Stub>(security);
1074
+ RPC::Administrator::Instance().Announce<Exchange::IMessagingControl, ExchangeMessagingControlProxy, ExchangeMessagingControlStub>(security);
1075
+ }
1076
+ ~Instantiation()
1077
+ {
1078
+ RPC::Administrator::Instance().Recall<RPC::IIteratorType<Exchange::IMessagingControl::Control, Exchange::ID_MESSAGING_CONTROL_ITERATOR>>();
1079
+ RPC::Administrator::Instance().Recall<RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>();
1080
+ RPC::Administrator::Instance().Recall<Exchange::IMessagingControl>();
1081
+ }
1082
+ } ProxyStubRegistration;
1083
+
1084
+ } // namespace
1085
+
1086
+ } // namespace ProxyStubs
1087
+
1088
+ }