decl_stream.hpp

#pragma once
 
#include <chrono>
#include <exception>
#include <limits>
#include <memory>
 
#include "../../_cexports/c_driver.h"
 
#include "../../global.hpp"
#include "../../exception.hpp"
 
#include "../driver.hpp"
#include "../stream_base.hpp"
 
#include "../../utilities/system_info.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace Driver
  {


    class Stream : public StreamBase
    {
    public:
      Cvb::Driver::AcquisitionInterface AcquisitionInterface() const noexcept override
      {
        return acquisitionEngine_->AcquisitionInterface();
      }
      Cvb::Driver::AcquisitionInterface AcquisitionInterface() const noexcept override {…}


      void SetAcquisitionInterface(Cvb::Driver::AcquisitionInterface acquisitionInterface)
      {
        if (acquisitionEngine_ && acquisitionInterface == acquisitionEngine_->AcquisitionInterface())
          return;
 
        switch (acquisitionInterface)
        {
          case Cvb::Driver::AcquisitionInterface::Grab2:
            acquisitionEngine_ = std::make_unique<Grab2>(*Parent());
            break;
 
          case Cvb::Driver::AcquisitionInterface::Grabber:
            acquisitionEngine_ = std::make_unique<Grab>(*Parent());
            break;
 
          default:
            throw std::runtime_error("no suitable acquisition interface implemented");
            break;
        }
      }
      void SetAcquisitionInterface(Cvb::Driver::AcquisitionInterface acquisitionInterface) {…}
 
      void Start() override
      {
        acquisitionEngine_->Start();
      }
      void Start() override {…}
 
      void Stop() override
      {
        if (!acquisitionEngine_->TryStop())
          throw std::runtime_error("failed to stop acquisition");
      }
      void Stop() override {…}
 
      bool TryStop() noexcept override
      {
        return acquisitionEngine_->TryStop();
      }
      bool TryStop() noexcept override {…}
 
      void Abort() override
      {
        if (!acquisitionEngine_->TryAbort())
          throw std::runtime_error("failed to abort acquisition");
      }
      void Abort() override {…}
 
      bool TryAbort() noexcept override
      {
        return acquisitionEngine_->TryAbort();
      }
      bool TryAbort() noexcept override {…}


      bool IsRunning() const noexcept
      {
        return acquisitionEngine_->IsRunning();
      }
      bool IsRunning() const noexcept {…}
 
      bool IsIndexed() const noexcept override
      {
        return false;
      }
      bool IsIndexed() const noexcept override {…}


      double Statistics(StreamInfo query) const
      {
        return statistics_->Query(query);
      }
      double Statistics(StreamInfo query) const {…}


      template <class T>
      T Statistics(StreamInfo query) const
      {
        return static_cast<T>(Statistics(query));
      }
      T Statistics(StreamInfo query) const {…}


      virtual RingBufferPtr RingBuffer() const noexcept
      {
        return RingBufferPtr();
      }
      virtual RingBufferPtr RingBuffer() const noexcept {…}


      template <class T, class Rep, class Period>
      std::shared_ptr<T> WaitFor(const std::chrono::duration<Rep, Period> &timeSpan, WaitStatus &waitStatus)
      {
        static_assert(std::is_base_of<StreamImage, T>::value, "CVB: StreamImage must be a base of T");
        auto baseImage = WaitFor(timeSpan, waitStatus);
        if (!baseImage)
          return std::shared_ptr<T>();
 
        auto image = std::dynamic_pointer_cast<T>(baseImage);
        if (!image)
          throw std::runtime_error("stream image cannot be cast");
 
        return image;
      }
      std::shared_ptr<T> WaitFor(const std::chrono::duration<Rep, Period> &timeSpan, WaitStatus &waitStatus) {…}


      template <class Rep, class Period>
      StreamImagePtr WaitFor(const std::chrono::duration<Rep, Period> &timeSpan, WaitStatus &waitStatus);


      template <class T, class Rep, class Period>
      WaitResult<T> WaitFor(const std::chrono::duration<Rep, Period> &timeSpan)
      {
        static_assert(std::is_base_of<StreamImage, T>::value, "CVB: StreamImage must be a base of T");
        WaitResult<T> waitResult;
        auto baseImage = WaitFor(timeSpan, waitResult.Status);
        if (!baseImage)
          return waitResult;
 
        auto image = std::dynamic_pointer_cast<T>(baseImage);
        if (!image)
          throw std::runtime_error("stream image cannot be cast");
 
        waitResult.Image = image;
        return waitResult;
      }
      WaitResult<T> WaitFor(const std::chrono::duration<Rep, Period> &timeSpan) {…}


      template <class Rep, class Period>
      WaitResult<StreamImage> WaitFor(const std::chrono::duration<Rep, Period> &timeSpan)
      {
        return WaitFor<StreamImage, Rep, Period>(timeSpan);
      }
      WaitResult<StreamImage> WaitFor(const std::chrono::duration<Rep, Period> &timeSpan) {…}


      template <class T>
      std::shared_ptr<T> Wait(WaitStatus &waitStatus)
      {
        static_assert(std::is_base_of<StreamImage, T>::value, "CVB: StreamImage must be a base of T");
        auto baseImage = Wait(waitStatus);
        if (!baseImage)
          return std::unique_ptr<T>();
        auto image = std::dynamic_pointer_cast<T>(baseImage);
        if (!image)
          throw std::runtime_error("stream image cannot be cast");
 
        return image;
      }
      std::shared_ptr<T> Wait(WaitStatus &waitStatus) {…}


      StreamImagePtr Wait(WaitStatus &waitStatus)
      {
#ifdef max
#  undef max
#endif
        while (true)
        {
          auto image = WaitFor(std::chrono::milliseconds(std::numeric_limits<std::uint32_t>::max()), waitStatus);
          if (waitStatus == WaitStatus::Timeout)
            continue;
          return std::move(image);
        }
      }
      StreamImagePtr Wait(WaitStatus &waitStatus) {…}


      template <class T>
      WaitResult<T> Wait()
      {
        static_assert(std::is_base_of<StreamImage, T>::value, "CVB: StreamImage must be a base of T");
        WaitResult<T> waitResult;
        auto baseImage = Wait(waitResult.Status);
        if (!baseImage)
          return waitResult;
        auto image = std::dynamic_pointer_cast<T>(baseImage);
        if (!image)
          throw std::runtime_error("stream image cannot be cast");
 
        waitResult.Image = image;
        return waitResult;
      }
      WaitResult<T> Wait() {…}


      WaitResult<StreamImage> Wait()
      {
#ifdef max
#  undef max
#endif
        while (true)
        {
          auto waitResult = WaitFor(std::chrono::milliseconds(std::numeric_limits<std::uint32_t>::max()));
          if (waitResult.Status == WaitStatus::Timeout)
            continue;
          return waitResult;
        }
      }
      WaitResult<StreamImage> Wait() {…}


      template <class T, class Rep, class Period>
      std::shared_ptr<T> GetTimedSnapshot(const std::chrono::duration<Rep, Period> &timeSpan, WaitStatus &waitStatus)
      {
        static_assert(std::is_base_of<StreamImage, T>::value, "CVB: StreamImage must be a base of T");
        auto baseImage = GetTimedSnapshot(timeSpan, waitStatus);
        if (!baseImage)
          return std::unique_ptr<T>();
        auto image = std::dynamic_pointer_cast<T>(baseImage);
        if (!image)
          throw std::runtime_error("stream image cannot be cast");
 
        return image;
      }
      std::shared_ptr<T> GetTimedSnapshot(const std::chrono::duration<Rep, Period> &timeSpan, WaitStatus &waitStatus) {…}


      template <class Rep, class Period>
      StreamImagePtr GetTimedSnapshot(const std::chrono::duration<Rep, Period> &timeSpan, WaitStatus &waitStatus);


      template <class T, class Rep, class Period>
      WaitResult<T> GetTimedSnapshot(const std::chrono::duration<Rep, Period> &timeSpan)
      {
        static_assert(std::is_base_of<StreamImage, T>::value, "CVB: StreamImage must be a base of T");
        WaitResult<T> waitResult;
        auto baseImage = GetTimedSnapshot(timeSpan, waitResult.Status);
        if (!baseImage)
          return waitResult;
        auto image = std::dynamic_pointer_cast<T>(baseImage);
        if (!image)
          throw std::runtime_error("stream image cannot be cast");
 
        waitResult.Image = image;
        return waitResult;
      }
      WaitResult<T> GetTimedSnapshot(const std::chrono::duration<Rep, Period> &timeSpan) {…}


      template <class Rep, class Period>
      WaitResult<StreamImage> GetTimedSnapshot(const std::chrono::duration<Rep, Period> &timeSpan)
      {
        return GetTimedSnapshot<StreamImage, Rep, Period>(timeSpan);
      }
      WaitResult<StreamImage> GetTimedSnapshot(const std::chrono::duration<Rep, Period> &timeSpan) {…}


      StreamImagePtr GetSnapshot(WaitStatus &waitStatus)
      {
#ifdef max
#  undef max
#endif
        while (true)
        {
          auto image =
              GetTimedSnapshot(std::chrono::milliseconds(std::numeric_limits<std::uint32_t>::max()), waitStatus);
          if (waitStatus == WaitStatus::Timeout)
            continue;
          return std::move(image);
        }
      }
      StreamImagePtr GetSnapshot(WaitStatus &waitStatus) {…}


      WaitResult<StreamImage> GetSnapshot()
      {
#ifdef max
#  undef max
#endif
        while (true)
        {
          auto waitResult = GetTimedSnapshot(std::chrono::milliseconds(std::numeric_limits<std::uint32_t>::max()));
          if (waitResult.Status == WaitStatus::Timeout)
            continue;
          return waitResult;
        }
      }
      WaitResult<StreamImage> GetSnapshot() {…}
 
    protected:
      explicit Stream(const DevicePtr &device);
 
      virtual StreamImagePtr MakeStreamImage() = 0;
 
      virtual StreamImagePtr MakeSnapshotImage() = 0;
 
    private:
      class AcquisitionEngine
      {
      public:
        static Cvb::Driver::AcquisitionInterface GetBestAcquisitionInterface(const Device &device);
 
        explicit AcquisitionEngine(const Device &device)
            : device_(device)
            , lastTimeout_(static_cast<uint32_t>(Utilities::SystemInfo::DefaultTimeout().count()))
        {
        }
 
        AcquisitionEngine(const AcquisitionEngine &other)            = delete;
        AcquisitionEngine &operator=(const AcquisitionEngine &other) = delete;
        AcquisitionEngine(AcquisitionEngine &&other)                 = delete;
        AcquisitionEngine &operator=(AcquisitionEngine &&other)      = delete;
 
        virtual ~AcquisitionEngine() = default;
 
        template <class Rep, class Period>
        void WaitFor(const std::chrono::duration<Rep, Period> &timeSpan, WaitStatus &waitResult)
        {
#ifdef max
#  undef max
#endif
          auto msTimeSpan = std::chrono::duration_cast<std::chrono::milliseconds>(timeSpan).count();
          if (msTimeSpan > static_cast<std::chrono::milliseconds::rep>(std::numeric_limits<std::uint32_t>::max()))
            throw std::overflow_error("wait timeout must fit to unsigned 32 bit integer in ms");
          auto result = TryWaitFor(static_cast<uint32_t>(msTimeSpan));
          if (result < 0)
          {
            switch (result)
            {
              case ErrorCodes::CVB_TIMEOUT:
                waitResult = WaitStatus::Timeout;
                return;
 
              case ErrorCodes::CVB_GRABABORTED:
                waitResult = WaitStatus::Abort;
                return;
 
              default:
                std::rethrow_exception(CvbException::FromCvbResult(result, "WaitFor failed"));
            }
          }
          waitResult = WaitStatus::Ok;
        }
 
        template <class Rep, class Period>
        void GetTimedSnapshot(const std::chrono::duration<Rep, Period> &timeSpan, WaitStatus &waitResult)
        {
#ifdef max
#  undef max
#endif
          auto msTimeSpan = std::chrono::duration_cast<std::chrono::milliseconds>(timeSpan).count();
          if (msTimeSpan > static_cast<std::chrono::milliseconds::rep>(std::numeric_limits<std::uint32_t>::max()))
            throw std::overflow_error("wait timeout must fit to unsigned 32 bit integer in ms");
          auto result = TryGetTimedSnapshot(static_cast<uint32_t>(msTimeSpan));
          if (result < 0)
          {
            switch (result)
            {
              case ErrorCodes::CVB_TIMEOUT:
                waitResult = WaitStatus::Timeout;
                return;
 
              case ErrorCodes::CVB_GRABABORTED:
                waitResult = WaitStatus::Abort;
                return;
 
              default:
                std::rethrow_exception(CvbException::FromCvbResult(result, "WaitFor failed"));
            }
          }
          waitResult = WaitStatus::Ok;
        }
 
        void SetTimeout(uint32_t msTimeSpan);
 
        virtual void Start() = 0;
 
        virtual bool TryStop() noexcept = 0;
 
        virtual bool TryAbort() noexcept = 0;
 
        virtual bool IsRunning() const noexcept = 0;
 
        virtual Cvb::Driver::AcquisitionInterface AcquisitionInterface() const noexcept = 0;
 
        virtual int TryWaitFor(uint32_t msTineSpan) = 0;
 
        virtual int TryGetTimedSnapshot(uint32_t msTineSpan) = 0;
 
      protected:
        void *Handle() const noexcept;
 
      private:
        const Device &device_;
 
        uint32_t lastTimeout_;
      };
 
      class Grab : public AcquisitionEngine
      {
      public:
        explicit Grab(const Device &device);
 
        void Start() override
        {
          if (isRunning_)
            std::rethrow_exception(CvbException::FromCvbResult(ErrorCodes::CVB_BUSY, "acquisition already running"));
          isRunning_ = true;
        }
 
        bool TryStop() noexcept override
        {
          isRunning_ = false;
          return true;
        }
 
        bool TryAbort() noexcept override
        {
          return TryStop();
        }
 
        bool IsRunning() const noexcept override
        {
          return isRunning_;
        }
 
        Cvb::Driver::AcquisitionInterface AcquisitionInterface() const noexcept override
        {
          return Cvb::Driver::AcquisitionInterface::Grabber;
        }
 
        int TryWaitFor(uint32_t msTineSpan) override;
 
        int TryGetTimedSnapshot(uint32_t msTineSpan) override;
 
      private:
        bool isRunning_;
      };
 
      class Grab2 : public AcquisitionEngine
      {
      public:
        explicit Grab2(const Device &device);
 
        void Start() override;
 
        bool TryStop() noexcept override;
 
        bool TryAbort() noexcept override;
 
        bool IsRunning() const noexcept override;
 
        Cvb::Driver::AcquisitionInterface AcquisitionInterface() const noexcept override
        {
          return Cvb::Driver::AcquisitionInterface::Grab2;
        }
 
        int TryWaitFor(uint32_t msTineSpan) override;
 
        int TryGetTimedSnapshot(uint32_t msTineSpan) override;
      };
 
      class StreamStats
      {
      public:
        static std::unique_ptr<StreamStats> CreateGrab2(const Device &device)
        {
          return std::make_unique<Grab2Stats>(device);
        }
 
        static std::unique_ptr<StreamStats> CreateNo(const Device &device)
        {
          return std::make_unique<NoStats>(device);
        }
 
        explicit StreamStats(const Device &device)
            : device_(device)
        {
        }
 
        StreamStats(const StreamStats &other)            = delete;
        StreamStats &operator=(const StreamStats &other) = delete;
        StreamStats(StreamStats &&other)                 = delete;
        StreamStats &operator=(StreamStats &&other)      = delete;
        virtual ~StreamStats()                           = default;
 
        double Query(StreamInfo query) const
        {
          double value = std::numeric_limits<double>::quiet_NaN();
          if (!TryGetValue(query, value))
            throw std::runtime_error("statistics query not supported");
          return value;
        }
 
      protected:
        virtual bool TryGetValue(StreamInfo query, double &value) const noexcept = 0;
 
        void *Handle() const noexcept;
 
      private:
        const Device &device_;
      };
 
      class Grab2Stats : public StreamStats
      {
      public:
        explicit Grab2Stats(const Device &device)
            : StreamStats(device)
        {
        }
 
      protected:
        bool TryGetValue(StreamInfo query, double &value) const noexcept override;
      };
 
      class NoStats : public StreamStats
      {
      public:
        explicit NoStats(const Device &device)
            : StreamStats(device)
        {
        }
 
      protected:
        bool TryGetValue(StreamInfo, double &) const noexcept override
        {
          return false;
        }
      };
 
      std::unique_ptr<AcquisitionEngine> acquisitionEngine_;
 
      std::unique_ptr<StreamStats> statistics_;
    };
    class Stream : public StreamBase {…};
 
  }  // namespace Driver
 
  using Driver::Stream;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb