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

}