1 files changed, 0 insertions, 340 deletions
diff --git a/Build/source/utils/asymptote/LspCpp/LibLsp/JsonRpc/RemoteEndPoint.h b/Build/source/utils/asymptote/LspCpp/LibLsp/JsonRpc/RemoteEndPoint.h
deleted file mode 100644
index 3ae6b567a5c..00000000000
--- a/Build/source/utils/asymptote/LspCpp/LibLsp/JsonRpc/RemoteEndPoint.h
+++ /dev/null
@@ -1,340 +0,0 @@
-#pragma once
-#include "LibLsp/lsp/lsp_diagnostic.h"
-#include "LibLsp/JsonRpc/Cancellation.h"
-#include "LibLsp/JsonRpc/lsResponseMessage.h"
-#include "LibLsp/JsonRpc/RequestInMessage.h"
-#include "LibLsp/JsonRpc/NotificationInMessage.h"
-#include "traits.h"
-#include <future>
-#include <string>
-#include "threaded_queue.h"
-#include <unordered_map>
-#include "MessageIssue.h"
-#include "LibLsp/JsonRpc/MessageJsonHandler.h"
-#include "Endpoint.h"
-
-
-class MessageJsonHandler;
-class  Endpoint;
-struct LspMessage;
-class RemoteEndPoint;
-namespace lsp {
-	class ostream;
-	class istream;
-
-	////////////////////////////////////////////////////////////////////////////////
-	// ResponseOrError<T>
-	////////////////////////////////////////////////////////////////////////////////
-
-	// ResponseOrError holds either the response to a  request or an error
-	// message.
-	template <typename T>
-	struct ResponseOrError {
-		 using Request = T;
-		 ResponseOrError();
-		 ResponseOrError(const T& response);
-		 ResponseOrError(T&& response);
-		 ResponseOrError(const Rsp_Error& error);
-		 ResponseOrError(Rsp_Error&& error);
-		 ResponseOrError(const ResponseOrError& other);
-		 ResponseOrError(ResponseOrError&& other) noexcept;
-
-		 ResponseOrError& operator=(const ResponseOrError& other);
-		 ResponseOrError& operator=(ResponseOrError&& other) noexcept;
-		bool  IsError() const { return  is_error; }
-		std::string ToJson()
-		{
-			if (is_error) return  error.ToJson();
-			return  response.ToJson();
-		}
-		T response;
-		Rsp_Error error;  // empty represents success.
-		bool is_error;
-	};
-
-	template <typename T>
-	ResponseOrError<T>::ResponseOrError(): is_error(false)
-	{
-	}
-
-	template <typename T>
-	ResponseOrError<T>::ResponseOrError(const T& resp) : response(resp), is_error(false) {}
-	template <typename T>
-	ResponseOrError<T>::ResponseOrError(T&& resp) : response(std::move(resp)), is_error(false) {}
-	template <typename T>
-	ResponseOrError<T>::ResponseOrError(const Rsp_Error& err) : error(err), is_error(true) {}
-	template <typename T>
-	ResponseOrError<T>::ResponseOrError(Rsp_Error&& err) : error(std::move(err)), is_error(true) {}
-	template <typename T>
-	ResponseOrError<T>::ResponseOrError(const ResponseOrError& other)
-		: response(other.response), error(other.error), is_error(other.is_error) {}
-	template <typename T>
-	ResponseOrError<T>::ResponseOrError(ResponseOrError&& other) noexcept
-		: response(std::move(other.response)), error(std::move(other.error)), is_error(other.is_error) {}
-	template <typename T>
-	ResponseOrError<T>& ResponseOrError<T>::operator=(
-		const ResponseOrError& other) {
-		response = other.response;
-		error = other.error;
-		is_error = other.is_error;
-		return *this;
-	}
-	template <typename T>
-	ResponseOrError<T>& ResponseOrError<T>::operator=(ResponseOrError&& other) noexcept
-	{
-		response = std::move(other.response);
-		error = std::move(other.error);
-		is_error = other.is_error;
-		return *this;
-	}
-
-}
-
-
-class RemoteEndPoint :MessageIssueHandler
-{
-
-	template <typename F, int N>
-	using ParamType = lsp::traits::ParameterType<F, N>;
-
-	template <typename T>
-	using IsRequest = lsp::traits::EnableIfIsType<RequestInMessage, T>;
-
-	template <typename T>
-	using IsResponse = lsp::traits::EnableIfIsType<ResponseInMessage, T>;
-
-	template <typename T>
-	using IsNotify = lsp::traits::EnableIfIsType<NotificationInMessage, T>;
-
-
-	template <typename F, typename ReturnType>
-	using IsRequestHandler = lsp::traits::EnableIf<lsp::traits::CompatibleWith<
-		F,
-		std::function<ReturnType(const RequestInMessage&)>>::
-		value>;
-
-	template <typename F, typename ReturnType>
-	using IsRequestHandlerWithMonitor = lsp::traits::EnableIf<lsp::traits::CompatibleWith<
-		F,
-		std::function<ReturnType(const RequestInMessage&,const CancelMonitor&)>>::
-		value>;
-
-public:
-
-	
-	RemoteEndPoint(const std::shared_ptr <MessageJsonHandler>& json_handler,
-		const std::shared_ptr < Endpoint >& localEndPoint,
-		lsp::Log& _log, uint8_t max_workers = 2);
-	
-	~RemoteEndPoint() override;
-	template <typename F, typename RequestType = ParamType<F, 0>, typename ResponseType = typename RequestType::Response>
-	IsRequestHandler< F, lsp::ResponseOrError<ResponseType> >  registerHandler(F&& handler)
-	{
-		ProcessRequestJsonHandler(handler);
-		local_endpoint->registerRequestHandler(RequestType::kMethodInfo, [=](std::unique_ptr<LspMessage> msg) {
-			auto  req = reinterpret_cast<const RequestType*>(msg.get());
-			lsp::ResponseOrError<ResponseType> res(handler(*req));
-			if (res.is_error) {
-				res.error.id = req->id;
-				send(res.error);
-			}
-			else
-			{
-				res.response.id = req->id;
-				send(res.response);
-			}
-			return  true;
-		});
-	}
-	template <typename F, typename RequestType = ParamType<F, 0>, typename ResponseType = typename RequestType::Response>
-	IsRequestHandlerWithMonitor< F, lsp::ResponseOrError<ResponseType> >  registerHandler(F&& handler)  {
-		ProcessRequestJsonHandler(handler);
-		local_endpoint->registerRequestHandler(RequestType::kMethodInfo, [=](std::unique_ptr<LspMessage> msg) {
-			auto  req = static_cast<const RequestType*>(msg.get());
-			lsp::ResponseOrError<ResponseType> res(handler(*req , getCancelMonitor(req->id)));
-			if (res.is_error) {
-				res.error.id = req->id;
-				send(res.error);
-			}
-			else
-			{
-				res.response.id = req->id;
-				send(res.response);
-			}
-			return  true;
-		});
-	}
-	using RequestErrorCallback = std::function<void(const Rsp_Error&)>;
-	
-	template <typename T, typename F, typename ResponseType = ParamType<F, 0> >
-	void send(T& request, F&& handler, RequestErrorCallback onError)
-	{
-		ProcessRequestJsonHandler(handler);
-		auto cb = [=](std::unique_ptr<LspMessage> msg) {
-			if (!msg)
-				return true;
-			const auto result = msg.get();
-		
-			if (static_cast<ResponseInMessage*>(result)->IsErrorType()) {
-				const auto rsp_error = static_cast<const Rsp_Error*>(result);
-				onError(*rsp_error);
-			}
-			else {
-				handler(*static_cast<ResponseType*>(result));
-			}
-
-			return  true;
-		};
-		internalSendRequest(request, cb);
-	}
-	
-
-	template <typename F, typename NotifyType = ParamType<F, 0> >
-	IsNotify<NotifyType>  registerHandler(F&& handler) {
-		{
-			std::lock_guard<std::mutex> lock(m_sendMutex);
-			if (!jsonHandler->GetNotificationJsonHandler(NotifyType::kMethodInfo))
-			{
-				jsonHandler->SetNotificationJsonHandler(NotifyType::kMethodInfo,
-					[](Reader& visitor)
-					{
-						return NotifyType::ReflectReader(visitor);
-					});
-			}
-		}
-		local_endpoint->registerNotifyHandler(NotifyType::kMethodInfo, [=](std::unique_ptr<LspMessage> msg) {
-			handler(*static_cast<NotifyType*>(msg.get()));
-			return  true;
-			});
-	}
-
-	template <typename T, typename = IsRequest<T>>
-	std::future< lsp::ResponseOrError<typename T::Response> > send(T& request) {
-
-		ProcessResponseJsonHandler(request);
-		using Response = typename T::Response;
-		auto promise = std::make_shared< std::promise<lsp::ResponseOrError<Response>>>();
-		auto cb = [=](std::unique_ptr<LspMessage> msg) {
-			if (!msg)
-				return true;
-			auto result = msg.get();
-
-			if (reinterpret_cast<ResponseInMessage*>(result)->IsErrorType())
-			{
-				Rsp_Error* rsp_error = static_cast<Rsp_Error*>(result);
-				Rsp_Error temp;
-				std::swap(temp, *rsp_error);
-				promise->set_value(std::move(lsp::ResponseOrError<Response>(std::move(temp))));
-			}
-			else
-			{
-				Response temp;
-				std::swap(temp, *static_cast<Response*>(result));
-				promise->set_value(std::move(lsp::ResponseOrError<Response>(std::move(temp))));
-			}
-			return  true;
-		};
-		internalSendRequest(request, cb);
-		return promise->get_future();
-	}
-
-	template <typename T, typename = IsRequest<T>>
-	std::unique_ptr<lsp::ResponseOrError<typename T::Response>> waitResponse(T& request, const unsigned time_out = 0)
-	{
-		auto future_rsp = send(request);
-		if (time_out == 0)
-		{
-			future_rsp.wait();
-		}
-		else
-		{
-			auto state = future_rsp.wait_for(std::chrono::milliseconds(time_out));
-			if (std::future_status::timeout == state)
-			{
-				return {};
-			}
-		}
-
-		using Response = typename T::Response;
-		return std::make_unique<lsp::ResponseOrError<Response>>(std::move(future_rsp.get()));
-	}
-
-	void send(NotificationInMessage& msg)
-	{
-		sendMsg(msg);
-	}
-
-	void send(ResponseInMessage& msg)
-	{
-		sendMsg(msg);
-	}
-	
-	void sendNotification(NotificationInMessage& msg)
-	{
-		send(msg);
-	}
-	void sendResponse(ResponseInMessage& msg)
-	{
-		send(msg);
-	}
-	void startProcessingMessages(std::shared_ptr<lsp::istream> r,
-		std::shared_ptr<lsp::ostream> w);
-
-	bool IsWorking() const
-	{
-		if (message_producer_thread_)
-			return true;
-		return  false;
-	}
-	void Stop();
-
-	std::unique_ptr<LspMessage> internalWaitResponse(RequestInMessage&, unsigned time_out = 0);
-
-	void internalSendRequest(RequestInMessage&, GenericResponseHandler);
-
-	void handle(std::vector<MessageIssue>&&) override;
-	void handle(MessageIssue&&) override;
-private:
-	CancelMonitor getCancelMonitor(const lsRequestId&);
-	void sendMsg(LspMessage& msg);
-	void mainLoop(std::unique_ptr<LspMessage>);
-	bool dispatch(const std::string&);
-	template <typename F, typename RequestType = ParamType<F, 0>>
-	IsRequest<RequestType>  ProcessRequestJsonHandler(const F& handler) {
-		std::lock_guard<std::mutex> lock(m_sendMutex);
-		if (!jsonHandler->GetRequestJsonHandler(RequestType::kMethodInfo))
-		{
-			jsonHandler->SetRequestJsonHandler(RequestType::kMethodInfo,
-				[](Reader& visitor)
-				{
-					return RequestType::ReflectReader(visitor);
-				});
-		}	
-	}
-	template <typename T, typename = IsRequest<T>>
-	void ProcessResponseJsonHandler(T& request)
-	{
-		using Response = typename T::Response;
-		std::lock_guard<std::mutex> lock(m_sendMutex);
-		if (!jsonHandler->GetResponseJsonHandler(T::kMethodInfo))
-		{
-			jsonHandler->SetResponseJsonHandler(T::kMethodInfo, [](Reader& visitor)
-				{
-					if (visitor.HasMember("error"))
-						return 	Rsp_Error::ReflectReader(visitor);
-					return Response::ReflectReader(visitor);
-				});
-		}
-	}
-
-	struct Data;
-
-	Data* d_ptr;
-
-	std::shared_ptr < MessageJsonHandler> jsonHandler;
-	std::mutex m_sendMutex;
-
-	std::shared_ptr < Endpoint > local_endpoint;
-public:
-	std::shared_ptr < std::thread > message_producer_thread_;
-};