saberbud/rest_rpc
1
0
Fork 0
mirror of https://github.com/qicosmos/rest_rpc.git synced 2026-08-29 08:34:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

nonstd

Browse Source
This commit is contained in:
qicosmos
2024-01-28 09:18:10 +08:00
parent 11a51c6942
commit a98f331dd1
3 changed files with 38 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/rest_rpc/cplusplus_14.h
+17 -14
View File
@@ -7,11 +7,13 @@
#if __cplusplus == 201103L
namespace std {
template <class T> struct unique_if { typedef unique_ptr<T> single_object; };
namespace nonstd {
template <class T> struct unique_if {
typedef std::unique_ptr<T> single_object;
};
template <class T> struct unique_if<T[]> {
typedef unique_ptr<T[]> unknown_bound;
typedef std::unique_ptr<T[]> unknown_bound;
};
template <class T, size_t N> struct unique_if<T[N]> {
@@ -24,7 +26,7 @@ typename unique_if<T>::single_object make_unique(Args &&...args) {
}
template <class T> typename unique_if<T>::unknown_bound make_unique(size_t n) {
typedef typename remove_extent<T>::type U;
typedef typename std::remove_extent<T>::type U;
return unique_ptr<T>(new U[n]());
}
@@ -59,20 +61,21 @@ template <typename... T>
using index_sequence_for = make_index_sequence<sizeof...(T)>;
template <bool B, class T = void>
using enable_if_t = typename enable_if<B, T>::type;
template <typename T> using remove_const_t = typename remove_const<T>::type;
using enable_if_t = typename std::enable_if<B, T>::type;
template <typename T>
using remove_reference_t = typename remove_reference<T>::type;
using remove_const_t = typename std::remove_const<T>::type;
template <typename T>
using remove_reference_t = typename std::remove_reference<T>::type;
template <int I, typename T>
using tuple_element_t = typename tuple_element<I, T>::type;
using tuple_element_t = typename std::tuple_element<I, T>::type;
template <typename T> using decay_t = typename decay<T>::type;
template <typename T> using decay_t = typename std::decay<T>::type;
template <typename F, typename Tuple, size_t... Idx>
auto apply_helper(F &&f, Tuple &&tp, std::index_sequence<Idx...>)
auto apply_helper(F &&f, Tuple &&tp, nonstd::index_sequence<Idx...>)
-> decltype(std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(tp))...)) {
return std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(tp))...);
}
@@ -80,10 +83,10 @@ auto apply_helper(F &&f, Tuple &&tp, std::index_sequence<Idx...>)
template <typename F, typename Tuple>
auto apply(F &&f, Tuple &&tp) -> decltype(apply_helper(
std::forward<F>(f), std::forward<Tuple>(tp),
std::make_index_sequence<std::tuple_size<decay_t<Tuple>>::value>{})) {
make_index_sequence<std::tuple_size<decay_t<Tuple>>::value>{})) {
return apply_helper(
std::forward<F>(f), std::forward<Tuple>(tp),
std::make_index_sequence<std::tuple_size<decay_t<Tuple>>::value>{});
make_index_sequence<std::tuple_size<decay_t<Tuple>>::value>{});
}
template <typename F, typename... Args>
@@ -92,7 +95,7 @@ auto invoke(F &&f, Args &&...args)
return std::forward<F>(f)(std::forward<Args>(args)...);
}
} // namespace std
} // namespace nonstd
#endif
include/rest_rpc/meta_util.hpp
+14 -13
View File
@@ -8,13 +8,13 @@ namespace rest_rpc {
template <typename... Args, typename Func, std::size_t... Idx>
void for_each(const std::tuple<Args...> &t, Func &&f,
std::index_sequence<Idx...>) {
nonstd::index_sequence<Idx...>) {
(void)std::initializer_list<int>{(f(std::get<Idx>(t)), void(), 0)...};
}
template <typename... Args, typename Func, std::size_t... Idx>
void for_each_i(const std::tuple<Args...> &t, Func &&f,
std::index_sequence<Idx...>) {
nonstd::index_sequence<Idx...>) {
(void)std::initializer_list<int>{
(f(std::get<Idx>(t), std::integral_constant<size_t, Idx>{}), void(),
0)...};
@@ -32,14 +32,15 @@ public:
typedef Ret (*pointer)(Arg, Args...);
typedef std::tuple<Arg, Args...> tuple_type;
typedef std::tuple<std::remove_const_t<std::remove_reference_t<Args>>...>
typedef std::tuple<
nonstd::remove_const_t<nonstd::remove_reference_t<Args>>...>
bare_tuple_type;
using args_tuple =
std::tuple<std::string, Arg,
std::remove_const_t<std::remove_reference_t<Args>>...>;
nonstd::remove_const_t<nonstd::remove_reference_t<Args>>...>;
using args_tuple_2nd =
std::tuple<std::string,
std::remove_const_t<std::remove_reference_t<Args>>...>;
nonstd::remove_const_t<nonstd::remove_reference_t<Args>>...>;
};
template <typename Ret> struct function_traits<Ret()> {
@@ -76,24 +77,24 @@ struct function_traits : function_traits<decltype(&Callable::operator())> {};
template <typename T>
using remove_const_reference_t =
std::remove_const_t<std::remove_reference_t<T>>;
nonstd::remove_const_t<nonstd::remove_reference_t<T>>;
template <size_t... Is>
auto make_tuple_from_sequence(std::index_sequence<Is...>)
auto make_tuple_from_sequence(nonstd::index_sequence<Is...>)
-> decltype(std::make_tuple(Is...)) {
std::make_tuple(Is...);
}
template <size_t N>
constexpr auto make_tuple_from_sequence()
-> decltype(make_tuple_from_sequence(std::make_index_sequence<N>{})) {
return make_tuple_from_sequence(std::make_index_sequence<N>{});
-> decltype(make_tuple_from_sequence(nonstd::make_index_sequence<N>{})) {
return make_tuple_from_sequence(nonstd::make_index_sequence<N>{});
}
namespace detail {
template <class Tuple, class F, std::size_t... Is>
void tuple_switch(const std::size_t i, Tuple &&t, F &&f,
std::index_sequence<Is...>) {
nonstd::index_sequence<Is...>) {
(void)std::initializer_list<int>{
(i == Is &&
((void)std::forward<F>(f)(std::integral_constant<size_t, Is>{}), 0))...};
@@ -102,14 +103,14 @@ void tuple_switch(const std::size_t i, Tuple &&t, F &&f,
template <class Tuple, class F>
inline void tuple_switch(const std::size_t i, Tuple &&t, F &&f) {
constexpr auto N = std::tuple_size<std::remove_reference_t<Tuple>>::value;
constexpr auto N = std::tuple_size<nonstd::remove_reference_t<Tuple>>::value;
detail::tuple_switch(i, std::forward<Tuple>(t), std::forward<F>(f),
std::make_index_sequence<N>{});
nonstd::make_index_sequence<N>{});
}
template <int N, typename... Args>
using nth_type_of = std::tuple_element_t<N, std::tuple<Args...>>;
using nth_type_of = nonstd::tuple_element_t<N, std::tuple<Args...>>;
template <typename... Args>
using last_type_of = nth_type_of<sizeof...(Args) - 1, Args...>;
include/rest_rpc/router.h
+7 -7
View File
@@ -119,7 +119,7 @@ private:
template <typename F, size_t... I, typename... Args>
static typename std::result_of<F(std::weak_ptr<connection>, Args...)>::type
call_helper(const F &f, const std::index_sequence<I...> &,
call_helper(const F &f, const nonstd::index_sequence<I...> &,
std::tuple<Args...> tup, std::weak_ptr<connection> ptr) {
return f(ptr, std::move(std::get<I>(tup))...);
}
@@ -129,8 +129,8 @@ private:
F(std::weak_ptr<connection>, Args...)>::type>::value>::type
call(const F &f, std::weak_ptr<connection> ptr, std::string &result,
std::tuple<Args...> tp) {
call_helper(f, std::make_index_sequence<sizeof...(Args)>{}, std::move(tp),
ptr);
call_helper(f, nonstd::make_index_sequence<sizeof...(Args)>{},
std::move(tp), ptr);
result = msgpack_codec::pack_args_str(result_code::OK);
}
@@ -139,7 +139,7 @@ private:
F(std::weak_ptr<connection>, Args...)>::type>::value>::type
call(const F &f, std::weak_ptr<connection> ptr, std::string &result,
std::tuple<Args...> tp) {
auto r = call_helper(f, std::make_index_sequence<sizeof...(Args)>{},
auto r = call_helper(f, nonstd::make_index_sequence<sizeof...(Args)>{},
std::move(tp), ptr);
msgpack_codec codec;
result = msgpack_codec::pack_args_str(result_code::OK, r);
@@ -149,7 +149,7 @@ private:
static
typename std::result_of<F(Self, std::weak_ptr<connection>, Args...)>::type
call_member_helper(const F &f, Self *self,
const std::index_sequence<Indexes...> &,
const nonstd::index_sequence<Indexes...> &,
std::tuple<Args...> tup,
std::weak_ptr<connection> ptr =
std::shared_ptr<connection>{nullptr}) {
@@ -162,7 +162,7 @@ private:
call_member(const F &f, Self *self, std::weak_ptr<connection> ptr,
std::string &result, std::tuple<Args...> tp) {
call_member_helper(f, self,
typename std::make_index_sequence<sizeof...(Args)>{},
typename nonstd::make_index_sequence<sizeof...(Args)>{},
std::move(tp), ptr);
result = msgpack_codec::pack_args_str(result_code::OK);
}
@@ -173,7 +173,7 @@ private:
call_member(const F &f, Self *self, std::weak_ptr<connection> ptr,
std::string &result, std::tuple<Args...> tp) {
auto r = call_member_helper(
f, self, typename std::make_index_sequence<sizeof...(Args)>{},
f, self, typename nonstd::make_index_sequence<sizeof...(Args)>{},
std::move(tp), ptr);
result = msgpack_codec::pack_args_str(result_code::OK, r);
}