image_stream.hpp

#pragma once
 
#include <memory>
 
#include "composite_stream_base.hpp"
#include "multi_part_image.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace Driver
  {


    class ImageStream : public CompositeStreamBase
    {
    public:
      using GuardType = HandleGuard<CompositeStreamBase>;
 
      ImageStream(HandleGuard<CompositeStreamBase> &&guard, PrivateTag, const DevicePtr &device = {})
          : CompositeStreamBase(device, std::move(guard))
      {
      }


      template <class Rep, class Period>
      WaitResultTuple<MultiPartImage> WaitFor(const std::chrono::duration<Rep, Period> &timeSpan,
                                              CancellationToken &token)
      {
        return CreateWaitResult(InternalWaitFor<Image>(timeSpan, token));
      }
      WaitResultTuple<MultiPartImage> WaitFor(const std::chrono::duration<Rep, Period> &timeSpan, {…}


      template <class Rep, class Period>
      WaitResultTuple<MultiPartImage> WaitFor(const std::chrono::duration<Rep, Period> &timeSpan)
      {
        return CreateWaitResult(InternalWaitFor<Image>(timeSpan));
      }
      WaitResultTuple<MultiPartImage> WaitFor(const std::chrono::duration<Rep, Period> &timeSpan) {…}


      WaitResultTuple<MultiPartImage> Wait(const CancellationToken &token)
      {
        return CreateWaitResult(InternalWait<Image>(token));
      }
      WaitResultTuple<MultiPartImage> Wait(const CancellationToken &token) {…}


      WaitResultTuple<MultiPartImage> Wait()
      {
        return CreateWaitResult(InternalWait<Image>());
      }
      WaitResultTuple<MultiPartImage> Wait() {…}
 
    private:
      WaitResultTuple<MultiPartImage> CreateWaitResult(WaitResultBase<Image> &&waitResultBase)
      {
        HandleGuard<Image> guard(nullptr);
        WaitStatus waitStatus       = WaitStatus::Ok;
        std::tie(guard, waitStatus) = std::move(waitResultBase);
        if (!guard.Handle())
          return std::make_tuple(MultiPartImagePtr(), waitStatus, NodeMapEnumerator());
        else
        {
          if (!CVB_CALL_CAPI(IsImage(guard.Handle())))
            throw std::runtime_error("acquired composite is not an image");
          MultiPartImagePtr image = Image::FromHandle<MultiPartImage>(std::move(guard));
          return std::make_tuple(image, waitStatus, NodeMapEnumerator::FromObject(*image));
        }
      }
    };
    class ImageStream : public CompositeStreamBase {…};
 
  }  // namespace Driver
 
  using Driver::ImageStream;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb