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)
    {
      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);
    }
 
    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);
    }
 
 
    void SendSync(const Image& image)
    {
      CVB_CALL_CAPI_CHECKED(CVWSStreamingSyncSendImage(Handle(), image.Handle()));
    }
 
 
    void SendAsync(const Image& image)
    {
      CVB_CALL_CAPI_CHECKED(CVWSStreamingAsyncSendImage(Handle(), image.Handle()));
    }
 
    void* Handle() const noexcept
    {
      return handle_.Handle();
    }
 
 
    String IPAddress() const noexcept
    {
      return ipAddress_;
    }
 
 
    int Port() const noexcept
    {
      return port_;
    }
 
  private:
 
    HandleGuard<Server> handle_;
    String ipAddress_;
    int port_;
    ConverterPtr converter_;
};
 
}
 
CVB_END_INLINE_NS
 
}