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.96
// source: /home/eltdev/workspace/ICS/RAD/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/ps/Traceable.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 GetState() = 0;
  virtual std::string GetStatus() = 0;
  virtual std::string GetVersion() = 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 -935828682;
  }
 
  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> GetState() = 0;
  virtual ::elt::mal::future<std::string> GetStatus() = 0;
  virtual ::elt::mal::future<std::string> GetVersion() = 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 -935828682;
  }
 
  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;
 
    try {
 
    p.set_value(m_entity->Init());
 
    } catch(::hellomalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Reset() {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->Reset());
 
    } catch(::hellomalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Enable() {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->Enable());
 
    } catch(::hellomalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Disable() {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->Disable());
 
    } catch(::hellomalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> GetState() {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->GetState());
 
    } catch(::hellomalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> GetStatus() {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->GetStatus());
 
    } catch(::hellomalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> GetVersion() {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->GetVersion());
 
    } catch(::hellomalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Stop() {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->Stop());
 
    } catch(::hellomalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    return p.get_future();
  }
  
  virtual ::elt::mal::future<std::string> Exit() {
    ::elt::mal::promise<std::string> p;
 
    try {
 
    p.set_value(m_entity->Exit());
 
    } catch(::hellomalif::ExceptionErr& exceptionerr) {
       p.set_exception(exceptionerr);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    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);
    } catch(const std::exception& ex) {
      p.set_exception(ex);
    }
 
    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