exmalifOpcUaImpl.hpp

Go to the documentation of this file.

// GENERATED, DO NOT MANUALLY MODIFY
// generator core v1.10
// specific generator: C++ OPC UA .hpp Generator v0.61
// source: /home/eltdev/workspace/ICS/RAD/ifw-rad-daily/rad/cpp/_examples/exmalif/src/exmalif.xml
 
#pragma once
 
#include <mal/Mal.hpp>
#include <mal/OpcUaMal.hpp>
#include <mal/util/OpcUaUtil.hpp>
#include <mal/ps/OpcUaDataEntity.hpp>
#include <mal/rr/OpcUaClientRrEntity.hpp>
#include <mal/bindings/opcua/OpcUaIcdBindings.hpp>
#include <mal/types/malTypesOpcUaImpl.hpp>
 
#include <Exmalif.hpp>
 
 
namespace elt {
namespace mal {
namespace icd {
namespace opcua {
 
template <>
struct MalOpcUaTraits<::exmalif::TelPosition> {
    static constexpr size_t dataValueCount =
        0
        + ::elt::mal::icd::opcua::Scalar<float>::dataValueCount
        + ::elt::mal::icd::opcua::Scalar<float>::dataValueCount
    ;
 
    static std::unique_ptr<::exmalif::TelPosition> makeImpl();
    static bool isImpl(const ::exmalif::TelPosition* object);
};
 
template <>
struct MalOpcUaTraits<::exmalif::AxesPosition> {
    static constexpr size_t dataValueCount =
        0
        + ::elt::mal::icd::opcua::Scalar<float>::dataValueCount
        + ::elt::mal::icd::opcua::Scalar<float>::dataValueCount
    ;
 
    static std::unique_ptr<::exmalif::AxesPosition> makeImpl();
    static bool isImpl(const ::exmalif::AxesPosition* object);
};
 
template <>
struct MalOpcUaTraits<::exmalif::LogInfo> {
    static constexpr size_t dataValueCount =
        0
        + ::elt::mal::icd::opcua::Scalar<std::string>::dataValueCount
        + ::elt::mal::icd::opcua::Scalar<std::string>::dataValueCount
    ;
 
    static std::unique_ptr<::exmalif::LogInfo> makeImpl();
    static bool isImpl(const ::exmalif::LogInfo* object);
};
 
}  // namespace opcua
}  // namespace icd
}  // namespace mal
}  // namespace elt
 
 
namespace generated {
namespace opcua {
 
namespace exmalif {
class TelPosition:
    public ::exmalif::TelPosition,
    public ::elt::mal::ps::OpcUaDataEntity<::exmalif::TelPosition>
{
public:
  // ::exmalif::TelPosition
 
  float getRa() const override {
    return dm_ra.get();
  }
 
  void setRa(float value) override {
    dm_ra = value;
  }
 
  float getDec() const override {
    return dm_dec.get();
  }
 
  void setDec(float value) override {
    dm_dec = value;
  }
 
  // ::elt::mal::ps::DataEntity
 
  std::unique_ptr<::exmalif::TelPosition> clone() const override {
    return std::unique_ptr<::exmalif::TelPosition>(new TelPosition(*this));
  }
 
  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 TelPosition);
    return entity;
  }
 
  bool hasKey() const override {
    return false;
  }
 
  //::elt::mal::ps::OpcUaDataEntity
 
  size_t getDataValueCount() const override {
    return ::elt::mal::icd::opcua::MalOpcUaTraits<::exmalif::TelPosition>::dataValueCount;
  }
 
  void setOpcUaDataValues(const UA_DataValue *resultIterator) override {
    resultIterator = dm_ra.assignFromDataValue("::exmalif::TelPosition.ra", resultIterator);
    resultIterator = dm_dec.assignFromDataValue("::exmalif::TelPosition.dec", resultIterator);
  }
 
  const UA_DataValue* getOpcUaDataValues() const override {
    auto* fieldIterator = m_dataValues.data();
 
    fieldIterator = dm_ra.assignToDataValue(fieldIterator);
    fieldIterator = dm_dec.assignToDataValue(fieldIterator);
 
    return m_dataValues.data();
  }
 
  void copy(const ::exmalif::TelPosition& from) override {
    dm_ra = from.getRa();
    dm_dec = from.getDec();
  }
 
 
private:
    ::elt::mal::icd::opcua::Scalar<float> dm_ra;
    ::elt::mal::icd::opcua::Scalar<float> dm_dec;
 
    mutable std::array<UA_DataValue, ::elt::mal::icd::opcua::MalOpcUaTraits<::exmalif::TelPosition>::dataValueCount> m_dataValues;
};
 
class AxesPosition:
    public ::exmalif::AxesPosition,
    public ::elt::mal::ps::OpcUaDataEntity<::exmalif::AxesPosition>
{
public:
  // ::exmalif::AxesPosition
 
  float getAlt() const override {
    return dm_alt.get();
  }
 
  void setAlt(float value) override {
    dm_alt = value;
  }
 
  float getAz() const override {
    return dm_az.get();
  }
 
  void setAz(float value) override {
    dm_az = value;
  }
 
  // ::elt::mal::ps::DataEntity
 
  std::unique_ptr<::exmalif::AxesPosition> clone() const override {
    return std::unique_ptr<::exmalif::AxesPosition>(new AxesPosition(*this));
  }
 
  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 AxesPosition);
    return entity;
  }
 
  bool hasKey() const override {
    return false;
  }
 
  //::elt::mal::ps::OpcUaDataEntity
 
  size_t getDataValueCount() const override {
    return ::elt::mal::icd::opcua::MalOpcUaTraits<::exmalif::AxesPosition>::dataValueCount;
  }
 
  void setOpcUaDataValues(const UA_DataValue *resultIterator) override {
    resultIterator = dm_alt.assignFromDataValue("::exmalif::AxesPosition.alt", resultIterator);
    resultIterator = dm_az.assignFromDataValue("::exmalif::AxesPosition.az", resultIterator);
  }
 
  const UA_DataValue* getOpcUaDataValues() const override {
    auto* fieldIterator = m_dataValues.data();
 
    fieldIterator = dm_alt.assignToDataValue(fieldIterator);
    fieldIterator = dm_az.assignToDataValue(fieldIterator);
 
    return m_dataValues.data();
  }
 
  void copy(const ::exmalif::AxesPosition& from) override {
    dm_alt = from.getAlt();
    dm_az = from.getAz();
  }
 
 
private:
    ::elt::mal::icd::opcua::Scalar<float> dm_alt;
    ::elt::mal::icd::opcua::Scalar<float> dm_az;
 
    mutable std::array<UA_DataValue, ::elt::mal::icd::opcua::MalOpcUaTraits<::exmalif::AxesPosition>::dataValueCount> m_dataValues;
};
 
class LogInfo:
    public ::exmalif::LogInfo,
    public ::elt::mal::ps::OpcUaDataEntity<::exmalif::LogInfo>
{
public:
  // ::exmalif::LogInfo
 
  std::string getLevel() const override {
    return dm_level.get();
  }
 
  void setLevel(const std::string& value) override {
    dm_level = value;
  }
 
  std::string getLogger() const override {
    return dm_logger.get();
  }
 
  void setLogger(const std::string& value) override {
    dm_logger = value;
  }
 
  // ::elt::mal::ps::DataEntity
 
  std::unique_ptr<::exmalif::LogInfo> clone() const override {
    return std::unique_ptr<::exmalif::LogInfo>(new LogInfo(*this));
  }
 
  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 LogInfo);
    return entity;
  }
 
  bool hasKey() const override {
    return false;
  }
 
  //::elt::mal::ps::OpcUaDataEntity
 
  size_t getDataValueCount() const override {
    return ::elt::mal::icd::opcua::MalOpcUaTraits<::exmalif::LogInfo>::dataValueCount;
  }
 
  void setOpcUaDataValues(const UA_DataValue *resultIterator) override {
    resultIterator = dm_level.assignFromDataValue("::exmalif::LogInfo.level", resultIterator);
    resultIterator = dm_logger.assignFromDataValue("::exmalif::LogInfo.logger", resultIterator);
  }
 
  const UA_DataValue* getOpcUaDataValues() const override {
    auto* fieldIterator = m_dataValues.data();
 
    fieldIterator = dm_level.assignToDataValue(fieldIterator);
    fieldIterator = dm_logger.assignToDataValue(fieldIterator);
 
    return m_dataValues.data();
  }
 
  void copy(const ::exmalif::LogInfo& from) override {
    dm_level = from.getLevel();
    dm_logger = from.getLogger();
  }
 
 
private:
    ::elt::mal::icd::opcua::Scalar<std::string> dm_level;
    ::elt::mal::icd::opcua::Scalar<std::string> dm_logger;
 
    mutable std::array<UA_DataValue, ::elt::mal::icd::opcua::MalOpcUaTraits<::exmalif::LogInfo>::dataValueCount> m_dataValues;
};
 
 
class StdCmdsAsyncImpl :
  public virtual ::exmalif::StdCmdsAsync,
  public virtual ::elt::mal::rr::OpcUaClientRrEntity<::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::OpcUaMal>& mal)
  :
    ::elt::mal::rr::OpcUaClientRrEntity<StdCmdsAsync>(uri, standardQoS, malSpecificProperties, mal)
  {}
 
 
  ::elt::mal::future<std::string> Stop() override {
    const auto methodSeqNr = 0;
 
 
    constexpr size_t dataValueCount =
        0
    ;
 
    std::array<UA_Variant, dataValueCount> arguments;
 
    const auto extractor = [](const UA_Variant& resultVariant) {
        ::elt::mal::icd::opcua::Scalar<std::string> result;
        result.assignFromVariant("StdCmds::Stop (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> Init() override {
    const auto methodSeqNr = 1;
 
 
    constexpr size_t dataValueCount =
        0
    ;
 
    std::array<UA_Variant, dataValueCount> arguments;
 
    const auto extractor = [](const UA_Variant& resultVariant) {
        ::elt::mal::icd::opcua::Scalar<std::string> result;
        result.assignFromVariant("StdCmds::Init (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> Reset() override {
    const auto methodSeqNr = 2;
 
 
    constexpr size_t dataValueCount =
        0
    ;
 
    std::array<UA_Variant, dataValueCount> arguments;
 
    const auto extractor = [](const UA_Variant& resultVariant) {
        ::elt::mal::icd::opcua::Scalar<std::string> result;
        result.assignFromVariant("StdCmds::Reset (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> Enable() override {
    const auto methodSeqNr = 3;
 
 
    constexpr size_t dataValueCount =
        0
    ;
 
    std::array<UA_Variant, dataValueCount> arguments;
 
    const auto extractor = [](const UA_Variant& resultVariant) {
        ::elt::mal::icd::opcua::Scalar<std::string> result;
        result.assignFromVariant("StdCmds::Enable (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> Disable() override {
    const auto methodSeqNr = 4;
 
 
    constexpr size_t dataValueCount =
        0
    ;
 
    std::array<UA_Variant, dataValueCount> arguments;
 
    const auto extractor = [](const UA_Variant& resultVariant) {
        ::elt::mal::icd::opcua::Scalar<std::string> result;
        result.assignFromVariant("StdCmds::Disable (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> GetState() override {
    const auto methodSeqNr = 5;
 
 
    constexpr size_t dataValueCount =
        0
    ;
 
    std::array<UA_Variant, dataValueCount> arguments;
 
    const auto extractor = [](const UA_Variant& resultVariant) {
        ::elt::mal::icd::opcua::Scalar<std::string> result;
        result.assignFromVariant("StdCmds::GetState (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> GetStatus() override {
    const auto methodSeqNr = 6;
 
 
    constexpr size_t dataValueCount =
        0
    ;
 
    std::array<UA_Variant, dataValueCount> arguments;
 
    const auto extractor = [](const UA_Variant& resultVariant) {
        ::elt::mal::icd::opcua::Scalar<std::string> result;
        result.assignFromVariant("StdCmds::GetStatus (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> GetVersion() override {
    const auto methodSeqNr = 7;
 
 
    constexpr size_t dataValueCount =
        0
    ;
 
    std::array<UA_Variant, dataValueCount> arguments;
 
    const auto extractor = [](const UA_Variant& resultVariant) {
        ::elt::mal::icd::opcua::Scalar<std::string> result;
        result.assignFromVariant("StdCmds::GetVersion (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> Config() override {
    const auto methodSeqNr = 8;
 
 
    constexpr size_t dataValueCount =
        0
    ;
 
    std::array<UA_Variant, dataValueCount> arguments;
 
    const auto extractor = [](const UA_Variant& resultVariant) {
        ::elt::mal::icd::opcua::Scalar<std::string> result;
        result.assignFromVariant("StdCmds::Config (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> Exit() override {
    const auto methodSeqNr = 9;
 
 
    constexpr size_t dataValueCount =
        0
    ;
 
    std::array<UA_Variant, dataValueCount> arguments;
 
    const auto extractor = [](const UA_Variant& resultVariant) {
        ::elt::mal::icd::opcua::Scalar<std::string> result;
        result.assignFromVariant("StdCmds::Exit (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> SetLogLevel( const std::shared_ptr<::exmalif::LogInfo>& info) override {
    const auto methodSeqNr = 10;
 
    ::elt::mal::icd::opcua::NestedStructure<::exmalif::LogInfo> arg_info;
    arg_info = info;
 
    constexpr size_t dataValueCount =
        0
        + decltype(arg_info)::dataValueCount
    ;
 
    std::array<UA_Variant, dataValueCount> arguments;
    auto* argIterator = arguments.data();
 
    argIterator = arg_info.assignToVariant(argIterator);
 
    const auto extractor = [](const UA_Variant& resultVariant) {
        ::elt::mal::icd::opcua::Scalar<std::string> result;
        result.assignFromVariant("StdCmds::SetLogLevel (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> Preset( const std::shared_ptr<::exmalif::TelPosition>& pos) override {
    const auto methodSeqNr = 11;
 
    ::elt::mal::icd::opcua::NestedStructure<::exmalif::TelPosition> arg_pos;
    arg_pos = pos;
 
    constexpr size_t dataValueCount =
        0
        + decltype(arg_pos)::dataValueCount
    ;
 
    std::array<UA_Variant, dataValueCount> arguments;
    auto* argIterator = arguments.data();
 
    argIterator = arg_pos.assignToVariant(argIterator);
 
    const auto extractor = [](const UA_Variant& resultVariant) {
        ::elt::mal::icd::opcua::Scalar<std::string> result;
        result.assignFromVariant("StdCmds::Preset (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> Move( const std::shared_ptr<::exmalif::AxesPosition>& pos) override {
    const auto methodSeqNr = 12;
 
    ::elt::mal::icd::opcua::NestedStructure<::exmalif::AxesPosition> arg_pos;
    arg_pos = pos;
 
    constexpr size_t dataValueCount =
        0
        + decltype(arg_pos)::dataValueCount
    ;
 
    std::array<UA_Variant, dataValueCount> arguments;
    auto* argIterator = arguments.data();
 
    argIterator = arg_pos.assignToVariant(argIterator);
 
    const auto extractor = [](const UA_Variant& resultVariant) {
        ::elt::mal::icd::opcua::Scalar<std::string> result;
        result.assignFromVariant("StdCmds::Move (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  std::shared_ptr<::elt::mal::rr::Ami<std::string>> GetPresetProgress() {
    throw std::runtime_error("AMI is not implemented in OPC-UA");
  }
};
 
class StdCmdsSyncImpl :
  public virtual ::exmalif::StdCmdsSync,
  public virtual ::elt::mal::rr::OpcUaSyncClientBase
{
 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::OpcUaMal>& mal)
  :
    ::elt::mal::rr::OpcUaSyncClientBase(uri, standardQoS, malSpecificProperties, mal),
    m_asyncClient(uri, standardQoS, malSpecificProperties, mal)
  {}
 
 
std::string Stop() override {
    return unpackAsync(m_asyncClient.Stop());
  }
 
 
std::string Init() override {
    return unpackAsync(m_asyncClient.Init());
  }
 
 
std::string Reset() override {
    return unpackAsync(m_asyncClient.Reset());
  }
 
 
std::string Enable() override {
    return unpackAsync(m_asyncClient.Enable());
  }
 
 
std::string Disable() override {
    return unpackAsync(m_asyncClient.Disable());
  }
 
 
std::string GetState() override {
    return unpackAsync(m_asyncClient.GetState());
  }
 
 
std::string GetStatus() override {
    return unpackAsync(m_asyncClient.GetStatus());
  }
 
 
std::string GetVersion() override {
    return unpackAsync(m_asyncClient.GetVersion());
  }
 
 
std::string Config() override {
    return unpackAsync(m_asyncClient.Config());
  }
 
 
std::string Exit() override {
    return unpackAsync(m_asyncClient.Exit());
  }
 
 
std::string SetLogLevel( const std::shared_ptr<::exmalif::LogInfo>& info) override {
    return unpackAsync(m_asyncClient.SetLogLevel(info));
  }
 
 
std::string Preset( const std::shared_ptr<::exmalif::TelPosition>& pos) override {
    return unpackAsync(m_asyncClient.Preset(pos));
  }
 
 
std::string Move( const std::shared_ptr<::exmalif::AxesPosition>& pos) override {
    return unpackAsync(m_asyncClient.Move(pos));
  }
 
 
  std::shared_ptr<::elt::mal::rr::Ami<std::string>> GetPresetProgress() {
    throw std::runtime_error("AMI is not implemented in OPC-UA");
  }
 
  ::elt::mal::future<void> asyncConnect() override {
    return m_asyncClient.asyncConnect();
  }
 
  ::elt::mal::rr::ListenerRegistration
  registerConnectionListener(::elt::mal::rr::ClientRrEntity::ConnectionListener listener) override {
    return m_asyncClient.registerConnectionListener(std::move(listener));
  }
 
//   std::unique_ptr<::exmalif::StdCmds> timeout(std::chrono::milliseconds newTimeout) override {
//     auto newInstance = std::unique_ptr<StdCmdsSyncImpl>(new StdCmdsSyncImpl(*this));
//     newInstance->m_timeout = newTimeout;
//     return std::unique_ptr<::exmalif::StdCmds>(std::move(newInstance));
//   }
 
private:
  StdCmdsAsyncImpl m_asyncClient;
};
}  // namespace exmalif
 
 
} // namespace opcua
} // namespace generated