Diff to HTML by rtfpessoa

Files changed (60) hide show
  1. {baseline → generated}/Debug/Thunder/Source/plugins/json/JConfiguration.h +2 -0
  2. {baseline → generated}/Debug/Thunder/Source/plugins/json/JDiscovery.h +1 -0
  3. {baseline → generated}/Debug/Thunder/Source/plugins/json/JLifeTime.h +6 -0
  4. {baseline → generated}/Debug/Thunder/Source/plugins/json/JStateController.h +1 -0
  5. {baseline → generated}/Debug/Thunder/Source/plugins/json/JSystem.h +3 -0
  6. {baseline → generated}/Debug/ThunderInterfaces/definitions/example_generated/JCustomErrorCode.h +2 -0
  7. {baseline → generated}/Debug/ThunderInterfaces/definitions/example_generated/JSimpleAsync.h +17 -0
  8. {baseline → generated}/Debug/ThunderInterfaces/definitions/example_generated/JSimpleCustomObjects.h +2 -0
  9. {baseline → generated}/Debug/ThunderInterfaces/definitions/example_generated/JSimpleInstanceObjects.h +4 -0
  10. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JAVSController.h +2 -0
  11. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JAmazonPrime.h +1 -0
  12. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JApplication.h +2 -0
  13. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JAudioStream.h +2 -0
  14. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JBluetoothAudioSink.h +2 -0
  15. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JBluetoothControl.h +14 -0
  16. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JBluetoothRemoteControl.h +2 -0
  17. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JBrowserCookieJar.h +1 -0
  18. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JBrowserResources.h +16 -10
  19. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JBrowserScripting.h +2 -0
  20. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JButler.h +8 -0
  21. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JConnectionProperties.h +1 -0
  22. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JContentProtection.h +6 -0
  23. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JDNSServer.h +5 -0
  24. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JDictionary.h +3 -0
  25. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JDolbyOutput.h +1 -0
  26. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JErrorToString.h +1 -0
  27. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JIOConnector.h +1 -0
  28. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JMath.h +2 -0
  29. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JMemoryMonitor.h +3 -1
  30. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JMessageControl.h +0 -126
  31. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JMessagingControl.h +2 -1
  32. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JMessenger.h +18 -12
  33. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JNetworkControl.h +16 -6
  34. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JNetworkTools.h +2 -0
  35. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JOpenCDM.h +2 -2
  36. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JPackageManager.h +14 -0
  37. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JPackager.h +1 -0
  38. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JPower.h +1 -0
  39. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JScriptEngine.h +1 -0
  40. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JSecurityAgent.h +1 -0
  41. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JStore2.h +4 -0
  42. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JSubsystemControl.h +1 -0
  43. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JSystemCommands.h +1 -0
  44. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JTimeSync.h +1 -0
  45. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JUSBHub.h +4 -2
  46. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JValuePointCatalog.h +2 -0
  47. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JWatchDog.h +1 -0
  48. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JWebBrowser.h +2 -0
  49. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JWebBrowserExt.h +9 -5
  50. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JWifiControl.h +4 -1
  51. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JZigWave.h +3 -0
  52. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JsonData_MessageControl.h +0 -134
  53. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JsonEnum_MessageControl.cpp +0 -22
  54. {baseline → generated}/Debug/ThunderInterfaces/definitions/generated/json_IMessageControl.h +0 -7
  55. {baseline → generated}/Debug/ThunderInterfaces/definitions/qa_generated/JComRpc.h +1 -0
  56. {baseline → generated}/Debug/ThunderInterfaces/definitions/qa_generated/JMemory.h +1 -0
  57. {baseline → generated}/Debug/ThunderInterfaces/definitions/qa_generated/JTestTextOptions.h +1 -0
  58. {baseline → generated}/Debug/ThunderInterfaces/definitions/qa_generated/JTestTextOptionsTestCustom.h +1 -0
  59. {baseline → generated}/Debug/ThunderInterfaces/definitions/qa_generated/JTestTextOptionsTestKeep.h +1 -0
  60. {baseline → generated}/Debug/ThunderInterfaces/definitions/qa_generated/JTestTextOptionsTestLegacy.h +1 -0
{baseline → generated}/Debug/Thunder/Source/plugins/json/JConfiguration.h RENAMED
@@ -35,10 +35,11 @@
35
35
  _module__.PluginHost::JSONRPC::template Register<JsonData::Configuration::PersistParamsInfo, void>(_T("persist"),
36
36
  [_implementation__](const JsonData::Configuration::PersistParamsInfo& params) -> uint32_t {
37
37
  uint32_t _errorCode__ = Core::ERROR_NONE;
38
38
 
39
39
  if ((params.IsSet() == true) && (params.IsDataValid() == false)) {
40
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JConfiguration"), _T("persist")));
40
41
  _errorCode__ = Core::ERROR_BAD_REQUEST;
41
42
  }
42
43
  else {
43
44
  Core::OptionalType<string> _callsign_{};
44
45
  if (params.Callsign.IsSet() == true) {
@@ -58,10 +59,11 @@
58
59
  _module__.PluginHost::JSONRPC::template Register<JsonData::Configuration::PersistParamsInfo, void>(_T("restore"),
59
60
  [_implementation__](const JsonData::Configuration::PersistParamsInfo& params) -> uint32_t {
60
61
  uint32_t _errorCode__ = Core::ERROR_NONE;
61
62
 
62
63
  if ((params.IsSet() == true) && (params.IsDataValid() == false)) {
64
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JConfiguration"), _T("restore")));
63
65
  _errorCode__ = Core::ERROR_BAD_REQUEST;
64
66
  }
65
67
  else {
66
68
  Core::OptionalType<string> _callsign_{};
67
69
  if (params.Callsign.IsSet() == true) {
{baseline → generated}/Debug/Thunder/Source/plugins/json/JDiscovery.h RENAMED
@@ -35,10 +35,11 @@
35
35
  _module__.PluginHost::JSONRPC::template Register<JsonData::Discovery::StartDiscoveryParamsData, void>(_T("startdiscovery"),
36
36
  [_implementation__](const JsonData::Discovery::StartDiscoveryParamsData& params) -> uint32_t {
37
37
  uint32_t _errorCode__ = Core::ERROR_NONE;
38
38
 
39
39
  if ((params.IsSet() == true) && (params.IsDataValid() == false)) {
40
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDiscovery"), _T("startdiscovery")));
40
41
  _errorCode__ = Core::ERROR_BAD_REQUEST;
41
42
  }
42
43
  else {
43
44
  Core::OptionalType<uint8_t> _ttl_{};
44
45
  if (params.Ttl.IsSet() == true) {
{baseline → generated}/Debug/Thunder/Source/plugins/json/JLifeTime.h RENAMED
@@ -42,10 +42,11 @@
42
42
  _module__.PluginHost::JSONRPC::template Register<JsonData::LifeTime::ActivateParamsInfo, void>(_T("activate"),
43
43
  [_implementation__](const JsonData::LifeTime::ActivateParamsInfo& params) -> uint32_t {
44
44
  uint32_t _errorCode__ = Core::ERROR_NONE;
45
45
 
46
46
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
47
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JLifeTime"), _T("activate")));
47
48
  _errorCode__ = Core::ERROR_BAD_REQUEST;
48
49
  }
49
50
  else {
50
51
  const string _callsign_{params.Callsign};
51
52
 
@@ -60,10 +61,11 @@
60
61
  _module__.PluginHost::JSONRPC::template Register<JsonData::LifeTime::ActivateParamsInfo, void>(_T("deactivate"),
61
62
  [_implementation__](const JsonData::LifeTime::ActivateParamsInfo& params) -> uint32_t {
62
63
  uint32_t _errorCode__ = Core::ERROR_NONE;
63
64
 
64
65
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
66
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JLifeTime"), _T("deactivate")));
65
67
  _errorCode__ = Core::ERROR_BAD_REQUEST;
66
68
  }
67
69
  else {
68
70
  const string _callsign_{params.Callsign};
69
71
 
@@ -78,10 +80,11 @@
78
80
  _module__.PluginHost::JSONRPC::template Register<JsonData::LifeTime::ActivateParamsInfo, void>(_T("unavailable"),
79
81
  [_implementation__](const JsonData::LifeTime::ActivateParamsInfo& params) -> uint32_t {
80
82
  uint32_t _errorCode__ = Core::ERROR_NONE;
81
83
 
82
84
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
85
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JLifeTime"), _T("unavailable")));
83
86
  _errorCode__ = Core::ERROR_BAD_REQUEST;
84
87
  }
85
88
  else {
86
89
  const string _callsign_{params.Callsign};
87
90
 
@@ -96,10 +99,11 @@
96
99
  _module__.PluginHost::JSONRPC::template Register<JsonData::LifeTime::HibernateParamsData, void>(_T("hibernate"),
97
100
  [_implementation__](const JsonData::LifeTime::HibernateParamsData& params) -> uint32_t {
98
101
  uint32_t _errorCode__ = Core::ERROR_NONE;
99
102
 
100
103
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
104
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JLifeTime"), _T("hibernate")));
101
105
  _errorCode__ = Core::ERROR_BAD_REQUEST;
102
106
  }
103
107
  else {
104
108
  const string _callsign_{params.Callsign};
105
109
  const uint32_t _timeout_{params.Timeout};
@@ -115,10 +119,11 @@
115
119
  _module__.PluginHost::JSONRPC::template Register<JsonData::LifeTime::ActivateParamsInfo, void>(_T("suspend"),
116
120
  [_implementation__](const JsonData::LifeTime::ActivateParamsInfo& params) -> uint32_t {
117
121
  uint32_t _errorCode__ = Core::ERROR_NONE;
118
122
 
119
123
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
124
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JLifeTime"), _T("suspend")));
120
125
  _errorCode__ = Core::ERROR_BAD_REQUEST;
121
126
  }
122
127
  else {
123
128
  const string _callsign_{params.Callsign};
124
129
 
@@ -133,10 +138,11 @@
133
138
  _module__.PluginHost::JSONRPC::template Register<JsonData::LifeTime::ActivateParamsInfo, void>(_T("resume"),
134
139
  [_implementation__](const JsonData::LifeTime::ActivateParamsInfo& params) -> uint32_t {
135
140
  uint32_t _errorCode__ = Core::ERROR_NONE;
136
141
 
137
142
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
143
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JLifeTime"), _T("resume")));
138
144
  _errorCode__ = Core::ERROR_BAD_REQUEST;
139
145
  }
140
146
  else {
141
147
  const string _callsign_{params.Callsign};
142
148
 
{baseline → generated}/Debug/Thunder/Source/plugins/json/JStateController.h RENAMED
@@ -33,10 +33,11 @@
33
33
  _module__.PluginHost::JSONRPC::template Register<JsonData::StateController::RequestParamsData, void>(_T("statecontrol::request"),
34
34
  [_implementation__](const JsonData::StateController::RequestParamsData& params) -> uint32_t {
35
35
  uint32_t _errorCode__ = Core::ERROR_NONE;
36
36
 
37
37
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
38
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JStateController"), _T("statecontrol::request")));
38
39
  _errorCode__ = Core::ERROR_BAD_REQUEST;
39
40
  }
40
41
  else {
41
42
  const PluginHost::IStateController::command _state_{params.State};
42
43
 
{baseline → generated}/Debug/Thunder/Source/plugins/json/JSystem.h RENAMED
@@ -47,10 +47,11 @@
47
47
  _module__.PluginHost::JSONRPC::template Register<JsonData::System::DeleteParamsData, void>(_T("delete"),
48
48
  [_implementation__](const JsonData::System::DeleteParamsData& params) -> uint32_t {
49
49
  uint32_t _errorCode__ = Core::ERROR_NONE;
50
50
 
51
51
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
52
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSystem"), _T("delete")));
52
53
  _errorCode__ = Core::ERROR_BAD_REQUEST;
53
54
  }
54
55
  else {
55
56
  const string _path_{params.Path};
56
57
 
@@ -65,10 +66,11 @@
65
66
  _module__.PluginHost::JSONRPC::template Register<JsonData::System::CloneParamsData, Core::JSON::String>(_T("clone"),
66
67
  [_implementation__](const JsonData::System::CloneParamsData& params, Core::JSON::String& response) -> uint32_t {
67
68
  uint32_t _errorCode__ = Core::ERROR_NONE;
68
69
 
69
70
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
71
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSystem"), _T("clone")));
70
72
  _errorCode__ = Core::ERROR_BAD_REQUEST;
71
73
  }
72
74
  else {
73
75
  const string _callsign_{params.Callsign};
74
76
  const string _newcallsign_{params.Newcallsign};
@@ -88,10 +90,11 @@
88
90
  _module__.PluginHost::JSONRPC::template Register<JsonData::System::DestroyParamsData, void>(_T("destroy"),
89
91
  [_implementation__](const JsonData::System::DestroyParamsData& params) -> uint32_t {
90
92
  uint32_t _errorCode__ = Core::ERROR_NONE;
91
93
 
92
94
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
95
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSystem"), _T("destroy")));
93
96
  _errorCode__ = Core::ERROR_BAD_REQUEST;
94
97
  }
95
98
  else {
96
99
  const string _callsign_{params.Callsign};
97
100
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/example_generated/JCustomErrorCode.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::CustomErrorCode::TriggerCustomErrorParamsData, void>(_T("triggerCustomError"),
37
37
  [_implementation__](const JsonData::CustomErrorCode::TriggerCustomErrorParamsData& params) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JCustomErrorCode"), _T("triggerCustomError")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const int32_t _errorcode_{params.Errorcode};
45
46
 
@@ -54,10 +55,11 @@
54
55
  _module__.PluginHost::JSONRPC::template Register<JsonData::CustomErrorCode::TriggerNonCustomErrorParamsData, void>(_T("triggerNonCustomError"),
55
56
  [_implementation__](const JsonData::CustomErrorCode::TriggerNonCustomErrorParamsData& params) -> uint32_t {
56
57
  uint32_t _errorCode__ = Core::ERROR_NONE;
57
58
 
58
59
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
60
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JCustomErrorCode"), _T("triggerNonCustomError")));
59
61
  _errorCode__ = Core::ERROR_BAD_REQUEST;
60
62
  }
61
63
  else {
62
64
  const uint32_t _errorcode_{params.Errorcode};
63
65
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/example_generated/JSimpleAsync.h RENAMED
@@ -121,10 +121,11 @@
121
121
  _module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::ConnectParamsData, void, std::function<uint32_t(const Core::JSONRPC::Context&, const JsonData::SimpleAsync::ConnectParamsData&)>>(_T("connect"),
122
122
  [_implementation__, &_module__](const Core::JSONRPC::Context& context_, const JsonData::SimpleAsync::ConnectParamsData& params) -> uint32_t {
123
123
  uint32_t _errorCode__ = Core::ERROR_NONE;
124
124
 
125
125
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
126
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("connect")));
126
127
  _errorCode__ = Core::ERROR_BAD_REQUEST;
127
128
  }
128
129
  else {
129
130
  std::vector<uint8_t> _addressContainer_{};
130
131
  Core::FromHexString(params.Address.Value(), _addressContainer_, 6, TCHAR(':'));
@@ -180,10 +181,11 @@
180
181
  _module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::LinkParamsInfo, void>(_T("link"),
181
182
  [_implementation__](const JsonData::SimpleAsync::LinkParamsInfo& params) -> uint32_t {
182
183
  uint32_t _errorCode__ = Core::ERROR_NONE;
183
184
 
184
185
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
186
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("link")));
185
187
  _errorCode__ = Core::ERROR_BAD_REQUEST;
186
188
  }
187
189
  else {
188
190
  uint8_t _address_[6]{};
189
191
  uint32_t _addressSize__(6);
@@ -200,10 +202,11 @@
200
202
  _module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::LinkParamsInfo, void>(_T("unlink"),
201
203
  [_implementation__](const JsonData::SimpleAsync::LinkParamsInfo& params) -> uint32_t {
202
204
  uint32_t _errorCode__ = Core::ERROR_NONE;
203
205
 
204
206
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
207
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("unlink")));
205
208
  _errorCode__ = Core::ERROR_BAD_REQUEST;
206
209
  }
207
210
  else {
208
211
  uint8_t _address_[6]{};
209
212
  uint32_t _addressSize__(6);
@@ -220,10 +223,11 @@
220
223
  _module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::BindParamsInfo, void>(_T("bind"),
221
224
  [_implementation__](const JsonData::SimpleAsync::BindParamsInfo& params) -> uint32_t {
222
225
  uint32_t _errorCode__ = Core::ERROR_NONE;
223
226
 
224
227
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
228
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("bind")));
225
229
  _errorCode__ = Core::ERROR_BAD_REQUEST;
226
230
  }
227
231
  else {
228
232
  const Core::MACAddress _address_{params.Address.Value().c_str()};
229
233
 
@@ -238,10 +242,11 @@
238
242
  _module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::BindParamsInfo, void>(_T("unbind"),
239
243
  [_implementation__](const JsonData::SimpleAsync::BindParamsInfo& params) -> uint32_t {
240
244
  uint32_t _errorCode__ = Core::ERROR_NONE;
241
245
 
242
246
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
247
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("unbind")));
243
248
  _errorCode__ = Core::ERROR_BAD_REQUEST;
244
249
  }
245
250
  else {
246
251
  const Core::MACAddress _address_{params.Address.Value().c_str()};
247
252
 
@@ -256,10 +261,11 @@
256
261
  _module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, Core::JSON::ArrayType<Core::JSON::String>>(_T("tables"),
257
262
  [_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, Core::JSON::ArrayType<Core::JSON::String>& stringTables) -> uint32_t {
258
263
  uint32_t _errorCode__ = Core::ERROR_NONE;
259
264
 
260
265
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
266
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables")));
261
267
  _errorCode__ = Core::ERROR_BAD_REQUEST;
262
268
  }
263
269
  else {
264
270
  const bool _fill_{params.Fill};
265
271
  std::vector<string> _stringTables_;
@@ -279,10 +285,11 @@
279
285
  _module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, JsonData::SimpleAsync::Tables2ResultData>(_T("tables2"),
280
286
  [_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, JsonData::SimpleAsync::Tables2ResultData& result) -> uint32_t {
281
287
  uint32_t _errorCode__ = Core::ERROR_NONE;
282
288
 
283
289
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
290
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables2")));
284
291
  _errorCode__ = Core::ERROR_BAD_REQUEST;
285
292
  }
286
293
  else {
287
294
  const bool _fill_{params.Fill};
288
295
  std::vector<string> _stringTables_;
@@ -305,10 +312,11 @@
305
312
  _module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, Core::JSON::ArrayType<Core::JSON::String>>(_T("tables3"),
306
313
  [_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, Core::JSON::ArrayType<Core::JSON::String>& stringTables) -> uint32_t {
307
314
  uint32_t _errorCode__ = Core::ERROR_NONE;
308
315
 
309
316
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
317
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables3")));
310
318
  _errorCode__ = Core::ERROR_BAD_REQUEST;
311
319
  }
312
320
  else {
313
321
  const bool _fill_{params.Fill};
314
322
  Core::OptionalType<std::vector<string>> _stringTables_;
@@ -330,10 +338,11 @@
330
338
  _module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, Core::JSON::ArrayType<Core::JSON::String>>(_T("tables4"),
331
339
  [_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, Core::JSON::ArrayType<Core::JSON::String>& stringTables) -> uint32_t {
332
340
  uint32_t _errorCode__ = Core::ERROR_NONE;
333
341
 
334
342
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
343
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables4")));
335
344
  _errorCode__ = Core::ERROR_BAD_REQUEST;
336
345
  }
337
346
  else {
338
347
  const bool _fill_{params.Fill};
339
348
  ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _stringTables_{};
@@ -358,10 +367,11 @@
358
367
  _module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, JsonData::SimpleAsync::Tables5ResultData>(_T("tables5"),
359
368
  [_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, JsonData::SimpleAsync::Tables5ResultData& result) -> uint32_t {
360
369
  uint32_t _errorCode__ = Core::ERROR_NONE;
361
370
 
362
371
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
372
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables5")));
363
373
  _errorCode__ = Core::ERROR_BAD_REQUEST;
364
374
  }
365
375
  else {
366
376
  const bool _fill_{params.Fill};
367
377
  ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _stringTables_{};
@@ -394,10 +404,11 @@
394
404
  _module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, JsonData::SimpleAsync::RecordInfo>(_T("tables6"),
395
405
  [_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, JsonData::SimpleAsync::RecordInfo& pod) -> uint32_t {
396
406
  uint32_t _errorCode__ = Core::ERROR_NONE;
397
407
 
398
408
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
409
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables6")));
399
410
  _errorCode__ = Core::ERROR_BAD_REQUEST;
400
411
  }
401
412
  else {
402
413
  const bool _fill_{params.Fill};
403
414
  Example::ISimpleAsync::Record _pod_{};
@@ -417,10 +428,11 @@
417
428
  _module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, JsonData::SimpleAsync::RecordInfo>(_T("tables7"),
418
429
  [_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, JsonData::SimpleAsync::RecordInfo& pod) -> uint32_t {
419
430
  uint32_t _errorCode__ = Core::ERROR_NONE;
420
431
 
421
432
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
433
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables7")));
422
434
  _errorCode__ = Core::ERROR_BAD_REQUEST;
423
435
  }
424
436
  else {
425
437
  const bool _fill_{params.Fill};
426
438
  Core::OptionalType<Example::ISimpleAsync::Record> _pod_{};
@@ -439,10 +451,11 @@
439
451
  _module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, JsonData::SimpleAsync::Record2Info>(_T("tables8"),
440
452
  [_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, JsonData::SimpleAsync::Record2Info& pod) -> uint32_t {
441
453
  uint32_t _errorCode__ = Core::ERROR_NONE;
442
454
 
443
455
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
456
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables8")));
444
457
  _errorCode__ = Core::ERROR_BAD_REQUEST;
445
458
  }
446
459
  else {
447
460
  const bool _fill_{params.Fill};
448
461
  Core::OptionalType<Example::ISimpleAsync::Record2> _pod_{};
@@ -461,10 +474,11 @@
461
474
  _module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, JsonData::SimpleAsync::Record2Info>(_T("tables9"),
462
475
  [_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, JsonData::SimpleAsync::Record2Info& pod) -> uint32_t {
463
476
  uint32_t _errorCode__ = Core::ERROR_NONE;
464
477
 
465
478
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
479
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("tables9")));
466
480
  _errorCode__ = Core::ERROR_BAD_REQUEST;
467
481
  }
468
482
  else {
469
483
  const bool _fill_{params.Fill};
470
484
  Example::ISimpleAsync::Record2 _pod_{};
@@ -483,10 +497,11 @@
483
497
  _module__.PluginHost::JSONRPC::template Register<JsonData::SimpleAsync::TablesParamsInfo, Core::JSON::String>(_T("optionalResult"),
484
498
  [_implementation__](const JsonData::SimpleAsync::TablesParamsInfo& params, Core::JSON::String& result) -> uint32_t {
485
499
  uint32_t _errorCode__ = Core::ERROR_NONE;
486
500
 
487
501
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
502
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("optionalResult")));
488
503
  _errorCode__ = Core::ERROR_BAD_REQUEST;
489
504
  }
490
505
  else {
491
506
  const bool _fill_{params.Fill};
492
507
  Core::OptionalType<string> _result_{};
@@ -584,10 +599,11 @@
584
599
  }
585
600
  }
586
601
  else {
587
602
 
588
603
  if (params.IsDataValid() == false) {
604
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("metadata")));
589
605
  _errorCode__ = Core::ERROR_BAD_REQUEST;
590
606
  }
591
607
  else {
592
608
  const string _value_{params.Value};
593
609
 
@@ -648,10 +664,11 @@
648
664
  }
649
665
  }
650
666
  else {
651
667
 
652
668
  if (params.IsDataValid() == false) {
669
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleAsync"), _T("type")));
653
670
  _errorCode__ = Core::ERROR_BAD_REQUEST;
654
671
  }
655
672
  else {
656
673
  const string _value_{params.Value};
657
674
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/example_generated/JSimpleCustomObjects.h RENAMED
@@ -89,10 +89,11 @@
89
89
  }
90
90
  }
91
91
  else {
92
92
 
93
93
  if (params.IsDataValid() == false) {
94
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleCustomObjects"), _T("accessory::name")));
94
95
  _errorCode__ = Core::ERROR_BAD_REQUEST;
95
96
  }
96
97
  else {
97
98
  ISimpleCustomObjects::IAccessory* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<ISimpleCustomObjects::IAccessory>(instanceId_, context_);
98
99
 
@@ -152,10 +153,11 @@
152
153
  }
153
154
  }
154
155
  else {
155
156
 
156
157
  if (params.IsDataValid() == false) {
158
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleCustomObjects"), _T("accessory::pin")));
157
159
  _errorCode__ = Core::ERROR_BAD_REQUEST;
158
160
  }
159
161
  else {
160
162
  ISimpleCustomObjects::IAccessory* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<ISimpleCustomObjects::IAccessory>(instanceId_, context_);
161
163
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/example_generated/JSimpleInstanceObjects.h RENAMED
@@ -60,10 +60,11 @@
60
60
  _module__.PluginHost::JSONRPC::template Register<JsonData::SimpleInstanceObjects::AcquireParamsData, Core::JSON::DecUInt32, std::function<uint32_t(const Core::JSONRPC::Context&, const JsonData::SimpleInstanceObjects::AcquireParamsData&, Core::JSON::DecUInt32&)>>(_T("acquire"),
61
61
  [_implementation__, &_module__](const Core::JSONRPC::Context& context_, const JsonData::SimpleInstanceObjects::AcquireParamsData& params, Core::JSON::DecUInt32& device) -> uint32_t {
62
62
  uint32_t _errorCode__ = Core::ERROR_NONE;
63
63
 
64
64
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
65
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleInstanceObjects"), _T("acquire")));
65
66
  _errorCode__ = Core::ERROR_BAD_REQUEST;
66
67
  }
67
68
  else {
68
69
  const string _name_{params.Name};
69
70
  uint32_t _device_{};
@@ -85,10 +86,11 @@
85
86
  _module__.PluginHost::JSONRPC::template Register<JsonData::SimpleInstanceObjects::RelinquishParamsData, void, std::function<uint32_t(const Core::JSONRPC::Context&, const JsonData::SimpleInstanceObjects::RelinquishParamsData&)>>(_T("relinquish"),
86
87
  [_implementation__, &_module__](const Core::JSONRPC::Context& context_, const JsonData::SimpleInstanceObjects::RelinquishParamsData& params) -> uint32_t {
87
88
  uint32_t _errorCode__ = Core::ERROR_NONE;
88
89
 
89
90
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
91
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleInstanceObjects"), _T("relinquish")));
90
92
  _errorCode__ = Core::ERROR_BAD_REQUEST;
91
93
  }
92
94
  else {
93
95
  const uint32_t _device_{params.Device};
94
96
  Example::ISimpleInstanceObjects::IDevice* _real_device_{};
@@ -169,10 +171,11 @@
169
171
  }
170
172
  }
171
173
  else {
172
174
 
173
175
  if (params.IsDataValid() == false) {
176
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleInstanceObjects"), _T("device::name")));
174
177
  _errorCode__ = Core::ERROR_BAD_REQUEST;
175
178
  }
176
179
  else {
177
180
  ISimpleInstanceObjects::IDevice* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<ISimpleInstanceObjects::IDevice>(instanceId_, context_);
178
181
 
@@ -232,10 +235,11 @@
232
235
  }
233
236
  }
234
237
  else {
235
238
 
236
239
  if (params.IsDataValid() == false) {
240
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSimpleInstanceObjects"), _T("device::pin")));
237
241
  _errorCode__ = Core::ERROR_BAD_REQUEST;
238
242
  }
239
243
  else {
240
244
  ISimpleInstanceObjects::IDevice* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<ISimpleInstanceObjects::IDevice>(instanceId_, context_);
241
245
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JAVSController.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<Core::JSON::Boolean, void>(_T("mute"),
37
37
  [_implementation__](const Core::JSON::Boolean& muted) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if (muted.IsSet() == false) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JAVSController"), _T("mute")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const bool _muted_{muted};
45
46
 
@@ -54,10 +55,11 @@
54
55
  _module__.PluginHost::JSONRPC::template Register<Core::JSON::Boolean, void>(_T("record"),
55
56
  [_implementation__](const Core::JSON::Boolean& started) -> uint32_t {
56
57
  uint32_t _errorCode__ = Core::ERROR_NONE;
57
58
 
58
59
  if (started.IsSet() == false) {
60
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JAVSController"), _T("record")));
59
61
  _errorCode__ = Core::ERROR_BAD_REQUEST;
60
62
  }
61
63
  else {
62
64
  const bool _started_{started};
63
65
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JAmazonPrime.h RENAMED
@@ -35,10 +35,11 @@
35
35
  _module__.PluginHost::JSONRPC::template Register<Core::JSON::String, void>(_T("send"),
36
36
  [_implementation__](const Core::JSON::String& message) -> uint32_t {
37
37
  uint32_t _errorCode__ = Core::ERROR_NONE;
38
38
 
39
39
  if (message.IsSet() == false) {
40
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JAmazonPrime"), _T("send")));
40
41
  _errorCode__ = Core::ERROR_BAD_REQUEST;
41
42
  }
42
43
  else {
43
44
  const string _message_{message};
44
45
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JApplication.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<Core::JSON::EnumType<Exchange::IApplication::resettype>, void>(_T("reset"),
37
37
  [_implementation__](const Core::JSON::EnumType<Exchange::IApplication::resettype>& type) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if (type.IsSet() == false) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JApplication"), _T("reset")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const Exchange::IApplication::resettype _type_{type};
45
46
 
@@ -70,10 +71,11 @@
70
71
  _module__.PluginHost::JSONRPC::template Register<Core::JSON::String, void>(_T("contentlink"),
71
72
  [_implementation__](const Core::JSON::String& params) -> uint32_t {
72
73
  uint32_t _errorCode__ = Core::ERROR_NONE;
73
74
 
74
75
  if (params.IsSet() == false) {
76
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JApplication"), _T("contentlink")));
75
77
  _errorCode__ = Core::ERROR_BAD_REQUEST;
76
78
  }
77
79
  else {
78
80
  const string _params_{params};
79
81
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JAudioStream.h RENAMED
@@ -103,10 +103,11 @@
103
103
  }
104
104
  }
105
105
  else {
106
106
 
107
107
  if (params.IsDataValid() == false) {
108
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JAudioStream"), _T("audioprofile")));
108
109
  _errorCode__ = Core::ERROR_BAD_REQUEST;
109
110
  }
110
111
  else {
111
112
  const Exchange::IAudioStream::audioprofile _value_(params.Value);
112
113
 
@@ -151,10 +152,11 @@
151
152
  }
152
153
  }
153
154
  else {
154
155
 
155
156
  if (params.IsDataValid() == false) {
157
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JAudioStream"), _T("speed")));
156
158
  _errorCode__ = Core::ERROR_BAD_REQUEST;
157
159
  }
158
160
  else {
159
161
  const uint8_t _value_{params.Value};
160
162
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JBluetoothAudioSink.h RENAMED
@@ -38,10 +38,11 @@
38
38
  _module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothAudio::Sink::AssignParamsData, void>(_T("sink::assign"),
39
39
  [_implementation__](const JsonData::BluetoothAudio::Sink::AssignParamsData& params) -> uint32_t {
40
40
  uint32_t _errorCode__ = Core::ERROR_NONE;
41
41
 
42
42
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
43
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSink"), _T("sink::assign")));
43
44
  _errorCode__ = Core::ERROR_BAD_REQUEST;
44
45
  }
45
46
  else {
46
47
  const string _address_{params.Address};
47
48
 
@@ -125,10 +126,11 @@
125
126
  }
126
127
  }
127
128
  else {
128
129
 
129
130
  if (params.IsDataValid() == false) {
131
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSink"), _T("sink::latency")));
130
132
  _errorCode__ = Core::ERROR_BAD_REQUEST;
131
133
  }
132
134
  else {
133
135
  const int16_t _value_{params.Value};
134
136
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JBluetoothControl.h RENAMED
@@ -46,10 +46,11 @@
46
46
  _module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::SetDiscoverableParamsData, void>(_T("setdiscoverable"),
47
47
  [_implementation__](const JsonData::BluetoothControl::SetDiscoverableParamsData& params) -> uint32_t {
48
48
  uint32_t _errorCode__ = Core::ERROR_NONE;
49
49
 
50
50
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
51
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("setdiscoverable")));
51
52
  _errorCode__ = Core::ERROR_BAD_REQUEST;
52
53
  }
53
54
  else {
54
55
  const Exchange::JSONRPC::IBluetoothControl::scantype _type_{params.Type};
55
56
  const Core::OptionalType<Exchange::JSONRPC::IBluetoothControl::scanmode> _mode_{params.Mode};
@@ -67,10 +68,11 @@
67
68
  _module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::StopDiscoverableParamsInfo, void>(_T("stopdiscoverable"),
68
69
  [_implementation__](const JsonData::BluetoothControl::StopDiscoverableParamsInfo& params) -> uint32_t {
69
70
  uint32_t _errorCode__ = Core::ERROR_NONE;
70
71
 
71
72
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
73
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("stopdiscoverable")));
72
74
  _errorCode__ = Core::ERROR_BAD_REQUEST;
73
75
  }
74
76
  else {
75
77
  const Exchange::JSONRPC::IBluetoothControl::scantype _type_{params.Type};
76
78
 
@@ -85,10 +87,11 @@
85
87
  _module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ScanParamsData, void>(_T("scan"),
86
88
  [_implementation__](const JsonData::BluetoothControl::ScanParamsData& params) -> uint32_t {
87
89
  uint32_t _errorCode__ = Core::ERROR_NONE;
88
90
 
89
91
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
92
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("scan")));
90
93
  _errorCode__ = Core::ERROR_BAD_REQUEST;
91
94
  }
92
95
  else {
93
96
  const Exchange::JSONRPC::IBluetoothControl::scantype _type_{params.Type};
94
97
  const Core::OptionalType<Exchange::JSONRPC::IBluetoothControl::scanmode> _mode_{params.Mode};
@@ -105,10 +108,11 @@
105
108
  _module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::StopDiscoverableParamsInfo, void>(_T("stopscanning"),
106
109
  [_implementation__](const JsonData::BluetoothControl::StopDiscoverableParamsInfo& params) -> uint32_t {
107
110
  uint32_t _errorCode__ = Core::ERROR_NONE;
108
111
 
109
112
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
113
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("stopscanning")));
110
114
  _errorCode__ = Core::ERROR_BAD_REQUEST;
111
115
  }
112
116
  else {
113
117
  const Exchange::JSONRPC::IBluetoothControl::scantype _type_{params.Type};
114
118
 
@@ -123,10 +127,11 @@
123
127
  _module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ConnectParamsInfo, void>(_T("connect"),
124
128
  [_implementation__](const JsonData::BluetoothControl::ConnectParamsInfo& params) -> uint32_t {
125
129
  uint32_t _errorCode__ = Core::ERROR_NONE;
126
130
 
127
131
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
132
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("connect")));
128
133
  _errorCode__ = Core::ERROR_BAD_REQUEST;
129
134
  }
130
135
  else {
131
136
  const string _address_{params.Address};
132
137
  const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
@@ -142,10 +147,11 @@
142
147
  _module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ConnectParamsInfo, void>(_T("disconnect"),
143
148
  [_implementation__](const JsonData::BluetoothControl::ConnectParamsInfo& params) -> uint32_t {
144
149
  uint32_t _errorCode__ = Core::ERROR_NONE;
145
150
 
146
151
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
152
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("disconnect")));
147
153
  _errorCode__ = Core::ERROR_BAD_REQUEST;
148
154
  }
149
155
  else {
150
156
  const string _address_{params.Address};
151
157
  const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
@@ -161,10 +167,11 @@
161
167
  _module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::PairParamsData, void>(_T("pair"),
162
168
  [_implementation__](const JsonData::BluetoothControl::PairParamsData& params) -> uint32_t {
163
169
  uint32_t _errorCode__ = Core::ERROR_NONE;
164
170
 
165
171
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
172
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("pair")));
166
173
  _errorCode__ = Core::ERROR_BAD_REQUEST;
167
174
  }
168
175
  else {
169
176
  const string _address_{params.Address};
170
177
  const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
@@ -182,10 +189,11 @@
182
189
  _module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ConnectParamsInfo, void>(_T("unpair"),
183
190
  [_implementation__](const JsonData::BluetoothControl::ConnectParamsInfo& params) -> uint32_t {
184
191
  uint32_t _errorCode__ = Core::ERROR_NONE;
185
192
 
186
193
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
194
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("unpair")));
187
195
  _errorCode__ = Core::ERROR_BAD_REQUEST;
188
196
  }
189
197
  else {
190
198
  const string _address_{params.Address};
191
199
  const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
@@ -201,10 +209,11 @@
201
209
  _module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ConnectParamsInfo, void>(_T("abortpairing"),
202
210
  [_implementation__](const JsonData::BluetoothControl::ConnectParamsInfo& params) -> uint32_t {
203
211
  uint32_t _errorCode__ = Core::ERROR_NONE;
204
212
 
205
213
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
214
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("abortpairing")));
206
215
  _errorCode__ = Core::ERROR_BAD_REQUEST;
207
216
  }
208
217
  else {
209
218
  const string _address_{params.Address};
210
219
  const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
@@ -220,10 +229,11 @@
220
229
  _module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ProvidePINCodeParamsData, void>(_T("providepincode"),
221
230
  [_implementation__](const JsonData::BluetoothControl::ProvidePINCodeParamsData& params) -> uint32_t {
222
231
  uint32_t _errorCode__ = Core::ERROR_NONE;
223
232
 
224
233
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
234
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("providepincode")));
225
235
  _errorCode__ = Core::ERROR_BAD_REQUEST;
226
236
  }
227
237
  else {
228
238
  const string _address_{params.Address};
229
239
  const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
@@ -240,10 +250,11 @@
240
250
  _module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ConfirmPasskeyParamsData, void>(_T("confirmpasskey"),
241
251
  [_implementation__](const JsonData::BluetoothControl::ConfirmPasskeyParamsData& params) -> uint32_t {
242
252
  uint32_t _errorCode__ = Core::ERROR_NONE;
243
253
 
244
254
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
255
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("confirmpasskey")));
245
256
  _errorCode__ = Core::ERROR_BAD_REQUEST;
246
257
  }
247
258
  else {
248
259
  const string _address_{params.Address};
249
260
  const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
@@ -260,10 +271,11 @@
260
271
  _module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ProvidePasskeyParamsInfo, void>(_T("providepasskey"),
261
272
  [_implementation__](const JsonData::BluetoothControl::ProvidePasskeyParamsInfo& params) -> uint32_t {
262
273
  uint32_t _errorCode__ = Core::ERROR_NONE;
263
274
 
264
275
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
276
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("providepasskey")));
265
277
  _errorCode__ = Core::ERROR_BAD_REQUEST;
266
278
  }
267
279
  else {
268
280
  const string _address_{params.Address};
269
281
  const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
@@ -280,10 +292,11 @@
280
292
  _module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ConnectParamsInfo, void>(_T("forget"),
281
293
  [_implementation__](const JsonData::BluetoothControl::ConnectParamsInfo& params) -> uint32_t {
282
294
  uint32_t _errorCode__ = Core::ERROR_NONE;
283
295
 
284
296
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
297
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("forget")));
285
298
  _errorCode__ = Core::ERROR_BAD_REQUEST;
286
299
  }
287
300
  else {
288
301
  const string _address_{params.Address};
289
302
  const Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
@@ -321,10 +334,11 @@
321
334
  _module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothControl::ConnectParamsInfo, JsonData::BluetoothControl::GetDeviceInfoResultData>(_T("getdeviceinfo"),
322
335
  [_implementation__](const JsonData::BluetoothControl::ConnectParamsInfo& params, JsonData::BluetoothControl::GetDeviceInfoResultData& result) -> uint32_t {
323
336
  uint32_t _errorCode__ = Core::ERROR_NONE;
324
337
 
325
338
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
339
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothControl"), _T("getdeviceinfo")));
326
340
  _errorCode__ = Core::ERROR_BAD_REQUEST;
327
341
  }
328
342
  else {
329
343
  string _address_{params.Address};
330
344
  Exchange::JSONRPC::IBluetoothControl::devicetype _type_{params.Type};
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JBluetoothRemoteControl.h RENAMED
@@ -42,10 +42,11 @@
42
42
  _module__.PluginHost::JSONRPC::template Register<JsonData::BluetoothRemoteControl::AssignParamsData, void>(_T("assign"),
43
43
  [_implementation__](const JsonData::BluetoothRemoteControl::AssignParamsData& params) -> uint32_t {
44
44
  uint32_t _errorCode__ = Core::ERROR_NONE;
45
45
 
46
46
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
47
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothRemoteControl"), _T("assign")));
47
48
  _errorCode__ = Core::ERROR_BAD_REQUEST;
48
49
  }
49
50
  else {
50
51
  const string _address_{params.Address};
51
52
 
@@ -134,10 +135,11 @@
134
135
  }
135
136
  }
136
137
  else {
137
138
 
138
139
  if (params.IsDataValid() == false) {
140
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBluetoothRemoteControl"), _T("voicecontrol")));
139
141
  _errorCode__ = Core::ERROR_BAD_REQUEST;
140
142
  }
141
143
  else {
142
144
  const bool _value_{params.Value};
143
145
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JBrowserCookieJar.h RENAMED
@@ -48,10 +48,11 @@
48
48
  }
49
49
  }
50
50
  else {
51
51
 
52
52
  if (params.IsDataValid() == false) {
53
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBrowserCookieJar"), _T("cookiejar")));
53
54
  _errorCode__ = Core::ERROR_BAD_REQUEST;
54
55
  }
55
56
  else {
56
57
  const Exchange::IBrowserCookieJar::Config _params_(params);
57
58
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JBrowserResources.h RENAMED
@@ -36,11 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<Core::JSON::ArrayType<Core::JSON::String>, Core::JSON::ArrayType<Core::JSON::String>>(_T("userScripts"),
37
37
  [_implementation__](const Core::JSON::ArrayType<Core::JSON::String>& params, Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if (params.IsSet() == false) {
41
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
41
+ ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _result_{};
42
42
 
43
43
  _errorCode__ = (static_cast<const IBrowserResources*>(_implementation__))->UserScripts(_result_);
44
44
 
45
45
  if (_errorCode__ == Core::ERROR_NONE) {
46
46
  result.Set(true);
@@ -51,19 +51,22 @@
51
51
  _result_->Release();
52
52
  }
53
53
  }
54
54
  }
55
55
  else {
56
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _params_{};
56
+ ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _params_{};
57
57
  std::list<string> _paramsElements_{};
58
58
  auto _paramsIterator_ = params.Elements();
59
59
  while (_paramsIterator_.Next() == true) { _paramsElements_.push_back(_paramsIterator_.Current()); }
60
- using _paramsIteratorImplType_ = ::Thunder::RPC::IteratorType<::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>;
61
- _params_ = Core::ServiceType<_paramsIteratorImplType_>::Create<::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>(std::move(_paramsElements_));
60
+ using _paramsIteratorImplType_ = ::Thunder::RPC::IteratorType<::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>>;
61
+ _params_ = Core::ServiceType<_paramsIteratorImplType_>::Create<::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>>(std::move(_paramsElements_));
62
62
  ASSERT(_params_ != nullptr);
63
63
 
64
- _errorCode__ = _implementation__->UserScripts(static_cast<::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* const&>(_params_));
64
+ _errorCode__ = _implementation__->UserScripts(static_cast<::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* const&>(_params_));
65
+ if (_params_ != nullptr) {
66
+ _params_->Release();
67
+ }
65
68
 
66
69
  result.Null(true);
67
70
  }
68
71
 
69
72
  return (_errorCode__);
@@ -73,11 +76,11 @@
73
76
  _module__.PluginHost::JSONRPC::template Register<Core::JSON::ArrayType<Core::JSON::String>, Core::JSON::ArrayType<Core::JSON::String>>(_T("userStyleSheets"),
74
77
  [_implementation__](const Core::JSON::ArrayType<Core::JSON::String>& params, Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
75
78
  uint32_t _errorCode__ = Core::ERROR_NONE;
76
79
 
77
80
  if (params.IsSet() == false) {
78
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
81
+ ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _result_{};
79
82
 
80
83
  _errorCode__ = (static_cast<const IBrowserResources*>(_implementation__))->UserStyleSheets(_result_);
81
84
 
82
85
  if (_errorCode__ == Core::ERROR_NONE) {
83
86
  result.Set(true);
@@ -88,19 +91,22 @@
88
91
  _result_->Release();
89
92
  }
90
93
  }
91
94
  }
92
95
  else {
93
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _params_{};
96
+ ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _params_{};
94
97
  std::list<string> _paramsElements_{};
95
98
  auto _paramsIterator_ = params.Elements();
96
99
  while (_paramsIterator_.Next() == true) { _paramsElements_.push_back(_paramsIterator_.Current()); }
97
- using _paramsIteratorImplType_ = ::Thunder::RPC::IteratorType<::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>;
98
- _params_ = Core::ServiceType<_paramsIteratorImplType_>::Create<::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>(std::move(_paramsElements_));
100
+ using _paramsIteratorImplType_ = ::Thunder::RPC::IteratorType<::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>>;
101
+ _params_ = Core::ServiceType<_paramsIteratorImplType_>::Create<::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>>(std::move(_paramsElements_));
99
102
  ASSERT(_params_ != nullptr);
100
103
 
101
- _errorCode__ = _implementation__->UserStyleSheets(static_cast<::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* const&>(_params_));
104
+ _errorCode__ = _implementation__->UserStyleSheets(static_cast<::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* const&>(_params_));
105
+ if (_params_ != nullptr) {
106
+ _params_->Release();
107
+ }
102
108
 
103
109
  result.Null(true);
104
110
  }
105
111
 
106
112
  return (_errorCode__);
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JBrowserScripting.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::BrowserScripting::RunJavaScriptParamsData, void>(_T("runjavascript"),
37
37
  [_implementation__](const JsonData::BrowserScripting::RunJavaScriptParamsData& params) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBrowserScripting"), _T("runjavascript")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const string _script_{params.Script};
45
46
 
@@ -54,10 +55,11 @@
54
55
  _module__.PluginHost::JSONRPC::template Register<JsonData::BrowserScripting::AddUserScriptParamsData, void>(_T("adduserscript"),
55
56
  [_implementation__](const JsonData::BrowserScripting::AddUserScriptParamsData& params) -> uint32_t {
56
57
  uint32_t _errorCode__ = Core::ERROR_NONE;
57
58
 
58
59
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
60
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JBrowserScripting"), _T("adduserscript")));
59
61
  _errorCode__ = Core::ERROR_BAD_REQUEST;
60
62
  }
61
63
  else {
62
64
  const string _script_{params.Script};
63
65
  const bool _topFrameOnly_{params.TopFrameOnly};
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JButler.h RENAMED
@@ -38,10 +38,11 @@
38
38
  _module__.PluginHost::JSONRPC::template Register<JsonData::Butler::NameParamsData, Core::JSON::String, std::function<uint32_t(const Core::JSONRPC::Context&, const JsonData::Butler::NameParamsData&, Core::JSON::String&)>>(_T("name"),
39
39
  [_implementation__, &_module__](const Core::JSONRPC::Context& context_, const JsonData::Butler::NameParamsData& params, Core::JSON::String& valuePoint) -> uint32_t {
40
40
  uint32_t _errorCode__ = Core::ERROR_NONE;
41
41
 
42
42
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
43
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JButler"), _T("name")));
43
44
  _errorCode__ = Core::ERROR_BAD_REQUEST;
44
45
  }
45
46
  else {
46
47
  const string _name_{params.Name};
47
48
  string _valuePoint_{};
@@ -63,10 +64,11 @@
63
64
  _module__.PluginHost::JSONRPC::template Register<JsonData::Butler::IdentifierParamsInfo, Core::JSON::String, std::function<uint32_t(const Core::JSONRPC::Context&, const JsonData::Butler::IdentifierParamsInfo&, Core::JSON::String&)>>(_T("identifier"),
64
65
  [_implementation__, &_module__](const Core::JSONRPC::Context& context_, const JsonData::Butler::IdentifierParamsInfo& params, Core::JSON::String& valuePoint) -> uint32_t {
65
66
  uint32_t _errorCode__ = Core::ERROR_NONE;
66
67
 
67
68
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
69
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JButler"), _T("identifier")));
68
70
  _errorCode__ = Core::ERROR_BAD_REQUEST;
69
71
  }
70
72
  else {
71
73
  const uint32_t _id_{params.Id};
72
74
  string _valuePoint_{};
@@ -88,10 +90,11 @@
88
90
  _module__.PluginHost::JSONRPC::template Register<JsonData::Butler::BranchParamsInfo, void>(_T("branch"),
89
91
  [_implementation__](const JsonData::Butler::BranchParamsInfo& params) -> uint32_t {
90
92
  uint32_t _errorCode__ = Core::ERROR_NONE;
91
93
 
92
94
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
95
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JButler"), _T("branch")));
93
96
  _errorCode__ = Core::ERROR_BAD_REQUEST;
94
97
  }
95
98
  else {
96
99
  const string _path_{params.Path};
97
100
 
@@ -106,10 +109,11 @@
106
109
  _module__.PluginHost::JSONRPC::template Register<JsonData::Butler::MoveParamsData, void>(_T("move"),
107
110
  [_implementation__](const JsonData::Butler::MoveParamsData& params) -> uint32_t {
108
111
  uint32_t _errorCode__ = Core::ERROR_NONE;
109
112
 
110
113
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
114
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JButler"), _T("move")));
111
115
  _errorCode__ = Core::ERROR_BAD_REQUEST;
112
116
  }
113
117
  else {
114
118
  const string _path_{params.Path};
115
119
  const string _newName_{params.NewName};
@@ -125,10 +129,11 @@
125
129
  _module__.PluginHost::JSONRPC::template Register<JsonData::Butler::BranchParamsInfo, void>(_T("delete"),
126
130
  [_implementation__](const JsonData::Butler::BranchParamsInfo& params) -> uint32_t {
127
131
  uint32_t _errorCode__ = Core::ERROR_NONE;
128
132
 
129
133
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
134
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JButler"), _T("delete")));
130
135
  _errorCode__ = Core::ERROR_BAD_REQUEST;
131
136
  }
132
137
  else {
133
138
  const string _path_{params.Path};
134
139
 
@@ -143,10 +148,11 @@
143
148
  _module__.PluginHost::JSONRPC::template Register<JsonData::Butler::IdentifierParamsInfo, Core::JSON::String>(_T("source"),
144
149
  [_implementation__](const JsonData::Butler::IdentifierParamsInfo& params, Core::JSON::String& callsign) -> uint32_t {
145
150
  uint32_t _errorCode__ = Core::ERROR_NONE;
146
151
 
147
152
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
153
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JButler"), _T("source")));
148
154
  _errorCode__ = Core::ERROR_BAD_REQUEST;
149
155
  }
150
156
  else {
151
157
  const uint32_t _id_{params.Id};
152
158
  string _callsign_{};
@@ -165,10 +171,11 @@
165
171
  _module__.PluginHost::JSONRPC::template Register<JsonData::Butler::LinkParamsData, void>(_T("link"),
166
172
  [_implementation__](const JsonData::Butler::LinkParamsData& params) -> uint32_t {
167
173
  uint32_t _errorCode__ = Core::ERROR_NONE;
168
174
 
169
175
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
176
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JButler"), _T("link")));
170
177
  _errorCode__ = Core::ERROR_BAD_REQUEST;
171
178
  }
172
179
  else {
173
180
  const string _name_{params.Name};
174
181
  const uint32_t _id_{params.Id};
@@ -184,10 +191,11 @@
184
191
  _module__.PluginHost::JSONRPC::template Register<JsonData::Butler::OrphansParamsData, Core::JSON::ArrayType<Core::JSON::DecUInt32>>(_T("orphans"),
185
192
  [_implementation__](const JsonData::Butler::OrphansParamsData& params, Core::JSON::ArrayType<Core::JSON::DecUInt32>& iterator) -> uint32_t {
186
193
  uint32_t _errorCode__ = Core::ERROR_NONE;
187
194
 
188
195
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
196
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JButler"), _T("orphans")));
189
197
  _errorCode__ = Core::ERROR_BAD_REQUEST;
190
198
  }
191
199
  else {
192
200
  const uint8_t _module_{params.Module};
193
201
  ::Thunder::RPC::IIteratorType<uint32_t, ::Thunder::RPC::ID_VALUEITERATOR>* _iterator_{};
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JConnectionProperties.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::ConnectionProperties::EDIDParamsData, JsonData::ConnectionProperties::EDIDResultData>(_T("edid"),
37
37
  [_implementation__](const JsonData::ConnectionProperties::EDIDParamsData& params, JsonData::ConnectionProperties::EDIDResultData& result) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JConnectionProperties"), _T("edid")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  uint16_t _length_{params.Length.Value()};
45
46
  uint8_t* _data_{};
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JContentProtection.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::ContentProtection::OpenDrmSessionParamsData, JsonData::ContentProtection::OpenDrmSessionResultData>(_T("openDrmSession"),
37
37
  [_implementation__](const JsonData::ContentProtection::OpenDrmSessionParamsData& params, JsonData::ContentProtection::OpenDrmSessionResultData& result) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JContentProtection"), _T("openDrmSession")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const string _clientId_{params.ClientId};
45
46
  const string _appId_{params.AppId};
@@ -64,10 +65,11 @@
64
65
  _module__.PluginHost::JSONRPC::template Register<JsonData::ContentProtection::SetDrmSessionStateParamsData, void>(_T("setDrmSessionState"),
65
66
  [_implementation__](const JsonData::ContentProtection::SetDrmSessionStateParamsData& params) -> uint32_t {
66
67
  uint32_t _errorCode__ = Core::ERROR_NONE;
67
68
 
68
69
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
70
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JContentProtection"), _T("setDrmSessionState")));
69
71
  _errorCode__ = Core::ERROR_BAD_REQUEST;
70
72
  }
71
73
  else {
72
74
  const string _sessionId_{params.SessionId};
73
75
  const Exchange::IContentProtection::State _sessionState_{params.SessionState};
@@ -83,10 +85,11 @@
83
85
  _module__.PluginHost::JSONRPC::template Register<JsonData::ContentProtection::UpdateDrmSessionParamsData, Core::JSON::String>(_T("updateDrmSession"),
84
86
  [_implementation__](const JsonData::ContentProtection::UpdateDrmSessionParamsData& params, Core::JSON::String& response) -> uint32_t {
85
87
  uint32_t _errorCode__ = Core::ERROR_NONE;
86
88
 
87
89
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
90
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JContentProtection"), _T("updateDrmSession")));
88
91
  _errorCode__ = Core::ERROR_BAD_REQUEST;
89
92
  }
90
93
  else {
91
94
  const string _sessionId_{params.SessionId};
92
95
  const string _licenseRequest_{params.LicenseRequest};
@@ -107,10 +110,11 @@
107
110
  _module__.PluginHost::JSONRPC::template Register<JsonData::ContentProtection::CloseDrmSessionParamsData, Core::JSON::String>(_T("closeDrmSession"),
108
111
  [_implementation__](const JsonData::ContentProtection::CloseDrmSessionParamsData& params, Core::JSON::String& response) -> uint32_t {
109
112
  uint32_t _errorCode__ = Core::ERROR_NONE;
110
113
 
111
114
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
115
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JContentProtection"), _T("closeDrmSession")));
112
116
  _errorCode__ = Core::ERROR_BAD_REQUEST;
113
117
  }
114
118
  else {
115
119
  const string _sessionId_{params.SessionId};
116
120
  string _response_{};
@@ -129,10 +133,11 @@
129
133
  _module__.PluginHost::JSONRPC::template Register<JsonData::ContentProtection::ShowWatermarkParamsData, void>(_T("showWatermark"),
130
134
  [_implementation__](const JsonData::ContentProtection::ShowWatermarkParamsData& params) -> uint32_t {
131
135
  uint32_t _errorCode__ = Core::ERROR_NONE;
132
136
 
133
137
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
138
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JContentProtection"), _T("showWatermark")));
134
139
  _errorCode__ = Core::ERROR_BAD_REQUEST;
135
140
  }
136
141
  else {
137
142
  const string _sessionId_{params.SessionId};
138
143
  const bool _show_{params.Show};
@@ -149,10 +154,11 @@
149
154
  _module__.PluginHost::JSONRPC::template Register<JsonData::ContentProtection::SetPlaybackPositionParamsData, void>(_T("setPlaybackPosition"),
150
155
  [_implementation__](const JsonData::ContentProtection::SetPlaybackPositionParamsData& params) -> uint32_t {
151
156
  uint32_t _errorCode__ = Core::ERROR_NONE;
152
157
 
153
158
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
159
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JContentProtection"), _T("setPlaybackPosition")));
154
160
  _errorCode__ = Core::ERROR_BAD_REQUEST;
155
161
  }
156
162
  else {
157
163
  const string _sessionId_{params.SessionId};
158
164
  const int32_t _speed_{params.Speed};
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JDNSServer.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::DNSServer::FindByKeyParamsData, JsonData::DNSServer::RecordInfo>(_T("findByKey"),
37
37
  [_implementation__](const JsonData::DNSServer::FindByKeyParamsData& params, JsonData::DNSServer::RecordInfo& entry) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDNSServer"), _T("findByKey")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const string _designator_{params.Designator};
45
46
  const string _key_{params.Key};
@@ -60,10 +61,11 @@
60
61
  _module__.PluginHost::JSONRPC::template Register<JsonData::DNSServer::CountByTypeParamsData, Core::JSON::DecUInt8>(_T("countByType"),
61
62
  [_implementation__](const JsonData::DNSServer::CountByTypeParamsData& params, Core::JSON::DecUInt8& index) -> uint32_t {
62
63
  uint32_t _errorCode__ = Core::ERROR_NONE;
63
64
 
64
65
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
66
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDNSServer"), _T("countByType")));
65
67
  _errorCode__ = Core::ERROR_BAD_REQUEST;
66
68
  }
67
69
  else {
68
70
  const string _designator_{params.Designator};
69
71
  const Exchange::IDNSServer::Record::type _kind_{params.Kind};
@@ -83,10 +85,11 @@
83
85
  _module__.PluginHost::JSONRPC::template Register<JsonData::DNSServer::FindByTypeParamsData, JsonData::DNSServer::RecordInfo>(_T("findByType"),
84
86
  [_implementation__](const JsonData::DNSServer::FindByTypeParamsData& params, JsonData::DNSServer::RecordInfo& entry) -> uint32_t {
85
87
  uint32_t _errorCode__ = Core::ERROR_NONE;
86
88
 
87
89
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
90
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDNSServer"), _T("findByType")));
88
91
  _errorCode__ = Core::ERROR_BAD_REQUEST;
89
92
  }
90
93
  else {
91
94
  const string _designator_{params.Designator};
92
95
  const Exchange::IDNSServer::Record::type _kind_{params.Kind};
@@ -108,10 +111,11 @@
108
111
  _module__.PluginHost::JSONRPC::template Register<JsonData::DNSServer::AddParamsData, void>(_T("add"),
109
112
  [_implementation__](const JsonData::DNSServer::AddParamsData& params) -> uint32_t {
110
113
  uint32_t _errorCode__ = Core::ERROR_NONE;
111
114
 
112
115
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
116
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDNSServer"), _T("add")));
113
117
  _errorCode__ = Core::ERROR_BAD_REQUEST;
114
118
  }
115
119
  else {
116
120
  const Exchange::IDNSServer::Record _entry_(params.Entry);
117
121
 
@@ -126,10 +130,11 @@
126
130
  _module__.PluginHost::JSONRPC::template Register<JsonData::DNSServer::RemoveParamsData, void>(_T("remove"),
127
131
  [_implementation__](const JsonData::DNSServer::RemoveParamsData& params) -> uint32_t {
128
132
  uint32_t _errorCode__ = Core::ERROR_NONE;
129
133
 
130
134
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
135
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDNSServer"), _T("remove")));
131
136
  _errorCode__ = Core::ERROR_BAD_REQUEST;
132
137
  }
133
138
  else {
134
139
  const Exchange::IDNSServer::Record _record_(params.Record);
135
140
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JDictionary.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::Dictionary::GetParamsData, Core::JSON::String>(_T("get"),
37
37
  [_implementation__](const JsonData::Dictionary::GetParamsData& params, Core::JSON::String& value) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDictionary"), _T("get")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const string _path_{params.Path};
45
46
  const string _key_{params.Key};
@@ -59,10 +60,11 @@
59
60
  _module__.PluginHost::JSONRPC::template Register<JsonData::Dictionary::SetParamsData, void>(_T("set"),
60
61
  [_implementation__](const JsonData::Dictionary::SetParamsData& params) -> uint32_t {
61
62
  uint32_t _errorCode__ = Core::ERROR_NONE;
62
63
 
63
64
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
65
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDictionary"), _T("set")));
64
66
  _errorCode__ = Core::ERROR_BAD_REQUEST;
65
67
  }
66
68
  else {
67
69
  const string _path_{params.Path};
68
70
  const string _key_{params.Key};
@@ -79,10 +81,11 @@
79
81
  _module__.PluginHost::JSONRPC::template Register<JsonData::Dictionary::PathEntriesParamsData, Core::JSON::ArrayType<JsonData::Dictionary::PathEntryData>>(_T("pathentries"),
80
82
  [_implementation__](const JsonData::Dictionary::PathEntriesParamsData& params, Core::JSON::ArrayType<JsonData::Dictionary::PathEntryData>& entries) -> uint32_t {
81
83
  uint32_t _errorCode__ = Core::ERROR_NONE;
82
84
 
83
85
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
86
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JDictionary"), _T("pathentries")));
84
87
  _errorCode__ = Core::ERROR_BAD_REQUEST;
85
88
  }
86
89
  else {
87
90
  const string _path_{params.Path};
88
91
  ::Thunder::RPC::IIteratorType<IDictionary::PathEntry, ID_DICTIONARY_ITERATOR>* _entries_{};
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JDolbyOutput.h RENAMED
@@ -77,10 +77,11 @@
77
77
  _module__.PluginHost::JSONRPC::template Register<Core::JSON::Boolean, void>(_T("dolbyatmosoutput"),
78
78
  [_implementation__](const Core::JSON::Boolean& params) -> uint32_t {
79
79
  uint32_t _errorCode__ = Core::ERROR_NONE;
80
80
 
81
81
  if (params.IsSet() == false) {
82
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JOutput"), _T("dolbyatmosoutput")));
82
83
  _errorCode__ = Core::ERROR_BAD_REQUEST;
83
84
  }
84
85
  else {
85
86
  const bool _params_{params};
86
87
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JErrorToString.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::ErrorToString::ErrorToStringParamsData, Core::JSON::String>(_T("errorToString"),
37
37
  [_implementation__](const JsonData::ErrorToString::ErrorToStringParamsData& params, Core::JSON::String& result) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JErrorToString"), _T("errorToString")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const int32_t _code_{params.Code};
45
46
  string _result_{};
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JIOConnector.h RENAMED
@@ -62,10 +62,11 @@
62
62
  }
63
63
  }
64
64
  else {
65
65
 
66
66
  if (params.IsDataValid() == false) {
67
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JIOConnector"), _T("pin")));
67
68
  _errorCode__ = Core::ERROR_BAD_REQUEST;
68
69
  }
69
70
  else {
70
71
  const int32_t _value_{params.Value};
71
72
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JMath.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::Math::AddParamsInfo, Core::JSON::DecUInt16>(_T("add"),
37
37
  [_implementation__](const JsonData::Math::AddParamsInfo& params, Core::JSON::DecUInt16& sum) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMath"), _T("add")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const uint16_t _a_{params.A};
45
46
  const uint16_t _b_{params.B};
@@ -59,10 +60,11 @@
59
60
  _module__.PluginHost::JSONRPC::template Register<JsonData::Math::AddParamsInfo, Core::JSON::DecUInt16>(_T("sub"),
60
61
  [_implementation__](const JsonData::Math::AddParamsInfo& params, Core::JSON::DecUInt16& sum) -> uint32_t {
61
62
  uint32_t _errorCode__ = Core::ERROR_NONE;
62
63
 
63
64
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
65
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMath"), _T("sub")));
64
66
  _errorCode__ = Core::ERROR_BAD_REQUEST;
65
67
  }
66
68
  else {
67
69
  const uint16_t _a_{params.A};
68
70
  const uint16_t _b_{params.B};
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JMemoryMonitor.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::MemoryMonitor::ResetStatisticsParamsData, void>(_T("resetstatistics"),
37
37
  [_implementation__](const JsonData::MemoryMonitor::ResetStatisticsParamsData& params) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMemoryMonitor"), _T("resetstatistics")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const string _callsign_{params.Callsign};
45
46
 
@@ -72,10 +73,11 @@
72
73
  }
73
74
  }
74
75
  else {
75
76
 
76
77
  if (params.IsDataValid() == false) {
78
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMemoryMonitor"), _T("restartinglimits")));
77
79
  _errorCode__ = Core::ERROR_BAD_REQUEST;
78
80
  }
79
81
  else {
80
82
  const Exchange::IMemoryMonitor::Restart _value_(params.Value);
81
83
 
@@ -93,11 +95,11 @@
93
95
  // Property: 'observables' - List of services watched by the Monitor (r/o)
94
96
  _module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::String>>(_T("observables"),
95
97
  [_implementation__](Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
96
98
  uint32_t _errorCode__ = Core::ERROR_NONE;
97
99
 
98
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
100
+ ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _result_{};
99
101
 
100
102
  _errorCode__ = _implementation__->Observables(_result_);
101
103
 
102
104
  if (_errorCode__ == Core::ERROR_NONE) {
103
105
  result.Set(true);
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JMessageControl.h RENAMED
@@ -1,126 +0,0 @@
1
- // Generated automatically from 'IMessageControl.h'. DO NOT EDIT.
2
-
3
- #pragma once
4
- #include "Module.h"
5
- #include "JsonData_MessageControl.h"
6
- #include <interfaces/IMessageControl.h>
7
-
8
- namespace Thunder {
9
-
10
- namespace Exchange {
11
-
12
- namespace JMessageControl {
13
-
14
- namespace Version {
15
-
16
- constexpr uint8_t Major = 1;
17
- constexpr uint8_t Minor = 0;
18
- constexpr uint8_t Patch = 0;
19
-
20
- } // namespace Version
21
-
22
- PUSH_WARNING(DISABLE_WARNING_UNUSED_FUNCTIONS)
23
- PUSH_WARNING(DISABLE_WARNING_DEPRECATED_USE)
24
- PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
25
-
26
- template<typename MODULE>
27
- static void Register(MODULE& _module__, IMessageControl* _implementation__)
28
- {
29
- ASSERT(_implementation__ != nullptr);
30
-
31
- _module__.PluginHost::JSONRPC::RegisterVersion(_T("JMessageControl"), Version::Major, Version::Minor, Version::Patch);
32
-
33
- // Register methods and properties...
34
-
35
- // Method: 'enable' - Enables/disables a message control
36
- _module__.PluginHost::JSONRPC::template Register<JsonData::MessageControl::ControlInfo, void>(_T("enable"),
37
- [_implementation__](const JsonData::MessageControl::ControlInfo& params) -> uint32_t {
38
- uint32_t _errorCode__ = Core::ERROR_NONE;
39
-
40
- if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
- _errorCode__ = Core::ERROR_BAD_REQUEST;
42
- }
43
- else {
44
- const Exchange::IMessageControl::messagetype _type_{params.Type};
45
- const string _category_{params.Category};
46
- const string _module_{params.Module};
47
- const bool _enabled_{params.Enabled};
48
-
49
- _errorCode__ = _implementation__->Enable(_type_, _category_, _module_, _enabled_);
50
-
51
- }
52
-
53
- return (_errorCode__);
54
- });
55
-
56
- // Property: 'modules' - Retrieves a list of current message modules (r/o)
57
- _module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::String>>(_T("modules"),
58
- [_implementation__](Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
59
- uint32_t _errorCode__ = Core::ERROR_NONE;
60
-
61
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
62
-
63
- _errorCode__ = _implementation__->Modules(_result_);
64
-
65
- if (_errorCode__ == Core::ERROR_NONE) {
66
- result.Set(true);
67
-
68
- if (_result_ != nullptr) {
69
- string _resultItem__{};
70
- while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
71
- _result_->Release();
72
- }
73
- }
74
-
75
- return (_errorCode__);
76
- });
77
-
78
- // Indexed Property: 'controls' - Retrieves a list of current message controls for a specific module (r/o)
79
- _module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<JsonData::MessageControl::ControlInfo>, std::function<uint32_t(const string&, Core::JSON::ArrayType<JsonData::MessageControl::ControlInfo>&)>>(_T("controls"),
80
- [_implementation__](const string& module, Core::JSON::ArrayType<JsonData::MessageControl::ControlInfo>& result) -> uint32_t {
81
- uint32_t _errorCode__ = Core::ERROR_NONE;
82
-
83
- if (module.empty() == true) {
84
- _errorCode__ = Core::ERROR_BAD_REQUEST;
85
- }
86
-
87
- if (_errorCode__ == Core::ERROR_NONE) {
88
- ::Thunder::RPC::IIteratorType<IMessageControl::Control, ID_MESSAGE_CONTROL_ITERATOR>* _result_{};
89
-
90
- _errorCode__ = _implementation__->Controls(module, _result_);
91
-
92
- if (_errorCode__ == Core::ERROR_NONE) {
93
- result.Set(true);
94
-
95
- if (_result_ != nullptr) {
96
- Exchange::IMessageControl::Control _resultItem__{};
97
- while (_result_->Next(_resultItem__) == true) { result.Add() = _resultItem__; }
98
- _result_->Release();
99
- }
100
- }
101
- }
102
-
103
- return (_errorCode__);
104
- });
105
-
106
- }
107
-
108
- template<typename MODULE>
109
- static void Unregister(MODULE& _module__)
110
- {
111
- // Unregister methods and properties...
112
- _module__.PluginHost::JSONRPC::Unregister(_T("enable"));
113
- _module__.PluginHost::JSONRPC::Unregister(_T("modules"));
114
- _module__.PluginHost::JSONRPC::Unregister(_T("controls"));
115
- }
116
-
117
- POP_WARNING()
118
- POP_WARNING()
119
- POP_WARNING()
120
-
121
- } // namespace JMessageControl
122
-
123
- } // namespace Exchange
124
-
125
- } // namespace Thunder
126
-
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JMessagingControl.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::MessagingControl::ControlInfo, void>(_T("enable"),
37
37
  [_implementation__](const JsonData::MessagingControl::ControlInfo& params) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMessagingControl"), _T("enable")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const Exchange::IMessagingControl::messagetype _type_{params.Type};
45
46
  const string _category_{params.Category};
@@ -56,11 +57,11 @@
56
57
  // Property: 'modules' - Retrieves a list of current message modules (r/o)
57
58
  _module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::String>>(_T("modules"),
58
59
  [_implementation__](Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
59
60
  uint32_t _errorCode__ = Core::ERROR_NONE;
60
61
 
61
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
62
+ ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _result_{};
62
63
 
63
64
  _errorCode__ = _implementation__->Modules(_result_);
64
65
 
65
66
  if (_errorCode__ == Core::ERROR_NONE) {
66
67
  result.Set(true);
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JMessenger.h RENAMED
@@ -45,27 +45,31 @@
45
45
  _module__.PluginHost::JSONRPC::template Register<JsonData::Messenger::JoinParamsData, Core::JSON::String, std::function<uint32_t(const Core::JSONRPC::Context&, const JsonData::Messenger::JoinParamsData&, Core::JSON::String&)>>(_T("join"),
46
46
  [_implementation__](const Core::JSONRPC::Context& context_, const JsonData::Messenger::JoinParamsData& params, Core::JSON::String& roomId) -> uint32_t {
47
47
  uint32_t _errorCode__ = Core::ERROR_NONE;
48
48
 
49
49
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
50
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMessenger"), _T("join")));
50
51
  _errorCode__ = Core::ERROR_BAD_REQUEST;
51
52
  }
52
53
  else {
53
54
  const string _room_{params.Room};
54
55
  const string _user_{params.User};
55
56
  const Exchange::JSONRPC::IMessenger::security _secure_{params.Secure};
56
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _acl_{};
57
+ ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _acl_{};
57
58
  std::list<string> _aclElements_{};
58
59
  auto _aclIterator_ = params.Acl.Elements();
59
60
  while (_aclIterator_.Next() == true) { _aclElements_.push_back(_aclIterator_.Current()); }
60
- using _aclIteratorImplType_ = ::Thunder::RPC::IteratorType<::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>;
61
- _acl_ = Core::ServiceType<_aclIteratorImplType_>::Create<::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>(std::move(_aclElements_));
61
+ using _aclIteratorImplType_ = ::Thunder::RPC::IteratorType<::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>>;
62
+ _acl_ = Core::ServiceType<_aclIteratorImplType_>::Create<::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>>(std::move(_aclElements_));
62
63
  ASSERT(_acl_ != nullptr);
63
64
 
64
65
  string _roomId_{};
65
66
 
66
67
  _errorCode__ = _implementation__->Join(context_, _room_, _user_, _secure_, _acl_, _roomId_);
68
+ if (_acl_ != nullptr) {
69
+ _acl_->Release();
70
+ }
67
71
 
68
72
  if (_errorCode__ == Core::ERROR_NONE) {
69
73
  roomId = _roomId_;
70
74
  }
71
75
  }
@@ -77,10 +81,11 @@
77
81
  _module__.PluginHost::JSONRPC::template Register<JsonData::Messenger::LeaveParamsData, void>(_T("leave"),
78
82
  [_implementation__](const JsonData::Messenger::LeaveParamsData& params) -> uint32_t {
79
83
  uint32_t _errorCode__ = Core::ERROR_NONE;
80
84
 
81
85
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
86
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMessenger"), _T("leave")));
82
87
  _errorCode__ = Core::ERROR_BAD_REQUEST;
83
88
  }
84
89
  else {
85
90
  const string _roomId_{params.RoomId};
86
91
 
@@ -95,10 +100,11 @@
95
100
  _module__.PluginHost::JSONRPC::template Register<JsonData::Messenger::SendParamsData, void>(_T("send"),
96
101
  [_implementation__](const JsonData::Messenger::SendParamsData& params) -> uint32_t {
97
102
  uint32_t _errorCode__ = Core::ERROR_NONE;
98
103
 
99
104
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
105
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMessenger"), _T("send")));
100
106
  _errorCode__ = Core::ERROR_BAD_REQUEST;
101
107
  }
102
108
  else {
103
109
  const string _roomId_{params.RoomId};
104
110
  const string _message_{params.Message};
@@ -208,16 +214,16 @@
208
214
  static void UserUpdate(const MODULE& module_, const string& id_, const JsonData::Messenger::UserUpdateParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
209
215
  {
210
216
  if (sendIfMethod_ == nullptr) {
211
217
  module_.Notify(_T("userupdate"), params, [&id_](const string& designator_) -> bool {
212
218
  Core::hresult _errorCode__ = Core::ERROR_NONE;
213
- const string designatorId_ = designator_.substr(0, designator_.find('.'));
219
+ const string index_ = designator_.substr(0, designator_.find('.'));
214
220
 
215
- if (designatorId_.empty() == true) {
221
+ if (index_.empty() == true) {
216
222
  _errorCode__ = Core::ERROR_BAD_REQUEST;
217
223
  }
218
- return ((_errorCode__ == Core::ERROR_NONE) && (id_ == designatorId_));
224
+ return ((_errorCode__ == Core::ERROR_NONE) && (id_ == index_));
219
225
  });
220
226
  }
221
227
  else {
222
228
  module_.Notify(_T("userupdate"), params, sendIfMethod_);
223
229
  }
@@ -228,16 +234,16 @@
228
234
  static void UserUpdate(const MODULE& module_, const string& id_, const JsonData::Messenger::UserUpdateParamsData& params, const string& client_)
229
235
  {
230
236
  module_.Notify(_T("userupdate"), params, [&id_, &client_](const string& designator_) -> bool {
231
237
  Core::hresult _errorCode__ = Core::ERROR_NONE;
232
238
  const size_t _dot = designator_.find('.');
233
- const string designatorId_ = designator_.substr(0, _dot);
239
+ const string index_ = designator_.substr(0, _dot);
234
240
 
235
- if (designatorId_.empty() == true) {
241
+ if (index_.empty() == true) {
236
242
  _errorCode__ = Core::ERROR_BAD_REQUEST;
237
243
  }
238
- return ((_errorCode__ == Core::ERROR_NONE) && ((client_.empty() == true) || (client_ == designator_.substr(_dot + 1))) && (id_ == designatorId_));
244
+ return ((_errorCode__ == Core::ERROR_NONE) && ((client_.empty() == true) || (client_ == designator_.substr(_dot + 1))) && (id_ == index_));
239
245
  });
240
246
  }
241
247
 
242
248
  // Event: 'userupdate' - Notifies of user status changes
243
249
  template<typename MODULE>
@@ -288,16 +294,16 @@
288
294
  static void Message(const MODULE& module_, const string& id_, const JsonData::Messenger::MessageParamsData& params, typename MODULE::SendIfMethod sendIfMethod_ = nullptr)
289
295
  {
290
296
  if (sendIfMethod_ == nullptr) {
291
297
  module_.Notify(_T("message"), params, [&id_](const string& designator_) -> bool {
292
298
  Core::hresult _errorCode__ = Core::ERROR_NONE;
293
- const string designatorId_ = designator_.substr(0, designator_.find('.'));
299
+ const string index_ = designator_.substr(0, designator_.find('.'));
294
300
 
295
- if (designatorId_.empty() == true) {
301
+ if (index_.empty() == true) {
296
302
  _errorCode__ = Core::ERROR_BAD_REQUEST;
297
303
  }
298
- return ((_errorCode__ == Core::ERROR_NONE) && (id_ == designatorId_));
304
+ return ((_errorCode__ == Core::ERROR_NONE) && (id_ == index_));
299
305
  });
300
306
  }
301
307
  else {
302
308
  module_.Notify(_T("message"), params, sendIfMethod_);
303
309
  }
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JNetworkControl.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::NetworkControl::FlushParamsData, void>(_T("flush"),
37
37
  [_implementation__](const JsonData::NetworkControl::FlushParamsData& params) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JNetworkControl"), _T("flush")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const string _interface_{params.Interface};
45
46
 
@@ -53,11 +54,11 @@
53
54
  // Property: 'interfaces' - Currently available interfaces (r/o)
54
55
  _module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::String>>(_T("interfaces"),
55
56
  [_implementation__](Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
56
57
  uint32_t _errorCode__ = Core::ERROR_NONE;
57
58
 
58
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
59
+ ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _result_{};
59
60
 
60
61
  _errorCode__ = _implementation__->Interfaces(_result_);
61
62
 
62
63
  if (_errorCode__ == Core::ERROR_NONE) {
63
64
  result.Set(true);
@@ -121,10 +122,11 @@
121
122
  }
122
123
  }
123
124
  else {
124
125
 
125
126
  if (params.IsDataValid() == false) {
127
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JNetworkControl"), _T("network")));
126
128
  _errorCode__ = Core::ERROR_BAD_REQUEST;
127
129
  }
128
130
  else {
129
131
  ::Thunder::RPC::IIteratorType<INetworkControl::NetworkInfo, ID_NETWORKCONTROL_NETWORK_INFO_ITERATOR>* _value_{};
130
132
  std::list<Exchange::INetworkControl::NetworkInfo> _valueElements_{};
@@ -133,10 +135,13 @@
133
135
  using _valueIteratorImplType_ = ::Thunder::RPC::IteratorType<::Thunder::RPC::IIteratorType<INetworkControl::NetworkInfo, ID_NETWORKCONTROL_NETWORK_INFO_ITERATOR>>;
134
136
  _value_ = Core::ServiceType<_valueIteratorImplType_>::Create<::Thunder::RPC::IIteratorType<INetworkControl::NetworkInfo, ID_NETWORKCONTROL_NETWORK_INFO_ITERATOR>>(std::move(_valueElements_));
135
137
  ASSERT(_value_ != nullptr);
136
138
 
137
139
  _errorCode__ = _implementation__->Network(interface, static_cast<::Thunder::RPC::IIteratorType<INetworkControl::NetworkInfo, ID_NETWORKCONTROL_NETWORK_INFO_ITERATOR>* const&>(_value_));
140
+ if (_value_ != nullptr) {
141
+ _value_->Release();
142
+ }
138
143
 
139
144
  }
140
145
 
141
146
  result.Null(true);
142
147
  }
@@ -149,11 +154,11 @@
149
154
  _module__.PluginHost::JSONRPC::template Register<JsonData::NetworkControl::DNSData, Core::JSON::ArrayType<Core::JSON::String>>(_T("dns"),
150
155
  [_implementation__](const JsonData::NetworkControl::DNSData& params, Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
151
156
  uint32_t _errorCode__ = Core::ERROR_NONE;
152
157
 
153
158
  if (params.IsSet() == false) {
154
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
159
+ ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _result_{};
155
160
 
156
161
  _errorCode__ = (static_cast<const INetworkControl*>(_implementation__))->DNS(_result_);
157
162
 
158
163
  if (_errorCode__ == Core::ERROR_NONE) {
159
164
  result.Set(true);
@@ -166,22 +171,26 @@
166
171
  }
167
172
  }
168
173
  else {
169
174
 
170
175
  if (params.IsDataValid() == false) {
176
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JNetworkControl"), _T("dns")));
171
177
  _errorCode__ = Core::ERROR_BAD_REQUEST;
172
178
  }
173
179
  else {
174
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _value_{};
180
+ ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _value_{};
175
181
  std::list<string> _valueElements_{};
176
182
  auto _valueIterator_ = params.Value.Elements();
177
183
  while (_valueIterator_.Next() == true) { _valueElements_.push_back(_valueIterator_.Current()); }
178
- using _valueIteratorImplType_ = ::Thunder::RPC::IteratorType<::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>;
179
- _value_ = Core::ServiceType<_valueIteratorImplType_>::Create<::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>(std::move(_valueElements_));
184
+ using _valueIteratorImplType_ = ::Thunder::RPC::IteratorType<::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>>;
185
+ _value_ = Core::ServiceType<_valueIteratorImplType_>::Create<::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>>(std::move(_valueElements_));
180
186
  ASSERT(_value_ != nullptr);
181
187
 
182
- _errorCode__ = _implementation__->DNS(static_cast<::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* const&>(_value_));
188
+ _errorCode__ = _implementation__->DNS(static_cast<::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* const&>(_value_));
189
+ if (_value_ != nullptr) {
190
+ _value_->Release();
191
+ }
183
192
 
184
193
  }
185
194
 
186
195
  result.Null(true);
187
196
  }
@@ -210,10 +219,11 @@
210
219
  }
211
220
  }
212
221
  else {
213
222
 
214
223
  if (params.IsDataValid() == false) {
224
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JNetworkControl"), _T("up")));
215
225
  _errorCode__ = Core::ERROR_BAD_REQUEST;
216
226
  }
217
227
  else {
218
228
  const bool _value_{params.Value};
219
229
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JNetworkTools.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::NetworkTools::PingParamsData, void>(_T("ping"),
37
37
  [_implementation__](const JsonData::NetworkTools::PingParamsData& params) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JNetworkTools"), _T("ping")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const string _destination_{params.Destination};
45
46
  const uint16_t _timeOutInSeconds_{params.TimeOutInSeconds};
@@ -56,10 +57,11 @@
56
57
  _module__.PluginHost::JSONRPC::template Register<JsonData::NetworkTools::TraceRouteParamsData, void>(_T("traceRoute"),
57
58
  [_implementation__](const JsonData::NetworkTools::TraceRouteParamsData& params) -> uint32_t {
58
59
  uint32_t _errorCode__ = Core::ERROR_NONE;
59
60
 
60
61
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
62
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JNetworkTools"), _T("traceRoute")));
61
63
  _errorCode__ = Core::ERROR_BAD_REQUEST;
62
64
  }
63
65
  else {
64
66
  const string _destination_{params.Destination};
65
67
  const uint16_t _timeOutInSeconds_{params.TimeOutInSeconds};
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JOpenCDM.h RENAMED
@@ -34,11 +34,11 @@
34
34
  // Property: 'systems' - Supported DRM systems (r/o)
35
35
  _module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::String>>(_T("systems"),
36
36
  [_implementation__](Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
37
37
  uint32_t _errorCode__ = Core::ERROR_NONE;
38
38
 
39
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
39
+ ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _result_{};
40
40
 
41
41
  _errorCode__ = _implementation__->Systems(_result_);
42
42
 
43
43
  if (_errorCode__ == Core::ERROR_NONE) {
44
44
  result.Set(true);
@@ -61,11 +61,11 @@
61
61
  if (keySystem.empty() == true) {
62
62
  _errorCode__ = Core::ERROR_BAD_REQUEST;
63
63
  }
64
64
 
65
65
  if (_errorCode__ == Core::ERROR_NONE) {
66
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
66
+ ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _result_{};
67
67
 
68
68
  _errorCode__ = _implementation__->Designators(keySystem, _result_);
69
69
 
70
70
  if (_errorCode__ == Core::ERROR_NONE) {
71
71
  result.Set(true);
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JPackageManager.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::InstallParamsData, Core::JSON::String>(_T("install"),
37
37
  [_implementation__](const JsonData::PackageManager::InstallParamsData& params, Core::JSON::String& handle) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("install")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const string _type_{params.Type};
45
46
  const string _id_{params.Id};
@@ -63,10 +64,11 @@
63
64
  _module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::UninstallParamsData, Core::JSON::String>(_T("uninstall"),
64
65
  [_implementation__](const JsonData::PackageManager::UninstallParamsData& params, Core::JSON::String& handle) -> uint32_t {
65
66
  uint32_t _errorCode__ = Core::ERROR_NONE;
66
67
 
67
68
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
69
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("uninstall")));
68
70
  _errorCode__ = Core::ERROR_BAD_REQUEST;
69
71
  }
70
72
  else {
71
73
  const string _type_{params.Type};
72
74
  const string _id_{params.Id};
@@ -88,10 +90,11 @@
88
90
  _module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::DownloadParamsData, Core::JSON::String>(_T("download"),
89
91
  [_implementation__](const JsonData::PackageManager::DownloadParamsData& params, Core::JSON::String& handle) -> uint32_t {
90
92
  uint32_t _errorCode__ = Core::ERROR_NONE;
91
93
 
92
94
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
95
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("download")));
93
96
  _errorCode__ = Core::ERROR_BAD_REQUEST;
94
97
  }
95
98
  else {
96
99
  const string _type_{params.Type};
97
100
  const string _id_{params.Id};
@@ -114,10 +117,11 @@
114
117
  _module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::ResetParamsData, void>(_T("reset"),
115
118
  [_implementation__](const JsonData::PackageManager::ResetParamsData& params) -> uint32_t {
116
119
  uint32_t _errorCode__ = Core::ERROR_NONE;
117
120
 
118
121
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
122
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("reset")));
119
123
  _errorCode__ = Core::ERROR_BAD_REQUEST;
120
124
  }
121
125
  else {
122
126
  const string _type_{params.Type};
123
127
  const string _id_{params.Id};
@@ -135,10 +139,11 @@
135
139
  _module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::GetStorageDetailsParamsInfo, JsonData::PackageManager::StorageInfoData>(_T("getStorageDetails"),
136
140
  [_implementation__](const JsonData::PackageManager::GetStorageDetailsParamsInfo& params, JsonData::PackageManager::StorageInfoData& storageinfo) -> uint32_t {
137
141
  uint32_t _errorCode__ = Core::ERROR_NONE;
138
142
 
139
143
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
144
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("getStorageDetails")));
140
145
  _errorCode__ = Core::ERROR_BAD_REQUEST;
141
146
  }
142
147
  else {
143
148
  const string _type_{params.Type};
144
149
  const string _id_{params.Id};
@@ -160,10 +165,11 @@
160
165
  _module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::SetAuxMetadataParamsData, void>(_T("setAuxMetadata"),
161
166
  [_implementation__](const JsonData::PackageManager::SetAuxMetadataParamsData& params) -> uint32_t {
162
167
  uint32_t _errorCode__ = Core::ERROR_NONE;
163
168
 
164
169
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
170
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("setAuxMetadata")));
165
171
  _errorCode__ = Core::ERROR_BAD_REQUEST;
166
172
  }
167
173
  else {
168
174
  const string _type_{params.Type};
169
175
  const string _id_{params.Id};
@@ -182,10 +188,11 @@
182
188
  _module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::ClearAuxMetadataParamsData, void>(_T("clearAuxMetadata"),
183
189
  [_implementation__](const JsonData::PackageManager::ClearAuxMetadataParamsData& params) -> uint32_t {
184
190
  uint32_t _errorCode__ = Core::ERROR_NONE;
185
191
 
186
192
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
193
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("clearAuxMetadata")));
187
194
  _errorCode__ = Core::ERROR_BAD_REQUEST;
188
195
  }
189
196
  else {
190
197
  const string _type_{params.Type};
191
198
  const string _id_{params.Id};
@@ -203,10 +210,11 @@
203
210
  _module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::GetStorageDetailsParamsInfo, JsonData::PackageManager::GetMetadataResultData>(_T("getMetadata"),
204
211
  [_implementation__](const JsonData::PackageManager::GetStorageDetailsParamsInfo& params, JsonData::PackageManager::GetMetadataResultData& result) -> uint32_t {
205
212
  uint32_t _errorCode__ = Core::ERROR_NONE;
206
213
 
207
214
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
215
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("getMetadata")));
208
216
  _errorCode__ = Core::ERROR_BAD_REQUEST;
209
217
  }
210
218
  else {
211
219
  const string _type_{params.Type};
212
220
  const string _id_{params.Id};
@@ -244,10 +252,11 @@
244
252
  _module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::CancelParamsInfo, void>(_T("cancel"),
245
253
  [_implementation__](const JsonData::PackageManager::CancelParamsInfo& params) -> uint32_t {
246
254
  uint32_t _errorCode__ = Core::ERROR_NONE;
247
255
 
248
256
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
257
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("cancel")));
249
258
  _errorCode__ = Core::ERROR_BAD_REQUEST;
250
259
  }
251
260
  else {
252
261
  const string _handle_{params.Handle};
253
262
 
@@ -262,10 +271,11 @@
262
271
  _module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::CancelParamsInfo, Core::JSON::DecUInt32>(_T("getProgress"),
263
272
  [_implementation__](const JsonData::PackageManager::CancelParamsInfo& params, Core::JSON::DecUInt32& progress) -> uint32_t {
264
273
  uint32_t _errorCode__ = Core::ERROR_NONE;
265
274
 
266
275
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
276
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("getProgress")));
267
277
  _errorCode__ = Core::ERROR_BAD_REQUEST;
268
278
  }
269
279
  else {
270
280
  const string _handle_{params.Handle};
271
281
  uint32_t _progress_{};
@@ -284,10 +294,11 @@
284
294
  _module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::GetListParamsData, Core::JSON::ArrayType<JsonData::PackageManager::PackageKeyData>>(_T("getList"),
285
295
  [_implementation__](const JsonData::PackageManager::GetListParamsData& params, Core::JSON::ArrayType<JsonData::PackageManager::PackageKeyData>& installedIds) -> uint32_t {
286
296
  uint32_t _errorCode__ = Core::ERROR_NONE;
287
297
 
288
298
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
299
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("getList")));
289
300
  _errorCode__ = Core::ERROR_BAD_REQUEST;
290
301
  }
291
302
  else {
292
303
  const string _type_{params.Type};
293
304
  const string _id_{params.Id};
@@ -316,10 +327,11 @@
316
327
  _module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::LockParamsData, Core::JSON::String>(_T("lock"),
317
328
  [_implementation__](const JsonData::PackageManager::LockParamsData& params, Core::JSON::String& handle) -> uint32_t {
318
329
  uint32_t _errorCode__ = Core::ERROR_NONE;
319
330
 
320
331
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
332
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("lock")));
321
333
  _errorCode__ = Core::ERROR_BAD_REQUEST;
322
334
  }
323
335
  else {
324
336
  const string _type_{params.Type};
325
337
  const string _id_{params.Id};
@@ -342,10 +354,11 @@
342
354
  _module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::CancelParamsInfo, void>(_T("unlock"),
343
355
  [_implementation__](const JsonData::PackageManager::CancelParamsInfo& params) -> uint32_t {
344
356
  uint32_t _errorCode__ = Core::ERROR_NONE;
345
357
 
346
358
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
359
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("unlock")));
347
360
  _errorCode__ = Core::ERROR_BAD_REQUEST;
348
361
  }
349
362
  else {
350
363
  const string _handle_{params.Handle};
351
364
 
@@ -360,10 +373,11 @@
360
373
  _module__.PluginHost::JSONRPC::template Register<JsonData::PackageManager::GetStorageDetailsParamsInfo, JsonData::PackageManager::LockInfoData>(_T("getLockInfo"),
361
374
  [_implementation__](const JsonData::PackageManager::GetStorageDetailsParamsInfo& params, JsonData::PackageManager::LockInfoData& result) -> uint32_t {
362
375
  uint32_t _errorCode__ = Core::ERROR_NONE;
363
376
 
364
377
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
378
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackageManager"), _T("getLockInfo")));
365
379
  _errorCode__ = Core::ERROR_BAD_REQUEST;
366
380
  }
367
381
  else {
368
382
  const string _type_{params.Type};
369
383
  const string _id_{params.Id};
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JPackager.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::Packager::InstallParamsData, void>(_T("install"),
37
37
  [_implementation__](const JsonData::Packager::InstallParamsData& params) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPackager"), _T("install")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const string _name_{params.Name};
45
46
  const string _version_{params.Version};
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JPower.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::Power::SetStateParamsData, void>(_T("setstate"),
37
37
  [_implementation__](const JsonData::Power::SetStateParamsData& params) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JPower"), _T("setstate")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const Exchange::IPower::PCState _state_{params.State};
45
46
  const uint32_t _waitTime_{params.WaitTime};
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JScriptEngine.h RENAMED
@@ -47,10 +47,11 @@
47
47
  }
48
48
  }
49
49
  else {
50
50
 
51
51
  if (params.IsDataValid() == false) {
52
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JScriptEngine"), _T("url")));
52
53
  _errorCode__ = Core::ERROR_BAD_REQUEST;
53
54
  }
54
55
  else {
55
56
  const string _value_{params.Value};
56
57
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JSecurityAgent.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::SecurityAgent::ValidateParamsData, Core::JSON::Boolean>(_T("validate"),
37
37
  [_implementation__](const JsonData::SecurityAgent::ValidateParamsData& params, Core::JSON::Boolean& valid) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSecurityAgent"), _T("validate")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const string _token_{params.Token};
45
46
  bool _valid_{};
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JStore2.h RENAMED
@@ -39,10 +39,11 @@
39
39
  _module__.PluginHost::JSONRPC::template Register<JsonData::Store2::SetValueParamsData, void>(_T("setValue"),
40
40
  [_implementation__](const JsonData::Store2::SetValueParamsData& params) -> uint32_t {
41
41
  uint32_t _errorCode__ = Core::ERROR_NONE;
42
42
 
43
43
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
44
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JStore2"), _T("setValue")));
44
45
  _errorCode__ = Core::ERROR_BAD_REQUEST;
45
46
  }
46
47
  else {
47
48
  const Exchange::IStore2::ScopeType _scope_{params.Scope};
48
49
  const string _ns_{params.Ns};
@@ -63,10 +64,11 @@
63
64
  _module__.PluginHost::JSONRPC::template Register<JsonData::Store2::GetValueParamsInfo, JsonData::Store2::GetValueResultData>(_T("getValue"),
64
65
  [_implementation__](const JsonData::Store2::GetValueParamsInfo& params, JsonData::Store2::GetValueResultData& result) -> uint32_t {
65
66
  uint32_t _errorCode__ = Core::ERROR_NONE;
66
67
 
67
68
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
69
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JStore2"), _T("getValue")));
68
70
  _errorCode__ = Core::ERROR_BAD_REQUEST;
69
71
  }
70
72
  else {
71
73
  const Exchange::IStore2::ScopeType _scope_{params.Scope};
72
74
  const string _ns_{params.Ns};
@@ -91,10 +93,11 @@
91
93
  _module__.PluginHost::JSONRPC::template Register<JsonData::Store2::GetValueParamsInfo, void>(_T("deleteKey"),
92
94
  [_implementation__](const JsonData::Store2::GetValueParamsInfo& params) -> uint32_t {
93
95
  uint32_t _errorCode__ = Core::ERROR_NONE;
94
96
 
95
97
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
98
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JStore2"), _T("deleteKey")));
96
99
  _errorCode__ = Core::ERROR_BAD_REQUEST;
97
100
  }
98
101
  else {
99
102
  const Exchange::IStore2::ScopeType _scope_{params.Scope};
100
103
  const string _ns_{params.Ns};
@@ -113,10 +116,11 @@
113
116
  _module__.PluginHost::JSONRPC::template Register<JsonData::Store2::DeleteNamespaceParamsData, void>(_T("deleteNamespace"),
114
117
  [_implementation__](const JsonData::Store2::DeleteNamespaceParamsData& params) -> uint32_t {
115
118
  uint32_t _errorCode__ = Core::ERROR_NONE;
116
119
 
117
120
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
121
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JStore2"), _T("deleteNamespace")));
118
122
  _errorCode__ = Core::ERROR_BAD_REQUEST;
119
123
  }
120
124
  else {
121
125
  const Exchange::IStore2::ScopeType _scope_{params.Scope};
122
126
  const string _ns_{params.Ns};
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JSubsystemControl.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::SubsystemControl::ActivateParamsData, void>(_T("activate"),
37
37
  [_implementation__](const JsonData::SubsystemControl::ActivateParamsData& params) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSubsystemControl"), _T("activate")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const PluginHost::ISubSystem::subsystem _subsystem_{params.Subsystem};
45
46
  Core::OptionalType<string> _configuration_{};
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JSystemCommands.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::SystemCommands::USBResetParamsData, void>(_T("usbreset"),
37
37
  [_implementation__](const JsonData::SystemCommands::USBResetParamsData& params) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JSystemCommands"), _T("usbreset")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const string _device_{params.Device};
45
46
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JTimeSync.h RENAMED
@@ -77,10 +77,11 @@
77
77
  }
78
78
  }
79
79
  else {
80
80
 
81
81
  if (params.IsDataValid() == false) {
82
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JTimeSync"), _T("time")));
82
83
  _errorCode__ = Core::ERROR_BAD_REQUEST;
83
84
  }
84
85
  else {
85
86
  Core::Time _value_{};
86
87
  _value_.FromISO8601(params.Value);
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JUSBHub.h RENAMED
@@ -35,11 +35,11 @@
35
35
  // Method: 'devices' - Get a string array defning al devices hooked up to this hub
36
36
  _module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::String>>(_T("devices"),
37
37
  [_implementation__](Core::JSON::ArrayType<Core::JSON::String>& iterator) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _iterator_{};
40
+ ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _iterator_{};
41
41
 
42
42
  _errorCode__ = _implementation__->Devices(_iterator_);
43
43
 
44
44
  if (_errorCode__ == Core::ERROR_NONE) {
45
45
  iterator.Set(true);
@@ -58,16 +58,17 @@
58
58
  _module__.PluginHost::JSONRPC::template Register<JsonData::USBHub::VendorDevicesParamsData, Core::JSON::ArrayType<Core::JSON::String>>(_T("vendorDevices"),
59
59
  [_implementation__](const JsonData::USBHub::VendorDevicesParamsData& params, Core::JSON::ArrayType<Core::JSON::String>& iterator) -> uint32_t {
60
60
  uint32_t _errorCode__ = Core::ERROR_NONE;
61
61
 
62
62
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
63
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JUSBHub"), _T("vendorDevices")));
63
64
  _errorCode__ = Core::ERROR_BAD_REQUEST;
64
65
  }
65
66
  else {
66
67
  const uint16_t _vendorId_{params.VendorId};
67
68
  const uint16_t _productId_{params.ProductId};
68
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _iterator_{};
69
+ ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _iterator_{};
69
70
 
70
71
  _errorCode__ = _implementation__->VendorDevices(_vendorId_, _productId_, _iterator_);
71
72
 
72
73
  if (_errorCode__ == Core::ERROR_NONE) {
73
74
  iterator.Set(true);
@@ -87,10 +88,11 @@
87
88
  _module__.PluginHost::JSONRPC::template Register<JsonData::USBHub::DeviceParamsData, JsonData::USBHub::DeviceMetadataInfo>(_T("device"),
88
89
  [_implementation__](const JsonData::USBHub::DeviceParamsData& params, JsonData::USBHub::DeviceMetadataInfo& device) -> uint32_t {
89
90
  uint32_t _errorCode__ = Core::ERROR_NONE;
90
91
 
91
92
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
93
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JUSBHub"), _T("device")));
92
94
  _errorCode__ = Core::ERROR_BAD_REQUEST;
93
95
  }
94
96
  else {
95
97
  const string _deviceName_{params.DeviceName};
96
98
  Exchange::IUSBHub::DeviceMetadata _device_{};
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JValuePointCatalog.h RENAMED
@@ -40,10 +40,11 @@
40
40
  _module__.PluginHost::JSONRPC::template Register<JsonData::ValuePoint::Catalog::ResourceParamsInfo, Core::JSON::String, std::function<uint32_t(const Core::JSONRPC::Context&, const JsonData::ValuePoint::Catalog::ResourceParamsInfo&, Core::JSON::String&)>>(_T("resource"),
41
41
  [_implementation__, &_module__](const Core::JSONRPC::Context& context_, const JsonData::ValuePoint::Catalog::ResourceParamsInfo& params, Core::JSON::String& interface) -> uint32_t {
42
42
  uint32_t _errorCode__ = Core::ERROR_NONE;
43
43
 
44
44
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
45
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JCatalog"), _T("resource")));
45
46
  _errorCode__ = Core::ERROR_BAD_REQUEST;
46
47
  }
47
48
  else {
48
49
  const uint32_t _id_{params.Id};
49
50
  string _interface_{};
@@ -250,10 +251,11 @@
250
251
  }
251
252
  }
252
253
  else {
253
254
 
254
255
  if (params.IsDataValid() == false) {
256
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JCatalog"), _T("valuePoint::value")));
255
257
  _errorCode__ = Core::ERROR_BAD_REQUEST;
256
258
  }
257
259
  else {
258
260
  IValuePoint* const _implementation__ = _module__.PluginHost::JSONRPCSupportsObjectLookup::template LookUp<IValuePoint>(instanceId_, context_);
259
261
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JWatchDog.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::WatchDog::TouchParamsData, void>(_T("touch"),
37
37
  [_implementation__](const JsonData::WatchDog::TouchParamsData& params) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JWatchDog"), _T("touch")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const string _callsign_{params.Callsign};
45
46
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JWebBrowser.h RENAMED
@@ -216,10 +216,11 @@
216
216
  _module__.PluginHost::JSONRPC::template Register<Core::JSON::String, void>(_T("bridgereply"),
217
217
  [_implementation__](const Core::JSON::String& params) -> uint32_t {
218
218
  uint32_t _errorCode__ = Core::ERROR_NONE;
219
219
 
220
220
  if (params.IsSet() == false) {
221
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JWebBrowser"), _T("bridgereply")));
221
222
  _errorCode__ = Core::ERROR_BAD_REQUEST;
222
223
  }
223
224
  else {
224
225
  const string _params_{params};
225
226
 
@@ -234,10 +235,11 @@
234
235
  _module__.PluginHost::JSONRPC::template Register<Core::JSON::String, void>(_T("bridgeevent"),
235
236
  [_implementation__](const Core::JSON::String& params) -> uint32_t {
236
237
  uint32_t _errorCode__ = Core::ERROR_NONE;
237
238
 
238
239
  if (params.IsSet() == false) {
240
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JWebBrowser"), _T("bridgeevent")));
239
241
  _errorCode__ = Core::ERROR_BAD_REQUEST;
240
242
  }
241
243
  else {
242
244
  const string _params_{params};
243
245
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JWebBrowserExt.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::WebBrowserExt::DeleteDirParamsData, void>(_T("deletedir"),
37
37
  [_implementation__](const JsonData::WebBrowserExt::DeleteDirParamsData& params) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JWebBrowserExt"), _T("deletedir")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const string _path_{params.Path};
45
46
 
@@ -56,11 +57,11 @@
56
57
  _module__.PluginHost::JSONRPC::template Register<Core::JSON::ArrayType<Core::JSON::String>, Core::JSON::ArrayType<Core::JSON::String>>(_T("languages"),
57
58
  [_implementation__](const Core::JSON::ArrayType<Core::JSON::String>& params, Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
58
59
  uint32_t _errorCode__ = Core::ERROR_NONE;
59
60
 
60
61
  if (params.IsSet() == false) {
61
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
62
+ ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _result_{};
62
63
 
63
64
  _errorCode__ = (static_cast<const IWebBrowserExt*>(_implementation__))->Languages(_result_);
64
65
 
65
66
  if (_errorCode__ == Core::ERROR_NONE) {
66
67
  result.Set(true);
@@ -71,19 +72,22 @@
71
72
  _result_->Release();
72
73
  }
73
74
  }
74
75
  }
75
76
  else {
76
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _params_{};
77
+ ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _params_{};
77
78
  std::list<string> _paramsElements_{};
78
79
  auto _paramsIterator_ = params.Elements();
79
80
  while (_paramsIterator_.Next() == true) { _paramsElements_.push_back(_paramsIterator_.Current()); }
80
- using _paramsIteratorImplType_ = ::Thunder::RPC::IteratorType<::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>;
81
- _params_ = Core::ServiceType<_paramsIteratorImplType_>::Create<::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>>(std::move(_paramsElements_));
81
+ using _paramsIteratorImplType_ = ::Thunder::RPC::IteratorType<::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>>;
82
+ _params_ = Core::ServiceType<_paramsIteratorImplType_>::Create<::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>>(std::move(_paramsElements_));
82
83
  ASSERT(_params_ != nullptr);
83
84
 
84
- _errorCode__ = _implementation__->Languages(static_cast<::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* const&>(_params_));
85
+ _errorCode__ = _implementation__->Languages(static_cast<::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* const&>(_params_));
86
+ if (_params_ != nullptr) {
87
+ _params_->Release();
88
+ }
85
89
 
86
90
  result.Null(true);
87
91
  }
88
92
 
89
93
  return (_errorCode__);
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JWifiControl.h RENAMED
@@ -56,10 +56,11 @@
56
56
  _module__.PluginHost::JSONRPC::template Register<JsonData::WifiControl::ConnectParamsInfo, void>(_T("connect"),
57
57
  [_implementation__](const JsonData::WifiControl::ConnectParamsInfo& params) -> uint32_t {
58
58
  uint32_t _errorCode__ = Core::ERROR_NONE;
59
59
 
60
60
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
61
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JWifiControl"), _T("connect")));
61
62
  _errorCode__ = Core::ERROR_BAD_REQUEST;
62
63
  }
63
64
  else {
64
65
  const string _configSSID_{params.ConfigSSID};
65
66
 
@@ -74,10 +75,11 @@
74
75
  _module__.PluginHost::JSONRPC::template Register<JsonData::WifiControl::ConnectParamsInfo, void>(_T("disconnect"),
75
76
  [_implementation__](const JsonData::WifiControl::ConnectParamsInfo& params) -> uint32_t {
76
77
  uint32_t _errorCode__ = Core::ERROR_NONE;
77
78
 
78
79
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
80
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JWifiControl"), _T("disconnect")));
79
81
  _errorCode__ = Core::ERROR_BAD_REQUEST;
80
82
  }
81
83
  else {
82
84
  const string _configSSID_{params.ConfigSSID};
83
85
 
@@ -159,11 +161,11 @@
159
161
  // Property: 'configs' - Provides configs list (r/o)
160
162
  _module__.PluginHost::JSONRPC::template Register<void, Core::JSON::ArrayType<Core::JSON::String>>(_T("configs"),
161
163
  [_implementation__](Core::JSON::ArrayType<Core::JSON::String>& result) -> uint32_t {
162
164
  uint32_t _errorCode__ = Core::ERROR_NONE;
163
165
 
164
- ::Thunder::RPC::IIteratorType<string, RPC::ID_STRINGITERATOR>* _result_{};
166
+ ::Thunder::RPC::IIteratorType<string, ::Thunder::RPC::ID_STRINGITERATOR>* _result_{};
165
167
 
166
168
  _errorCode__ = _implementation__->Configs(_result_);
167
169
 
168
170
  if (_errorCode__ == Core::ERROR_NONE) {
169
171
  result.Set(true);
@@ -200,10 +202,11 @@
200
202
  }
201
203
  }
202
204
  else {
203
205
 
204
206
  if (params.IsDataValid() == false) {
207
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JWifiControl"), _T("config")));
205
208
  _errorCode__ = Core::ERROR_BAD_REQUEST;
206
209
  }
207
210
  else {
208
211
  const Exchange::IWifiControl::ConfigInfo _value_(params.Value);
209
212
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JZigWave.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::ZigWave::BindParamsInfo, void>(_T("bind"),
37
37
  [_implementation__](const JsonData::ZigWave::BindParamsInfo& params) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JZigWave"), _T("bind")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const uint32_t _source_{params.Source};
45
46
  const uint32_t _destination_{params.Destination};
@@ -55,10 +56,11 @@
55
56
  _module__.PluginHost::JSONRPC::template Register<JsonData::ZigWave::BindParamsInfo, void>(_T("unbind"),
56
57
  [_implementation__](const JsonData::ZigWave::BindParamsInfo& params) -> uint32_t {
57
58
  uint32_t _errorCode__ = Core::ERROR_NONE;
58
59
 
59
60
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
61
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JZigWave"), _T("unbind")));
60
62
  _errorCode__ = Core::ERROR_BAD_REQUEST;
61
63
  }
62
64
  else {
63
65
  const uint32_t _source_{params.Source};
64
66
  const uint32_t _destination_{params.Destination};
@@ -117,10 +119,11 @@
117
119
  }
118
120
  }
119
121
  else {
120
122
 
121
123
  if (params.IsDataValid() == false) {
124
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JZigWave"), _T("permutable")));
122
125
  _errorCode__ = Core::ERROR_BAD_REQUEST;
123
126
  }
124
127
  else {
125
128
  const bool _value_{params.Value};
126
129
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JsonData_MessageControl.h RENAMED
@@ -1,134 +0,0 @@
1
- // C++ types for MessageControl API.
2
- // Generated automatically from 'IMessageControl.h'. DO NOT EDIT.
3
-
4
- // Note: This code is inherently not thread safe. If required, proper synchronisation must be added.
5
-
6
- #pragma once
7
-
8
- #include <core/JSON.h>
9
- #include <interfaces/IMessageControl.h>
10
-
11
- namespace Thunder {
12
-
13
- namespace JsonData {
14
-
15
- PUSH_WARNING(DISABLE_WARNING_TYPE_LIMITS)
16
-
17
- namespace MessageControl {
18
-
19
- // Common classes
20
- //
21
-
22
- class ControlInfo : public Core::JSON::Container {
23
- public:
24
- ControlInfo()
25
- : Core::JSON::Container()
26
- {
27
- _Init();
28
- }
29
-
30
- ControlInfo(const ControlInfo& _other)
31
- : Core::JSON::Container()
32
- , Type(_other.Type)
33
- , Category(_other.Category)
34
- , Module(_other.Module)
35
- , Enabled(_other.Enabled)
36
- {
37
- _Init();
38
- }
39
-
40
- ControlInfo(ControlInfo&& _other) noexcept
41
- : Core::JSON::Container()
42
- , Type(std::move(_other.Type))
43
- , Category(std::move(_other.Category))
44
- , Module(std::move(_other.Module))
45
- , Enabled(std::move(_other.Enabled))
46
- {
47
- _Init();
48
- }
49
-
50
- ControlInfo(const Exchange::IMessageControl::Control& _other)
51
- : Core::JSON::Container()
52
- {
53
- Type = _other.type;
54
- Category = _other.category;
55
- Module = _other.module;
56
- Enabled = _other.enabled;
57
- _Init();
58
- }
59
-
60
- ControlInfo& operator=(const ControlInfo& _rhs)
61
- {
62
- Type = _rhs.Type;
63
- Category = _rhs.Category;
64
- Module = _rhs.Module;
65
- Enabled = _rhs.Enabled;
66
- return (*this);
67
- }
68
-
69
- ControlInfo& operator=(ControlInfo&& _rhs) noexcept
70
- {
71
- Type = std::move(_rhs.Type);
72
- Category = std::move(_rhs.Category);
73
- Module = std::move(_rhs.Module);
74
- Enabled = std::move(_rhs.Enabled);
75
- return (*this);
76
- }
77
-
78
- ControlInfo& operator=(const Exchange::IMessageControl::Control& _rhs)
79
- {
80
- Type = _rhs.type;
81
- Category = _rhs.category;
82
- Module = _rhs.module;
83
- Enabled = _rhs.enabled;
84
- return (*this);
85
- }
86
-
87
- operator Exchange::IMessageControl::Control() const
88
- {
89
- Exchange::IMessageControl::Control _value{};
90
- _value.type = Type;
91
- _value.category = Category;
92
- _value.module = Module;
93
- _value.enabled = Enabled;
94
- return (_value);
95
- }
96
-
97
- ~ControlInfo() = default;
98
-
99
- public:
100
- bool IsDataValid() const
101
- {
102
- return ((Type.IsSet() == true) && (Category.IsSet() == true) && (Module.IsSet() == true) && (Enabled.IsSet() == true));
103
- }
104
-
105
- private:
106
- void _Init()
107
- {
108
- Add(_T("type"), &Type);
109
- Add(_T("category"), &Category);
110
- Add(_T("module"), &Module);
111
- Add(_T("enabled"), &Enabled);
112
- }
113
-
114
- public:
115
- Core::JSON::EnumType<Exchange::IMessageControl::messagetype> Type; // Type of message
116
- Core::JSON::String Category; // Name of the message category
117
- Core::JSON::String Module; // Name of the module the message is originating from
118
- Core::JSON::Boolean Enabled; // Denotes if the control is enabled (true) or disabled (false)
119
- }; // class ControlInfo
120
-
121
- // Method params/result classes
122
- //
123
-
124
- } // namespace MessageControl
125
-
126
- POP_WARNING()
127
-
128
- } // namespace JsonData
129
-
130
- // Enum conversion handlers
131
- ENUM_CONVERSION_HANDLER(Exchange::IMessageControl::messagetype)
132
-
133
- }
134
-
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/JsonEnum_MessageControl.cpp RENAMED
@@ -1,22 +0,0 @@
1
- // Enumeration code for MessageControl API.
2
- // Generated automatically from 'IMessageControl.h'.
3
-
4
- #include <core/Enumerate.h>
5
-
6
- #include "definitions.h"
7
- #include <interfaces/IMessageControl.h>
8
- #include "JsonData_MessageControl.h"
9
-
10
- namespace Thunder {
11
-
12
- ENUM_CONVERSION_BEGIN(Exchange::IMessageControl::messagetype)
13
- { Exchange::IMessageControl::messagetype::INVALID, _TXT("Invalid") },
14
- { Exchange::IMessageControl::messagetype::TRACING, _TXT("Tracing") },
15
- { Exchange::IMessageControl::messagetype::LOGGING, _TXT("Logging") },
16
- { Exchange::IMessageControl::messagetype::REPORTING, _TXT("Reporting") },
17
- { Exchange::IMessageControl::messagetype::OPERATIONAL_STREAM, _TXT("OperationalStream") },
18
- { Exchange::IMessageControl::messagetype::ASSERT, _TXT("Assert") },
19
- { Exchange::IMessageControl::messagetype::TELEMETRY, _TXT("Telemetry") },
20
- ENUM_CONVERSION_END(Exchange::IMessageControl::messagetype)
21
-
22
- }
{baseline → generated}/Debug/ThunderInterfaces/definitions/generated/json_IMessageControl.h RENAMED
@@ -1,7 +0,0 @@
1
- // IMessageControl API
2
- // Generated automatically. DO NOT EDIT.
3
-
4
- #pragma once
5
-
6
- #include "JsonData_MessageControl.h"
7
- #include "JMessageControl.h"
{baseline → generated}/Debug/ThunderInterfaces/definitions/qa_generated/JComRpc.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::ComRpc::TestBigStringParamsData, void>(_T("testbigstring"),
37
37
  [_implementation__](const JsonData::ComRpc::TestBigStringParamsData& params) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JComRpc"), _T("testbigstring")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const uint32_t _length_{params.Length};
45
46
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/qa_generated/JMemory.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::Memory::AllocateMemoryParamsData, void>(_T("allocatememory"),
37
37
  [_implementation__](const JsonData::Memory::AllocateMemoryParamsData& params) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JMemory"), _T("allocatememory")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const uint32_t _size_{params.Size};
45
46
 
{baseline → generated}/Debug/ThunderInterfaces/definitions/qa_generated/JTestTextOptions.h RENAMED
@@ -36,10 +36,11 @@
36
36
  _module__.PluginHost::JSONRPC::template Register<JsonData::TestTextOptions::TestStandardParamsInfo, void>(_T("testStandard"),
37
37
  [_implementation__](const JsonData::TestTextOptions::TestStandardParamsInfo& params) -> uint32_t {
38
38
  uint32_t _errorCode__ = Core::ERROR_NONE;
39
39
 
40
40
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
41
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JTestTextOptions"), _T("testStandard")));
41
42
  _errorCode__ = Core::ERROR_BAD_REQUEST;
42
43
  }
43
44
  else {
44
45
  const uint32_t _firstTestParam_{params.FirstTestParam};
45
46
  const uint32_t _secondTestParam_{params.SecondTestParam};
{baseline → generated}/Debug/ThunderInterfaces/definitions/qa_generated/JTestTextOptionsTestCustom.h RENAMED
@@ -38,10 +38,11 @@
38
38
  _module__.PluginHost::JSONRPC::template Register<JsonData::TestTextOptions::TestCustom::TestCustomParamsInfo, void>(_T("TESTCUSTOM"),
39
39
  [_implementation__](const JsonData::TestTextOptions::TestCustom::TestCustomParamsInfo& params) -> uint32_t {
40
40
  uint32_t _errorCode__ = Core::ERROR_NONE;
41
41
 
42
42
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
43
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JTestCustom"), _T("TESTCUSTOM")));
43
44
  _errorCode__ = Core::ERROR_BAD_REQUEST;
44
45
  }
45
46
  else {
46
47
  const uint32_t _firstTestParam_{params.FirstTestParam};
47
48
  const uint32_t _secondTestParam_{params.SecondTestParam};
{baseline → generated}/Debug/ThunderInterfaces/definitions/qa_generated/JTestTextOptionsTestKeep.h RENAMED
@@ -38,10 +38,11 @@
38
38
  _module__.PluginHost::JSONRPC::template Register<JsonData::TestTextOptions::TestKeep::TestKeePParamsData, void>(_T("TestKeeP"),
39
39
  [_implementation__](const JsonData::TestTextOptions::TestKeep::TestKeePParamsData& params) -> uint32_t {
40
40
  uint32_t _errorCode__ = Core::ERROR_NONE;
41
41
 
42
42
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
43
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JTestKeep"), _T("TestKeeP")));
43
44
  _errorCode__ = Core::ERROR_BAD_REQUEST;
44
45
  }
45
46
  else {
46
47
  const uint32_t _firstTestParaM_{params.FirstTestParaM};
47
48
  const uint32_t _secondTestParaM_{params.SecondTestParaM};
{baseline → generated}/Debug/ThunderInterfaces/definitions/qa_generated/JTestTextOptionsTestLegacy.h RENAMED
@@ -38,10 +38,11 @@
38
38
  _module__.PluginHost::JSONRPC::template Register<JsonData::TestTextOptions::TestLegacy::TestLegacyParamsInfo, void>(_T("testlegacy"),
39
39
  [_implementation__](const JsonData::TestTextOptions::TestLegacy::TestLegacyParamsInfo& params) -> uint32_t {
40
40
  uint32_t _errorCode__ = Core::ERROR_NONE;
41
41
 
42
42
  if ((params.IsSet() == false) || (params.IsDataValid() == false)) {
43
+ TRACE_GLOBAL(Trace::Error, (_T("Invalid parameters for JSON-RPC call: %s.%s"), _T("JTestLegacy"), _T("testlegacy")));
43
44
  _errorCode__ = Core::ERROR_BAD_REQUEST;
44
45
  }
45
46
  else {
46
47
  const uint32_t _firstTestParam_{params.FirstTestParam};
47
48
  const uint32_t _secondTestParam_{params.SecondTestParam};