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"
#include "_detail/iconfigurable_register_node.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
  namespace GevServer
  {

    class CommandNode
        : public ValueNode
        , public Private::IConfigurableCommandNode
        , public Private::IHasValueConfig<IntegerBaseNodePtr>
    {
    public:
      explicit CommandNode(HandleGuard<Node> &&guard)
          : 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, const GevServer::Namespace &nameSpace) {…}

      static CommandNodePtr Create(const String &name)
      {
        return Create(ParseName(name), ParseNamespace(name));
      }
      static CommandNodePtr Create(const String &name) {…}

      GenApi::AccessMode AccessMode() const override
      {
        auto value = GetTerminalRegisterNode<CommandNode, IntegerBaseNodePtr>(
            this, [](Node *node) { return dynamic_cast<Private::IConfigurableRegisterNode *>(node) ? true : false; });
        if (value == nullptr)
          return GenApi::AccessMode::ReadWrite;
        else
          return value->AccessMode();
      }
      GenApi::AccessMode AccessMode() const override {…}

      GenApi::CacheMode CacheMode() const override
      {
        auto value = GetTerminalRegisterNode<CommandNode, IntegerBaseNodePtr>(
            this, [](Node *node) { return dynamic_cast<Private::IConfigurableRegisterNode *>(node) ? true : false; });
        if (value == nullptr)
          return GenApi::CacheMode::NoCache;
        else
          return value->CacheMode();
      }
      GenApi::CacheMode CacheMode() const override {…}

      bool IsStreamable() const override
      {
        return false;
      }
      bool IsStreamable() const override {…}
 
      [[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;
      }
      bool IsDone() const {…}

      void Execute()
      {
        NativeCall([&]() { return CVB_CALL_CAPI(GSNSetAsBoolean(Handle(), true)); });
      }
      void Execute() {…}

      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();
      }
      std::chrono::duration<Rep, Period> PollingTime() const {…}

      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());
      }
      void SetPollingTime(const std::chrono::duration<Rep, Period> &timespan) {…}

      template <class T>
      T CommandConfig() const
      {
        throw std::runtime_error(
            "requested command config type must be derived from IntegerBaseNode or "
            "of integral type");
      }
      T CommandConfig() const {…}

      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");
      }
      void SetCommandConfig(const T & /*value*/) {…}
 
      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");
      }
      T ValueConfig() const {…}

      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 SetValueConfig(const T & /*value*/) {…}

      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 = false;
        is >> std::boolalpha >> b;
        if (b)
          Execute();
      }
      void FromString(const String &value) override {…}

      String ToString() const override
      {
        return IsDone() ? CVB_LIT("true") : CVB_LIT("false");
      }
      String ToString() const override {…}
    };
    class CommandNode {…};
 
    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);
    }
 
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb