boolean_node.hpp

#pragma once

#include <cctype>

#include "../global.hpp"

#include "integer_base_node.hpp"
#include "value_node.hpp"

#include "_detail/iconfigurable_boolean_node.hpp"
#include "_detail/ihas_value_config.hpp"

namespace Cvb
{
CVB_BEGIN_INLINE_NS

namespace GevServer
{

class BooleanNode
    : public ValueNode
    , public Private::IConfigurableBooleanNode
    , public Private::IHasValueConfig<IntegerBaseNodePtr>
{
public:
  BooleanNode(HandleGuard<Node> &&guard) noexcept : 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) { return Create(ParseName(name), ParseNamespace(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<GenApi::Private::IRegisterNode *>(node) || !hasValueConfig->ValueConfigAsNode()) ? true
                                                                                                            : false;
    });
    if (value == nullptr)
      return GenApi::AccessMode::ReadWrite;
    else
      return value->AccessMode();
  }

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

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

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

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

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

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


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


  void SetValue(bool value)
  {
    NativeCall([&]() { return CVB_CALL_CAPI(GSNSetAsBoolean(Handle(), static_cast<CExports::cvbbool_t>(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");
  }

  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 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;
    SetValue(b);
  }

  String ToString() const override { return Value() ? CVB_LIT("true") : CVB_LIT("false"); }
};

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);
}
}
CVB_END_INLINE_NS
}