decl_stream_handler_base.hpp

#pragma once
 
#include "../../point_cloud.hpp"
#include "../../driver/image_stream.hpp"
#include "../async.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace Async
  {
    namespace Internal
    {
      template <class STREAMTYPE>
      struct IsValidStreamImpl
      {
        static auto check(STREAMTYPE *) -> decltype(std::is_base_of<CompositeStreamBase, STREAMTYPE>::value
                                                        || std::is_same<Stream, STREAMTYPE>::value,
                                                    std::true_type());
        static auto check(...) -> std::false_type;
      };
 
      template <class STREAMTYPE>
      struct IsValidStream : public decltype(IsValidStreamImpl<STREAMTYPE>::check(nullptr)){};
 
      // \brief Abstracts information about the main deliverable of the
      //        specified stream.
      // \tparam STREAMTYPE Type of stream.
      template <class STREAMTYPE, typename std::enable_if_t<IsValidStream<STREAMTYPE>::value> * = nullptr>
      struct DeliverableTraits;
 
      template <>
      struct DeliverableTraits<ImageStream>
      {
        using type = MultiPartImage;
      };
 
      template <>
      struct DeliverableTraits<CompositeStream>
      {
        using type = Composite;
      };
 
      template <>
      struct DeliverableTraits<PointCloudStream>
      {
        using type = PointCloud;
      };
 
      template <>
      struct DeliverableTraits<Stream>
      {
        using type = StreamImage;
      };
 
      // \brief Abstracts information about the corresponding device of the
      //        specified stream.
      // \tparam STREAMTYPE Type of stream.
      template <class STREAMTYPE, typename std::enable_if_t<IsValidStream<STREAMTYPE>::value> * = nullptr>
      struct DeviceTraits
      {
        // Represents the corresponding device type of the specified stream.
        using type = Driver::GenICamDevice;
      };
 
      template <>
      struct DeviceTraits<Stream>
      {
        using type = Device;
      };
 
      // \brief multi-stream handler based on the specified stream.
      // \tparam STREAMTYPE Type of stream.
      template <class STREAMTYPE, typename std::enable_if_t<IsValidStream<STREAMTYPE>::value> * = nullptr>
      struct TpedStreamHandlerTraits
      {
        // Represents the corresponding multi-stream handler type of the specified stream.
        using type = void;
      };
 
    }  // namespace Internal


    template <class STREAMTYPE>
    class StreamHandlerBase
    {
 
    public:
      using StreamType = STREAMTYPE;

      using StreamPtrType = std::shared_ptr<StreamType>;

      using StreamVectorType = std::vector<StreamPtrType>;

      using DeliverableType = typename Internal::DeliverableTraits<STREAMTYPE>::type;

      using DeliverablePtrType = std::shared_ptr<typename Internal::DeliverableTraits<STREAMTYPE>::type>;

      using DeliverablePtrVectorType = std::vector<DeliverablePtrType>;

      using EventHandlerType = std::function<void(DeliverablePtrType, Cvb::WaitStatus)>;

      using EventHandlerVectorType = std::vector<EventHandlerType>;


      static std::unique_ptr<StreamHandlerBase> Create(const StreamVectorType &streamVector)
      {
        return std::unique_ptr<StreamHandlerBase>(new StreamHandlerBase(streamVector));
      }
      static std::unique_ptr<StreamHandlerBase> Create(const StreamVectorType &streamVector) {…}


      static std::unique_ptr<StreamHandlerBase> Create(const StreamPtrType &stream)
      {
        return Create(StreamVectorType{stream});
      }
      static std::unique_ptr<StreamHandlerBase> Create(const StreamPtrType &stream) {…}
 
      StreamHandlerBase(const StreamHandlerBase &other)            = delete;
      StreamHandlerBase &operator=(const StreamHandlerBase &other) = delete;
      StreamHandlerBase(StreamHandlerBase &&other)                 = delete;
      StreamHandlerBase &operator=(StreamHandlerBase &&other)      = delete;
      virtual ~StreamHandlerBase();


      void Run();


      bool TryFinish() noexcept;


      void Finish();


      bool IsActive() const noexcept
      {
        return isActive_;
      }
      bool IsActive() const noexcept {…}
 
      void operator()();
 
    protected:

      virtual void HandleAsyncStream(const StreamVectorType &streamVector);


      virtual void HandleAsyncWaitResult(
          const std::vector<WaitResult<typename Internal::DeliverableTraits<STREAMTYPE>::type>> &waitResultVector);


      virtual void HandleAsyncWaitResult(
          const std::vector<WaitResultTuple<typename Internal::DeliverableTraits<STREAMTYPE>::type>> &waitResultVector);


      virtual void Setup(const StreamVectorType streamVector);


      virtual void TearDown(const StreamVectorType streamVector) noexcept;


      virtual void HandleError(const std::exception &error) noexcept;


      virtual void Begin() noexcept {}


      virtual void End() noexcept {}
 
    protected:

      explicit StreamHandlerBase(const StreamVectorType &streamVector);


      explicit StreamHandlerBase(const StreamPtrType &stream);


      std::vector<StreamPtrType> StreamVector() const noexcept
      {
        return streamVector_;
      }
      std::vector<StreamPtrType> StreamVector() const noexcept {…}
 
    private:
      void BeginFinish();
      void EndFinish();
 
      StreamVectorType streamVector_;
 
      std::unique_ptr<std::thread> thread_;
      std::mutex mutex_;
 
      std::atomic<bool> isActive_;
 
      std::exception_ptr lastError_;
    };
    class StreamHandlerBase {…};


    template <class STREAMTYPE>
    class StreamHandlerGuard final
    {
    public:
      using StreamHandlerBasePtr = std::shared_ptr<StreamHandlerBase<STREAMTYPE>>;


      explicit StreamHandlerGuard(StreamHandlerBasePtr streamHandler, AutoRun autoRun = AutoRun::No) noexcept
          : streamHandler_(streamHandler)
      {
        assert(("streamHandler must not be NULL", streamHandler));
        if (!streamHandler->IsActive() && autoRun == AutoRun::Yes)
          streamHandler->Run();
      }
      explicit StreamHandlerGuard(StreamHandlerBasePtr streamHandler, AutoRun autoRun = AutoRun::No) noexcept {…}
 
      StreamHandlerGuard(const StreamHandlerGuard &other)            = delete;
      StreamHandlerGuard &operator=(const StreamHandlerGuard &other) = delete;
      StreamHandlerGuard(StreamHandlerGuard &&other)                 = delete;
      StreamHandlerGuard &operator=(StreamHandlerGuard &&other)      = delete;


      ~StreamHandlerGuard()
      {
        streamHandler_->TryFinish();
      }
      ~StreamHandlerGuard() {…}
 
    private:
      StreamHandlerBasePtr streamHandler_;
    };
    class StreamHandlerGuard final {…};
 
  }  // namespace Async
 
  using Async::StreamHandlerBase;
  using Async::StreamHandlerBasePtr;
 
  using Async::StreamHandlerGuard;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb