enumeration_node.hpp

#pragma once
 
#include "../global.hpp"
 
#include "integer_base_node.hpp"
#include "value_node.hpp"

#include "_detail/ihas_value_config.hpp"
#include "_detail/iconfigurable_register_node.hpp"
#include "_detail/iconfigurable_command_node.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
  namespace GevServer
  {

    class EnumerationNode
        : public SelectorNode
        , public Private::IHasValueConfig<IntegerBaseNodePtr>
    {
    public:
      explicit EnumerationNode(HandleGuard<Node> &&guard)
          : 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, const GevServer::Namespace &nameSpace) {…}

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

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

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

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

      std::vector<EnumEntryNodePtr> Entries() const
      {
        return GetDependentNodes<EnumEntryNode>(NodeList::Child);
      }
      std::vector<EnumEntryNodePtr> Entries() const {…}
 
      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");
      }
      T ValueConfig() const {…}

 
      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");
      }
      void SetValueConfig(const T & /*value*/) {…}


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


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


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

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

      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();
      }
      String ToString() const override {…}
    };
    class EnumerationNode {…};
 
    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);
    }
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb