enumeration_node.hpp

#pragma once

#include "../global.hpp"

#include "integer_base_node.hpp"
#include "value_node.hpp"

#include "_detail/iconfigurable_enumeration_node.hpp"
#include "_detail/ihas_value_config.hpp"

namespace Cvb
{
CVB_BEGIN_INLINE_NS
namespace GevServer
{

class EnumerationNode
    : public SelectorNode
    , public Private::IConfigurableEnumerationNode
    , public Private::IHasValueConfig<IntegerBaseNodePtr>
{
public:
  EnumerationNode(HandleGuard<Node> &&guard) noexcept : SelectorNode(std::move(guard)) {}

  static EnumerationNodePtr Create(const String &name, const GevServer::Namespace &nameSpace)
  {
    String okName = EnsureNodeNameOnly(name);
    return std::make_shared<EnumerationNode>(HandleGuard<Node>(
        CExports::CreateGSEnumerationNodeTyped(okName.data(), static_cast<CExports::TGSNamespace>(nameSpace))));
  }

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

  GenApi::AccessMode AccessMode() const override
  {
    auto value = GetTerminalRegisterNode<EnumerationNode, IntegerBaseNodePtr>(
        this, [](Node *node) { return dynamic_cast<GenApi::Private::IRegisterNode *>(node) ? true : false; });
    if (value == nullptr)
      return GenApi::AccessMode::ReadWrite;
    else
      return value->AccessMode();
  }

  GenApi::CacheMode CacheMode() const override
  {
    auto value = GetTerminalRegisterNode<EnumerationNode, IntegerBaseNodePtr>(
        this, [](Node *node) { return dynamic_cast<GenApi::Private::IRegisterNode *>(node) ? true : false; });
    if (value == nullptr)
      return GenApi::CacheMode::NoCache;
    else
      return value->CacheMode();
  }

  template <class Rep, class Period> std::chrono::duration<Rep, Period> PollingTime() const
  {
    auto value = GetTerminalRegisterNode<EnumerationNode, IntegerBaseNodePtr>(this, [](Node *node) {
      auto isRegisterNode = dynamic_cast<GenApi::Private::IRegisterNode *>(node);
      auto isCommandNode = dynamic_cast<GenApi::Private::ICommandNode *>(node);
      return (isRegisterNode || isCommandNode) ? true : false;
    });
    if (value == nullptr)
      return std::chrono::duration<Rep, Period>::zero();
    else
      return value->template PollingTime<Rep, Period>();
  }

  std::vector<EnumEntryNodePtr> Entries() const { return GetDependentNodes<EnumEntryNode>(NodeList::Child); }

  IntegerBaseNodePtr ValueConfigAsNode() const override;

  template <class T> T ValueConfig() const
  {
    throw std::runtime_error("requested value config type must be derived from GSIntergerBaseNode "
                             "or be of type int64_t");
  }


  template <class T> void SetValueConfig(const T & /*value*/)
  {
    throw std::runtime_error("requested value config type must be derived from "
                             "IntegerBaseNode or be of type std::int64_t");
  }


  String Value() const { return ToString(); }


  void SetValue(const String &value) { FromString(value); }

  void FromString(const String &value) override
  {
    NativeCall([&]() { return CExports::GSNSetAsStringTyped(Handle(), value.data()); });
  }

  virtual String ToString() const override
  {
    auto bufferSize = NativeCall<size_t>(
        [&](size_t &size) { return CExports::GSNGetAsStringTyped(Handle(), reinterpret_cast<Char *>(0), size); });
    bufferSize += sizeof(Char);
    std::vector<Char> buffer(bufferSize);
    NativeCall([&]() { return CExports::GSNGetAsStringTyped(Handle(), buffer.data(), bufferSize); });
    return buffer.data();
  }
};

template <> inline std::int64_t EnumerationNode::ValueConfig<std::int64_t>() const
{
  return GetInfoAsInt(NodeInfo::Value);
}

template <> inline void EnumerationNode::SetValueConfig<std::int64_t>(const std::int64_t &value)
{
  SetInfoAsInt(NodeInfo::Value, value);
}
}
CVB_END_INLINE_NS
}