Exmalif.hpp

Go to the documentation of this file.

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

#pragma once

#include <chrono>
#include <memory>
#include <stdexcept>
#include <string>


#include <mal/utility/future.hpp>
#include <mal/rr/RrEntity.hpp>
#include <mal/rr/Ami.hpp>
#include <mal/rr/ClientRrEntity.hpp>
#include <mal/ps/DataEntity.hpp>
#include <mal/Mal.hpp>
#include <mal/IcdTypes.hpp>
#include <mal/utility/shared_vector.hpp>


namespace exmalif {


// generated
class TelPosition : public ::elt::mal::ps::DataEntity<TelPosition> {
 public:
  static constexpr const char* TYPE_ID = "TelPosition";


  virtual float getRa() const = 0;
  virtual void setRa(float ra) = 0;

  virtual float getDec() const = 0;
  virtual void setDec(float dec) = 0;
  virtual ~TelPosition() = default;
  
  ::exmalif::TelPosition& operator=(const ::exmalif::TelPosition& other) {
    setRa(other.getRa());
    setDec(other.getDec());
    return *this;
  }
};


// generated
class AxesPosition : public ::elt::mal::ps::DataEntity<AxesPosition> {
 public:
  static constexpr const char* TYPE_ID = "AxesPosition";


  virtual float getAlt() const = 0;
  virtual void setAlt(float alt) = 0;

  virtual float getAz() const = 0;
  virtual void setAz(float az) = 0;
  virtual ~AxesPosition() = default;
  
  ::exmalif::AxesPosition& operator=(const ::exmalif::AxesPosition& other) {
    setAlt(other.getAlt());
    setAz(other.getAz());
    return *this;
  }
};


// generated
class LogInfo : public ::elt::mal::ps::DataEntity<LogInfo> {
 public:
  static constexpr const char* TYPE_ID = "LogInfo";


  virtual std::string getLevel() const = 0;
  virtual void setLevel(const std::string& level) = 0;

  virtual std::string getLogger() const = 0;
  virtual void setLogger(const std::string& logger) = 0;
  virtual ~LogInfo() = default;
  
  ::exmalif::LogInfo& operator=(const ::exmalif::LogInfo& other) {
    setLevel(other.getLevel());
    setLogger(other.getLogger());
    return *this;
  }
};

// generated
class ExceptionErr : public std::exception {
 public:
  ExceptionErr(const std::string& _desc, int32_t _code):
    desc(_desc), code(_code) {}

  virtual std::string getDesc() const {
    return desc;
  }
  
  virtual int32_t getCode() const {
    return code;
  }
  

  virtual const char* what() const noexcept { 
    return "::exmalif::ExceptionErr";
  };
  
  virtual ~ExceptionErr() = default;

 protected:
  ExceptionErr() = default;
  std::string desc;
  int32_t code;
};



class StdCmds : public virtual ::elt::mal::rr::RrEntity {
 public:
  virtual std::string Stop() = 0;
  virtual std::string Init() = 0;
  virtual std::string Reset() = 0;
  virtual std::string Enable() = 0;
  virtual std::string Disable() = 0;
  virtual std::string Status() = 0;
  virtual std::string Config() = 0;
  virtual std::string Exit() = 0;
  virtual std::string SetLogLevel(const std::shared_ptr<::exmalif::LogInfo>& info) = 0;
  virtual std::string Preset(const std::shared_ptr<::exmalif::TelPosition>& pos) = 0;
  virtual std::string Move(const std::shared_ptr<::exmalif::AxesPosition>& pos) = 0;
  virtual std::shared_ptr<::elt::mal::rr::Ami<std::string>> GetPresetProgress() = 0;

  static int typeHash() {
    return -1534276328;
  }

  virtual ~StdCmds() = default;
};

class AsyncStdCmds : public virtual ::elt::mal::rr::RrEntity {
 public:
  virtual ::elt::mal::future<std::string> Stop() = 0;
  virtual ::elt::mal::future<std::string> Init() = 0;
  virtual ::elt::mal::future<std::string> Reset() = 0;
  virtual ::elt::mal::future<std::string> Enable() = 0;
  virtual ::elt::mal::future<std::string> Disable() = 0;
  virtual ::elt::mal::future<std::string> Status() = 0;
  virtual ::elt::mal::future<std::string> Config() = 0;
  virtual ::elt::mal::future<std::string> Exit() = 0;
  virtual ::elt::mal::future<std::string> SetLogLevel(const std::shared_ptr<::exmalif::LogInfo>& info) = 0;
  virtual ::elt::mal::future<std::string> Preset(const std::shared_ptr<::exmalif::TelPosition>& pos) = 0;
  virtual ::elt::mal::future<std::string> Move(const std::shared_ptr<::exmalif::AxesPosition>& pos) = 0;
  virtual std::shared_ptr<::elt::mal::rr::Ami<std::string>> GetPresetProgress() = 0;

  static int typeHash() {
    return -1534276328;
  }

  virtual ~AsyncStdCmds() = default;
};

class StdCmdsSync :
  public virtual ::exmalif::StdCmds,
  public virtual ::elt::mal::rr::ClientRrEntity {
   //virtual StdCmdsSync timeout(std::chrono::milliseconds timeoutDuration) = 0;
};

class StdCmdsAsync :
  public virtual AsyncStdCmds,
  public virtual ::elt::mal::rr::ClientRrEntity {
};

class AsyncStdCmdsImplWrapper :
  public virtual AsyncStdCmds {
 public:
  explicit AsyncStdCmdsImplWrapper(
    const std::shared_ptr<StdCmds> &entity)
    : m_entity(entity) {}
 
  virtual ::elt::mal::future<std::string> Stop() {
    ::elt::mal::promise<std::string> p;


    p.set_value(m_entity->Stop());


    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Init() {
    ::elt::mal::promise<std::string> p;


    p.set_value(m_entity->Init());


    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Reset() {
    ::elt::mal::promise<std::string> p;


    p.set_value(m_entity->Reset());


    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Enable() {
    ::elt::mal::promise<std::string> p;


    p.set_value(m_entity->Enable());


    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Disable() {
    ::elt::mal::promise<std::string> p;


    p.set_value(m_entity->Disable());


    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Status() {
    ::elt::mal::promise<std::string> p;


    p.set_value(m_entity->Status());


    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Config() {
    ::elt::mal::promise<std::string> p;


    p.set_value(m_entity->Config());


    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Exit() {
    ::elt::mal::promise<std::string> p;


    p.set_value(m_entity->Exit());


    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> SetLogLevel(const std::shared_ptr<::exmalif::LogInfo>& info) {
    ::elt::mal::promise<std::string> p;

    try {

    p.set_value(m_entity->SetLogLevel(info));

    } catch(::exmalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    }

    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Preset(const std::shared_ptr<::exmalif::TelPosition>& pos) {
    ::elt::mal::promise<std::string> p;


    p.set_value(m_entity->Preset(pos));


    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Move(const std::shared_ptr<::exmalif::AxesPosition>& pos) {
    ::elt::mal::promise<std::string> p;

    try {

    p.set_value(m_entity->Move(pos));

    } catch(::exmalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    }

    return p.get_future();
  }
  
  virtual std::shared_ptr<::elt::mal::rr::Ami<std::string>> GetPresetProgress() {
    return m_entity->GetPresetProgress();
  }

  virtual ~AsyncStdCmdsImplWrapper() = default;

 private:
    std::shared_ptr<StdCmds> m_entity;
};


} // exmalif

namespace elt {
namespace mal {

template <>
struct MalTypeTraits<::exmalif::TelPosition> {
  static const char* libraryName;
  static const char* name;
};

template <>
struct MalTypeTraits<::exmalif::AxesPosition> {
  static const char* libraryName;
  static const char* name;
};

template <>
struct MalTypeTraits<::exmalif::LogInfo> {
  static const char* libraryName;
  static const char* name;
};

template <>
struct MalTypeTraits<::exmalif::StdCmds, true> {
  static const char* libraryName;
  static const char* name;
};

template <>
struct MalTypeTraits<::exmalif::StdCmdsSync, true> {
  static const char* libraryName;
  static const char* name;
};

template <>
struct MalTypeTraits<::exmalif::StdCmdsAsync, true> {
  static const char* libraryName;
  static const char* name;
};

template <>
struct MalTypeTraits<::exmalif::AsyncStdCmds, false> {
  static const char* libraryName;
  static const char* name;
};
}  // namespace mal
}  // namespace elt