node_map_enumerator.hpp

#pragma once
 
#include <map>
#include <memory>
 
#include "genapi.hpp"
#include "node_map.hpp"
 
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<GenApi::NodeMapEnumerator>::HandleGuard(void* handle) noexcept
    : HandleGuard<GenApi::NodeMapEnumerator>(handle, [](void* handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace GenApi
  {
 
 
    class NodeMapEnumerator final
    {
      struct PrivateTag {};
 
    public:
 
      NodeMapEnumerator() noexcept
        : handle_(nullptr) // not an invalid object just no node maps to enumerate
      {
      }
      
      NodeMapEnumerator(HandleGuard<NodeMapEnumerator>&& guard, PrivateTag) noexcept
        : handle_(std::move(guard))
      {
      }
      
      // we need only move
      NodeMapEnumerator(const NodeMapEnumerator& other) = delete;
      NodeMapEnumerator& operator=(const NodeMapEnumerator& other) = delete;
      
 
      NodeMapEnumerator(NodeMapEnumerator&& other) noexcept
      : nodeMaps_(std::move_if_noexcept(other.nodeMaps_)),
        handle_(std::move(other.handle_))
      {
      }
 
 
      NodeMapEnumerator& operator=(NodeMapEnumerator&& other) noexcept
      {
        if (this != &other) {
            nodeMaps_ = std::move_if_noexcept(other.nodeMaps_);
            handle_ = std::move(other.handle_);
        }
        return *this;
      }
 
      ~NodeMapEnumerator() = default;
 
 
      template<class T>
      static NodeMapEnumerator FromObject(const T& object)
      {
          CVB_CALL_CAPI_CHECKED(ShareObject(object.Handle()));
          return NodeMapEnumerator(HandleGuard<NodeMapEnumerator>(object.Handle()), PrivateTag{});
      }
 
 
      void* Handle() const noexcept 
      { 
        return handle_.Handle(); 
      }
 
 
      std::vector<String> Names() const
      {
        std::vector<String> names;
        auto nodeMapCount = NodeMapCount();
        names.reserve(nodeMapCount);
        std::generate_n(std::back_inserter(names), nodeMapCount, [this, i = 0]() mutable {
          return NameAt(i++); });
        return names;
      }
 
 
      NodeMapPtr operator[](const String& name) const
      {
        return NodeMap(name);
      }
 
 
      NodeMapPtr NodeMap(const String& name) const
      {
        auto iter = nodeMaps_.find(name);
        if (iter != nodeMaps_.end())
        {
          if (auto nodeMap = iter->second.lock())
            return nodeMap;
        }
 
        CExports::NODEMAP handle = nullptr;
        std::string cname(Internal::CastToAscii(name));
        CVB_CALL_CAPI_CHECKED(NMH2GetNodeMap(Handle(), cname.c_str(), handle));
 
        auto nodeMap = NodeMap::FromHandle(HandleGuard<class NodeMap>(handle), name, Handle());
        nodeMaps_[name] = nodeMap;
        return nodeMap;
      }
 
    private:
 
      int NodeMapCount() const noexcept
      {
        size_t numNodeMaps = 0;
        CExports::NMH2GetNum(Handle(), numNodeMaps);
        return static_cast<int>(numNodeMaps);
      }
 
      String NameAt(int index) const
      {
        size_t bufferSize = 0;
        CVB_CALL_CAPI_CHECKED(NMH2GetID(Handle(), index, nullptr, bufferSize));
 
        std::vector<char> buffer(bufferSize);
        CVB_CALL_CAPI_CHECKED(NMH2GetID(Handle(), index, buffer.data(), bufferSize));
 
        return String(buffer.begin(), buffer.end() - 1); // safe as we define the node map names
      }
 
      mutable std::map<String, std::weak_ptr<class NodeMap>> nodeMaps_;
 
      HandleGuard<NodeMapEnumerator> handle_;
 
 
 
    };
  }
 
  CVB_END_INLINE_NS
}