detail_server_base.hpp

#pragma once
 
#include "../../_cexports/c_gev_server.h"
#include "../_decl/decl_node_map.hpp"
#include "../_decl/decl_server_base.hpp"
#include "../_decl/decl_stream_base.hpp"
#include "../../driver/flow_set_pool.hpp"
#include "../../driver/gendc_descriptor.hpp"
#include "../logical_network_interface.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
  namespace GevServer
  {
    inline NodeMapPtr ServerBase::NodeMap() const
    {
      std::lock_guard<std::mutex> lock(nodemapMtx_);
      if (!nodeMap_)
        const_cast<ServerBase*>(this)->nodeMap_ = std::make_shared<GevServer::NodeMap>(std::const_pointer_cast<ServerBase>(shared_from_this()));
 
      return nodeMap_;
    }
 
    inline GevServer::State ServerBase::State()
    {
      return state_;
    }
 
    inline GevServer::DriverType ServerBase::DriverType()
    {
      CExports::TDriver driverType = CExports::DT_Auto;
      NativeCall([&]() { return CVB_CALL_CAPI(GSDriverType(Handle(), driverType)); });
      return static_cast<GevServer::DriverType>(driverType);
    }
 
    inline String ServerBase::UserVersion() const
    {
      return GetInfoAsString(Info::ServerUserVersion);
    }
 
    inline void ServerBase::SetUserVersion(const String &value)
    {
      NativeCall(
          [&]() { return CExports::GSSetInfoAsStringTyped(Handle(), CExports::GSI_ServerUserVersion, value.c_str()); });
    }
 
    inline Cvb::NetworkConnection ServerBase::LocalEndpoint() const
    {
      CExports::gsipv4 ip   = 0;
      CExports::gsport port = 0;
      NativeCall([&]() { return CVB_CALL_CAPI(GSGetLocalIPv4(Handle(), ip, port)); });
      return Cvb::NetworkConnection{ip, port};
    }
 
    inline Cvb::NetworkConnection ServerBase::RemoteEndpoint() const
    {
      CExports::gsipv4 ip   = 0;
      CExports::gsport port = 0;
      CVB_CALL_CAPI(GSGetRemoteIPv4(Handle(), ip, port));
      return Cvb::NetworkConnection{ip, port};
    }
 
    inline void ServerBase::Start(const Cvb::NetworkConnection::IPAddress &address)
    {
      std::lock_guard<std::mutex> lock(mtx);
      NativeCall(
          [&]() { return CVB_CALL_CAPI(GSStartIPv4(Handle(), Cvb::NetworkConnection::ToIPAddressUInt(address))); });
      state_ = GevServer::State::Disconnected;
    }
 
    inline void ServerBase::Start(const Cvb::NetworkConnection::IPAddressUInt &address)
    {
      std::lock_guard<std::mutex> lock(mtx);
      NativeCall([&]() { return CVB_CALL_CAPI(GSStartIPv4(Handle(), address)); });
      state_ = GevServer::State::Disconnected;
    }
 
    inline void ServerBase::Stop()
    {
      std::lock_guard<std::mutex> lock(mtx);
      NativeCall([&]() { return CVB_CALL_CAPI(GSStop(Handle())); });
      state_ = GevServer::State::Configuration;
    }
 
    inline String ServerBase::GetInfoAsString(Info command) const
    {
      auto bufferSize = NativeCall<size_t>([&](size_t &size) {
        return CExports::GSGetInfoAsStringTyped(Handle(), static_cast<CExports::TGSInfo>(command),
                                                reinterpret_cast<Char *>(0), size);
      });
 
      bufferSize += sizeof(Char);
      std::vector<Char> buffer(bufferSize);
 
      NativeCall([&]() {
        return CExports::GSGetInfoAsStringTyped(Handle(), static_cast<CExports::TGSInfo>(command), buffer.data(),
                                                bufferSize);
      });
 
      return buffer.data();
    }
 
    inline void ServerBase::SetState(const GevServer::State &state) noexcept
    {
      state_ = state;
    }
 
    inline void ServerBase::RegisterEvents()
    {
      std::size_t dummy{0};
      NativeCall([&]() {
        return CVB_CALL_CAPI(
            GSRegisterEvent(Handle(), CExports::TServerEvent::SE_Connected, &ServerBase::OnConnected, this, dummy));
      });
      NativeCall([&]() {
        return CVB_CALL_CAPI(
            GSRegisterEvent(Handle(), CExports::TServerEvent::SE_Disconnected, &OnDisconnected, this, dummy));
      });
      NativeCall([&]() {
        return CVB_CALL_CAPI(
            GSRegisterEvent(Handle(), CExports::TServerEvent::SE_AcquisitionStart, &OnAcquisitionStart, this, dummy));
      });
      NativeCall([&]() {
        return CVB_CALL_CAPI(
            GSRegisterEvent(Handle(), CExports::TServerEvent::SE_AcquisitionStop, &OnAcquisitionStop, this, dummy));
      });
    }
 
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb