category_node.hpp

#pragma once

#include "../global.hpp"

#include "value_node.hpp"

#include "_detail/iconfigurable_category_node.hpp"

namespace Cvb
{
CVB_BEGIN_INLINE_NS
namespace GevServer
{

class CategoryNode
    : public ValueNode
    , public Private::IConfigurableCategoryNode
{
public:
  CategoryNode(HandleGuard<Node> &&guard) noexcept : ValueNode(std::move(guard)) {}

  static CategoryNodePtr Create(const String &name, const GevServer::Namespace &nameSpace)
  {
    CExports::GEVSRV handle = nullptr;
    handle = CExports::CreateGSCategoryNodeTyped(name.data(), static_cast<CExports::TGSNamespace>(nameSpace));

    HandleGuard<Node> guard(handle);
    return std::make_shared<CategoryNode>(std::move(guard));
  }

  static CategoryNodePtr Create(const String &name) { return Create(ParseName(name), ParseNamespace(name)); }


  void FromString(const String &value) override
  {
    (void)value;
    throw std::runtime_error("not implemented");
  }

  String ToString() const override
  {
    auto bufferSize = NativeCall<size_t>([&](size_t &size) {
      return CExports::GSNGetInfoAsStringTyped(
          Handle(), CExports::TGSNodeInfo::GSNI_Alias, reinterpret_cast<Char *>(0), size);
    });

    bufferSize += sizeof(Char);
    std::vector<Char> buffer(bufferSize);
    NativeCall([&]() {
      return CExports::GSNGetInfoAsStringTyped(
          Handle(), CExports::TGSNodeInfo::GSNI_Alias, buffer.data(), bufferSize);
    });

    return buffer.data() ? String(buffer.data()) : String();
  }


  GenApi::AccessMode AccessMode() const noexcept override { return GenApi::AccessMode::ReadOnly; }


  Cvb::GenApi::CacheMode CacheMode() const noexcept override { return GenApi::CacheMode::NoCache; }


  template <class Rep, class Period> std::chrono::duration<Rep, Period> PollingTime() const noexcept
  {
    return std::chrono::duration<Rep, Period>::zero();
  }

  bool IsStreamable() const override { return false; }

  [[noreturn]] void SetIsStreamable(const std::int64_t & /*value*/) override
  {
    throw std::runtime_error("Category nodes cannot be streamed");
  }


  std::vector<NodePtr> Nodes() const { return GetDependentNodes<Node>(NodeList::Child); }
};
}
CVB_END_INLINE_NS
}