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
    {
      if (nodes_.find(CVB_LIT("Cust::FileSelector")) == nodes_.end()
          && nodes_.find(CVB_LIT("Std::FileSelector")) == nodes_.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())
      {
        if (nodes_.find(CVB_LIT("Cust::") + name) != nodes_.end())
          localName = String(CVB_LIT("Cust::")) + name;
        else if (nodes_.find(CVB_LIT("Std::") + name) != nodes_.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
    {
      std::map<String, NodePtr> nodes;
      for (const auto &entry : nodes_)
        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))
        ReadDescription(provider);
      FillNodeKeys();
    }
 
    inline void NodeMap::ReadDescription(void *provider)
    {
      std::string cname(name_.begin(), name_.end());
      size_t bufferLength = 0;
      if (CExports::NMH2GetDescription(provider, cname.c_str(), nullptr, bufferLength) >= 0 && bufferLength > 1)
      {
        std::vector<char> buffer(bufferLength);
        auto resultDescription = CExports::NMH2GetDescription(provider, 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);
      }
    }
 
    inline void NodeMap::FillNodeKeys()
    {
      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);
 
        nodes_[keyString] = std::weak_ptr<class Node>();
      }
    }
 
    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