detail_server_gev3.hpp

#pragma once
 
#ifndef NOMINMAX
#  define NOMINMAX
#endif
 
#include "../../_cexports/c_gev_server.h"
#include "../_decl/decl_server_gev3.hpp"
#include "../_decl/decl_stream_gev3.hpp"
#include "../../driver/flow_set_pool.hpp"
#include "../../driver/gendc_descriptor.hpp"
#include <algorithm>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
  namespace GevServer
  {
    inline ServerGev3Ptr ServerGev3::Create(GevServer::DriverType driverType)
    {
      auto server = Internal::DoResCallShareOut<ServerGev3>([&](void *&handle) {
        return CVB_CALL_CAPI(CVGSCreateGevServer3(static_cast<CExports::TDriver>(driverType), handle));
      });
      return server;
    }
 
    inline std::vector<FlowInfo> ServerGev3::CreateFlowInfoForDescriptor(const GenDcDescriptor &descriptor,
                                                                         std::size_t alignment)
    {
      std::vector<FlowInfo> infos{std::max(descriptor.CalculateDataFlowCount(), std::size_t{1}), {0, alignment}};
 
      infos[0].Size = descriptor.GetDescriptorSize();
      for (const auto &component : descriptor.GetComponents())
      {
        for (const auto &part : component.GetParts())
        {
          visit([&infos](const GenDcPart &part) {
                infos[part.GetFlowId()].Size += part.GetDataSize();
              },
              part);
        }
      }
      return infos;
    }
 
    inline size_t ServerGev3::GetRegisteredFlowSetPoolSize() const noexcept
    {
      return registeredPoolSize_;
    }
 
    inline std::vector<FlowInfo> ServerGev3::GetRegisteredFlowSetInfo() const noexcept
    {
      return registeredFlowSetInfo_;
    }
 
    inline void ServerGev3::RegisterFlowSetPool(const GenDcDescriptor &descriptor, FlowSetPoolPtr pool,
                                                std::function<void()> userCallback)
    {
      if (!pool)
        throw std::invalid_argument("FlowSetPool must not be null");
 
      if (!userCallback)
        throw std::invalid_argument("User callback must not be null");
 
      pool->SetUserCallback(userCallback);
      CVB_CALL_CAPI_CHECKED(CVGSServerRegisterFlowSetPool(
          Handle(), reinterpret_cast<CExports::CVDGNDCDESCRIPTORDATA *>(descriptor.Handle()),
          reinterpret_cast<CExports::CVDFlowSet *>(pool->ToNativeStruct().data()), pool->PoolSize(),
          pool->OnReleaseCallback, &*pool));
      registeredPoolSize_    = pool->PoolSize();
      registeredFlowSetInfo_ = pool->FlowSetInfo();
      pool->SetReleaseThis(pool);
    }
 
    inline StreamGev3Ptr ServerGev3::Stream() const
    {
      if (hasStream_)
        return gsStream_.AtomicGet([&]() {
          return std::make_shared<GevServer::StreamGev3>(std::const_pointer_cast<ServerBase>(shared_from_this()));
        });
      else
        return nullptr;
    }
 
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb