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:
      using GuardType = HandleGuard<NodeMapEnumerator>;
 
      template <class T>
      static NodeMapEnumeratorPtr FromHandle(HandleGuard<NodeMapEnumerator> &&guard)
      {
        // no check for valid guard required!
        return std::make_shared<NodeMapEnumerator>(std::move(guard), PrivateTag{});
      }
 
      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(NodeMapEnumerator &&other) noexcept {…}


      NodeMapEnumerator &operator=(NodeMapEnumerator &&other) noexcept
      {
        if (this != &other)
        {
          nodeMaps_ = std::move_if_noexcept(other.nodeMaps_);
          handle_   = std::move(other.handle_);
        }
        return *this;
      }
      NodeMapEnumerator &operator=(NodeMapEnumerator &&other) noexcept {…}
 
      ~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{});
      }
      static NodeMapEnumerator FromObject(const T &object) {…}


      void *Handle() const noexcept
      {
        return handle_.Handle();
      }
      void *Handle() const noexcept {…}


      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;
      }
      std::vector<String> Names() const {…}


      NodeMapPtr operator[](const String &name) const
      {
        return NodeMap(name);
      }
      NodeMapPtr operator[](const String &name) const {…}


      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;
      }
      NodeMapPtr NodeMap(const String &name) const {…}
 
    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_;
    };
    class NodeMapEnumerator final {…};
  }  // namespace GenApi
 
  CVB_END_INLINE_NS
}  // namespace Cvb