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
}