command_node.hpp

#pragma once
 
#include <cctype>
 
#include "../global.hpp"
 
#include "integer_base_node.hpp"
#include "value_node.hpp"
 
#include "_detail/iconfigurable_command_node.hpp"
#include "_detail/ihas_value_config.hpp"
 
namespace Cvb
{
CVB_BEGIN_INLINE_NS
namespace GevServer
{
 
class CommandNode
    : public ValueNode
    , public Private::IConfigurableCommandNode
    , public Private::IHasValueConfig<IntegerBaseNodePtr>
{
public:
  CommandNode(HandleGuard<Node> &&guard) noexcept : ValueNode(std::move(guard)) {}
 
  static CommandNodePtr Create(const String &name, const GevServer::Namespace &nameSpace)
  {
    String okName = EnsureNodeNameOnly(name);
    return std::make_shared<CommandNode>(HandleGuard<Node>(
        CreateGSCommandNodeTyped(okName.data(), static_cast<CExports::TGSNamespace>(nameSpace))));
  }
 
  static CommandNodePtr Create(const String &name) { return Create(ParseName(name), ParseNamespace(name)); }
 
  GenApi::AccessMode AccessMode() const override
  {
    auto value = GetTerminalRegisterNode<CommandNode, IntegerBaseNodePtr>(
        this, [](Node *node) { return dynamic_cast<GenApi::Private::IRegisterNode *>(node) ? true : false; });
    if (value == nullptr)
      return GenApi::AccessMode::ReadWrite;
    else
      return value->AccessMode();
  }
 
  GenApi::CacheMode CacheMode() const override
  {
    auto value = GetTerminalRegisterNode<CommandNode, IntegerBaseNodePtr>(
        this, [](Node *node) { return dynamic_cast<GenApi::Private::IRegisterNode *>(node) ? true : false; });
    if (value == nullptr)
      return GenApi::CacheMode::NoCache;
    else
      return value->CacheMode();
  }
 
  bool IsStreamable() const override { return false; }
 
  [[noreturn]] void SetIsStreamable(const CExports::cvbint64_t & /*value*/) override
  {
    throw std::runtime_error("Command nodes cannot be streamed");
  }
 
  bool IsDone() const
  {
    return (NativeCall<CExports::cvbbool_t>(
               [&](CExports::cvbbool_t &value) { return CVB_CALL_CAPI(GSNGetAsBoolean(Handle(), value)); }))
               ? true
               : false;
  }
 
  void Execute()
  {
    NativeCall([&]() { return CVB_CALL_CAPI(GSNSetAsBoolean(Handle(), true)); });
  }
 
  template <class Rep, class Period> std::chrono::duration<Rep, Period> PollingTime() const
  {
    auto timespan = GetInfoAsInt(NodeInfo::PollingTime);
    if (timespan > 0)
      return std::chrono::duration<Rep, Period>(timespan);
    else
      return std::chrono::duration<Rep, Period>::zero();
  }
 
  template <class Rep, class Period> void SetPollingTime(const std::chrono::duration<Rep, Period> &timespan)
  {
    if (timespan == std::chrono::duration<Rep, Period>::zero())
      SetInfoAsInt(NodeInfo::PollingTime, -1);
    else
      SetInfoAsInt(NodeInfo::PollingTime, std::chrono::duration_cast<std::chrono::milliseconds>(timespan).count());
  }
 
  template <class T> T CommandConfig() const
  {
    throw std::runtime_error("requested command config type must be derived from IntegerBaseNode or "
                             "of integral type");
  }
 
  template <class T> void SetCommandConfig(const T & /*value*/)
  {
 
    throw std::runtime_error("requested command config type must be derived from "
                             "IntegerBaseNode or "
                             "of type std::int64_t");
  }
 
  IntegerBaseNodePtr ValueConfigAsNode() const override;
 
  template <class T> T ValueConfig() const
  {
    throw std::runtime_error("requested value config type must be derived from IntegerBaseNode or be "
                             "of type int64_t");
  }
 
  template <class T> void SetValueConfig(const T & /*value*/)
  {
    throw std::runtime_error("requested value config type must be derived from "
                             "IntegerBaseNode or be of integral type");
  }
 
  void FromString(const String &value) override
  {
    if (value.empty())
      throw std::runtime_error("String must not be empty");
 
    std::string str(Internal::CastToAscii(value));
    std::transform(str.begin(), str.end(), str.begin(), [](char ch)
    {
      return static_cast<char>(std::tolower(ch));
    });
    std::istringstream is(str);
    bool b;
    is >> std::boolalpha >> b;
    if (b)
      Execute();
  }
 
  String ToString() const override { return IsDone() ? CVB_LIT("true") : CVB_LIT("false"); }
};
 
template <> inline std::int64_t CommandNode::CommandConfig<std::int64_t>() const
{
  return GetInfoAsInt(NodeInfo::OnValue);
}
 
template <> inline IntegerBaseNodePtr CommandNode::CommandConfig<IntegerBaseNodePtr>() const
{
  return GetInfoAs<IntegerBaseNode>(NodeInfo::OnValue);
}
 
template <> inline void CommandNode::SetCommandConfig<std::int64_t>(const std::int64_t &value)
{
  SetInfoAsInt(NodeInfo::OnValue, value);
}
 
template <> inline std::int64_t CommandNode::ValueConfig<std::int64_t>() const
{
  return GetInfoAsInt(NodeInfo::Value);
}
 
template <> inline void CommandNode::SetValueConfig<std::int64_t>(const std::int64_t &value)
{
  SetInfoAsInt(NodeInfo::Value, value);
}
 
}
CVB_END_INLINE_NS
}