338 lines
11 KiB
C++
338 lines
11 KiB
C++
#pragma once
|
|
#include "adminive/concepts.hpp"
|
|
#include "magic_enum/magic_enum.hpp"
|
|
#include <cctype>
|
|
#include <concepts>
|
|
#include <map>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <tuple>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
namespace adminive {
|
|
template <class T>
|
|
struct Type_Descriptor;
|
|
template <class T>
|
|
concept Described_Type = requires {
|
|
{ Type_Descriptor<std::remove_cvref_t<T>>::get() };
|
|
};
|
|
template <auto Member>
|
|
struct Member_Pointer_Traits;
|
|
template <class Owner, class Member_Type, Member_Type Owner::*Member>
|
|
struct Member_Pointer_Traits<Member> {
|
|
using owner_type = Owner;
|
|
using member_type = Member_Type;
|
|
static constexpr auto value = Member;
|
|
};
|
|
inline std::string make_label(std::string_view name) {
|
|
std::string result;
|
|
result.reserve(name.size());
|
|
bool uppercase = true;
|
|
for(const char value : name) {
|
|
if(value == '_') {
|
|
result.push_back(' ');
|
|
uppercase = true;
|
|
continue;
|
|
}
|
|
result.push_back(uppercase ? static_cast<char>(std::toupper(static_cast<unsigned char>(value))) : value);
|
|
uppercase = false;
|
|
}
|
|
return result;
|
|
}
|
|
template <auto Member>
|
|
class Field_Descriptor {
|
|
public:
|
|
using owner_type = typename Member_Pointer_Traits<Member>::owner_type;
|
|
using member_type = typename Member_Pointer_Traits<Member>::member_type;
|
|
static constexpr auto member = Member;
|
|
explicit Field_Descriptor(std::string name) : name_(std::move(name)), label_(make_label(name_)) {}
|
|
Field_Descriptor(std::string name, std::string label) : name_(std::move(name)), label_(std::move(label)) {}
|
|
Field_Descriptor editable(bool value = true) const {
|
|
auto result = *this;
|
|
result.editable_ = value;
|
|
return result;
|
|
}
|
|
Field_Descriptor creatable(bool value = true) const {
|
|
auto result = *this;
|
|
result.creatable_ = value;
|
|
return result;
|
|
}
|
|
Field_Descriptor readable(bool value = true) const {
|
|
auto result = *this;
|
|
result.readable_ = value;
|
|
return result;
|
|
}
|
|
Field_Descriptor visible(bool value = true) const {
|
|
auto result = *this;
|
|
result.visible_ = value;
|
|
return result;
|
|
}
|
|
Field_Descriptor required(bool value = true) const {
|
|
auto result = *this;
|
|
result.required_ = value;
|
|
return result;
|
|
}
|
|
Field_Descriptor list_visible(bool value = true) const {
|
|
auto result = *this;
|
|
result.list_visible_ = value;
|
|
return result;
|
|
}
|
|
Field_Descriptor label(std::string value) const {
|
|
auto result = *this;
|
|
result.label_ = std::move(value);
|
|
return result;
|
|
}
|
|
Field_Descriptor description(std::string value) const {
|
|
auto result = *this;
|
|
result.description_ = std::move(value);
|
|
return result;
|
|
}
|
|
Field_Descriptor widget(std::string value) const {
|
|
auto result = *this;
|
|
result.widget_ = std::move(value);
|
|
return result;
|
|
}
|
|
Field_Descriptor visible_on(std::string value) const {
|
|
auto result = *this;
|
|
result.visible_on_ = std::move(value);
|
|
return result;
|
|
}
|
|
Field_Descriptor list_label(std::string value) const {
|
|
auto result = *this;
|
|
result.list_label_ = std::move(value);
|
|
return result;
|
|
}
|
|
Field_Descriptor order(int value) const {
|
|
auto result = *this;
|
|
result.order_ = value;
|
|
return result;
|
|
}
|
|
Field_Descriptor sortable(bool value = true) const {
|
|
auto result = *this;
|
|
result.sortable_ = value;
|
|
return result;
|
|
}
|
|
template <auto Value>
|
|
requires std::is_enum_v<member_type> && std::same_as<decltype(Value), member_type>
|
|
Field_Descriptor enum_label(std::string label) const {
|
|
const auto name = magic_enum::enum_name(Value);
|
|
if(name.empty()) {
|
|
throw std::invalid_argument("enum value is outside the magic_enum reflection range");
|
|
}
|
|
auto result = *this;
|
|
result.enum_labels_.insert_or_assign(std::string(name), std::move(label));
|
|
return result;
|
|
}
|
|
const std::string& name() const noexcept {
|
|
return name_;
|
|
}
|
|
const std::string& label() const noexcept {
|
|
return label_;
|
|
}
|
|
const std::string& list_label() const noexcept {
|
|
return list_label_.empty() ? label_ : list_label_;
|
|
}
|
|
const std::string& description() const noexcept {
|
|
return description_;
|
|
}
|
|
const std::string& widget() const noexcept {
|
|
return widget_;
|
|
}
|
|
const std::string& visible_on() const noexcept {
|
|
return visible_on_;
|
|
}
|
|
const std::map<std::string, std::string>& enum_labels() const noexcept {
|
|
return enum_labels_;
|
|
}
|
|
bool is_editable() const noexcept {
|
|
return editable_;
|
|
}
|
|
bool is_creatable() const noexcept {
|
|
return creatable_;
|
|
}
|
|
bool is_readable() const noexcept {
|
|
return readable_;
|
|
}
|
|
bool is_visible() const noexcept {
|
|
return visible_;
|
|
}
|
|
bool is_required() const noexcept {
|
|
return required_;
|
|
}
|
|
int order() const noexcept {
|
|
return order_;
|
|
}
|
|
bool is_sortable() const noexcept {
|
|
return sortable_;
|
|
}
|
|
bool is_list_visible() const noexcept {
|
|
return list_visible_;
|
|
}
|
|
private:
|
|
std::string name_;
|
|
std::string label_;
|
|
std::string list_label_;
|
|
std::string description_;
|
|
std::string widget_;
|
|
std::string visible_on_;
|
|
std::map<std::string, std::string> enum_labels_;
|
|
bool editable_{};
|
|
bool creatable_{};
|
|
bool readable_{true};
|
|
bool visible_{true};
|
|
bool required_{};
|
|
bool list_visible_{true};
|
|
int order_{-1};
|
|
bool sortable_{};
|
|
};
|
|
template <class T>
|
|
struct Is_Field_Descriptor : std::false_type {};
|
|
template <auto Member>
|
|
struct Is_Field_Descriptor<Field_Descriptor<Member>> : std::true_type {};
|
|
template <class T>
|
|
concept Field_Descriptor_Type = Is_Field_Descriptor<std::remove_cvref_t<T>>::value;
|
|
template <auto Member>
|
|
auto field(std::string name) {
|
|
return Field_Descriptor<Member>(std::move(name));
|
|
}
|
|
template <auto Member>
|
|
auto field(std::string name, std::string label) {
|
|
return Field_Descriptor<Member>(std::move(name), std::move(label));
|
|
}
|
|
struct No_Object_Validator {
|
|
template <class T>
|
|
void operator()(const T&) const noexcept {}
|
|
};
|
|
struct Object_List_Options {
|
|
std::string id_label{"ID"};
|
|
std::string create_label{"Create"};
|
|
std::string edit_label{"Edit"};
|
|
std::string delete_label{"Delete"};
|
|
std::string actions_label{"Actions"};
|
|
std::string confirm_label{"Confirm Changes"};
|
|
std::string delete_confirm{"Delete this record?"};
|
|
std::string view_status_label{"View status ▾"};
|
|
std::string management_label;
|
|
std::string default_order_by;
|
|
std::string default_order_dir{"asc"};
|
|
bool user_reorderable_{};
|
|
bool column_reorderable_{true};
|
|
};
|
|
template <class T, class Validator, Field_Descriptor_Type... Fields>
|
|
class Object_Descriptor {
|
|
public:
|
|
using object_type = T;
|
|
using validator_type = Validator;
|
|
Object_Descriptor(std::string name, std::string label, Validator validator, std::tuple<Fields...> fields, Object_List_Options list_options = {}) : name_(std::move(name)), label_(std::move(label)), validator_(std::move(validator)), fields_(std::move(fields)), list_options_(std::move(list_options)) {}
|
|
template <class New_Validator>
|
|
auto validator(New_Validator value) const {
|
|
return Object_Descriptor<T, New_Validator, Fields...>(name_, label_, std::move(value), fields_, list_options_);
|
|
}
|
|
Object_Descriptor label(std::string value) const {
|
|
auto result = *this;
|
|
result.label_ = std::move(value);
|
|
return result;
|
|
}
|
|
Object_Descriptor id_label(std::string value) const {
|
|
auto result = *this;
|
|
result.list_options_.id_label = std::move(value);
|
|
return result;
|
|
}
|
|
Object_Descriptor create_label(std::string value) const {
|
|
auto result = *this;
|
|
result.list_options_.create_label = std::move(value);
|
|
return result;
|
|
}
|
|
Object_Descriptor edit_label(std::string value) const {
|
|
auto result = *this;
|
|
result.list_options_.edit_label = std::move(value);
|
|
return result;
|
|
}
|
|
Object_Descriptor delete_label(std::string value) const {
|
|
auto result = *this;
|
|
result.list_options_.delete_label = std::move(value);
|
|
return result;
|
|
}
|
|
Object_Descriptor actions_label(std::string value) const {
|
|
auto result = *this;
|
|
result.list_options_.actions_label = std::move(value);
|
|
return result;
|
|
}
|
|
Object_Descriptor confirm_label(std::string value) const {
|
|
auto result = *this;
|
|
result.list_options_.confirm_label = std::move(value);
|
|
return result;
|
|
}
|
|
Object_Descriptor delete_confirm(std::string value) const {
|
|
auto result = *this;
|
|
result.list_options_.delete_confirm = std::move(value);
|
|
return result;
|
|
}
|
|
Object_Descriptor view_status_label(std::string value) const {
|
|
auto result = *this;
|
|
result.list_options_.view_status_label = std::move(value);
|
|
return result;
|
|
}
|
|
Object_Descriptor management_label(std::string value) const {
|
|
auto result = *this;
|
|
result.list_options_.management_label = std::move(value);
|
|
return result;
|
|
}
|
|
Object_Descriptor default_sort(std::string field_name, bool descending = false) const {
|
|
auto result = *this;
|
|
result.list_options_.default_order_by = std::move(field_name);
|
|
result.list_options_.default_order_dir = descending ? "desc" : "asc";
|
|
return result;
|
|
}
|
|
Object_Descriptor user_reorderable(bool value = true) const {
|
|
auto result = *this;
|
|
result.list_options_.user_reorderable_ = value;
|
|
return result;
|
|
}
|
|
Object_Descriptor column_reorderable(bool value = true) const {
|
|
auto result = *this;
|
|
result.list_options_.column_reorderable_ = value;
|
|
return result;
|
|
}
|
|
const std::string& name() const noexcept {
|
|
return name_;
|
|
}
|
|
const std::string& label() const noexcept {
|
|
return label_;
|
|
}
|
|
const Validator& object_validator() const noexcept {
|
|
return validator_;
|
|
}
|
|
const std::tuple<Fields...>& fields() const noexcept {
|
|
return fields_;
|
|
}
|
|
const Object_List_Options& list_options() const noexcept {
|
|
return list_options_;
|
|
}
|
|
private:
|
|
std::string name_;
|
|
std::string label_;
|
|
Validator validator_;
|
|
std::tuple<Fields...> fields_;
|
|
Object_List_Options list_options_;
|
|
};
|
|
template <class T, Field_Descriptor_Type... Fields>
|
|
auto object(std::string name, Fields... fields) {
|
|
static_assert((std::same_as<typename Fields::owner_type, T> && ...));
|
|
const auto label = make_label(name);
|
|
return Object_Descriptor<T, No_Object_Validator, Fields...>(std::move(name), label, No_Object_Validator{}, std::tuple<Fields...>(std::move(fields)...));
|
|
}
|
|
template <class T, Field_Descriptor_Type... Fields>
|
|
auto object(std::string name, std::string label, Fields... fields) {
|
|
static_assert((std::same_as<typename Fields::owner_type, T> && ...));
|
|
return Object_Descriptor<T, No_Object_Validator, Fields...>(std::move(name), std::move(label), No_Object_Validator{}, std::tuple<Fields...>(std::move(fields)...));
|
|
}
|
|
template <Described_Type T>
|
|
auto describe() {
|
|
return Type_Descriptor<std::remove_cvref_t<T>>::get();
|
|
}
|
|
}
|
|
#define ADMINIVE_FIELD(Type, Member) ::adminive::field<&Type::Member>(#Member)
|
|
#define ADMINIVE_FIELD_LABEL(Type, Member, Label) ::adminive::field<&Type::Member>(#Member, Label)
|