21 template<
typename... Args>
34 using ElementT =
typename std::decay<T>::type;
38 std::vector<char> data =
data_;
42 element.write(builder);
58 template<
typename... Args>
63 template<
typename Arg,
typename... Args>
66 using ElementT =
typename std::decay<Arg>::type;
71 element.write(builder);
82 builder.start_array(element.write_size());
83 element.write(builder);
84 builder.finish_array();
103 template<
typename Callback>
108 template<
typename... Args>
130 static auto test(T *) ->
typename T::is_form_element_t;
133 static std::false_type
test(...);
141 template<
typename Derived, Elements element>
146 static constexpr
auto type = element;
148 static constexpr
size_t write_size() {
return 3 + Derived::write_size_(); }
155 builder.
write(
static_cast<typename std::underlying_type<Elements>::type
>(
type));
157 static_cast<Derived &
>(*this).write_(builder);
177 static_assert(std::is_same_v<std::decay_t<T>, T>);
183 static inline constexpr
bool is_callback = std::is_invocable_v<T>;
224 builder.
write(has_def_);
232 template<
typename T, Elements element>
248 template<
typename T, Elements element>
254 interactive_(interactive)
260 interactive_(interactive)
271 builder.
write(interactive_);
280 #define MAKE_DATA_INPUT_HELPER(DATAT, ELEMENT, FNAME) \
281 inline details::FormDataInput<DATAT, ELEMENT> FNAME(const std::string & name, bool required) \
283 return {name, required}; \
286 template<typename T = DATAT> \
287 inline auto FNAME(const std::string & name, bool required, T value) \
289 if constexpr(std::is_invocable_v<T>) { return details::FormDataInput<T, ELEMENT>{name, required, value}; } \
292 if constexpr(std::is_same_v<std::decay_t<T>, DATAT>) \
294 return details::FormDataInput<DATAT, ELEMENT>{name, required, value}; \
298 return details::FormDataInput<DATAT, ELEMENT>{name, required, DATAT{value}}; \
303 #define MAKE_INTERACTIVE_DATA_INPUT_HELPER(DATAT, ELEMENT, FNAME) \
304 inline details::FormInteractiveDataInput<DATAT, ELEMENT> FNAME(const std::string & name, bool required, \
305 bool interactive = true) \
307 return {name, required, interactive}; \
310 template<typename T = DATAT, typename = std::enable_if_t<!std::is_same_v<T, bool>>> \
311 inline auto FNAME(const std::string & name, bool required, T value, bool interactive = true) \
313 if constexpr(std::is_invocable_v<T>) \
315 return details::FormInteractiveDataInput<T, ELEMENT>{name, required, value, interactive}; \
319 if constexpr(std::is_same_v<std::decay_t<T>, DATAT>) \
321 return details::FormInteractiveDataInput<DATAT, ELEMENT>{name, required, value, interactive}; \
325 return details::FormInteractiveDataInput<DATAT, ELEMENT>{name, required, DATAT{value}, interactive}; \
338 #undef MAKE_DATA_INPUT_HELPER
339 #undef MAKE_INTERACTIVE_DATA_INPUT_HELPER
349 const std::vector<std::string> & labels,
351 bool fixed_size =
true)
353 has_def_(true), labels_(labels)
359 const std::vector<std::string> & labels = {},
360 bool fixed_size =
false)
373 builder.
write(fixed_size_);
374 builder.
write(has_def_);
375 builder.
write(labels_);
382 std::vector<std::string> labels_;
391 return {name, required, Labels::labels, fixed_size};
395 auto FormArrayInput(
const std::string & name,
bool required, T && value,
bool fixed_size =
true)
397 if constexpr(std::is_invocable_v<T>)
399 using DataT = std::decay_t<decltype(std::declval<T>()())>;
405 using DataT = std::decay_t<T>;
415 const std::vector<std::string> & values,
416 bool send_index =
false,
427 builder.
write(values_);
428 builder.
write(send_index_);
436 std::vector<std::string> values_;
437 bool send_index_ =
false;
445 const std::vector<std::string> & ref,
446 bool send_index =
false)
456 builder.
write(send_index_);
463 std::vector<std::string> ref_;
474 template<
typename... Args>
498 template<
typename T = details::Vo
idValue>
502 template<
typename = std::enable_if_t<!details::is_form_element_v<T>>>
508 template<
typename Element,
typename = std::enable_if_t<details::is_form_element_v<Element>>>
511 FormElements(std::forward<Element>(element)), data_{data}
522 FormElements::write_impl(builder);
523 data_.write(builder);
540 template<
typename T = details::Vo
idValue>
550 typename = std::enable_if_t<!details::is_variant_v<std::decay_t<U>> && !details::is_getter<U>()>>
551 FormOneOfInput(
const std::string & name,
bool required, U && arg, Args &&... args)
557 template<
typename... Args>
558 FormOneOfInput(
const std::string & name,
bool required,
const T & def, Args &&... args)
570 FormElements::write_impl(builder);
578 template<
typename Callback,
typename... Args>
579 auto Form(
const std::string & name, Callback cb, Args &&... args)
constexpr bool is_form_element_v
Definition: Form.h:137
auto write(T &value)
Definition: traits.h:230
Definition: Observer.h:16
auto Form(const std::string &name, Callback cb, Args &&... args)
Definition: Form.h:579
details::FormArrayInput< T > FormArrayInput(const std::string &name, bool required, bool fixed_size=false)
Definition: Form.h:388
Elements
Definition: elements.h:23
auto ArrayInput(const std::string &name, GetT get_fn, SetT set_fn)
Definition: ArrayInput.h:59
auto ComboInput(const std::string &name, const std::vector< std::string > &values, GetT get_fn, SetT set_fn)
Definition: ComboInput.h:52
auto DataComboInput(const std::string &name, const std::vector< std::string > &values, GetT get_fn, SetT set_fn)
Definition: DataComboInput.h:51
void error_and_throw(Args &&... args)
Definition: logging.h:47
Definition: MessagePackBuilder.h:87
void start_array(size_t size)
void write_object(const char *data, size_t s)
Definition: elements.h:127
Definition: elements.h:59
const std::string & name() const
Definition: elements.h:61
CallbackOrValue()
Definition: Form.h:202
CallbackOrValue(VoidValue)
Definition: Form.h:203
void write(mc_rtc::MessagePackBuilder &builder)
Definition: Form.h:207
void write(mc_rtc::MessagePackBuilder &builder)
Definition: Form.h:185
CallbackOrValue(T value)
Definition: Form.h:179
T callback_or_value
Definition: Form.h:181
static constexpr bool is_callback
Definition: Form.h:183