integer_base_node.hpp

#pragma once
 
#include "../global.hpp"
 
#include "selector_node.hpp"
 
#include "_detail/iconfigurable_integer_base_node.hpp"
 
namespace Cvb
{
CVB_BEGIN_INLINE_NS
namespace GevServer
{
 
class IntegerBaseNode
    : public SelectorNode
    , public Private::IConfigurableIntegerBaseNode
{
public:
  IntegerBaseNode(HandleGuard<Node> &&guard) noexcept : SelectorNode(std::move(guard)) {}
 
 
  std::int64_t Increment() const { return GetInfoAsInt(NodeInfo::Increment); }
 
 
  std::int64_t Max() const { return GetInfoAsInt(NodeInfo::Max); }
 
 
  std::int64_t Min() const { return GetInfoAsInt(NodeInfo::Min); }
 
 
  GenApi::NumberRepresentation Representation() const
  {
    return static_cast<GenApi::NumberRepresentation>(GetInfoAsInt(NodeInfo::NumberRepresentation));
  }
 
 
  void SetRepresentation(const GenApi::NumberRepresentation &representation)
  {
    SetInfoAsInt(NodeInfo::NumberRepresentation, static_cast<std::int64_t>(representation));
  }
 
 
  virtual String Unit() const
  {
    return String(); // Not yet implemented
  }
 
  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)); }));
  }
 
 
  void SetValue(const std::int64_t &value)
  {
    NativeCall([&]() { return CVB_CALL_CAPI(GSNSetAsInteger(Handle(), static_cast<CExports::cvbint64_t>(value))); });
  }
 
  void FromString(const String &value) override
  {
    NativeCall([&]() { return CExports::GSNSetAsStringTyped(Handle(), value.data()); });
  }
 
  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();
  }
};
}
CVB_END_INLINE_NS
}