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));
      }
      WaitResultTuple<Composite> WaitFor(const std::chrono::duration<Rep, Period> &timeSpan, {…}


      template <class Rep, class Period>
      WaitResultTuple<Composite> WaitFor(const std::chrono::duration<Rep, Period> &timeSpan)
      {
        return CreateWaitResult(InternalWaitFor<Composite>(timeSpan));
      }
      WaitResultTuple<Composite> WaitFor(const std::chrono::duration<Rep, Period> &timeSpan) {…}


      WaitResultTuple<Composite> Wait(const CancellationToken &token)
      {
        return CreateWaitResult(InternalWait<Composite>(token));
      }
      WaitResultTuple<Composite> Wait(const CancellationToken &token) {…}


      WaitResultTuple<Composite> Wait()
      {
        return CreateWaitResult(InternalWait<Composite>());
      }
      WaitResultTuple<Composite> Wait() {…}
 
    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));
        }
      }
    };
    class CompositeStream : public CompositeStreamBase {…};
 
  }  // namespace Driver
 
  using Driver::CompositeStream;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb