detail_node.hpp

#pragma once
 
#include <cassert>
#include <typeinfo>
 
#include "../../_cexports/c_gev_server.h"
 
#include "../../exception.hpp"
#include "../../global.hpp"
 
#include "../_decl/decl_node.hpp"
#include "../_decl/decl_node_map.hpp"
#include "../boolean_node.hpp"
#include "../category_node.hpp"
#include "../command_node.hpp"
#include "../enum_entry_node.hpp"
#include "../enumeration_node.hpp"
#include "../int_32_reg_node.hpp"
#include "../int_64_reg_node.hpp"
#include "../int_reg_node.hpp"
#include "../float_reg_node.hpp"
#include "../float_32_reg_node.hpp"
#include "../float_64_reg_node.hpp"
#include "../int_swiss_knife_node.hpp"
#include "../integer_base_node.hpp"
#include "../integer_node.hpp"
#include "../float_base_node.hpp"
#include "../float_node.hpp"
#include "../string_reg_node.hpp"
#include "../string_node.hpp"
#include "../value_node.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
  namespace GevServer
  {
    inline NodePtr Node::FromName(const NodeMapPtr &nodeMap, const String &name)
    {
      CExports::GSNODE handle = nullptr;
 
      auto result = CExports::GSGetNodeTyped(nodeMap->Handle(), name.c_str(), handle);
      if (result < 0)
        std::rethrow_exception(CvbException::FromCvbResult(result, "failed to get node"));
 
      HandleGuard<Node> guard(handle);
 
      CExports::TGSNodeType nodeType = CExports::GSNT_Invalid;
      result                         = CVB_CALL_CAPI(GSNType(guard.Handle(), nodeType));
      if (result < 0)
        std::rethrow_exception(CvbException::FromCvbResult(result, "failed to get node type"));
 
      NodePtr node = nullptr;
      switch (nodeType)
      {
        case CExports::GSNT_Invalid:
          throw std::runtime_error("invalid node type");
 
        case CExports::GSNT_Category:
          node = std::make_shared<CategoryNode>(std::move(guard));
          break;
 
        case CExports::GSNT_IntReg:
        {
          CExports::cvbint64_t registerLength = 0;
          result =
              CVB_CALL_CAPI(GSNGetInfoAsInteger(handle, CExports::TGSNodeInfo::GSNI_RegisterLength, registerLength));
          if (result < 0)
            std::rethrow_exception(CvbException::FromCvbResult(result, "failed to get node register length"));
 
          switch (registerLength)
          {
            case 4:
              node = std::make_shared<Int32RegNode>(std::move(guard));
              break;
            case 8:
              node = std::make_shared<Int64RegNode>(std::move(guard));
              break;
            default:
              node = std::make_shared<IntRegNode>(std::move(guard));
              break;
          }
          break;
        }
        case CExports::GSNT_FloatReg:
        {
          CExports::cvbint64_t registerLength = 0;
          result =
              CVB_CALL_CAPI(GSNGetInfoAsInteger(handle, CExports::TGSNodeInfo::GSNI_RegisterLength, registerLength));
          if (result < 0)
            std::rethrow_exception(CvbException::FromCvbResult(result, "failed to get node register length"));
 
          switch (registerLength)
          {
            case 4:
              node = std::make_shared<Float32RegNode>(std::move(guard));
              break;
            case 8:
              node = std::make_shared<Float64RegNode>(std::move(guard));
              break;
            default:
              node = std::make_shared<FloatRegNode>(std::move(guard));
              break;
          }
          break;
        }
        case CExports::GSNT_StringReg:
          node = std::make_shared<StringRegNode>(std::move(guard));
          break;
        case CExports::GSNT_String:
          node = std::make_shared<StringNode>(std::move(guard));
          break;
        case CExports::GSNT_Integer:
          node = std::make_shared<IntegerNode>(std::move(guard));
          break;
        case CExports::GSNT_Float:
          node = std::make_shared<FloatNode>(std::move(guard));
          break;
        case CExports::GSNT_Boolean:
          node = std::make_shared<BooleanNode>(std::move(guard));
          break;
        case CExports::GSNT_Command:
          node = std::make_shared<CommandNode>(std::move(guard));
          break;
        case CExports::GSNT_Enumeration:
          node = std::make_shared<EnumerationNode>(std::move(guard));
          break;
        case CExports::GSNT_EnumEntry:
          node = std::make_shared<EnumEntryNode>(std::move(guard));
          break;
        case CExports::GSNT_IntSwissKnife:
          node = std::make_shared<IntSwissKnifeNode>(std::move(guard));
          break;
 
        default:
          node = std::make_shared<Private::DefaultNode>(std::move(guard));
          break;
      }
 
      node->SetNodeMap(nodeMap);
 
      return node;
    }
    inline NodePtr Node::FromName(const NodeMapPtr &nodeMap, const String &name) {…}
 
    inline NodePtr Node::FromHandle(HandleGuard<Node> &&guard, const NodeMapPtr &nodeMap)
    {
      CExports::TGSNodeType nodeType = CExports::GSNT_Invalid;
      auto resultType                = CVB_CALL_CAPI(GSNType(guard.Handle(), nodeType));
      if (resultType < 0)
        throw std::runtime_error("failed to get node type");
 
      NodePtr node = nullptr;
      switch (nodeType)
      {
        case CExports::GSNT_Invalid:
          throw std::runtime_error("invalid node type");
        case CExports::GSNT_Category:
          node = std::make_shared<CategoryNode>(std::move(guard));
          break;
        case CExports::GSNT_IntReg:
        {
          std::int64_t length = 0;
          auto result =
              CVB_CALL_CAPI(GSNGetInfoAsInteger(guard.Handle(), CExports::TGSNodeInfo::GSNI_RegisterLength, length));
          if (result < 0)
            throw std::runtime_error("failed to get register length");
 
          switch (length)
          {
            case 4:
              node = std::make_shared<Int32RegNode>(std::move(guard));
              break;
            case 8:
              node = std::make_shared<Int64RegNode>(std::move(guard));
              break;
            default:
              node = std::make_shared<IntRegNode>(std::move(guard));
              break;
          }
        }
        break;
        case CExports::GSNT_FloatReg:
        {
          std::int64_t length = 0;
          auto result =
              CVB_CALL_CAPI(GSNGetInfoAsInteger(guard.Handle(), CExports::TGSNodeInfo::GSNI_RegisterLength, length));
          if (result < 0)
            throw std::runtime_error("failed to get register length");
 
          switch (length)
          {
            case 4:
              node = std::make_shared<Float32RegNode>(std::move(guard));
              break;
            case 8:
              node = std::make_shared<Float64RegNode>(std::move(guard));
              break;
            default:
              node = std::make_shared<FloatRegNode>(std::move(guard));
              break;
          }
        }
        break;
        case CExports::GSNT_StringReg:
          node = std::make_shared<StringRegNode>(std::move(guard));
          break;
        case CExports::GSNT_String:
          node = std::make_shared<StringNode>(std::move(guard));
          break;
        case CExports::GSNT_Integer:
          node = std::make_shared<IntegerNode>(std::move(guard));
          break;
        case CExports::GSNT_Float:
          node = std::make_shared<FloatNode>(std::move(guard));
          break;
        case CExports::GSNT_Boolean:
          node = std::make_shared<BooleanNode>(std::move(guard));
          break;
        case CExports::GSNT_Command:
          node = std::make_shared<CommandNode>(std::move(guard));
          break;
        case CExports::GSNT_Enumeration:
          node = std::make_shared<EnumerationNode>(std::move(guard));
          break;
        case CExports::GSNT_EnumEntry:
          node = std::make_shared<EnumEntryNode>(std::move(guard));
          break;
        case CExports::GSNT_IntSwissKnife:
          node = std::make_shared<IntSwissKnifeNode>(std::move(guard));
          break;
        default:
          node = std::make_shared<Private::DefaultNode>(std::move(guard));
          break;
      }
 
      node->SetNodeMap(nodeMap);
 
      return node;
    }
    inline NodePtr Node::FromHandle(HandleGuard<Node> &&guard, const NodeMapPtr &nodeMap) {…}
 
    inline void Node::Add(const NodePtr &item, const NodeList &kind)
    {
      if (item == nullptr)
        throw std::runtime_error("Added Node must not be nullptr");
 
      auto nodeMap = nodeMap_.lock();
      if (!nodeMap)
        throw std::runtime_error("Parent Node must have node map");
 
      // Ignore node map check for inline enum entries if parent is enumeration
      bool enumWithInlineEntries = false;
      NodePtr nonInlineNode      = nodeMap_.lock()->TryGetNode(item->NameOnly());
      auto nType                 = NodeType(this->Handle());
      if (nType == GevServer::NodeType::Enumeration && nonInlineNode == NodePtr())
        enumWithInlineEntries = true;
 
      if (!enumWithInlineEntries)
        if (item->NodeMap() != NodeMapPtr() && nodeMap->Handle() != item->NodeMap()->Handle())
          throw std::runtime_error("Added Node must be in the same node map as this Parent");
 
      NativeCall([&]() {
        return CVB_CALL_CAPI(GSNAddNode(Handle(), static_cast<CExports::TGSNodeList>(kind), item->Handle()));
      });
 
      // Add node map to item if it is enum entry and parent is enumeration
      if (enumWithInlineEntries)
        item->SetNodeMap(nodeMap);
 
      nodeMap->Nodes()[item->NameOnly()] = item;
    }
    inline void Node::Add(const NodePtr &item, const NodeList &kind) {…}
 
    inline bool Node::Remove(const NodePtr &item, const NodeList &kind)
    {
      if (item == nullptr)
        throw std::runtime_error("Added Node must not be nullptr");
 
      auto nodeMap = nodeMap_.lock();
      if (!nodeMap)
        throw std::runtime_error("Parent Node must have node map");
 
      auto nodes_ = nodeMap->Nodes();
      auto it     = nodes_.find(item->NameOnly());
      if (it != nodes_.end())
      {
        nodes_.erase(it);
        NativeCall([&]() {
          return CVB_CALL_CAPI(GSNRemoveNode(Handle(), static_cast<CExports::TGSNodeList>(kind), item->Handle()));
        });
        return true;
      }
      return false;
    }
    inline bool Node::Remove(const NodePtr &item, const NodeList &kind) {…}
 
    inline IntegerBaseNodePtr Node::IsImplementedConfig() const
    {
      return GetInfoAs<IntegerBaseNode>(NodeInfo::IsImplemented);
    }
    inline IntegerBaseNodePtr Node::IsImplementedConfig() const {…}
 
    inline void Node::SetIsImplementedConfig(const IntegerBaseNodePtr &node)
    {
      SetInfo<IntegerBaseNodePtr>(NodeInfo::IsImplemented, node);
    }
    inline void Node::SetIsImplementedConfig(const IntegerBaseNodePtr &node) {…}
 
    inline IntegerBaseNodePtr Node::IsAvailableConfig() const
    {
      return GetInfoAs<IntegerBaseNode>(NodeInfo::IsAvailable);
    }
    inline IntegerBaseNodePtr Node::IsAvailableConfig() const {…}
 
    inline void Node::SetIsAvailableConfig(const IntegerBaseNodePtr &node)
    {
      SetInfo<IntegerBaseNodePtr>(NodeInfo::IsAvailable, node);
    }
    inline void Node::SetIsAvailableConfig(const IntegerBaseNodePtr &node) {…}
 
    inline IntegerBaseNodePtr Node::IsLockedConfig() const
    {
      return GetInfoAs<IntegerBaseNode>(NodeInfo::IsLocked);
    }
    inline IntegerBaseNodePtr Node::IsLockedConfig() const {…}
 
    inline void Node::SetIsLockedConfig(const IntegerBaseNodePtr &node)
    {
      SetInfo<IntegerBaseNodePtr>(NodeInfo::IsLocked, node);
    }
    inline void Node::SetIsLockedConfig(const IntegerBaseNodePtr &node) {…}
 
    inline bool Node::IsFeature() const
    {
      auto nm = nodeMap_.lock();
      if (!nm)
        return false;
 
      CategoryNodePtr root = nm->Node<CategoryNode>(CVB_LIT("Root"));
 
      return IsFeatureIter(root);
    }
    inline bool Node::IsFeature() const {…}
 
    inline bool Node::IsFeatureIter(CategoryNodePtr parent) const  // NOLINT(misc-no-recursion)
    {
      for (auto child : parent->GetDependentNodes<Node>(NodeList::Child))
      {
        if (child && child.get() == this)
          return true;
      }
 
      for (auto subCategory : parent->GetDependentNodes<CategoryNode>(NodeList::Child))
      {
        if (subCategory)
        {
          if (subCategory && subCategory.get() == this)
            return true;
 
          if (IsFeatureIter(subCategory))
            return true;
        }
      }
      return false;
    }
 
    inline NodePtr Node::AliasNode() const
    {
      return GetInfoAs<Node>(NodeInfo::Alias);
    }
    inline NodePtr Node::AliasNode() const {…}
 
    inline String Node::NameOnly() const
    {
      return ParseName(Name());
    }
    inline String Node::NameOnly() const {…}
 
    inline void Node::SetAliasNode(const NodePtr &value)
    {
      SetInfo<NodePtr>(NodeInfo::Alias, value);
    }
    inline void Node::SetAliasNode(const NodePtr &value) {…}
 
    inline GenApi::AccessMode Node::AccessMode() const
    {
      return static_cast<GenApi::AccessMode>(GetInfoAsInt(NodeInfo::AccessMode));
    }
    inline GenApi::AccessMode Node::AccessMode() const {…}
 
    inline Cvb::GenApi::AccessMode Node::ImposedAccessMode() const
    {
      auto am = static_cast<Cvb::GenApi::AccessMode>(GetInfoAsInt(NodeInfo::ImposedAccessMode));
      if (am == static_cast<Cvb::GenApi::AccessMode>(-1))
        return Cvb::GenApi::AccessMode::NotImplemented;
      else
        return am;
    }
    inline Cvb::GenApi::AccessMode Node::ImposedAccessMode() const {…}
 
    inline void Node::SetImposedAccessMode(const Cvb::GenApi::AccessMode &accessMode)
    {
      NativeCall<CExports::cvbint64_t>([&](CExports::cvbint64_t &value) {
        return CVB_CALL_CAPI(GSNSetInfoAsInteger(Handle(), static_cast<CExports::TGSNodeInfo>(accessMode), value));
      });
    }
    inline void Node::SetImposedAccessMode(const Cvb::GenApi::AccessMode &accessMode) {…}
 
    inline Cvb::GenApi::CacheMode Node::CacheMode() const
    {
      return static_cast<Cvb::GenApi::CacheMode>(GetInfoAsInt(NodeInfo::CachingMode));
    }
    inline Cvb::GenApi::CacheMode Node::CacheMode() const {…}
 
    inline EventCookie Node::RegisterEventUpdated(std::function<void(Node &)> handler)
    {
      auto holder = Internal::CbCarrier<void(Node &)>::Create(handler);
      return updatedCarrierContainer_.Register(holder);
    }
    inline EventCookie Node::RegisterEventUpdated(std::function<void(Node &)> handler) {…}
 
    inline void Node::UnregisterEventUpdated(EventCookie eventCookie) noexcept
    {
      updatedCarrierContainer_.Unregister(eventCookie);
    }
    inline void Node::UnregisterEventUpdated(EventCookie eventCookie) noexcept {…}
 
    template <class T>
    inline std::vector<std::shared_ptr<T>> Node::GetDependentNodes(const NodeList &type) const
    {
      std::size_t numNodes = GetDependentNodeCount(type);
      std::vector<std::shared_ptr<T>> dependentNodes(static_cast<std::size_t>(numNodes));
      for (std::size_t i = 0; i < numNodes; i++)
      {
        std::size_t bufferSize    = 0;
        std::size_t keyBufferSize = 0;
        auto bufferSizeResult =
            CExports::GSNListExTyped(Handle(), static_cast<CExports::TGSNodeList>(type), i, reinterpret_cast<Char *>(0),
                                     bufferSize, reinterpret_cast<Char *>(0), keyBufferSize);
        if (bufferSizeResult < 0)
          throw std::runtime_error("Failed to get name length");
 
        bufferSize += sizeof(Char);
        std::vector<Char> buffer(bufferSize);
        keyBufferSize += sizeof(Char);
        std::vector<Char> keyBuffer(keyBufferSize);
 
        CExports::cvbres_t bufferResult = 0;
        bufferResult = CExports::GSNListExTyped(Handle(), static_cast<CExports::TGSNodeList>(type), i,
                                                reinterpret_cast<Char *>(buffer.data()), bufferSize,
                                                reinterpret_cast<Char *>(keyBuffer.data()), keyBufferSize);
        if (bufferResult < 0)
          throw std::runtime_error("Failed to list node names");
 
        CExports::NODE hChild = nullptr;
        auto result =
            CExports::GSNGetNodeTyped(Handle(), static_cast<CExports::TGSNodeList>(type), buffer.data(), hChild);
        if (result < 0)
          throw std::runtime_error("Failed to get child handle");
 
        HandleGuard<class Node> guard(hChild);
        String name(buffer.data());
        std::shared_ptr<T> nonInlineNode = nodeMap_.lock()->TryGetNode<T>(name);
        if (nonInlineNode != nullptr && (guard.Handle() == nullptr || guard.Handle() == nonInlineNode->Handle()))
        {
          dependentNodes[i] = nonInlineNode;
        }
        else
        {
          NodePtr inlineNode = Node::FromHandle(std::move(guard), nodeMap_.lock());
          dependentNodes[i]  = std::dynamic_pointer_cast<T>(inlineNode);
        }
      }
      return dependentNodes;
    }
    inline std::vector<std::shared_ptr<T>> Node::GetDependentNodes(const NodeList &type) const {…}
 
    inline void Node::SetInfoAsString(const NodeInfo &command, const String &value)
    {
      NativeCall([&]() {
        return CExports::GSNSetInfoAsStringTyped(Handle(), static_cast<CExports::TGSNodeInfo>(command), value.c_str());
      });
    }
 
    inline void Node::SetInfoAsInt(const NodeInfo &command, const std::int64_t &value)
    {
      NativeCall([&]() {
        return CVB_CALL_CAPI(GSNSetInfoAsInteger(Handle(), static_cast<CExports::TGSNodeInfo>(command),
                                                 static_cast<CExports::cvbint64_t>(value)));
      });
    }
 
    inline double Node::GetInfoAsFloat(const NodeInfo &command) const
    {
      return NativeCall<double>([&](double &value) {
        return CVB_CALL_CAPI(GSNGetInfoAsFloat(Handle(), static_cast<CExports::TGSNodeInfo>(command), value));
      });
    }
 
    inline void Node::SetInfoAsFloat(const NodeInfo &command, const double &value)
    {
      NativeCall([&]() {
        return CVB_CALL_CAPI(GSNSetInfoAsFloat(Handle(), static_cast<CExports::TGSNodeInfo>(command), value));
      });
    }
 
    template <class NodeT>
    inline void Node::SetInfo(const NodeInfo &info, const NodeT &valueNode)
    {
      if (valueNode == NodeT())
        throw std::runtime_error("node to set must not be empty");
 
      NativeCall([&]() {
        return CVB_CALL_CAPI(GSNSetInfoAsNode(Handle(), static_cast<CExports::TGSNodeInfo>(info), valueNode->Handle()));
      });
    }
 
    inline void Node::SetInfo(const NodeInfo &info, const String &value)
    {
      if (value.empty())
        throw std::runtime_error("value to set must not be empty");
 
      NativeCall([&]() {
        return CExports::GSNSetInfoAsStringTyped(Handle(), static_cast<CExports::TGSNodeInfo>(info), value.data());
      });
    }
 
    template <class NodeT>
    inline std::shared_ptr<NodeT> Node::GetInfoAs(const NodeInfo &info) const
    {
      CExports::GSNODE handle = nullptr;
      NativeCall([&]() {
        return CVB_CALL_CAPI(GSNGetInfoAsNode(Handle(), static_cast<CExports::TGSNodeInfo>(info), handle));
      });
 
      if (handle == nullptr)
        return nullptr;
 
      HandleGuard<Node> guard(handle);
 
      std::shared_ptr<NodeT> tmpNode;
      tmpNode = std::make_shared<NodeT>(std::move(guard));
 
      return nodeMap_.lock()->Node<NodeT>(tmpNode->NameOnly());
    }
 
    template <>
    inline IntegerBaseNodePtr IntegerNode::MaxConfig<IntegerBaseNodePtr>() const
    {
      return GetInfoAs<IntegerBaseNode>(NodeInfo::Max);
    }
 
    template <>
    inline IntegerBaseNodePtr IntegerNode::MinConfig<IntegerBaseNodePtr>() const
    {
      return GetInfoAs<IntegerBaseNode>(NodeInfo::Min);
    }
 
    template <>
    inline IntegerBaseNodePtr IntegerNode::IncrementConfig<IntegerBaseNodePtr>() const
    {
      return GetInfoAs<IntegerBaseNode>(NodeInfo::Increment);
    }
 
    template <>
    inline void IntegerNode::SetMaxConfig<IntegerBaseNodePtr>(const IntegerBaseNodePtr &value)
    {
      SetInfo<IntegerBaseNodePtr>(NodeInfo::Max, value);
    }
 
    template <>
    inline IntegerBaseNodePtr IntegerNode::ValueConfig<IntegerBaseNodePtr>() const
    {
      return GetInfoAs<IntegerBaseNode>(NodeInfo::Value);
    }
 
    template <>
    inline void IntegerNode::SetValueConfig<IntegerBaseNodePtr>(const IntegerBaseNodePtr &value)
    {
      return SetInfo<IntegerBaseNodePtr>(NodeInfo::Value, value);
    }
 
    template <>
    inline void IntegerNode::SetMinConfig<IntegerBaseNodePtr>(const IntegerBaseNodePtr &value)
    {
      SetInfo<IntegerBaseNodePtr>(NodeInfo::Min, value);
    }
 
    inline IntegerBaseNodePtr IntegerNode::ValueConfigAsNode() const
    {
      return ValueConfig<IntegerBaseNodePtr>();
    }
 
    template <>
    inline void IntegerNode::SetIncrementConfig<IntegerBaseNodePtr>(const IntegerBaseNodePtr &value)
    {
      SetInfo<IntegerBaseNodePtr>(NodeInfo::Increment, value);
    }
 
    template <>
    inline void FloatNode::SetValueConfig<FloatBaseNodePtr>(const FloatBaseNodePtr &value)
    {
      SetInfo<FloatBaseNodePtr>(NodeInfo::Value, value);
    }
 
    template <>
    inline FloatBaseNodePtr FloatNode::MaxConfig<FloatBaseNodePtr>() const
    {
      return GetInfoAs<FloatBaseNode>(NodeInfo::Max);
    }
 
    template <>
    inline FloatBaseNodePtr FloatNode::MinConfig<FloatBaseNodePtr>() const
    {
      return GetInfoAs<FloatBaseNode>(NodeInfo::Min);
    }
 
    template <>
    inline FloatBaseNodePtr FloatNode::IncrementConfig<FloatBaseNodePtr>() const
    {
      return GetInfoAs<FloatBaseNode>(NodeInfo::Increment);
    }
 
    template <>
    inline void FloatNode::SetMaxConfig<FloatBaseNodePtr>(const FloatBaseNodePtr &value)
    {
      SetInfo<FloatBaseNodePtr>(NodeInfo::Max, value);
    }
 
    template <>
    inline FloatBaseNodePtr FloatNode::ValueConfig<FloatBaseNodePtr>() const
    {
      return GetInfoAs<FloatBaseNode>(NodeInfo::Value);
    }
 
    template <>
    inline void FloatNode::SetMinConfig<FloatBaseNodePtr>(const FloatBaseNodePtr &value)
    {
      SetInfo<FloatBaseNodePtr>(NodeInfo::Min, value);
    }
 
    inline FloatBaseNodePtr FloatNode::ValueConfigAsNode() const
    {
      return ValueConfig<FloatBaseNodePtr>();
    }
 
    template <>
    inline void FloatNode::SetIncrementConfig<FloatBaseNodePtr>(const FloatBaseNodePtr &value)
    {
      SetInfo<FloatBaseNodePtr>(NodeInfo::Increment, value);
    }
 
    template <>
    inline IntegerBaseNodePtr CommandNode::ValueConfig<IntegerBaseNodePtr>() const
    {
      return GetInfoAs<IntegerBaseNode>(NodeInfo::Value);
    }
 
    template <>
    inline void CommandNode::SetCommandConfig<IntegerBaseNodePtr>(const IntegerBaseNodePtr &value)
    {
      SetInfo<IntegerBaseNodePtr>(NodeInfo::OnValue, value);
    }
 
    template <>
    inline void CommandNode::SetValueConfig<IntegerBaseNodePtr>(const IntegerBaseNodePtr &value)
    {
      SetInfo<IntegerBaseNodePtr>(NodeInfo::Value, value);
    }
 
    inline IntegerBaseNodePtr CommandNode::ValueConfigAsNode() const
    {
      return ValueConfig<IntegerBaseNodePtr>();
    }
 
    template <>
    inline IntegerBaseNodePtr EnumerationNode::ValueConfig<IntegerBaseNodePtr>() const
    {
      return GetInfoAs<IntegerBaseNode>(NodeInfo::Value);
    }
 
    template <>
    inline void EnumerationNode::SetValueConfig<IntegerBaseNodePtr>(const IntegerBaseNodePtr &value)
    {
      SetInfo<IntegerBaseNodePtr>(NodeInfo::Value, value);
    }
 
    inline IntegerBaseNodePtr EnumerationNode::ValueConfigAsNode() const
    {
      return ValueConfig<IntegerBaseNodePtr>();
    }
 
    template <>
    inline IntegerBaseNodePtr BooleanNode::ValueConfig<IntegerBaseNodePtr>() const
    {
      return GetInfoAs<IntegerBaseNode>(NodeInfo::Value);
    }
 
    inline IntegerBaseNodePtr BooleanNode::ValueConfigAsNode() const
    {
      return ValueConfig<IntegerBaseNodePtr>();
    }
 
    template <>
    inline void BooleanNode::SetValueConfig<IntegerBaseNodePtr>(const IntegerBaseNodePtr &value)
    {
      SetInfo<IntegerBaseNodePtr>(NodeInfo::Value, value);
    }
 
    template <>
    inline StringNodePtr StringNode::ValueConfig<StringNodePtr>() const
    {
      return GetInfoAs<StringNode>(NodeInfo::Value);
    }
 
    inline StringNodePtr StringNode::ValueConfigAsNode() const
    {
      return ValueConfig<StringNodePtr>();
    }
 
    template <>
    inline void StringNode::SetValueConfig<StringNodePtr>(const StringNodePtr &value)
    {
      SetInfo<StringNodePtr>(NodeInfo::Value, value);
    }
 
    template <class NodeT, class ValueConfigNodeType>
    inline ValueNodePtr Node::GetTerminalRegisterNode(const NodeT *node,
                                                      std::function<bool(Node *)> f) const  // NOLINT(misc-no-recursion)
    {
      auto hasValueConfig = dynamic_cast<Private::IHasValueConfig<ValueConfigNodeType> *>(
          const_cast<NodeT *>(node));  // NOLINT(cppcoreguidelines-pro-type-const-cast)
      if (hasValueConfig)
      {
        auto otherNode = hasValueConfig->ValueConfigAsNode();
 
        if (f(dynamic_cast<Node *>(otherNode.get())))
          return std::dynamic_pointer_cast<ValueNode>(otherNode);
        else
        {
          auto valNode = dynamic_cast<ValueNode *>(otherNode.get());
          return GetTerminalRegisterNode<ValueNode, ValueConfigNodeType>(valNode, f);
        }
      }
      else
        return nullptr;
    }
    inline ValueNodePtr Node::GetTerminalRegisterNode(const NodeT *node, {…}
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb