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))
      {
      }


      NodeMapEnumerator(NodeMapEnumerator&& other) = default;


      NodeMapEnumerator& operator=(NodeMapEnumerator&& other) = 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
}