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

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


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

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


  ::elt::mal::future<std::string> Stop() 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::Stop (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<::hellomalif::LogInfo>& info) override {
    const auto methodSeqNr = 8;

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


std::string Config() override {
    return unpackAsync(m_asyncClient.Config());
  }


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