flow_set_pool.hpp

#pragma once
 
#include <functional>
#include <algorithm>
 
#include "../global.hpp"
#include "driver.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace Driver
  {
 
    struct FlowInfo
    {
      size_t Size = 0;
 
      size_t Alignment = 0;
 
      FlowInfo() = default;
 
 
      FlowInfo(size_t size, size_t alignment)
        : Size{ size }
        , Alignment{ alignment }
      {
      }
 
 
      bool operator==(const FlowInfo& other) const noexcept
      {
        return (Size == other.Size && Alignment == other.Alignment);
      }
 
 
 
      bool operator!=(const FlowInfo& other) const noexcept
      {
        return !(*this == other);
      }
    };
 
 
 
    class FlowSetPool
    {
      friend class CompositeStreamBase;
 
 
      std::vector<FlowInfo> flowInfos_;
      std::vector<std::vector<Cvb::Flow>> flowSets_;
 
      std::function<void()> releaseThis_;
      std::function<void()> userCallback_;
 
    protected:
      struct ProtectedTag {};
 
    public:
      using value_type = std::vector<void*>;
 
      FlowSetPool(const std::vector<FlowInfo>& flowInfos, ProtectedTag) noexcept
        : flowInfos_{ flowInfos }
      {
      }
 
      FlowSetPool(const FlowSetPool& other) = delete;
      FlowSetPool& operator=(const FlowSetPool& other) = delete;
      FlowSetPool(FlowSetPool&& other) = delete;
      FlowSetPool& operator=(FlowSetPool&& other) = delete;
      virtual ~FlowSetPool() = default;
 
 
      static FlowSetPoolPtr Create(const std::vector<FlowInfo>& flowInfos)
      {
        return std::make_shared<FlowSetPool>(flowInfos, ProtectedTag{});
      }
 
 
      virtual void PushBack(const std::vector<void*>& flowBuffers)
      {
        if (flowBuffers.size() != flowInfos_.size())
          throw std::length_error("index out of range");
 
        // Create Flows from size and buffer
        auto flows = std::vector<Cvb::Flow>(flowBuffers.size());
        std::transform(flowBuffers.begin(), flowBuffers.end(), flowInfos_.begin(), flows.begin(), [](void* pBuffer, FlowInfo info) mutable
          {
            return Cvb::Flow { info.Size, pBuffer };
          });
        flowSets_.push_back(flows);
      }
 
 
      void push_back(const std::vector<void*>& flows)
      {
        PushBack(flows);
      }
 
 
      size_t PoolSize() const noexcept
      {
        return flowSets_.size();
      }
 
 
      void Reserve(int flowSets) noexcept
      {
        flowSets_.reserve(flowSets);
      }
 
 
      auto CBegin() const noexcept
      {
        return flowSets_.cbegin();
      }
 
 
      auto Begin() noexcept
      {
        return flowSets_.begin();
      }
 
 
      auto cbegin() const noexcept
      {
        return CBegin();
      }
 
 
      auto begin() noexcept
      {
        return Begin();
      }
 
 
      auto CEnd() const noexcept
      {
        return flowSets_.cend();
      }
 
 
      auto End() noexcept
      {
        return flowSets_.end();
      }
 
 
      auto cend() const noexcept
      {
        return CEnd();
      }
 
 
      auto end() noexcept
      {
        return End();
      }
 
 
      auto CRBegin() const noexcept
      {
        return flowSets_.crbegin();
      }
 
 
      auto RBegin() noexcept
      {
        return flowSets_.rbegin();
      }
 
 
      auto crbegin() const noexcept
      {
        return CRBegin();
      }
 
 
      auto rbegin() noexcept
      {
        return RBegin();
      }
 
 
      auto CREnd() const noexcept
      {
        return flowSets_.crend();
      }
 
 
      auto REnd() const noexcept
      {
        return flowSets_.rend();
      }
 
 
      auto crend() const noexcept
      {
        return CREnd();
      }
 
 
      auto rend() noexcept
      {
        return REnd();
      }
 
    private:
      void SetReleaseThis(std::shared_ptr<FlowSetPool>& flowSetPoolPtr) noexcept
      {
        releaseThis_ = [flowSetPool = flowSetPoolPtr]() mutable
        {
          flowSetPool.reset();
        };
      }
 
      void SetUserCallback(std::function<void()> userCallback)
      {
        userCallback_ = userCallback;
      }
 
      std::vector<CExports::CVDFlowSet> ToNativeStruct()
      {
        std::vector<CExports::CVDFlowSet> flowSetPool(flowSets_.size());
        std::transform(flowSets_.begin(), flowSets_.end(), flowSetPool.begin(), [this](std::vector<Cvb::Flow>& flows)
          {
            return CExports::CVDFlowSet{ 0, flowInfos_.size(), reinterpret_cast<CExports::CVDFlow*>(flows.data()) };
          });
        return flowSetPool;
      }
 
      static CExports::cvbres_t __stdcall OnReleaseCallback(void* pPrivate)
      {
        auto flowSetPool = reinterpret_cast<FlowSetPool*>(pPrivate);
        try
        {
          flowSetPool->userCallback_();
        }
        catch (...)
        {
          flowSetPool->releaseThis_();
          return CExports::CVC_E_ERROR;
        }
 
        flowSetPool->releaseThis_();
        return CExports::CVC_E_OK;
      }
    };
 
  }
 
  using Driver::FlowInfo;
 
  CVB_END_INLINE_NS
 
}