server.hpp

#pragma once
 
#include "../_cexports/c_webstreaming.h"
#include "webstreaming.hpp"
#include "converter.hpp"
#include "../string.hpp"
#include "../global.hpp"
#include "../image.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<WebStreaming::Server>::HandleGuard(void *handle) noexcept
      : HandleGuard<WebStreaming::Server>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace WebStreaming
  {

    class Server
    {
    public:
      using GuardType = HandleGuard<Server>;
 
    private:
      struct PrivateTag
      {
      };
 
    public:

      static ServerPtr Create(const String &ipAddress, int port, const ConverterPtr &converter)
      {
        return Internal::DoResCallShareOut<Server>(
            [&](void *&handle) {
              return CVB_CALL_CAPI(CVWSCreateServerTyped(ipAddress.c_str(), static_cast<CExports::cvbval_t>(port),
                                                         converter->Handle(), handle));
            },
            ipAddress, port, converter);
      }
      static ServerPtr Create(const String &ipAddress, int port, const ConverterPtr &converter) {…}


      static ServerPtr Create(const String &ipAddress, int port)
      {
        CExports::CVWSCONVERTER converter = nullptr;
        CVB_CALL_CAPI_CHECKED(CVWSCreateConverter(CExports::CVWSCT_Raw, converter));
        HandleGuard<Converter> converterGuard(converter);
        return Internal::DoResCallShareOut<Server>(
            [&](void *&handle) {
              return CVB_CALL_CAPI(CVWSCreateServerTyped(ipAddress.c_str(), static_cast<CExports::cvbval_t>(port),
                                                         converterGuard.Handle(), handle));
            },
            ipAddress, port);
      }
      static ServerPtr Create(const String &ipAddress, int port) {…}
 
      template <class T>
      static ServerPtr FromHandle(HandleGuard<Server> &&guard, const String &ipAddress, int port,
                                  const ConverterPtr &converter = {})
      {
        static_assert(std::is_same<Server, T>::value, "CVB: T must be a Server");
        if (!guard.Handle())
          throw std::runtime_error("server handle invalid");
        return std::make_shared<T>(std::move(guard), ipAddress, port, converter, PrivateTag{});
      }
 
      Server(HandleGuard<Server> &&guard, const String &ipAddress, int port, const ConverterPtr &converter,
             PrivateTag) noexcept
          : handle_(std::move(guard))
          , ipAddress_(ipAddress)
          , port_(port)
          , converter_(converter)
      {
      }


      int ActiveConnections() const
      {
        CExports::cvbint64_t value = -1;
        CVB_CALL_CAPI_CHECKED(CVWSServerGetPropertyAsInteger(Handle(), CExports::CVWSSP_ActiveConnections, value));
        return static_cast<int>(value);
      }
      int ActiveConnections() const {…}


      void SendSync(const Image &image)
      {
        CVB_CALL_CAPI_CHECKED(CVWSStreamingSyncSendImage(Handle(), image.Handle()));
      }
      void SendSync(const Image &image) {…}


      void SendAsync(const Image &image)
      {
        CVB_CALL_CAPI_CHECKED(CVWSStreamingAsyncSendImage(Handle(), image.Handle()));
      }
      void SendAsync(const Image &image) {…}

      void *Handle() const noexcept
      {
        return handle_.Handle();
      }
      void *Handle() const noexcept {…}


      String IPAddress() const noexcept
      {
        return ipAddress_;
      }
      String IPAddress() const noexcept {…}


      int Port() const noexcept
      {
        return port_;
      }
      int Port() const noexcept {…}
 
    private:
      HandleGuard<Server> handle_;
      String ipAddress_;
      int port_;
      ConverterPtr converter_;
    };
    class Server {…};
 
  }  // namespace WebStreaming
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb