value_node.hpp

#pragma once
 
#include <typeinfo>
#include <vector>
 
#include "../_cexports/c_gev_server.h"
 
#include "../global.hpp"
 
#include "_decl/decl_node.hpp"
 
 
 
namespace Cvb
{
CVB_BEGIN_INLINE_NS
namespace GevServer
{
 
class ValueNode
    : public GevServer::Node
{
  enum ReplyStatus
  {
    Success,
    AccessDenied,
    Busy,
    NotImplemented,
    DataOverrun,
    InvalidParameter,
    WrongConfig,
    LocalProblem
  };
 
public:
  
  ValueNode(const ValueNode& other) = delete;
  ValueNode& operator=(const ValueNode& other) = delete;
  ValueNode(ValueNode&& other) = delete;
  ValueNode& operator=(ValueNode&& other) = delete;
  virtual ~ValueNode()
  {
    if (readCallbackID_)
      CVB_CALL_CAPI(GSNUnregisterEvent(Handle(), CExports::TGSNodeEvent::GSNE_Read, readCallbackID_));
 
    if (writeCallbackID_)
      CVB_CALL_CAPI(GSNUnregisterEvent(Handle(), CExports::TGSNodeEvent::GSNE_Write, writeCallbackID_));
  }
 
 
  virtual bool IsStreamable() const { return GetInfoAsInt(NodeInfo::Streamable) != 0; }
 
 
  virtual void SetIsStreamable(const std::int64_t &value)
  {
    NativeCall([&]() {
      return CVB_CALL_CAPI(GSNSetInfoAsInteger(Handle(), CExports::TGSNodeInfo::GSNI_Streamable, (value ? 1 : 0)));
    });
  }
 
 
  template <class Rep, class Period> std::chrono::duration<Rep, Period> PollingTime() const
  {
    auto timeMs = GetInfoAsInt(NodeInfo::PollingTime);
    if (timeMs > 0)
      return std::chrono::duration<Rep, Period>(timeMs);
    else
      return std::chrono::duration<Rep, Period>::zero();
  }
 
 
  virtual String ToString() const
  {
    auto bufferSize = NativeCall<size_t>(
        [&](size_t &size) { return CExports::GSNGetAsStringTyped(Handle(), reinterpret_cast<Char *>(0), size); });
    bufferSize += sizeof(Char);
    std::vector<Char> buffer(bufferSize);
    NativeCall([&]() { return CExports::GSNGetAsStringTyped(Handle(), buffer.data(), bufferSize); });
    return buffer.data();
  }
 
 
  virtual void FromString(const String &value)
  {
    NativeCall([&]() { return CExports::GSNSetAsStringTyped(Handle(), value.data()); });
  }
 
 
  EventCookie RegisterEventWrittenUpdated(std::function<void(ValueNode &)> handler)
  {
    auto holder = Internal::CbCarrier<void(ValueNode &)>::Create(handler);
    return updatedCarrierContainerWritten_.Register(holder);
  }
 
 
  void UnregisterEventWrittenUpdated(EventCookie eventCookie) noexcept
  {
    updatedCarrierContainerWritten_.Unregister(eventCookie);
  }
 
 
  EventCookie RegisterEventOnReadUpdated(std::function<void(ValueNode &)> handler)
  {
    auto holder = Internal::CbCarrier<void(ValueNode &)>::Create(handler);
    return updatedCarrierContainerOnRead_.Register(holder);
  }
 
 
  void UnregisterEventOnReadUpdated(EventCookie eventCookie) noexcept
  {
    updatedCarrierContainerOnRead_.Unregister(eventCookie);
  }
 
protected:
  explicit ValueNode(HandleGuard<Node> &&guard) : Node(std::move(guard))
  {
    switch (NodeType(Handle()))
    {
    case GevServer::NodeType::Category:
    case GevServer::NodeType::EnumEntry:
      break; // No value events
    default:
      int resultRegister = CVB_CALL_CAPI(GSNRegisterEventWithStatus(
          Handle(), CExports::TGSNodeEvent::GSNE_Read, &ValueNode::EventOnReadCallback, this, readCallbackID_));
      if (resultRegister < 0)
        std::rethrow_exception(CvbException::FromCvbResult(resultRegister, "failed to register updated handler"));
 
      resultRegister = CVB_CALL_CAPI(GSNRegisterEventWithStatus(
          Handle(), CExports::TGSNodeEvent::GSNE_Write, &ValueNode::EventWrittenCallback, this, writeCallbackID_));
      if (resultRegister < 0)
        std::rethrow_exception(CvbException::FromCvbResult(resultRegister, "failed to register updated handler"));
      break;
    }
  }
 
private:
  static void __stdcall EventWrittenCallback(CExports::cvbres_t &status, void *pPrivate)
  {
    if (status == ReplyStatus::Success)
    {
      try
      {
        auto node = reinterpret_cast<ValueNode *>(pPrivate);
        node->updatedCarrierContainerWritten_.Call<void(ValueNode &)>(*node);
      }
      catch (...)
      {
      }
    }
    switch (status)
    {
    case ReplyStatus::Success:
      status = ErrorCodes::CVB_OK;
      break;
    case ReplyStatus::AccessDenied:
      status = ErrorCodes::CVB_ACCESS;
      break;
    case ReplyStatus::Busy:
      status = ErrorCodes::CVB_BUSY;
      break;
    case ReplyStatus::NotImplemented:
      status = ErrorCodes::CVB_NOTSUPPORTED;
      break;
    case ReplyStatus::DataOverrun:
      status = ErrorCodes::CVB_OVERFLOW;
      break;
    case ReplyStatus::InvalidParameter:
      status = ErrorCodes::CVB_PARAMETER;
      break;
    case ReplyStatus::WrongConfig:
      status = ErrorCodes::CVB_NOTENOUGHDATA;
      break;
    default:
    case ReplyStatus::LocalProblem:
      status = ErrorCodes::CVB_ERROR;
      break;
    }
  }
 
  static void __stdcall EventOnReadCallback(CExports::cvbres_t &status, void *pPrivate)
  {
    if (status == ReplyStatus::Success)
    {
      try
      {
        auto node = reinterpret_cast<ValueNode *>(pPrivate);
        node->updatedCarrierContainerOnRead_.Call<void(ValueNode &)>(*node);
      }
      catch (...)
      {
      }
    }
 
    switch (status)
    {
    case ReplyStatus::Success:
      status = ErrorCodes::CVB_OK;
      break;
    case ReplyStatus::AccessDenied:
      status = ErrorCodes::CVB_ACCESS;
      break;
    case ReplyStatus::Busy:
      status = ErrorCodes::CVB_BUSY;
      break;
    case ReplyStatus::NotImplemented:
      status = ErrorCodes::CVB_NOTSUPPORTED;
      break;
    case ReplyStatus::DataOverrun:
      status = ErrorCodes::CVB_OVERFLOW;
      break;
    case ReplyStatus::InvalidParameter:
      status = ErrorCodes::CVB_PARAMETER;
      break;
    case ReplyStatus::WrongConfig:
      status = ErrorCodes::CVB_NOTENOUGHDATA;
      break;
    default:
    case ReplyStatus::LocalProblem:
      status = ErrorCodes::CVB_ERROR;
      break;
    }
  }
 
  Internal::CarrierContainer updatedCarrierContainerWritten_;
  Internal::CarrierContainer updatedCarrierContainerOnRead_;
 
  std::size_t readCallbackID_{0};
  std::size_t writeCallbackID_{0};
};
CVB_END_INLINE_NS
}
}