SDRAngel  4.11.5
Developer docs for <a href="https://github.com/f4exb/sdrangel">SDRangel<\a>, an Open Source Qt5 / OpenGL 3.0+ SDR and signal analyzer frontend to various hardware.
SWGInstanceApi.cpp
Go to the documentation of this file.
1 
13 #include "SWGInstanceApi.h"
14 #include "SWGHelpers.h"
15 #include "SWGModelFactory.h"
16 
17 #include <QJsonArray>
18 #include <QJsonDocument>
19 
20 namespace SWGSDRangel {
21 
23 
25 
27  this->host = host;
28  this->basePath = basePath;
29 }
30 
31 void
33  QString fullPath;
34  fullPath.append(this->host).append(this->basePath).append("/sdrangel/ambe/devices");
35 
36 
37 
39  SWGHttpRequestInput input(fullPath, "DELETE");
40 
41 
42 
43 
44 
45  foreach(QString key, this->defaultHeaders.keys()) {
46  input.headers.insert(key, this->defaultHeaders.value(key));
47  }
48 
49  connect(worker,
51  this,
53 
54  worker->execute(&input);
55 }
56 
57 void
59  QString msg;
60  QString error_str = worker->error_str;
61  QNetworkReply::NetworkError error_type = worker->error_type;
62 
63  if (worker->error_type == QNetworkReply::NoError) {
64  msg = QString("Success! %1 bytes").arg(worker->response.length());
65  }
66  else {
67  msg = "Error: " + worker->error_str;
68  }
69 
70 
71  QString json(worker->response);
72  SWGSuccessResponse* output = static_cast<SWGSuccessResponse*>(create(json, QString("SWGSuccessResponse")));
73  worker->deleteLater();
74 
75  if (worker->error_type == QNetworkReply::NoError) {
77  } else {
78  emit instanceAMBEDevicesDeleteSignalE(output, error_type, error_str);
79  emit instanceAMBEDevicesDeleteSignalEFull(worker, error_type, error_str);
80  }
81 }
82 
83 void
85  QString fullPath;
86  fullPath.append(this->host).append(this->basePath).append("/sdrangel/ambe/devices");
87 
88 
89 
91  SWGHttpRequestInput input(fullPath, "GET");
92 
93 
94 
95 
96 
97  foreach(QString key, this->defaultHeaders.keys()) {
98  input.headers.insert(key, this->defaultHeaders.value(key));
99  }
100 
101  connect(worker,
103  this,
105 
106  worker->execute(&input);
107 }
108 
109 void
111  QString msg;
112  QString error_str = worker->error_str;
113  QNetworkReply::NetworkError error_type = worker->error_type;
114 
115  if (worker->error_type == QNetworkReply::NoError) {
116  msg = QString("Success! %1 bytes").arg(worker->response.length());
117  }
118  else {
119  msg = "Error: " + worker->error_str;
120  }
121 
122 
123  QString json(worker->response);
124  SWGAMBEDevices* output = static_cast<SWGAMBEDevices*>(create(json, QString("SWGAMBEDevices")));
125  worker->deleteLater();
126 
127  if (worker->error_type == QNetworkReply::NoError) {
128  emit instanceAMBEDevicesGetSignal(output);
129  } else {
130  emit instanceAMBEDevicesGetSignalE(output, error_type, error_str);
131  emit instanceAMBEDevicesGetSignalEFull(worker, error_type, error_str);
132  }
133 }
134 
135 void
137  QString fullPath;
138  fullPath.append(this->host).append(this->basePath).append("/sdrangel/ambe/devices");
139 
140 
141 
143  SWGHttpRequestInput input(fullPath, "PATCH");
144 
145 
146 
147  QString output = body.asJson();
148  input.request_body.append(output);
149 
150 
151 
152  foreach(QString key, this->defaultHeaders.keys()) {
153  input.headers.insert(key, this->defaultHeaders.value(key));
154  }
155 
156  connect(worker,
158  this,
160 
161  worker->execute(&input);
162 }
163 
164 void
166  QString msg;
167  QString error_str = worker->error_str;
168  QNetworkReply::NetworkError error_type = worker->error_type;
169 
170  if (worker->error_type == QNetworkReply::NoError) {
171  msg = QString("Success! %1 bytes").arg(worker->response.length());
172  }
173  else {
174  msg = "Error: " + worker->error_str;
175  }
176 
177 
178  QString json(worker->response);
179  SWGAMBEDevices* output = static_cast<SWGAMBEDevices*>(create(json, QString("SWGAMBEDevices")));
180  worker->deleteLater();
181 
182  if (worker->error_type == QNetworkReply::NoError) {
183  emit instanceAMBEDevicesPatchSignal(output);
184  } else {
185  emit instanceAMBEDevicesPatchSignalE(output, error_type, error_str);
186  emit instanceAMBEDevicesPatchSignalEFull(worker, error_type, error_str);
187  }
188 }
189 
190 void
192  QString fullPath;
193  fullPath.append(this->host).append(this->basePath).append("/sdrangel/ambe/devices");
194 
195 
196 
198  SWGHttpRequestInput input(fullPath, "PUT");
199 
200 
201 
202  QString output = body.asJson();
203  input.request_body.append(output);
204 
205 
206 
207  foreach(QString key, this->defaultHeaders.keys()) {
208  input.headers.insert(key, this->defaultHeaders.value(key));
209  }
210 
211  connect(worker,
213  this,
215 
216  worker->execute(&input);
217 }
218 
219 void
221  QString msg;
222  QString error_str = worker->error_str;
223  QNetworkReply::NetworkError error_type = worker->error_type;
224 
225  if (worker->error_type == QNetworkReply::NoError) {
226  msg = QString("Success! %1 bytes").arg(worker->response.length());
227  }
228  else {
229  msg = "Error: " + worker->error_str;
230  }
231 
232 
233  QString json(worker->response);
234  SWGAMBEDevices* output = static_cast<SWGAMBEDevices*>(create(json, QString("SWGAMBEDevices")));
235  worker->deleteLater();
236 
237  if (worker->error_type == QNetworkReply::NoError) {
238  emit instanceAMBEDevicesPutSignal(output);
239  } else {
240  emit instanceAMBEDevicesPutSignalE(output, error_type, error_str);
241  emit instanceAMBEDevicesPutSignalEFull(worker, error_type, error_str);
242  }
243 }
244 
245 void
247  QString fullPath;
248  fullPath.append(this->host).append(this->basePath).append("/sdrangel/ambe/serial");
249 
250 
251 
253  SWGHttpRequestInput input(fullPath, "GET");
254 
255 
256 
257 
258 
259  foreach(QString key, this->defaultHeaders.keys()) {
260  input.headers.insert(key, this->defaultHeaders.value(key));
261  }
262 
263  connect(worker,
265  this,
267 
268  worker->execute(&input);
269 }
270 
271 void
273  QString msg;
274  QString error_str = worker->error_str;
275  QNetworkReply::NetworkError error_type = worker->error_type;
276 
277  if (worker->error_type == QNetworkReply::NoError) {
278  msg = QString("Success! %1 bytes").arg(worker->response.length());
279  }
280  else {
281  msg = "Error: " + worker->error_str;
282  }
283 
284 
285  QString json(worker->response);
286  SWGDVSerialDevices* output = static_cast<SWGDVSerialDevices*>(create(json, QString("SWGDVSerialDevices")));
287  worker->deleteLater();
288 
289  if (worker->error_type == QNetworkReply::NoError) {
290  emit instanceAMBESerialGetSignal(output);
291  } else {
292  emit instanceAMBESerialGetSignalE(output, error_type, error_str);
293  emit instanceAMBESerialGetSignalEFull(worker, error_type, error_str);
294  }
295 }
296 
297 void
299  QString fullPath;
300  fullPath.append(this->host).append(this->basePath).append("/sdrangel/audio");
301 
302 
303 
305  SWGHttpRequestInput input(fullPath, "GET");
306 
307 
308 
309 
310 
311  foreach(QString key, this->defaultHeaders.keys()) {
312  input.headers.insert(key, this->defaultHeaders.value(key));
313  }
314 
315  connect(worker,
317  this,
319 
320  worker->execute(&input);
321 }
322 
323 void
325  QString msg;
326  QString error_str = worker->error_str;
327  QNetworkReply::NetworkError error_type = worker->error_type;
328 
329  if (worker->error_type == QNetworkReply::NoError) {
330  msg = QString("Success! %1 bytes").arg(worker->response.length());
331  }
332  else {
333  msg = "Error: " + worker->error_str;
334  }
335 
336 
337  QString json(worker->response);
338  SWGAudioDevices* output = static_cast<SWGAudioDevices*>(create(json, QString("SWGAudioDevices")));
339  worker->deleteLater();
340 
341  if (worker->error_type == QNetworkReply::NoError) {
342  emit instanceAudioGetSignal(output);
343  } else {
344  emit instanceAudioGetSignalE(output, error_type, error_str);
345  emit instanceAudioGetSignalEFull(worker, error_type, error_str);
346  }
347 }
348 
349 void
351  QString fullPath;
352  fullPath.append(this->host).append(this->basePath).append("/sdrangel/audio/input/cleanup");
353 
354 
355 
357  SWGHttpRequestInput input(fullPath, "PATCH");
358 
359 
360 
361 
362 
363  foreach(QString key, this->defaultHeaders.keys()) {
364  input.headers.insert(key, this->defaultHeaders.value(key));
365  }
366 
367  connect(worker,
369  this,
371 
372  worker->execute(&input);
373 }
374 
375 void
377  QString msg;
378  QString error_str = worker->error_str;
379  QNetworkReply::NetworkError error_type = worker->error_type;
380 
381  if (worker->error_type == QNetworkReply::NoError) {
382  msg = QString("Success! %1 bytes").arg(worker->response.length());
383  }
384  else {
385  msg = "Error: " + worker->error_str;
386  }
387 
388 
389  QString json(worker->response);
390  SWGSuccessResponse* output = static_cast<SWGSuccessResponse*>(create(json, QString("SWGSuccessResponse")));
391  worker->deleteLater();
392 
393  if (worker->error_type == QNetworkReply::NoError) {
395  } else {
396  emit instanceAudioInputCleanupPatchSignalE(output, error_type, error_str);
397  emit instanceAudioInputCleanupPatchSignalEFull(worker, error_type, error_str);
398  }
399 }
400 
401 void
403  QString fullPath;
404  fullPath.append(this->host).append(this->basePath).append("/sdrangel/audio/input/parameters");
405 
406 
407 
409  SWGHttpRequestInput input(fullPath, "DELETE");
410 
411 
412 
413  QString output = body.asJson();
414  input.request_body.append(output);
415 
416 
417 
418  foreach(QString key, this->defaultHeaders.keys()) {
419  input.headers.insert(key, this->defaultHeaders.value(key));
420  }
421 
422  connect(worker,
424  this,
426 
427  worker->execute(&input);
428 }
429 
430 void
432  QString msg;
433  QString error_str = worker->error_str;
434  QNetworkReply::NetworkError error_type = worker->error_type;
435 
436  if (worker->error_type == QNetworkReply::NoError) {
437  msg = QString("Success! %1 bytes").arg(worker->response.length());
438  }
439  else {
440  msg = "Error: " + worker->error_str;
441  }
442 
443 
444  QString json(worker->response);
445  SWGAudioInputDevice* output = static_cast<SWGAudioInputDevice*>(create(json, QString("SWGAudioInputDevice")));
446  worker->deleteLater();
447 
448  if (worker->error_type == QNetworkReply::NoError) {
449  emit instanceAudioInputDeleteSignal(output);
450  } else {
451  emit instanceAudioInputDeleteSignalE(output, error_type, error_str);
452  emit instanceAudioInputDeleteSignalEFull(worker, error_type, error_str);
453  }
454 }
455 
456 void
458  QString fullPath;
459  fullPath.append(this->host).append(this->basePath).append("/sdrangel/audio/input/parameters");
460 
461 
462 
464  SWGHttpRequestInput input(fullPath, "PATCH");
465 
466 
467 
468  QString output = body.asJson();
469  input.request_body.append(output);
470 
471 
472 
473  foreach(QString key, this->defaultHeaders.keys()) {
474  input.headers.insert(key, this->defaultHeaders.value(key));
475  }
476 
477  connect(worker,
479  this,
481 
482  worker->execute(&input);
483 }
484 
485 void
487  QString msg;
488  QString error_str = worker->error_str;
489  QNetworkReply::NetworkError error_type = worker->error_type;
490 
491  if (worker->error_type == QNetworkReply::NoError) {
492  msg = QString("Success! %1 bytes").arg(worker->response.length());
493  }
494  else {
495  msg = "Error: " + worker->error_str;
496  }
497 
498 
499  QString json(worker->response);
500  SWGAudioInputDevice* output = static_cast<SWGAudioInputDevice*>(create(json, QString("SWGAudioInputDevice")));
501  worker->deleteLater();
502 
503  if (worker->error_type == QNetworkReply::NoError) {
504  emit instanceAudioInputPatchSignal(output);
505  } else {
506  emit instanceAudioInputPatchSignalE(output, error_type, error_str);
507  emit instanceAudioInputPatchSignalEFull(worker, error_type, error_str);
508  }
509 }
510 
511 void
513  QString fullPath;
514  fullPath.append(this->host).append(this->basePath).append("/sdrangel/audio/output/cleanup");
515 
516 
517 
519  SWGHttpRequestInput input(fullPath, "PATCH");
520 
521 
522 
523 
524 
525  foreach(QString key, this->defaultHeaders.keys()) {
526  input.headers.insert(key, this->defaultHeaders.value(key));
527  }
528 
529  connect(worker,
531  this,
533 
534  worker->execute(&input);
535 }
536 
537 void
539  QString msg;
540  QString error_str = worker->error_str;
541  QNetworkReply::NetworkError error_type = worker->error_type;
542 
543  if (worker->error_type == QNetworkReply::NoError) {
544  msg = QString("Success! %1 bytes").arg(worker->response.length());
545  }
546  else {
547  msg = "Error: " + worker->error_str;
548  }
549 
550 
551  QString json(worker->response);
552  SWGSuccessResponse* output = static_cast<SWGSuccessResponse*>(create(json, QString("SWGSuccessResponse")));
553  worker->deleteLater();
554 
555  if (worker->error_type == QNetworkReply::NoError) {
557  } else {
558  emit instanceAudioOutputCleanupPatchSignalE(output, error_type, error_str);
559  emit instanceAudioOutputCleanupPatchSignalEFull(worker, error_type, error_str);
560  }
561 }
562 
563 void
565  QString fullPath;
566  fullPath.append(this->host).append(this->basePath).append("/sdrangel/audio/output/parameters");
567 
568 
569 
571  SWGHttpRequestInput input(fullPath, "DELETE");
572 
573 
574 
575  QString output = body.asJson();
576  input.request_body.append(output);
577 
578 
579 
580  foreach(QString key, this->defaultHeaders.keys()) {
581  input.headers.insert(key, this->defaultHeaders.value(key));
582  }
583 
584  connect(worker,
586  this,
588 
589  worker->execute(&input);
590 }
591 
592 void
594  QString msg;
595  QString error_str = worker->error_str;
596  QNetworkReply::NetworkError error_type = worker->error_type;
597 
598  if (worker->error_type == QNetworkReply::NoError) {
599  msg = QString("Success! %1 bytes").arg(worker->response.length());
600  }
601  else {
602  msg = "Error: " + worker->error_str;
603  }
604 
605 
606  QString json(worker->response);
607  SWGAudioOutputDevice* output = static_cast<SWGAudioOutputDevice*>(create(json, QString("SWGAudioOutputDevice")));
608  worker->deleteLater();
609 
610  if (worker->error_type == QNetworkReply::NoError) {
611  emit instanceAudioOutputDeleteSignal(output);
612  } else {
613  emit instanceAudioOutputDeleteSignalE(output, error_type, error_str);
614  emit instanceAudioOutputDeleteSignalEFull(worker, error_type, error_str);
615  }
616 }
617 
618 void
620  QString fullPath;
621  fullPath.append(this->host).append(this->basePath).append("/sdrangel/audio/output/parameters");
622 
623 
624 
626  SWGHttpRequestInput input(fullPath, "PATCH");
627 
628 
629 
630  QString output = body.asJson();
631  input.request_body.append(output);
632 
633 
634 
635  foreach(QString key, this->defaultHeaders.keys()) {
636  input.headers.insert(key, this->defaultHeaders.value(key));
637  }
638 
639  connect(worker,
641  this,
643 
644  worker->execute(&input);
645 }
646 
647 void
649  QString msg;
650  QString error_str = worker->error_str;
651  QNetworkReply::NetworkError error_type = worker->error_type;
652 
653  if (worker->error_type == QNetworkReply::NoError) {
654  msg = QString("Success! %1 bytes").arg(worker->response.length());
655  }
656  else {
657  msg = "Error: " + worker->error_str;
658  }
659 
660 
661  QString json(worker->response);
662  SWGAudioOutputDevice* output = static_cast<SWGAudioOutputDevice*>(create(json, QString("SWGAudioOutputDevice")));
663  worker->deleteLater();
664 
665  if (worker->error_type == QNetworkReply::NoError) {
666  emit instanceAudioOutputPatchSignal(output);
667  } else {
668  emit instanceAudioOutputPatchSignalE(output, error_type, error_str);
669  emit instanceAudioOutputPatchSignalEFull(worker, error_type, error_str);
670  }
671 }
672 
673 void
675  QString fullPath;
676  fullPath.append(this->host).append(this->basePath).append("/sdrangel/channels");
677 
678 
679  if (fullPath.indexOf("?") > 0)
680  fullPath.append("&");
681  else
682  fullPath.append("?");
683  fullPath.append(QUrl::toPercentEncoding("direction"))
684  .append("=")
685  .append(QUrl::toPercentEncoding(stringValue(direction)));
686 
687 
689  SWGHttpRequestInput input(fullPath, "GET");
690 
691 
692 
693 
694 
695  foreach(QString key, this->defaultHeaders.keys()) {
696  input.headers.insert(key, this->defaultHeaders.value(key));
697  }
698 
699  connect(worker,
701  this,
703 
704  worker->execute(&input);
705 }
706 
707 void
709  QString msg;
710  QString error_str = worker->error_str;
711  QNetworkReply::NetworkError error_type = worker->error_type;
712 
713  if (worker->error_type == QNetworkReply::NoError) {
714  msg = QString("Success! %1 bytes").arg(worker->response.length());
715  }
716  else {
717  msg = "Error: " + worker->error_str;
718  }
719 
720 
721  QString json(worker->response);
722  SWGInstanceChannelsResponse* output = static_cast<SWGInstanceChannelsResponse*>(create(json, QString("SWGInstanceChannelsResponse")));
723  worker->deleteLater();
724 
725  if (worker->error_type == QNetworkReply::NoError) {
726  emit instanceChannelsSignal(output);
727  } else {
728  emit instanceChannelsSignalE(output, error_type, error_str);
729  emit instanceChannelsSignalEFull(worker, error_type, error_str);
730  }
731 }
732 
733 void
735  QString fullPath;
736  fullPath.append(this->host).append(this->basePath).append("/sdrangel/config");
737 
738 
739 
741  SWGHttpRequestInput input(fullPath, "GET");
742 
743 
744 
745 
746 
747  foreach(QString key, this->defaultHeaders.keys()) {
748  input.headers.insert(key, this->defaultHeaders.value(key));
749  }
750 
751  connect(worker,
753  this,
755 
756  worker->execute(&input);
757 }
758 
759 void
761  QString msg;
762  QString error_str = worker->error_str;
763  QNetworkReply::NetworkError error_type = worker->error_type;
764 
765  if (worker->error_type == QNetworkReply::NoError) {
766  msg = QString("Success! %1 bytes").arg(worker->response.length());
767  }
768  else {
769  msg = "Error: " + worker->error_str;
770  }
771 
772 
773  QString json(worker->response);
774  SWGInstanceConfigResponse* output = static_cast<SWGInstanceConfigResponse*>(create(json, QString("SWGInstanceConfigResponse")));
775  worker->deleteLater();
776 
777  if (worker->error_type == QNetworkReply::NoError) {
778  emit instanceConfigSignal(output);
779  } else {
780  emit instanceConfigSignalE(output, error_type, error_str);
781  emit instanceConfigSignalEFull(worker, error_type, error_str);
782  }
783 }
784 
785 void
787  QString fullPath;
788  fullPath.append(this->host).append(this->basePath).append("/sdrangel");
789 
790 
791 
793  SWGHttpRequestInput input(fullPath, "DELETE");
794 
795 
796 
797 
798 
799  foreach(QString key, this->defaultHeaders.keys()) {
800  input.headers.insert(key, this->defaultHeaders.value(key));
801  }
802 
803  connect(worker,
805  this,
807 
808  worker->execute(&input);
809 }
810 
811 void
813  QString msg;
814  QString error_str = worker->error_str;
815  QNetworkReply::NetworkError error_type = worker->error_type;
816 
817  if (worker->error_type == QNetworkReply::NoError) {
818  msg = QString("Success! %1 bytes").arg(worker->response.length());
819  }
820  else {
821  msg = "Error: " + worker->error_str;
822  }
823 
824 
825  QString json(worker->response);
826  SWGInstanceSummaryResponse* output = static_cast<SWGInstanceSummaryResponse*>(create(json, QString("SWGInstanceSummaryResponse")));
827  worker->deleteLater();
828 
829  if (worker->error_type == QNetworkReply::NoError) {
830  emit instanceDeleteSignal(output);
831  } else {
832  emit instanceDeleteSignalE(output, error_type, error_str);
833  emit instanceDeleteSignalEFull(worker, error_type, error_str);
834  }
835 }
836 
837 void
839  QString fullPath;
840  fullPath.append(this->host).append(this->basePath).append("/sdrangel/devicesets");
841 
842 
843 
845  SWGHttpRequestInput input(fullPath, "GET");
846 
847 
848 
849 
850 
851  foreach(QString key, this->defaultHeaders.keys()) {
852  input.headers.insert(key, this->defaultHeaders.value(key));
853  }
854 
855  connect(worker,
857  this,
859 
860  worker->execute(&input);
861 }
862 
863 void
865  QString msg;
866  QString error_str = worker->error_str;
867  QNetworkReply::NetworkError error_type = worker->error_type;
868 
869  if (worker->error_type == QNetworkReply::NoError) {
870  msg = QString("Success! %1 bytes").arg(worker->response.length());
871  }
872  else {
873  msg = "Error: " + worker->error_str;
874  }
875 
876 
877  QString json(worker->response);
878  SWGDeviceSetList* output = static_cast<SWGDeviceSetList*>(create(json, QString("SWGDeviceSetList")));
879  worker->deleteLater();
880 
881  if (worker->error_type == QNetworkReply::NoError) {
882  emit instanceDeviceSetsGetSignal(output);
883  } else {
884  emit instanceDeviceSetsGetSignalE(output, error_type, error_str);
885  emit instanceDeviceSetsGetSignalEFull(worker, error_type, error_str);
886  }
887 }
888 
889 void
891  QString fullPath;
892  fullPath.append(this->host).append(this->basePath).append("/sdrangel/devices");
893 
894 
895  if (fullPath.indexOf("?") > 0)
896  fullPath.append("&");
897  else
898  fullPath.append("?");
899  fullPath.append(QUrl::toPercentEncoding("direction"))
900  .append("=")
901  .append(QUrl::toPercentEncoding(stringValue(direction)));
902 
903 
905  SWGHttpRequestInput input(fullPath, "GET");
906 
907 
908 
909 
910 
911  foreach(QString key, this->defaultHeaders.keys()) {
912  input.headers.insert(key, this->defaultHeaders.value(key));
913  }
914 
915  connect(worker,
917  this,
919 
920  worker->execute(&input);
921 }
922 
923 void
925  QString msg;
926  QString error_str = worker->error_str;
927  QNetworkReply::NetworkError error_type = worker->error_type;
928 
929  if (worker->error_type == QNetworkReply::NoError) {
930  msg = QString("Success! %1 bytes").arg(worker->response.length());
931  }
932  else {
933  msg = "Error: " + worker->error_str;
934  }
935 
936 
937  QString json(worker->response);
938  SWGInstanceDevicesResponse* output = static_cast<SWGInstanceDevicesResponse*>(create(json, QString("SWGInstanceDevicesResponse")));
939  worker->deleteLater();
940 
941  if (worker->error_type == QNetworkReply::NoError) {
942  emit instanceDevicesSignal(output);
943  } else {
944  emit instanceDevicesSignalE(output, error_type, error_str);
945  emit instanceDevicesSignalEFull(worker, error_type, error_str);
946  }
947 }
948 
949 void
951  QString fullPath;
952  fullPath.append(this->host).append(this->basePath).append("/sdrangel/location");
953 
954 
955 
957  SWGHttpRequestInput input(fullPath, "GET");
958 
959 
960 
961 
962 
963  foreach(QString key, this->defaultHeaders.keys()) {
964  input.headers.insert(key, this->defaultHeaders.value(key));
965  }
966 
967  connect(worker,
969  this,
971 
972  worker->execute(&input);
973 }
974 
975 void
977  QString msg;
978  QString error_str = worker->error_str;
979  QNetworkReply::NetworkError error_type = worker->error_type;
980 
981  if (worker->error_type == QNetworkReply::NoError) {
982  msg = QString("Success! %1 bytes").arg(worker->response.length());
983  }
984  else {
985  msg = "Error: " + worker->error_str;
986  }
987 
988 
989  QString json(worker->response);
990  SWGLocationInformation* output = static_cast<SWGLocationInformation*>(create(json, QString("SWGLocationInformation")));
991  worker->deleteLater();
992 
993  if (worker->error_type == QNetworkReply::NoError) {
994  emit instanceLocationGetSignal(output);
995  } else {
996  emit instanceLocationGetSignalE(output, error_type, error_str);
997  emit instanceLocationGetSignalEFull(worker, error_type, error_str);
998  }
999 }
1000 
1001 void
1003  QString fullPath;
1004  fullPath.append(this->host).append(this->basePath).append("/sdrangel/location");
1005 
1006 
1007 
1009  SWGHttpRequestInput input(fullPath, "PUT");
1010 
1011 
1012 
1013  QString output = body.asJson();
1014  input.request_body.append(output);
1015 
1016 
1017 
1018  foreach(QString key, this->defaultHeaders.keys()) {
1019  input.headers.insert(key, this->defaultHeaders.value(key));
1020  }
1021 
1022  connect(worker,
1024  this,
1026 
1027  worker->execute(&input);
1028 }
1029 
1030 void
1032  QString msg;
1033  QString error_str = worker->error_str;
1034  QNetworkReply::NetworkError error_type = worker->error_type;
1035 
1036  if (worker->error_type == QNetworkReply::NoError) {
1037  msg = QString("Success! %1 bytes").arg(worker->response.length());
1038  }
1039  else {
1040  msg = "Error: " + worker->error_str;
1041  }
1042 
1043 
1044  QString json(worker->response);
1045  SWGLocationInformation* output = static_cast<SWGLocationInformation*>(create(json, QString("SWGLocationInformation")));
1046  worker->deleteLater();
1047 
1048  if (worker->error_type == QNetworkReply::NoError) {
1049  emit instanceLocationPutSignal(output);
1050  } else {
1051  emit instanceLocationPutSignalE(output, error_type, error_str);
1052  emit instanceLocationPutSignalEFull(worker, error_type, error_str);
1053  }
1054 }
1055 
1056 void
1058  QString fullPath;
1059  fullPath.append(this->host).append(this->basePath).append("/sdrangel/logging");
1060 
1061 
1062 
1064  SWGHttpRequestInput input(fullPath, "GET");
1065 
1066 
1067 
1068 
1069 
1070  foreach(QString key, this->defaultHeaders.keys()) {
1071  input.headers.insert(key, this->defaultHeaders.value(key));
1072  }
1073 
1074  connect(worker,
1076  this,
1078 
1079  worker->execute(&input);
1080 }
1081 
1082 void
1084  QString msg;
1085  QString error_str = worker->error_str;
1086  QNetworkReply::NetworkError error_type = worker->error_type;
1087 
1088  if (worker->error_type == QNetworkReply::NoError) {
1089  msg = QString("Success! %1 bytes").arg(worker->response.length());
1090  }
1091  else {
1092  msg = "Error: " + worker->error_str;
1093  }
1094 
1095 
1096  QString json(worker->response);
1097  SWGLoggingInfo* output = static_cast<SWGLoggingInfo*>(create(json, QString("SWGLoggingInfo")));
1098  worker->deleteLater();
1099 
1100  if (worker->error_type == QNetworkReply::NoError) {
1101  emit instanceLoggingGetSignal(output);
1102  } else {
1103  emit instanceLoggingGetSignalE(output, error_type, error_str);
1104  emit instanceLoggingGetSignalEFull(worker, error_type, error_str);
1105  }
1106 }
1107 
1108 void
1110  QString fullPath;
1111  fullPath.append(this->host).append(this->basePath).append("/sdrangel/logging");
1112 
1113 
1114 
1116  SWGHttpRequestInput input(fullPath, "PUT");
1117 
1118 
1119 
1120  QString output = body.asJson();
1121  input.request_body.append(output);
1122 
1123 
1124 
1125  foreach(QString key, this->defaultHeaders.keys()) {
1126  input.headers.insert(key, this->defaultHeaders.value(key));
1127  }
1128 
1129  connect(worker,
1131  this,
1133 
1134  worker->execute(&input);
1135 }
1136 
1137 void
1139  QString msg;
1140  QString error_str = worker->error_str;
1141  QNetworkReply::NetworkError error_type = worker->error_type;
1142 
1143  if (worker->error_type == QNetworkReply::NoError) {
1144  msg = QString("Success! %1 bytes").arg(worker->response.length());
1145  }
1146  else {
1147  msg = "Error: " + worker->error_str;
1148  }
1149 
1150 
1151  QString json(worker->response);
1152  SWGLoggingInfo* output = static_cast<SWGLoggingInfo*>(create(json, QString("SWGLoggingInfo")));
1153  worker->deleteLater();
1154 
1155  if (worker->error_type == QNetworkReply::NoError) {
1156  emit instanceLoggingPutSignal(output);
1157  } else {
1158  emit instanceLoggingPutSignalE(output, error_type, error_str);
1159  emit instanceLoggingPutSignalEFull(worker, error_type, error_str);
1160  }
1161 }
1162 
1163 void
1165  QString fullPath;
1166  fullPath.append(this->host).append(this->basePath).append("/sdrangel/preset");
1167 
1168 
1169 
1171  SWGHttpRequestInput input(fullPath, "DELETE");
1172 
1173 
1174 
1175  QString output = body.asJson();
1176  input.request_body.append(output);
1177 
1178 
1179 
1180  foreach(QString key, this->defaultHeaders.keys()) {
1181  input.headers.insert(key, this->defaultHeaders.value(key));
1182  }
1183 
1184  connect(worker,
1186  this,
1188 
1189  worker->execute(&input);
1190 }
1191 
1192 void
1194  QString msg;
1195  QString error_str = worker->error_str;
1196  QNetworkReply::NetworkError error_type = worker->error_type;
1197 
1198  if (worker->error_type == QNetworkReply::NoError) {
1199  msg = QString("Success! %1 bytes").arg(worker->response.length());
1200  }
1201  else {
1202  msg = "Error: " + worker->error_str;
1203  }
1204 
1205 
1206  QString json(worker->response);
1207  SWGPresetIdentifier* output = static_cast<SWGPresetIdentifier*>(create(json, QString("SWGPresetIdentifier")));
1208  worker->deleteLater();
1209 
1210  if (worker->error_type == QNetworkReply::NoError) {
1211  emit instancePresetDeleteSignal(output);
1212  } else {
1213  emit instancePresetDeleteSignalE(output, error_type, error_str);
1214  emit instancePresetDeleteSignalEFull(worker, error_type, error_str);
1215  }
1216 }
1217 
1218 void
1220  QString fullPath;
1221  fullPath.append(this->host).append(this->basePath).append("/sdrangel/preset/file");
1222 
1223 
1224 
1226  SWGHttpRequestInput input(fullPath, "POST");
1227 
1228 
1229 
1230  QString output = body.asJson();
1231  input.request_body.append(output);
1232 
1233 
1234 
1235  foreach(QString key, this->defaultHeaders.keys()) {
1236  input.headers.insert(key, this->defaultHeaders.value(key));
1237  }
1238 
1239  connect(worker,
1241  this,
1243 
1244  worker->execute(&input);
1245 }
1246 
1247 void
1249  QString msg;
1250  QString error_str = worker->error_str;
1251  QNetworkReply::NetworkError error_type = worker->error_type;
1252 
1253  if (worker->error_type == QNetworkReply::NoError) {
1254  msg = QString("Success! %1 bytes").arg(worker->response.length());
1255  }
1256  else {
1257  msg = "Error: " + worker->error_str;
1258  }
1259 
1260 
1261  QString json(worker->response);
1262  SWGPresetIdentifier* output = static_cast<SWGPresetIdentifier*>(create(json, QString("SWGPresetIdentifier")));
1263  worker->deleteLater();
1264 
1265  if (worker->error_type == QNetworkReply::NoError) {
1266  emit instancePresetFilePostSignal(output);
1267  } else {
1268  emit instancePresetFilePostSignalE(output, error_type, error_str);
1269  emit instancePresetFilePostSignalEFull(worker, error_type, error_str);
1270  }
1271 }
1272 
1273 void
1275  QString fullPath;
1276  fullPath.append(this->host).append(this->basePath).append("/sdrangel/preset/file");
1277 
1278 
1279 
1281  SWGHttpRequestInput input(fullPath, "PUT");
1282 
1283 
1284 
1285  QString output = body.asJson();
1286  input.request_body.append(output);
1287 
1288 
1289 
1290  foreach(QString key, this->defaultHeaders.keys()) {
1291  input.headers.insert(key, this->defaultHeaders.value(key));
1292  }
1293 
1294  connect(worker,
1296  this,
1298 
1299  worker->execute(&input);
1300 }
1301 
1302 void
1304  QString msg;
1305  QString error_str = worker->error_str;
1306  QNetworkReply::NetworkError error_type = worker->error_type;
1307 
1308  if (worker->error_type == QNetworkReply::NoError) {
1309  msg = QString("Success! %1 bytes").arg(worker->response.length());
1310  }
1311  else {
1312  msg = "Error: " + worker->error_str;
1313  }
1314 
1315 
1316  QString json(worker->response);
1317  SWGPresetIdentifier* output = static_cast<SWGPresetIdentifier*>(create(json, QString("SWGPresetIdentifier")));
1318  worker->deleteLater();
1319 
1320  if (worker->error_type == QNetworkReply::NoError) {
1321  emit instancePresetFilePutSignal(output);
1322  } else {
1323  emit instancePresetFilePutSignalE(output, error_type, error_str);
1324  emit instancePresetFilePutSignalEFull(worker, error_type, error_str);
1325  }
1326 }
1327 
1328 void
1330  QString fullPath;
1331  fullPath.append(this->host).append(this->basePath).append("/sdrangel/presets");
1332 
1333 
1334 
1336  SWGHttpRequestInput input(fullPath, "GET");
1337 
1338 
1339 
1340 
1341 
1342  foreach(QString key, this->defaultHeaders.keys()) {
1343  input.headers.insert(key, this->defaultHeaders.value(key));
1344  }
1345 
1346  connect(worker,
1348  this,
1350 
1351  worker->execute(&input);
1352 }
1353 
1354 void
1356  QString msg;
1357  QString error_str = worker->error_str;
1358  QNetworkReply::NetworkError error_type = worker->error_type;
1359 
1360  if (worker->error_type == QNetworkReply::NoError) {
1361  msg = QString("Success! %1 bytes").arg(worker->response.length());
1362  }
1363  else {
1364  msg = "Error: " + worker->error_str;
1365  }
1366 
1367 
1368  QString json(worker->response);
1369  SWGPresets* output = static_cast<SWGPresets*>(create(json, QString("SWGPresets")));
1370  worker->deleteLater();
1371 
1372  if (worker->error_type == QNetworkReply::NoError) {
1373  emit instancePresetGetSignal(output);
1374  } else {
1375  emit instancePresetGetSignalE(output, error_type, error_str);
1376  emit instancePresetGetSignalEFull(worker, error_type, error_str);
1377  }
1378 }
1379 
1380 void
1382  QString fullPath;
1383  fullPath.append(this->host).append(this->basePath).append("/sdrangel/preset");
1384 
1385 
1386 
1388  SWGHttpRequestInput input(fullPath, "PATCH");
1389 
1390 
1391 
1392  QString output = body.asJson();
1393  input.request_body.append(output);
1394 
1395 
1396 
1397  foreach(QString key, this->defaultHeaders.keys()) {
1398  input.headers.insert(key, this->defaultHeaders.value(key));
1399  }
1400 
1401  connect(worker,
1403  this,
1405 
1406  worker->execute(&input);
1407 }
1408 
1409 void
1411  QString msg;
1412  QString error_str = worker->error_str;
1413  QNetworkReply::NetworkError error_type = worker->error_type;
1414 
1415  if (worker->error_type == QNetworkReply::NoError) {
1416  msg = QString("Success! %1 bytes").arg(worker->response.length());
1417  }
1418  else {
1419  msg = "Error: " + worker->error_str;
1420  }
1421 
1422 
1423  QString json(worker->response);
1424  SWGPresetIdentifier* output = static_cast<SWGPresetIdentifier*>(create(json, QString("SWGPresetIdentifier")));
1425  worker->deleteLater();
1426 
1427  if (worker->error_type == QNetworkReply::NoError) {
1428  emit instancePresetPatchSignal(output);
1429  } else {
1430  emit instancePresetPatchSignalE(output, error_type, error_str);
1431  emit instancePresetPatchSignalEFull(worker, error_type, error_str);
1432  }
1433 }
1434 
1435 void
1437  QString fullPath;
1438  fullPath.append(this->host).append(this->basePath).append("/sdrangel/preset");
1439 
1440 
1441 
1443  SWGHttpRequestInput input(fullPath, "POST");
1444 
1445 
1446 
1447  QString output = body.asJson();
1448  input.request_body.append(output);
1449 
1450 
1451 
1452  foreach(QString key, this->defaultHeaders.keys()) {
1453  input.headers.insert(key, this->defaultHeaders.value(key));
1454  }
1455 
1456  connect(worker,
1458  this,
1460 
1461  worker->execute(&input);
1462 }
1463 
1464 void
1466  QString msg;
1467  QString error_str = worker->error_str;
1468  QNetworkReply::NetworkError error_type = worker->error_type;
1469 
1470  if (worker->error_type == QNetworkReply::NoError) {
1471  msg = QString("Success! %1 bytes").arg(worker->response.length());
1472  }
1473  else {
1474  msg = "Error: " + worker->error_str;
1475  }
1476 
1477 
1478  QString json(worker->response);
1479  SWGPresetIdentifier* output = static_cast<SWGPresetIdentifier*>(create(json, QString("SWGPresetIdentifier")));
1480  worker->deleteLater();
1481 
1482  if (worker->error_type == QNetworkReply::NoError) {
1483  emit instancePresetPostSignal(output);
1484  } else {
1485  emit instancePresetPostSignalE(output, error_type, error_str);
1486  emit instancePresetPostSignalEFull(worker, error_type, error_str);
1487  }
1488 }
1489 
1490 void
1492  QString fullPath;
1493  fullPath.append(this->host).append(this->basePath).append("/sdrangel/preset");
1494 
1495 
1496 
1498  SWGHttpRequestInput input(fullPath, "PUT");
1499 
1500 
1501 
1502  QString output = body.asJson();
1503  input.request_body.append(output);
1504 
1505 
1506 
1507  foreach(QString key, this->defaultHeaders.keys()) {
1508  input.headers.insert(key, this->defaultHeaders.value(key));
1509  }
1510 
1511  connect(worker,
1513  this,
1515 
1516  worker->execute(&input);
1517 }
1518 
1519 void
1521  QString msg;
1522  QString error_str = worker->error_str;
1523  QNetworkReply::NetworkError error_type = worker->error_type;
1524 
1525  if (worker->error_type == QNetworkReply::NoError) {
1526  msg = QString("Success! %1 bytes").arg(worker->response.length());
1527  }
1528  else {
1529  msg = "Error: " + worker->error_str;
1530  }
1531 
1532 
1533  QString json(worker->response);
1534  SWGPresetIdentifier* output = static_cast<SWGPresetIdentifier*>(create(json, QString("SWGPresetIdentifier")));
1535  worker->deleteLater();
1536 
1537  if (worker->error_type == QNetworkReply::NoError) {
1538  emit instancePresetPutSignal(output);
1539  } else {
1540  emit instancePresetPutSignalE(output, error_type, error_str);
1541  emit instancePresetPutSignalEFull(worker, error_type, error_str);
1542  }
1543 }
1544 
1545 void
1547  QString fullPath;
1548  fullPath.append(this->host).append(this->basePath).append("/sdrangel");
1549 
1550 
1551 
1553  SWGHttpRequestInput input(fullPath, "GET");
1554 
1555 
1556 
1557 
1558 
1559  foreach(QString key, this->defaultHeaders.keys()) {
1560  input.headers.insert(key, this->defaultHeaders.value(key));
1561  }
1562 
1563  connect(worker,
1565  this,
1567 
1568  worker->execute(&input);
1569 }
1570 
1571 void
1573  QString msg;
1574  QString error_str = worker->error_str;
1575  QNetworkReply::NetworkError error_type = worker->error_type;
1576 
1577  if (worker->error_type == QNetworkReply::NoError) {
1578  msg = QString("Success! %1 bytes").arg(worker->response.length());
1579  }
1580  else {
1581  msg = "Error: " + worker->error_str;
1582  }
1583 
1584 
1585  QString json(worker->response);
1586  SWGInstanceSummaryResponse* output = static_cast<SWGInstanceSummaryResponse*>(create(json, QString("SWGInstanceSummaryResponse")));
1587  worker->deleteLater();
1588 
1589  if (worker->error_type == QNetworkReply::NoError) {
1590  emit instanceSummarySignal(output);
1591  } else {
1592  emit instanceSummarySignalE(output, error_type, error_str);
1593  emit instanceSummarySignalEFull(worker, error_type, error_str);
1594  }
1595 }
1596 
1597 
1598 }
void instanceAMBEDevicesPut(SWGAMBEDevices &body)
void instanceAMBEDevicesPutCallback(SWGHttpRequestWorker *worker)
void instanceDeleteSignalE(SWGInstanceSummaryResponse *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void execute(SWGHttpRequestInput *input)
void instanceLoggingGetSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceConfigSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetPatchSignal(SWGPresetIdentifier *summary)
void instancePresetFilePost(SWGPresetExport &body)
void instanceDeviceSetsGetSignal(SWGDeviceSetList *summary)
void instanceAudioGetCallback(SWGHttpRequestWorker *worker)
void instanceAMBEDevicesPutSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceAMBEDevicesPatchSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceAMBEDevicesPatchSignalE(SWGAMBEDevices *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetPutCallback(SWGHttpRequestWorker *worker)
void instanceAudioInputPatchCallback(SWGHttpRequestWorker *worker)
void instanceAudioInputDeleteSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceDevicesSignalE(SWGInstanceDevicesResponse *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceAudioInputPatch(SWGAudioInputDevice &body)
void instanceLocationPutSignal(SWGLocationInformation *summary)
void instanceAMBEDevicesGetSignal(SWGAMBEDevices *summary)
void on_execution_finished(SWGHttpRequestWorker *worker)
void instanceDeleteSignal(SWGInstanceSummaryResponse *summary)
void instancePresetGetCallback(SWGHttpRequestWorker *worker)
virtual QString asJson() override
void instanceAudioInputCleanupPatchSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetPutSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceAMBEDevicesPatchSignal(SWGAMBEDevices *summary)
void instanceLoggingPutSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceAudioInputPatchSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceChannelsSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetFilePostSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceDeviceSetsGetCallback(SWGHttpRequestWorker *worker)
void instanceAudioInputPatchSignal(SWGAudioInputDevice *summary)
void instanceAudioOutputPatchSignalE(SWGAudioOutputDevice *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceLoggingGetSignal(SWGLoggingInfo *summary)
void instanceAMBEDevicesDeleteCallback(SWGHttpRequestWorker *worker)
void instanceSummarySignalE(SWGInstanceSummaryResponse *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceAMBEDevicesDeleteSignal(SWGSuccessResponse *summary)
void instanceAMBEDevicesDeleteSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceLoggingPut(SWGLoggingInfo &body)
void instanceDevices(qint32 direction)
void instanceAudioInputPatchSignalE(SWGAudioInputDevice *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetDeleteSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceAudioGetSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceAudioOutputDeleteCallback(SWGHttpRequestWorker *worker)
void instancePresetPutSignalE(SWGPresetIdentifier *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceDevicesCallback(SWGHttpRequestWorker *worker)
void instanceAudioOutputPatchSignal(SWGAudioOutputDevice *summary)
void instancePresetFilePut(SWGPresetImport &body)
void instanceAMBEDevicesPutSignal(SWGAMBEDevices *summary)
void instanceAMBESerialGetSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceAMBEDevicesPatch(SWGAMBEDevices &body)
void instanceAudioInputDelete(SWGAudioInputDevice &body)
void instanceLocationGetSignalE(SWGLocationInformation *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void * create(QString type)
void instancePresetDeleteSignalE(SWGPresetIdentifier *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetPostSignal(SWGPresetIdentifier *summary)
void instancePresetPut(SWGPresetTransfer &body)
void instancePresetPatchSignalE(SWGPresetIdentifier *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceChannelsSignalE(SWGInstanceChannelsResponse *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceLocationGetSignal(SWGLocationInformation *summary)
void instanceAudioOutputPatchCallback(SWGHttpRequestWorker *worker)
void instanceAMBEDevicesPatchCallback(SWGHttpRequestWorker *worker)
void instanceLocationPutSignalE(SWGLocationInformation *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceConfigSignalE(SWGInstanceConfigResponse *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceDeleteSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetPatchCallback(SWGHttpRequestWorker *worker)
void instanceChannels(qint32 direction)
void instanceAudioOutputDelete(SWGAudioOutputDevice &body)
void instanceChannelsSignal(SWGInstanceChannelsResponse *summary)
void instanceAudioGetSignal(SWGAudioDevices *summary)
void instanceLoggingGetCallback(SWGHttpRequestWorker *worker)
void instanceAMBEDevicesPutSignalE(SWGAMBEDevices *summary, QNetworkReply::NetworkError error_type, QString &error_str)
virtual QString asJson() override
void instanceAudioInputDeleteCallback(SWGHttpRequestWorker *worker)
void instanceDevicesSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetPatch(SWGPresetTransfer &body)
void instanceAudioOutputPatch(SWGAudioOutputDevice &body)
QMap< QString, QString > defaultHeaders
void instanceAudioOutputDeleteSignal(SWGAudioOutputDevice *summary)
void instanceChannelsCallback(SWGHttpRequestWorker *worker)
void instancePresetPostSignalE(SWGPresetIdentifier *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceConfigSignal(SWGInstanceConfigResponse *summary)
virtual QString asJson() override
void instanceDevicesSignal(SWGInstanceDevicesResponse *summary)
void instanceDeviceSetsGetSignalE(SWGDeviceSetList *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetFilePutSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetPost(SWGPresetTransfer &body)
void instanceAMBESerialGetSignalE(SWGDVSerialDevices *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceSummarySignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceLocationPut(SWGLocationInformation &body)
void instanceAudioOutputCleanupPatchSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetFilePutCallback(SWGHttpRequestWorker *worker)
void instanceDeleteCallback(SWGHttpRequestWorker *worker)
void instanceLocationGetSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceAudioInputCleanupPatchSignalE(SWGSuccessResponse *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceAudioInputDeleteSignalE(SWGAudioInputDevice *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceConfigCallback(SWGHttpRequestWorker *worker)
void instanceAudioOutputCleanupPatchSignal(SWGSuccessResponse *summary)
void instancePresetFilePostCallback(SWGHttpRequestWorker *worker)
virtual QString asJson() override
void instanceAudioOutputCleanupPatchSignalE(SWGSuccessResponse *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceLocationPutCallback(SWGHttpRequestWorker *worker)
void instanceAMBEDevicesGetCallback(SWGHttpRequestWorker *worker)
void instanceAudioInputCleanupPatchSignal(SWGSuccessResponse *summary)
void instancePresetGetSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
virtual QString asJson() override
void instanceAMBESerialGetSignal(SWGDVSerialDevices *summary)
void instanceAMBEDevicesGetSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetDeleteSignal(SWGPresetIdentifier *summary)
void instanceLoggingPutSignal(SWGLoggingInfo *summary)
void instanceLoggingPutCallback(SWGHttpRequestWorker *worker)
void instancePresetPostSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceAudioGetSignalE(SWGAudioDevices *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceAMBEDevicesGetSignalE(SWGAMBEDevices *summary, QNetworkReply::NetworkError error_type, QString &error_str)
virtual QString asJson() override
void instanceSummaryCallback(SWGHttpRequestWorker *worker)
void instanceSummarySignal(SWGInstanceSummaryResponse *summary)
QMap< QString, QString > headers
void instancePresetGetSignalE(SWGPresets *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetPutSignal(SWGPresetIdentifier *summary)
void instanceAMBESerialGetCallback(SWGHttpRequestWorker *worker)
void instanceDeviceSetsGetSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceLocationGetCallback(SWGHttpRequestWorker *worker)
void instanceLoggingPutSignalE(SWGLoggingInfo *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetDeleteCallback(SWGHttpRequestWorker *worker)
void instanceAudioOutputDeleteSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceAudioOutputDeleteSignalE(SWGAudioOutputDevice *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetFilePostSignalE(SWGPresetIdentifier *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetPatchSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetFilePostSignal(SWGPresetIdentifier *summary)
void instanceLoggingGetSignalE(SWGLoggingInfo *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceAMBEDevicesDeleteSignalE(SWGSuccessResponse *summary, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceAudioOutputPatchSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instanceAudioOutputCleanupPatchCallback(SWGHttpRequestWorker *worker)
void instanceAudioInputDeleteSignal(SWGAudioInputDevice *summary)
QNetworkReply::NetworkError error_type
void instancePresetDelete(SWGPresetIdentifier &body)
virtual QString asJson() override
void instancePresetGetSignal(SWGPresets *summary)
void instancePresetFilePutSignalE(SWGPresetIdentifier *summary, QNetworkReply::NetworkError error_type, QString &error_str)
QString stringValue(QString *value)
Definition: SWGHelpers.cpp:578
void instanceAudioInputCleanupPatchCallback(SWGHttpRequestWorker *worker)
void instancePresetFilePutSignal(SWGPresetIdentifier *summary)
void instanceLocationPutSignalEFull(SWGHttpRequestWorker *worker, QNetworkReply::NetworkError error_type, QString &error_str)
void instancePresetPostCallback(SWGHttpRequestWorker *worker)