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));
    }
 
 
    template<class Rep, class Period>
    WaitResultTuple<MultiPartImage> WaitFor(const std::chrono::duration<Rep, Period>& timeSpan)
    {
      return CreateWaitResult(InternalWaitFor<Image>(timeSpan));
    }
 
 
    WaitResultTuple<MultiPartImage> Wait(const CancellationToken & token)
    {
      return CreateWaitResult(InternalWait<Image>(token));
    }
 
 
    WaitResultTuple<MultiPartImage> Wait()
    {
      return CreateWaitResult(InternalWait<Image>());
    }
 
  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));
      }
    }
};
 
}
 
using Driver::ImageStream;
 
CVB_END_INLINE_NS
 
}