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;
      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

}