mewin/cppdap
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #58 from ben-clayton/response-callbacks

Browse Source 
Add Session::registerHandler() overloads that support response callbacks
This commit is contained in:
Ben Clayton
2021-02-03 19:08:27 +00:00
committed by GitHub
parent e10691ab3f
commit 2a3ba20937
6 changed files with 776 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
include/dap/session.h
View File

@@ -17,6 +17,7 @@
#include "future.h"
#include "io.h"
#include "traits.h"
#include "typeinfo.h"
#include "typeof.h"
@@ -29,33 +30,6 @@ struct Request;
struct Response;
struct Event;
// internal functionality
namespace detail {
template <typename T>
struct traits {
static constexpr bool isRequest = std::is_base_of<dap::Request, T>::value;
static constexpr bool isResponse = std::is_base_of<dap::Response, T>::value;
static constexpr bool isEvent = std::is_base_of<dap::Event, T>::value;
};
// ArgTy<F>::type resolves to the first argument type of the function F.
// F can be a function, static member function, or lambda.
template <typename F>
struct ArgTy {
using type = typename ArgTy<decltype(&F::operator())>::type;
};
template <typename R, typename Arg>
struct ArgTy<R (*)(Arg)> {
using type = typename std::decay<Arg>::type;
};
template <typename R, typename C, typename Arg>
struct ArgTy<R (C::*)(Arg) const> {
using type = typename std::decay<Arg>::type;
};
} // namespace detail
////////////////////////////////////////////////////////////////////////////////
// Error
////////////////////////////////////////////////////////////////////////////////
@@ -137,14 +111,24 @@ ResponseOrError<T>& ResponseOrError<T>::operator=(ResponseOrError&& other) {
// (3) Bind the session to the remote endpoint with bind().
// (4) Send requests or events with send().
class Session {
template <typename T>
using IsRequest = typename std::enable_if<detail::traits<T>::isRequest>::type;
template <typename F, int N>
using ParamType = traits::ParameterType<F, N>;
template <typename T>
using IsEvent = typename std::enable_if<detail::traits<T>::isEvent>::type;
using IsRequest = traits::EnableIfIsType<dap::Request, T>;
template <typename T>
using IsEvent = traits::EnableIfIsType<dap::Event, T>;
template <typename F>
using ArgTy = typename detail::ArgTy<F>::type;
using IsRequestHandlerWithoutCallback = traits::EnableIf<
traits::CompatibleWith<F, std::function<void(dap::Request)>>::value>;
template <typename F, typename CallbackType>
using IsRequestHandlerWithCallback = traits::EnableIf<traits::CompatibleWith<
F,
std::function<void(dap::Request, std::function<void(CallbackType)>)>>::
value>;
public:
virtual ~Session();
@@ -167,20 +151,47 @@ class Session {
// ResponseOrError<ResponseType>(const RequestType&)
// ResponseType(const RequestType&)
// Error(const RequestType&)
template <typename F, typename RequestType = ArgTy<F>>
inline IsRequest<RequestType> registerHandler(F&& handler);
template <typename F, typename RequestType = ParamType<F, 0>>
inline IsRequestHandlerWithoutCallback<F> registerHandler(F&& handler);
// registerHandler() registers a request handler for a specific request type.
// The handler has a response callback function for the second argument of the
// handler function. This callback may be called after the handler has
// returned.
// The function F must have the following signature:
// void(const RequestType& request,
// std::function<void(ResponseType)> response)
template <typename F,
typename RequestType = ParamType<F, 0>,
typename ResponseType = typename RequestType::Response>
inline IsRequestHandlerWithCallback<F, ResponseType> registerHandler(
F&& handler);
// registerHandler() registers a request handler for a specific request type.
// The handler has a response callback function for the second argument of the
// handler function. This callback may be called after the handler has
// returned.
// The function F must have the following signature:
// void(const RequestType& request,
// std::function<void(ResponseOrError<ResponseType>)> response)
template <typename F,
typename RequestType = ParamType<F, 0>,
typename ResponseType = typename RequestType::Response>
inline IsRequestHandlerWithCallback<F, ResponseOrError<ResponseType>>
registerHandler(F&& handler);
// registerHandler() registers a event handler for a specific event type.
// The function F must have the following signature:
// void(const EventType&)
template <typename F, typename EventType = ArgTy<F>>
template <typename F, typename EventType = ParamType<F, 0>>
inline IsEvent<EventType> registerHandler(F&& handler);
// registerSentHandler() registers the function F to be called when a response
// of the specific type has been sent.
// The function F must have the following signature:
// void(const ResponseOrError<ResponseType>&)
template <typename F, typename ResponseType = typename ArgTy<F>::Request>
template <typename F,
typename ResponseType = typename ParamType<F, 0>::Request>
inline void registerSentHandler(F&& handler);
// send() sends the request to the connected endpoint and returns a
@@ -251,21 +262,57 @@ class Session {
virtual bool send(const TypeInfo*, const void* event) = 0;
};
template <typename F, typename T>
Session::IsRequest<T> Session::registerHandler(F&& handler) {
using ResponseType = typename T::Response;
auto cb = [handler](const void* args, const RequestSuccessCallback& onSuccess,
const RequestErrorCallback& onError) {
template <typename F, typename RequestType>
Session::IsRequestHandlerWithoutCallback<F> Session::registerHandler(
F&& handler) {
using ResponseType = typename RequestType::Response;
const TypeInfo* typeinfo = TypeOf<RequestType>::type();
registerHandler(typeinfo, [handler](const void* args,
const RequestSuccessCallback& onSuccess,
const RequestErrorCallback& onError) {
ResponseOrError<ResponseType> res =
handler(*reinterpret_cast<const T*>(args));
handler(*reinterpret_cast<const RequestType*>(args));
if (res.error) {
onError(TypeOf<ResponseType>::type(), res.error);
} else {
onSuccess(TypeOf<ResponseType>::type(), &res.response);
}
};
const TypeInfo* typeinfo = TypeOf<T>::type();
registerHandler(typeinfo, cb);
});
}
template <typename F, typename RequestType, typename ResponseType>
Session::IsRequestHandlerWithCallback<F, ResponseType> Session::registerHandler(
F&& handler) {
using CallbackType = ParamType<F, 1>;
registerHandler(
TypeOf<RequestType>::type(),
[handler](const void* args, const RequestSuccessCallback& onSuccess,
const RequestErrorCallback&) {
CallbackType responseCallback = [onSuccess](const ResponseType& res) {
onSuccess(TypeOf<ResponseType>::type(), &res);
};
handler(*reinterpret_cast<const RequestType*>(args), responseCallback);
});
}
template <typename F, typename RequestType, typename ResponseType>
Session::IsRequestHandlerWithCallback<F, ResponseOrError<ResponseType>>
Session::registerHandler(F&& handler) {
using CallbackType = ParamType<F, 1>;
registerHandler(
TypeOf<RequestType>::type(),
[handler](const void* args, const RequestSuccessCallback& onSuccess,
const RequestErrorCallback& onError) {
CallbackType responseCallback =
[onError, onSuccess](const ResponseOrError<ResponseType>& res) {
if (res.error) {
onError(TypeOf<ResponseType>::type(), res.error);
} else {
onSuccess(TypeOf<ResponseType>::type(), &res.response);
}
};
handler(*reinterpret_cast<const RequestType*>(args), responseCallback);
});
}
template <typename F, typename T>

159
include/dap/traits.h Normal file
View File

@@ -0,0 +1,159 @@
// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef dap_traits_h
#define dap_traits_h
#include <tuple>
#include <type_traits>
namespace dap {
namespace traits {
// NthTypeOf returns the `N`th type in `Types`
template <int N, typename... Types>
using NthTypeOf = typename std::tuple_element<N, std::tuple<Types...>>::type;
// `IsTypeOrDerived<BASE, T>::value` is true iff `T` is of type `BASE`, or
// derives from `BASE`.
template <typename BASE, typename T>
using IsTypeOrDerived = std::integral_constant<
bool,
std::is_base_of<BASE, typename std::decay<T>::type>::value ||
std::is_same<BASE, typename std::decay<T>::type>::value>;
// `EachIsTypeOrDerived<N, BASES, TYPES>::value` is true iff all of the types in
// the std::tuple `TYPES` is of, or derives from the corresponding indexed type
// in the std::tuple `BASES`.
// `N` must be equal to the number of types in both the std::tuple `BASES` and
// `TYPES`.
template <int N, typename BASES, typename TYPES>
struct EachIsTypeOrDerived {
using base = typename std::tuple_element<N - 1, BASES>::type;
using type = typename std::tuple_element<N - 1, TYPES>::type;
using last_matches = IsTypeOrDerived<base, type>;
using others_match = EachIsTypeOrDerived<N - 1, BASES, TYPES>;
static constexpr bool value = last_matches::value && others_match::value;
};
// EachIsTypeOrDerived specialization for N = 1
template <typename BASES, typename TYPES>
struct EachIsTypeOrDerived<1, BASES, TYPES> {
using base = typename std::tuple_element<0, BASES>::type;
using type = typename std::tuple_element<0, TYPES>::type;
static constexpr bool value = IsTypeOrDerived<base, type>::value;
};
// EachIsTypeOrDerived specialization for N = 0
template <typename BASES, typename TYPES>
struct EachIsTypeOrDerived<0, BASES, TYPES> {
static constexpr bool value = true;
};
// Signature describes the signature of a function.
template <typename RETURN, typename... PARAMETERS>
struct Signature {
// The return type of the function signature
using ret = RETURN;
// The parameters of the function signature held in a std::tuple
using parameters = std::tuple<PARAMETERS...>;
// The type of the Nth parameter of function signature
template <std::size_t N>
using parameter = NthTypeOf<N, PARAMETERS...>;
// The total number of parameters
static constexpr std::size_t parameter_count = sizeof...(PARAMETERS);
};
// SignatureOf is a traits helper that infers the signature of the function,
// method, static method, lambda, or function-like object `F`.
template <typename F>
struct SignatureOf {
// The signature of the function-like object `F`
using type = typename SignatureOf<decltype(&F::operator())>::type;
};
// SignatureOf specialization for a regular function or static method.
template <typename R, typename... ARGS>
struct SignatureOf<R (*)(ARGS...)> {
// The signature of the function-like object `F`
using type = Signature<typename std::decay<R>::type,
typename std::decay<ARGS>::type...>;
};
// SignatureOf specialization for a non-static method.
template <typename R, typename C, typename... ARGS>
struct SignatureOf<R (C::*)(ARGS...)> {
// The signature of the function-like object `F`
using type = Signature<typename std::decay<R>::type,
typename std::decay<ARGS>::type...>;
};
// SignatureOf specialization for a non-static, const method.
template <typename R, typename C, typename... ARGS>
struct SignatureOf<R (C::*)(ARGS...) const> {
// The signature of the function-like object `F`
using type = Signature<typename std::decay<R>::type,
typename std::decay<ARGS>::type...>;
};
// SignatureOfT is an alias to `typename SignatureOf<F>::type`.
template <typename F>
using SignatureOfT = typename SignatureOf<F>::type;
// ParameterType is an alias to `typename SignatureOf<F>::type::parameter<N>`.
template <typename F, std::size_t N>
using ParameterType = typename SignatureOfT<F>::template parameter<N>;
// `HasSignature<F, S>::value` is true iff the function-like `F` has a matching
// signature to the function-like `S`.
template <typename F, typename S>
using HasSignature = std::integral_constant<
bool,
std::is_same<SignatureOfT<F>, SignatureOfT<S>>::value>;
// `Min<A, B>::value` resolves to the smaller value of A and B.
template <std::size_t A, std::size_t B>
using Min = std::integral_constant<std::size_t, (A < B ? A : B)>;
// `CompatibleWith<F, S>::value` is true iff the function-like `F`
// can be called with the argument types of the function-like `S`. Return type
// of the two functions are not considered.
template <typename F, typename S>
using CompatibleWith = std::integral_constant<
bool,
(SignatureOfT<S>::parameter_count == SignatureOfT<F>::parameter_count) &&
EachIsTypeOrDerived<Min<SignatureOfT<S>::parameter_count,
SignatureOfT<F>::parameter_count>::value,
typename SignatureOfT<S>::parameters,
typename SignatureOfT<F>::parameters>::value>;
// If `CONDITION` is true then EnableIf resolves to type T, otherwise an
// invalid type.
template <bool CONDITION, typename T = void>
using EnableIf = typename std::enable_if<CONDITION, T>::type;
// If `BASE` is a base of `T` then EnableIfIsType resolves to type `TRUE`,
// otherwise an invalid type.
template <typename BASE, typename T, typename TRUE = void>
using EnableIfIsType = EnableIf<IsTypeOrDerived<BASE, T>::value, TRUE>;
// If the function-like `F` has a matching signature to the function-like `S`
// then EnableIfHasSignature resolves to type `TRUE`, otherwise an invalid type.
template <typename F, typename S, typename TRUE = void>
using EnableIfHasSignature = EnableIf<HasSignature<F, S>::value, TRUE>;
} // namespace traits
} // namespace dap
#endif // dap_traits_h