ZpbExmalifImpl.hpp

Go to the documentation of this file.

// GENERATED, DO NOT MANUALLY MODIFY
// generator core v1.10
// specific generator: C++ ZPB .hpp Generator v0.86
// source: /home/jenkins/workspace/ICS-daily-and-weekly/ifw-rad-daily/rad/cpp/_examples/exmalif/src/exmalif.xml

#pragma once

#include <memory>
#include <vector>
#include <string>
#include <algorithm>
#include <utility>

#include <boost/functional/hash.hpp>

#include <google/protobuf/io/zero_copy_stream_impl_lite.h>

#include <mal/Mal.hpp>
#include <mal/utility/future.hpp>
#include <mal/rr/ClientAsync.hpp>
#include <mal/rr/AmiZpb.hpp>
#include <mal/ps/ZpbDataEntity.hpp>
#include <mal/utility/Uri.hpp>
#include <mal/util/ZpbList.hpp>
#include <mal/types/ZpbMalTypes.hpp>
#include <mal/rr/ServerContextZpb.hpp>
#include <mal/rr/ServerContextZpbAmi.hpp>
#include <mal/rr/ServerContextProvider.hpp>




namespace exmalif {
namespace zpb {

// generated
class TelPositionImpl : public virtual ::exmalif::TelPosition,
   public virtual ::elt::mal::ps::ZpbDataEntity<::exmalif::TelPosition> {
 public:
  typedef ::generated::zpb::exmalif::TelPosition ZpbType;

  TelPositionImpl(): m_zpbObj(new ::generated::zpb::exmalif::TelPosition())
            {}

  explicit TelPositionImpl(::generated::zpb::exmalif::TelPosition* inner):
      m_zpbObj(inner, ::elt::mal::util::list::NoopDeleter<ZpbType*>())
          {}


  explicit TelPositionImpl(const ::generated::zpb::exmalif::TelPosition& inner):
      TelPositionImpl() {
      *m_zpbObj = inner;
    }

  TelPositionImpl(  float ra,     float dec  ): TelPositionImpl() {
      setRa(ra);
      setDec(dec);
      }


  TelPositionImpl(const TelPositionImpl &rhs): m_zpbObj(rhs.m_zpbObj) {}

  TelPositionImpl(TelPositionImpl &&rhs): m_zpbObj(std::move(rhs.m_zpbObj)) {}

  TelPositionImpl &operator=(const TelPositionImpl &that) {
    copy(that);
    return *this;
  }

  float getRa() const override {
    return m_zpbObj->ra();
  }

  void setRa(float ra) override {
    m_zpbObj->set_ra(ra);
      }
  float getDec() const override {
    return m_zpbObj->dec();
  }

  void setDec(float dec) override {
    m_zpbObj->set_dec(dec);
      }

  std::unique_ptr<::exmalif::TelPosition> clone() const override {
    return std::unique_ptr<::exmalif::TelPosition>(new TelPositionImpl(getRa(),getDec()));
  }

  bool keyEquals(const ::exmalif::TelPosition& other) const override {
      return false;
    }

  std::size_t keyHash() const {
    std::size_t seed = 0;
    return seed;
  }

  std::unique_ptr<::exmalif::TelPosition> cloneKey() const override {
    std::unique_ptr<::exmalif::TelPosition> entity(new TelPositionImpl());
    return entity;
  };

  bool hasKey() const override {
      return false;
    }

  bool toByteArray(zmq::message_t& msg) const override {
    msg.rebuild(m_zpbObj->ByteSizeLong());
    return m_zpbObj->SerializeToArray(msg.data(), msg.size());
  }

  bool toByteArray(std::string &output) const override {
    return m_zpbObj->SerializeToString(&output);
  }

  bool fromByteArray(const std::string &data) override {
    return m_zpbObj->ParseFromString(data);
  }
  
  bool fromByteArray(const void * data, std::size_t size) override {
    google::protobuf::io::ArrayInputStream ais(data, size);
    return m_zpbObj->ParseFromZeroCopyStream(&ais);
  }

  void copy(const ::exmalif::TelPosition &from) override {
            setRa(from.getRa());
            setDec(from.getDec());
      };

  operator ZpbType*() const {
      return &*m_zpbObj;
  }

  static int32_t typeHash() {
    return -1632905179;
  }

 private:
     
 std::shared_ptr<ZpbType> m_zpbObj;

     };

}  // namespace zpb
} // namespace exmalif








namespace exmalif {
namespace zpb {

// generated
class AxesPositionImpl : public virtual ::exmalif::AxesPosition,
   public virtual ::elt::mal::ps::ZpbDataEntity<::exmalif::AxesPosition> {
 public:
  typedef ::generated::zpb::exmalif::AxesPosition ZpbType;

  AxesPositionImpl(): m_zpbObj(new ::generated::zpb::exmalif::AxesPosition())
            {}

  explicit AxesPositionImpl(::generated::zpb::exmalif::AxesPosition* inner):
      m_zpbObj(inner, ::elt::mal::util::list::NoopDeleter<ZpbType*>())
          {}


  explicit AxesPositionImpl(const ::generated::zpb::exmalif::AxesPosition& inner):
      AxesPositionImpl() {
      *m_zpbObj = inner;
    }

  AxesPositionImpl(  float alt,     float az  ): AxesPositionImpl() {
      setAlt(alt);
      setAz(az);
      }


  AxesPositionImpl(const AxesPositionImpl &rhs): m_zpbObj(rhs.m_zpbObj) {}

  AxesPositionImpl(AxesPositionImpl &&rhs): m_zpbObj(std::move(rhs.m_zpbObj)) {}

  AxesPositionImpl &operator=(const AxesPositionImpl &that) {
    copy(that);
    return *this;
  }

  float getAlt() const override {
    return m_zpbObj->alt();
  }

  void setAlt(float alt) override {
    m_zpbObj->set_alt(alt);
      }
  float getAz() const override {
    return m_zpbObj->az();
  }

  void setAz(float az) override {
    m_zpbObj->set_az(az);
      }

  std::unique_ptr<::exmalif::AxesPosition> clone() const override {
    return std::unique_ptr<::exmalif::AxesPosition>(new AxesPositionImpl(getAlt(),getAz()));
  }

  bool keyEquals(const ::exmalif::AxesPosition& other) const override {
      return false;
    }

  std::size_t keyHash() const {
    std::size_t seed = 0;
    return seed;
  }

  std::unique_ptr<::exmalif::AxesPosition> cloneKey() const override {
    std::unique_ptr<::exmalif::AxesPosition> entity(new AxesPositionImpl());
    return entity;
  };

  bool hasKey() const override {
      return false;
    }

  bool toByteArray(zmq::message_t& msg) const override {
    msg.rebuild(m_zpbObj->ByteSizeLong());
    return m_zpbObj->SerializeToArray(msg.data(), msg.size());
  }

  bool toByteArray(std::string &output) const override {
    return m_zpbObj->SerializeToString(&output);
  }

  bool fromByteArray(const std::string &data) override {
    return m_zpbObj->ParseFromString(data);
  }
  
  bool fromByteArray(const void * data, std::size_t size) override {
    google::protobuf::io::ArrayInputStream ais(data, size);
    return m_zpbObj->ParseFromZeroCopyStream(&ais);
  }

  void copy(const ::exmalif::AxesPosition &from) override {
            setAlt(from.getAlt());
            setAz(from.getAz());
      };

  operator ZpbType*() const {
      return &*m_zpbObj;
  }

  static int32_t typeHash() {
    return -1286306241;
  }

 private:
     
 std::shared_ptr<ZpbType> m_zpbObj;

     };

}  // namespace zpb
} // namespace exmalif








namespace exmalif {
namespace zpb {

// generated
class LogInfoImpl : public virtual ::exmalif::LogInfo,
   public virtual ::elt::mal::ps::ZpbDataEntity<::exmalif::LogInfo> {
 public:
  typedef ::generated::zpb::exmalif::LogInfo ZpbType;

  LogInfoImpl(): m_zpbObj(new ::generated::zpb::exmalif::LogInfo())
            {}

  explicit LogInfoImpl(::generated::zpb::exmalif::LogInfo* inner):
      m_zpbObj(inner, ::elt::mal::util::list::NoopDeleter<ZpbType*>())
          {}


  explicit LogInfoImpl(const ::generated::zpb::exmalif::LogInfo& inner):
      LogInfoImpl() {
      *m_zpbObj = inner;
    }

  LogInfoImpl(  const std::string& level,     const std::string& logger  ): LogInfoImpl() {
      setLevel(level);
      setLogger(logger);
      }


  LogInfoImpl(const LogInfoImpl &rhs): m_zpbObj(rhs.m_zpbObj) {}

  LogInfoImpl(LogInfoImpl &&rhs): m_zpbObj(std::move(rhs.m_zpbObj)) {}

  LogInfoImpl &operator=(const LogInfoImpl &that) {
    copy(that);
    return *this;
  }

  std::string getLevel() const override {
    return m_zpbObj->level();
  }

  void setLevel(const std::string& level) override {
    m_zpbObj->set_level(level);
      }
  std::string getLogger() const override {
    return m_zpbObj->logger();
  }

  void setLogger(const std::string& logger) override {
    m_zpbObj->set_logger(logger);
      }

  std::unique_ptr<::exmalif::LogInfo> clone() const override {
    return std::unique_ptr<::exmalif::LogInfo>(new LogInfoImpl(getLevel(),getLogger()));
  }

  bool keyEquals(const ::exmalif::LogInfo& other) const override {
      return false;
    }

  std::size_t keyHash() const {
    std::size_t seed = 0;
    return seed;
  }

  std::unique_ptr<::exmalif::LogInfo> cloneKey() const override {
    std::unique_ptr<::exmalif::LogInfo> entity(new LogInfoImpl());
    return entity;
  };

  bool hasKey() const override {
      return false;
    }

  bool toByteArray(zmq::message_t& msg) const override {
    msg.rebuild(m_zpbObj->ByteSizeLong());
    return m_zpbObj->SerializeToArray(msg.data(), msg.size());
  }

  bool toByteArray(std::string &output) const override {
    return m_zpbObj->SerializeToString(&output);
  }

  bool fromByteArray(const std::string &data) override {
    return m_zpbObj->ParseFromString(data);
  }
  
  bool fromByteArray(const void * data, std::size_t size) override {
    google::protobuf::io::ArrayInputStream ais(data, size);
    return m_zpbObj->ParseFromZeroCopyStream(&ais);
  }

  void copy(const ::exmalif::LogInfo &from) override {
            setLevel(from.getLevel());
            setLogger(from.getLogger());
      };

  operator ZpbType*() const {
      return &*m_zpbObj;
  }

  static int32_t typeHash() {
    return -1574765012;
  }

 private:
     
 std::shared_ptr<ZpbType> m_zpbObj;

     };

}  // namespace zpb
} // namespace exmalif








namespace exmalif {
namespace zpb {

// generated
class ExceptionErrImpl : public ::exmalif::ExceptionErr {
 public:
  typedef ::generated::zpb::exmalif::ExceptionErr ZpbType;

  ExceptionErrImpl(): m_zpbObj(new ::generated::zpb::exmalif::ExceptionErr())
            {}

  explicit ExceptionErrImpl(::generated::zpb::exmalif::ExceptionErr* inner):
      m_zpbObj(inner, ::elt::mal::util::list::NoopDeleter<ZpbType*>())
          {}


  explicit ExceptionErrImpl(const ::generated::zpb::exmalif::ExceptionErr& inner):
      ExceptionErrImpl() {
      *m_zpbObj = inner;
    }

  explicit ExceptionErrImpl(const ::exmalif::ExceptionErr& malVal):
        ExceptionErrImpl() {
        copy(malVal);
      }

    ExceptionErrImpl(  const std::string& desc,     int32_t code  ): ExceptionErrImpl() {
      setDesc(desc);
      setCode(code);
      }
  

  ExceptionErrImpl(const ExceptionErrImpl &rhs): m_zpbObj(rhs.m_zpbObj) {}

  ExceptionErrImpl(ExceptionErrImpl &&rhs): m_zpbObj(std::move(rhs.m_zpbObj)) {}

  ExceptionErrImpl &operator=(const ExceptionErrImpl &that) {
    copy(that);
    return *this;
  }

  std::string getDesc() const override {
    return m_zpbObj->desc();
  }
  int32_t getCode() const override {
    return m_zpbObj->code();
  }

  void copy(const ::exmalif::ExceptionErr &from) {
            setDesc(from.getDesc());
            setCode(from.getCode());
      };

  operator ZpbType*() const {
      return &*m_zpbObj;
  }

 private:
     void setDesc(const std::string& desc) {
     m_zpbObj->set_desc(desc);
       }
      void setCode(int32_t code) {
     m_zpbObj->set_code(code);
       }
  
 std::shared_ptr<ZpbType> m_zpbObj;

     };

}  // namespace zpb
} // namespace exmalif







namespace elt {
namespace mal {
namespace rr {

template<>
class AmiZpb<std::string, ::generated::zpb::exmalif::StdCmds_Reply, ::generated::zpb::exmalif::StdCmds_GetPresetProgress_Out> :
  public AmiZpbHelper<std::string>,
  public ReplyObserver<::generated::zpb::exmalif::StdCmds_Reply> {
 public:
  void updateReply(const ::generated::zpb::exmalif::StdCmds_Reply& reply, bool isPending) {
    auto& data = reply.data();
    auto code = reply.header().code();

    if (code != ::elt::mal::zpb::rr::CompletionCode::COMPLETED) {
      std::ostringstream errMsg;

      errMsg << "Code:" << code << " Message:";
      reply.header().has_exceptionmessage() ?
      errMsg << reply.header().exceptionmessage() : errMsg << "Unknown error message";

      code == ::elt::mal::zpb::rr::CompletionCode::UNKNOWN_EXCEPTION ?
      handleCompletedExceptionally(::elt::mal::UnhandledRemoteException(errMsg.str())) :
      handleCompletedExceptionally(::elt::mal::MalException(errMsg.str()));

    } else if (isPending) {
      handlePending((std::string)data.getpresetprogress().retval());
    } else {
            handleCompleted((std::string)data.getpresetprogress().retval());
          }
  }

  void cancel() {}
};

}  // namespace rr
}  // namespace mal
}  // namespace elt



namespace exmalif {
namespace zpb {


template<typename Intf>
class StdCmdsAsyncImpl;


template<>
class StdCmdsAsyncImpl<::exmalif::StdCmdsAsync>
  : public virtual ::elt::mal::rr::ClientAsyncImpl<::exmalif::StdCmdsAsync,
    ::generated::zpb::exmalif::StdCmds_Request,
    ::generated::zpb::exmalif::StdCmds_Reply>,
    public virtual ::exmalif::StdCmdsAsync {
 public:
  StdCmdsAsyncImpl(
  const ::elt::mal::Uri &uri,
  const std::vector<std::shared_ptr<::elt::mal::rr::qos::QoS>> &standardQoS,
  const ::elt::mal::Mal::Properties &malSpecificProperties,
  const std::shared_ptr<::elt::mal::ZpbMal> &zpbMal):
     ::elt::mal::rr::ClientAsyncImpl<::exmalif::StdCmdsAsync,
     ::generated::zpb::exmalif::StdCmds_Request, ::generated::zpb::exmalif::StdCmds_Reply>(
     uri, standardQoS, malSpecificProperties, zpbMal) {}

    ::elt::mal::future<std::string> Stop() override {
    ::generated::zpb::exmalif::StdCmds_Request request;
    ::generated::zpb::exmalif::StdCmds_Stop_In *params =
        new ::generated::zpb::exmalif::StdCmds_Stop_In();



    request.mutable_data()->set_allocated_stop(params);

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::exmalif::StdCmds_Reply> replyFut) {
      auto reply = replyFut.get();
      auto code = reply.header().code();

      if (code != ::elt::mal::zpb::rr::CompletionCode::COMPLETED)  {
        std::ostringstream errMsg;

        errMsg << "Code:" << code << " Message:";
        reply.header().has_exceptionmessage() ?
          errMsg << reply.header().exceptionmessage() : errMsg << "Unknown error message";

        code == ::elt::mal::zpb::rr::CompletionCode::UNKNOWN_EXCEPTION ?
          ::elt::mal::throw_exception(::elt::mal::UnhandledRemoteException(errMsg.str())) :
          ::elt::mal::throw_exception(::elt::mal::MalException(errMsg.str()));
      }
      auto data = reply.data();
     return (std::string)data.stop().retval();
     });
     }

  ::elt::mal::future<std::string> Init() override {
    ::generated::zpb::exmalif::StdCmds_Request request;
    ::generated::zpb::exmalif::StdCmds_Init_In *params =
        new ::generated::zpb::exmalif::StdCmds_Init_In();



    request.mutable_data()->set_allocated_init(params);

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::exmalif::StdCmds_Reply> replyFut) {
      auto reply = replyFut.get();
      auto code = reply.header().code();

      if (code != ::elt::mal::zpb::rr::CompletionCode::COMPLETED)  {
        std::ostringstream errMsg;

        errMsg << "Code:" << code << " Message:";
        reply.header().has_exceptionmessage() ?
          errMsg << reply.header().exceptionmessage() : errMsg << "Unknown error message";

        code == ::elt::mal::zpb::rr::CompletionCode::UNKNOWN_EXCEPTION ?
          ::elt::mal::throw_exception(::elt::mal::UnhandledRemoteException(errMsg.str())) :
          ::elt::mal::throw_exception(::elt::mal::MalException(errMsg.str()));
      }
      auto data = reply.data();
     return (std::string)data.init().retval();
     });
     }

  ::elt::mal::future<std::string> Reset() override {
    ::generated::zpb::exmalif::StdCmds_Request request;
    ::generated::zpb::exmalif::StdCmds_Reset_In *params =
        new ::generated::zpb::exmalif::StdCmds_Reset_In();



    request.mutable_data()->set_allocated_reset(params);

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::exmalif::StdCmds_Reply> replyFut) {
      auto reply = replyFut.get();
      auto code = reply.header().code();

      if (code != ::elt::mal::zpb::rr::CompletionCode::COMPLETED)  {
        std::ostringstream errMsg;

        errMsg << "Code:" << code << " Message:";
        reply.header().has_exceptionmessage() ?
          errMsg << reply.header().exceptionmessage() : errMsg << "Unknown error message";

        code == ::elt::mal::zpb::rr::CompletionCode::UNKNOWN_EXCEPTION ?
          ::elt::mal::throw_exception(::elt::mal::UnhandledRemoteException(errMsg.str())) :
          ::elt::mal::throw_exception(::elt::mal::MalException(errMsg.str()));
      }
      auto data = reply.data();
     return (std::string)data.reset().retval();
     });
     }

  ::elt::mal::future<std::string> Enable() override {
    ::generated::zpb::exmalif::StdCmds_Request request;
    ::generated::zpb::exmalif::StdCmds_Enable_In *params =
        new ::generated::zpb::exmalif::StdCmds_Enable_In();



    request.mutable_data()->set_allocated_enable(params);

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::exmalif::StdCmds_Reply> replyFut) {
      auto reply = replyFut.get();
      auto code = reply.header().code();

      if (code != ::elt::mal::zpb::rr::CompletionCode::COMPLETED)  {
        std::ostringstream errMsg;

        errMsg << "Code:" << code << " Message:";
        reply.header().has_exceptionmessage() ?
          errMsg << reply.header().exceptionmessage() : errMsg << "Unknown error message";

        code == ::elt::mal::zpb::rr::CompletionCode::UNKNOWN_EXCEPTION ?
          ::elt::mal::throw_exception(::elt::mal::UnhandledRemoteException(errMsg.str())) :
          ::elt::mal::throw_exception(::elt::mal::MalException(errMsg.str()));
      }
      auto data = reply.data();
     return (std::string)data.enable().retval();
     });
     }

  ::elt::mal::future<std::string> Disable() override {
    ::generated::zpb::exmalif::StdCmds_Request request;
    ::generated::zpb::exmalif::StdCmds_Disable_In *params =
        new ::generated::zpb::exmalif::StdCmds_Disable_In();



    request.mutable_data()->set_allocated_disable(params);

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::exmalif::StdCmds_Reply> replyFut) {
      auto reply = replyFut.get();
      auto code = reply.header().code();

      if (code != ::elt::mal::zpb::rr::CompletionCode::COMPLETED)  {
        std::ostringstream errMsg;

        errMsg << "Code:" << code << " Message:";
        reply.header().has_exceptionmessage() ?
          errMsg << reply.header().exceptionmessage() : errMsg << "Unknown error message";

        code == ::elt::mal::zpb::rr::CompletionCode::UNKNOWN_EXCEPTION ?
          ::elt::mal::throw_exception(::elt::mal::UnhandledRemoteException(errMsg.str())) :
          ::elt::mal::throw_exception(::elt::mal::MalException(errMsg.str()));
      }
      auto data = reply.data();
     return (std::string)data.disable().retval();
     });
     }

  ::elt::mal::future<std::string> Status() override {
    ::generated::zpb::exmalif::StdCmds_Request request;
    ::generated::zpb::exmalif::StdCmds_Status_In *params =
        new ::generated::zpb::exmalif::StdCmds_Status_In();



    request.mutable_data()->set_allocated_status(params);

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::exmalif::StdCmds_Reply> replyFut) {
      auto reply = replyFut.get();
      auto code = reply.header().code();

      if (code != ::elt::mal::zpb::rr::CompletionCode::COMPLETED)  {
        std::ostringstream errMsg;

        errMsg << "Code:" << code << " Message:";
        reply.header().has_exceptionmessage() ?
          errMsg << reply.header().exceptionmessage() : errMsg << "Unknown error message";

        code == ::elt::mal::zpb::rr::CompletionCode::UNKNOWN_EXCEPTION ?
          ::elt::mal::throw_exception(::elt::mal::UnhandledRemoteException(errMsg.str())) :
          ::elt::mal::throw_exception(::elt::mal::MalException(errMsg.str()));
      }
      auto data = reply.data();
     return (std::string)data.status().retval();
     });
     }

  ::elt::mal::future<std::string> Config() override {
    ::generated::zpb::exmalif::StdCmds_Request request;
    ::generated::zpb::exmalif::StdCmds_Config_In *params =
        new ::generated::zpb::exmalif::StdCmds_Config_In();



    request.mutable_data()->set_allocated_config(params);

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::exmalif::StdCmds_Reply> replyFut) {
      auto reply = replyFut.get();
      auto code = reply.header().code();

      if (code != ::elt::mal::zpb::rr::CompletionCode::COMPLETED)  {
        std::ostringstream errMsg;

        errMsg << "Code:" << code << " Message:";
        reply.header().has_exceptionmessage() ?
          errMsg << reply.header().exceptionmessage() : errMsg << "Unknown error message";

        code == ::elt::mal::zpb::rr::CompletionCode::UNKNOWN_EXCEPTION ?
          ::elt::mal::throw_exception(::elt::mal::UnhandledRemoteException(errMsg.str())) :
          ::elt::mal::throw_exception(::elt::mal::MalException(errMsg.str()));
      }
      auto data = reply.data();
     return (std::string)data.config().retval();
     });
     }

  ::elt::mal::future<std::string> Exit() override {
    ::generated::zpb::exmalif::StdCmds_Request request;
    ::generated::zpb::exmalif::StdCmds_Exit_In *params =
        new ::generated::zpb::exmalif::StdCmds_Exit_In();



    request.mutable_data()->set_allocated_exit(params);

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::exmalif::StdCmds_Reply> replyFut) {
      auto reply = replyFut.get();
      auto code = reply.header().code();

      if (code != ::elt::mal::zpb::rr::CompletionCode::COMPLETED)  {
        std::ostringstream errMsg;

        errMsg << "Code:" << code << " Message:";
        reply.header().has_exceptionmessage() ?
          errMsg << reply.header().exceptionmessage() : errMsg << "Unknown error message";

        code == ::elt::mal::zpb::rr::CompletionCode::UNKNOWN_EXCEPTION ?
          ::elt::mal::throw_exception(::elt::mal::UnhandledRemoteException(errMsg.str())) :
          ::elt::mal::throw_exception(::elt::mal::MalException(errMsg.str()));
      }
      auto data = reply.data();
     return (std::string)data.exit().retval();
     });
     }

  ::elt::mal::future<std::string> SetLogLevel(const std::shared_ptr<::exmalif::LogInfo>& info) override {
    ::generated::zpb::exmalif::StdCmds_Request request;
    ::generated::zpb::exmalif::StdCmds_SetLogLevel_In *params =
        new ::generated::zpb::exmalif::StdCmds_SetLogLevel_In();


     {
    auto _infoImpl = dynamic_cast< ::exmalif::zpb::LogInfoImpl*>(info.get());
        if (_infoImpl) {
          *params->mutable_info() = **_infoImpl;
        } else {
          ::exmalif::zpb::LogInfoImpl _tmp;
          _tmp.copy(*info);
          *params->mutable_info() = **&_tmp;
        }
      }
    
    request.mutable_data()->set_allocated_setloglevel(params);

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::exmalif::StdCmds_Reply> replyFut) {
      auto reply = replyFut.get();
      auto code = reply.header().code();

      if (code != ::elt::mal::zpb::rr::CompletionCode::COMPLETED)  {
        std::ostringstream errMsg;

        errMsg << "Code:" << code << " Message:";
        reply.header().has_exceptionmessage() ?
          errMsg << reply.header().exceptionmessage() : errMsg << "Unknown error message";

        code == ::elt::mal::zpb::rr::CompletionCode::UNKNOWN_EXCEPTION ?
          ::elt::mal::throw_exception(::elt::mal::UnhandledRemoteException(errMsg.str())) :
          ::elt::mal::throw_exception(::elt::mal::MalException(errMsg.str()));
      }
      auto data = reply.data();
     if (data.setloglevel().has_exexceptionerr()) {
       ::elt::mal::throw_exception(::exmalif::zpb::ExceptionErrImpl(data.setloglevel().exexceptionerr()));
     }
     return (std::string)data.setloglevel().retval();
     });
     }

  ::elt::mal::future<std::string> Preset(const std::shared_ptr<::exmalif::TelPosition>& pos) override {
    ::generated::zpb::exmalif::StdCmds_Request request;
    ::generated::zpb::exmalif::StdCmds_Preset_In *params =
        new ::generated::zpb::exmalif::StdCmds_Preset_In();


     {
    auto _posImpl = dynamic_cast< ::exmalif::zpb::TelPositionImpl*>(pos.get());
        if (_posImpl) {
          *params->mutable_pos() = **_posImpl;
        } else {
          ::exmalif::zpb::TelPositionImpl _tmp;
          _tmp.copy(*pos);
          *params->mutable_pos() = **&_tmp;
        }
      }
    
    request.mutable_data()->set_allocated_preset(params);

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::exmalif::StdCmds_Reply> replyFut) {
      auto reply = replyFut.get();
      auto code = reply.header().code();

      if (code != ::elt::mal::zpb::rr::CompletionCode::COMPLETED)  {
        std::ostringstream errMsg;

        errMsg << "Code:" << code << " Message:";
        reply.header().has_exceptionmessage() ?
          errMsg << reply.header().exceptionmessage() : errMsg << "Unknown error message";

        code == ::elt::mal::zpb::rr::CompletionCode::UNKNOWN_EXCEPTION ?
          ::elt::mal::throw_exception(::elt::mal::UnhandledRemoteException(errMsg.str())) :
          ::elt::mal::throw_exception(::elt::mal::MalException(errMsg.str()));
      }
      auto data = reply.data();
     return (std::string)data.preset().retval();
     });
     }

  ::elt::mal::future<std::string> Move(const std::shared_ptr<::exmalif::AxesPosition>& pos) override {
    ::generated::zpb::exmalif::StdCmds_Request request;
    ::generated::zpb::exmalif::StdCmds_Move_In *params =
        new ::generated::zpb::exmalif::StdCmds_Move_In();


     {
    auto _posImpl = dynamic_cast< ::exmalif::zpb::AxesPositionImpl*>(pos.get());
        if (_posImpl) {
          *params->mutable_pos() = **_posImpl;
        } else {
          ::exmalif::zpb::AxesPositionImpl _tmp;
          _tmp.copy(*pos);
          *params->mutable_pos() = **&_tmp;
        }
      }
    
    request.mutable_data()->set_allocated_move(params);

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::exmalif::StdCmds_Reply> replyFut) {
      auto reply = replyFut.get();
      auto code = reply.header().code();

      if (code != ::elt::mal::zpb::rr::CompletionCode::COMPLETED)  {
        std::ostringstream errMsg;

        errMsg << "Code:" << code << " Message:";
        reply.header().has_exceptionmessage() ?
          errMsg << reply.header().exceptionmessage() : errMsg << "Unknown error message";

        code == ::elt::mal::zpb::rr::CompletionCode::UNKNOWN_EXCEPTION ?
          ::elt::mal::throw_exception(::elt::mal::UnhandledRemoteException(errMsg.str())) :
          ::elt::mal::throw_exception(::elt::mal::MalException(errMsg.str()));
      }
      auto data = reply.data();
     if (data.move().has_exexceptionerr()) {
       ::elt::mal::throw_exception(::exmalif::zpb::ExceptionErrImpl(data.move().exexceptionerr()));
     }
     return (std::string)data.move().retval();
     });
     }

  std::shared_ptr<::elt::mal::rr::Ami<std::string>> GetPresetProgress() override {
    ::generated::zpb::exmalif::StdCmds_Request request;
    ::generated::zpb::exmalif::StdCmds_GetPresetProgress_In *params =
        new ::generated::zpb::exmalif::StdCmds_GetPresetProgress_In();



    request.mutable_data()->set_allocated_getpresetprogress(params);

    auto ami = std::shared_ptr<::elt::mal::rr::Ami<std::string>>(
      new ::elt::mal::rr::AmiZpb<std::string, ::generated::zpb::exmalif::StdCmds_Reply,
        ::generated::zpb::exmalif::StdCmds_GetPresetProgress_Out>());

    auto observer =
      std::dynamic_pointer_cast<::elt::mal::rr::ReplyObserver<
        ::generated::zpb::exmalif::StdCmds_Reply>>(ami);

    sendRequestWithObserver(request, observer);
    return ami;

}

};


class StdCmdsSyncImpl : virtual public ::exmalif::StdCmdsSync {
 public:
  StdCmdsSyncImpl(
    const ::elt::mal::Uri &uri,
    const std::vector<std::shared_ptr<::elt::mal::rr::qos::QoS>> &standardQoS,
    const ::elt::mal::Mal::Properties &malSpecificProperties,
    const std::shared_ptr<::elt::mal::ZpbMal> &zpbMal)
    : m_delegate(uri, standardQoS, malSpecificProperties, zpbMal), m_timeoutMs{} {
    m_timeoutMs = ::elt::mal::util::getReplyTimeQoS(standardQoS);
  }

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

  std::string Stop() override {
    auto future = m_delegate.Stop();
    if (::elt::mal::future_status::ready
         == future.wait_for(boost::chrono::milliseconds(m_timeoutMs))) {
      return future.get();
    } else {
      throw ::elt::mal::TimeoutException("timeout");
    }
  }

  std::string Init() override {
    auto future = m_delegate.Init();
    if (::elt::mal::future_status::ready
         == future.wait_for(boost::chrono::milliseconds(m_timeoutMs))) {
      return future.get();
    } else {
      throw ::elt::mal::TimeoutException("timeout");
    }
  }

  std::string Reset() override {
    auto future = m_delegate.Reset();
    if (::elt::mal::future_status::ready
         == future.wait_for(boost::chrono::milliseconds(m_timeoutMs))) {
      return future.get();
    } else {
      throw ::elt::mal::TimeoutException("timeout");
    }
  }

  std::string Enable() override {
    auto future = m_delegate.Enable();
    if (::elt::mal::future_status::ready
         == future.wait_for(boost::chrono::milliseconds(m_timeoutMs))) {
      return future.get();
    } else {
      throw ::elt::mal::TimeoutException("timeout");
    }
  }

  std::string Disable() override {
    auto future = m_delegate.Disable();
    if (::elt::mal::future_status::ready
         == future.wait_for(boost::chrono::milliseconds(m_timeoutMs))) {
      return future.get();
    } else {
      throw ::elt::mal::TimeoutException("timeout");
    }
  }

  std::string Status() override {
    auto future = m_delegate.Status();
    if (::elt::mal::future_status::ready
         == future.wait_for(boost::chrono::milliseconds(m_timeoutMs))) {
      return future.get();
    } else {
      throw ::elt::mal::TimeoutException("timeout");
    }
  }

  std::string Config() override {
    auto future = m_delegate.Config();
    if (::elt::mal::future_status::ready
         == future.wait_for(boost::chrono::milliseconds(m_timeoutMs))) {
      return future.get();
    } else {
      throw ::elt::mal::TimeoutException("timeout");
    }
  }

  std::string Exit() override {
    auto future = m_delegate.Exit();
    if (::elt::mal::future_status::ready
         == future.wait_for(boost::chrono::milliseconds(m_timeoutMs))) {
      return future.get();
    } else {
      throw ::elt::mal::TimeoutException("timeout");
    }
  }

  std::string SetLogLevel(const std::shared_ptr<::exmalif::LogInfo>& info) override {
    auto future = m_delegate.SetLogLevel(info);
    if (::elt::mal::future_status::ready
         == future.wait_for(boost::chrono::milliseconds(m_timeoutMs))) {
      return future.get();
    } else {
      throw ::elt::mal::TimeoutException("timeout");
    }
  }

  std::string Preset(const std::shared_ptr<::exmalif::TelPosition>& pos) override {
    auto future = m_delegate.Preset(pos);
    if (::elt::mal::future_status::ready
         == future.wait_for(boost::chrono::milliseconds(m_timeoutMs))) {
      return future.get();
    } else {
      throw ::elt::mal::TimeoutException("timeout");
    }
  }

  std::string Move(const std::shared_ptr<::exmalif::AxesPosition>& pos) override {
    auto future = m_delegate.Move(pos);
    if (::elt::mal::future_status::ready
         == future.wait_for(boost::chrono::milliseconds(m_timeoutMs))) {
      return future.get();
    } else {
      throw ::elt::mal::TimeoutException("timeout");
    }
  }

  std::shared_ptr<::elt::mal::rr::Ami<std::string>> GetPresetProgress() override {
    return m_delegate.GetPresetProgress();
  }



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

  ::elt::mal::future<void> asyncConnect() override {
    return m_delegate.asyncConnect();
  }

  ::elt::mal::rr::ListenerRegistration registerConnectionListener(ConnectionListener listener) override {
    return m_delegate.registerConnectionListener(listener);
  }

 private:
  StdCmdsAsyncImpl<::exmalif::StdCmdsAsync> m_delegate;
  int64_t m_timeoutMs;
};


class AsyncStdCmdsImpl : virtual public ::elt::mal::rr::ZpbRrEntity {
 public:
  AsyncStdCmdsImpl(
    ::elt::mal::rr::ZpbServer &zpbServer,
    const std::shared_ptr<::exmalif::AsyncStdCmds> &entity,
    const std::shared_ptr<::elt::mal::Mal> &mal)
    : m_zpbServer(zpbServer), m_entity(entity), m_mal(mal) {}


  void processRequest(zmq::socket_t &socket,
                        const std::string &id, const std::string &topicIdFrame,
                        const std::string &headerFrame,
                        const ::elt::mal::zpb::rr::ZpbHeader &header) {
    if (!::elt::mal::util::getSocketHasRcvMore(socket)) {
      std::unique_ptr<::elt::mal::zpb::rr::ReplyHeader> unhandledExReplyHeader(
         new ::elt::mal::zpb::rr::ReplyHeader());

      unhandledExReplyHeader->set_code(::elt::mal::zpb::rr::CompletionCode::INVALID_ARGUMENT);
      unhandledExReplyHeader->set_exceptionmessage("missing request frame");

      sendReply(socket, id, topicIdFrame, headerFrame, std::move(unhandledExReplyHeader),
                  std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return>());

      return;
    }

    ::generated::zpb::exmalif::StdCmds_Request request;

    //auto requestStr = ::elt::mal::util::readFrame(socket);
    zmq::message_t msgFrame;
    socket.recv(&msgFrame, 0);

    if (!request.ParseFromArray(msgFrame.data(), msgFrame.size())) {
      std::unique_ptr<::elt::mal::zpb::rr::ReplyHeader> unhandledExReplyHeader(
         new ::elt::mal::zpb::rr::ReplyHeader());

      unhandledExReplyHeader->set_code(::elt::mal::zpb::rr::CompletionCode::INVALID_ARGUMENT);
      unhandledExReplyHeader->set_exceptionmessage("Invalid Request: Request parsing failed");

      sendReply(socket, id, topicIdFrame, headerFrame, std::move(unhandledExReplyHeader),
                    std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return>());

      return;
    }

    auto call = request.mutable_data();

    if (call->has_stop()) {
            auto params = call->mutable_stop();

      auto serverContext = std::unique_ptr<::elt::mal::rr::ServerContext<std::string>>(
        new ::elt::mal::rr::ServerContextZpb<std::string>(m_mal));

      ::elt::mal::rr::ServerContextProvider::setInstance<
        ::elt::mal::rr::ServerContext<std::string>>(serverContext);

      m_entity->Stop().then(m_zpbServer.getExecutor(), [this, &socket, id, topicIdFrame, headerFrame, params]
    (::elt::mal::future<std::string> f) {
    if (!f.has_exception()) {
       std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data(
                               new ::generated::zpb::exmalif::StdCmds_Return());

       auto out = new ::generated::zpb::exmalif::StdCmds_Stop_Out();

                   out->set_retval(f.get());
            
       data->set_allocated_stop(out);

       sendCompletedReply(socket, id, topicIdFrame, headerFrame, std::move(data));
    } else {
       sendUnhandledExceptionReply(socket, id, topicIdFrame, headerFrame, f.get_exception_ptr());
    }
        });

    } else if (call->has_init()) {
            auto params = call->mutable_init();

      auto serverContext = std::unique_ptr<::elt::mal::rr::ServerContext<std::string>>(
        new ::elt::mal::rr::ServerContextZpb<std::string>(m_mal));

      ::elt::mal::rr::ServerContextProvider::setInstance<
        ::elt::mal::rr::ServerContext<std::string>>(serverContext);

      m_entity->Init().then(m_zpbServer.getExecutor(), [this, &socket, id, topicIdFrame, headerFrame, params]
    (::elt::mal::future<std::string> f) {
    if (!f.has_exception()) {
       std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data(
                               new ::generated::zpb::exmalif::StdCmds_Return());

       auto out = new ::generated::zpb::exmalif::StdCmds_Init_Out();

                   out->set_retval(f.get());
            
       data->set_allocated_init(out);

       sendCompletedReply(socket, id, topicIdFrame, headerFrame, std::move(data));
    } else {
       sendUnhandledExceptionReply(socket, id, topicIdFrame, headerFrame, f.get_exception_ptr());
    }
        });

    } else if (call->has_reset()) {
            auto params = call->mutable_reset();

      auto serverContext = std::unique_ptr<::elt::mal::rr::ServerContext<std::string>>(
        new ::elt::mal::rr::ServerContextZpb<std::string>(m_mal));

      ::elt::mal::rr::ServerContextProvider::setInstance<
        ::elt::mal::rr::ServerContext<std::string>>(serverContext);

      m_entity->Reset().then(m_zpbServer.getExecutor(), [this, &socket, id, topicIdFrame, headerFrame, params]
    (::elt::mal::future<std::string> f) {
    if (!f.has_exception()) {
       std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data(
                               new ::generated::zpb::exmalif::StdCmds_Return());

       auto out = new ::generated::zpb::exmalif::StdCmds_Reset_Out();

                   out->set_retval(f.get());
            
       data->set_allocated_reset(out);

       sendCompletedReply(socket, id, topicIdFrame, headerFrame, std::move(data));
    } else {
       sendUnhandledExceptionReply(socket, id, topicIdFrame, headerFrame, f.get_exception_ptr());
    }
        });

    } else if (call->has_enable()) {
            auto params = call->mutable_enable();

      auto serverContext = std::unique_ptr<::elt::mal::rr::ServerContext<std::string>>(
        new ::elt::mal::rr::ServerContextZpb<std::string>(m_mal));

      ::elt::mal::rr::ServerContextProvider::setInstance<
        ::elt::mal::rr::ServerContext<std::string>>(serverContext);

      m_entity->Enable().then(m_zpbServer.getExecutor(), [this, &socket, id, topicIdFrame, headerFrame, params]
    (::elt::mal::future<std::string> f) {
    if (!f.has_exception()) {
       std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data(
                               new ::generated::zpb::exmalif::StdCmds_Return());

       auto out = new ::generated::zpb::exmalif::StdCmds_Enable_Out();

                   out->set_retval(f.get());
            
       data->set_allocated_enable(out);

       sendCompletedReply(socket, id, topicIdFrame, headerFrame, std::move(data));
    } else {
       sendUnhandledExceptionReply(socket, id, topicIdFrame, headerFrame, f.get_exception_ptr());
    }
        });

    } else if (call->has_disable()) {
            auto params = call->mutable_disable();

      auto serverContext = std::unique_ptr<::elt::mal::rr::ServerContext<std::string>>(
        new ::elt::mal::rr::ServerContextZpb<std::string>(m_mal));

      ::elt::mal::rr::ServerContextProvider::setInstance<
        ::elt::mal::rr::ServerContext<std::string>>(serverContext);

      m_entity->Disable().then(m_zpbServer.getExecutor(), [this, &socket, id, topicIdFrame, headerFrame, params]
    (::elt::mal::future<std::string> f) {
    if (!f.has_exception()) {
       std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data(
                               new ::generated::zpb::exmalif::StdCmds_Return());

       auto out = new ::generated::zpb::exmalif::StdCmds_Disable_Out();

                   out->set_retval(f.get());
            
       data->set_allocated_disable(out);

       sendCompletedReply(socket, id, topicIdFrame, headerFrame, std::move(data));
    } else {
       sendUnhandledExceptionReply(socket, id, topicIdFrame, headerFrame, f.get_exception_ptr());
    }
        });

    } else if (call->has_status()) {
            auto params = call->mutable_status();

      auto serverContext = std::unique_ptr<::elt::mal::rr::ServerContext<std::string>>(
        new ::elt::mal::rr::ServerContextZpb<std::string>(m_mal));

      ::elt::mal::rr::ServerContextProvider::setInstance<
        ::elt::mal::rr::ServerContext<std::string>>(serverContext);

      m_entity->Status().then(m_zpbServer.getExecutor(), [this, &socket, id, topicIdFrame, headerFrame, params]
    (::elt::mal::future<std::string> f) {
    if (!f.has_exception()) {
       std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data(
                               new ::generated::zpb::exmalif::StdCmds_Return());

       auto out = new ::generated::zpb::exmalif::StdCmds_Status_Out();

                   out->set_retval(f.get());
            
       data->set_allocated_status(out);

       sendCompletedReply(socket, id, topicIdFrame, headerFrame, std::move(data));
    } else {
       sendUnhandledExceptionReply(socket, id, topicIdFrame, headerFrame, f.get_exception_ptr());
    }
        });

    } else if (call->has_config()) {
            auto params = call->mutable_config();

      auto serverContext = std::unique_ptr<::elt::mal::rr::ServerContext<std::string>>(
        new ::elt::mal::rr::ServerContextZpb<std::string>(m_mal));

      ::elt::mal::rr::ServerContextProvider::setInstance<
        ::elt::mal::rr::ServerContext<std::string>>(serverContext);

      m_entity->Config().then(m_zpbServer.getExecutor(), [this, &socket, id, topicIdFrame, headerFrame, params]
    (::elt::mal::future<std::string> f) {
    if (!f.has_exception()) {
       std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data(
                               new ::generated::zpb::exmalif::StdCmds_Return());

       auto out = new ::generated::zpb::exmalif::StdCmds_Config_Out();

                   out->set_retval(f.get());
            
       data->set_allocated_config(out);

       sendCompletedReply(socket, id, topicIdFrame, headerFrame, std::move(data));
    } else {
       sendUnhandledExceptionReply(socket, id, topicIdFrame, headerFrame, f.get_exception_ptr());
    }
        });

    } else if (call->has_exit()) {
            auto params = call->mutable_exit();

      auto serverContext = std::unique_ptr<::elt::mal::rr::ServerContext<std::string>>(
        new ::elt::mal::rr::ServerContextZpb<std::string>(m_mal));

      ::elt::mal::rr::ServerContextProvider::setInstance<
        ::elt::mal::rr::ServerContext<std::string>>(serverContext);

      m_entity->Exit().then(m_zpbServer.getExecutor(), [this, &socket, id, topicIdFrame, headerFrame, params]
    (::elt::mal::future<std::string> f) {
    if (!f.has_exception()) {
       std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data(
                               new ::generated::zpb::exmalif::StdCmds_Return());

       auto out = new ::generated::zpb::exmalif::StdCmds_Exit_Out();

                   out->set_retval(f.get());
            
       data->set_allocated_exit(out);

       sendCompletedReply(socket, id, topicIdFrame, headerFrame, std::move(data));
    } else {
       sendUnhandledExceptionReply(socket, id, topicIdFrame, headerFrame, f.get_exception_ptr());
    }
        });

    } else if (call->has_setloglevel()) {
            auto params = call->mutable_setloglevel();

      auto serverContext = std::unique_ptr<::elt::mal::rr::ServerContext<std::string>>(
        new ::elt::mal::rr::ServerContextZpb<std::string>(m_mal));

      ::elt::mal::rr::ServerContextProvider::setInstance<
        ::elt::mal::rr::ServerContext<std::string>>(serverContext);

      m_entity->SetLogLevel(std::shared_ptr< ::exmalif::LogInfo>(new ::exmalif::zpb::LogInfoImpl(params->mutable_info()))).then(m_zpbServer.getExecutor(), [this, &socket, id, topicIdFrame, headerFrame, params]
    (::elt::mal::future<std::string> f) {
    if (!f.has_exception()) {
       std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data(
                               new ::generated::zpb::exmalif::StdCmds_Return());

       auto out = new ::generated::zpb::exmalif::StdCmds_SetLogLevel_Out();

                   out->set_retval(f.get());
            
       data->set_allocated_setloglevel(out);

       sendCompletedReply(socket, id, topicIdFrame, headerFrame, std::move(data));
    } else {
            try {
          ::elt::mal::rethrow_exception(f.get_exception_ptr());
        }
        catch (::exmalif::ExceptionErr &e) {
          std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data(new ::generated::zpb::exmalif::StdCmds_Return());

          ::exmalif::zpb::ExceptionErrImpl _ex(e);

          auto out = new ::generated::zpb::exmalif::StdCmds_SetLogLevel_Out();

          *out->mutable_exexceptionerr() = **&_ex;

          data->set_allocated_setloglevel(out);

          sendCompletedReply(socket, id, topicIdFrame, headerFrame, std::move(data));
        } catch (...) {}

        sendUnhandledExceptionReply(socket, id, topicIdFrame,
                  headerFrame, f.get_exception_ptr());
      }
        });

    } else if (call->has_preset()) {
            auto params = call->mutable_preset();

      auto serverContext = std::unique_ptr<::elt::mal::rr::ServerContext<std::string>>(
        new ::elt::mal::rr::ServerContextZpb<std::string>(m_mal));

      ::elt::mal::rr::ServerContextProvider::setInstance<
        ::elt::mal::rr::ServerContext<std::string>>(serverContext);

      m_entity->Preset(std::shared_ptr< ::exmalif::TelPosition>(new ::exmalif::zpb::TelPositionImpl(params->mutable_pos()))).then(m_zpbServer.getExecutor(), [this, &socket, id, topicIdFrame, headerFrame, params]
    (::elt::mal::future<std::string> f) {
    if (!f.has_exception()) {
       std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data(
                               new ::generated::zpb::exmalif::StdCmds_Return());

       auto out = new ::generated::zpb::exmalif::StdCmds_Preset_Out();

                   out->set_retval(f.get());
            
       data->set_allocated_preset(out);

       sendCompletedReply(socket, id, topicIdFrame, headerFrame, std::move(data));
    } else {
       sendUnhandledExceptionReply(socket, id, topicIdFrame, headerFrame, f.get_exception_ptr());
    }
        });

    } else if (call->has_move()) {
            auto params = call->mutable_move();

      auto serverContext = std::unique_ptr<::elt::mal::rr::ServerContext<std::string>>(
        new ::elt::mal::rr::ServerContextZpb<std::string>(m_mal));

      ::elt::mal::rr::ServerContextProvider::setInstance<
        ::elt::mal::rr::ServerContext<std::string>>(serverContext);

      m_entity->Move(std::shared_ptr< ::exmalif::AxesPosition>(new ::exmalif::zpb::AxesPositionImpl(params->mutable_pos()))).then(m_zpbServer.getExecutor(), [this, &socket, id, topicIdFrame, headerFrame, params]
    (::elt::mal::future<std::string> f) {
    if (!f.has_exception()) {
       std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data(
                               new ::generated::zpb::exmalif::StdCmds_Return());

       auto out = new ::generated::zpb::exmalif::StdCmds_Move_Out();

                   out->set_retval(f.get());
            
       data->set_allocated_move(out);

       sendCompletedReply(socket, id, topicIdFrame, headerFrame, std::move(data));
    } else {
            try {
          ::elt::mal::rethrow_exception(f.get_exception_ptr());
        }
        catch (::exmalif::ExceptionErr &e) {
          std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data(new ::generated::zpb::exmalif::StdCmds_Return());

          ::exmalif::zpb::ExceptionErrImpl _ex(e);

          auto out = new ::generated::zpb::exmalif::StdCmds_Move_Out();

          *out->mutable_exexceptionerr() = **&_ex;

          data->set_allocated_move(out);

          sendCompletedReply(socket, id, topicIdFrame, headerFrame, std::move(data));
        } catch (...) {}

        sendUnhandledExceptionReply(socket, id, topicIdFrame,
                  headerFrame, f.get_exception_ptr());
      }
        });

    } else if (call->has_getpresetprogress()) {
               auto serverContext = std::unique_ptr<::elt::mal::rr::ServerContext<std::string>>(
              new ::elt::mal::rr::ServerContextZpbAmi<std::string,
                ::exmalif::zpb::AsyncStdCmdsImpl,
                ::generated::zpb::exmalif::StdCmds_GetPresetProgress_Out>(
                *this, socket, id, topicIdFrame, headerFrame, header, m_mal));

            ::elt::mal::rr::ServerContextProvider::setInstance<
              ::elt::mal::rr::ServerContext<std::string>>(serverContext);

                try {
        m_entity->GetPresetProgress();
        } catch (std::exception &e) {
          auto ami = ::elt::mal::rr::ServerContextProvider::getInstance<
            ::elt::mal::rr::ServerContext<float>>().createAmi();
          if (ami) {
            ami->completeExceptionally(e);
          }
        }
      
} else {
std::unique_ptr<::elt::mal::zpb::rr::ReplyHeader> unhandledExReplyHeader(
   new ::elt::mal::zpb::rr::ReplyHeader());

unhandledExReplyHeader->set_code(::elt::mal::zpb::rr::CompletionCode::UNKNOWN_OPERATION);

sendReply(socket, id, topicIdFrame, headerFrame, std::move(unhandledExReplyHeader),
              std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return>());
}
  }

  void sendReply(
      zmq::socket_t &socket, const std::string &id, const std::string &topicIdFrame,
      const std::string &headerFrame,
      std::unique_ptr<::elt::mal::zpb::rr::ReplyHeader> replyHeader,
      std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data) {
    ::generated::zpb::exmalif::StdCmds_Reply reply;

    reply.set_allocated_header(replyHeader.release());

    if (data) {
      reply.set_allocated_data(data.release());
    }

    auto replyStr = reply.SerializeAsString();

    m_zpbServer.sendReply(socket, id, topicIdFrame, headerFrame, replyStr);
  }

  void sendCompletedReply(
      zmq::socket_t &socket, const std::string &id,
      const std::string &topicIdFrame, const std::string &headerFrame,
      std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data) {
    std::unique_ptr<::elt::mal::zpb::rr::ReplyHeader> completedReplyHeader(
    new ::elt::mal::zpb::rr::ReplyHeader());

    completedReplyHeader->set_code(::elt::mal::zpb::rr::CompletionCode::COMPLETED);

    sendReply(socket, id, topicIdFrame, headerFrame,
      std::move(completedReplyHeader), std::move(data));
  }

  void sendUnhandledExceptionReply(
      zmq::socket_t &socket, const std::string &id, const std::string &topicIdFrame,
        const std::string &headerFrame, ::elt::mal::exception_ptr exceptionPtr) {
    std::unique_ptr<::elt::mal::zpb::rr::ReplyHeader> unhandledExReplyHeader(
      new ::elt::mal::zpb::rr::ReplyHeader());

    unhandledExReplyHeader->set_code(::elt::mal::zpb::rr::CompletionCode::UNKNOWN_EXCEPTION);

    std::string exceptionMessage = "Unknown";

    try {
      ::elt::mal::rethrow_exception(exceptionPtr);
    } catch (std::exception &e) {
      exceptionMessage = e.what();
    } catch (...) {}

    unhandledExReplyHeader->set_exceptionmessage(exceptionMessage);

    sendReply(socket, id, topicIdFrame, headerFrame, std::move(unhandledExReplyHeader),
              std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return>());
  }

 private:
    ::elt::mal::rr::ZpbServer &m_zpbServer;
    std::shared_ptr<::exmalif::AsyncStdCmds> m_entity;
    const std::shared_ptr<::elt::mal::Mal>& m_mal;
};


}  // namespace zpb
} // namespace exmalif



namespace elt {
namespace mal {
namespace rr {


template<>
class ServerAmiZpb<std::string, ::exmalif::zpb::AsyncStdCmdsImpl, ::generated::zpb::exmalif::StdCmds_GetPresetProgress_Out> :
  public ::elt::mal::rr::ServerAmi<std::string> {
 public:
  ServerAmiZpb(::exmalif::zpb::AsyncStdCmdsImpl &replier,
               zmq::socket_t &socket,
               const std::string &id,
               const std::string &topicIdFrame,
               const std::string &headerFrame,
               const ::elt::mal::zpb::rr::ZpbHeader &header) :
    m_replier(replier),
    m_socket(socket),
    m_id(id),
    m_topicIdFrame(topicIdFrame),
    m_headerFrame(headerFrame),
    m_header(header) {}

  bool complete(const std::string& status) override {
    std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data(
      new ::generated::zpb::exmalif::StdCmds_Return());

    std::unique_ptr<::elt::mal::zpb::rr::ReplyHeader> replyHeader(
      new ::elt::mal::zpb::rr::ReplyHeader());

    replyHeader->set_code(::elt::mal::zpb::rr::CompletionCode::PENDING);

                 data->mutable_getpresetprogress()->set_retval(status);
         
    m_replier.sendReply(m_socket, m_id, m_topicIdFrame,
        m_headerFrame, std::move(replyHeader), std::move(data));

    return true;
  }

  bool completeExceptionally(const std::exception &ex) override {
    std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data(
      new ::generated::zpb::exmalif::StdCmds_Return());

        m_replier.sendUnhandledExceptionReply(m_socket, m_id, m_topicIdFrame,
      m_headerFrame, boost::copy_exception(ex));
        m_isCompleted = true;
    return true;
  }

  bool completed(const std::string& status) override {
    std::unique_ptr<::generated::zpb::exmalif::StdCmds_Return> data(
      new ::generated::zpb::exmalif::StdCmds_Return());

                 data->mutable_getpresetprogress()->set_retval(status);
         
    m_replier.sendCompletedReply(m_socket, m_id, m_topicIdFrame,
       m_headerFrame, std::move(data));

    m_isCompleted = true;
    return true;
  }

  bool isDone() override {
    return m_isCompleted;
  }

  future_type next() override {
    return future_type();
  }

 private:
  ::exmalif::zpb::AsyncStdCmdsImpl& m_replier;

  // replier arguments

  zmq::socket_t &m_socket;
  const std::string m_id;
  const std::string m_topicIdFrame;
  const std::string m_headerFrame;
  const ::elt::mal::zpb::rr::ZpbHeader m_header;
  bool m_isCompleted = false;
};


}  // namespace rr
}  // namespace mal
}  // namespace elt