decl_server_base.hpp

#pragma once
 
#include <atomic>
#include <iostream>
#include <mutex>
#include <thread>
 
#include "../../exception.hpp"
#include "../../global.hpp"
#include "../../size_2d.hpp"
#include "../../utilities/system_info.hpp"
#include "../logical_network_interface.hpp"
 
#include "../../driver/driver.hpp"
#include "../gevserver.hpp"
#include "../../pfnc_format.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace GevServer
  {
    enum class State
    {
      Configuration,      // the state after creation of the server, before starting it
      Disconnected,       // the state after a connection was torn down
      Connected,          // the state after a configured server was started
      AcquisitionEnabled  // the state after a client started acquisition on the server
    };

    class ServerBase : public std::enable_shared_from_this<ServerBase>
    {
    protected:
      struct ProtectedTag
      {
      };
 
    public:
      virtual void *Handle() const noexcept = 0;

      virtual GevServer::State State();

      virtual GevServer::DriverType DriverType();

      virtual String UserVersion() const;

      virtual void SetUserVersion(const String &value);

      virtual Cvb::NetworkConnection LocalEndpoint() const;

      virtual Cvb::NetworkConnection RemoteEndpoint() const;

      virtual NodeMapPtr NodeMap() const;

      virtual void Start(const Cvb::NetworkConnection::IPAddress &address);

      virtual void Start(const Cvb::NetworkConnection::IPAddressUInt &address);

      virtual void Stop();
 
    protected:
      explicit ServerBase(bool hasStream)
          : state_{GevServer::State::Configuration}
          , hasStream_{hasStream}
      {
      }
 
      void RegisterEvents();
 
      std::string GetLastGSErrorMessage() const noexcept
      {
        std::size_t messageSize = 0;
        auto res                = CVB_CALL_CAPI(GSGetLastErrorString(nullptr, messageSize));
        if (res || messageSize < 2)
          return {};
        std::vector<char> message(messageSize);
        if (CVB_CALL_CAPI(GSGetLastErrorString(message.data(), messageSize)))
          return {};
        return std::string(message.data());
      }
 
      void NativeCall(std::function<CExports::cvbres_t()> fn) const
      {
        auto result = fn();
        if (result < 0)
        {
          auto message = GetLastGSErrorMessage();
          if (message.empty())
            message = "Error";
 
          std::stringstream stream;
          stream << "ServerBase " << message;
          std::rethrow_exception(CvbException::FromCvbResult(result, stream.str()));
        }
      }
 
      template <class T>
      T NativeCall(std::function<CExports::cvbres_t(T &value)> fn) const
      {
        T value;
        auto result = fn(value);
        if (result < 0)
        {
          auto message = Utilities::SystemInfo::GetLastErrorMessage();
          if (message.empty())
            message = "Error";
 
          std::stringstream stream;
          stream << "ServerBase " << message;
          std::rethrow_exception(CvbException::FromCvbResult(result, stream.str()));
        }
        return value;
      }
 
      String GetInfoAsString(Info command) const;
 
      static void __stdcall OnConnected(void *pPrivate)
      {
        auto server = reinterpret_cast<ServerBase *>(pPrivate);
        server->SetState(GevServer::State::Connected);
      }
 
      static void __stdcall OnDisconnected(void *pPrivate)
      {
        auto server = reinterpret_cast<ServerBase *>(pPrivate);
        server->SetState(GevServer::State::Disconnected);
      }
 
      static void __stdcall OnAcquisitionStart(void *pPrivate)
      {
        auto server = reinterpret_cast<ServerBase *>(pPrivate);
        server->SetState(GevServer::State::AcquisitionEnabled);
      }
 
      static void __stdcall OnAcquisitionStop(void *pPrivate)
      {
        auto server = reinterpret_cast<ServerBase *>(pPrivate);
        server->SetState(GevServer::State::Connected);
      }
 
      void SetState(const GevServer::State &state) noexcept;
 
      const bool hasStream_;
 
    private:
      std::atomic<GevServer::State> state_;
      mutable Internal::AsyncRef<GevServer::NodeMap> nodeMap_;
      std::mutex mtx;
    };
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb