point_cloud_stream.hpp

#pragma once
 
#include <memory>
 
#include "composite_stream_base.hpp"
#include "../point_cloud.hpp"
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
namespace Driver
{
 
 
class PointCloudStream
  : public CompositeStreamBase
{
    public:
 
      using GuardType = HandleGuard<CompositeStreamBase>;
 
      PointCloudStream(HandleGuard<CompositeStreamBase>&& guard, PrivateTag, const DevicePtr& device)
        : CompositeStreamBase(device, std::move(guard))
      {
      }
      
 
      template<class Rep, class Period>
      WaitResultTuple<PointCloud> WaitFor(const std::chrono::duration<Rep, Period>& timeSpan, const CancellationToken & token)
      {
        return CreateWaitResult<PointCloud>(InternalWaitFor<PointCloud>(timeSpan, token));
      }
 
 
      template<class Rep, class Period>
      WaitResultTuple<PointCloud> WaitFor(const std::chrono::duration<Rep, Period>& timeSpan)
      {
        return CreateWaitResult<PointCloud>(InternalWaitFor<PointCloud>(timeSpan));
      }
 
 
      template<class T, class Rep, class Period>
      WaitResultTuple<T> WaitFor(const std::chrono::duration<Rep, Period>& timeSpan, const CancellationToken & token)
      {
        static_assert(std::is_base_of<PointCloud, T>::value, "CVB: PointCloud must be a base of T");
        return CreateWaitResult<T>(InternalWaitFor<PointCloud>(timeSpan, token));
      }
 
 
      template<class T, class Rep, class Period>
      WaitResultTuple<T> WaitFor(const std::chrono::duration<Rep, Period>& timeSpan)
      {
        static_assert(std::is_base_of<PointCloud, T>::value, "CVB: PointCloud must be a base of T");
        return CreateWaitResult<T>(InternalWaitFor<PointCloud>(timeSpan));
      }
 
 
      WaitResultTuple<PointCloud> Wait(const CancellationToken & token)
      {
        return CreateWaitResult<PointCloud>(InternalWait<PointCloud>(token));
      }
 
 
      WaitResultTuple<PointCloud> Wait()
      {
        return CreateWaitResult<PointCloud>(InternalWait<PointCloud>());
      }
 
 
      template <class T>
      WaitResultTuple<T> Wait(const CancellationToken & token)
      {
        static_assert(std::is_base_of<PointCloud, T>::value, "CVB: PointCloud must be a base of T");
        return CreateWaitResult<T>(InternalWait<PointCloud>(token));
      }
 
 
      template <class T>
      WaitResultTuple<T> Wait()
      {
        static_assert(std::is_base_of<PointCloud, T>::value, "CVB: PointCloud must be a base of T");
        return CreateWaitResult<T>(InternalWait<PointCloud>());
      }
 
  private:
 
    template<class T>
    WaitResultTuple<T> CreateWaitResult(WaitResultBase<PointCloud>&& waitResultBase)
    {
      HandleGuard<PointCloud> guard(nullptr);
      WaitStatus waitStatus;
      std::tie(guard, waitStatus) = std::move(waitResultBase);
      if (!guard.Handle())
        return std::make_tuple(std::shared_ptr<T>(), waitStatus, NodeMapEnumerator());
      else
      {
        CExports::CVCCompositePurpose purpose = CExports::CVCCP_Custom;
        CVB_CALL_CAPI_CHECKED(CVCCompositeGetPurpose(guard.Handle(), purpose))
        if (purpose != CExports::CVCCP_PointCloud)
          throw std::runtime_error("acquired composite is not a point cloud");
        auto pointCloud = T::FromHandle(std::move(guard));
        return std::make_tuple(pointCloud, waitStatus, NodeMapEnumerator::FromObject(*pointCloud));
      }
    }
};
 
}
 
using Driver::PointCloudStream;
 
CVB_END_INLINE_NS
 
}