decl_device_factory.hpp

#pragma once
 
#include <exception>
#include <memory>
#include <mutex>
#include <stdexcept>
#include <chrono>
#include <vector>
 
#include "../global.hpp"
#include "../exception.hpp"
#include "../string.hpp"
 
#include "../utilities/system_info.hpp"
 
#include "../driver/discovery_information.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS


 
  class DeviceFactory final
  {
  public:

    template <class T>
    static std::shared_ptr<T> Open(const String &provider,
                                   AcquisitionStack acquisitionStack = AcquisitionStack::PreferVin)
    {
      static_assert(std::is_base_of<Device, T>::value, "CVB: Device must be a base of T");
      auto device = std::dynamic_pointer_cast<T>(Open(provider, acquisitionStack));
      if (!device)
        throw std::runtime_error("open failed to cast to device type");
      return device;
    }
    static std::shared_ptr<T> Open(const String &provider, {…}


    static DevicePtr Open(const String &provider, AcquisitionStack acquisitionStack = AcquisitionStack::PreferVin);


    template <class T>
    static std::shared_ptr<T> Open(const String &provider, int port, int board)
    {
      static_assert(std::is_base_of<Device, T>::value, "CVB: Device must be a base of T");
      auto device = std::dynamic_pointer_cast<T>(Open(provider, port, board));
      if (!device)
        throw std::runtime_error("open failed to cast to device type");
      return device;
    }
    static std::shared_ptr<T> Open(const String &provider, int port, int board) {…}


    static DevicePtr Open(const String &provider, int port, int board)
    {
      if (Internal::IsAccessToken(provider))
        throw std::logic_error("access tokens do not support port or board switch");
      auto device = Open(provider, AcquisitionStack::PreferVin);
      ChangeBoard(device, board);
      ChangePort(device, port);
      return device;
    }
    static DevicePtr Open(const String &provider, int port, int board) {…}


    template <class T>
    static std::shared_ptr<T> OpenBoard(const String &provider, int board)
    {
      static_assert(std::is_base_of<Device, T>::value, "CVB: Device must be a base of T");
      auto device = std::dynamic_pointer_cast<T>(OpenBoard(provider, board));
      if (!device)
        throw std::runtime_error("open board failed to cast to device type");
      return device;
    }
    static std::shared_ptr<T> OpenBoard(const String &provider, int board) {…}


    static DevicePtr OpenBoard(const String &provider, int board)
    {
      if (Internal::IsAccessToken(provider))
        throw std::logic_error("access tokens do not support port or board switch");
      auto device = Open(provider, AcquisitionStack::PreferVin);
      ChangeBoard(device, board);
      return device;
    }
    static DevicePtr OpenBoard(const String &provider, int board) {…}


    template <class T>
    static std::shared_ptr<T> OpenPort(const String &provider, int port)
    {
      static_assert(std::is_base_of<Device, T>::value, "CVB: Device must be a base of T");
      auto device = std::dynamic_pointer_cast<T>(OpenPort(provider, port));
      if (!device)
        throw std::runtime_error("open port failed to cast to device type");
      return device;
    }
    static std::shared_ptr<T> OpenPort(const String &provider, int port) {…}


    static DevicePtr OpenPort(const String &provider, int port)
    {
      if (Internal::IsAccessToken(provider))
        throw std::logic_error("access tokens do not support port or board switch");
      auto device = Open(provider, AcquisitionStack::PreferVin);
      ChangePort(device, port);
      return device;
    }
    static DevicePtr OpenPort(const String &provider, int port) {…}


    static std::vector<DiscoveryInformation> Discover()
    {
#if defined _WIN32
      return Discover(DiscoverFlags::IgnoreVins | DiscoverFlags::IgnoreGevSD);
#else
      return Discover(DiscoverFlags::IgnoreVins);
#endif
    }
    static std::vector<DiscoveryInformation> Discover() {…}


    static std::vector<DiscoveryInformation> Discover(DiscoverFlags flags)
    {
      return Discover(String(), flags, std::chrono::milliseconds(300));
    }
    static std::vector<DiscoveryInformation> Discover(DiscoverFlags flags) {…}


    template <class Rep, class Period>
    static std::vector<DiscoveryInformation> Discover(DiscoverFlags flags,
                                                      const std::chrono::duration<Rep, Period> &timeSpan)
    {
      return Discover(String(), flags, timeSpan);
    }
    static std::vector<DiscoveryInformation> Discover(DiscoverFlags flags, {…}


    template <class Rep, class Period>
    static std::vector<DiscoveryInformation> Discover(const String &accessToken, DiscoverFlags flags,
                                                      const std::chrono::duration<Rep, Period> &timeSpan);


    static std::vector<DiscoveryInformation> Discover(const String &accessToken, DiscoverFlags flags)
    {
      return Discover(accessToken, flags, std::chrono::milliseconds(300));
    }
    static std::vector<DiscoveryInformation> Discover(const String &accessToken, DiscoverFlags flags) {…}


    static std::vector<DiscoveryInformation> Discover(const String &accessToken)
    {
      return Discover(accessToken, DiscoverFlags::FindAll);
    }
    static std::vector<DiscoveryInformation> Discover(const String &accessToken) {…}


    static std::vector<DiscoveryInformation> Discover(const DiscoveryInformation &info)
    {
      return Discover(info.AccessToken());
    }
    static std::vector<DiscoveryInformation> Discover(const DiscoveryInformation &info) {…}


    static std::vector<DiscoveryInformation> Discover(const DiscoveryInformation &info, DiscoverFlags flags)
    {
      return Discover(info.AccessToken(), flags, std::chrono::milliseconds(300));
    }
    static std::vector<DiscoveryInformation> Discover(const DiscoveryInformation &info, DiscoverFlags flags) {…}


    template <class Rep, class Period>
    static std::vector<DiscoveryInformation> Discover(const DiscoveryInformation &info, DiscoverFlags flags,
                                                      const std::chrono::duration<Rep, Period> &timeSpan)
    {
      return Discover(info.AccessToken(), flags, timeSpan);
    }
    static std::vector<DiscoveryInformation> Discover(const DiscoveryInformation &info, DiscoverFlags flags, {…}
 
    static CExports::cvbguid_t AviMpgGuid()
    {
      static CExports::cvbguid_t guid = {0x7DBE4A03, 0xAD3D, 0x4533, 0x85, 0x1F, 0x61, 0xB4, 0xAE, 0x62, 0xC2, 0x0E};
      return guid;
    }
 
    static CExports::cvbguid_t EmuGuid()
    {
      static CExports::cvbguid_t guid = {0x10cb8e8f, 0x00b6, 0x4bb0, 0xbb, 0x82, 0xcd, 0x77, 0x2c, 0xba, 0xb7, 0x57};
      return guid;
    }
 
    static std::mutex &LockAnchor()
    {
      static std::mutex mutex;
      return mutex;
    }
 
  private:
    DeviceFactory() noexcept = delete;
 
    static void ChangeBoard(DevicePtr &device, int board);
 
    static void ChangeBoard1(DevicePtr &device, int board);
 
    static void ChangeBoard2(DevicePtr &device, int board);
 
    static void ChangePort(DevicePtr &device, int port);
 
    static void ChangePort1(DevicePtr &device, int port);
 
    static void ChangePort2(DevicePtr &device, int port);
 
    static bool AllowFallback(AcquisitionStack acquisitionStack) noexcept
    {
      return acquisitionStack == Cvb::AcquisitionStack::PreferVin
             || acquisitionStack == Cvb::AcquisitionStack::PreferGenTL;
    }
 
    static HandleGuard<Device> LoadAsGenTL(const String &provider, AcquisitionStack acquisitionStack);
 
    static HandleGuard<Device> LoadAsVin(const String &provider, AcquisitionStack acquisitionStack);
 
    static HandleGuard<Device> LoadAsNonStreaming(const String &provider);
 
    static DevicePtr CreateDeviceByDriverGUID(const String &provider, HandleGuard<Device> &&guard) noexcept;
  };
  class DeviceFactory final {…};
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb