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.96
// source: /home/eltdev/workspace/ICS/RAD/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/ps/Traceable.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 GetState() = 0;
  virtual std::string GetStatus() = 0;
  virtual std::string GetVersion() = 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 -1200413694;
  }
 
  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> GetState() = 0;
  virtual ::elt::mal::future<std::string> GetStatus() = 0;
  virtual ::elt::mal::future<std::string> GetVersion() = 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 -1200413694;
  }
 
  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;
 
    try {
 
    p.set_value(m_entity->Stop());
 
    } catch(::exmalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Init() {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->Init());
 
    } catch(::exmalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Reset() {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->Reset());
 
    } catch(::exmalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Enable() {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->Enable());
 
    } catch(::exmalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Disable() {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->Disable());
 
    } catch(::exmalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> GetState() {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->GetState());
 
    } catch(::exmalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> GetStatus() {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->GetStatus());
 
    } catch(::exmalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> GetVersion() {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->GetVersion());
 
    } catch(::exmalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Config() {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->Config());
 
    } catch(::exmalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Exit() {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->Exit());
 
    } catch(::exmalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    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);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Preset( const std::shared_ptr<::exmalif::TelPosition>& pos) {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->Preset(pos));
 
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    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);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    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