decl_device.hpp

#pragma once
 
#include <map>
#include <memory>
#include <vector>
 
#include "../_cexports/c_driver.h"
#include "../_cexports/c_img.h"
 
#include "../exception.hpp"
#include "../global.hpp"
#include "../string.hpp"
 
#include "../genapi/genapi.hpp"
 
#include "../driver/driver.hpp"
 
#include "../driver/_decl/decl_notify_observable.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<Device>::HandleGuard(void *handle) noexcept
      : HandleGuard<Device>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }


  class Device : public std::enable_shared_from_this<Device>
  {
    friend DeviceFactory;
 
    friend Driver::Stream;
    friend Driver::RingBuffer;
    friend Driver::ImageRect;
 
  public:
    using GuardType = HandleGuard<Device>;
 
    template <class T, class... ARGS>
    static std::shared_ptr<T> FromHandle(HandleGuard<Device> &&guard, ARGS &&...args)
    {
      if (!guard.Handle())
        throw std::runtime_error("handle must not be null");
 
      static_assert(std::is_base_of<Device, T>::value, "CVB: Type must be derived from Device");
      auto image = std::shared_ptr<T>(new T(std::move(guard), std::forward<ARGS>(args)...));
      return image;
    }
 
    Device(const Device &other)            = delete;
    Device &operator=(const Device &other) = delete;
    Device(Device &&other)                 = delete;
    Device &operator=(Device &&other)      = delete;
 
    virtual ~Device()
    {
      if (CExports::CanNotify(Handle()) && deviceDisconnectCookie_ && deviceReconnectCookie_)
      {
        deviceDisconnect_->UnregisterEvent(deviceDisconnectCookie_);
        deviceReconnect_->UnregisterEvent(deviceReconnectCookie_);
      }
    }


    void *Handle() const noexcept
    {
      return handle_.Handle();
    }
    void *Handle() const noexcept {…}


    String ResourceLocator() const noexcept
    {
      return resourceLocator_;
    }
    String ResourceLocator() const noexcept {…}


    DeviceControlPtr DeviceControl() const;


    DigitalIOPtr DigitalIO() const;


    SoftwareTriggerPtr SoftwareTrigger() const;


    ImageRectPtr ImageRect() const;


    virtual StreamPtr Stream() const;


    int StreamCount() const noexcept;


    template <class T>
    std::shared_ptr<T> DeviceImage() const
    {
      return std::dynamic_pointer_cast<T>(DeviceImage());
    }
    std::shared_ptr<T> DeviceImage() const {…}


    DeviceImagePtr DeviceImage() const
    {
      return deviceImage_.AtomicGet([&]() { return CreateDeviceImage(); });
    }
    DeviceImagePtr DeviceImage() const {…}


    NodeMapPtr NodeMap(const String &name) const;


    std::map<String, NodeMapPtr> NodeMaps() const;


    NotifyObservablePtr NotifyObservable(int id) const;

    Cvb::ConnectionState ConnectionState() const noexcept
    {
      return connectionState_;
    }
    Cvb::ConnectionState ConnectionState() const noexcept {…}


    EventCookie RegisterConnectionStateChangedEvent(std::function<void()> handler);


    void UnregisterConnectionStateChangedEvent(EventCookie eventCookie) noexcept;
 
  protected:
    Device(HandleGuard<Device> &&guard, const String &resourceLocator) noexcept
        : handle_(std::move(guard))
        , resourceLocator_(resourceLocator)
    {
      if (CExports::CanNodeMapHandle2(Handle()))
      {
        TryFillNodeMapKeys2();
      }
      else if (CExports::CanNodeMapHandle(Handle()))
      {
        nodeMaps_[CVB_LIT("Device")].Reset();
      }
 
      if (CExports::CanNotify(Handle()))
        InitNotifyConnectionState();
    }
 
    virtual Driver::DeviceImagePtr CreateDeviceImage() const
    {
      throw std::runtime_error("device image not implemented");
    }
 
    virtual Driver::StreamBasePtr CreateStream(int index, Driver::StreamType streamType) const;
 
    void AnnounceStreams(int streamsCount)
    {
      std::vector<Internal::AsyncRef<Driver::StreamBase>> streams(static_cast<size_t>(streamsCount));
      streams_.swap(streams);
    }
 
    Driver::StreamPtr StreamsOptional(int index) const noexcept;
 
    void OnImageAcquired() const;
 
    virtual void ChangeHandle(HandleGuard<Device> &&guard, DeviceUpdateMode mode);
 
  protected:
    template <class T>
    StreamBasePtr CreateOrGetStreamHelper(int index) const;
 
  private:
    // Private constructor creates dummy device, for internal use only.
    explicit Device(HandleGuard<Device> &&guard) noexcept
        : handle_(std::move(guard))
    {
    }
 
    static DevicePtr FromHandle(HandleGuard<Device> &&guard)
    {
      return DevicePtr(new Device(std::move(guard)));
    }
 
    bool TryFillNodeMapKeys2() noexcept
    {
      size_t numNodeMaps = 0;
      auto resultNum     = CExports::NMH2GetNum(Handle(), numNodeMaps);
      if (resultNum < 0)
        return false;
      for (size_t i = 0; i < numNodeMaps; ++i)
      {
        size_t bufferSize       = 0;
        auto resultBufferLength = CExports::NMH2GetID(Handle(), i, nullptr, bufferSize);
        if (resultBufferLength < 0)
          continue;
        std::vector<char> buffer(bufferSize);
        auto resultBuffer = CExports::NMH2GetID(Handle(), i, &buffer[0], bufferSize);
        if (resultBuffer < 0)
          continue;
        String keyString(buffer.begin(), buffer.end() - 1);
        nodeMaps_[keyString].Reset();
      }
      return true;
    }
 
    bool TryFillNotifyObservables() noexcept;
 
    void InitNotifyConnectionState();
 
    void OnDisconnect(Cvb::Driver::NotifyArgs /*notifyArgs*/, void *pPrivate)
    {
      OnNewConnectionState(Cvb::ConnectionState::Disconnected, pPrivate);
    }
 
    void OnReconnect(Cvb::Driver::NotifyArgs /*notifyArgs*/, void *pPrivate)
    {
      OnNewConnectionState(Cvb::ConnectionState::Connected, pPrivate);
    }
 
    static void __stdcall OnNewConnectionState(const Cvb::ConnectionState &newState, void *pPrivate)
    {
      static std::mutex mtx;
      Cvb::ConnectionState oldState = Cvb::ConnectionState::NotSupported;
 
      auto device = reinterpret_cast<Device *>(pPrivate);
      {
        std::lock_guard<std::mutex> lock(mtx);
        oldState                 = device->connectionState_;
        device->connectionState_ = newState;
      }
 
      try
      {
        if (oldState != newState)
        {
          device->carrierContainer_.Call<void()>();
        }
      }
      catch (...)
      {
        // swallow exception so they do not reach native realm
      }
    }
 
    mutable HandleGuard<Device> handle_;
 
    String resourceLocator_;
 
    mutable std::vector<Internal::AsyncRef<Driver::StreamBase>> streams_;
 
    mutable Internal::AsyncRef<Driver::DeviceImage> deviceImage_;
 
    mutable Internal::AsyncRef<Driver::DeviceControl> deviceControl_;
 
    mutable Internal::AsyncRef<Driver::DigitalIO> digitalIO_;
 
    mutable Internal::AsyncRef<Driver::SoftwareTrigger> softwareTrigger_;
 
    mutable Internal::AsyncRef<Driver::ImageRect> imageRect_;
 
    mutable std::map<String, Internal::AsyncRef<GenApi::NodeMap>> nodeMaps_;
 
    mutable std::map<int, Driver::NotifyObservablePtr> observables_;
 
    mutable Driver::NotifyObservablePtr deviceReconnect_;
 
    mutable Driver::NotifyObservablePtr deviceDisconnect_;
    mutable EventCookie deviceDisconnectCookie_;
    mutable EventCookie deviceReconnectCookie_;
 
    mutable Cvb::ConnectionState connectionState_{Cvb::ConnectionState::NotSupported};
 
    Internal::CarrierContainer carrierContainer_;
  };
  class Device : public std::enable_shared_from_this<Device> {…};
 
  CVB_END_INLINE_NS
}  // namespace Cvb