ouczbs/zengine-old
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rebuild refl

Browse Source
This commit is contained in:
ouczbs 2024-04-19 22:02:27 +08:00
parent 76d865b2c2
commit 545a72a5de
16 changed files with 371 additions and 315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
engine/3rdparty/zlib/include/refl/detail/any.h vendored Normal file
View File

@ -0,0 +1,60 @@
#pragma once
#include "type.h"
namespace refl {
class UClass;
//生命周期短，适用于传参，不建议保存数据
//只能指向指针，引用=>指针，指针=>指针，T => T*,T的类型丢失
struct Any {
public:
const void* ptr;
const UClass* cls;
constexpr Any(const void* ptr,const UClass* cls) : ptr(ptr), cls(cls) {}
constexpr Any() : ptr(nullptr), cls(nullptr) {}
//右值=>右值压入栈，caller入栈地址
//左值=>caller变量地址
template<typename T>
constexpr Any(T&& v) : ptr(&v), cls(&TypeInfo<args_type_t<T>*>::StaticClass) {
if constexpr (std::is_same_v<args_type_t<T>, Any>) {
ptr = v.ptr;
cls = v.cls;
}
}
template<typename T>
constexpr Any(T* v) : ptr(v), cls(&TypeInfo<args_type_t<T>*>::StaticClass) {
if constexpr (std::is_same_v<args_type_t<T>, Any>) {
ptr = v->ptr;
cls = v->cls;
}
}
template<typename T>//参数 T* => T*
constexpr inline T cast_to() const {
if constexpr (std::is_pointer_v<T>) {
return (T)ptr;
}
else if constexpr (std::is_reference_v<T>) {
using RT = std::remove_reference_t<T>;
return *(RT*)ptr;
}
else {
return *(T*)ptr;
}
}
template<typename T>
T cast_ret() const {
if constexpr (std::is_pointer_v<T>) {
return *(T*)ptr;
}
else if constexpr (std::is_reference_v<T>) {
using RT = std::remove_reference_t<T>;
return **(RT**)ptr;
}
else {
return *(T*)ptr;
}
}
Any* ConvertTo(const UClass* toClass);
constexpr bool IsValid() const{
return cls != nullptr && ptr != nullptr;
}
};
}

113
engine/3rdparty/zlib/include/refl/detail/field.h vendored
View File

@ -1,21 +1,29 @@
#pragma once
#include "UTemplate/Type.hpp"
#include "../std/sarray.h"
#include "any.h"
#include <variant>
#include <functional>
using Ubpa::Name;
using Ubpa::type_name;
namespace refl {
class UClass;
class ArgsView;
class ArgsValue;
using Offset = uint32_t;
using Method = void*;
using DefaultMember = const ArgsView (*)();
using DefaultMethod = std::pair<ArgsView*, int>(*)();
struct MemberData {
Offset offset;
Any value;
Any meta;
constexpr MemberData() :offset(0), value(), meta() {}
constexpr MemberData(Offset offset,const Any& value,const Any& meta) : offset(offset), value(value), meta(meta) {}
};
struct MethodData {
Method fptr;
sarray<Any> value;
Any meta;
constexpr MethodData() :fptr(nullptr), value(), meta() {}
constexpr MethodData(Method fptr,const sarray<Any>& value, const Any& meta) : fptr(fptr), value(value), meta(meta) {}
};
enum FieldFlag:uint32_t {
FIELD_NONE_FLAG = 0,
FIELD_MEMBER_FLAG = 1 << 0,
@ -27,99 +35,28 @@ namespace refl {
struct FieldPtr {
union Data
{
Offset offset;
Method method;
constexpr Data() : method(nullptr) {}
constexpr Data(Offset& offset) : offset(offset) {}
constexpr Data(Method& method) : method(method) {}
constexpr Data(const Method& method) : method(method) {}
};
union Default {
DefaultMember member;
DefaultMethod method;
constexpr Default(): method(nullptr) {}
constexpr Default(DefaultMember& member) : member(member) {}
constexpr Default(DefaultMethod& method) : method(method) {}
MemberData member;
MethodData method;
constexpr Data() : member() {};
constexpr Data(const MemberData& member) :member(member) {}
constexpr Data(const MethodData& method) : method(method) {}
constexpr Data(Offset offset) :member(offset, {}, {}) {}
constexpr Data(Offset offset, const Any& value, const Any& meta):member(offset, value, meta){}
constexpr Data(Method fptr, const sarray<Any>& value, const Any& meta) : method(fptr, value, meta) {}
};
Name name;
const UClass* type{};
Data data{};
Default value{};
uint32_t flag{};
//unsafe
bool Invoke(const sarray<ArgsView>& ArgsList)const;
bool Invoke(const sarray<Any>& ArgsList)const;
//safe
bool Invoke(svector<ArgsView>& ArgsList)const;
bool Invoke(svector<Any>& ArgsList)const;
template<typename Func, typename... Args>
auto Call(Func func, Args&&... args)const;
sarray<const UClass*> GetParams() const;
};
template<typename T, typename R, typename ...Args>
consteval auto fetch_method_t(R(T::*)(Args...)) {
using MethodType = R(*)(const void*, Args...);
return MethodType{ nullptr };
}
template<typename R, typename ...Args>
consteval auto fetch_method_t(R(*)(Args...)) {
using MethodType = R(*)(Args...);
return MethodType{ nullptr };
}
template<typename T>
consteval int fetch_args_size() {
auto fields = T::__MakeStaticFields();
int size = 0;
for (auto& field : fields) {
size += field.data.offset;
}
return size;
}
template<typename T>
class Field;
/*
template<typename T, typename V>
consteval V* fetch_member_v(V T::*) {
return nullptr;
}
template<typename R, typename T, typename ...Args>
consteval auto fetch_method_v(R (T::* ptr)(Args...)) {
using MethodType = R(*)(T*, Args...);
return MethodType{nullptr};
}
template<typename R, typename ...Args>
consteval auto fetch_method_v(R(*ptr)(Args...)) {
return ptr;
}
template<typename... Args>
consteval auto FetchMembers(const std::tuple<Args...>&) {
return std::make_tuple(fetch_member_v(Args{nullptr})...);
}
template<typename... Args>
consteval auto FetchMethods(const std::tuple<Args...>&) {
return std::make_tuple(fetch_method_v(Args{ nullptr })...);
}
template<typename ...Args>
class FieldMembers{
public:
constexpr FieldMembers() {}
FieldMembers(const std::tuple<Args*...>&) {
}
constexpr static int GetSize() {
return sizeof...(Args);
}
};
template<typename ...Args>
class FieldMethods{
public:
constexpr FieldMethods() {}
FieldMethods(const std::tuple<Args*...>&) {
}
constexpr static int GetSize() {
return sizeof...(Args);
}
};*/
}

59
engine/3rdparty/zlib/include/refl/detail/field.inl vendored
View File

@ -4,24 +4,25 @@ namespace refl {
inline auto FieldPtr::Call(Func func, Args&& ...args)const
{
using MemberFunc = decltype(fetch_method_t(func));
MemberFunc fptr = (MemberFunc)data.method;
MemberFunc fptr = (MemberFunc)data.method.fptr;
return fptr(std::forward<Args>(args)...);
}
bool FieldPtr::Invoke(const sarray<ArgsView>& ArgsList)const{
bool FieldPtr::Invoke(const sarray<Any>& ArgsList)const{
auto Call = type->vtable.Call;
if (Call) {
Call(this, ArgsList);
}
return Call;
}
bool FieldPtr::Invoke(svector<ArgsView>& ArgsList)const {
bool FieldPtr::Invoke(svector<Any>& ArgsList)const {
auto Call = type->vtable.Call;
if (Call) {
auto params = GetParams();
sarray<const UClass*> params = GetParams();
int paramsSize = params.size();
int argsSize = ArgsList.size();
if (argsSize < paramsSize && flag & FIELD_METHOD_VALUE_FLAG) {
auto [argsPtr, valueSize] = value.method();
const Any* argsPtr = data.method.value.front();
int valueSize = data.method.value.size();
if (argsSize + valueSize >= paramsSize) {
for (int i = valueSize + argsSize - paramsSize; i < valueSize; i++) {
ArgsList.push_back(*(argsPtr + i));
@ -32,8 +33,7 @@ namespace refl {
if (argsSize < paramsSize) {
return false;
}
auto a = ArgsList.front();
Any* a = ArgsList.front();
auto p = params.front();
for (auto e = params.back(); p < e; ++p, ++a) {
if (a->cls != *p && !a->ConvertTo(*p)) {
@ -51,49 +51,4 @@ namespace refl {
}
return{};
}
template<typename T>
class Field {
public:
inline static char s_data[fetch_args_size<T>()]{};
inline static int s_index{0};
template<typename V>
static FieldPtr MakeField(V T::* ptr, Name name)
{
FieldPtr::Default value;
Offset offset = reinterpret_cast<std::size_t>(&(reinterpret_cast<const T*>(0)->*ptr));
FieldPtr::Data member = { offset };
constexpr uint32_t flag = FIELD_MEMBER_FLAG | FIELD_ATTRIBUTE_FLAG;
return { name, &TypeInfo<V>::StaticClass, member, value, flag };
}
template<typename R, typename ...Args>
static FieldPtr MakeField(R(*ptr)(Args...), Name name, const sarray<ArgsValue>& args = {}) {
uint32_t flag = FIELD_METHOD_FLAG;
FieldPtr::Default value;
if (args.size() > 0) {
flag |= FIELD_METHOD_VALUE_FLAG;
static const ArgsValueList argsValue(args, &Field<T>::s_data[Field<T>::s_index]);
Field<T>::s_index += ArgsValueList::GetArgsSize(args);
value.method = []() ->std::pair<ArgsView*, int> {
return { argsValue.ptr , argsValue.num };
};
}
FieldPtr::Data method = { *(Method*)&ptr };
return { name, &TypeInfo<real_type_t<R>(*)(real_type_t<Args>...)>::StaticClass, method, value, flag };
}
template<typename R, typename ...Args>
static FieldPtr MakeField(R(T::* ptr)(Args...), Name name, const sarray<ArgsValue>& args = {}) {
uint32_t flag = FIELD_MEMBER_FLAG | FIELD_METHOD_FLAG;
FieldPtr::Default value;
if (args.size() > 0) {
flag |= FIELD_METHOD_VALUE_FLAG;
static const ArgsValueList argsValue(args, &s_data[s_index]);
s_index += ArgsValueList::GetArgsSize(args);
value.method = []() ->std::pair<ArgsView*, int> {
return { argsValue.ptr , argsValue.num };
};
}
FieldPtr::Data method = { *(Method*)&ptr };
return { name, &TypeInfo<real_type_t<R>(*)(const void*,real_type_t<Args>...)>::StaticClass, method, value,flag };
}
};
}

45
engine/3rdparty/zlib/include/refl/detail/meta.h vendored Normal file
View File

@ -0,0 +1,45 @@
#pragma once
#include "field.h"
namespace refl {
template<typename T, typename R, typename ...Args>
consteval auto fetch_method_t(R(T::*)(Args...)) {
using MethodType = R(*)(const void*, Args...);
return MethodType{ nullptr };
}
template<typename R, typename ...Args>
consteval auto fetch_method_t(R(*)(Args...)) {
using MethodType = R(*)(Args...);
return MethodType{ nullptr };
}
template<typename T>
consteval int fetch_meta_size() {
auto fields = T::__MakeStaticFields();
int size = 0;
for (auto& field : fields) {
size += field.data.member.offset;
}
return size;
}
enum MetaFlag :uint32_t {
META_NONE_FLAG = 0,
META_SERIZLE_FLAG = 1 << 0,
META_UI_FLAG = 1 << 0,
};
class UClass;
class MemberDataValue;
class MethodDataValue;
class Meta {
public:
UClass* cls;
uint32_t flag{ 0 };
template<typename T, typename Obj>
static FieldPtr MemberField(T Obj::* ptr, const Name& name, char*& memory, const MemberDataValue& data = {});
template<typename R, typename ...Args>
static FieldPtr MethodField(R(*ptr)(Args...), const Name& name,char*& memory, const MethodDataValue& data = {});
template<typename T,typename R, typename ...Args>
static FieldPtr MethodField(R(T::*ptr)(Args...), const Name& name,char*& memory, const MethodDataValue& data = {});
};
}

70
engine/3rdparty/zlib/include/refl/detail/meta.inl vendored Normal file
View File

@ -0,0 +1,70 @@
#pragma once
#include "meta.h"
#include "uclass.h"
namespace refl {
template<typename T, typename Obj>
inline FieldPtr Meta::MemberField(T Obj::* ptr, const Name& name, char*& memory, const MemberDataValue& data)
{
MemberData member;
member.offset = reinterpret_cast<std::size_t>(&(reinterpret_cast<const Obj*>(0)->*ptr));
if (AnyValue arg = data.value; arg.IsValid()) {
arg.type->InitObject(memory);
arg.type->CopyObject(memory, arg.ptr);
member.value = Any(memory, arg.cls).ConvertTo(&TypeInfo<real_type_t<T>*>::StaticClass);
memory += arg.type->size;
}
if (AnyValue arg = data.meta; arg.IsValid()) {
arg.type->InitObject(memory);
arg.type->CopyObject(memory, arg.ptr);
member.meta = Any(memory, arg.cls);
memory += arg.type->size;
}
constexpr uint32_t flag = FIELD_MEMBER_FLAG | FIELD_ATTRIBUTE_FLAG;
return { name, &TypeInfo<T>::StaticClass, member,flag};
}
template<typename R, typename ...Args>
inline FieldPtr Meta::MethodField(R(*ptr)(Args...), const Name& name, char*& memory, const MethodDataValue& data)
{
MethodData method;
uint32_t flag = FIELD_METHOD_FLAG;
auto cls = &TypeInfo<real_type_t<R>(*)(real_type_t<Args>...)>::StaticClass;
if (auto& args = data.value; !args.empty()) {
flag |= FIELD_METHOD_VALUE_FLAG;
AnyValueList argsValue(args, memory);
argsValue.ConvertArgs(cls->vtable.GetParams(cls));
method.value = argsValue.ToSArray();
memory += AnyValueList::GetArgsSize(args);
}
if (AnyValue arg = data.meta; arg.IsValid()) {
arg.type->InitObject(memory);
arg.type->CopyObject(memory, arg.ptr);
method.meta = Any(memory, arg.cls);
memory += arg.type->size;
}
method.fptr = { *(Method*)&ptr };
return { name, cls, method,flag };
}
template<typename T, typename R, typename ...Args>
inline FieldPtr Meta::MethodField(R(T::*ptr)(Args...),const Name& name, char*& memory, const MethodDataValue& data)
{
MethodData method;
uint32_t flag = FIELD_MEMBER_FLAG | FIELD_METHOD_FLAG;
auto cls = &TypeInfo<real_type_t<R>(*)(const void*, real_type_t<Args>...)>::StaticClass;
if (auto& args = data.value; !args.empty()) {
flag |= FIELD_METHOD_VALUE_FLAG;
AnyValueList argsValue(args, memory);
argsValue.ConvertArgs(cls->vtable.GetParams(cls));
method.value = argsValue.ToSArray();
memory += AnyValueList::GetArgsSize(args);
}
if (AnyValue arg = data.meta; arg.IsValid()) {
arg.type->InitObject(memory);
arg.type->CopyObject(memory, arg.ptr);
method.meta = Any(memory, arg.cls);
memory += arg.type->size;
}
method.fptr = { *(Method*)&ptr };
return { name, cls, method,flag };
}
}

6
engine/3rdparty/zlib/include/refl/detail/type.h vendored
View File

@ -1,10 +1,13 @@
#pragma once
#include <type_traits>
namespace refl {
template <class T>
concept _ReflCheck_Meta = requires { typename T::MyStatic; typename T::MyUClass;};
template <class T>
concept _ReflCheck_Ctor = requires { T(); };
template <class T>
concept _ReflCheck_UClass = requires { !std::is_void_v<decltype(T::__MakeFields())>; };
concept _ReflCheck_UClass = _ReflCheck_Meta<typename T::MyMeta>;
template <class T>
concept _ReflCheck_Ctor_NoUClass = _ReflCheck_Ctor<T> && !_ReflCheck_UClass<T>;
@ -34,6 +37,7 @@ namespace refl {
struct real_type<T*> {
using type = std::remove_cv_t<T>*;
};
template<typename T>
using real_type_t = real_type<T>::type;

7
engine/3rdparty/zlib/include/refl/detail/uclass.h vendored
View File

@ -1,7 +1,7 @@
#pragma once
#include "type.h"
#include "field.h"
#include "view.h"
#include "meta.h"
namespace refl {
enum ClassFlag :uint32_t {
CLASS_NONE_FLAG = 0,
@ -15,7 +15,7 @@ namespace refl {
//function
sarray<const UClass*>(*GetParams)(const UClass*);
//function
void (*Call)(const FieldPtr*, const sarray<ArgsView>& ArgsList);
void (*Call)(const FieldPtr*, const sarray<Any>& ArgsList);
//object
void (*InitObject)(void*);
@ -28,11 +28,12 @@ namespace refl {
uint32_t size;
uint32_t flag{0};
const UClass* parent;
Meta* meta{nullptr};
vtable_uclass vtable{};
public:
constexpr UClass(std::string_view name, uint32_t size, const UClass* parent = nullptr)
:name(name), size(size), parent(parent){}
ObjectView New(void* ptr = nullptr) const{
AnyView New(void* ptr = nullptr) const{
if (ptr == nullptr) {
ptr = malloc(size);
InitObject(ptr);

14
engine/3rdparty/zlib/include/refl/detail/uclass.inl vendored
View File

@ -48,19 +48,19 @@ namespace refl {
//这里顺序似乎是不确定的，但是我实际运用是对的
//如果使用make_index_sequence,会多一次函数调用
//为什么包裹一层迭代器，就不会出现警告了
static void Call(const FieldPtr* field, const sarray<ArgsView>& ArgsList) {
static void Call(const FieldPtr* field, const sarray<Any>& ArgsList) {
assert(sizeof...(Args) <= ArgsList.size());
if constexpr (std::is_same_v<R, void>) {
MethodType fptr = (MethodType)field->data.method;
MethodType fptr = (MethodType)field->data.method.fptr;
auto param = ArgsList.end();
fptr((param--->cast_to<Args>())...);
}
else {
MethodType fptr = (MethodType)field->data.method;
MethodType fptr = (MethodType)field->data.method.fptr;
auto param = ArgsList.end();
auto ret = ArgsList.front();
if (ret->cls == &TypeInfo<R*>::StaticClass) {
*(R*)ret->val = fptr((param--->cast_to<Args>())...);
*(R*)ret->ptr = fptr((param--->cast_to<Args>())...);
}
else {
fptr((param--->cast_to<Args>())...);
@ -91,8 +91,8 @@ namespace refl {
template<typename T, typename P = void>
class UClass_Meta : public UClass {
public:
using FieldsType = decltype(T::__MakeFields());
FieldsType Fields{ T::__MakeFields() };
using FieldsType = decltype(T::MyMeta::__MakeFields());
FieldsType Fields{ T::MyMeta::__MakeFields() };
UClass_Meta() : UClass(type_name<T>().View(), sizeof(T)){
if constexpr (std::is_trivially_copyable_v<T>) {
flag = CLASS_TRIVIAL_FLAG;
@ -140,7 +140,7 @@ namespace refl {
};
template<_ReflCheck_UClass T>
struct TypeInfoImpl<T> {
using MyUClass = typename T::MyUClass;
using MyUClass = typename T::MyMeta::MyUClass;
inline static MyUClass StaticClass = MyUClass();
};
}

91
engine/3rdparty/zlib/include/refl/detail/view.h vendored
View File

@ -1,77 +1,42 @@
#pragma once
#include <string>
#include "type.h"
#include "field.h"
namespace refl {
class UClass;
class FieldPtr;
//生命周期短，适用于传参，不建议保存数据
//只能指向指针，引用=>指针，指针=>指针，T => T*,T的类型丢失
struct ArgsView {
public:
const void* val;
const UClass* cls;
constexpr ArgsView() : val(nullptr), cls(nullptr) {}
//右值=>右值压入栈，caller入栈地址
//左值=>caller变量地址
template<typename T>
constexpr ArgsView(T&& v): val(&v), cls(&TypeInfo<args_type_t<T>*>::StaticClass){
if constexpr (std::is_same_v<args_type_t<T>, ArgsView>) {
val = v.val;
cls = v.cls;
}
}
template<typename T>
constexpr ArgsView(T* v) : val(v), cls(&TypeInfo<args_type_t<T>*>::StaticClass) {
}
template<typename T>//参数 T* => T*
constexpr inline T cast_to() const {
if constexpr (std::is_pointer_v<T>) {
return (T)val;
}
else if constexpr (std::is_reference_v<T>){
using RT = std::remove_reference_t<T>;
return *(RT*)val;
}else{
return *(T*)val;
}
}
template<typename T>
T cast_ret() const {
if constexpr (std::is_pointer_v<T>) {
return *(T*)val;
}
else if constexpr (std::is_reference_v<T>) {
using RT = std::remove_reference_t<T>;
return **(RT**)val;
}
else {
return *(T*)val;
}
}
bool ConvertTo(const UClass* toClass);
};
//存入的是真实的数据类型,type用于拷贝数据
struct ArgsValue : public ArgsView {
struct AnyValue : public Any {
const UClass* type;
constexpr AnyValue() :Any(), type(nullptr) {}
template<typename T>
constexpr ArgsValue(T&& t) : ArgsView(t), type(&TypeInfo<args_type_t<T>>::StaticClass){}
constexpr AnyValue(T&& t) : Any(t), type(&TypeInfo<args_type_t<T>>::StaticClass){}
};
struct ArgsValueList{
struct MemberDataValue {
Offset offset{0};
AnyValue value;
AnyValue meta;
constexpr MemberDataValue() :value(), meta() {}
constexpr MemberDataValue(const AnyValue& value, const AnyValue& meta = {}) : value(value), meta(meta) {}
};
struct MethodDataValue {
Method fptr{nullptr};
sarray<AnyValue> value;
AnyValue meta;
constexpr MethodDataValue() :value(), meta() {}
constexpr MethodDataValue(const sarray<AnyValue>& value, const AnyValue& meta = {}) : value(value), meta(meta) {}
};
struct AnyValueList{
void* data;
ArgsView* ptr;
int num;
bool isMemoryOwner{false};
ArgsValueList(const sarray<ArgsValue>& args,void* memory = nullptr);
~ArgsValueList();
constexpr static int GetArgsSize(const sarray<ArgsValue>& args);
AnyValueList(const sarray<AnyValue>& args,void* memory = nullptr);
~AnyValueList();
void ConvertArgs(sarray<const UClass*> params);
const sarray<Any> ToSArray();
constexpr static int GetArgsSize(const sarray<AnyValue>& args);
};
class ObjectView {
class AnyView : public Any{
public:
const void* ptr;
const UClass* cls;
const FieldPtr* cache{ nullptr };
ObjectView(const void* ptr, const UClass* cls) : ptr(ptr), cls(cls) {}
AnyView(const void* ptr, const UClass* cls) : Any(ptr,cls) {}
public:
template<typename T>
@ -80,10 +45,10 @@ namespace refl {
template<typename T>
bool Set(const Name& name, const T& t);
bool Invoke(const Name& name,const sarray<ArgsView>& ArgsList);//这里是内存分配慢呀，这里是可以改成栈容器的
bool Invoke(const Name& name,const sarray<Any>& ArgsList);
bool Invoke(const Name& name,svector<ArgsView>& ArgsList);
bool Invoke(const Name& name,svector<Any>& ArgsList);
ObjectView Parent();
AnyView Parent();
};
}

62
engine/3rdparty/zlib/include/refl/detail/view.inl vendored
View File

@ -8,45 +8,49 @@ namespace refl {
* 对象从大到小
*/
using enum ClassFlag;
bool ArgsView::ConvertTo(const UClass* toClass) {
Any* Any::ConvertTo(const UClass* toClass) {
if (cls == toClass) {
return this;
}
//子类转父类
if (cls->IsChildOf(toClass)) {
cls = toClass;
return true;
return this;
}
if (cls->flag & CLASS_TRIVIAL_FLAG && toClass->flag & CLASS_TRIVIAL_FLAG) {
cls = toClass;
return true;
return this;
}
return false;
return nullptr;
}
ArgsValueList::ArgsValueList(const sarray<ArgsValue>& args, void* memory)
: ptr((ArgsView*)memory),data(memory), num(args.size())
AnyValueList::AnyValueList(const sarray<AnyValue>& args, void* memory)
: data(memory), num(args.size())
{
if (!memory) {
isMemoryOwner = true;
data = malloc(GetArgsSize(args));
ptr = (ArgsView*)data;
assert(data != nullptr);
}
char* pData = ((char*)data) + num * sizeof(ArgsView);
Any* any = (Any*)data;
assert(any != nullptr);
char* pData = ((char*)data) + num * sizeof(Any);
for (auto& arg : args) {
arg.type->InitObject(pData);
arg.type->CopyObject(pData, arg.val);
ptr->val = pData;
ptr->cls = arg.cls;
ptr++;
arg.type->CopyObject(pData, arg.ptr);
any->ptr = pData;
any->cls = arg.cls;
any++;
pData += arg.type->size;
}
ptr = (ArgsView*)data;
}
inline ArgsValueList::~ArgsValueList()
inline AnyValueList::~AnyValueList()
{
if (num == 0 || !data) {
return;
}
Any* ptr = (Any*)data;
for (int i = 0; i < num; i++) {
ptr->cls->DestObject((void*)ptr->val);
ptr->cls->DestObject((void*)ptr->ptr);
ptr++;
}
if (isMemoryOwner) {
free(data);
@ -54,16 +58,28 @@ namespace refl {
num = 0;
data = nullptr;
}
inline constexpr int ArgsValueList::GetArgsSize(const sarray<ArgsValue>& args)
inline void AnyValueList::ConvertArgs(sarray<const UClass*> params)
{
int size = args.size() * sizeof(ArgsView);
Any* ptr = (Any*)data;
int first = params.size() - num;
for (int i = 0; i < num; i++, ptr++) {
ptr->ConvertTo(*params.at(first + i));
}
}
inline const sarray<Any> AnyValueList::ToSArray()
{
return sarray<Any>((Any*)data, num);
}
inline constexpr int AnyValueList::GetArgsSize(const sarray<AnyValue>& args)
{
int size = args.size() * sizeof(Any);
for (auto& arg : args) {
size += arg.type->size;
}
return size;
}
template<typename T>
inline bool ObjectView::Get(const Name& name, T& t)
inline bool AnyView::Get(const Name& name, T& t)
{
if (cache && cache->name == name) {
_cache_get: bool isChild = cache->type->IsChildOf<T>(true);
@ -83,7 +99,7 @@ namespace refl {
return false;
}
template<typename T>
inline bool ObjectView::Set(const Name& name, const T& t)
inline bool AnyView::Set(const Name& name, const T& t)
{
if (cache && cache->name == name) {
_cache_set: bool isChild = cache->type->IsChildOf<T>(true);
@ -102,7 +118,7 @@ namespace refl {
}
return false;
}
bool ObjectView::Invoke(const Name& name,const sarray<ArgsView>& ArgsList)
bool AnyView::Invoke(const Name& name,const sarray<Any>& ArgsList)
{
auto field = cls->GetField(name, 0);
if (!field) {
@ -113,7 +129,7 @@ namespace refl {
}
return field->Invoke(ArgsList);
}
bool ObjectView::Invoke(const Name& name, svector<ArgsView>& ArgsList)
bool AnyView::Invoke(const Name& name, svector<Any>& ArgsList)
{
auto field = cls->GetField(name, 0);
if (!field) {
@ -124,7 +140,7 @@ namespace refl {
}
return field->Invoke(ArgsList);
}
ObjectView ObjectView::Parent() {
AnyView AnyView::Parent() {
return { ptr, cls ? cls->parent : nullptr };
}
}

38
engine/3rdparty/zlib/include/refl/macro.h vendored
View File

@ -1,35 +1,3 @@
#pragma once
/*
#define REGISTER_CLASS(cls) using _T = cls;
#define MAKE_STATIC_FIELD(member, ...) \
MakeStaticField(&_T::member, #member, __VA_ARGS__)
#define MAKE_FIELD(member, ...) \
Field<_T>::MakeField(&_T::member, #member, __VA_ARGS__)
#define REGISTER_FIELDS()\
consteval static auto __MakeStaticFields() {\
return std::array{\
MAKE_FIELD_LIST(MAKE_STATIC_FIELD)\
};\
}\
static auto __MakeFields() {\
return std::array{\
MAKE_FIELD_LIST(MAKE_FIELD)\
};\
}
#define MAKE_FIELD_LIST(MACRO) \
MACRO(x), \
MACRO(y), \
MACRO(z), \
MACRO(norm, {10,9}), \
MACRO(norm1, {1}), \
MACRO(norm2, {2}),
REGISTER_CLASS(vec3)
REGISTER_FIELDS()
#undef MAKE_FIELD_LIST
*/
#if !defined(__cppast)
#define __cppast(...)
#endif

53
engine/3rdparty/zlib/include/refl/refl.h vendored
View File

@ -2,37 +2,44 @@
#include "detail/uclass.inl"
#include "detail/view.inl"
#include "detail/field.inl"
#include "detail/meta.inl"
#include "std/sarray.h"
#include "macro.h"
namespace refl {
template<typename T, typename Obj>
consteval FieldPtr MakeStaticField(T Obj::* ptr, Name name) {
FieldPtr::Default value;
Offset offset = 0;
FieldPtr::Data member = { offset };
consteval FieldPtr StaticMemberField(T Obj::* ptr, const Name& name, const MemberDataValue& data = {}) {
Offset offset = data.value.IsValid() ? sizeof(T) : 0;
if (data.meta.IsValid()) {
offset += data.meta.type->size;
}
FieldPtr::Data member(offset);
constexpr uint32_t flag = FIELD_MEMBER_FLAG | FIELD_ATTRIBUTE_FLAG;
return { name, &TypeInfo<T>::StaticClass, member, value, flag };
return { name,&TypeInfo<T>::StaticClass, member,flag};
}
template<typename R, typename ...Args>
consteval FieldPtr MakeStaticField(R(*ptr)(Args...), Name name, const sarray<ArgsValue>& args = {}) {
consteval FieldPtr StaticMethodField(R(*ptr)(Args...), const Name& name, const MethodDataValue& data = {}) {
uint32_t flag = FIELD_METHOD_FLAG;
FieldPtr::Default value;
Offset offset = ArgsValueList::GetArgsSize(args);
FieldPtr::Data method = { offset };
return { name, &TypeInfo<real_type_t<R>(*)(real_type_t<Args>...)>::StaticClass, method, value, flag };
Offset offset = AnyValueList::GetArgsSize(data.value);
if (data.meta.IsValid()) {
offset += data.meta.type->size;
}
FieldPtr::Data method(offset);
return { name,&TypeInfo<real_type_t<R>(*)(real_type_t<Args>...)>::StaticClass,method, flag };
}
template<typename T, typename R, typename ...Args>
consteval FieldPtr MakeStaticField(R(T::* ptr)(Args...), Name name, const sarray<ArgsValue>& args = {}) {
consteval FieldPtr StaticMethodField(R(T::* ptr)(Args...), const Name& name, const MethodDataValue& data = {}) {
uint32_t flag = FIELD_MEMBER_FLAG | FIELD_METHOD_FLAG;
FieldPtr::Default value;
Offset offset = ArgsValueList::GetArgsSize(args);
FieldPtr::Data method = { offset };
return { name, &TypeInfo<real_type_t<R>(*)(const void*,real_type_t<Args>...)>::StaticClass, method, value,flag };
Offset offset = AnyValueList::GetArgsSize(data.value);
if (data.meta.IsValid()) {
offset += data.meta.type->size;
}
FieldPtr::Data method(offset);
return { name, &TypeInfo<real_type_t<R>(*)(const void*,real_type_t<Args>...)>::StaticClass,method,flag };
}
//用处不大---------------begin
template<typename T>
consteval int GetStaticFieldID(Name name) {
auto fields = T::__MakeStaticFields();
template<_ReflCheck_Meta T>
consteval int GetStaticFieldID(const Name& name) {
auto fields = T::MyStatic::__MakeStaticFields();
auto first = fields.begin();
for (auto& field : fields) {
if (field.name == name) {
@ -41,9 +48,9 @@ namespace refl {
}
return 0;
}
template<typename T>
template<_ReflCheck_Meta T>
consteval int GetStaticFieldID(bool(* fptr)(FieldPtr)) {
auto fields = T::__MakeStaticFields();
auto fields = T::MyStatic::__MakeStaticFields();
auto first = fields.begin();
for (auto& field : fields) {
if (fptr(field)) {
@ -52,15 +59,15 @@ namespace refl {
}
return 0;
}
template<typename T, auto name>
template<_ReflCheck_Meta T, auto name>
consteval auto GetStaticField() {
constexpr auto fields = T::__StaticFields();
constexpr auto fields = T::MyMeta::__StaticFields();
using AutoType = decltype(name);
if constexpr (std::is_same_v<AutoType, int>) {
return std::get<name>(fields);
}
else {
constexpr auto id = GetStaticFieldID<T>(Name(name.Data()));
constexpr auto id = GetStaticFieldID<T>(name.Data());
return std::get<id>(fields);
}
}

3
engine/3rdparty/zlib/include/refl/std/sarray.h vendored
View File

@ -24,6 +24,9 @@ namespace refl {
}
return nullptr;
}
constexpr bool empty() const noexcept {
return m_count == 0;
}
constexpr int size() const noexcept {
return m_count;
}

3
engine/3rdparty/zlib/include/refl/std/svector.h vendored
View File

@ -23,6 +23,9 @@ namespace refl {
m_count++;
}
}
constexpr bool empty() const noexcept {
return m_count == 0;
}
constexpr int size() const noexcept {
return m_count;
}

48
engine/3rdparty/zlib/test/refl/vertex.h vendored
View File

@ -9,11 +9,20 @@ struct vec3_parent {
//cout << x2 << "vec3_parent::norm" << endl;
}
};
struct vec4 {
string name{ "hello" };
};
struct vec3_Meta;
struct vec3 : public vec3_parent {
using MyMeta = vec3_Meta;
__cppast(Meta = { 0.f})
float x = 1;
__cppast(Meta = { 0.f})
float y = 2;
__cppast(Meta = { 0.f})
float z = 3;
string name{ "hellohellohellohellohellohello" };
__cppast(Meta = { {3,4} })
int norm(int x1, int& x2)override {
int tmp = x1 * 2 + 1;
x1 = x2;
@ -36,29 +45,40 @@ struct vec3 : public vec3_parent {
x1 = x1 * 10;
cout << x1 << "::norm3" << endl;
}
using MyUClass = UClass_Meta<vec3, vec3_parent>;
};
struct vec3_Static_Meta {
//这里好像不需要
consteval static auto __StaticFields() {
return std::make_tuple(&vec3::x, &vec3::y, &vec3::z, &vec3::norm, &vec3::norm1, &vec3::norm2);
};
consteval static auto __MakeStaticFields() {
return std::array{
MakeStaticField(&vec3::x, "x"),
MakeStaticField(&vec3::y, "y"),
MakeStaticField(&vec3::z, "z"),
MakeStaticField(&vec3::norm, "norm", { 10,9 }),
MakeStaticField(&vec3::norm1, "norm1", { 10 }),
MakeStaticField(&vec3::norm2, "norm2", { 10 }),
StaticMemberField(&vec3::x, "x", {0.f,vec4{}}),
StaticMemberField(&vec3::y, "y", {0.f,{}}),
StaticMemberField(&vec3::z, "z", {0.f,{}}),
StaticMethodField(&vec3::norm, "norm", {{10,9},{}}),
StaticMethodField(&vec3::norm1, "norm1", {{10},{}}),
StaticMethodField(&vec3::norm2, "norm2", {{10},{}}),
};
}
consteval static int Size() {
return fetch_meta_size<vec3_Static_Meta>();
}
};
constexpr int size = vec3_Static_Meta::Size();
struct vec3_Meta : public Meta{
using MyStatic = vec3_Static_Meta;
using MyUClass = UClass_Meta<vec3, vec3_parent>;
inline static char s_data[MyStatic::Size()]{};
static auto __MakeFields() {
return std::array{
Field<vec3>::MakeField(&vec3::x, "x"),
Field<vec3>::MakeField(&vec3::y, "y"),
Field<vec3>::MakeField(&vec3::z, "z"),
Field<vec3>::MakeField(&vec3::norm, "norm", {10,9}),
Field<vec3>::MakeField(&vec3::norm1, "norm1", {10}),
Field<vec3>::MakeField(&vec3::norm2, "norm2", {10}),
char* memory = &s_data[0];
return std::array{
MemberField(&vec3::x, "x",memory, {0.f,vec4{}}),
MemberField(&vec3::y, "y",memory, {0.f,{}}),
MemberField(&vec3::z, "z",memory, {0.f,{}}),
MethodField(&vec3::norm, "norm", memory, {{10,9},{}}),
MethodField(&vec3::norm1, "norm1",memory, {{10},{}}),
MethodField(&vec3::norm2, "norm2",memory, {{10},{}}),
};
};
};

14
engine/3rdparty/zlib/test/refl_01.cpp vendored
View File

@ -2,31 +2,33 @@
#include <benchmark/benchmark.h>
auto cls = &TypeInfo<vec3>::StaticClass;
vec3 v;
constexpr int smeta = sizeof(vec3_Meta);
constexpr int scls = sizeof(decltype(*cls));
auto ov = cls->New((void*)&v);
constexpr Name func("norm");
void TestRefl1(benchmark::State& state) {
int x = 1, y = 2;
for (auto _ : state) {
std::array<ArgsView, 4> arr{&x, ov.ptr};
svector<ArgsView> svec(&arr.front(), arr.size(), 2);
std::array<Any, 4> arr{&x, ov.ptr};
svector<Any> svec(&arr.front(), arr.size(), 2);
ov.Invoke("norm", svec);
}
}
BENCHMARK(TestRefl1);
void TestRefl2(benchmark::State& state) {
int x = 1, y = 2;
constexpr auto id = GetStaticFieldID<vec3>(func);
constexpr auto id = GetStaticFieldID<vec3_Meta>(func);
auto field = cls->GetField(id);
for (auto _ : state) {
std::array<ArgsView, 4> arr{&x, ov.ptr};
svector<ArgsView> svec(&arr.front(), arr.size(), 2);
std::array<Any, 4> arr{&x, ov.ptr};
svector<Any> svec(&arr.front(), arr.size(), 2);
field->Invoke(svec);
}
}
BENCHMARK(TestRefl2);
void TestRefl3(benchmark::State& state) {
int x = 1, y = 2;
constexpr auto id = GetStaticFieldID<vec3>(func);
constexpr auto id = GetStaticFieldID<vec3_Meta>(func);
auto field = cls->GetField(id);
for (auto _ : state) {
field->Invoke({ &x,ov.ptr, x, y });