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
}