hellomalifOpcUaImpl.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/test/templates/genMalSm/hello/hellomalif/src/hellomalif.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 <Hellomalif.hpp>
 
 
namespace elt {
namespace mal {
namespace icd {
namespace opcua {
 
template <>
struct MalOpcUaTraits<::hellomalif::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<::hellomalif::LogInfo> makeImpl();
    static bool isImpl(const ::hellomalif::LogInfo* object);
};
 
}  // namespace opcua
}  // namespace icd
}  // namespace mal
}  // namespace elt
 
 
namespace generated {
namespace opcua {
 
namespace hellomalif {
class LogInfo:
    public ::hellomalif::LogInfo,
    public ::elt::mal::ps::OpcUaDataEntity<::hellomalif::LogInfo>
{
public:
  // ::hellomalif::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<::hellomalif::LogInfo> clone() const override {
    return std::unique_ptr<::hellomalif::LogInfo>(new LogInfo(*this));
  }
 
  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 LogInfo);
    return entity;
  }
 
  bool hasKey() const override {
    return false;
  }
 
  //::elt::mal::ps::OpcUaDataEntity
 
  size_t getDataValueCount() const override {
    return ::elt::mal::icd::opcua::MalOpcUaTraits<::hellomalif::LogInfo>::dataValueCount;
  }
 
  void setOpcUaDataValues(const UA_DataValue *resultIterator) override {
    resultIterator = dm_level.assignFromDataValue("::hellomalif::LogInfo.level", resultIterator);
    resultIterator = dm_logger.assignFromDataValue("::hellomalif::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 ::hellomalif::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<::hellomalif::LogInfo>::dataValueCount> m_dataValues;
};
 
 
class StdCmdsAsyncImpl :
  public virtual ::hellomalif::StdCmdsAsync,
  public virtual ::elt::mal::rr::OpcUaClientRrEntity<::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::OpcUaMal>& mal)
  :
    ::elt::mal::rr::OpcUaClientRrEntity<StdCmdsAsync>(uri, standardQoS, malSpecificProperties, mal)
  {}
 
 
  ::elt::mal::future<std::string> Init() 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::Init (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> Reset() 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::Reset (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> Enable() 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::Enable (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> Disable() 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::Disable (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> GetState() 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::GetState (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> GetStatus() 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::GetStatus (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> GetVersion() 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::GetVersion (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> Stop() 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::Stop (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> Exit() 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::Exit (return value)", &resultVariant);
        return result.get();
    };
 
    return callMethodAsync<std::string>(methodSeqNr, arguments, extractor);
  }
 
 
  ::elt::mal::future<std::string> SetLogLevel( const std::shared_ptr<::hellomalif::LogInfo>& info) override {
    const auto methodSeqNr = 9;
 
    ::elt::mal::icd::opcua::NestedStructure<::hellomalif::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);
  }
 
};
 
class StdCmdsSyncImpl :
  public virtual ::hellomalif::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 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 Stop() override {
    return unpackAsync(m_asyncClient.Stop());
  }
 
 
std::string Exit() override {
    return unpackAsync(m_asyncClient.Exit());
  }
 
 
std::string SetLogLevel( const std::shared_ptr<::hellomalif::LogInfo>& info) override {
    return unpackAsync(m_asyncClient.SetLogLevel(info));
  }
 
 
  ::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<::hellomalif::StdCmds> timeout(std::chrono::milliseconds newTimeout) override {
//     auto newInstance = std::unique_ptr<StdCmdsSyncImpl>(new StdCmdsSyncImpl(*this));
//     newInstance->m_timeout = newTimeout;
//     return std::unique_ptr<::hellomalif::StdCmds>(std::move(newInstance));
//   }
 
private:
  StdCmdsAsyncImpl m_asyncClient;
};
}  // namespace hellomalif
 
 
} // namespace opcua
} // namespace generated