detail_node_map.hpp

#pragma once
 
#include <memory>
#include <stdexcept>
#include <vector>
 
#include "../../_cexports/c_gen_api.h"
#include "../../_cexports/c_driver.h"
 
#include "../../global.hpp"
 
#include "../_decl/decl_node.hpp"
#include "../_decl/decl_node_map.hpp"
 
#include "../../_decl/decl_device.hpp"
 
#include "../value_node.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace GenApi
  {
 
    inline NodeMapPtr NodeMap::FromHandle(HandleGuard<NodeMap> &&guard, const String &name, const Device &device)
    {
      return FromHandle(std::move(guard), name, device.Handle());
    }
 
    inline NodeMapPtr NodeMap::Create(const Device &device, const String &name)
    {
      NodeMapPtr nodeMap;
 
      if (CExports::CanNodeMapHandle2(device.Handle()))
      {
        std::string cname(Internal::CastToAscii(name));
        nodeMap = Internal::DoResCallShareOut<NodeMap>(
            [&](void *&handle) { return CVB_CALL_CAPI(NMH2GetNodeMap(device.Handle(), cname.c_str(), handle)); }, name,
            device);
      }
      else if (name == CVB_LIT("Device"))
        nodeMap = Internal::DoResCallShareOut<NodeMap>(
            [&](void *&handle) { return CVB_CALL_CAPI(NMHGetNodeMap(device.Handle(), handle)); }, name, device);
      else
        throw std::runtime_error("node map not found");
 
      return nodeMap;
    }
 
    inline std::vector<String> NodeMap::AvailableFiles() const
    {
      FillNodeKeys();
      if (nodeKeys_.find(CVB_LIT("Cust::FileSelector")) == nodeKeys_.end()
          && nodeKeys_.find(CVB_LIT("Std::FileSelector")) == nodeKeys_.end())
        return std::vector<String>();
 
      auto enumerationNode = Node<EnumerationNode>(CVB_LIT("FileSelector"));
      auto entries         = enumerationNode->Entries();
 
      std::vector<String> availableFiles;
      for (auto entry : entries)
      {
        if (entry->IsAvailable())
          availableFiles.push_back(entry->SymbolicValue());
      }
      return availableFiles;
    }
 
    inline NodePtr NodeMap::Node(const String &name) const
    {
      auto element     = nodes_.find(name);
      String localName = name;
      if (element == nodes_.end())
      {
        // Looking up the node directly is the common case. In particular,
        // VinBuffer maps are created for every delivered buffer, so eagerly
        // listing every node before looking up FrameID or Timestamp is costly.
        CExports::NODE nodeHandle = nullptr;
        const auto result = CExports::NMGetNodeTyped(Handle(), name.c_str(), nodeHandle);
        if (result >= 0)
        {
          auto node = Node::FromHandle(std::const_pointer_cast<NodeMap>(shared_from_this()),
                                       HandleGuard<class Node>(nodeHandle));
          nodes_[name] = node;
          return node;
        }
 
        // The legacy lookup resolves unqualified names by preferring Cust
        // over Std. Preserve that behavior for producers which require a
        // namespace-qualified name.
        FillNodeKeys();
 
        if (nodeKeys_.find(CVB_LIT("Cust::") + name) != nodeKeys_.end())
          localName = String(CVB_LIT("Cust::")) + name;
        else if (nodeKeys_.find(CVB_LIT("Std::") + name) != nodeKeys_.end())
          localName = String(CVB_LIT("Std::")) + name;
        else
          throw std::out_of_range("no node for name");
      }
 
      auto node = nodes_[localName].lock();
      if (!node)
      {
        node              = Node::FromName(std::const_pointer_cast<NodeMap>(shared_from_this()), localName);
        nodes_[localName] = node;
      }
 
      return node;
    }
 
    inline NodePtr NodeMap::TryGetNode(const String &name) const noexcept
    {
      try
      {
        return Node(name);
      }
      catch (...)
      {
        return nullptr;
      }
    }
 
    inline std::map<String, NodePtr> NodeMap::Nodes() const
    {
      FillNodeKeys();
      std::map<String, NodePtr> nodes;
      for (const auto &entry : nodeKeys_)
        nodes[entry.first] = Node(entry.first);
      return nodes;
    }
 
    inline NodeMap::NodeMap(HandleGuard<NodeMap> &&guard, const String &name, void *provider)
        : handle_(std::move(guard))
        , name_(name)
        , lastPoll_(std::chrono::system_clock::now())
    {
      if (CExports::CanNodeMapHandle2(provider))
      {
        CVB_CALL_CAPI_CHECKED(ShareObject(provider));
        provider_.Reset(provider);
      }
    }
 
    inline void NodeMap::ReadDescription() const
    {
      if (descriptionRead_ || provider_.Handle() == nullptr)
        return;
 
      std::string cname(Internal::CastToAscii(name_));
      size_t bufferLength = 0;
      if (CExports::NMH2GetDescription(provider_.Handle(), cname.c_str(), nullptr, bufferLength) >= 0
          && bufferLength > 1)
      {
        std::vector<char> buffer(bufferLength);
        auto resultDescription =
            CExports::NMH2GetDescription(provider_.Handle(), cname.c_str(), &buffer[0], bufferLength);
        if (resultDescription < 0)
          std::rethrow_exception(CvbException::FromCvbResult(resultDescription, "failed to get node map description"));
        description_ = String(buffer.begin(), buffer.end() - 1);
      }
 
      descriptionRead_ = true;
    }
 
    inline void NodeMap::FillNodeKeys() const
    {
      if (nodeKeysFilled_)
        return;
 
      CExports::cvbdim_t numNodes = 0;
      auto resultNum              = CExports::NMNodeCount(Handle(), numNodes);
      if (resultNum < 0)
        std::rethrow_exception(CvbException::FromCvbResult(resultNum, "failed to get node count"));
 
      for (CExports::cvbdim_t i = 0; i < numNodes; ++i)
      {
        size_t nameLength     = 0;
        auto resultNameLength = CExports::NMListNode(Handle(), i, nullptr, nameLength);
        if (resultNameLength < 0)
          std::rethrow_exception(CvbException::FromCvbResult(resultNameLength, "failed to get node name length"));
        std::vector<char> buffer(static_cast<size_t>(nameLength));
        auto resultBuffer = CExports::NMListNode(Handle(), i, &buffer[0], nameLength);
        if (resultBuffer < 0)
          std::rethrow_exception(CvbException::FromCvbResult(resultBuffer, "failed to get node name"));
        String keyString(buffer.begin(), buffer.end() - 1);
 
        nodeKeys_.emplace(std::move(keyString), true);
      }
 
      nodeKeysFilled_ = true;
    }
 
    inline String NodeMap::ToJson(std::vector<NodePtr> nodes,
                                  std::function<void(NodePtr, const std::string &)> serializationErrorCallback)
    {
      CExports::NODEMAPSTREAM nodeMapStream;
      auto res = CExports::NMCreateStream(Handle(), CExports::TStreamType::ST_JSON, nodeMapStream);
      if (res < 0)
        Utilities::SystemInfo::ThrowLastError(res);
      ReleaseObjectGuard guard(nodeMapStream);
 
      for (const auto &node : nodes)
      {
        res = CExports::NMStreamPush(nodeMapStream, node->Handle());
        if (res < 0)
        {
          if (serializationErrorCallback)
            serializationErrorCallback(node, Internal::CastToAscii(node->Name()) + ": "
                                                 + Utilities::SystemInfo::GetLastErrorMessage());
          else
            Utilities::SystemInfo::ThrowLastError(res);
        }
      }
 
      size_t settingsSize;
      res = CExports::NMStreamDumpTyped(nodeMapStream, reinterpret_cast<Char *>(0), settingsSize);
      if (res < 0)
        Utilities::SystemInfo::ThrowLastError(res);
      settingsSize += sizeof(Char);
      std::vector<Char> settings(settingsSize);
      res = CExports::NMStreamDumpTyped(nodeMapStream, &settings[0], settingsSize);
      if (res < 0)
        Utilities::SystemInfo::ThrowLastError(res);
 
      return String(&settings[0]);
    }
 
  }  // namespace GenApi
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb