integer_node.hpp

#pragma once
 
#include "../global.hpp"
 
#include "selector_node.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace GenApi
  {


    class IntegerNode : public SelectorNode
    {
    public:
      explicit IntegerNode(HandleGuard<Node> &&guard) noexcept
          : SelectorNode(std::move(guard))
      {
      }


      std::int64_t Value() const
      {
        return static_cast<std::int64_t>(NativeCall<CExports::cvbint64_t>(
            [&](CExports::cvbint64_t &value) { return CExports::NGetAsInteger(Handle(), value); }));
      }
      std::int64_t Value() const {…}


      void SetValue(std::int64_t value)
      {
        NativeCall([&]() { return CExports::NSetAsInteger(Handle(), static_cast<CExports::cvbint64_t>(value)); });
      }
      void SetValue(std::int64_t value) {…}


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


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


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


      NumberRepresentation Representation() const
      {
        return static_cast<NumberRepresentation>(GetInfoAsInt(NodeInfo::Representation));
      }
      NumberRepresentation Representation() const {…}


      String Unit() const
      {
        return GetInfoAsString(NodeInfo::Unit);
      }
      String Unit() const {…}
    };
    class IntegerNode : public SelectorNode {…};
 
  }  // namespace GenApi
 
  using GenApi::IntegerNode;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb