enum_entry_node.hpp

#pragma once

#include "../global.hpp"

#include "selector_node.hpp"

#include "_detail/iconfigurable_enum_entry_node.hpp"

namespace Cvb
{
CVB_BEGIN_INLINE_NS
namespace GevServer
{

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

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

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

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

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

  bool IsStreamable() const override { return false; }

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

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

  std::int64_t NumericValue() const { return GetInfoAsInt(NodeInfo::Value); }

  void SetNumericValue(const std::int64_t &value) { SetInfoAsInt(NodeInfo::Value, value); }

  String SymbolicValue() const { return GetInfoAsString(NodeInfo::Value); }

  void SetSymbolicValue(const String &value) { SetInfo(NodeInfo::Value, value); }

  void FromString(const String & /*value*/) override
  {
    throw std::runtime_error("Symbolic values cannot be set as value");
  }

  String ToString() const override { return SymbolicValue(); }
};
}
CVB_END_INLINE_NS
}