string_node.hpp

#pragma once
 
#include "../global.hpp"
 
#include "selector_node.hpp"

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

    class StringNode
        : public SelectorNode
        , public Private::IHasValueConfig<StringNodePtr>
    {
    public:
      explicit StringNode(HandleGuard<Node> &&guard)
          : SelectorNode(std::move(guard))
      {
      }

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

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

      GenApi::AccessMode AccessMode() const override
      {
        auto value = GetTerminalRegisterNode<StringNode, StringNodePtr>(this, [](Node *node) {
          return dynamic_cast<GevServer::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<StringNode, StringNodePtr>(
            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 {…}
 
      StringNodePtr ValueConfigAsNode() const override;


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


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

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

      template <class T>
      void SetValueConfig(const T & /*value*/)
      {
        throw std::runtime_error(
            "requested value config type must be derived from "
            "StringNode or be of Cvb::String type");
      }
      void SetValueConfig(const T & /*value*/) {…}
    };
    class StringNode {…};
 
    template <>
    inline Cvb::String StringNode::ValueConfig<Cvb::String>() const
    {
      return GetInfoAsString(NodeInfo::Value);
    }
 
    template <>
    inline void StringNode::SetValueConfig<Cvb::String>(const Cvb::String &value)
    {
      SetInfoAsString(NodeInfo::Value, value);
    }
 
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb