detail_notify_observable.hpp

#pragma once
 
#include "../../global.hpp"
 
#include "../_decl/decl_notify_observable.hpp"
 
#include "../../_cexports/c_driver.h"
 
#include "../../_decl/decl_device.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace Driver
  {
 
    inline NotifyObservable::NotifyObservable(const DevicePtr &parent, int index)
        : parent_(parent)
    {
      std::size_t bufferSize               = 0;
      CExports::CVNotifyInfo_t eventNumber = 0;
      auto bufferSizeResult = CExports::NOGetDescription(parent_->Handle(), static_cast<std::size_t>(index), nullptr,
                                                         bufferSize, eventNumber);
      if (bufferSizeResult < 0)
        std::rethrow_exception(CvbException::FromCvbResult(bufferSizeResult, "failed description buffer size"));
 
      std::vector<char> buffer(bufferSize);
      auto bufferResult = CExports::NOGetDescription(parent_->Handle(), static_cast<std::size_t>(index), &buffer[0],
                                                     bufferSize, eventNumber);
      if (bufferResult)
        std::rethrow_exception(CvbException::FromCvbResult(bufferResult, "failed description buffer"));
 
      eventNumber_ = eventNumber;
      description_ = String(buffer.begin(), buffer.end());
 
      CExports::cvbres_t resultRegister =
          CExports::NORegister(parent_->Handle(), static_cast<CExports::CVNotifyEvent_t>(eventNumber_),
                               &NotifyObservable::Callback, this, cookie_);
      if (resultRegister < 0)
        std::rethrow_exception(CvbException::FromCvbResult(resultRegister, "failed to register node object"));
    }
 
    inline NotifyObservable::~NotifyObservable()
    {
      // may be switched to another port
      CExports::NOUnregister(parent_->Handle(), cookie_);
    }
 
    inline bool NotifyObservable::IsAvailable() const
    {
      CExports::cvbint64_t info = 0;
      auto result               = CExports::NOGetStatus(parent_->Handle(), static_cast<CExports::CVNotifyEvent_t>(ID()),
                                                        CExports::CVNO_INFO_IS_AVAILABLE, info);
      if (result < 0)
        std::rethrow_exception(CvbException::FromCvbResult(result, "failed get status available"));
 
      return (info) ? true : false;
    }
    inline bool NotifyObservable::IsAvailable() const {…}
 
    inline EventCookie NotifyObservable::RegisterEvent(std::function<void(NotifyArgs)> handler)
    {
      auto carrier = Internal::CbCarrier<void(NotifyArgs)>::Create(handler);
      return carrierContainer_.Register(carrier);
    }
    inline EventCookie NotifyObservable::RegisterEvent(std::function<void(NotifyArgs)> handler) {…}
 
    inline void NotifyObservable::UnregisterEvent(EventCookie eventCookie) noexcept
    {
      carrierContainer_.Unregister(eventCookie);
    }
    inline void NotifyObservable::UnregisterEvent(EventCookie eventCookie) noexcept {…}
 
  }  // namespace Driver
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb