ModExmalif.hpp

Go to the documentation of this file.

#pragma once
// GENERATED, DO NOT MANUALLY MODIFY
// generator core v1.10
// specific generator: Python binding Hpp Generator v0.971
// source: /home/jenkins/workspace/ICS-daily-and-weekly/ifw-rad-daily/rad/cpp/_examples/exmalif/src/exmalif.xml

#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
#endif

#include <array>
#include <string>
#include <memory>
#include <vector>
#include <iostream>
#include <sstream>
#include <chrono>
#include <cstdint>
#include <stdexcept>
#include <exception>
#include <utility>
#include <mal/Cii.hpp>
#include <mal/ps/DataEntity.hpp>
#include <mal/Mal.hpp>
#include <mal/rr/Ami.hpp>
#include <mal/rr/ServerAmi.hpp>
#include <pymal/delegates/ps/DataEntityBaseDelegate.hpp>
#include <pymal/delegates/ps/DataEventFilterBaseDelegate.hpp>
#include <pymal/delegates/ps/PublisherDelegate.hpp>
#include <pymal/delegates/ps/InstancePublisherDelegate.hpp>
#include <pymal/delegates/ps/SubscriberDelegate.hpp>
#include <pymal/delegates/ps/LoanedDataEntityDelegate.hpp>
#include <pymal/delegates/ps/DataEventFilterDelegate.hpp>
#include <pymal/delegates/ps/DataEventDelegate.hpp>
#include <pymal/delegates/ps/SubscriptionDelegate.hpp>
#include <pymal/delegates/ps/MrvSubscriberDelegate.hpp>
#include <pymal/delegates/rr/ClientRrEntityBaseDelegate.hpp>
#include <pymal/delegates/rr/AmiBaseDelegate.hpp>
#include <pymal/delegates/rr/AmiDelegate.hpp>
#include <pymal/delegates/rr/ServerAmiDelegate.hpp>
#include <pymal/delegates/rr/ServerContextDelegate.hpp>
#include <pymal/delegates/FutureDelegate.hpp>
#include <pymal/delegates/FutureUtil.hpp>

#include <Exmalif.hpp>

#ifdef __GNUC__
#pragma GCC visibility push(hidden)
#endif

#include <pymal/pybind11/pybind11.h>    // NOLINT
#include <pymal/pybind11/chrono.h>      // NOLINT
#include <pymal/pybind11/stl.h>         // NOLINT
#include <pymal/pybind11/stl_bind.h>    // NOLINT
#include <pymal/pybind11/functional.h>  // NOLINT


namespace py = pybind11;


namespace exmalif {




// generated -1534276328
class StdCmdsSyncDelegate:
  public virtual ::elt::mal::bindings::rr::ClientRrEntityBaseDelegate {
  public:
    StdCmdsSyncDelegate() = delete;
    StdCmdsSyncDelegate(const StdCmdsSyncDelegate&) = delete;
    StdCmdsSyncDelegate& operator=(const StdCmdsSyncDelegate&) = delete;
    StdCmdsSyncDelegate(StdCmdsSyncDelegate&&) = delete;

    explicit StdCmdsSyncDelegate(std::unique_ptr<StdCmdsSync> &other):
     pStdCmdsSync(std::move(other)), rStdCmdsSync(*pStdCmdsSync) {}
    explicit StdCmdsSyncDelegate(const StdCmdsSync& other):
     pStdCmdsSync(nullptr), rStdCmdsSync(const_cast<StdCmdsSync&>(other)) {}

    // RrClientEntity interface

    void close() override { rStdCmdsSync.close(); }

    ::elt::mal::bindings::FutureDelegate<void> asyncConnect() override {
      // Release GIL
      py::gil_scoped_release release;
      return ::elt::mal::bindings::FutureDelegate<void>(rStdCmdsSync.asyncConnect());
    }

    ::elt::mal::rr::ListenerRegistration registerConnectionListener(
      const ::elt::mal::rr::ClientRrEntity::ConnectionListener &listener) override {
       return rStdCmdsSync.registerConnectionListener(listener);
    }

    std::shared_ptr<::elt::mal::Mal> getMal() const override {
      return rStdCmdsSync.getMal();
    }

    // StdCmdsSync interface
    std::string Stop() {
      return rStdCmdsSync.Stop();
    }

    std::string Init() {
      return rStdCmdsSync.Init();
    }

    std::string Reset() {
      return rStdCmdsSync.Reset();
    }

    std::string Enable() {
      return rStdCmdsSync.Enable();
    }

    std::string Disable() {
      return rStdCmdsSync.Disable();
    }

    std::string Status() {
      return rStdCmdsSync.Status();
    }

    std::string Config() {
      return rStdCmdsSync.Config();
    }

    std::string Exit() {
      return rStdCmdsSync.Exit();
    }

    std::string SetLogLevel(const std::shared_ptr<::exmalif::LogInfo>& info) {
      return rStdCmdsSync.SetLogLevel(info);
    }

    std::string Preset(const std::shared_ptr<::exmalif::TelPosition>& pos) {
      return rStdCmdsSync.Preset(pos);
    }

    std::string Move(const std::shared_ptr<::exmalif::AxesPosition>& pos) {
      return rStdCmdsSync.Move(pos);
    }

    std::unique_ptr<::elt::mal::bindings::rr::AmiBaseDelegate> GetPresetProgress() {
      auto ami = rStdCmdsSync.GetPresetProgress();
      if (ami) {
        return std::unique_ptr<::elt::mal::bindings::rr::AmiBaseDelegate>(
          new ::elt::mal::bindings::rr::AmiDelegate<std::string,
           StdCmds>(ami));
      }
      return nullptr;
    }


    virtual ~StdCmdsSyncDelegate() = default;

  private:
    std::unique_ptr<StdCmdsSync> pStdCmdsSync;
    StdCmdsSync &rStdCmdsSync;
};



class StdCmdsAsyncDelegate:
  public virtual ::elt::mal::bindings::rr::ClientRrEntityBaseDelegate {
  public:
    StdCmdsAsyncDelegate() = delete;
    StdCmdsAsyncDelegate(const StdCmdsAsyncDelegate&) = delete;
    StdCmdsAsyncDelegate& operator=(const StdCmdsAsyncDelegate&) = delete;
    StdCmdsAsyncDelegate(StdCmdsAsyncDelegate&&) = delete;

    explicit StdCmdsAsyncDelegate(std::unique_ptr<StdCmdsAsync> &other):
     pStdCmdsAsync(std::move(other)), rStdCmdsAsync(*pStdCmdsAsync) {}
    explicit StdCmdsAsyncDelegate(const StdCmdsAsync& other):
     pStdCmdsAsync(nullptr), rStdCmdsAsync(const_cast<StdCmdsAsync&>(other)) {}

    // RrClientEntity interface

    void close() override { rStdCmdsAsync.close(); }

    ::elt::mal::bindings::FutureDelegate<void> asyncConnect() override {
      // Release GIL
      py::gil_scoped_release release;
      return ::elt::mal::bindings::FutureDelegate<void>(rStdCmdsAsync.asyncConnect());
    }

    ::elt::mal::rr::ListenerRegistration registerConnectionListener(
      const ::elt::mal::rr::ClientRrEntity::ConnectionListener &listener) override {
      return rStdCmdsAsync.registerConnectionListener(listener);
    }

    std::shared_ptr<::elt::mal::Mal> getMal() const override {
      return rStdCmdsAsync.getMal();
    }

    // StdCmdsAsync interface
    std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
     Stop() {
      return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
       new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
         rStdCmdsAsync.Stop()));
    }

    std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
     Init() {
      return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
       new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
         rStdCmdsAsync.Init()));
    }

    std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
     Reset() {
      return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
       new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
         rStdCmdsAsync.Reset()));
    }

    std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
     Enable() {
      return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
       new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
         rStdCmdsAsync.Enable()));
    }

    std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
     Disable() {
      return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
       new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
         rStdCmdsAsync.Disable()));
    }

    std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
     Status() {
      return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
       new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
         rStdCmdsAsync.Status()));
    }

    std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
     Config() {
      return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
       new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
         rStdCmdsAsync.Config()));
    }

    std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
     Exit() {
      return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
       new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
         rStdCmdsAsync.Exit()));
    }

    std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
     SetLogLevel(const std::shared_ptr<::exmalif::LogInfo>& info) {
      return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
       new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
         rStdCmdsAsync.SetLogLevel(info)));
    }

    std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
     Preset(const std::shared_ptr<::exmalif::TelPosition>& pos) {
      return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
       new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
         rStdCmdsAsync.Preset(pos)));
    }

    std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>
     Move(const std::shared_ptr<::exmalif::AxesPosition>& pos) {
      return std::unique_ptr<::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>>(
       new ::elt::mal::bindings::FutureDelegate<std::string, ::exmalif::StdCmds>(
         rStdCmdsAsync.Move(pos)));
    }

   std::unique_ptr<::elt::mal::bindings::rr::AmiBaseDelegate> GetPresetProgress() {
      auto ami = rStdCmdsAsync.GetPresetProgress();
      if (ami) {
        return std::unique_ptr<::elt::mal::bindings::rr::AmiBaseDelegate>(
          new ::elt::mal::bindings::rr::AmiDelegate<std::string,
           StdCmds>(ami));
      }
      return nullptr;
    }


    virtual ~StdCmdsAsyncDelegate() = default;

  private:
    std::unique_ptr<StdCmdsAsync> pStdCmdsAsync;
    StdCmdsAsync &rStdCmdsAsync;
};


class StdCmdsImpl: public virtual StdCmds {
 public:
   explicit StdCmdsImpl(py::object &pyImpl): mPyImpl(pyImpl) {}
    std::string Stop() {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Stop")();
      return pyresult.cast<std::string>();
    }
    std::string Init() {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Init")();
      return pyresult.cast<std::string>();
    }
    std::string Reset() {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Reset")();
      return pyresult.cast<std::string>();
    }
    std::string Enable() {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Enable")();
      return pyresult.cast<std::string>();
    }
    std::string Disable() {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Disable")();
      return pyresult.cast<std::string>();
    }
    std::string Status() {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Status")();
      return pyresult.cast<std::string>();
    }
    std::string Config() {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Config")();
      return pyresult.cast<std::string>();
    }
    std::string Exit() {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Exit")();
      return pyresult.cast<std::string>();
    }
    std::string SetLogLevel(const std::shared_ptr<::exmalif::LogInfo>& info) {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("SetLogLevel")(info);
      return pyresult.cast<std::string>();
    }
    std::string Preset(const std::shared_ptr<::exmalif::TelPosition>& pos) {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Preset")(pos);
      return pyresult.cast<std::string>();
    }
    std::string Move(const std::shared_ptr<::exmalif::AxesPosition>& pos) {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Move")(pos);
      return pyresult.cast<std::string>();
    }
    std::shared_ptr<::elt::mal::rr::Ami<std::string>>
     GetPresetProgress() override {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("GetPresetProgress")();
      ::elt::mal::bindings::rr::ServerAmiDelegate<std::string, StdCmds> &serverAmi =
       pyresult.cast<::elt::mal::bindings::rr::ServerAmiDelegate<std::string, StdCmds>&>();
       return serverAmi.getAmi();
    }


 private:
  py::object mPyImpl;

};



class AsyncStdCmdsImpl: public virtual AsyncStdCmds {
 public:
   explicit AsyncStdCmdsImpl(py::object &pyImpl): mPyImpl(pyImpl) {}
    ::elt::mal::future<std::string> Stop() {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Stop")();
      ::elt::mal::future<std::string> result = 
       ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
      return result;
    }
    ::elt::mal::future<std::string> Init() {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Init")();
      ::elt::mal::future<std::string> result = 
       ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
      return result;
    }
    ::elt::mal::future<std::string> Reset() {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Reset")();
      ::elt::mal::future<std::string> result = 
       ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
      return result;
    }
    ::elt::mal::future<std::string> Enable() {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Enable")();
      ::elt::mal::future<std::string> result = 
       ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
      return result;
    }
    ::elt::mal::future<std::string> Disable() {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Disable")();
      ::elt::mal::future<std::string> result = 
       ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
      return result;
    }
    ::elt::mal::future<std::string> Status() {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Status")();
      ::elt::mal::future<std::string> result = 
       ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
      return result;
    }
    ::elt::mal::future<std::string> Config() {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Config")();
      ::elt::mal::future<std::string> result = 
       ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
      return result;
    }
    ::elt::mal::future<std::string> Exit() {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Exit")();
      ::elt::mal::future<std::string> result = 
       ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
      return result;
    }
    ::elt::mal::future<std::string> SetLogLevel(const std::shared_ptr<::exmalif::LogInfo>& info) {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("SetLogLevel")(info);
      ::elt::mal::future<std::string> result = 
       ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
      return result;
    }
    ::elt::mal::future<std::string> Preset(const std::shared_ptr<::exmalif::TelPosition>& pos) {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Preset")(pos);
      ::elt::mal::future<std::string> result = 
       ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
      return result;
    }
    ::elt::mal::future<std::string> Move(const std::shared_ptr<::exmalif::AxesPosition>& pos) {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("Move")(pos);
      ::elt::mal::future<std::string> result = 
       ::elt::mal::bindings::pyFutToMal<std::string>(pyresult);
      return result;
    }
    std::shared_ptr<::elt::mal::rr::Ami<std::string>>
     GetPresetProgress() override {
      py::gil_scoped_acquire acquire;
      auto pyresult = mPyImpl.attr("GetPresetProgress")();
      ::elt::mal::bindings::rr::ServerAmiDelegate<std::string, StdCmds> &serverAmi =
       pyresult.cast<::elt::mal::bindings::rr::ServerAmiDelegate<std::string, StdCmds>&>();
       return serverAmi.getAmi();
    }

 private:
  py::object mPyImpl;

};

} // exmalif


#ifndef ICD_GEN_ARRAY_1632905179_HPP_
#define ICD_GEN_ARRAY_1632905179_HPP_
  PYBIND11_MAKE_OPAQUE(std::vector<std::shared_ptr<::exmalif::TelPosition>>);
#endif

#ifndef ICD_GEN_ARRAY_1286306241_HPP_
#define ICD_GEN_ARRAY_1286306241_HPP_
  PYBIND11_MAKE_OPAQUE(std::vector<std::shared_ptr<::exmalif::AxesPosition>>);
#endif

#ifndef ICD_GEN_ARRAY_1574765012_HPP_
#define ICD_GEN_ARRAY_1574765012_HPP_
  PYBIND11_MAKE_OPAQUE(std::vector<std::shared_ptr<::exmalif::LogInfo>>);
#endif

//  GENERATED MODULE END

#ifdef __GNUC__
#pragma GCC visibility pop
#pragma GCC diagnostic pop
#endif