string_reg_node.hpp

#pragma once

#include "../global.hpp"

#include "string_node.hpp"

#include "_detail/iconfigurable_register_node.hpp"

namespace Cvb
{
  CVB_BEGIN_INLINE_NS
    namespace GevServer
  {

    class StringRegNode
      : public StringNode
      , public Private::IConfigurableRegisterNode
    {
    public:
      StringRegNode(HandleGuard<Node>&& guard) noexcept : StringNode(std::move(guard)) {}

      static StringRegNodePtr Create(const String& name, const GevServer::Namespace& nameSpace, const std::int64_t& address, const std::int64_t& length)
      {
        String okName = EnsureNodeNameOnly(name);
        return std::make_shared<StringRegNode>(HandleGuard<Node>(
          CExports::CreateGSStringRegNodeTyped(okName.data(), static_cast<CExports::TGSNamespace>(nameSpace), address, length)));
      }

      static StringRegNodePtr Create(const String& name, const std::int64_t& address, const std::int64_t& length)
      {
        return Create(ParseName(name), ParseNamespace(name), address, length);
      }

      static StringRegNodePtr Create(const String& name, const std::int64_t& length)
      {
        return Create(ParseName(name), ParseNamespace(name), -1, length);
      }

      GenApi::AccessMode AccessMode() const override
      {
        return static_cast<GenApi::AccessMode>(GetInfoAsInt(NodeInfo::AccessMode));
      }

      void SetAccessMode(const GenApi::AccessMode& value)
      {
        SetInfoAsInt(NodeInfo::AccessMode, static_cast<std::int64_t>(value));
      }


      std::int64_t Address() const { return StringNode::GetInfoAsInt(NodeInfo::RegisterAddress); }

      std::vector<IntegerBaseNodePtr> AddressNodes() const
      {
        return GetDependentNodes<IntegerBaseNode>(NodeList::Addresses);
      }

      GenApi::CacheMode CacheMode() const override
      {
        return static_cast<GenApi::CacheMode>(GetInfoAsInt(NodeInfo::CachingMode));
      }

      void SetCacheMode(const GenApi::CacheMode& value)
      {
        SetInfoAsInt(NodeInfo::CachingMode, static_cast<std::int64_t>(value));
      }

      std::vector<NodePtr> InvalidatorNodes() const noexcept { return GetDependentNodes<Node>(NodeList::Invalidator); }


      std::int64_t Length() const { return StringNode::GetInfoAsInt(NodeInfo::RegisterLength); }

      template <class Rep, class Period> std::chrono::duration<Rep, Period> PollingTime() const
      {
        auto timespan = GetInfoAsInt(NodeInfo::PollingTime);
        if (timespan > 0)
          return std::chrono::duration<Rep, Period>(timespan);
        else
          return std::chrono::duration<Rep, Period>::zero();
      }

      template <class Rep, class Period> void SetPollingTime(const std::chrono::duration<Rep, Period>& timespan)
      {
        if (timespan == std::chrono::duration<Rep, Period>::zero())
          SetInfoAsInt(NodeInfo::PollingTime, -1);
        else
          SetInfoAsInt(NodeInfo::PollingTime, std::chrono::duration_cast<std::chrono::milliseconds>(timespan).count());
      }


      String Value() const
      {
        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();
      }


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