integer_base_node.hpp

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

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


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


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


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


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


      void SetRepresentation(const GenApi::NumberRepresentation &representation)
      {
        SetInfoAsInt(NodeInfo::NumberRepresentation, static_cast<std::int64_t>(representation));
      }
      void SetRepresentation(const GenApi::NumberRepresentation &representation) {…}


      virtual String Unit() const
      {
        return String();  // Not yet implemented
      }
      virtual String Unit() const {…}
 
      virtual void SetUnit(const String & /*unit*/) {}


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


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

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

      String ToString() const override
      {
        size_t nameLength     = 0;
        auto resultNameLength = CExports::GSNGetAsStringTyped(Handle(), reinterpret_cast<Char *>(0), nameLength);
        if (resultNameLength < 0)
          std::rethrow_exception(
              CvbException::FromCvbResult(resultNameLength, "failed to get string representation name length"));
 
        nameLength += sizeof(Char);
        std::vector<Char> buffer(static_cast<size_t>(nameLength));
 
        auto resultBuffer = CExports::GSNGetAsStringTyped(Handle(), buffer.data(), nameLength);
        if (resultBuffer < 0)
          std::rethrow_exception(
              CvbException::FromCvbResult(resultBuffer, "failed to get string representation of this node"));
 
        return buffer.data();
      }
      String ToString() const override {…}
    };
    class IntegerBaseNode : public SelectorNode {…};
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb