detail_node.hpp

#pragma once
 
#include "../../_cexports/c_gen_api.h"
 
#include "../../global.hpp"
#include "../../exception.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 "../enumeration_node.hpp"
#include "../enum_entry_node.hpp"
#include "../float_reg_node.hpp"
#include "../float_node.hpp"
#include "../int_reg_node.hpp"
#include "../integer_node.hpp"
#include "../string_reg_node.hpp"
#include "../string_node.hpp"
#include "../port_node.hpp"
#include "../register_node.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace GenApi
  {
 
    inline NodePtr Node::FromName(const NodeMapPtr &nodeMap, const String &name)
    {
 
      CExports::NODEMAP handle = nullptr;
      auto resultGet           = CExports::NMGetNodeTyped(nodeMap->Handle(), name.c_str(), handle);
      if (resultGet < 0)
        std::rethrow_exception(CvbException::FromCvbResult(resultGet, "failed to get node"));
 
      HandleGuard<Node> guard(handle);
      return FromHandle(nodeMap, std::move(guard));
    }
 
    inline NodePtr Node::FromHandle(const NodeMapPtr &nodeMap, HandleGuard<Node> &&guard)
    {
      auto handle = guard.Handle();
 
      CExports::TNodeType nodeType = CExports::TNodeType::NT_Invalid;
      auto resultType              = CExports::NType(handle, nodeType);
      if (resultType < 0)
        std::rethrow_exception(CvbException::FromCvbResult(resultType, "failed to get node type"));
 
      CExports::cvbint64_t value = 0;
      bool isRegister =
          CExports::NInfoAsInteger(guard.Handle(), static_cast<CExports::TNodeInfo>(NodeInfo::RegisterLength), value)
              >= 0
          && value > 0;
 
      NodePtr node;
      switch (nodeType)
      {
 
        case CExports::TNodeType::NT_Invalid:
        case CExports::TNodeType::NT_Unknown:
          throw std::runtime_error("invalid node type");
 
        case CExports::TNodeType::NT_Boolean:
          node = std::make_shared<BooleanNode>(std::move(guard));
          break;
 
        case CExports::TNodeType::NT_Category:
          node = std::make_shared<CategoryNode>(std::move(guard));
          break;
 
        case CExports::TNodeType::NT_Command:
          node = std::make_shared<CommandNode>(std::move(guard));
          break;
 
        case CExports::TNodeType::NT_Enumeration:
          node = std::make_shared<EnumerationNode>(std::move(guard));
          break;
 
        case CExports::TNodeType::NT_EnumEntry:
          node = std::make_shared<EnumEntryNode>(std::move(guard));
          break;
 
        case CExports::TNodeType::NT_Float:
          if (isRegister)
            node = std::make_shared<FloatRegNode>(std::move(guard));
          else
            node = std::make_shared<FloatNode>(std::move(guard));
          break;
 
        case CExports::TNodeType::NT_Integer:
          if (isRegister)
            node = std::make_shared<IntRegNode>(std::move(guard));
          else
            node = std::make_shared<IntegerNode>(std::move(guard));
          break;
 
        case CExports::TNodeType::NT_String:
          if (isRegister)
            node = std::make_shared<StringRegNode>(std::move(guard));
          else
            node = std::make_shared<StringNode>(std::move(guard));
          break;
 
        case CExports::TNodeType::NT_Port:
          node = std::make_shared<PortNode>(std::move(guard));
          break;
 
        default:
          if (isRegister)
            node = std::make_shared<RegisterNode>(std::move(guard));
          else
            node = std::shared_ptr<Node>(new Node(std::move(guard)));
          break;
      }
 
      node->nodeMap_ = nodeMap;
      return node;
    }
 
    inline NodePtr Node::AliasNode() const
    {
      auto aliasName = GetInfoAsString(NodeInfo::AliasName);
      if (aliasName.empty())
        return NodePtr();
 
      return nodeMap_->Node(aliasName);
    }
 
    inline EventCookie Node::RegisterEventUpdated(std::function<void(Node &)> handler)
    {
      auto holder = Internal::CbCarrier<void(Node &)>::Create(handler);
      auto eventCookie = updatedCarrierContainer_.Register(holder);
 
      std::lock_guard<std::mutex> guard(nativeUpdateRegistrationMutex_);
      if (nativeUpdateRegistered_)
        return eventCookie;
 
      const auto result = CExports::NRegisterUpdate(Handle(), UpdatedCallback, this, cbID_);
      if (result < 0)
      {
        updatedCarrierContainer_.Unregister(eventCookie);
        std::rethrow_exception(CvbException::FromCvbResult(result, "failed to register updated handler"));
      }
 
      nativeUpdateRegistered_ = true;
      return eventCookie;
    }
 
    inline void Node::UnregisterEventUpdated(EventCookie eventCookie) noexcept
    {
      updatedCarrierContainer_.Unregister(eventCookie);
    }
 
    template <class T>
    inline std::vector<std::shared_ptr<T>> Node::GetDependentNodes(NodeList type) const
    {
      int numNodes = GetDependentNodeCount(type);
      std::vector<std::shared_ptr<T>> dependentNodes(static_cast<std::size_t>(numNodes));
 
      for (int i = 0; i < numNodes; ++i)
      {
        auto nodeName     = NativeCall<String>([&](String &value) {
          std::size_t bufferSize = 0;
          auto bufferSizeResult  = CExports::NListTyped(Handle(), static_cast<CExports::TNodeList>(type), i,
                                                            reinterpret_cast<Char *>(0), bufferSize);
          if (bufferSizeResult < 0)
            return bufferSizeResult;
 
          std::vector<Char> buffer(bufferSize);
          auto bufferResult =
              CExports::NListTyped(Handle(), static_cast<CExports::TNodeList>(type), i, buffer.data(), bufferSize);
          if (bufferResult < 0)
            return bufferResult;
 
          value = String(buffer.data());
          return bufferResult;
        });
        dependentNodes[i] = nodeMap_->Node<T>(nodeName);
      }
      return dependentNodes;
    }
 
  }  // namespace GenApi
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb