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 }
      {
      }
    };



    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 }
      {
      }

      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

}