float_reg_node.hpp

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

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

    class FloatRegNode
        : public FloatBaseNode
        , public Private::IConfigurableRegisterNode
    {
    public:
      explicit FloatRegNode(HandleGuard<Node> &&guard)
          : FloatBaseNode(std::move(guard))
      {
      }

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

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


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

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

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

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

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

      bool IsSigned() const
      {
        return GetInfoAsInt(NodeInfo::Sign) != 0;
      }
      bool IsSigned() const {…}

      void SetIsSigned(const bool &value)
      {
        SetInfoAsInt(NodeInfo::Sign, value ? 1 : 0);
      }
      void SetIsSigned(const bool &value) {…}


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

      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();
      }
      std::chrono::duration<Rep, Period> PollingTime() const {…}

      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());
      }
      void SetPollingTime(const std::chrono::duration<Rep, Period> &timespan) {…}
    };
    class FloatRegNode {…};
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb