ZpbHellomalifImpl.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/test/templates/genMalSm/hello/hellomalif/src/hellomalif.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 hellomalif {
namespace zpb {

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

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

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


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

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

    ExceptionErrImpl(  const std::string& desc  ): ExceptionErrImpl() {
      setDesc(desc);
      }
  

  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();
  }

  void copy(const ::hellomalif::ExceptionErr &from) {
            setDesc(from.getDesc());
      };

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

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

   };

}  // namespace zpb
} // namespace hellomalif








namespace hellomalif {
namespace zpb {

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

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

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


  explicit LogInfoImpl(const ::generated::zpb::hellomalif::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<::hellomalif::LogInfo> clone() const override {
    return std::unique_ptr<::hellomalif::LogInfo>(new LogInfoImpl(getLevel(),getLogger()));
  }

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

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

  std::unique_ptr<::hellomalif::LogInfo> cloneKey() const override {
    std::unique_ptr<::hellomalif::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 ::hellomalif::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 hellomalif









namespace hellomalif {
namespace zpb {


template<typename Intf>
class StdCmdsAsyncImpl;


template<>
class StdCmdsAsyncImpl<::hellomalif::StdCmdsAsync>
  : public virtual ::elt::mal::rr::ClientAsyncImpl<::hellomalif::StdCmdsAsync,
    ::generated::zpb::hellomalif::StdCmds_Request,
    ::generated::zpb::hellomalif::StdCmds_Reply>,
    public virtual ::hellomalif::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<::hellomalif::StdCmdsAsync,
     ::generated::zpb::hellomalif::StdCmds_Request, ::generated::zpb::hellomalif::StdCmds_Reply>(
     uri, standardQoS, malSpecificProperties, zpbMal) {}

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



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

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::hellomalif::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::hellomalif::StdCmds_Request request;
    ::generated::zpb::hellomalif::StdCmds_Reset_In *params =
        new ::generated::zpb::hellomalif::StdCmds_Reset_In();



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

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::hellomalif::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::hellomalif::StdCmds_Request request;
    ::generated::zpb::hellomalif::StdCmds_Enable_In *params =
        new ::generated::zpb::hellomalif::StdCmds_Enable_In();



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

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::hellomalif::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::hellomalif::StdCmds_Request request;
    ::generated::zpb::hellomalif::StdCmds_Disable_In *params =
        new ::generated::zpb::hellomalif::StdCmds_Disable_In();



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

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::hellomalif::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::hellomalif::StdCmds_Request request;
    ::generated::zpb::hellomalif::StdCmds_Status_In *params =
        new ::generated::zpb::hellomalif::StdCmds_Status_In();



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

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::hellomalif::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::hellomalif::StdCmds_Request request;
    ::generated::zpb::hellomalif::StdCmds_Config_In *params =
        new ::generated::zpb::hellomalif::StdCmds_Config_In();



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

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::hellomalif::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> Stop() override {
    ::generated::zpb::hellomalif::StdCmds_Request request;
    ::generated::zpb::hellomalif::StdCmds_Stop_In *params =
        new ::generated::zpb::hellomalif::StdCmds_Stop_In();



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

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::hellomalif::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> Exit() override {
    ::generated::zpb::hellomalif::StdCmds_Request request;
    ::generated::zpb::hellomalif::StdCmds_Exit_In *params =
        new ::generated::zpb::hellomalif::StdCmds_Exit_In();



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

    return sendRequest(request).then([](
     ::elt::mal::future<::generated::zpb::hellomalif::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<::hellomalif::LogInfo>& info) override {
    ::generated::zpb::hellomalif::StdCmds_Request request;
    ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In *params =
        new ::generated::zpb::hellomalif::StdCmds_SetLogLevel_In();


     {
    auto _infoImpl = dynamic_cast< ::hellomalif::zpb::LogInfoImpl*>(info.get());
        if (_infoImpl) {
          *params->mutable_info() = **_infoImpl;
        } else {
          ::hellomalif::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::hellomalif::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(::hellomalif::zpb::ExceptionErrImpl(data.setloglevel().exexceptionerr()));
     }
     return (std::string)data.setloglevel().retval();
     });
     }

};


class StdCmdsSyncImpl : virtual public ::hellomalif::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 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 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 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<::hellomalif::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");
    }
  }



  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<::hellomalif::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<::hellomalif::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::hellomalif::StdCmds_Return>());

      return;
    }

    ::generated::zpb::hellomalif::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::hellomalif::StdCmds_Return>());

      return;
    }

    auto call = request.mutable_data();

    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::hellomalif::StdCmds_Return> data(
                               new ::generated::zpb::hellomalif::StdCmds_Return());

       auto out = new ::generated::zpb::hellomalif::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::hellomalif::StdCmds_Return> data(
                               new ::generated::zpb::hellomalif::StdCmds_Return());

       auto out = new ::generated::zpb::hellomalif::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::hellomalif::StdCmds_Return> data(
                               new ::generated::zpb::hellomalif::StdCmds_Return());

       auto out = new ::generated::zpb::hellomalif::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::hellomalif::StdCmds_Return> data(
                               new ::generated::zpb::hellomalif::StdCmds_Return());

       auto out = new ::generated::zpb::hellomalif::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::hellomalif::StdCmds_Return> data(
                               new ::generated::zpb::hellomalif::StdCmds_Return());

       auto out = new ::generated::zpb::hellomalif::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::hellomalif::StdCmds_Return> data(
                               new ::generated::zpb::hellomalif::StdCmds_Return());

       auto out = new ::generated::zpb::hellomalif::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_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::hellomalif::StdCmds_Return> data(
                               new ::generated::zpb::hellomalif::StdCmds_Return());

       auto out = new ::generated::zpb::hellomalif::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_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::hellomalif::StdCmds_Return> data(
                               new ::generated::zpb::hellomalif::StdCmds_Return());

       auto out = new ::generated::zpb::hellomalif::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< ::hellomalif::LogInfo>(new ::hellomalif::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::hellomalif::StdCmds_Return> data(
                               new ::generated::zpb::hellomalif::StdCmds_Return());

       auto out = new ::generated::zpb::hellomalif::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 (::hellomalif::ExceptionErr &e) {
          std::unique_ptr<::generated::zpb::hellomalif::StdCmds_Return> data(new ::generated::zpb::hellomalif::StdCmds_Return());

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

          auto out = new ::generated::zpb::hellomalif::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 {
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::hellomalif::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::hellomalif::StdCmds_Return> data) {
    ::generated::zpb::hellomalif::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::hellomalif::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::hellomalif::StdCmds_Return>());
  }

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


}  // namespace zpb
} // namespace hellomalif