Hellomalif.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.92
// source: /home/jenkins/workspace/ICS-daily-and-weekly/ifw-rad-daily/test/templates/genMalSm/hello/hellomalif/src/hellomalif.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/Mal.hpp>
#include <mal/IcdTypes.hpp>
#include <mal/utility/shared_vector.hpp>


namespace hellomalif {

// generated
class ExceptionErr : public std::exception {
 public:
  ExceptionErr(const std::string& _desc):
    desc(_desc) {}

  virtual std::string getDesc() const {
    return desc;
  }
  

  virtual const char* what() const noexcept { 
    return "::hellomalif::ExceptionErr";
  };
  
  virtual ~ExceptionErr() = default;

 protected:
  ExceptionErr() = default;
  std::string desc;
};


// 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;
  
  ::hellomalif::LogInfo& operator=(const ::hellomalif::LogInfo& other) {
    setLevel(other.getLevel());
    setLogger(other.getLogger());
    return *this;
  }
};



class StdCmds : public virtual ::elt::mal::rr::RrEntity {
 public:
  virtual std::string Init() = 0;
  virtual std::string Reset() = 0;
  virtual std::string Enable() = 0;
  virtual std::string Disable() = 0;
  virtual std::string Status() = 0;
  virtual std::string Config() = 0;
  virtual std::string Stop() = 0;
  virtual std::string Exit() = 0;
  virtual std::string SetLogLevel(const std::shared_ptr<::hellomalif::LogInfo>& info) = 0;

  static int typeHash() {
    return -1766698911;
  }

  virtual ~StdCmds() = default;
};

class AsyncStdCmds : public virtual ::elt::mal::rr::RrEntity {
 public:
  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> Status() = 0;
  virtual ::elt::mal::future<std::string> Config() = 0;
  virtual ::elt::mal::future<std::string> Stop() = 0;
  virtual ::elt::mal::future<std::string> Exit() = 0;
  virtual ::elt::mal::future<std::string> SetLogLevel(const std::shared_ptr<::hellomalif::LogInfo>& info) = 0;

  static int typeHash() {
    return -1766698911;
  }

  virtual ~AsyncStdCmds() = default;
};

class StdCmdsSync :
  public virtual ::hellomalif::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> Init() {
    ::elt::mal::promise<std::string> p;


    p.set_value(m_entity->Init());


    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Reset() {
    ::elt::mal::promise<std::string> p;


    p.set_value(m_entity->Reset());


    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Enable() {
    ::elt::mal::promise<std::string> p;


    p.set_value(m_entity->Enable());


    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Disable() {
    ::elt::mal::promise<std::string> p;


    p.set_value(m_entity->Disable());


    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Status() {
    ::elt::mal::promise<std::string> p;


    p.set_value(m_entity->Status());


    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Config() {
    ::elt::mal::promise<std::string> p;


    p.set_value(m_entity->Config());


    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Stop() {
    ::elt::mal::promise<std::string> p;


    p.set_value(m_entity->Stop());


    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Exit() {
    ::elt::mal::promise<std::string> p;


    p.set_value(m_entity->Exit());


    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> SetLogLevel(const std::shared_ptr<::hellomalif::LogInfo>& info) {
    ::elt::mal::promise<std::string> p;

    try {

    p.set_value(m_entity->SetLogLevel(info));

    } catch(::hellomalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    }

    return p.get_future();
  }
  

  virtual ~AsyncStdCmdsImplWrapper() = default;

 private:
    std::shared_ptr<StdCmds> m_entity;
};


} // hellomalif

namespace elt {
namespace mal {

template <>
struct MalTypeTraits<::hellomalif::LogInfo> {
  static const char* libraryName;
  static const char* name;
};

template <>
struct MalTypeTraits<::hellomalif::StdCmds, true> {
  static const char* libraryName;
  static const char* name;
};

template <>
struct MalTypeTraits<::hellomalif::StdCmdsSync, true> {
  static const char* libraryName;
  static const char* name;
};

template <>
struct MalTypeTraits<::hellomalif::StdCmdsAsync, true> {
  static const char* libraryName;
  static const char* name;
};

template <>
struct MalTypeTraits<::hellomalif::AsyncStdCmds, false> {
  static const char* libraryName;
  static const char* name;
};
}  // namespace mal
}  // namespace elt