Diff to HTML by rtfpessoa

Files changed (2) hide show
  1. {baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Debug/Thunder/Source/plugins/generated/ProxyStubs_Controller.cpp +66 -13
  2. {baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Release/Thunder/Source/plugins/generated/ProxyStubs_Controller.cpp +102 -17
{baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Debug/Thunder/Source/plugins/generated/ProxyStubs_Controller.cpp RENAMED
@@ -176,29 +176,54 @@ namespace ProxyStubs {
176
176
 
177
177
  //
178
178
  // Controller::IConfiguration interface stub definitions
179
179
  //
180
180
  // Methods:
181
- // (0) virtual Core::hresult Persist() = 0
182
- // (1) virtual Core::hresult Configuration(const Core::OptionalType<string>&, string&) const = 0
183
- // (2) virtual Core::hresult Configuration(const string&, const string&) = 0
181
+ // (0) virtual Core::hresult Persist(const Core::OptionalType<string>&) = 0
182
+ // (1) virtual Core::hresult Restore(const Core::OptionalType<string>&) = 0
183
+ // (2) virtual Core::hresult Configuration(const Core::OptionalType<string>&, string&) const = 0
184
+ // (3) virtual Core::hresult Configuration(const string&, const string&) = 0
184
185
  //
185
186
 
186
187
  static ProxyStub::MethodHandler ControllerConfigurationStubMethods[] = {
187
- // (0) virtual Core::hresult Persist() = 0
188
+ // (0) virtual Core::hresult Persist(const Core::OptionalType<string>&) = 0
188
189
  //
189
190
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
190
191
  Controller::IConfiguration* implementation = reinterpret_cast<Controller::IConfiguration*>(message->Parameters().Implementation());
191
192
  ASSERT(implementation != nullptr);
192
193
 
193
- Core::hresult result = implementation->Persist();
194
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
195
+ Core::OptionalType<string> _callsign{};
196
+ if (reader.Boolean() == true) {
197
+ _callsign = reader.Text();
198
+ }
199
+
200
+ Core::hresult result = implementation->Persist(static_cast<const Core::OptionalType<string>&>(_callsign));
201
+
202
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
203
+ writer.Number<Core::hresult>(result);
204
+ },
205
+
206
+ // (1) virtual Core::hresult Restore(const Core::OptionalType<string>&) = 0
207
+ //
208
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
209
+ Controller::IConfiguration* implementation = reinterpret_cast<Controller::IConfiguration*>(message->Parameters().Implementation());
210
+ ASSERT(implementation != nullptr);
211
+
212
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
213
+ Core::OptionalType<string> _callsign{};
214
+ if (reader.Boolean() == true) {
215
+ _callsign = reader.Text();
216
+ }
217
+
218
+ Core::hresult result = implementation->Restore(static_cast<const Core::OptionalType<string>&>(_callsign));
194
219
 
195
220
  RPC::Data::Frame::Writer writer(message->Response().Writer());
196
221
  writer.Number<Core::hresult>(result);
197
222
  },
198
223
 
199
- // (1) virtual Core::hresult Configuration(const Core::OptionalType<string>&, string&) const = 0
224
+ // (2) virtual Core::hresult Configuration(const Core::OptionalType<string>&, string&) const = 0
200
225
  //
201
226
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
202
227
  const Controller::IConfiguration* implementation = reinterpret_cast<const Controller::IConfiguration*>(message->Parameters().Implementation());
203
228
  ASSERT(implementation != nullptr);
204
229
 
@@ -215,11 +240,11 @@ namespace ProxyStubs {
215
240
  RPC::Data::Frame::Writer writer(message->Response().Writer());
216
241
  writer.Number<Core::hresult>(result);
217
242
  writer.Text(_configuration);
218
243
  },
219
244
 
220
- // (2) virtual Core::hresult Configuration(const string&, const string&) = 0
245
+ // (3) virtual Core::hresult Configuration(const string&, const string&) = 0
221
246
  //
222
247
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
223
248
  Controller::IConfiguration* implementation = reinterpret_cast<Controller::IConfiguration*>(message->Parameters().Implementation());
224
249
  ASSERT(implementation != nullptr);
225
250
 
@@ -1006,26 +1031,33 @@ namespace ProxyStubs {
1006
1031
 
1007
1032
  //
1008
1033
  // Controller::IConfiguration interface proxy definitions
1009
1034
  //
1010
1035
  // Methods:
1011
- // (0) virtual Core::hresult Persist() = 0
1012
- // (1) virtual Core::hresult Configuration(const Core::OptionalType<string>&, string&) const = 0
1013
- // (2) virtual Core::hresult Configuration(const string&, const string&) = 0
1036
+ // (0) virtual Core::hresult Persist(const Core::OptionalType<string>&) = 0
1037
+ // (1) virtual Core::hresult Restore(const Core::OptionalType<string>&) = 0
1038
+ // (2) virtual Core::hresult Configuration(const Core::OptionalType<string>&, string&) const = 0
1039
+ // (3) virtual Core::hresult Configuration(const string&, const string&) = 0
1014
1040
  //
1015
1041
 
1016
1042
  class ControllerConfigurationProxy final : public ProxyStub::UnknownProxyType<Controller::IConfiguration> {
1017
1043
  public:
1018
1044
  ControllerConfigurationProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
1019
1045
  : BaseClass(channel, implementation, otherSideInformed)
1020
1046
  {
1021
1047
  }
1022
1048
 
1023
- Core::hresult Persist() override
1049
+ Core::hresult Persist(const Core::OptionalType<string>& _callsign) override
1024
1050
  {
1025
1051
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
1026
1052
 
1053
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1054
+ writer.Boolean(_callsign.IsSet());
1055
+ if (_callsign.IsSet() == true) {
1056
+ writer.Text(_callsign.Value());
1057
+ }
1058
+
1027
1059
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1028
1060
  if (hresult == Core::ERROR_NONE) {
1029
1061
  RPC::Data::Frame::Reader reader(message->Response().Reader());
1030
1062
  hresult = reader.Number<Core::hresult>();
1031
1063
  } else {
@@ -1033,20 +1065,41 @@ namespace ProxyStubs {
1033
1065
  }
1034
1066
 
1035
1067
  return (hresult);
1036
1068
  }
1037
1069
 
1038
- Core::hresult Configuration(const Core::OptionalType<string>& _callsign, string& _configuration) const override
1070
+ Core::hresult Restore(const Core::OptionalType<string>& _callsign) override
1039
1071
  {
1040
1072
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
1041
1073
 
1042
1074
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1043
1075
  writer.Boolean(_callsign.IsSet());
1044
1076
  if (_callsign.IsSet() == true) {
1045
1077
  writer.Text(_callsign.Value());
1046
1078
  }
1047
1079
 
1080
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1081
+ if (hresult == Core::ERROR_NONE) {
1082
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1083
+ hresult = reader.Number<Core::hresult>();
1084
+ } else {
1085
+ ASSERT((hresult & COM_ERROR) != 0);
1086
+ }
1087
+
1088
+ return (hresult);
1089
+ }
1090
+
1091
+ Core::hresult Configuration(const Core::OptionalType<string>& _callsign, string& _configuration) const override
1092
+ {
1093
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
1094
+
1095
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1096
+ writer.Boolean(_callsign.IsSet());
1097
+ if (_callsign.IsSet() == true) {
1098
+ writer.Text(_callsign.Value());
1099
+ }
1100
+
1048
1101
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1049
1102
  if (hresult == Core::ERROR_NONE) {
1050
1103
  RPC::Data::Frame::Reader reader(message->Response().Reader());
1051
1104
  hresult = reader.Number<Core::hresult>();
1052
1105
  _configuration = reader.Text();
@@ -1057,11 +1110,11 @@ namespace ProxyStubs {
1057
1110
  return (hresult);
1058
1111
  }
1059
1112
 
1060
1113
  Core::hresult Configuration(const string& _callsign, const string& _configuration) override
1061
1114
  {
1062
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
1115
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
1063
1116
 
1064
1117
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1065
1118
  writer.Text(_callsign);
1066
1119
  writer.Text(_configuration);
1067
1120
 
{baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Release/Thunder/Source/plugins/generated/ProxyStubs_Controller.cpp RENAMED
@@ -304,17 +304,18 @@ namespace ProxyStubs {
304
304
 
305
305
  //
306
306
  // Controller::IConfiguration interface stub definitions
307
307
  //
308
308
  // Methods:
309
- // (0) virtual Core::hresult Persist() = 0
310
- // (1) virtual Core::hresult Configuration(const Core::OptionalType<string>&, string&) const = 0
311
- // (2) virtual Core::hresult Configuration(const string&, const string&) = 0
309
+ // (0) virtual Core::hresult Persist(const Core::OptionalType<string>&) = 0
310
+ // (1) virtual Core::hresult Restore(const Core::OptionalType<string>&) = 0
311
+ // (2) virtual Core::hresult Configuration(const Core::OptionalType<string>&, string&) const = 0
312
+ // (3) virtual Core::hresult Configuration(const string&, const string&) = 0
312
313
  //
313
314
 
314
315
  static ProxyStub::MethodHandler ControllerConfigurationStubMethods[] = {
315
- // (0) virtual Core::hresult Persist() = 0
316
+ // (0) virtual Core::hresult Persist(const Core::OptionalType<string>&) = 0
316
317
  //
317
318
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
318
319
  Core::hresult hresult = Core::ERROR_NONE;
319
320
 
320
321
  hresult = [&]() -> Core::hresult {
@@ -322,11 +323,21 @@ namespace ProxyStubs {
322
323
 
323
324
  Controller::IConfiguration* implementation = reinterpret_cast<Controller::IConfiguration*>(message->Parameters().Implementation());
324
325
  ASSERT(implementation != nullptr);
325
326
  if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), Controller::IConfiguration::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
326
327
 
327
- Core::hresult result = implementation->Persist();
328
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
329
+ Core::OptionalType<string> _callsign{};
330
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
331
+ if (reader.Boolean() == true) {
332
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
333
+ const uint16_t _callsignPeekedLen__ = reader.PeekNumber<uint16_t>();
334
+ if (reader.Length() < (static_cast<uint32_t>(1) + _callsignPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
335
+ _callsign = reader.Text();
336
+ }
337
+
338
+ Core::hresult result = implementation->Persist(static_cast<const Core::OptionalType<string>&>(_callsign));
328
339
 
329
340
  RPC::Data::Frame::Writer writer(message->Response().Writer());
330
341
  writer.Number<Core::hresult>(result);
331
342
 
332
343
  return (Core::ERROR_NONE);
@@ -337,11 +348,48 @@ namespace ProxyStubs {
337
348
  writer.Number<uint32_t>(hresult);
338
349
  fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Controller::IConfiguration::ID, 0, hresult);
339
350
  }
340
351
  },
341
352
 
342
- // (1) virtual Core::hresult Configuration(const Core::OptionalType<string>&, string&) const = 0
353
+ // (1) virtual Core::hresult Restore(const Core::OptionalType<string>&) = 0
354
+ //
355
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
356
+ Core::hresult hresult = Core::ERROR_NONE;
357
+
358
+ hresult = [&]() -> Core::hresult {
359
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
360
+
361
+ Controller::IConfiguration* implementation = reinterpret_cast<Controller::IConfiguration*>(message->Parameters().Implementation());
362
+ ASSERT(implementation != nullptr);
363
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), Controller::IConfiguration::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
364
+
365
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
366
+ Core::OptionalType<string> _callsign{};
367
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
368
+ if (reader.Boolean() == true) {
369
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
370
+ const uint16_t _callsignPeekedLen__ = reader.PeekNumber<uint16_t>();
371
+ if (reader.Length() < (static_cast<uint32_t>(1) + _callsignPeekedLen__)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
372
+ _callsign = reader.Text();
373
+ }
374
+
375
+ Core::hresult result = implementation->Restore(static_cast<const Core::OptionalType<string>&>(_callsign));
376
+
377
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
378
+ writer.Number<Core::hresult>(result);
379
+
380
+ return (Core::ERROR_NONE);
381
+ } ();
382
+
383
+ if (hresult != Core::ERROR_NONE) {
384
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
385
+ writer.Number<uint32_t>(hresult);
386
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Controller::IConfiguration::ID, 1, hresult);
387
+ }
388
+ },
389
+
390
+ // (2) virtual Core::hresult Configuration(const Core::OptionalType<string>&, string&) const = 0
343
391
  //
344
392
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
345
393
  Core::hresult hresult = Core::ERROR_NONE;
346
394
 
347
395
  hresult = [&]() -> Core::hresult {
@@ -373,15 +421,15 @@ namespace ProxyStubs {
373
421
  } ();
374
422
 
375
423
  if (hresult != Core::ERROR_NONE) {
376
424
  RPC::Data::Frame::Writer writer(message->Response().Writer());
377
425
  writer.Number<uint32_t>(hresult);
378
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Controller::IConfiguration::ID, 1, hresult);
426
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Controller::IConfiguration::ID, 2, hresult);
379
427
  }
380
428
  },
381
429
 
382
- // (2) virtual Core::hresult Configuration(const string&, const string&) = 0
430
+ // (3) virtual Core::hresult Configuration(const string&, const string&) = 0
383
431
  //
384
432
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
385
433
  Core::hresult hresult = Core::ERROR_NONE;
386
434
 
387
435
  hresult = [&]() -> Core::hresult {
@@ -410,11 +458,11 @@ namespace ProxyStubs {
410
458
  } ();
411
459
 
412
460
  if (hresult != Core::ERROR_NONE) {
413
461
  RPC::Data::Frame::Writer writer(message->Response().Writer());
414
462
  writer.Number<uint32_t>(hresult);
415
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Controller::IConfiguration::ID, 2, hresult);
463
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Controller::IConfiguration::ID, 3, hresult);
416
464
  }
417
465
  }
418
466
  , nullptr
419
467
  }; // ControllerConfigurationStubMethods
420
468
 
@@ -1709,26 +1757,33 @@ namespace ProxyStubs {
1709
1757
 
1710
1758
  //
1711
1759
  // Controller::IConfiguration interface proxy definitions
1712
1760
  //
1713
1761
  // Methods:
1714
- // (0) virtual Core::hresult Persist() = 0
1715
- // (1) virtual Core::hresult Configuration(const Core::OptionalType<string>&, string&) const = 0
1716
- // (2) virtual Core::hresult Configuration(const string&, const string&) = 0
1762
+ // (0) virtual Core::hresult Persist(const Core::OptionalType<string>&) = 0
1763
+ // (1) virtual Core::hresult Restore(const Core::OptionalType<string>&) = 0
1764
+ // (2) virtual Core::hresult Configuration(const Core::OptionalType<string>&, string&) const = 0
1765
+ // (3) virtual Core::hresult Configuration(const string&, const string&) = 0
1717
1766
  //
1718
1767
 
1719
1768
  class ControllerConfigurationProxy final : public ProxyStub::UnknownProxyType<Controller::IConfiguration> {
1720
1769
  public:
1721
1770
  ControllerConfigurationProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
1722
1771
  : BaseClass(channel, implementation, otherSideInformed)
1723
1772
  {
1724
1773
  }
1725
1774
 
1726
- Core::hresult Persist() override
1775
+ Core::hresult Persist(const Core::OptionalType<string>& _callsign) override
1727
1776
  {
1728
1777
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
1729
1778
 
1779
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1780
+ writer.Boolean(_callsign.IsSet());
1781
+ if (_callsign.IsSet() == true) {
1782
+ writer.Text(_callsign.Value());
1783
+ }
1784
+
1730
1785
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1731
1786
  if (hresult == Core::ERROR_NONE) {
1732
1787
  hresult = [&]() -> Core::hresult {
1733
1788
  RPC::Data::Frame::Reader reader(message->Response().Reader());
1734
1789
  if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
@@ -1745,20 +1800,50 @@ namespace ProxyStubs {
1745
1800
  }
1746
1801
 
1747
1802
  return (hresult);
1748
1803
  }
1749
1804
 
1750
- Core::hresult Configuration(const Core::OptionalType<string>& _callsign, string& _configuration) const override
1805
+ Core::hresult Restore(const Core::OptionalType<string>& _callsign) override
1751
1806
  {
1752
1807
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
1753
1808
 
1754
1809
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1755
1810
  writer.Boolean(_callsign.IsSet());
1756
1811
  if (_callsign.IsSet() == true) {
1757
1812
  writer.Text(_callsign.Value());
1758
1813
  }
1759
1814
 
1815
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1816
+ if (hresult == Core::ERROR_NONE) {
1817
+ hresult = [&]() -> Core::hresult {
1818
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1819
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1820
+ hresult = reader.Number<Core::hresult>();
1821
+
1822
+ return (hresult);
1823
+ } ();
1824
+ } else {
1825
+ ASSERT((hresult & COM_ERROR) != 0);
1826
+ }
1827
+
1828
+ if ((hresult & COM_ERROR) != 0) {
1829
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", Controller::IConfiguration::ID, 1, hresult);
1830
+ }
1831
+
1832
+ return (hresult);
1833
+ }
1834
+
1835
+ Core::hresult Configuration(const Core::OptionalType<string>& _callsign, string& _configuration) const override
1836
+ {
1837
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
1838
+
1839
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1840
+ writer.Boolean(_callsign.IsSet());
1841
+ if (_callsign.IsSet() == true) {
1842
+ writer.Text(_callsign.Value());
1843
+ }
1844
+
1760
1845
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1761
1846
  if (hresult == Core::ERROR_NONE) {
1762
1847
  hresult = [&]() -> Core::hresult {
1763
1848
  RPC::Data::Frame::Reader reader(message->Response().Reader());
1764
1849
  if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
@@ -1775,19 +1860,19 @@ namespace ProxyStubs {
1775
1860
  } else {
1776
1861
  ASSERT((hresult & COM_ERROR) != 0);
1777
1862
  }
1778
1863
 
1779
1864
  if ((hresult & COM_ERROR) != 0) {
1780
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", Controller::IConfiguration::ID, 1, hresult);
1865
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", Controller::IConfiguration::ID, 2, hresult);
1781
1866
  }
1782
1867
 
1783
1868
  return (hresult);
1784
1869
  }
1785
1870
 
1786
1871
  Core::hresult Configuration(const string& _callsign, const string& _configuration) override
1787
1872
  {
1788
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
1873
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(3));
1789
1874
 
1790
1875
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1791
1876
  writer.Text(_callsign);
1792
1877
  writer.Text(_configuration);
1793
1878
 
@@ -1803,11 +1888,11 @@ namespace ProxyStubs {
1803
1888
  } else {
1804
1889
  ASSERT((hresult & COM_ERROR) != 0);
1805
1890
  }
1806
1891
 
1807
1892
  if ((hresult & COM_ERROR) != 0) {
1808
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", Controller::IConfiguration::ID, 2, hresult);
1893
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", Controller::IConfiguration::ID, 3, hresult);
1809
1894
  }
1810
1895
 
1811
1896
  return (hresult);
1812
1897
  }
1813
1898