Diff to HTML by rtfpessoa

Files changed (4) hide show
  1. {baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Debug/Thunder/Source/plugins/generated/ProxyStubs_Plugin.cpp +36 -18
  2. {baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Debug/Thunder/Source/plugins/generated/ProxyStubs_Shell.cpp +123 -35
  3. {baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Release/Thunder/Source/plugins/generated/ProxyStubs_Plugin.cpp +45 -24
  4. {baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Release/Thunder/Source/plugins/generated/ProxyStubs_Shell.cpp +203 -51
{baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Debug/Thunder/Source/plugins/generated/ProxyStubs_Plugin.cpp RENAMED
@@ -103,17 +103,17 @@ namespace ProxyStubs {
103
103
 
104
104
  //
105
105
  // IPlugin::INotification interface stub definitions
106
106
  //
107
107
  // Methods:
108
- // (0) virtual void Activated(const string&, IShell*) = 0
109
- // (1) virtual void Deactivated(const string&, IShell*) = 0
110
- // (2) virtual void Unavailable(const string&, IShell*) = 0
108
+ // (0) virtual Core::hresult CancelableActivated(const string&, IShell*)
109
+ // (1) virtual Core::hresult CancelableDeactivated(const string&, IShell*)
110
+ // (2) virtual Core::hresult CancelableUnavailable(const string&, IShell*)
111
111
  //
112
112
 
113
113
  static ProxyStub::MethodHandler PluginNotificationStubMethods[] = {
114
- // (0) virtual void Activated(const string&, IShell*) = 0
114
+ // (0) virtual Core::hresult CancelableActivated(const string&, IShell*)
115
115
  //
116
116
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
117
117
  IPlugin::INotification* implementation = reinterpret_cast<IPlugin::INotification*>(message->Parameters().Implementation());
118
118
  ASSERT(implementation != nullptr);
119
119
 
@@ -126,18 +126,21 @@ namespace ProxyStubs {
126
126
  if (_pluginInstanceId__ != 0) {
127
127
  _pluginProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _pluginInstanceId__, false, _plugin);
128
128
  ASSERT((_plugin != nullptr) && (_pluginProxy__ != nullptr));
129
129
  }
130
130
 
131
- implementation->Activated(static_cast<const string&>(_callsign), _plugin);
131
+ Core::hresult result = implementation->CancelableActivated(static_cast<const string&>(_callsign), _plugin);
132
+
133
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
134
+ writer.Number<Core::hresult>(result);
132
135
 
133
136
  if (_pluginProxy__ != nullptr) {
134
137
  RPC::Administrator::Instance().Release(_pluginProxy__, message->Response());
135
138
  }
136
139
  },
137
140
 
138
- // (1) virtual void Deactivated(const string&, IShell*) = 0
141
+ // (1) virtual Core::hresult CancelableDeactivated(const string&, IShell*)
139
142
  //
140
143
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
141
144
  IPlugin::INotification* implementation = reinterpret_cast<IPlugin::INotification*>(message->Parameters().Implementation());
142
145
  ASSERT(implementation != nullptr);
143
146
 
@@ -150,18 +153,21 @@ namespace ProxyStubs {
150
153
  if (_pluginInstanceId__ != 0) {
151
154
  _pluginProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _pluginInstanceId__, false, _plugin);
152
155
  ASSERT((_plugin != nullptr) && (_pluginProxy__ != nullptr));
153
156
  }
154
157
 
155
- implementation->Deactivated(static_cast<const string&>(_callsign), _plugin);
158
+ Core::hresult result = implementation->CancelableDeactivated(static_cast<const string&>(_callsign), _plugin);
159
+
160
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
161
+ writer.Number<Core::hresult>(result);
156
162
 
157
163
  if (_pluginProxy__ != nullptr) {
158
164
  RPC::Administrator::Instance().Release(_pluginProxy__, message->Response());
159
165
  }
160
166
  },
161
167
 
162
- // (2) virtual void Unavailable(const string&, IShell*) = 0
168
+ // (2) virtual Core::hresult CancelableUnavailable(const string&, IShell*)
163
169
  //
164
170
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
165
171
  IPlugin::INotification* implementation = reinterpret_cast<IPlugin::INotification*>(message->Parameters().Implementation());
166
172
  ASSERT(implementation != nullptr);
167
173
 
@@ -174,11 +180,14 @@ namespace ProxyStubs {
174
180
  if (_pluginInstanceId__ != 0) {
175
181
  _pluginProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _pluginInstanceId__, false, _plugin);
176
182
  ASSERT((_plugin != nullptr) && (_pluginProxy__ != nullptr));
177
183
  }
178
184
 
179
- implementation->Unavailable(static_cast<const string&>(_callsign), _plugin);
185
+ Core::hresult result = implementation->CancelableUnavailable(static_cast<const string&>(_callsign), _plugin);
186
+
187
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
188
+ writer.Number<Core::hresult>(result);
180
189
 
181
190
  if (_pluginProxy__ != nullptr) {
182
191
  RPC::Administrator::Instance().Release(_pluginProxy__, message->Response());
183
192
  }
184
193
  }
@@ -561,74 +570,83 @@ namespace ProxyStubs {
561
570
 
562
571
  //
563
572
  // IPlugin::INotification interface proxy definitions
564
573
  //
565
574
  // Methods:
566
- // (0) virtual void Activated(const string&, IShell*) = 0
567
- // (1) virtual void Deactivated(const string&, IShell*) = 0
568
- // (2) virtual void Unavailable(const string&, IShell*) = 0
575
+ // (0) virtual Core::hresult CancelableActivated(const string&, IShell*)
576
+ // (1) virtual Core::hresult CancelableDeactivated(const string&, IShell*)
577
+ // (2) virtual Core::hresult CancelableUnavailable(const string&, IShell*)
569
578
  //
570
579
 
571
580
  class PluginNotificationProxy final : public ProxyStub::UnknownProxyType<IPlugin::INotification> {
572
581
  public:
573
582
  PluginNotificationProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
574
583
  : BaseClass(channel, implementation, otherSideInformed)
575
584
  {
576
585
  }
577
586
 
578
- void Activated(const string& _callsign, IShell* _plugin) override
587
+ Core::hresult CancelableActivated(const string& _callsign, IShell* _plugin) override
579
588
  {
580
589
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
581
590
 
582
591
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
583
592
  writer.Text(_callsign);
584
593
  writer.Number<Core::instance_id>(RPC::instance_cast(_plugin));
585
594
 
586
- const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
595
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
587
596
  if (hresult == Core::ERROR_NONE) {
588
597
  RPC::Data::Frame::Reader reader(message->Response().Reader());
598
+ hresult = reader.Number<Core::hresult>();
589
599
 
590
600
  _Complete(reader);
591
601
  } else {
592
602
  ASSERT((hresult & COM_ERROR) != 0);
593
603
  }
604
+
605
+ return (hresult);
594
606
  }
595
607
 
596
- void Deactivated(const string& _callsign, IShell* _plugin) override
608
+ Core::hresult CancelableDeactivated(const string& _callsign, IShell* _plugin) override
597
609
  {
598
610
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
599
611
 
600
612
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
601
613
  writer.Text(_callsign);
602
614
  writer.Number<Core::instance_id>(RPC::instance_cast(_plugin));
603
615
 
604
- const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
616
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
605
617
  if (hresult == Core::ERROR_NONE) {
606
618
  RPC::Data::Frame::Reader reader(message->Response().Reader());
619
+ hresult = reader.Number<Core::hresult>();
607
620
 
608
621
  _Complete(reader);
609
622
  } else {
610
623
  ASSERT((hresult & COM_ERROR) != 0);
611
624
  }
625
+
626
+ return (hresult);
612
627
  }
613
628
 
614
- void Unavailable(const string& _callsign, IShell* _plugin) override
629
+ Core::hresult CancelableUnavailable(const string& _callsign, IShell* _plugin) override
615
630
  {
616
631
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
617
632
 
618
633
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
619
634
  writer.Text(_callsign);
620
635
  writer.Number<Core::instance_id>(RPC::instance_cast(_plugin));
621
636
 
622
- const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
637
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
623
638
  if (hresult == Core::ERROR_NONE) {
624
639
  RPC::Data::Frame::Reader reader(message->Response().Reader());
640
+ hresult = reader.Number<Core::hresult>();
625
641
 
626
642
  _Complete(reader);
627
643
  } else {
628
644
  ASSERT((hresult & COM_ERROR) != 0);
629
645
  }
646
+
647
+ return (hresult);
630
648
  }
631
649
 
632
650
  private:
633
651
  uint32_t _Complete(RPC::Data::Frame::Reader& reader) const
634
652
  {
{baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Debug/Thunder/Source/plugins/generated/ProxyStubs_Shell.cpp RENAMED
@@ -57,19 +57,21 @@ namespace ProxyStubs {
57
57
  // (25) virtual Core::hresult Metadata(string&) const = 0
58
58
  // (26) virtual ISubSystem* SubSystems() = 0
59
59
  // (27) virtual void Notify(const string&, const string&) = 0
60
60
  // (28) virtual void Register(IPlugin::INotification*, const Core::OptionalType<string>&) = 0
61
61
  // (29) virtual void Unregister(IPlugin::INotification*, const Core::OptionalType<string>&) = 0
62
- // (30) virtual IShell::state State() const = 0
63
- // (31) virtual void* QueryInterfaceByCallsign(const uint32_t, const string&) = 0
64
- // (32) virtual Core::hresult Activate(const IShell::reason) = 0
65
- // (33) virtual Core::hresult Deactivate(const IShell::reason) = 0
66
- // (34) virtual Core::hresult Unavailable(const IShell::reason) = 0
67
- // (35) virtual Core::hresult Hibernate(const uint32_t) = 0
68
- // (36) virtual IShell::reason Reason() const = 0
69
- // (37) virtual uint32_t Submit(const uint32_t, /* undefined type */ const Core::ProxyType<Core::JSON::IElement>&) = 0
70
- // (38) virtual RPC::IStringIterator* GetLibrarySearchPaths(const string&) const = 0
62
+ // (30) virtual void Register(IPlugin::INotification*, const uint32_t) = 0
63
+ // (31) virtual void Unregister(IPlugin::INotification*, const uint32_t) = 0
64
+ // (32) virtual IShell::state State() const = 0
65
+ // (33) virtual void* QueryInterfaceByCallsign(const uint32_t, const string&) = 0
66
+ // (34) virtual Core::hresult Activate(const IShell::reason) = 0
67
+ // (35) virtual Core::hresult Deactivate(const IShell::reason) = 0
68
+ // (36) virtual Core::hresult Unavailable(const IShell::reason) = 0
69
+ // (37) virtual Core::hresult Hibernate(const uint32_t) = 0
70
+ // (38) virtual IShell::reason Reason() const = 0
71
+ // (39) virtual uint32_t Submit(const uint32_t, /* undefined type */ const Core::ProxyType<Core::JSON::IElement>&) = 0
72
+ // (40) virtual RPC::IStringIterator* GetLibrarySearchPaths(const string&) const = 0
71
73
  //
72
74
 
73
75
  static ProxyStub::MethodHandler ShellStubMethods[] = {
74
76
  // (0) virtual void EnableWebServer(const string&, const string&) = 0
75
77
  //
@@ -478,11 +480,59 @@ namespace ProxyStubs {
478
480
  if (_sinkProxy__ != nullptr) {
479
481
  RPC::Administrator::Instance().Release(_sinkProxy__, message->Response());
480
482
  }
481
483
  },
482
484
 
483
- // (30) virtual IShell::state State() const = 0
485
+ // (30) virtual void Register(IPlugin::INotification*, const uint32_t) = 0
486
+ //
487
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
488
+ IShell* implementation = reinterpret_cast<IShell*>(message->Parameters().Implementation());
489
+ ASSERT(implementation != nullptr);
490
+
491
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
492
+ Core::instance_id _sinkInstanceId__ = reader.Number<Core::instance_id>();
493
+ const uint32_t _interface_id = reader.Number<uint32_t>();
494
+
495
+ IPlugin::INotification* _sink{};
496
+ ProxyStub::UnknownProxy* _sinkProxy__ = nullptr;
497
+ if (_sinkInstanceId__ != 0) {
498
+ _sinkProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _sinkInstanceId__, false, _sink);
499
+ ASSERT((_sink != nullptr) && (_sinkProxy__ != nullptr));
500
+ }
501
+
502
+ implementation->Register(_sink, _interface_id);
503
+
504
+ if (_sinkProxy__ != nullptr) {
505
+ RPC::Administrator::Instance().Release(_sinkProxy__, message->Response());
506
+ }
507
+ },
508
+
509
+ // (31) virtual void Unregister(IPlugin::INotification*, const uint32_t) = 0
510
+ //
511
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
512
+ IShell* implementation = reinterpret_cast<IShell*>(message->Parameters().Implementation());
513
+ ASSERT(implementation != nullptr);
514
+
515
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
516
+ Core::instance_id _sinkInstanceId__ = reader.Number<Core::instance_id>();
517
+ const uint32_t _interface_id = reader.Number<uint32_t>();
518
+
519
+ IPlugin::INotification* _sink{};
520
+ ProxyStub::UnknownProxy* _sinkProxy__ = nullptr;
521
+ if (_sinkInstanceId__ != 0) {
522
+ _sinkProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _sinkInstanceId__, false, _sink);
523
+ ASSERT((_sink != nullptr) && (_sinkProxy__ != nullptr));
524
+ }
525
+
526
+ implementation->Unregister(_sink, _interface_id);
527
+
528
+ if (_sinkProxy__ != nullptr) {
529
+ RPC::Administrator::Instance().Release(_sinkProxy__, message->Response());
530
+ }
531
+ },
532
+
533
+ // (32) virtual IShell::state State() const = 0
484
534
  //
485
535
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
486
536
  const IShell* implementation = reinterpret_cast<const IShell*>(message->Parameters().Implementation());
487
537
  ASSERT(implementation != nullptr);
488
538
 
@@ -490,11 +540,11 @@ namespace ProxyStubs {
490
540
 
491
541
  RPC::Data::Frame::Writer writer(message->Response().Writer());
492
542
  writer.Number<IShell::state>(result);
493
543
  },
494
544
 
495
- // (31) virtual void* QueryInterfaceByCallsign(const uint32_t, const string&) = 0
545
+ // (33) virtual void* QueryInterfaceByCallsign(const uint32_t, const string&) = 0
496
546
  //
497
547
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
498
548
  IShell* implementation = reinterpret_cast<IShell*>(message->Parameters().Implementation());
499
549
  ASSERT(implementation != nullptr);
500
550
 
@@ -508,11 +558,11 @@ namespace ProxyStubs {
508
558
  writer.Number<Core::instance_id>(RPC::instance_cast(result));
509
559
 
510
560
  RPC::Administrator::Instance().RegisterInterface(channel, result, _id);
511
561
  },
512
562
 
513
- // (32) virtual Core::hresult Activate(const IShell::reason) = 0
563
+ // (34) virtual Core::hresult Activate(const IShell::reason) = 0
514
564
  //
515
565
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
516
566
  IShell* implementation = reinterpret_cast<IShell*>(message->Parameters().Implementation());
517
567
  ASSERT(implementation != nullptr);
518
568
 
@@ -523,11 +573,11 @@ namespace ProxyStubs {
523
573
 
524
574
  RPC::Data::Frame::Writer writer(message->Response().Writer());
525
575
  writer.Number<Core::hresult>(result);
526
576
  },
527
577
 
528
- // (33) virtual Core::hresult Deactivate(const IShell::reason) = 0
578
+ // (35) virtual Core::hresult Deactivate(const IShell::reason) = 0
529
579
  //
530
580
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
531
581
  IShell* implementation = reinterpret_cast<IShell*>(message->Parameters().Implementation());
532
582
  ASSERT(implementation != nullptr);
533
583
 
@@ -538,11 +588,11 @@ namespace ProxyStubs {
538
588
 
539
589
  RPC::Data::Frame::Writer writer(message->Response().Writer());
540
590
  writer.Number<Core::hresult>(result);
541
591
  },
542
592
 
543
- // (34) virtual Core::hresult Unavailable(const IShell::reason) = 0
593
+ // (36) virtual Core::hresult Unavailable(const IShell::reason) = 0
544
594
  //
545
595
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
546
596
  IShell* implementation = reinterpret_cast<IShell*>(message->Parameters().Implementation());
547
597
  ASSERT(implementation != nullptr);
548
598
 
@@ -553,11 +603,11 @@ namespace ProxyStubs {
553
603
 
554
604
  RPC::Data::Frame::Writer writer(message->Response().Writer());
555
605
  writer.Number<Core::hresult>(result);
556
606
  },
557
607
 
558
- // (35) virtual Core::hresult Hibernate(const uint32_t) = 0
608
+ // (37) virtual Core::hresult Hibernate(const uint32_t) = 0
559
609
  //
560
610
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
561
611
  IShell* implementation = reinterpret_cast<IShell*>(message->Parameters().Implementation());
562
612
  ASSERT(implementation != nullptr);
563
613
 
@@ -568,11 +618,11 @@ namespace ProxyStubs {
568
618
 
569
619
  RPC::Data::Frame::Writer writer(message->Response().Writer());
570
620
  writer.Number<Core::hresult>(result);
571
621
  },
572
622
 
573
- // (36) virtual IShell::reason Reason() const = 0
623
+ // (38) virtual IShell::reason Reason() const = 0
574
624
  //
575
625
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
576
626
  const IShell* implementation = reinterpret_cast<const IShell*>(message->Parameters().Implementation());
577
627
  ASSERT(implementation != nullptr);
578
628
 
@@ -580,17 +630,17 @@ namespace ProxyStubs {
580
630
 
581
631
  RPC::Data::Frame::Writer writer(message->Response().Writer());
582
632
  writer.Number<IShell::reason>(result);
583
633
  },
584
634
 
585
- // (37) virtual uint32_t Submit(const uint32_t, /* undefined type */ const Core::ProxyType<Core::JSON::IElement>&) = 0
635
+ // (39) virtual uint32_t Submit(const uint32_t, /* undefined type */ const Core::ProxyType<Core::JSON::IElement>&) = 0
586
636
  //
587
637
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& /* message */) {
588
638
  // stubbed method, no implementation
589
639
  },
590
640
 
591
- // (38) virtual RPC::IStringIterator* GetLibrarySearchPaths(const string&) const = 0
641
+ // (40) virtual RPC::IStringIterator* GetLibrarySearchPaths(const string&) const = 0
592
642
  //
593
643
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
594
644
  const IShell* implementation = reinterpret_cast<const IShell*>(message->Parameters().Implementation());
595
645
  ASSERT(implementation != nullptr);
596
646
 
@@ -735,19 +785,21 @@ namespace ProxyStubs {
735
785
  // (25) virtual Core::hresult Metadata(string&) const = 0
736
786
  // (26) virtual ISubSystem* SubSystems() = 0
737
787
  // (27) virtual void Notify(const string&, const string&) = 0
738
788
  // (28) virtual void Register(IPlugin::INotification*, const Core::OptionalType<string>&) = 0
739
789
  // (29) virtual void Unregister(IPlugin::INotification*, const Core::OptionalType<string>&) = 0
740
- // (30) virtual IShell::state State() const = 0
741
- // (31) virtual void* QueryInterfaceByCallsign(const uint32_t, const string&) = 0
742
- // (32) virtual Core::hresult Activate(const IShell::reason) = 0
743
- // (33) virtual Core::hresult Deactivate(const IShell::reason) = 0
744
- // (34) virtual Core::hresult Unavailable(const IShell::reason) = 0
745
- // (35) virtual Core::hresult Hibernate(const uint32_t) = 0
746
- // (36) virtual IShell::reason Reason() const = 0
747
- // (37) virtual uint32_t Submit(const uint32_t, /* undefined type */ const Core::ProxyType<Core::JSON::IElement>&) = 0
748
- // (38) virtual RPC::IStringIterator* GetLibrarySearchPaths(const string&) const = 0
790
+ // (30) virtual void Register(IPlugin::INotification*, const uint32_t) = 0
791
+ // (31) virtual void Unregister(IPlugin::INotification*, const uint32_t) = 0
792
+ // (32) virtual IShell::state State() const = 0
793
+ // (33) virtual void* QueryInterfaceByCallsign(const uint32_t, const string&) = 0
794
+ // (34) virtual Core::hresult Activate(const IShell::reason) = 0
795
+ // (35) virtual Core::hresult Deactivate(const IShell::reason) = 0
796
+ // (36) virtual Core::hresult Unavailable(const IShell::reason) = 0
797
+ // (37) virtual Core::hresult Hibernate(const uint32_t) = 0
798
+ // (38) virtual IShell::reason Reason() const = 0
799
+ // (39) virtual uint32_t Submit(const uint32_t, /* undefined type */ const Core::ProxyType<Core::JSON::IElement>&) = 0
800
+ // (40) virtual RPC::IStringIterator* GetLibrarySearchPaths(const string&) const = 0
749
801
  //
750
802
 
751
803
  class ShellProxy final : public ProxyStub::UnknownProxyType<IShell> {
752
804
  public:
753
805
  ShellProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
@@ -1255,14 +1307,50 @@ namespace ProxyStubs {
1255
1307
  } else {
1256
1308
  ASSERT((hresult & COM_ERROR) != 0);
1257
1309
  }
1258
1310
  }
1259
1311
 
1260
- IShell::state State() const override
1312
+ void Register(IPlugin::INotification* _sink, const uint32_t _interface_id) override
1261
1313
  {
1262
1314
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(30));
1263
1315
 
1316
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1317
+ writer.Number<Core::instance_id>(RPC::instance_cast(_sink));
1318
+ writer.Number<uint32_t>(_interface_id);
1319
+
1320
+ const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1321
+ if (hresult == Core::ERROR_NONE) {
1322
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1323
+
1324
+ _Complete(reader);
1325
+ } else {
1326
+ ASSERT((hresult & COM_ERROR) != 0);
1327
+ }
1328
+ }
1329
+
1330
+ void Unregister(IPlugin::INotification* _sink, const uint32_t _interface_id) override
1331
+ {
1332
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(31));
1333
+
1334
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1335
+ writer.Number<Core::instance_id>(RPC::instance_cast(_sink));
1336
+ writer.Number<uint32_t>(_interface_id);
1337
+
1338
+ const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1339
+ if (hresult == Core::ERROR_NONE) {
1340
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
1341
+
1342
+ _Complete(reader);
1343
+ } else {
1344
+ ASSERT((hresult & COM_ERROR) != 0);
1345
+ }
1346
+ }
1347
+
1348
+ IShell::state State() const override
1349
+ {
1350
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(32));
1351
+
1264
1352
  IShell::state result{};
1265
1353
 
1266
1354
  const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1267
1355
  if (hresult == Core::ERROR_NONE) {
1268
1356
  RPC::Data::Frame::Reader reader(message->Response().Reader());
@@ -1274,11 +1362,11 @@ namespace ProxyStubs {
1274
1362
  return (result);
1275
1363
  }
1276
1364
 
1277
1365
  void* QueryInterfaceByCallsign(const uint32_t _id, const string& _name) override
1278
1366
  {
1279
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(31));
1367
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(33));
1280
1368
 
1281
1369
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1282
1370
  writer.Number<uint32_t>(_id);
1283
1371
  writer.Text(_name);
1284
1372
 
@@ -1295,11 +1383,11 @@ namespace ProxyStubs {
1295
1383
  return (result);
1296
1384
  }
1297
1385
 
1298
1386
  Core::hresult Activate(const IShell::reason _parameter_1) override
1299
1387
  {
1300
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(32));
1388
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(34));
1301
1389
 
1302
1390
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1303
1391
  writer.Number<IShell::reason>(_parameter_1);
1304
1392
 
1305
1393
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
@@ -1313,11 +1401,11 @@ namespace ProxyStubs {
1313
1401
  return (hresult);
1314
1402
  }
1315
1403
 
1316
1404
  Core::hresult Deactivate(const IShell::reason _parameter_1) override
1317
1405
  {
1318
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(33));
1406
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(35));
1319
1407
 
1320
1408
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1321
1409
  writer.Number<IShell::reason>(_parameter_1);
1322
1410
 
1323
1411
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
@@ -1331,11 +1419,11 @@ namespace ProxyStubs {
1331
1419
  return (hresult);
1332
1420
  }
1333
1421
 
1334
1422
  Core::hresult Unavailable(const IShell::reason _parameter_1) override
1335
1423
  {
1336
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(34));
1424
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(36));
1337
1425
 
1338
1426
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1339
1427
  writer.Number<IShell::reason>(_parameter_1);
1340
1428
 
1341
1429
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
@@ -1349,11 +1437,11 @@ namespace ProxyStubs {
1349
1437
  return (hresult);
1350
1438
  }
1351
1439
 
1352
1440
  Core::hresult Hibernate(const uint32_t _timeout) override
1353
1441
  {
1354
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(35));
1442
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(37));
1355
1443
 
1356
1444
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1357
1445
  writer.Number<uint32_t>(_timeout);
1358
1446
 
1359
1447
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
@@ -1367,11 +1455,11 @@ namespace ProxyStubs {
1367
1455
  return (hresult);
1368
1456
  }
1369
1457
 
1370
1458
  IShell::reason Reason() const override
1371
1459
  {
1372
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(36));
1460
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(38));
1373
1461
 
1374
1462
  IShell::reason result{};
1375
1463
 
1376
1464
  const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
1377
1465
  if (hresult == Core::ERROR_NONE) {
@@ -1391,11 +1479,11 @@ namespace ProxyStubs {
1391
1479
  return {};
1392
1480
  }
1393
1481
 
1394
1482
  RPC::IStringIterator* GetLibrarySearchPaths(const string& _parameter_1) const override
1395
1483
  {
1396
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(38));
1484
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(40));
1397
1485
 
1398
1486
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
1399
1487
  writer.Text(_parameter_1);
1400
1488
 
1401
1489
  RPC::IStringIterator* result{};
{baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Release/Thunder/Source/plugins/generated/ProxyStubs_Plugin.cpp RENAMED
@@ -154,17 +154,17 @@ namespace ProxyStubs {
154
154
 
155
155
  //
156
156
  // IPlugin::INotification interface stub definitions
157
157
  //
158
158
  // Methods:
159
- // (0) virtual void Activated(const string&, IShell*) = 0
160
- // (1) virtual void Deactivated(const string&, IShell*) = 0
161
- // (2) virtual void Unavailable(const string&, IShell*) = 0
159
+ // (0) virtual Core::hresult CancelableActivated(const string&, IShell*)
160
+ // (1) virtual Core::hresult CancelableDeactivated(const string&, IShell*)
161
+ // (2) virtual Core::hresult CancelableUnavailable(const string&, IShell*)
162
162
  //
163
163
 
164
164
  static ProxyStub::MethodHandler PluginNotificationStubMethods[] = {
165
- // (0) virtual void Activated(const string&, IShell*) = 0
165
+ // (0) virtual Core::hresult CancelableActivated(const string&, IShell*)
166
166
  //
167
167
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
168
168
  Core::hresult hresult = Core::ERROR_NONE;
169
169
 
170
170
  hresult = [&]() -> Core::hresult {
@@ -188,26 +188,30 @@ namespace ProxyStubs {
188
188
  _pluginProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _pluginInstanceId__, false, _plugin);
189
189
  ASSERT((_plugin != nullptr) && (_pluginProxy__ != nullptr));
190
190
  if ((_plugin == nullptr) || (_pluginProxy__ == nullptr)) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
191
191
  }
192
192
 
193
- implementation->Activated(static_cast<const string&>(_callsign), _plugin);
193
+ Core::hresult result = implementation->CancelableActivated(static_cast<const string&>(_callsign), _plugin);
194
+
195
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
196
+ writer.Number<Core::hresult>(result);
194
197
 
195
198
  if (_pluginProxy__ != nullptr) {
196
199
  RPC::Administrator::Instance().Release(_pluginProxy__, message->Response());
197
200
  }
198
201
 
199
202
  return (Core::ERROR_NONE);
200
203
  } ();
201
204
 
202
205
  if (hresult != Core::ERROR_NONE) {
206
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
207
+ writer.Number<uint32_t>(hresult);
203
208
  fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IPlugin::INotification::ID, 0, hresult);
204
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
205
209
  }
206
210
  },
207
211
 
208
- // (1) virtual void Deactivated(const string&, IShell*) = 0
212
+ // (1) virtual Core::hresult CancelableDeactivated(const string&, IShell*)
209
213
  //
210
214
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
211
215
  Core::hresult hresult = Core::ERROR_NONE;
212
216
 
213
217
  hresult = [&]() -> Core::hresult {
@@ -231,26 +235,30 @@ namespace ProxyStubs {
231
235
  _pluginProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _pluginInstanceId__, false, _plugin);
232
236
  ASSERT((_plugin != nullptr) && (_pluginProxy__ != nullptr));
233
237
  if ((_plugin == nullptr) || (_pluginProxy__ == nullptr)) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
234
238
  }
235
239
 
236
- implementation->Deactivated(static_cast<const string&>(_callsign), _plugin);
240
+ Core::hresult result = implementation->CancelableDeactivated(static_cast<const string&>(_callsign), _plugin);
241
+
242
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
243
+ writer.Number<Core::hresult>(result);
237
244
 
238
245
  if (_pluginProxy__ != nullptr) {
239
246
  RPC::Administrator::Instance().Release(_pluginProxy__, message->Response());
240
247
  }
241
248
 
242
249
  return (Core::ERROR_NONE);
243
250
  } ();
244
251
 
245
252
  if (hresult != Core::ERROR_NONE) {
253
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
254
+ writer.Number<uint32_t>(hresult);
246
255
  fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IPlugin::INotification::ID, 1, hresult);
247
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
248
256
  }
249
257
  },
250
258
 
251
- // (2) virtual void Unavailable(const string&, IShell*) = 0
259
+ // (2) virtual Core::hresult CancelableUnavailable(const string&, IShell*)
252
260
  //
253
261
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
254
262
  Core::hresult hresult = Core::ERROR_NONE;
255
263
 
256
264
  hresult = [&]() -> Core::hresult {
@@ -274,22 +282,26 @@ namespace ProxyStubs {
274
282
  _pluginProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _pluginInstanceId__, false, _plugin);
275
283
  ASSERT((_plugin != nullptr) && (_pluginProxy__ != nullptr));
276
284
  if ((_plugin == nullptr) || (_pluginProxy__ == nullptr)) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
277
285
  }
278
286
 
279
- implementation->Unavailable(static_cast<const string&>(_callsign), _plugin);
287
+ Core::hresult result = implementation->CancelableUnavailable(static_cast<const string&>(_callsign), _plugin);
288
+
289
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
290
+ writer.Number<Core::hresult>(result);
280
291
 
281
292
  if (_pluginProxy__ != nullptr) {
282
293
  RPC::Administrator::Instance().Release(_pluginProxy__, message->Response());
283
294
  }
284
295
 
285
296
  return (Core::ERROR_NONE);
286
297
  } ();
287
298
 
288
299
  if (hresult != Core::ERROR_NONE) {
300
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
301
+ writer.Number<uint32_t>(hresult);
289
302
  fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IPlugin::INotification::ID, 2, hresult);
290
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
291
303
  }
292
304
  }
293
305
  , nullptr
294
306
  }; // PluginNotificationStubMethods
295
307
 
@@ -903,23 +915,23 @@ namespace ProxyStubs {
903
915
 
904
916
  //
905
917
  // IPlugin::INotification interface proxy definitions
906
918
  //
907
919
  // Methods:
908
- // (0) virtual void Activated(const string&, IShell*) = 0
909
- // (1) virtual void Deactivated(const string&, IShell*) = 0
910
- // (2) virtual void Unavailable(const string&, IShell*) = 0
920
+ // (0) virtual Core::hresult CancelableActivated(const string&, IShell*)
921
+ // (1) virtual Core::hresult CancelableDeactivated(const string&, IShell*)
922
+ // (2) virtual Core::hresult CancelableUnavailable(const string&, IShell*)
911
923
  //
912
924
 
913
925
  class PluginNotificationProxy final : public ProxyStub::UnknownProxyType<IPlugin::INotification> {
914
926
  public:
915
927
  PluginNotificationProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
916
928
  : BaseClass(channel, implementation, otherSideInformed)
917
929
  {
918
930
  }
919
931
 
920
- void Activated(const string& _callsign, IShell* _plugin) override
932
+ Core::hresult CancelableActivated(const string& _callsign, IShell* _plugin) override
921
933
  {
922
934
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
923
935
 
924
936
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
925
937
  writer.Text(_callsign);
@@ -930,29 +942,32 @@ namespace ProxyStubs {
930
942
 
931
943
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
932
944
  if (hresult == Core::ERROR_NONE) {
933
945
  hresult = [&]() -> Core::hresult {
934
946
  RPC::Data::Frame::Reader reader(message->Response().Reader());
947
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
948
+ hresult = reader.Number<Core::hresult>();
935
949
 
936
950
  const uint32_t completeResult__ = _Complete(reader);
937
951
  if (completeResult__ != Core::ERROR_NONE) { return (completeResult__); }
938
952
 
939
- return (Core::ERROR_NONE);
953
+ return (hresult);
940
954
  } ();
941
955
  } else {
942
956
  ASSERT((hresult & COM_ERROR) != 0);
943
957
  }
944
958
 
945
959
  if ((hresult & COM_ERROR) != 0) {
946
960
  fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IPlugin::INotification::ID, 0, hresult);
947
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
948
961
  }
949
962
 
950
963
  static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(nullptr);
964
+
965
+ return (hresult);
951
966
  }
952
967
 
953
- void Deactivated(const string& _callsign, IShell* _plugin) override
968
+ Core::hresult CancelableDeactivated(const string& _callsign, IShell* _plugin) override
954
969
  {
955
970
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(1));
956
971
 
957
972
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
958
973
  writer.Text(_callsign);
@@ -963,29 +978,32 @@ namespace ProxyStubs {
963
978
 
964
979
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
965
980
  if (hresult == Core::ERROR_NONE) {
966
981
  hresult = [&]() -> Core::hresult {
967
982
  RPC::Data::Frame::Reader reader(message->Response().Reader());
983
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
984
+ hresult = reader.Number<Core::hresult>();
968
985
 
969
986
  const uint32_t completeResult__ = _Complete(reader);
970
987
  if (completeResult__ != Core::ERROR_NONE) { return (completeResult__); }
971
988
 
972
- return (Core::ERROR_NONE);
989
+ return (hresult);
973
990
  } ();
974
991
  } else {
975
992
  ASSERT((hresult & COM_ERROR) != 0);
976
993
  }
977
994
 
978
995
  if ((hresult & COM_ERROR) != 0) {
979
996
  fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IPlugin::INotification::ID, 1, hresult);
980
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
981
997
  }
982
998
 
983
999
  static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(nullptr);
1000
+
1001
+ return (hresult);
984
1002
  }
985
1003
 
986
- void Unavailable(const string& _callsign, IShell* _plugin) override
1004
+ Core::hresult CancelableUnavailable(const string& _callsign, IShell* _plugin) override
987
1005
  {
988
1006
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(2));
989
1007
 
990
1008
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
991
1009
  writer.Text(_callsign);
@@ -996,26 +1014,29 @@ namespace ProxyStubs {
996
1014
 
997
1015
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
998
1016
  if (hresult == Core::ERROR_NONE) {
999
1017
  hresult = [&]() -> Core::hresult {
1000
1018
  RPC::Data::Frame::Reader reader(message->Response().Reader());
1019
+ if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1020
+ hresult = reader.Number<Core::hresult>();
1001
1021
 
1002
1022
  const uint32_t completeResult__ = _Complete(reader);
1003
1023
  if (completeResult__ != Core::ERROR_NONE) { return (completeResult__); }
1004
1024
 
1005
- return (Core::ERROR_NONE);
1025
+ return (hresult);
1006
1026
  } ();
1007
1027
  } else {
1008
1028
  ASSERT((hresult & COM_ERROR) != 0);
1009
1029
  }
1010
1030
 
1011
1031
  if ((hresult & COM_ERROR) != 0) {
1012
1032
  fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IPlugin::INotification::ID, 2, hresult);
1013
- TRACE_L1("Warning: This COM-RPC failure will not propagate!");
1014
1033
  }
1015
1034
 
1016
1035
  static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(nullptr);
1036
+
1037
+ return (hresult);
1017
1038
  }
1018
1039
 
1019
1040
  private:
1020
1041
  uint32_t _Complete(RPC::Data::Frame::Reader& reader) const
1021
1042
  {
{baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Release/Thunder/Source/plugins/generated/ProxyStubs_Shell.cpp RENAMED
@@ -62,19 +62,21 @@ namespace ProxyStubs {
62
62
  // (25) virtual Core::hresult Metadata(string&) const = 0
63
63
  // (26) virtual ISubSystem* SubSystems() = 0
64
64
  // (27) virtual void Notify(const string&, const string&) = 0
65
65
  // (28) virtual void Register(IPlugin::INotification*, const Core::OptionalType<string>&) = 0
66
66
  // (29) virtual void Unregister(IPlugin::INotification*, const Core::OptionalType<string>&) = 0
67
- // (30) virtual IShell::state State() const = 0
68
- // (31) virtual void* QueryInterfaceByCallsign(const uint32_t, const string&) = 0
69
- // (32) virtual Core::hresult Activate(const IShell::reason) = 0
70
- // (33) virtual Core::hresult Deactivate(const IShell::reason) = 0
71
- // (34) virtual Core::hresult Unavailable(const IShell::reason) = 0
72
- // (35) virtual Core::hresult Hibernate(const uint32_t) = 0
73
- // (36) virtual IShell::reason Reason() const = 0
74
- // (37) virtual uint32_t Submit(const uint32_t, /* undefined type */ const Core::ProxyType<Core::JSON::IElement>&) = 0
75
- // (38) virtual RPC::IStringIterator* GetLibrarySearchPaths(const string&) const = 0
67
+ // (30) virtual void Register(IPlugin::INotification*, const uint32_t) = 0
68
+ // (31) virtual void Unregister(IPlugin::INotification*, const uint32_t) = 0
69
+ // (32) virtual IShell::state State() const = 0
70
+ // (33) virtual void* QueryInterfaceByCallsign(const uint32_t, const string&) = 0
71
+ // (34) virtual Core::hresult Activate(const IShell::reason) = 0
72
+ // (35) virtual Core::hresult Deactivate(const IShell::reason) = 0
73
+ // (36) virtual Core::hresult Unavailable(const IShell::reason) = 0
74
+ // (37) virtual Core::hresult Hibernate(const uint32_t) = 0
75
+ // (38) virtual IShell::reason Reason() const = 0
76
+ // (39) virtual uint32_t Submit(const uint32_t, /* undefined type */ const Core::ProxyType<Core::JSON::IElement>&) = 0
77
+ // (40) virtual RPC::IStringIterator* GetLibrarySearchPaths(const string&) const = 0
76
78
  //
77
79
 
78
80
  static ProxyStub::MethodHandler ShellStubMethods[] = {
79
81
  // (0) virtual void EnableWebServer(const string&, const string&) = 0
80
82
  //
@@ -943,11 +945,93 @@ namespace ProxyStubs {
943
945
  fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 29, hresult);
944
946
  TRACE_L1("Warning: This COM-RPC failure will not propagate!");
945
947
  }
946
948
  },
947
949
 
948
- // (30) virtual IShell::state State() const = 0
950
+ // (30) virtual void Register(IPlugin::INotification*, const uint32_t) = 0
951
+ //
952
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
953
+ Core::hresult hresult = Core::ERROR_NONE;
954
+
955
+ hresult = [&]() -> Core::hresult {
956
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
957
+
958
+ IShell* implementation = reinterpret_cast<IShell*>(message->Parameters().Implementation());
959
+ ASSERT(implementation != nullptr);
960
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), IShell::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
961
+
962
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
963
+ if (reader.Length() < (sizeof(Core::instance_id))) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
964
+ Core::instance_id _sinkInstanceId__ = reader.Number<Core::instance_id>();
965
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
966
+ const uint32_t _interface_id = reader.Number<uint32_t>();
967
+
968
+ IPlugin::INotification* _sink{};
969
+ ProxyStub::UnknownProxy* _sinkProxy__ = nullptr;
970
+ if (_sinkInstanceId__ != 0) {
971
+ _sinkProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _sinkInstanceId__, false, _sink);
972
+ ASSERT((_sink != nullptr) && (_sinkProxy__ != nullptr));
973
+ if ((_sink == nullptr) || (_sinkProxy__ == nullptr)) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
974
+ }
975
+
976
+ implementation->Register(_sink, _interface_id);
977
+
978
+ if (_sinkProxy__ != nullptr) {
979
+ RPC::Administrator::Instance().Release(_sinkProxy__, message->Response());
980
+ }
981
+
982
+ return (Core::ERROR_NONE);
983
+ } ();
984
+
985
+ if (hresult != Core::ERROR_NONE) {
986
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 30, hresult);
987
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
988
+ }
989
+ },
990
+
991
+ // (31) virtual void Unregister(IPlugin::INotification*, const uint32_t) = 0
992
+ //
993
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
994
+ Core::hresult hresult = Core::ERROR_NONE;
995
+
996
+ hresult = [&]() -> Core::hresult {
997
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
998
+
999
+ IShell* implementation = reinterpret_cast<IShell*>(message->Parameters().Implementation());
1000
+ ASSERT(implementation != nullptr);
1001
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), IShell::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
1002
+
1003
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
1004
+ if (reader.Length() < (sizeof(Core::instance_id))) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1005
+ Core::instance_id _sinkInstanceId__ = reader.Number<Core::instance_id>();
1006
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
1007
+ const uint32_t _interface_id = reader.Number<uint32_t>();
1008
+
1009
+ IPlugin::INotification* _sink{};
1010
+ ProxyStub::UnknownProxy* _sinkProxy__ = nullptr;
1011
+ if (_sinkInstanceId__ != 0) {
1012
+ _sinkProxy__ = RPC::Administrator::Instance().ProxyInstance(channel, _sinkInstanceId__, false, _sink);
1013
+ ASSERT((_sink != nullptr) && (_sinkProxy__ != nullptr));
1014
+ if ((_sink == nullptr) || (_sinkProxy__ == nullptr)) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
1015
+ }
1016
+
1017
+ implementation->Unregister(_sink, _interface_id);
1018
+
1019
+ if (_sinkProxy__ != nullptr) {
1020
+ RPC::Administrator::Instance().Release(_sinkProxy__, message->Response());
1021
+ }
1022
+
1023
+ return (Core::ERROR_NONE);
1024
+ } ();
1025
+
1026
+ if (hresult != Core::ERROR_NONE) {
1027
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 31, hresult);
1028
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
1029
+ }
1030
+ },
1031
+
1032
+ // (32) virtual IShell::state State() const = 0
949
1033
  //
950
1034
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
951
1035
  Core::hresult hresult = Core::ERROR_NONE;
952
1036
 
953
1037
  hresult = [&]() -> Core::hresult {
@@ -964,16 +1048,16 @@ namespace ProxyStubs {
964
1048
 
965
1049
  return (Core::ERROR_NONE);
966
1050
  } ();
967
1051
 
968
1052
  if (hresult != Core::ERROR_NONE) {
969
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 30, hresult);
1053
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 32, hresult);
970
1054
  TRACE_L1("Warning: This COM-RPC failure will not propagate!");
971
1055
  }
972
1056
  },
973
1057
 
974
- // (31) virtual void* QueryInterfaceByCallsign(const uint32_t, const string&) = 0
1058
+ // (33) virtual void* QueryInterfaceByCallsign(const uint32_t, const string&) = 0
975
1059
  //
976
1060
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
977
1061
  Core::hresult hresult = Core::ERROR_NONE;
978
1062
 
979
1063
  hresult = [&]() -> Core::hresult {
@@ -1000,16 +1084,16 @@ namespace ProxyStubs {
1000
1084
 
1001
1085
  return (Core::ERROR_NONE);
1002
1086
  } ();
1003
1087
 
1004
1088
  if (hresult != Core::ERROR_NONE) {
1005
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 31, hresult);
1089
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 33, hresult);
1006
1090
  TRACE_L1("Warning: This COM-RPC failure will not propagate!");
1007
1091
  }
1008
1092
  },
1009
1093
 
1010
- // (32) virtual Core::hresult Activate(const IShell::reason) = 0
1094
+ // (34) virtual Core::hresult Activate(const IShell::reason) = 0
1011
1095
  //
1012
1096
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
1013
1097
  Core::hresult hresult = Core::ERROR_NONE;
1014
1098
 
1015
1099
  hresult = [&]() -> Core::hresult {
@@ -1032,15 +1116,15 @@ namespace ProxyStubs {
1032
1116
  } ();
1033
1117
 
1034
1118
  if (hresult != Core::ERROR_NONE) {
1035
1119
  RPC::Data::Frame::Writer writer(message->Response().Writer());
1036
1120
  writer.Number<uint32_t>(hresult);
1037
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 32, hresult);
1121
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 34, hresult);
1038
1122
  }
1039
1123
  },
1040
1124
 
1041
- // (33) virtual Core::hresult Deactivate(const IShell::reason) = 0
1125
+ // (35) virtual Core::hresult Deactivate(const IShell::reason) = 0
1042
1126
  //
1043
1127
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
1044
1128
  Core::hresult hresult = Core::ERROR_NONE;
1045
1129
 
1046
1130
  hresult = [&]() -> Core::hresult {
@@ -1063,15 +1147,15 @@ namespace ProxyStubs {
1063
1147
  } ();
1064
1148
 
1065
1149
  if (hresult != Core::ERROR_NONE) {
1066
1150
  RPC::Data::Frame::Writer writer(message->Response().Writer());
1067
1151
  writer.Number<uint32_t>(hresult);
1068
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 33, hresult);
1152
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 35, hresult);
1069
1153
  }
1070
1154
  },
1071
1155
 
1072
- // (34) virtual Core::hresult Unavailable(const IShell::reason) = 0
1156
+ // (36) virtual Core::hresult Unavailable(const IShell::reason) = 0
1073
1157
  //
1074
1158
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
1075
1159
  Core::hresult hresult = Core::ERROR_NONE;
1076
1160
 
1077
1161
  hresult = [&]() -> Core::hresult {
@@ -1094,15 +1178,15 @@ namespace ProxyStubs {
1094
1178
  } ();
1095
1179
 
1096
1180
  if (hresult != Core::ERROR_NONE) {
1097
1181
  RPC::Data::Frame::Writer writer(message->Response().Writer());
1098
1182
  writer.Number<uint32_t>(hresult);
1099
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 34, hresult);
1183
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 36, hresult);
1100
1184
  }
1101
1185
  },
1102
1186
 
1103
- // (35) virtual Core::hresult Hibernate(const uint32_t) = 0
1187
+ // (37) virtual Core::hresult Hibernate(const uint32_t) = 0
1104
1188
  //
1105
1189
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
1106
1190
  Core::hresult hresult = Core::ERROR_NONE;
1107
1191
 
1108
1192
  hresult = [&]() -> Core::hresult {
@@ -1125,15 +1209,15 @@ namespace ProxyStubs {
1125
1209
  } ();
1126
1210
 
1127
1211
  if (hresult != Core::ERROR_NONE) {
1128
1212
  RPC::Data::Frame::Writer writer(message->Response().Writer());
1129
1213
  writer.Number<uint32_t>(hresult);
1130
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 35, hresult);
1214
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 37, hresult);
1131
1215
  }
1132
1216
  },
1133
1217
 
1134
- // (36) virtual IShell::reason Reason() const = 0
1218
+ // (38) virtual IShell::reason Reason() const = 0
1135
1219
  //
1136
1220
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
1137
1221
  Core::hresult hresult = Core::ERROR_NONE;
1138
1222
 
1139
1223
  hresult = [&]() -> Core::hresult {
@@ -1150,22 +1234,22 @@ namespace ProxyStubs {
1150
1234
 
1151
1235
  return (Core::ERROR_NONE);
1152
1236
  } ();
1153
1237
 
1154
1238
  if (hresult != Core::ERROR_NONE) {
1155
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 36, hresult);
1239
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 38, hresult);
1156
1240
  TRACE_L1("Warning: This COM-RPC failure will not propagate!");
1157
1241
  }
1158
1242
  },
1159
1243
 
1160
- // (37) virtual uint32_t Submit(const uint32_t, /* undefined type */ const Core::ProxyType<Core::JSON::IElement>&) = 0
1244
+ // (39) virtual uint32_t Submit(const uint32_t, /* undefined type */ const Core::ProxyType<Core::JSON::IElement>&) = 0
1161
1245
  //
1162
1246
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& /* message */) {
1163
1247
  // stubbed method, no implementation
1164
1248
  },
1165
1249
 
1166
- // (38) virtual RPC::IStringIterator* GetLibrarySearchPaths(const string&) const = 0
1250
+ // (40) virtual RPC::IStringIterator* GetLibrarySearchPaths(const string&) const = 0
1167
1251
  //
1168
1252
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
1169
1253
  Core::hresult hresult = Core::ERROR_NONE;
1170
1254
 
1171
1255
  hresult = [&]() -> Core::hresult {
@@ -1190,11 +1274,11 @@ namespace ProxyStubs {
1190
1274
 
1191
1275
  return (Core::ERROR_NONE);
1192
1276
  } ();
1193
1277
 
1194
1278
  if (hresult != Core::ERROR_NONE) {
1195
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 38, hresult);
1279
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 40, hresult);
1196
1280
  TRACE_L1("Warning: This COM-RPC failure will not propagate!");
1197
1281
  }
1198
1282
  }
1199
1283
  , nullptr
1200
1284
  }; // ShellStubMethods
@@ -1389,19 +1473,21 @@ namespace ProxyStubs {
1389
1473
  // (25) virtual Core::hresult Metadata(string&) const = 0
1390
1474
  // (26) virtual ISubSystem* SubSystems() = 0
1391
1475
  // (27) virtual void Notify(const string&, const string&) = 0
1392
1476
  // (28) virtual void Register(IPlugin::INotification*, const Core::OptionalType<string>&) = 0
1393
1477
  // (29) virtual void Unregister(IPlugin::INotification*, const Core::OptionalType<string>&) = 0
1394
- // (30) virtual IShell::state State() const = 0
1395
- // (31) virtual void* QueryInterfaceByCallsign(const uint32_t, const string&) = 0
1396
- // (32) virtual Core::hresult Activate(const IShell::reason) = 0
1397
- // (33) virtual Core::hresult Deactivate(const IShell::reason) = 0
1398
- // (34) virtual Core::hresult Unavailable(const IShell::reason) = 0
1399
- // (35) virtual Core::hresult Hibernate(const uint32_t) = 0
1400
- // (36) virtual IShell::reason Reason() const = 0
1401
- // (37) virtual uint32_t Submit(const uint32_t, /* undefined type */ const Core::ProxyType<Core::JSON::IElement>&) = 0
1402
- // (38) virtual RPC::IStringIterator* GetLibrarySearchPaths(const string&) const = 0
1478
+ // (30) virtual void Register(IPlugin::INotification*, const uint32_t) = 0
1479
+ // (31) virtual void Unregister(IPlugin::INotification*, const uint32_t) = 0
1480
+ // (32) virtual IShell::state State() const = 0
1481
+ // (33) virtual void* QueryInterfaceByCallsign(const uint32_t, const string&) = 0
1482
+ // (34) virtual Core::hresult Activate(const IShell::reason) = 0
1483
+ // (35) virtual Core::hresult Deactivate(const IShell::reason) = 0
1484
+ // (36) virtual Core::hresult Unavailable(const IShell::reason) = 0
1485
+ // (37) virtual Core::hresult Hibernate(const uint32_t) = 0
1486
+ // (38) virtual IShell::reason Reason() const = 0
1487
+ // (39) virtual uint32_t Submit(const uint32_t, /* undefined type */ const Core::ProxyType<Core::JSON::IElement>&) = 0
1488
+ // (40) virtual RPC::IStringIterator* GetLibrarySearchPaths(const string&) const = 0
1403
1489
  //
1404
1490
 
1405
1491
  class ShellProxy final : public ProxyStub::UnknownProxyType<IShell> {
1406
1492
  public:
1407
1493
  ShellProxy(const Core::ProxyType<Core::IPCChannel>& channel, const Core::instance_id implementation, const bool otherSideInformed)
@@ -2259,14 +2345,80 @@ namespace ProxyStubs {
2259
2345
  }
2260
2346
 
2261
2347
  static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(nullptr);
2262
2348
  }
2263
2349
 
2264
- IShell::state State() const override
2350
+ void Register(IPlugin::INotification* _sink, const uint32_t _interface_id) override
2265
2351
  {
2266
2352
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(30));
2267
2353
 
2354
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
2355
+ writer.Number<Core::instance_id>(RPC::instance_cast(_sink));
2356
+ writer.Number<uint32_t>(_interface_id);
2357
+
2358
+ const RPC::InstanceRecord passedInstances[] = { { RPC::instance_cast(_sink), IPlugin::INotification::ID }, { 0, 0 } };
2359
+ static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(passedInstances);
2360
+
2361
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
2362
+ if (hresult == Core::ERROR_NONE) {
2363
+ hresult = [&]() -> Core::hresult {
2364
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
2365
+
2366
+ const uint32_t completeResult__ = _Complete(reader);
2367
+ if (completeResult__ != Core::ERROR_NONE) { return (completeResult__); }
2368
+
2369
+ return (Core::ERROR_NONE);
2370
+ } ();
2371
+ } else {
2372
+ ASSERT((hresult & COM_ERROR) != 0);
2373
+ }
2374
+
2375
+ if ((hresult & COM_ERROR) != 0) {
2376
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 30, hresult);
2377
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
2378
+ }
2379
+
2380
+ static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(nullptr);
2381
+ }
2382
+
2383
+ void Unregister(IPlugin::INotification* _sink, const uint32_t _interface_id) override
2384
+ {
2385
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(31));
2386
+
2387
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
2388
+ writer.Number<Core::instance_id>(RPC::instance_cast(_sink));
2389
+ writer.Number<uint32_t>(_interface_id);
2390
+
2391
+ const RPC::InstanceRecord passedInstances[] = { { RPC::instance_cast(_sink), IPlugin::INotification::ID }, { 0, 0 } };
2392
+ static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(passedInstances);
2393
+
2394
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
2395
+ if (hresult == Core::ERROR_NONE) {
2396
+ hresult = [&]() -> Core::hresult {
2397
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
2398
+
2399
+ const uint32_t completeResult__ = _Complete(reader);
2400
+ if (completeResult__ != Core::ERROR_NONE) { return (completeResult__); }
2401
+
2402
+ return (Core::ERROR_NONE);
2403
+ } ();
2404
+ } else {
2405
+ ASSERT((hresult & COM_ERROR) != 0);
2406
+ }
2407
+
2408
+ if ((hresult & COM_ERROR) != 0) {
2409
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 31, hresult);
2410
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
2411
+ }
2412
+
2413
+ static_cast<const ProxyStub::UnknownProxy&>(*this).Channel()->CustomData(nullptr);
2414
+ }
2415
+
2416
+ IShell::state State() const override
2417
+ {
2418
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(32));
2419
+
2268
2420
  IShell::state result{};
2269
2421
 
2270
2422
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
2271
2423
  if (hresult == Core::ERROR_NONE) {
2272
2424
  hresult = [&]() -> Core::hresult {
@@ -2279,20 +2431,20 @@ namespace ProxyStubs {
2279
2431
  } else {
2280
2432
  ASSERT((hresult & COM_ERROR) != 0);
2281
2433
  }
2282
2434
 
2283
2435
  if ((hresult & COM_ERROR) != 0) {
2284
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 30, hresult);
2436
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 32, hresult);
2285
2437
  TRACE_L1("Warning: This COM-RPC failure will not propagate!");
2286
2438
  }
2287
2439
 
2288
2440
  return (result);
2289
2441
  }
2290
2442
 
2291
2443
  void* QueryInterfaceByCallsign(const uint32_t _id, const string& _name) override
2292
2444
  {
2293
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(31));
2445
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(33));
2294
2446
 
2295
2447
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
2296
2448
  writer.Number<uint32_t>(_id);
2297
2449
  writer.Text(_name);
2298
2450
 
@@ -2309,20 +2461,20 @@ namespace ProxyStubs {
2309
2461
  } else {
2310
2462
  ASSERT((hresult & COM_ERROR) != 0);
2311
2463
  }
2312
2464
 
2313
2465
  if ((hresult & COM_ERROR) != 0) {
2314
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 31, hresult);
2466
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 33, hresult);
2315
2467
  TRACE_L1("Warning: This COM-RPC failure will not propagate!");
2316
2468
  }
2317
2469
 
2318
2470
  return (result);
2319
2471
  }
2320
2472
 
2321
2473
  Core::hresult Activate(const IShell::reason _parameter_1) override
2322
2474
  {
2323
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(32));
2475
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(34));
2324
2476
 
2325
2477
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
2326
2478
  writer.Number<IShell::reason>(_parameter_1);
2327
2479
 
2328
2480
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
@@ -2337,19 +2489,19 @@ namespace ProxyStubs {
2337
2489
  } else {
2338
2490
  ASSERT((hresult & COM_ERROR) != 0);
2339
2491
  }
2340
2492
 
2341
2493
  if ((hresult & COM_ERROR) != 0) {
2342
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 32, hresult);
2494
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 34, hresult);
2343
2495
  }
2344
2496
 
2345
2497
  return (hresult);
2346
2498
  }
2347
2499
 
2348
2500
  Core::hresult Deactivate(const IShell::reason _parameter_1) override
2349
2501
  {
2350
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(33));
2502
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(35));
2351
2503
 
2352
2504
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
2353
2505
  writer.Number<IShell::reason>(_parameter_1);
2354
2506
 
2355
2507
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
@@ -2364,19 +2516,19 @@ namespace ProxyStubs {
2364
2516
  } else {
2365
2517
  ASSERT((hresult & COM_ERROR) != 0);
2366
2518
  }
2367
2519
 
2368
2520
  if ((hresult & COM_ERROR) != 0) {
2369
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 33, hresult);
2521
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 35, hresult);
2370
2522
  }
2371
2523
 
2372
2524
  return (hresult);
2373
2525
  }
2374
2526
 
2375
2527
  Core::hresult Unavailable(const IShell::reason _parameter_1) override
2376
2528
  {
2377
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(34));
2529
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(36));
2378
2530
 
2379
2531
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
2380
2532
  writer.Number<IShell::reason>(_parameter_1);
2381
2533
 
2382
2534
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
@@ -2391,19 +2543,19 @@ namespace ProxyStubs {
2391
2543
  } else {
2392
2544
  ASSERT((hresult & COM_ERROR) != 0);
2393
2545
  }
2394
2546
 
2395
2547
  if ((hresult & COM_ERROR) != 0) {
2396
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 34, hresult);
2548
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 36, hresult);
2397
2549
  }
2398
2550
 
2399
2551
  return (hresult);
2400
2552
  }
2401
2553
 
2402
2554
  Core::hresult Hibernate(const uint32_t _timeout) override
2403
2555
  {
2404
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(35));
2556
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(37));
2405
2557
 
2406
2558
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
2407
2559
  writer.Number<uint32_t>(_timeout);
2408
2560
 
2409
2561
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
@@ -2418,19 +2570,19 @@ namespace ProxyStubs {
2418
2570
  } else {
2419
2571
  ASSERT((hresult & COM_ERROR) != 0);
2420
2572
  }
2421
2573
 
2422
2574
  if ((hresult & COM_ERROR) != 0) {
2423
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 35, hresult);
2575
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 37, hresult);
2424
2576
  }
2425
2577
 
2426
2578
  return (hresult);
2427
2579
  }
2428
2580
 
2429
2581
  IShell::reason Reason() const override
2430
2582
  {
2431
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(36));
2583
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(38));
2432
2584
 
2433
2585
  IShell::reason result{};
2434
2586
 
2435
2587
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
2436
2588
  if (hresult == Core::ERROR_NONE) {
@@ -2444,11 +2596,11 @@ namespace ProxyStubs {
2444
2596
  } else {
2445
2597
  ASSERT((hresult & COM_ERROR) != 0);
2446
2598
  }
2447
2599
 
2448
2600
  if ((hresult & COM_ERROR) != 0) {
2449
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 36, hresult);
2601
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 38, hresult);
2450
2602
  TRACE_L1("Warning: This COM-RPC failure will not propagate!");
2451
2603
  }
2452
2604
 
2453
2605
  return (result);
2454
2606
  }
@@ -2460,11 +2612,11 @@ namespace ProxyStubs {
2460
2612
  return {};
2461
2613
  }
2462
2614
 
2463
2615
  RPC::IStringIterator* GetLibrarySearchPaths(const string& _parameter_1) const override
2464
2616
  {
2465
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(38));
2617
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(40));
2466
2618
 
2467
2619
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
2468
2620
  writer.Text(_parameter_1);
2469
2621
 
2470
2622
  RPC::IStringIterator* result{};
@@ -2480,11 +2632,11 @@ namespace ProxyStubs {
2480
2632
  } else {
2481
2633
  ASSERT((hresult & COM_ERROR) != 0);
2482
2634
  }
2483
2635
 
2484
2636
  if ((hresult & COM_ERROR) != 0) {
2485
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 38, hresult);
2637
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", IShell::ID, 40, hresult);
2486
2638
  TRACE_L1("Warning: This COM-RPC failure will not propagate!");
2487
2639
  }
2488
2640
 
2489
2641
  return (result);
2490
2642
  }