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}
      {
      }
      FlowInfo(size_t size, size_t alignment) {…}


      bool operator==(const FlowInfo &other) const noexcept
      {
        return (Size == other.Size && Alignment == other.Alignment);
      }
      bool operator==(const FlowInfo &other) const noexcept {…}


      bool operator!=(const FlowInfo &other) const noexcept
      {
        return !(*this == other);
      }
      bool operator!=(const FlowInfo &other) const noexcept {…}
    };
    struct FlowInfo {…};


    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 std::vector<FlowInfo> &flowInfos, ProtectedTag) noexcept {…}
 
      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{});
      }
      static FlowSetPoolPtr Create(const std::vector<FlowInfo> &flowInfos) {…}


      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);
      }
      virtual void PushBack(const std::vector<void *> &flowBuffers) {…}


      void push_back(const std::vector<void *> &flows)
      {
        PushBack(flows);
      }
      void push_back(const std::vector<void *> &flows) {…}


      size_t PoolSize() const noexcept
      {
        return flowSets_.size();
      }
      size_t PoolSize() const noexcept {…}


      void Reserve(int flowSets) noexcept
      {
        flowSets_.reserve(flowSets);
      }
      void Reserve(int flowSets) noexcept {…}


      auto CBegin() const noexcept
      {
        return flowSets_.cbegin();
      }
      auto CBegin() const noexcept {…}


      auto Begin() noexcept
      {
        return flowSets_.begin();
      }
      auto Begin() noexcept {…}


      auto cbegin() const noexcept
      {
        return CBegin();
      }
      auto cbegin() const noexcept {…}


      auto begin() noexcept
      {
        return Begin();
      }
      auto begin() noexcept {…}


      auto CEnd() const noexcept
      {
        return flowSets_.cend();
      }
      auto CEnd() const noexcept {…}


      auto End() noexcept
      {
        return flowSets_.end();
      }
      auto End() noexcept {…}


      auto cend() const noexcept
      {
        return CEnd();
      }
      auto cend() const noexcept {…}


      auto end() noexcept
      {
        return End();
      }
      auto end() noexcept {…}


      auto CRBegin() const noexcept
      {
        return flowSets_.crbegin();
      }
      auto CRBegin() const noexcept {…}


      auto RBegin() noexcept
      {
        return flowSets_.rbegin();
      }
      auto RBegin() noexcept {…}


      auto crbegin() const noexcept
      {
        return CRBegin();
      }
      auto crbegin() const noexcept {…}


      auto rbegin() noexcept
      {
        return RBegin();
      }
      auto rbegin() noexcept {…}


      auto CREnd() const noexcept
      {
        return flowSets_.crend();
      }
      auto CREnd() const noexcept {…}


      auto REnd() const noexcept
      {
        return flowSets_.rend();
      }
      auto REnd() const noexcept {…}


      auto crend() const noexcept
      {
        return CREnd();
      }
      auto crend() const noexcept {…}


      auto rend() noexcept
      {
        return REnd();
      }
      auto rend() noexcept {…}
 
    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;
      }
    };
    class FlowSetPool {…};
 
  }  // namespace Driver
 
  using Driver::FlowInfo;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb