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.6
// source: /home/jenkins/workspace/ICS-daily-and-weekly/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> Status() 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::Status (return value)", &resultVariant);
        return result.get();
    };

    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }


  ::elt::mal::future<std::string> Config() 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::Config (return value)", &resultVariant);
        return result.get();
    };

    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }


  ::elt::mal::future<std::string> Exit() 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::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 = 8;

    ::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 = 9;

    ::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 = 10;

    ::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 Status() override {
    return unpackAsync(m_asyncClient.Status());
  }


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