detail_server.hpp

#pragma once
 
#include "../../_cexports/c_gev_server.h"
#include "../../global.hpp"
 
#include "../_decl/decl_node_map.hpp"
#include "../_decl/decl_server.hpp"
#include "../_decl/decl_stream.hpp"
#include "../logical_network_interface.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
  namespace GevServer
  {
    inline NodeMapPtr Server::NodeMap() const
    {
      return nodeMap_;
    }
    inline NodeMapPtr Server::NodeMap() const {…}
 
    inline StreamPtr Server::Stream() const
    {
      if (hasStream_)
        return gsStream_.AtomicGet(
            [&]() { return std::make_shared<GevServer::Stream>(std::const_pointer_cast<Server>(shared_from_this())); });
      else
        return nullptr;
    }
    inline StreamPtr Server::Stream() const {…}
 
    inline ServerPtr Server::CreateNonStreaming()
    {
      ServerPtr server(new Server(HandleGuard<Server>(CVB_CALL_CAPI(CreateGevServer())), false));
      server->CreateNodeMap();
      return server;
    }
    inline ServerPtr Server::CreateNonStreaming() {…}
 
    inline ServerPtr Server::CreateWithConstSize(Size2D<int> size, PfncFormat pixelFormat,
                                                 GevServer::DriverType driverType)
    {
      // Check here is necessary as we cast to uint
      if (size.Width() < 1)
        throw std::runtime_error("Width must be larger or equal to 1");
      if (size.Height() < 1)
        throw std::runtime_error("Height must be larger or equal to 1");
      if (pixelFormat == PfncFormat::InvalidPixelFormat)
        throw std::runtime_error("Invalid pixel format");
 
      using namespace CExports;
      auto pixelFormatName = PfncFormatValue::ToANSI(pixelFormat);
      GSFixedSizeInitInfo init{GSSI_FixedSize,
                               static_cast<cvbuint32_t>(pixelFormat),
                               pixelFormatName.c_str(),
                               static_cast<cvbuint32_t>(size.Width()),
                               static_cast<cvbuint32_t>(size.Height()),
                               intptr_t()};  // Auto calculation
 
      ServerPtr server(new Server(HandleGuard<Server>(CVB_CALL_CAPI(CreateGevServer2(
                                      static_cast<TDriver>(driverType), reinterpret_cast<GSInitInfo &>(init)))),
                                  true));
      server->CreateNodeMap();
      return server;
    }
    inline ServerPtr Server::CreateWithConstSize(Size2D<int> size, PfncFormat pixelFormat, {…}
 
    inline ServerPtr Server::CreateWithConstSize(Size2D<int> size, ColorModel colorModel, DataType dataType,
                                                 GevServer::DriverType driverType)
    {
      return CreateWithConstSize(size, PfncFormatValue::From(colorModel, dataType), driverType);
    }
    inline ServerPtr Server::CreateWithConstSize(Size2D<int> size, ColorModel colorModel, DataType dataType, {…}
 
    inline ServerPtr Server::CreateWithVariableSize(Size2D<int> maxSize, ColorModel colorModel, DataType dataType,
                                                    GevServer::DriverType driverType)
    {
      return CreateWithVariableSize(maxSize, PfncFormatValue::From(colorModel, dataType), driverType);
    }
    inline ServerPtr Server::CreateWithVariableSize(Size2D<int> maxSize, ColorModel colorModel, DataType dataType, {…}
 
    inline ServerPtr Server::CreateWithVariableSize(Size2D<int> maxSize, PfncFormat pixelFormat,
                                                    GevServer::DriverType driverType)
    {
      // check here is necessary as we cast to uint
      if (maxSize.Width() < 1)
        throw std::runtime_error("Width must be larger or equal to 1");
      if (maxSize.Height() < 1)
        throw std::runtime_error("Height must be larger or equal to 1");
      if (pixelFormat == PfncFormat::InvalidPixelFormat)
        throw std::runtime_error("Invalid pixel format");
 
      using namespace CExports;
      GSDynamicSizeInitInfo init{GSFixedSizeInitInfo{GSSI_DynamicSize, static_cast<CExports::cvbuint32_t>(pixelFormat),
                                                     PfncFormatValue::ToANSI(pixelFormat).c_str(),
                                                     static_cast<CExports::cvbuint32_t>(maxSize.Width()),
                                                     static_cast<CExports::cvbuint32_t>(maxSize.Height()), intptr_t()},
                                 static_cast<CExports::cvbuint32_t>(maxSize.Width()),
                                 static_cast<CExports::cvbuint32_t>(maxSize.Height())};
 
      ServerPtr server(new Server(HandleGuard<Server>(CVB_CALL_CAPI(CreateGevServer2(
                                      static_cast<TDriver>(driverType), reinterpret_cast<GSInitInfo &>(init)))),
                                  true));
      server->CreateNodeMap();
      return server;
    }
    inline ServerPtr Server::CreateWithVariableSize(Size2D<int> maxSize, PfncFormat pixelFormat, {…}
 
    inline GevServer::State Server::State()
    {
      return state_;
    }
    inline GevServer::State Server::State() {…}
 
    inline GevServer::DriverType Server::DriverType()
    {
      CExports::TDriver driverType = CExports::DT_Auto;
      NativeCall([&]() { return CVB_CALL_CAPI(GSDriverType(Handle(), driverType)); });
      return static_cast<GevServer::DriverType>(driverType);
    }
    inline GevServer::DriverType Server::DriverType() {…}
 
    inline String Server::UserVersion() const
    {
      return GetInfoAsString(Info::ServerUserVersion);
    }
    inline String Server::UserVersion() const {…}
 
    inline void Server::SetUserVersion(const String &value)
    {
      NativeCall(
          [&]() { return CExports::GSSetInfoAsStringTyped(Handle(), CExports::GSI_ServerUserVersion, value.c_str()); });
    }
    inline void Server::SetUserVersion(const String &value) {…}
 
    inline Cvb::NetworkConnection Server::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 Server::LocalEndpoint() const {…}
 
    inline Cvb::NetworkConnection Server::RemoteEndpoint() const
    {
      CExports::gsipv4 ip   = 0;
      CExports::gsport port = 0;
      CVB_CALL_CAPI(GSGetRemoteIPv4(Handle(), ip, port));
      return Cvb::NetworkConnection{ip, port};
    }
    inline Cvb::NetworkConnection Server::RemoteEndpoint() const {…}
 
    inline void Server::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 Server::Start(const Cvb::NetworkConnection::IPAddress &address) {…}
 
    inline void Server::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 Server::Start(const Cvb::NetworkConnection::IPAddressUInt &address) {…}
 
    inline void Server::Stop()
    {
      std::lock_guard<std::mutex> lock(mtx);
      NativeCall([&]() { return CVB_CALL_CAPI(GSStop(Handle())); });
      state_ = GevServer::State::Configuration;
    }
    inline void Server::Stop() {…}
 
    inline String Server::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 Server::SetState(const GevServer::State &state) noexcept
    {
      state_ = state;
    }
 
    inline void Server::CreateNodeMap()
    {
      std::lock_guard<std::mutex> lock(mtx);
      nodeMap_ = std::make_shared<GevServer::NodeMap>(std::const_pointer_cast<Server>(shared_from_this()));
    }
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb