Skip to content

Commit 47d20fe

Browse files
stephenberrystephenberry
authored
glz::tuplet::tuple -> glz::tuple (#1514)
* glz::tuplet::tuple -> glz::tuple * Update tuple.hpp * removing unused map function in glz::tuple * rename to_tuple -> to_tie * Fix duplicate to_tie template instantiations * Remove unnecessary glaze_names * Faster glz::schema compilation
1 parent 360fced commit 47d20fe

23 files changed

+385
-470
lines changed

‎include/glaze/api/tuplet.hpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -9,10 +9,10 @@
99
namespace glz
1010
{
1111
template <class... T>
12-
struct meta<glz::tuplet::tuple<T...>>
12+
struct meta<glz::tuple<T...>>
1313
{
1414
static constexpr std::string_view name = []<size_t... I>(std::index_sequence<I...>) {
15-
return join_v<chars<"glz::tuplet::tuple<">,
15+
return join_v<chars<"glz::tuple<">,
1616
((I != sizeof...(T) - 1) ? join_v<name_v<T>, chars<",">> : join_v<name_v<T>>)..., chars<">">>;
1717
}(std::make_index_sequence<sizeof...(T)>{});
1818
};

‎include/glaze/beve/read.hpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -1236,7 +1236,7 @@ namespace glz
12361236
static void op(auto&& value, is_context auto&& ctx, auto&& it, auto&& end)
12371237
{
12381238
if constexpr (reflectable<T>) {
1239-
auto t = to_tuple(value);
1239+
auto t = to_tie(value);
12401240
read<BEVE>::op<Opts>(t, ctx, it, end);
12411241
}
12421242
else {
@@ -1338,7 +1338,7 @@ namespace glz
13381338
static constexpr auto Length = TargetKey.size();
13391339
if ((Length == n) && compare<Length>(TargetKey.data(), key.data())) [[likely]] {
13401340
if constexpr (detail::reflectable<T>) {
1341-
read<BEVE>::op<Opts>(get_member(value, get<I>(to_tuple(value))), ctx, it, end);
1341+
read<BEVE>::op<Opts>(get_member(value, get<I>(to_tie(value))), ctx, it, end);
13421342
}
13431343
else {
13441344
read<BEVE>::op<Opts>(get_member(value, get<I>(reflect<T>::values)), ctx, it, end);

‎include/glaze/beve/write.hpp

+3-3
Original file line numberDiff line numberDiff line change
@@ -699,7 +699,7 @@ namespace glz
699699

700700
[[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) {
701701
if constexpr (reflectable<T>) {
702-
return to_tuple(value);
702+
return to_tie(value);
703703
}
704704
else {
705705
return nullptr;
@@ -737,7 +737,7 @@ namespace glz
737737

738738
[[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) {
739739
if constexpr (reflectable<T>) {
740-
return to_tuple(value);
740+
return to_tie(value);
741741
}
742742
else {
743743
return nullptr;
@@ -884,7 +884,7 @@ namespace glz
884884
}
885885
else {
886886
detail::write<BEVE>::no_header<Opts>(key, ctx, b, ix);
887-
write_partial<BEVE>::op<sub_partial, Opts>(get_member(value, get<index>(to_tuple(value))), ctx, b,
887+
write_partial<BEVE>::op<sub_partial, Opts>(get_member(value, get<index>(to_tie(value))), ctx, b,
888888
ix);
889889
}
890890
});

‎include/glaze/core/common.hpp

+9-9
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,7 @@ namespace glz
4141
template <class... T>
4242
struct obj final
4343
{
44-
glz::tuplet::tuple<std::conditional_t<std::is_convertible_v<std::decay_t<T>, sv>, sv, T>...> value;
44+
glz::tuple<std::conditional_t<std::is_convertible_v<std::decay_t<T>, sv>, sv, T>...> value;
4545
static constexpr auto glaze_reflect = false;
4646
};
4747

@@ -51,7 +51,7 @@ namespace glz
5151
template <class... T>
5252
struct obj_copy final
5353
{
54-
glz::tuplet::tuple<T...> value;
54+
glz::tuple<T...> value;
5555
static constexpr auto glaze_reflect = false;
5656
};
5757

@@ -61,7 +61,7 @@ namespace glz
6161
template <class... T>
6262
struct arr final
6363
{
64-
glz::tuplet::tuple<std::conditional_t<std::is_convertible_v<std::decay_t<T>, sv>, sv, T>...> value;
64+
glz::tuple<std::conditional_t<std::is_convertible_v<std::decay_t<T>, sv>, sv, T>...> value;
6565
static constexpr auto glaze_reflect = false;
6666
};
6767

@@ -71,7 +71,7 @@ namespace glz
7171
template <class... T>
7272
struct arr_copy final
7373
{
74-
glz::tuplet::tuple<T...> value;
74+
glz::tuple<T...> value;
7575
};
7676

7777
template <class... T>
@@ -81,7 +81,7 @@ namespace glz
8181
template <class... T>
8282
struct merge final
8383
{
84-
glz::tuplet::tuple<std::conditional_t<std::is_convertible_v<std::decay_t<T>, sv>, sv, T>...> value;
84+
glz::tuple<std::conditional_t<std::is_convertible_v<std::decay_t<T>, sv>, sv, T>...> value;
8585
static constexpr auto glaze_reflect = false;
8686
};
8787

@@ -521,17 +521,17 @@ namespace glz
521521
}
522522
}
523523

524-
constexpr auto array(auto&&... args) noexcept { return detail::Array{glz::tuplet::tuple{conv_sv(args)...}}; }
524+
constexpr auto array(auto&&... args) noexcept { return detail::Array{glz::tuple{conv_sv(args)...}}; }
525525

526526
template <class... Args>
527527
constexpr auto object(Args&&... args) noexcept
528528
{
529-
return detail::Object{tuplet::tuple{std::forward<Args>(args)...}};
529+
return detail::Object{tuple{std::forward<Args>(args)...}};
530530
}
531531

532-
constexpr auto enumerate(auto&&... args) noexcept { return detail::Enum{tuplet::tuple{args...}}; }
532+
constexpr auto enumerate(auto&&... args) noexcept { return detail::Enum{tuple{args...}}; }
533533

534-
constexpr auto flags(auto&&... args) noexcept { return detail::Flags{tuplet::tuple{args...}}; }
534+
constexpr auto flags(auto&&... args) noexcept { return detail::Flags{tuple{args...}}; }
535535
}
536536

537537
namespace glz

‎include/glaze/core/convert_struct.hpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -22,8 +22,8 @@ namespace glz
2222
template <class In, class Out>
2323
void convert_struct(In&& in, Out&& out)
2424
{
25-
auto in_tuple = to_tuple(std::forward<In>(in));
26-
auto out_tuple = to_tuple(std::forward<Out>(out));
25+
auto in_tuple = to_tie(std::forward<In>(in));
26+
auto out_tuple = to_tie(std::forward<Out>(out));
2727

2828
constexpr auto N = tuple_size_v<std::decay_t<decltype(in_tuple)>>;
2929
static_assert(N == tuple_size_v<std::decay_t<decltype(out_tuple)>>);

‎include/glaze/core/meta.hpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -110,7 +110,7 @@ namespace glz
110110

111111
struct empty
112112
{
113-
static constexpr glz::tuplet::tuple<> value{};
113+
static constexpr glz::tuple<> value{};
114114
};
115115

116116
template <class T>

‎include/glaze/core/reflect.hpp

+9-9
Original file line numberDiff line numberDiff line change
@@ -91,7 +91,7 @@ namespace glz
9191
struct reflect<T>
9292
{
9393
static constexpr auto size = 0;
94-
static constexpr auto values = tuplet::tuple{};
94+
static constexpr auto values = tuple{};
9595
static constexpr std::array<sv, 0> keys{};
9696

9797
template <size_t I>
@@ -109,7 +109,7 @@ namespace glz
109109

110110
static constexpr auto values = [] {
111111
return [&]<size_t... I>(std::index_sequence<I...>) { //
112-
return tuplet::tuple{get<value_indices[I]>(meta_v<T>)...}; //
112+
return tuple{get<value_indices[I]>(meta_v<T>)...}; //
113113
}(std::make_index_sequence<value_indices.size()>{}); //
114114
}();
115115

@@ -188,16 +188,16 @@ namespace glz
188188
struct reflect<T>
189189
{
190190
using V = std::remove_cvref_t<T>;
191-
using tuple = decay_keep_volatile_t<decltype(to_tuple(std::declval<T>()))>;
191+
using tie_type = decltype(to_tie(std::declval<T&>()));
192192

193193
static constexpr auto keys = member_names<V>;
194194
static constexpr auto size = keys.size();
195195

196196
template <size_t I>
197-
using elem = decltype(get<I>(std::declval<tuple>()));
197+
using elem = decltype(get<I>(std::declval<tie_type>()));
198198

199199
template <size_t I>
200-
using type = member_t<V, decltype(get<I>(std::declval<tuple>()))>;
200+
using type = member_t<V, decltype(get<I>(std::declval<tie_type>()))>;
201201
};
202202

203203
template <class T>
@@ -328,7 +328,7 @@ namespace glz::detail
328328
struct tuple_ptr_variant;
329329

330330
template <class... Ts>
331-
struct tuple_ptr_variant<glz::tuplet::tuple<Ts...>> : unique<std::variant<>, std::add_pointer_t<Ts>...>
331+
struct tuple_ptr_variant<glz::tuple<Ts...>> : unique<std::variant<>, std::add_pointer_t<Ts>...>
332332
{};
333333

334334
template <class... Ts>
@@ -345,8 +345,8 @@ namespace glz::detail
345345
template <class T, size_t... I>
346346
struct member_tuple_type<T, std::index_sequence<I...>>
347347
{
348-
using type = std::conditional_t<sizeof...(I) == 0, tuplet::tuple<>,
349-
tuplet::tuple<std::remove_cvref_t<member_t<T, refl_t<T, I>>>...>>;
348+
using type = std::conditional_t<sizeof...(I) == 0, tuple<>,
349+
tuple<std::remove_cvref_t<member_t<T, refl_t<T, I>>>...>>;
350350
};
351351

352352
template <class T>
@@ -1992,7 +1992,7 @@ namespace glz
19921992
constexpr auto N = reflect<T>::size;
19931993
if constexpr (N > 0) {
19941994
[&]<size_t... I>(std::index_sequence<I...>) constexpr {
1995-
(callable(get_member(value, get<I>(to_tuple(value)))), ...);
1995+
(callable(get_member(value, get<I>(to_tie(value)))), ...);
19961996
}(std::make_index_sequence<N>{});
19971997
}
19981998
}

‎include/glaze/core/seek.hpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -107,7 +107,7 @@ namespace glz::detail
107107
jump_table<N>(
108108
[&]<size_t I>() {
109109
if constexpr (reflectable<T>) {
110-
ret = seek_impl(std::forward<F>(func), get_member(value, get<I>(to_tuple(value))), json_ptr);
110+
ret = seek_impl(std::forward<F>(func), get_member(value, get<I>(to_tie(value))), json_ptr);
111111
}
112112
else {
113113
ret = seek_impl(std::forward<F>(func), get_member(value, get<I>(reflect<T>::values)), json_ptr);
@@ -494,7 +494,7 @@ namespace glz
494494
n_items_per_group[i] = std::count(first_keys.begin(), first_keys.end(), unique_keys[i]);
495495
}
496496

497-
return glz::tuplet::tuple{n_items_per_group, n_unique, unique_keys};
497+
return glz::tuple{n_items_per_group, n_unique, unique_keys};
498498
}
499499

500500
template <auto Arr, std::size_t... Is>

‎include/glaze/csv/read.hpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -464,7 +464,7 @@ namespace glz
464464
[&]<size_t I>() {
465465
decltype(auto) member = [&]() -> decltype(auto) {
466466
if constexpr (reflectable<T>) {
467-
return get_member(value, get<I>(to_tuple(value)));
467+
return get_member(value, get<I>(to_tie(value)));
468468
}
469469
else {
470470
return get_member(value, get<I>(reflect<T>::values));
@@ -581,7 +581,7 @@ namespace glz
581581
[&]<size_t I>() {
582582
decltype(auto) member = [&]() -> decltype(auto) {
583583
if constexpr (reflectable<T>) {
584-
return get_member(value, get<I>(to_tuple(value)));
584+
return get_member(value, get<I>(to_tie(value)));
585585
}
586586
else {
587587
return get_member(value, get<I>(reflect<T>::values));

‎include/glaze/csv/write.hpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -180,7 +180,7 @@ namespace glz
180180

181181
[[maybe_unused]] decltype(auto) t = [&] {
182182
if constexpr (reflectable<T>) {
183-
return to_tuple(value);
183+
return to_tie(value);
184184
}
185185
else {
186186
return nullptr;

‎include/glaze/ext/cli_menu.hpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -70,7 +70,7 @@ namespace glz
7070

7171
[[maybe_unused]] decltype(auto) t = [&] {
7272
if constexpr (reflectable<T>) {
73-
return to_tuple(value);
73+
return to_tie(value);
7474
}
7575
else {
7676
return nullptr;
@@ -181,7 +181,7 @@ namespace glz
181181
else {
182182
[[maybe_unused]] decltype(auto) t = [&] {
183183
if constexpr (reflectable<T>) {
184-
return to_tuple(value);
184+
return to_tie(value);
185185
}
186186
else {
187187
return nullptr;

‎include/glaze/ext/jsonrpc.hpp

+4-4
Original file line numberDiff line numberDiff line change
@@ -198,7 +198,7 @@ namespace glz::rpc
198198
namespace detail
199199
{
200200
template <string_literal name, class... Method>
201-
inline constexpr void set_callback(glz::tuplet::tuple<Method...>& methods, const auto& callback)
201+
inline constexpr void set_callback(glz::tuple<Method...>& methods, const auto& callback)
202202
{
203203
constexpr bool method_found = ((Method::name_v == name) || ...);
204204
static_assert(method_found, "Method not settable in given tuple.");
@@ -257,7 +257,7 @@ namespace glz::rpc
257257
};
258258

259259
template <class Map, string_literal Name, class... Method>
260-
auto get_request_map(glz::tuplet::tuple<Method...>& methods) -> Map&
260+
auto get_request_map(glz::tuple<Method...>& methods) -> Map&
261261
{
262262
constexpr bool method_found = ((Method::name_v == Name) || ...);
263263
static_assert(method_found, "Method not declared in client.");
@@ -284,7 +284,7 @@ namespace glz::rpc
284284
{
285285
using raw_response_t = response_t<glz::raw_json>;
286286

287-
glz::tuplet::tuple<server_method_t<Method>...> methods{};
287+
glz::tuple<server_method_t<Method>...> methods{};
288288

289289
template <string_literal name>
290290
constexpr void on(const auto& callback) // std::function<expected<result_t, rpc::error>(params_t const&)>
@@ -411,7 +411,7 @@ namespace glz::rpc
411411
template <concepts::method_type... Method>
412412
struct client
413413
{
414-
glz::tuplet::tuple<client_method_t<Method>...> methods{};
414+
glz::tuple<client_method_t<Method>...> methods{};
415415

416416
rpc::error call(std::string_view json_response)
417417
{

‎include/glaze/json/read.hpp

+11-11
Original file line numberDiff line numberDiff line change
@@ -174,7 +174,7 @@ namespace glz
174174
}
175175
else {
176176
from<JSON, std::remove_cvref_t<V>>::template op<ws_handled<Opts>()>(
177-
get_member(value, get<I>(to_tuple(value))), ctx, it, end);
177+
get_member(value, get<I>(to_tie(value))), ctx, it, end);
178178
}
179179
}
180180

@@ -2065,36 +2065,36 @@ namespace glz
20652065
{
20662066
// TODO: this way of filtering types is compile time intensive.
20672067
using bool_types = decltype(tuplet::tuple_cat(
2068-
std::conditional_t<bool_t<remove_meta_wrapper_t<Ts>>, tuplet::tuple<Ts>, tuplet::tuple<>>{}...));
2068+
std::conditional_t<bool_t<remove_meta_wrapper_t<Ts>>, tuple<Ts>, tuple<>>{}...));
20692069
using number_types = decltype(tuplet::tuple_cat(
2070-
std::conditional_t<num_t<remove_meta_wrapper_t<Ts>>, tuplet::tuple<Ts>, tuplet::tuple<>>{}...));
2070+
std::conditional_t<num_t<remove_meta_wrapper_t<Ts>>, tuple<Ts>, tuple<>>{}...));
20712071
using string_types = decltype(tuplet::tuple_cat( // glaze_enum_t remove_meta_wrapper_t supports constexpr
20722072
// types while the other supports non const
20732073
std::conditional_t < str_t<remove_meta_wrapper_t<Ts>> || glaze_enum_t<remove_meta_wrapper_t<Ts>> ||
20742074
glaze_enum_t<Ts>,
2075-
tuplet::tuple<Ts>, tuplet::tuple < >> {}...));
2075+
tuple<Ts>, tuple < >> {}...));
20762076
using object_types =
2077-
decltype(tuplet::tuple_cat(std::conditional_t<json_object<Ts>, tuplet::tuple<Ts>, tuplet::tuple<>>{}...));
2077+
decltype(tuplet::tuple_cat(std::conditional_t<json_object<Ts>, tuple<Ts>, tuple<>>{}...));
20782078
using array_types =
20792079
decltype(tuplet::tuple_cat(std::conditional_t < array_t<remove_meta_wrapper_t<Ts>> || glaze_array_t<Ts>,
2080-
tuplet::tuple<Ts>, tuplet::tuple < >> {}...));
2080+
tuple<Ts>, tuple < >> {}...));
20812081
using nullable_types =
2082-
decltype(tuplet::tuple_cat(std::conditional_t<null_t<Ts>, tuplet::tuple<Ts>, tuplet::tuple<>>{}...));
2082+
decltype(tuplet::tuple_cat(std::conditional_t<null_t<Ts>, tuple<Ts>, tuple<>>{}...));
20832083
using nullable_objects = decltype(tuplet::tuple_cat(
2084-
std::conditional_t<is_memory_object<Ts>, tuplet::tuple<Ts>, tuplet::tuple<>>{}...));
2084+
std::conditional_t<is_memory_object<Ts>, tuple<Ts>, tuple<>>{}...));
20852085
};
20862086

20872087
// post process output of variant_types
20882088
template <class>
20892089
struct tuple_types;
20902090

20912091
template <class... Ts>
2092-
struct tuple_types<tuplet::tuple<Ts...>>
2092+
struct tuple_types<tuple<Ts...>>
20932093
{
20942094
using glaze_const_types = decltype(tuplet::tuple_cat(
2095-
std::conditional_t<glaze_const_value_t<Ts>, tuplet::tuple<Ts>, tuplet::tuple<>>{}...));
2095+
std::conditional_t<glaze_const_value_t<Ts>, tuple<Ts>, tuple<>>{}...));
20962096
using glaze_non_const_types = decltype(tuplet::tuple_cat(
2097-
std::conditional_t<!glaze_const_value_t<Ts>, tuplet::tuple<Ts>, tuplet::tuple<>>{}...));
2097+
std::conditional_t<!glaze_const_value_t<Ts>, tuple<Ts>, tuple<>>{}...));
20982098
};
20992099

21002100
template <class>

0 commit comments

Comments
 (0)