boolean_node.hpp

#pragma once
 
#include <cctype>
 
#include "../global.hpp"
 
#include "integer_base_node.hpp"
#include "value_node.hpp"

#include "_detail/ihas_value_config.hpp"
#include "_detail/iconfigurable_register_node.hpp"
#include "_detail/iconfigurable_command_node.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace GevServer
  {

    class BooleanNode
        : public ValueNode
        , public Private::IHasValueConfig<IntegerBaseNodePtr>
    {
    public:
      explicit BooleanNode(HandleGuard<Node> &&guard)
          : ValueNode(std::move(guard))
      {
      }

      static BooleanNodePtr Create(const String &name, const GevServer::Namespace &nameSpace)
      {
        String okName = EnsureNodeNameOnly(name);
        return std::make_shared<BooleanNode>(HandleGuard<Node>(
            CExports::CreateGSBooleanNodeTyped(okName.data(), static_cast<CExports::TGSNamespace>(nameSpace))));
      }
      static BooleanNodePtr Create(const String &name, const GevServer::Namespace &nameSpace) {…}

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

      GenApi::AccessMode AccessMode() const override
      {
        auto value = GetTerminalRegisterNode<BooleanNode, IntegerBaseNodePtr>(this, [](Node *node) {
          auto hasValueConfig = dynamic_cast<Private::IHasValueConfig<IntegerBaseNodePtr> *>(node);
          return (dynamic_cast<Private::IConfigurableRegisterNode *>(node) || !hasValueConfig->ValueConfigAsNode())
                     ? 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<BooleanNode, IntegerBaseNodePtr>(this, [](Node *node) {
          auto hasValueConfig = dynamic_cast<Private::IHasValueConfig<IntegerBaseNodePtr> *>(node);
          return (dynamic_cast<Private::IConfigurableRegisterNode *>(node) || !hasValueConfig->ValueConfigAsNode())
                     ? true
                     : false;
        });
        if (value == nullptr)
          return GenApi::CacheMode::NoCache;
        else
          return value->CacheMode();
      }
      GenApi::CacheMode CacheMode() const override {…}

      template <class Rep, class Period>
      std::chrono::duration<Rep, Period> PollingTime() const
      {
        auto value = GetTerminalRegisterNode<BooleanNode, IntegerBaseNodePtr>(this, [](Node *node) {
          auto isRegisterNode = dynamic_cast<Private::IConfigurableRegisterNode *>(node);
          auto isCommandNode  = dynamic_cast<Private::IConfigurableCommandNode *>(node);
          return (isRegisterNode || isCommandNode) ? true : false;
        });
        if (value == nullptr)
          return std::chrono::duration<Rep, Period>::zero();
        else
          return value->template PollingTime<Rep, Period>();
      }
      std::chrono::duration<Rep, Period> PollingTime() const {…}

      std::int64_t OffValue() const
      {
        return GetInfoAsInt(NodeInfo::OffValue);
      }
      std::int64_t OffValue() const {…}

      void SetOffValue(const std::int64_t &value)
      {
        SetInfoAsInt(NodeInfo::OffValue, value);
      }
      void SetOffValue(const std::int64_t &value) {…}

      std::int64_t OnValue() const
      {
        return GetInfoAsInt(NodeInfo::OnValue);
      }
      std::int64_t OnValue() const {…}

      void SetOnValue(const std::int64_t &value)
      {
        SetInfoAsInt(NodeInfo::OnValue, value);
      }
      void SetOnValue(const std::int64_t &value) {…}


      bool Value() const
      {
        return (NativeCall<CExports::cvbbool_t>(
                   [&](CExports::cvbbool_t &value) { return CVB_CALL_CAPI(GSNGetAsBoolean(Handle(), value)); }))
                   ? true
                   : false;
      }
      bool Value() const {…}


      void SetValue(bool value)
      {
        NativeCall([&]() { return CVB_CALL_CAPI(GSNSetAsBoolean(Handle(), static_cast<CExports::cvbbool_t>(value))); });
      }
      void SetValue(bool value) {…}

      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 {…}
 
      IntegerBaseNodePtr ValueConfigAsNode() const override;

      template <class T>
      void SetValueConfig(const T & /*value*/)
      {
        throw std::runtime_error(
            "requested command 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;
        SetValue(b);
      }
      void FromString(const String &value) override {…}

      String ToString() const override
      {
        return Value() ? CVB_LIT("true") : CVB_LIT("false");
      }
      String ToString() const override {…}
    };
    class BooleanNode {…};
 
    template <>
    inline std::int64_t BooleanNode::ValueConfig<std::int64_t>() const
    {
      return GetInfoAsInt(NodeInfo::Value);
    }
 
    template <>
    inline void BooleanNode::SetValueConfig<std::int64_t>(const std::int64_t &value)
    {
      SetInfoAsInt(NodeInfo::Value, value);
    }
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb