composite_stream.hpp

#pragma once
 
#include <memory>
 
#include "composite_stream_base.hpp"
#include "../composite.hpp"
 
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
namespace Driver
{
 
 
class CompositeStream
  : public CompositeStreamBase
{
  public:
 
    using GuardType = HandleGuard<CompositeStreamBase>;
 
    CompositeStream(HandleGuard<CompositeStreamBase>&& guard, PrivateTag, const DevicePtr& device)
      : CompositeStreamBase(device, std::move(guard))
    {
    }
 
 
    template<class Rep, class Period>
    WaitResultTuple<Composite> WaitFor(const std::chrono::duration<Rep, Period>& timeSpan, const CancellationToken& token)
    {
      return CreateWaitResult(InternalWaitFor<Composite>(timeSpan, token));
    }
 
 
    template<class Rep, class Period>
    WaitResultTuple<Composite> WaitFor(const std::chrono::duration<Rep, Period>& timeSpan)
    {
      return CreateWaitResult(InternalWaitFor<Composite>(timeSpan));
    }
 
 
    WaitResultTuple<Composite> Wait(const CancellationToken& token)
    {
      return CreateWaitResult(InternalWait<Composite>(token));
    }
 
 
    WaitResultTuple<Composite> Wait()
    {
      return CreateWaitResult(InternalWait<Composite>());
    }
 
  private:
 
    WaitResultTuple<Composite> CreateWaitResult(WaitResultBase<Composite>&& waitResultBase)
    {
      HandleGuard<Composite> guard(nullptr);
      WaitStatus waitStatus = WaitStatus::Ok;
      std::tie(guard, waitStatus) = std::move(waitResultBase);
      if (!guard.Handle())
        return std::make_tuple(CompositePtr(), waitStatus, NodeMapEnumerator());
      else
      {
        CompositePtr composite = Composite::FromHandle(std::move(guard));
        return std::make_tuple(composite, waitStatus, NodeMapEnumerator::FromObject(*composite));
      }
    }
};
 
}
 
using Driver::CompositeStream;
 
CVB_END_INLINE_NS
 
}