detail_node_map.hpp

#pragma once
 
#include <memory>
#include <stdexcept>
#include <vector>
 
#include "../../_cexports/c_gev_server.h"
 
#include "../../global.hpp"
 
#include "../_decl/decl_node.hpp"
#include "../_decl/decl_node_map.hpp"
#include "../_decl/decl_server_base.hpp"
 
#include "../../_decl/decl_device.hpp"
 
#include "../category_node.hpp"
#include "../value_node.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
  namespace GevServer
  {
    inline NodeMap::NodeMap(ServerBasePtr server)
        : server_(server)
    {
      FillNodeKeys();
    }
 
    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 void NodeMap::FillNodeKeys()
    {
      std::size_t numNodes = 0;
      auto resultNum       = CVB_CALL_CAPI(GSNodeCount(Handle(), numNodes));
      if (resultNum < 0)
        std::rethrow_exception(CvbException::FromCvbResult(resultNum, "failed to get node count"));
 
      for (std::size_t i = 0; i < numNodes; ++i)
      {
        size_t nameLength     = 0;
        auto resultNameLength = CVB_CALL_CAPI(GSNodeList(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 = CVB_CALL_CAPI(GSNodeList(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::shared_ptr<class Node>();
      }
    }
    inline void NodeMap::AddNode(const String &key, const NodePtr &value, const NodeList &kind)
    {
      if (key.empty())
        throw std::runtime_error("key must not be empty");
      if (!value)
        throw std::runtime_error("node must not be null");
      auto name = value->NameOnly();
      if (key != name)
        throw std::runtime_error("key and value->NameOnly() must be equal");
 
      NativeCall([&]() {
        return CExports::GSNAddNodeExTyped(value->Handle(), static_cast<CExports::TGSNodeList>(kind), key.data(),
                                           value->Handle());
      });
 
      // add node map to item
      value->SetNodeMap(std::const_pointer_cast<NodeMap>(shared_from_this()));
 
      nodes_[key] = value;
    }
 
    inline std::size_t ChunkNodesSerializedSize(const NodeMapPtr& nodemap)
    {
      if (!nodemap)
        throw std::runtime_error("nodemap must not be null");
 
      std::size_t ret = 0;
      CVB_CALL_CAPI_CHECKED(CVGSServerGetRequiredChunkSize(nodemap->Handle(), ret));
      return ret;
    }
 
    inline std::uint64_t SerializeChunkNodes(const NodeMapPtr& nodemap, void *buffer, size_t size)
    {
      if (!nodemap)
        throw std::runtime_error("nodemap must not be null");
      if (!buffer)
        throw std::runtime_error("buffer must not be null");
 
      std::uint64_t layoutId = 0;
      CVB_CALL_CAPI_CHECKED(CVGSServerWriteChunkMemory(nodemap->Handle(), buffer, size, layoutId));
      return layoutId;
    }
 
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb