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

}