rad  3.0.0
ModExmalif.hpp
Go to the documentation of this file.
1 #pragma once
2 // GENERATED, DO NOT MANUALLY MODIFY
3 // generator core v1.10
4 // specific generator: Python binding Hpp Generator v0.997
5 // source: /home/eltdev/workspace/ICS/RAD/ifw-rad-daily/rad/cpp/_examples/exmalif/src/exmalif.xml
6 
7 #ifdef __GNUC__
8 #pragma GCC diagnostic push
9 #pragma GCC diagnostic ignored "-Wpedantic"
10 #endif
11 
12 #include <array>
13 #include <string>
14 #include <memory>
15 #include <vector>
16 #include <iostream>
17 #include <sstream>
18 #include <chrono>
19 #include <cstdint>
20 #include <stdexcept>
21 #include <exception>
22 #include <utility>
23 #include <mal/Cii.hpp>
24 #include <mal/ps/DataEntity.hpp>
25 #include <mal/Mal.hpp>
26 #include <mal/rr/Ami.hpp>
27 #include <mal/rr/ServerAmi.hpp>
28 #include <mal/rr/da/DataAccess.hpp>
29 #include <pymal/delegates/ps/DataEntityBaseDelegate.hpp>
30 #include <pymal/delegates/ps/DataEventFilterBaseDelegate.hpp>
31 #include <pymal/delegates/ps/PublisherDelegate.hpp>
32 #include <pymal/delegates/ps/InstancePublisherDelegate.hpp>
33 #include <pymal/delegates/ps/SubscriberDelegate.hpp>
34 #include <pymal/delegates/ps/LoanedDataEntityDelegate.hpp>
35 #include <pymal/delegates/ps/DataEventFilterDelegate.hpp>
36 #include <pymal/delegates/ps/DataEventDelegate.hpp>
37 #include <pymal/delegates/ps/SubscriptionDelegate.hpp>
38 #include <pymal/delegates/ps/MrvSubscriberDelegate.hpp>
39 #include <pymal/delegates/rr/ClientRrEntityBaseDelegate.hpp>
40 #include <pymal/delegates/rr/AmiBaseDelegate.hpp>
41 #include <pymal/delegates/rr/AmiDelegate.hpp>
42 #include <pymal/delegates/rr/ServerAmiDelegate.hpp>
43 #include <pymal/delegates/rr/ServerContextDelegate.hpp>
44 #include <pymal/delegates/FutureDelegate.hpp>
45 #include <pymal/delegates/FutureUtil.hpp>
46 #include <pymal/support/ExceptionSupport.hpp>
47 #include <pymal/support/SharedVector.hpp>
48 
49 #include <Exmalif.hpp>
50 
51 #ifdef __GNUC__
52 #pragma GCC visibility push(hidden)
53 #endif
54 
55 #include <pymal/pybind11/pybind11.h> // NOLINT
56 #include <pymal/pybind11/chrono.h> // NOLINT
57 #include <pymal/pybind11/stl.h> // NOLINT
58 #include <pymal/pybind11/stl_bind.h> // NOLINT
59 #include <pymal/pybind11/functional.h> // NOLINT
60 
61 
62 namespace py = pybind11;
63 
64 
65 namespace exmalif {
66 
67 // Binding helper class for exception ExceptionErr
68 class ExceptionErrExc: public ::elt::mal::bindings::MalPythonExceptionObject,
69  public py::object {
70  public:
71  ExceptionErrExc() = default;
72 
82  ExceptionErrExc(py::handle scope, const char *name, PyObject *base = PyExc_Exception) {
83  std::string full_name = scope.attr("__name__").cast<std::string>() +
84  std::string(".") + name;
85  m_ptr = PyErr_NewException(const_cast<char *>(full_name.c_str()), base, NULL);
86  if (hasattr(scope, name))
87  py::pybind11_fail("Error during initialization: multiple incompatible "
88  "definitions with name \"" + std::string(name) + "\"");
89  AttachMethods();
90  scope.attr(name) = *this;
91  }
92 
93  void operator()(const ::exmalif::ExceptionErr &e) {
94  desc_ = e.getDesc();
95  code_ = e.getCode();
96  PyErr_SetString(m_ptr, e.what());
97  }
98 
99  ::elt::mal::bindings::MalPythonExceptionObjectPtr cpp_exception_factory(py::object arguments) {
100  ExceptionErrExc* exc = new ExceptionErrExc();
101  ::elt::mal::bindings::MalPythonExceptionObjectPtr result(exc);
102  try {
103  py::list arglist(arguments);
104  if (arglist.size() > 0) {
105  exc -> desc_ = py::cast<std::string>(arglist.attr("pop")(0));
106  }
107  if (arglist.size() > 0) {
108  exc -> code_ = py::cast<int32_t>(arglist.attr("pop")(0));
109  }
110  } catch (py::cast_error &e) {
111  std::cerr << "cpp_exception_factory for ExceptionErrExc cast fail: " << e.what() << std::endl;
112  } catch (py::error_already_set &e) {
113  std::cerr << "cpp_exception_factory for ExceptionErrExc general fail: " << e.what() << std::endl;
114  PyErr_Clear();
115  }
116  return result;
117  }
118 
119  void throw_cpp_exception() override {
120  throw ::exmalif::ExceptionErr(desc_,code_);
121  }
122 
123  protected:
127  void AttachMethods() {
128  (*this).attr("_cpp_exception_factory") = py::cpp_function([this](py::object arguments) {
129  return this -> cpp_exception_factory(arguments);
130  }, "Return container pointer for C++ exception to be thrown");
131  (*this).attr("getDesc") = py::cpp_function([this]() {
132  return desc_;
133  }, "Return value of desc");
134  (*this).attr("getCode") = py::cpp_function([this]() {
135  return code_;
136  }, "Return value of code");
137  }
138 
139  private:
140  std::string desc_;
141  int32_t code_;
142 }; // class ExceptionErrExc
143 
144 
145 
146 
147 // generated -1200413694
148 class StdCmdsSyncDelegate:
149  public virtual ::elt::mal::bindings::rr::ClientRrEntityBaseDelegate {
150  public:
151  StdCmdsSyncDelegate() = delete;
152  StdCmdsSyncDelegate(const StdCmdsSyncDelegate&) = delete;
153  StdCmdsSyncDelegate& operator=(const StdCmdsSyncDelegate&) = delete;
154  StdCmdsSyncDelegate(StdCmdsSyncDelegate&&) = delete;
155 
156  explicit StdCmdsSyncDelegate(std::unique_ptr<StdCmdsSync> &other):
157  pStdCmdsSync(std::move(other)), rStdCmdsSync(*pStdCmdsSync) {}
158  explicit StdCmdsSyncDelegate(const StdCmdsSync& other):
159  pStdCmdsSync(nullptr), rStdCmdsSync(const_cast<StdCmdsSync&>(other)) {}
160 
161  // RrClientEntity interface
162 
163  void close() override { rStdCmdsSync.close(); }
164 
165  ::elt::mal::bindings::FutureDelegate<void> asyncConnect() override {
166  // Release GIL
167  py::gil_scoped_release release;
168  return ::elt::mal::bindings::FutureDelegate<void>(rStdCmdsSync.asyncConnect());
169  }
170 
171  ::elt::mal::rr::ListenerRegistration registerConnectionListener(
172  const ::elt::mal::rr::ClientRrEntity::ConnectionListener &listener) override {
173  return rStdCmdsSync.registerConnectionListener(listener);
174  }
175 
176  std::shared_ptr<::elt::mal::Mal> getMal() const override {
177  return rStdCmdsSync.getMal();
178  }
179 
180  // StdCmdsSync interface
181  std::string Stop() {
182  return rStdCmdsSync.Stop();
183  }
184 
185  std::string Init() {
186  return rStdCmdsSync.Init();
187  }
188 
189  std::string Reset() {
190  return rStdCmdsSync.Reset();
191  }
192 
193  std::string Enable() {
194  return rStdCmdsSync.Enable();
195  }
196 
197  std::string Disable() {
198  return rStdCmdsSync.Disable();
199  }
200 
201  std::string GetState() {
202  return rStdCmdsSync.GetState();
203  }
204 
205  std::string GetStatus() {
206  return rStdCmdsSync.GetStatus();
207  }
208 
209  std::string GetVersion() {
210  return rStdCmdsSync.GetVersion();
211  }
212 
213  std::string Config() {
214  return rStdCmdsSync.Config();
215  }
216 
217  std::string Exit() {
218  return rStdCmdsSync.Exit();
219  }
220 
221  std::string SetLogLevel( const std::shared_ptr<::exmalif::LogInfo>& info) {
222  return rStdCmdsSync.SetLogLevel(info);
223  }
224 
225  std::string Preset( const std::shared_ptr<::exmalif::TelPosition>& pos) {
226  return rStdCmdsSync.Preset(pos);
227  }
228 
229  std::string Move( const std::shared_ptr<::exmalif::AxesPosition>& pos) {
230  return rStdCmdsSync.Move(pos);
231  }
232 
233  std::unique_ptr<::elt::mal::bindings::rr::AmiBaseDelegate> GetPresetProgress() {
234  auto ami = rStdCmdsSync.GetPresetProgress();
235  if (ami) {
236  return std::unique_ptr<::elt::mal::bindings::rr::AmiBaseDelegate>(
237  new ::elt::mal::bindings::rr::AmiDelegate<std::string,
238  StdCmds>(ami));
239  }
240  return nullptr;
241  }
242 
243 
244  virtual ~StdCmdsSyncDelegate() = default;
245 
246  private:
247  std::unique_ptr<StdCmdsSync> pStdCmdsSync;
248  StdCmdsSync &rStdCmdsSync;
249 };
250 
251 
252 
253 class StdCmdsAsyncDelegate:
254  public virtual ::elt::mal::bindings::rr::ClientRrEntityBaseDelegate {
255  public:
256  StdCmdsAsyncDelegate() = delete;
257  StdCmdsAsyncDelegate(const StdCmdsAsyncDelegate&) = delete;
258  StdCmdsAsyncDelegate& operator=(const StdCmdsAsyncDelegate&) = delete;
259  StdCmdsAsyncDelegate(StdCmdsAsyncDelegate&&) = delete;
260 
261  explicit StdCmdsAsyncDelegate(std::unique_ptr<StdCmdsAsync> &other):
262  pStdCmdsAsync(std::move(other)), rStdCmdsAsync(*pStdCmdsAsync) {}
263  explicit StdCmdsAsyncDelegate(const StdCmdsAsync& other):
264  pStdCmdsAsync(nullptr), rStdCmdsAsync(const_cast<StdCmdsAsync&>(other)) {}
265 
266  // RrClientEntity interface
267 
268  void close() override { rStdCmdsAsync.close(); }
269 
270  ::elt::mal::bindings::FutureDelegate<void> asyncConnect() override {
271  // Release GIL
272  py::gil_scoped_release release;
273  return ::elt::mal::bindings::FutureDelegate<void>(rStdCmdsAsync.asyncConnect());
274  }
275 
276  ::elt::mal::rr::ListenerRegistration registerConnectionListener(
277  const ::elt::mal::rr::ClientRrEntity::ConnectionListener &listener) override {
278  return rStdCmdsAsync.registerConnectionListener(listener);
279  }
280 
281  std::shared_ptr<::elt::mal::Mal> getMal() const override {
282  return rStdCmdsAsync.getMal();
283  }
284 
285  // StdCmdsAsync interface
286  std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
287  Stop() {
288  return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
289  new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
290  rStdCmdsAsync.Stop()));
291  }
292 
293  std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
294  Init() {
295  return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
296  new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
297  rStdCmdsAsync.Init()));
298  }
299 
300  std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
301  Reset() {
302  return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
303  new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
304  rStdCmdsAsync.Reset()));
305  }
306 
307  std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
308  Enable() {
309  return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
310  new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
311  rStdCmdsAsync.Enable()));
312  }
313 
314  std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
315  Disable() {
316  return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
317  new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
318  rStdCmdsAsync.Disable()));
319  }
320 
321  std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
322  GetState() {
323  return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
324  new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
325  rStdCmdsAsync.GetState()));
326  }
327 
328  std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
329  GetStatus() {
330  return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
331  new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
332  rStdCmdsAsync.GetStatus()));
333  }
334 
335  std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
336  GetVersion() {
337  return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
338  new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
339  rStdCmdsAsync.GetVersion()));
340  }
341 
342  std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
343  Config() {
344  return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
345  new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
346  rStdCmdsAsync.Config()));
347  }
348 
349  std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
350  Exit() {
351  return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
352  new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
353  rStdCmdsAsync.Exit()));
354  }
355 
356  std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
357  SetLogLevel( const std::shared_ptr<::exmalif::LogInfo>& info) {
358  return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
359  new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
360  rStdCmdsAsync.SetLogLevel(info)));
361  }
362 
363  std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
364  Preset( const std::shared_ptr<::exmalif::TelPosition>& pos) {
365  return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
366  new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
367  rStdCmdsAsync.Preset(pos)));
368  }
369 
370  std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
371  Move( const std::shared_ptr<::exmalif::AxesPosition>& pos) {
372  return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
373  new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
374  rStdCmdsAsync.Move(pos)));
375  }
376 
377  std::unique_ptr<::elt::mal::bindings::rr::AmiBaseDelegate> GetPresetProgress() {
378  auto ami = rStdCmdsAsync.GetPresetProgress();
379  if (ami) {
380  return std::unique_ptr<::elt::mal::bindings::rr::AmiBaseDelegate>(
381  new ::elt::mal::bindings::rr::AmiDelegate<std::string,
382  StdCmds>(ami));
383  }
384  return nullptr;
385  }
386 
387 
388  virtual ~StdCmdsAsyncDelegate() = default;
389 
390  private:
391  std::unique_ptr<StdCmdsAsync> pStdCmdsAsync;
392  StdCmdsAsync &rStdCmdsAsync;
393 };
394 
395 
396 class StdCmdsImpl: public virtual StdCmds {
397  public:
398  explicit StdCmdsImpl(py::object &pyImpl): mPyImpl(pyImpl) {}
399  std::string Stop() {
400  py::gil_scoped_acquire acquire;
401  try {
402  auto pyresult = mPyImpl.attr("Stop")();
403  return pyresult.cast<std::string>();
404  } catch(py::error_already_set &what) {
405  PyErr_Clear();
406  py::object obj = what.value();
407  if (py::hasattr(obj, "_cpp_exception_factory")) {
408  py::list arguments;
409  if (py::hasattr(obj, "args")) {
410  arguments = obj.attr("args");
411  }
412  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
413  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
414  ex.instance() -> throw_cpp_exception();
415  } else {
416  throw std::runtime_error(what.what());
417  }
418  }
419  throw std::runtime_error("Python implementation exception handler - unknown error");
420  }
421  std::string Init() {
422  py::gil_scoped_acquire acquire;
423  try {
424  auto pyresult = mPyImpl.attr("Init")();
425  return pyresult.cast<std::string>();
426  } catch(py::error_already_set &what) {
427  PyErr_Clear();
428  py::object obj = what.value();
429  if (py::hasattr(obj, "_cpp_exception_factory")) {
430  py::list arguments;
431  if (py::hasattr(obj, "args")) {
432  arguments = obj.attr("args");
433  }
434  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
435  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
436  ex.instance() -> throw_cpp_exception();
437  } else {
438  throw std::runtime_error(what.what());
439  }
440  }
441  throw std::runtime_error("Python implementation exception handler - unknown error");
442  }
443  std::string Reset() {
444  py::gil_scoped_acquire acquire;
445  try {
446  auto pyresult = mPyImpl.attr("Reset")();
447  return pyresult.cast<std::string>();
448  } catch(py::error_already_set &what) {
449  PyErr_Clear();
450  py::object obj = what.value();
451  if (py::hasattr(obj, "_cpp_exception_factory")) {
452  py::list arguments;
453  if (py::hasattr(obj, "args")) {
454  arguments = obj.attr("args");
455  }
456  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
457  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
458  ex.instance() -> throw_cpp_exception();
459  } else {
460  throw std::runtime_error(what.what());
461  }
462  }
463  throw std::runtime_error("Python implementation exception handler - unknown error");
464  }
465  std::string Enable() {
466  py::gil_scoped_acquire acquire;
467  try {
468  auto pyresult = mPyImpl.attr("Enable")();
469  return pyresult.cast<std::string>();
470  } catch(py::error_already_set &what) {
471  PyErr_Clear();
472  py::object obj = what.value();
473  if (py::hasattr(obj, "_cpp_exception_factory")) {
474  py::list arguments;
475  if (py::hasattr(obj, "args")) {
476  arguments = obj.attr("args");
477  }
478  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
479  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
480  ex.instance() -> throw_cpp_exception();
481  } else {
482  throw std::runtime_error(what.what());
483  }
484  }
485  throw std::runtime_error("Python implementation exception handler - unknown error");
486  }
487  std::string Disable() {
488  py::gil_scoped_acquire acquire;
489  try {
490  auto pyresult = mPyImpl.attr("Disable")();
491  return pyresult.cast<std::string>();
492  } catch(py::error_already_set &what) {
493  PyErr_Clear();
494  py::object obj = what.value();
495  if (py::hasattr(obj, "_cpp_exception_factory")) {
496  py::list arguments;
497  if (py::hasattr(obj, "args")) {
498  arguments = obj.attr("args");
499  }
500  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
501  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
502  ex.instance() -> throw_cpp_exception();
503  } else {
504  throw std::runtime_error(what.what());
505  }
506  }
507  throw std::runtime_error("Python implementation exception handler - unknown error");
508  }
509  std::string GetState() {
510  py::gil_scoped_acquire acquire;
511  try {
512  auto pyresult = mPyImpl.attr("GetState")();
513  return pyresult.cast<std::string>();
514  } catch(py::error_already_set &what) {
515  PyErr_Clear();
516  py::object obj = what.value();
517  if (py::hasattr(obj, "_cpp_exception_factory")) {
518  py::list arguments;
519  if (py::hasattr(obj, "args")) {
520  arguments = obj.attr("args");
521  }
522  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
523  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
524  ex.instance() -> throw_cpp_exception();
525  } else {
526  throw std::runtime_error(what.what());
527  }
528  }
529  throw std::runtime_error("Python implementation exception handler - unknown error");
530  }
531  std::string GetStatus() {
532  py::gil_scoped_acquire acquire;
533  try {
534  auto pyresult = mPyImpl.attr("GetStatus")();
535  return pyresult.cast<std::string>();
536  } catch(py::error_already_set &what) {
537  PyErr_Clear();
538  py::object obj = what.value();
539  if (py::hasattr(obj, "_cpp_exception_factory")) {
540  py::list arguments;
541  if (py::hasattr(obj, "args")) {
542  arguments = obj.attr("args");
543  }
544  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
545  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
546  ex.instance() -> throw_cpp_exception();
547  } else {
548  throw std::runtime_error(what.what());
549  }
550  }
551  throw std::runtime_error("Python implementation exception handler - unknown error");
552  }
553  std::string GetVersion() {
554  py::gil_scoped_acquire acquire;
555  try {
556  auto pyresult = mPyImpl.attr("GetVersion")();
557  return pyresult.cast<std::string>();
558  } catch(py::error_already_set &what) {
559  PyErr_Clear();
560  py::object obj = what.value();
561  if (py::hasattr(obj, "_cpp_exception_factory")) {
562  py::list arguments;
563  if (py::hasattr(obj, "args")) {
564  arguments = obj.attr("args");
565  }
566  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
567  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
568  ex.instance() -> throw_cpp_exception();
569  } else {
570  throw std::runtime_error(what.what());
571  }
572  }
573  throw std::runtime_error("Python implementation exception handler - unknown error");
574  }
575  std::string Config() {
576  py::gil_scoped_acquire acquire;
577  try {
578  auto pyresult = mPyImpl.attr("Config")();
579  return pyresult.cast<std::string>();
580  } catch(py::error_already_set &what) {
581  PyErr_Clear();
582  py::object obj = what.value();
583  if (py::hasattr(obj, "_cpp_exception_factory")) {
584  py::list arguments;
585  if (py::hasattr(obj, "args")) {
586  arguments = obj.attr("args");
587  }
588  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
589  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
590  ex.instance() -> throw_cpp_exception();
591  } else {
592  throw std::runtime_error(what.what());
593  }
594  }
595  throw std::runtime_error("Python implementation exception handler - unknown error");
596  }
597  std::string Exit() {
598  py::gil_scoped_acquire acquire;
599  try {
600  auto pyresult = mPyImpl.attr("Exit")();
601  return pyresult.cast<std::string>();
602  } catch(py::error_already_set &what) {
603  PyErr_Clear();
604  py::object obj = what.value();
605  if (py::hasattr(obj, "_cpp_exception_factory")) {
606  py::list arguments;
607  if (py::hasattr(obj, "args")) {
608  arguments = obj.attr("args");
609  }
610  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
611  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
612  ex.instance() -> throw_cpp_exception();
613  } else {
614  throw std::runtime_error(what.what());
615  }
616  }
617  throw std::runtime_error("Python implementation exception handler - unknown error");
618  }
619  std::string SetLogLevel( const std::shared_ptr<::exmalif::LogInfo>& info) {
620  py::gil_scoped_acquire acquire;
621  try {
622  auto pyresult = mPyImpl.attr("SetLogLevel")(info);
623  return pyresult.cast<std::string>();
624  } catch(py::error_already_set &what) {
625  PyErr_Clear();
626  py::object obj = what.value();
627  if (py::hasattr(obj, "_cpp_exception_factory")) {
628  py::list arguments;
629  if (py::hasattr(obj, "args")) {
630  arguments = obj.attr("args");
631  }
632  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
633  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
634  ex.instance() -> throw_cpp_exception();
635  } else {
636  throw std::runtime_error(what.what());
637  }
638  }
639  throw std::runtime_error("Python implementation exception handler - unknown error");
640  }
641  std::string Preset( const std::shared_ptr<::exmalif::TelPosition>& pos) {
642  py::gil_scoped_acquire acquire;
643  try {
644  auto pyresult = mPyImpl.attr("Preset")(pos);
645  return pyresult.cast<std::string>();
646  } catch(py::error_already_set &what) {
647  PyErr_Clear();
648  py::object obj = what.value();
649  if (py::hasattr(obj, "_cpp_exception_factory")) {
650  py::list arguments;
651  if (py::hasattr(obj, "args")) {
652  arguments = obj.attr("args");
653  }
654  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
655  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
656  ex.instance() -> throw_cpp_exception();
657  } else {
658  throw std::runtime_error(what.what());
659  }
660  }
661  throw std::runtime_error("Python implementation exception handler - unknown error");
662  }
663  std::string Move( const std::shared_ptr<::exmalif::AxesPosition>& pos) {
664  py::gil_scoped_acquire acquire;
665  try {
666  auto pyresult = mPyImpl.attr("Move")(pos);
667  return pyresult.cast<std::string>();
668  } catch(py::error_already_set &what) {
669  PyErr_Clear();
670  py::object obj = what.value();
671  if (py::hasattr(obj, "_cpp_exception_factory")) {
672  py::list arguments;
673  if (py::hasattr(obj, "args")) {
674  arguments = obj.attr("args");
675  }
676  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
677  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
678  ex.instance() -> throw_cpp_exception();
679  } else {
680  throw std::runtime_error(what.what());
681  }
682  }
683  throw std::runtime_error("Python implementation exception handler - unknown error");
684  }
685  std::shared_ptr<::elt::mal::rr::Ami<std::string>>
686  GetPresetProgress() override {
687  py::gil_scoped_acquire acquire;
688  try {
689  auto pyresult = mPyImpl.attr("GetPresetProgress")();
690  ::elt::mal::bindings::rr::ServerAmiDelegate<std::string, StdCmds> &serverAmi =
691  pyresult.cast<::elt::mal::bindings::rr::ServerAmiDelegate<std::string, StdCmds>&>();
692  return serverAmi.getAmi();
693  } catch(py::error_already_set &what) {
694  PyErr_Clear();
695  py::object obj = what.value();
696  if (py::hasattr(obj, "_cpp_exception_factory")) {
697  py::list arguments;
698  if (py::hasattr(obj, "args")) {
699  arguments = obj.attr("args");
700  }
701  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
702  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
703  ex.instance() -> throw_cpp_exception();
704  } else {
705  throw std::runtime_error(what.what());
706  }
707  }
708  throw std::runtime_error("Python implementation exception handler - unknown error");
709  }
710 
711 
712  private:
713  py::object mPyImpl;
714 
715 };
716 
717 
718 
719 class AsyncStdCmdsImpl: public virtual AsyncStdCmds {
720  public:
721  explicit AsyncStdCmdsImpl(py::object &pyImpl): mPyImpl(pyImpl) {}
722  ::elt::mal::future<std::string> Stop() {
723  py::gil_scoped_acquire acquire;
724  try {
725  auto pyresult = mPyImpl.attr("Stop")();
726  ::elt::mal::future<std::string> result =
727  ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
728  return result;
729  } catch(py::error_already_set &what) {
730  PyErr_Clear();
731  py::object obj = what.value();
732  if (py::hasattr(obj, "_cpp_exception_factory")) {
733  py::list arguments;
734  if (py::hasattr(obj, "args")) {
735  arguments = obj.attr("args");
736  }
737  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
738  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
739  ex.instance() -> throw_cpp_exception();
740  } else {
741  throw std::runtime_error(what.what());
742  }
743  }
744  throw std::runtime_error("Python implementation exception handler - unknown error");
745  }
746  ::elt::mal::future<std::string> Init() {
747  py::gil_scoped_acquire acquire;
748  try {
749  auto pyresult = mPyImpl.attr("Init")();
750  ::elt::mal::future<std::string> result =
751  ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
752  return result;
753  } catch(py::error_already_set &what) {
754  PyErr_Clear();
755  py::object obj = what.value();
756  if (py::hasattr(obj, "_cpp_exception_factory")) {
757  py::list arguments;
758  if (py::hasattr(obj, "args")) {
759  arguments = obj.attr("args");
760  }
761  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
762  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
763  ex.instance() -> throw_cpp_exception();
764  } else {
765  throw std::runtime_error(what.what());
766  }
767  }
768  throw std::runtime_error("Python implementation exception handler - unknown error");
769  }
770  ::elt::mal::future<std::string> Reset() {
771  py::gil_scoped_acquire acquire;
772  try {
773  auto pyresult = mPyImpl.attr("Reset")();
774  ::elt::mal::future<std::string> result =
775  ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
776  return result;
777  } catch(py::error_already_set &what) {
778  PyErr_Clear();
779  py::object obj = what.value();
780  if (py::hasattr(obj, "_cpp_exception_factory")) {
781  py::list arguments;
782  if (py::hasattr(obj, "args")) {
783  arguments = obj.attr("args");
784  }
785  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
786  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
787  ex.instance() -> throw_cpp_exception();
788  } else {
789  throw std::runtime_error(what.what());
790  }
791  }
792  throw std::runtime_error("Python implementation exception handler - unknown error");
793  }
794  ::elt::mal::future<std::string> Enable() {
795  py::gil_scoped_acquire acquire;
796  try {
797  auto pyresult = mPyImpl.attr("Enable")();
798  ::elt::mal::future<std::string> result =
799  ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
800  return result;
801  } catch(py::error_already_set &what) {
802  PyErr_Clear();
803  py::object obj = what.value();
804  if (py::hasattr(obj, "_cpp_exception_factory")) {
805  py::list arguments;
806  if (py::hasattr(obj, "args")) {
807  arguments = obj.attr("args");
808  }
809  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
810  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
811  ex.instance() -> throw_cpp_exception();
812  } else {
813  throw std::runtime_error(what.what());
814  }
815  }
816  throw std::runtime_error("Python implementation exception handler - unknown error");
817  }
818  ::elt::mal::future<std::string> Disable() {
819  py::gil_scoped_acquire acquire;
820  try {
821  auto pyresult = mPyImpl.attr("Disable")();
822  ::elt::mal::future<std::string> result =
823  ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
824  return result;
825  } catch(py::error_already_set &what) {
826  PyErr_Clear();
827  py::object obj = what.value();
828  if (py::hasattr(obj, "_cpp_exception_factory")) {
829  py::list arguments;
830  if (py::hasattr(obj, "args")) {
831  arguments = obj.attr("args");
832  }
833  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
834  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
835  ex.instance() -> throw_cpp_exception();
836  } else {
837  throw std::runtime_error(what.what());
838  }
839  }
840  throw std::runtime_error("Python implementation exception handler - unknown error");
841  }
842  ::elt::mal::future<std::string> GetState() {
843  py::gil_scoped_acquire acquire;
844  try {
845  auto pyresult = mPyImpl.attr("GetState")();
846  ::elt::mal::future<std::string> result =
847  ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
848  return result;
849  } catch(py::error_already_set &what) {
850  PyErr_Clear();
851  py::object obj = what.value();
852  if (py::hasattr(obj, "_cpp_exception_factory")) {
853  py::list arguments;
854  if (py::hasattr(obj, "args")) {
855  arguments = obj.attr("args");
856  }
857  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
858  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
859  ex.instance() -> throw_cpp_exception();
860  } else {
861  throw std::runtime_error(what.what());
862  }
863  }
864  throw std::runtime_error("Python implementation exception handler - unknown error");
865  }
866  ::elt::mal::future<std::string> GetStatus() {
867  py::gil_scoped_acquire acquire;
868  try {
869  auto pyresult = mPyImpl.attr("GetStatus")();
870  ::elt::mal::future<std::string> result =
871  ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
872  return result;
873  } catch(py::error_already_set &what) {
874  PyErr_Clear();
875  py::object obj = what.value();
876  if (py::hasattr(obj, "_cpp_exception_factory")) {
877  py::list arguments;
878  if (py::hasattr(obj, "args")) {
879  arguments = obj.attr("args");
880  }
881  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
882  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
883  ex.instance() -> throw_cpp_exception();
884  } else {
885  throw std::runtime_error(what.what());
886  }
887  }
888  throw std::runtime_error("Python implementation exception handler - unknown error");
889  }
890  ::elt::mal::future<std::string> GetVersion() {
891  py::gil_scoped_acquire acquire;
892  try {
893  auto pyresult = mPyImpl.attr("GetVersion")();
894  ::elt::mal::future<std::string> result =
895  ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
896  return result;
897  } catch(py::error_already_set &what) {
898  PyErr_Clear();
899  py::object obj = what.value();
900  if (py::hasattr(obj, "_cpp_exception_factory")) {
901  py::list arguments;
902  if (py::hasattr(obj, "args")) {
903  arguments = obj.attr("args");
904  }
905  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
906  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
907  ex.instance() -> throw_cpp_exception();
908  } else {
909  throw std::runtime_error(what.what());
910  }
911  }
912  throw std::runtime_error("Python implementation exception handler - unknown error");
913  }
914  ::elt::mal::future<std::string> Config() {
915  py::gil_scoped_acquire acquire;
916  try {
917  auto pyresult = mPyImpl.attr("Config")();
918  ::elt::mal::future<std::string> result =
919  ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
920  return result;
921  } catch(py::error_already_set &what) {
922  PyErr_Clear();
923  py::object obj = what.value();
924  if (py::hasattr(obj, "_cpp_exception_factory")) {
925  py::list arguments;
926  if (py::hasattr(obj, "args")) {
927  arguments = obj.attr("args");
928  }
929  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
930  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
931  ex.instance() -> throw_cpp_exception();
932  } else {
933  throw std::runtime_error(what.what());
934  }
935  }
936  throw std::runtime_error("Python implementation exception handler - unknown error");
937  }
938  ::elt::mal::future<std::string> Exit() {
939  py::gil_scoped_acquire acquire;
940  try {
941  auto pyresult = mPyImpl.attr("Exit")();
942  ::elt::mal::future<std::string> result =
943  ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
944  return result;
945  } catch(py::error_already_set &what) {
946  PyErr_Clear();
947  py::object obj = what.value();
948  if (py::hasattr(obj, "_cpp_exception_factory")) {
949  py::list arguments;
950  if (py::hasattr(obj, "args")) {
951  arguments = obj.attr("args");
952  }
953  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
954  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
955  ex.instance() -> throw_cpp_exception();
956  } else {
957  throw std::runtime_error(what.what());
958  }
959  }
960  throw std::runtime_error("Python implementation exception handler - unknown error");
961  }
962  ::elt::mal::future<std::string> SetLogLevel( const std::shared_ptr<::exmalif::LogInfo>& info) {
963  py::gil_scoped_acquire acquire;
964  try {
965  auto pyresult = mPyImpl.attr("SetLogLevel")(info);
966  ::elt::mal::future<std::string> result =
967  ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
968  return result;
969  } catch(py::error_already_set &what) {
970  PyErr_Clear();
971  py::object obj = what.value();
972  if (py::hasattr(obj, "_cpp_exception_factory")) {
973  py::list arguments;
974  if (py::hasattr(obj, "args")) {
975  arguments = obj.attr("args");
976  }
977  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
978  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
979  ex.instance() -> throw_cpp_exception();
980  } else {
981  throw std::runtime_error(what.what());
982  }
983  }
984  throw std::runtime_error("Python implementation exception handler - unknown error");
985  }
986  ::elt::mal::future<std::string> Preset( const std::shared_ptr<::exmalif::TelPosition>& pos) {
987  py::gil_scoped_acquire acquire;
988  try {
989  auto pyresult = mPyImpl.attr("Preset")(pos);
990  ::elt::mal::future<std::string> result =
991  ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
992  return result;
993  } catch(py::error_already_set &what) {
994  PyErr_Clear();
995  py::object obj = what.value();
996  if (py::hasattr(obj, "_cpp_exception_factory")) {
997  py::list arguments;
998  if (py::hasattr(obj, "args")) {
999  arguments = obj.attr("args");
1000  }
1001  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
1002  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
1003  ex.instance() -> throw_cpp_exception();
1004  } else {
1005  throw std::runtime_error(what.what());
1006  }
1007  }
1008  throw std::runtime_error("Python implementation exception handler - unknown error");
1009  }
1010  ::elt::mal::future<std::string> Move( const std::shared_ptr<::exmalif::AxesPosition>& pos) {
1011  py::gil_scoped_acquire acquire;
1012  try {
1013  auto pyresult = mPyImpl.attr("Move")(pos);
1014  ::elt::mal::future<std::string> result =
1015  ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
1016  return result;
1017  } catch(py::error_already_set &what) {
1018  PyErr_Clear();
1019  py::object obj = what.value();
1020  if (py::hasattr(obj, "_cpp_exception_factory")) {
1021  py::list arguments;
1022  if (py::hasattr(obj, "args")) {
1023  arguments = obj.attr("args");
1024  }
1025  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
1026  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
1027  ex.instance() -> throw_cpp_exception();
1028  } else {
1029  throw std::runtime_error(what.what());
1030  }
1031  }
1032  throw std::runtime_error("Python implementation exception handler - unknown error");
1033  }
1034  std::shared_ptr<::elt::mal::rr::Ami<std::string>>
1035  GetPresetProgress() override {
1036  py::gil_scoped_acquire acquire;
1037  try {
1038  auto pyresult = mPyImpl.attr("GetPresetProgress")();
1039  ::elt::mal::bindings::rr::ServerAmiDelegate<std::string, StdCmds> &serverAmi =
1040  pyresult.cast<::elt::mal::bindings::rr::ServerAmiDelegate<std::string, StdCmds>&>();
1041  return serverAmi.getAmi();
1042  } catch(py::error_already_set &what) {
1043  PyErr_Clear();
1044  py::object obj = what.value();
1045  if (py::hasattr(obj, "_cpp_exception_factory")) {
1046  py::list arguments;
1047  if (py::hasattr(obj, "args")) {
1048  arguments = obj.attr("args");
1049  }
1050  ::elt::mal::bindings::MalPythonExceptionObjectPtr ex =
1051  py::cast<::elt::mal::bindings::MalPythonExceptionObjectPtr>(obj.attr("_cpp_exception_factory")(arguments));
1052  ex.instance() -> throw_cpp_exception();
1053  } else {
1054  throw std::runtime_error(what.what());
1055  }
1056  }
1057  throw std::runtime_error("Python implementation exception handler - unknown error");
1058  }
1059 
1060  private:
1061  py::object mPyImpl;
1062 
1063 };
1064 
1065 } // exmalif
1066 
1067 
1068 #ifndef ICD_GEN_ARRAY_1632905179_HPP_
1069 #define ICD_GEN_ARRAY_1632905179_HPP_
1070  PYBIND11_MAKE_OPAQUE(std::vector<std::shared_ptr<::exmalif::TelPosition>>);
1071 #endif
1072 
1073 #ifndef ICD_GEN_ARRAY_1286306241_HPP_
1074 #define ICD_GEN_ARRAY_1286306241_HPP_
1075  PYBIND11_MAKE_OPAQUE(std::vector<std::shared_ptr<::exmalif::AxesPosition>>);
1076 #endif
1077 
1078 #ifndef ICD_GEN_ARRAY_1574765012_HPP_
1079 #define ICD_GEN_ARRAY_1574765012_HPP_
1080  PYBIND11_MAKE_OPAQUE(std::vector<std::shared_ptr<::exmalif::LogInfo>>);
1081 #endif
1082 
1083 // GENERATED MODULE END
1084 
1085 #ifdef __GNUC__
1086 #pragma GCC visibility pop
1087 #pragma GCC diagnostic pop
1088 #endif
exmalif::StdCmdsSyncDelegate::StdCmdsSyncDelegate
StdCmdsSyncDelegate(const StdCmdsSync &other)
Definition: ModExmalif.hpp:158
exmalif::ExceptionErrExc::operator()
void operator()(const ::exmalif::ExceptionErr &e)
Definition: ModExmalif.hpp:93
exmalif::AsyncStdCmds::GetVersion
virtual ::elt::mal::future< std::string > GetVersion()=0
exmalif::StdCmds::GetStatus
virtual std::string GetStatus()=0
wscript.name
name
Definition: wscript:8
exmalif::StdCmdsSyncDelegate::asyncConnect
::elt::mal::bindings::FutureDelegate< void > asyncConnect() override
Definition: ModExmalif.hpp:165
exmalif::StdCmdsSyncDelegate::getMal
std::shared_ptr<::elt::mal::Mal > getMal() const override
Definition: ModExmalif.hpp:176
exmalif::ExceptionErrExc::ExceptionErrExc
ExceptionErrExc()=default
exmalif::StdCmdsAsyncDelegate::GetPresetProgress
std::unique_ptr<::elt::mal::bindings::rr::AmiBaseDelegate > GetPresetProgress()
Definition: ModExmalif.hpp:377
exmalif::AsyncStdCmds::Config
virtual ::elt::mal::future< std::string > Config()=0
exmalif::StdCmdsSyncDelegate::StdCmdsSyncDelegate
StdCmdsSyncDelegate(const StdCmdsSyncDelegate &)=delete
exmalif::AsyncStdCmdsImpl::Stop
::elt::mal::future< std::string > Stop()
Definition: ModExmalif.hpp:722
exmalif::AsyncStdCmds::GetPresetProgress
virtual std::shared_ptr<::elt::mal::rr::Ami< std::string > > GetPresetProgress()=0
exmalif::AsyncStdCmdsImpl::Config
::elt::mal::future< std::string > Config()
Definition: ModExmalif.hpp:914
exmalif::StdCmdsAsyncDelegate::close
void close() override
Definition: ModExmalif.hpp:268
exmalif::AsyncStdCmds
AsyncStdCmds.
Definition: Exmalif.hpp:157
exmalif::StdCmdsAsyncDelegate::GetStatus
std::unique_ptr<::elt::mal::bindings::FutureDelegate< std::string, ::exmalif::StdCmds > > GetStatus()
Definition: ModExmalif.hpp:329
exmalif::StdCmds::SetLogLevel
virtual std::string SetLogLevel(const std::shared_ptr<::exmalif::LogInfo > &info)=0
exmalif::StdCmds::Exit
virtual std::string Exit()=0
exmalif::AsyncStdCmds::Enable
virtual ::elt::mal::future< std::string > Enable()=0
exmalif::StdCmdsAsyncDelegate::~StdCmdsAsyncDelegate
virtual ~StdCmdsAsyncDelegate()=default
exmalif::StdCmdsAsyncDelegate::asyncConnect
::elt::mal::bindings::FutureDelegate< void > asyncConnect() override
Definition: ModExmalif.hpp:270
exmalif::StdCmdsImpl::StdCmdsImpl
StdCmdsImpl(py::object &pyImpl)
Definition: ModExmalif.hpp:398
exmalif::StdCmds::Enable
virtual std::string Enable()=0
exmalif::StdCmdsSyncDelegate::Reset
std::string Reset()
Definition: ModExmalif.hpp:189
exmalif::StdCmdsImpl::Init
std::string Init()
Definition: ModExmalif.hpp:421
exmalif::ExceptionErrExc
Definition: ModExmalif.hpp:69
exmalif::StdCmdsSyncDelegate::Preset
std::string Preset(const std::shared_ptr<::exmalif::TelPosition > &pos)
Definition: ModExmalif.hpp:225
exmalif::StdCmdsSyncDelegate::~StdCmdsSyncDelegate
virtual ~StdCmdsSyncDelegate()=default
exmalif::StdCmdsAsyncDelegate::Preset
std::unique_ptr<::elt::mal::bindings::FutureDelegate< std::string, ::exmalif::StdCmds > > Preset(const std::shared_ptr<::exmalif::TelPosition > &pos)
Definition: ModExmalif.hpp:364
exmalif::AsyncStdCmdsImpl::GetStatus
::elt::mal::future< std::string > GetStatus()
Definition: ModExmalif.hpp:866
exmalif::StdCmdsImpl::Reset
std::string Reset()
Definition: ModExmalif.hpp:443
exmalif::StdCmds::GetVersion
virtual std::string GetVersion()=0
exmalif::StdCmdsAsyncDelegate::StdCmdsAsyncDelegate
StdCmdsAsyncDelegate(std::unique_ptr< StdCmdsAsync > &other)
Definition: ModExmalif.hpp:261
conf.release
string release
Definition: conf.py:79
exmalif::AsyncStdCmdsImpl::SetLogLevel
::elt::mal::future< std::string > SetLogLevel(const std::shared_ptr<::exmalif::LogInfo > &info)
Definition: ModExmalif.hpp:962
exmalif::StdCmds::Move
virtual std::string Move(const std::shared_ptr<::exmalif::AxesPosition > &pos)=0
exmalif::StdCmdsSyncDelegate::Exit
std::string Exit()
Definition: ModExmalif.hpp:217
exmalif::StdCmdsSyncDelegate
Definition: ModExmalif.hpp:149
exmalif::AsyncStdCmdsImpl::GetPresetProgress
std::shared_ptr<::elt::mal::rr::Ami< std::string > > GetPresetProgress() override
Definition: ModExmalif.hpp:1035
exmalif::AsyncStdCmdsImpl::Preset
::elt::mal::future< std::string > Preset(const std::shared_ptr<::exmalif::TelPosition > &pos)
Definition: ModExmalif.hpp:986
exmalif::StdCmdsImpl::GetPresetProgress
std::shared_ptr<::elt::mal::rr::Ami< std::string > > GetPresetProgress() override
Definition: ModExmalif.hpp:686
exmalif::StdCmdsImpl::SetLogLevel
std::string SetLogLevel(const std::shared_ptr<::exmalif::LogInfo > &info)
Definition: ModExmalif.hpp:619
exmalif::StdCmds::Stop
virtual std::string Stop()=0
exmalif::AsyncStdCmds::Move
virtual ::elt::mal::future< std::string > Move(const std::shared_ptr<::exmalif::AxesPosition > &pos)=0
exmalif::StdCmdsAsyncDelegate::Enable
std::unique_ptr<::elt::mal::bindings::FutureDelegate< std::string, ::exmalif::StdCmds > > Enable()
Definition: ModExmalif.hpp:308
exmalif::StdCmdsAsyncDelegate
Definition: ModExmalif.hpp:254
exmalif::AsyncStdCmdsImpl::Move
::elt::mal::future< std::string > Move(const std::shared_ptr<::exmalif::AxesPosition > &pos)
Definition: ModExmalif.hpp:1010
exmalif::StdCmds::Reset
virtual std::string Reset()=0
exmalif::AsyncStdCmds::Disable
virtual ::elt::mal::future< std::string > Disable()=0
exmalif::AsyncStdCmdsImpl::Init
::elt::mal::future< std::string > Init()
Definition: ModExmalif.hpp:746
exmalif::StdCmdsImpl::Enable
std::string Enable()
Definition: ModExmalif.hpp:465
exmalif::StdCmdsAsyncDelegate::Config
std::unique_ptr<::elt::mal::bindings::FutureDelegate< std::string, ::exmalif::StdCmds > > Config()
Definition: ModExmalif.hpp:343
exmalif::StdCmdsAsyncDelegate::StdCmdsAsyncDelegate
StdCmdsAsyncDelegate(const StdCmdsAsync &other)
Definition: ModExmalif.hpp:263
Exmalif.hpp
exmalif::StdCmdsAsyncDelegate::Disable
std::unique_ptr<::elt::mal::bindings::FutureDelegate< std::string, ::exmalif::StdCmds > > Disable()
Definition: ModExmalif.hpp:315
exmalif::StdCmdsAsyncDelegate::Exit
std::unique_ptr<::elt::mal::bindings::FutureDelegate< std::string, ::exmalif::StdCmds > > Exit()
Definition: ModExmalif.hpp:350
exmalif::StdCmdsSyncDelegate::close
void close() override
Definition: ModExmalif.hpp:163
exmalif::StdCmdsImpl::Disable
std::string Disable()
Definition: ModExmalif.hpp:487
exmalif::StdCmdsSyncDelegate::Move
std::string Move(const std::shared_ptr<::exmalif::AxesPosition > &pos)
Definition: ModExmalif.hpp:229
exmalif::StdCmdsSyncDelegate::GetVersion
std::string GetVersion()
Definition: ModExmalif.hpp:209
exmalif::StdCmdsAsyncDelegate::GetVersion
std::unique_ptr<::elt::mal::bindings::FutureDelegate< std::string, ::exmalif::StdCmds > > GetVersion()
Definition: ModExmalif.hpp:336
exmalif::StdCmdsSync
Definition: Exmalif.hpp:183
exmalif::ExceptionErrExc::AttachMethods
void AttachMethods()
Definition: ModExmalif.hpp:127
exmalif::StdCmdsAsync
Definition: Exmalif.hpp:189
exmalif::StdCmdsAsyncDelegate::Stop
std::unique_ptr<::elt::mal::bindings::FutureDelegate< std::string, ::exmalif::StdCmds > > Stop()
Definition: ModExmalif.hpp:287
exmalif::StdCmdsSyncDelegate::Config
std::string Config()
Definition: ModExmalif.hpp:213
exmalif::StdCmds::Init
virtual std::string Init()=0
exmalif::StdCmdsAsyncDelegate::GetState
std::unique_ptr<::elt::mal::bindings::FutureDelegate< std::string, ::exmalif::StdCmds > > GetState()
Definition: ModExmalif.hpp:322
exmalif::AsyncStdCmds::GetState
virtual ::elt::mal::future< std::string > GetState()=0
exmalif::StdCmdsImpl::Exit
std::string Exit()
Definition: ModExmalif.hpp:597
exmalif::StdCmdsAsyncDelegate::Reset
std::unique_ptr<::elt::mal::bindings::FutureDelegate< std::string, ::exmalif::StdCmds > > Reset()
Definition: ModExmalif.hpp:301
exmalif::StdCmdsAsyncDelegate::StdCmdsAsyncDelegate
StdCmdsAsyncDelegate()=delete
exmalif::StdCmdsAsyncDelegate::StdCmdsAsyncDelegate
StdCmdsAsyncDelegate(StdCmdsAsyncDelegate &&)=delete
exmalif::StdCmdsImpl::Move
std::string Move(const std::shared_ptr<::exmalif::AxesPosition > &pos)
Definition: ModExmalif.hpp:663
exmalif::ExceptionErrExc::ExceptionErrExc
ExceptionErrExc(py::handle scope, const char *name, PyObject *base=PyExc_Exception)
Definition: ModExmalif.hpp:82
exmalif::StdCmdsSyncDelegate::Stop
std::string Stop()
Definition: ModExmalif.hpp:181
exmalif::StdCmdsImpl::Stop
std::string Stop()
Definition: ModExmalif.hpp:399
exmalif::AsyncStdCmdsImpl::AsyncStdCmdsImpl
AsyncStdCmdsImpl(py::object &pyImpl)
Definition: ModExmalif.hpp:721
exmalif::AsyncStdCmdsImpl::Enable
::elt::mal::future< std::string > Enable()
Definition: ModExmalif.hpp:794
exmalif::StdCmdsAsyncDelegate::StdCmdsAsyncDelegate
StdCmdsAsyncDelegate(const StdCmdsAsyncDelegate &)=delete
exmalif::AsyncStdCmdsImpl::Disable
::elt::mal::future< std::string > Disable()
Definition: ModExmalif.hpp:818
exmalif::AsyncStdCmdsImpl::GetVersion
::elt::mal::future< std::string > GetVersion()
Definition: ModExmalif.hpp:890
exmalif::ExceptionErrExc::cpp_exception_factory
::elt::mal::bindings::MalPythonExceptionObjectPtr cpp_exception_factory(py::object arguments)
Definition: ModExmalif.hpp:99
exmalif::AsyncStdCmds::Exit
virtual ::elt::mal::future< std::string > Exit()=0
exmalif::StdCmdsSyncDelegate::StdCmdsSyncDelegate
StdCmdsSyncDelegate(std::unique_ptr< StdCmdsSync > &other)
Definition: ModExmalif.hpp:156
exmalif::StdCmdsImpl
Definition: ModExmalif.hpp:396
exmalif::StdCmdsSyncDelegate::GetState
std::string GetState()
Definition: ModExmalif.hpp:201
exmalif::StdCmdsSyncDelegate::Init
std::string Init()
Definition: ModExmalif.hpp:185
exmalif::StdCmdsSyncDelegate::GetPresetProgress
std::unique_ptr<::elt::mal::bindings::rr::AmiBaseDelegate > GetPresetProgress()
Definition: ModExmalif.hpp:233
exmalif::StdCmdsAsyncDelegate::Move
std::unique_ptr<::elt::mal::bindings::FutureDelegate< std::string, ::exmalif::StdCmds > > Move(const std::shared_ptr<::exmalif::AxesPosition > &pos)
Definition: ModExmalif.hpp:371
exmalif::StdCmdsSyncDelegate::GetStatus
std::string GetStatus()
Definition: ModExmalif.hpp:205
exmalif::StdCmdsAsyncDelegate::registerConnectionListener
::elt::mal::rr::ListenerRegistration registerConnectionListener(const ::elt::mal::rr::ClientRrEntity::ConnectionListener &listener) override
Definition: ModExmalif.hpp:276
exmalif::StdCmdsImpl::GetVersion
std::string GetVersion()
Definition: ModExmalif.hpp:553
exmalif::AsyncStdCmds::Stop
virtual ::elt::mal::future< std::string > Stop()=0
exmalif::StdCmds::GetPresetProgress
virtual std::shared_ptr<::elt::mal::rr::Ami< std::string > > GetPresetProgress()=0
exmalif::StdCmdsSyncDelegate::StdCmdsSyncDelegate
StdCmdsSyncDelegate()=delete
exmalif::StdCmds::Preset
virtual std::string Preset(const std::shared_ptr<::exmalif::TelPosition > &pos)=0
std
Definition: errors.hpp:58
exmalif::AsyncStdCmdsImpl::Exit
::elt::mal::future< std::string > Exit()
Definition: ModExmalif.hpp:938
exmalif
Definition: Exmalif.hpp:25
exmalif::AsyncStdCmds::GetStatus
virtual ::elt::mal::future< std::string > GetStatus()=0
exmalif::AsyncStdCmds::Reset
virtual ::elt::mal::future< std::string > Reset()=0
exmalif::AsyncStdCmds::Preset
virtual ::elt::mal::future< std::string > Preset(const std::shared_ptr<::exmalif::TelPosition > &pos)=0
exmalif::StdCmdsSyncDelegate::Disable
std::string Disable()
Definition: ModExmalif.hpp:197
exmalif::StdCmdsImpl::Preset
std::string Preset(const std::shared_ptr<::exmalif::TelPosition > &pos)
Definition: ModExmalif.hpp:641
exmalif::StdCmdsImpl::GetState
std::string GetState()
Definition: ModExmalif.hpp:509
exmalif::AsyncStdCmdsImpl::Reset
::elt::mal::future< std::string > Reset()
Definition: ModExmalif.hpp:770
exmalif::StdCmdsAsyncDelegate::Init
std::unique_ptr<::elt::mal::bindings::FutureDelegate< std::string, ::exmalif::StdCmds > > Init()
Definition: ModExmalif.hpp:294
exmalif::StdCmdsAsyncDelegate::getMal
std::shared_ptr<::elt::mal::Mal > getMal() const override
Definition: ModExmalif.hpp:281
exmalif::StdCmdsImpl::Config
std::string Config()
Definition: ModExmalif.hpp:575
exmalif::StdCmds::Disable
virtual std::string Disable()=0
exmalif::StdCmdsAsyncDelegate::operator=
StdCmdsAsyncDelegate & operator=(const StdCmdsAsyncDelegate &)=delete
exmalif::StdCmds::Config
virtual std::string Config()=0
exmalif::StdCmdsSyncDelegate::operator=
StdCmdsSyncDelegate & operator=(const StdCmdsSyncDelegate &)=delete
exmalif::StdCmdsAsyncDelegate::SetLogLevel
std::unique_ptr<::elt::mal::bindings::FutureDelegate< std::string, ::exmalif::StdCmds > > SetLogLevel(const std::shared_ptr<::exmalif::LogInfo > &info)
Definition: ModExmalif.hpp:357
exmalif::AsyncStdCmdsImpl::GetState
::elt::mal::future< std::string > GetState()
Definition: ModExmalif.hpp:842
exmalif::ExceptionErrExc::throw_cpp_exception
void throw_cpp_exception() override
Definition: ModExmalif.hpp:119
PYBIND11_MAKE_OPAQUE
PYBIND11_MAKE_OPAQUE(std::vector< std::shared_ptr<::exmalif::TelPosition >>)
exmalif::StdCmds::GetState
virtual std::string GetState()=0
exmalif::StdCmdsSyncDelegate::registerConnectionListener
::elt::mal::rr::ListenerRegistration registerConnectionListener(const ::elt::mal::rr::ClientRrEntity::ConnectionListener &listener) override
Definition: ModExmalif.hpp:171
exmalif::StdCmdsSyncDelegate::StdCmdsSyncDelegate
StdCmdsSyncDelegate(StdCmdsSyncDelegate &&)=delete
exmalif::StdCmdsSyncDelegate::SetLogLevel
std::string SetLogLevel(const std::shared_ptr<::exmalif::LogInfo > &info)
Definition: ModExmalif.hpp:221
exmalif::StdCmdsSyncDelegate::Enable
std::string Enable()
Definition: ModExmalif.hpp:193
exmalif::AsyncStdCmds::Init
virtual ::elt::mal::future< std::string > Init()=0
exmalif::StdCmds
StdCmds.
Definition: Exmalif.hpp:131
exmalif::AsyncStdCmdsImpl
Definition: ModExmalif.hpp:719
exmalif::StdCmdsImpl::GetStatus
std::string GetStatus()
Definition: ModExmalif.hpp:531
exmalif::AsyncStdCmds::SetLogLevel
virtual ::elt::mal::future< std::string > SetLogLevel(const std::shared_ptr<::exmalif::LogInfo > &info)=0
Generated by doxygen 1.8.20