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

refl support tuple pair

Browse Source
This commit is contained in:
ouczbs 2024-06-24 22:26:09 +08:00
parent ead02af962
commit dd880d4972
4 changed files with 99 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -26,20 +26,22 @@ namespace refl {
return cls->vsize(ptr);
}
auto begin() {
auto it = cls->vbegin(ptr);
return iterator(it, cls);
Container::iterator it(cls);
cls->vbegin(it, ptr);
return it;
}
auto end() {
auto it = cls->vend(ptr);
return iterator(it, cls);
Container::iterator it(cls);
cls->vend(it, ptr);
return it;
}
// Iterator class
class iterator : public UClass_Container::iterator{
private:
const UClass_Container* cls;
public:
iterator(UClass_Container::iterator it,const UClass_Container* cls)
: UClass_Container::iterator(it), cls(cls) {}
iterator(const UClass_Container* cls)
: cls(cls) {}
iterator& operator++() noexcept {
cls->viterator_add(this);
return *this;

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

@ -107,16 +107,16 @@ namespace refl {
return cls;
}
};
constexpr static std::array<std::string_view, 16> IndexNames = {
"1", "2", "3", "4", "5", "6", "7", "8",
"9", "10", "11", "12", "13", "14", "15", "16"
};
template<typename... Types>
class UClass_Tuple : public UClass {
using UClass::UClass;
using MyUClass = UClass_Tuple<Types...>;
using MyTuple = std::tuple<Types...>;
public:
constexpr static std::array<std::string_view, 16> IndexNames = {
"1", "2", "3", "4", "5", "6", "7", "8",
"9", "10", "11", "12", "13", "14", "15", "16"
};
std::array<FieldPtr, sizeof...(Types)> Fields;
static bool construct(void* ptr, const UClass* cls, const sarray<Any>& ArgsList) {
new(ptr)MyTuple();
@ -125,11 +125,27 @@ namespace refl {
static void destruct(void* ptr) {
((MyTuple*)ptr)->~MyTuple();
}
template <typename T>
template <typename T, std::size_t Index>
static FieldPtr field_in_tuple() {
MemberData member;
constexpr uint32_t flag = FIELD_MEMBER_FLAG | FIELD_ATTRIBUTE_FLAG;
return { FName(""), &TypeInfo<T>::StaticClass, member, flag};
const MyTuple* tuple_ptr = nullptr;
const auto& element = std::get<Index>(*tuple_ptr);
const std::ptrdiff_t offset = reinterpret_cast<const char*>(&element) - reinterpret_cast<const char*>(tuple_ptr);
MemberData member;
member.offset = offset;
return { IndexNames[Index], &TypeInfo<T>::StaticClass, member, flag};
}
template <std::size_t... Is>
void BuildFields(std::index_sequence<Is...>) {
auto ptr = &Fields[0];
(..., (*ptr = field_in_tuple<Types, Is>(), ptr++));
}
UClass_Tuple():UClass(type_name<MyTuple>().View(), sizeof(MyTuple)) {
assert(sizeof...(Types) < IndexNames.size());
BuildFields(std::index_sequence_for<Types...>{});
vtable.Construct = &MyUClass::construct;
vtable.Destruct = &MyUClass::destruct;
vtable.GetFields = &MyUClass::GetFields;
}
const sarray<const FieldPtr> GetFields(EFieldFind find, const Name& name) const {
return sarray<const FieldPtr>(&Fields[0], sizeof...(Types));
@ -138,20 +154,51 @@ namespace refl {
auto cls = static_cast<const MyUClass*>(_cls);
return cls->GetFields(find, name);
}
UClass_Tuple():UClass(type_name<MyTuple>().View(), sizeof(MyTuple)) {
};
template<typename First,typename Second>
class UClass_Pair : public UClass {
using UClass::UClass;
using MyUClass = UClass_Tuple<First, Second>;
using MyPair = std::pair<First, Second>;
public:
std::array<FieldPtr, 2> Fields;
static bool construct(void* ptr, const UClass* cls, const sarray<Any>& ArgsList) {
new(ptr)MyPair();
return true;
}
static void destruct(void* ptr) {
((MyPair*)ptr)->~MyPair();
}
template<typename T, int Index>
static FieldPtr field_in_pair() {
constexpr uint32_t flag = FIELD_MEMBER_FLAG | FIELD_ATTRIBUTE_FLAG;
const MyPair* pair_ptr = nullptr;
MemberData member;
if constexpr (Index == 0) {
const auto& first = pair_ptr->first;
const std::ptrdiff_t offset = reinterpret_cast<const char*>(&first) - reinterpret_cast<const char*>(pair_ptr);
member.offset = offset;
}
else {
const auto& second = pair_ptr->second;
const std::ptrdiff_t offset = reinterpret_cast<const char*>(&second) - reinterpret_cast<const char*>(pair_ptr);
member.offset = offset;
}
return { IndexNames[Index], &TypeInfo<T>::StaticClass, member, flag };
}
UClass_Pair() :UClass(type_name<MyPair>().View(), sizeof(MyPair)) {
Fields[0] = field_in_pair<First, 0>();
Fields[1] = field_in_pair<Second, 1>();
vtable.Construct = &MyUClass::construct;
vtable.Destruct = &MyUClass::destruct;
vtable.GetFields = &MyUClass::GetFields;
auto ptr = &Fields[0];
(..., (*ptr = field_in_tuple<Types>(), ptr++));
Offset offset = 0;
constexpr int N = sizeof...(Types);
assert(N < IndexNames.size());
for (int i = 0; i < N; i++) {
Fields[i].name = IndexNames[i];
Fields[i].data.member.offset = offset;
offset += Fields[i].type->size;
}
}
const sarray<const FieldPtr> GetFields(EFieldFind find, const Name& name) const {
return sarray<const FieldPtr>(&Fields[0], 2);
}
static const sarray<const FieldPtr> GetFields(const UClass* _cls, EFieldFind find, const Name& name) {
auto cls = static_cast<const MyUClass*>(_cls);
return cls->GetFields(find, name);
}
};
class UClass_Container : public UClass {
@ -163,10 +210,10 @@ namespace refl {
};
//container
using size_impl = size_t(*)(const void*);
using to_iterator_impl = iterator(*)(const void*);
using to_iterator_impl = void(*)(iterator& ,const void*);
using insert_impl = void (*)(const void*, const void*);
//iterator
using iterator_impl = void* (*)(const void*);
using iterator_impl = void (*)(iterator*);
public:
size_impl vsize;
to_iterator_impl vbegin;
@ -189,8 +236,6 @@ namespace refl {
class UClass_Container_impl : public UClass_Container {
using UClass_Container::UClass_Container;
using MyUClass = UClass_Container_impl<T, value_type>;
using ToIteratorFunc = T::iterator(T::*)();
using IteratorFunc = T::iterator& (T::iterator::*)();
public:
static bool construct(void* ptr, const UClass* cls, const sarray<Any>& ArgsList) {
new(ptr)T();
@ -199,13 +244,25 @@ namespace refl {
static void destruct(void* ptr) {
((T*)ptr)->~T();
}
static iterator begin(const void* ptr) {
static void begin(iterator& pit,const void* ptr) {
auto it = ((T*)ptr)->begin();
return iterator{ *(void**)&it, &*it};
memcpy(&pit, &it, sizeof(it));
pit.val = &*it;
}
static iterator end(const void* ptr) {
static void end(iterator& pit, const void* ptr) {
auto it = ((T*)ptr)->end();
return iterator{ *(void**)&it, &*it };
memcpy(&pit, &it, sizeof(it));
pit.val = &*it;
}
static void add(iterator* pit) {
auto it = ++(*(T::iterator*)pit);
memcpy(pit, &it, sizeof(it));
pit->val = &*it;
}
static void sub(iterator* pit) {
auto it = --(*(T::iterator*)pit);
memcpy(pit, &it, sizeof(it));
pit->val = &*it;
}
UClass_Container_impl() : UClass_Container(type_name<T>().View(), sizeof(T)) {
parent = &TypeInfo<value_type>::StaticClass;
@ -225,10 +282,8 @@ namespace refl {
vend = &MyUClass::end;
vinsert = &MyUClass::insert<T>;
IteratorFunc __it_add = &T::iterator::operator++;
viterator_add = *(iterator_impl*)&__it_add;
IteratorFunc __it_sub = &T::iterator::operator++;
viterator_sub = *(iterator_impl*)&__it_sub;
viterator_add = &MyUClass::add;
viterator_sub = &MyUClass::sub;
};
};
template<typename T, typename MyMeta>
@ -330,9 +385,9 @@ namespace refl {
using MyUClass = UClass_Tuple<Types...>;
inline static MyUClass StaticClass = MyUClass();
};
template<typename... Types>
struct TypeInfoImpl<std::pair<Types...>> {
using MyUClass = UClass_Tuple<Types...>;
template<typename First, typename Second>
struct TypeInfoImpl<std::pair<First, Second>> {
using MyUClass = UClass_Pair<First, Second>;
inline static MyUClass StaticClass = MyUClass();
};
template<is_container_v T>

1
engine/3rdparty/zlib/include/yaml/serialize/register.inl vendored
View File

@ -1,4 +1,5 @@
#ifdef RegisterAny
RegisterAny(string);
RegisterAny(int);
RegisterAny(unsigned int);
RegisterAny(short);

31
engine/3rdparty/zlib/test/yaml/main.cpp vendored
View File

@ -32,21 +32,6 @@ void testTuple() {
table.insert(std::make_pair(111,"hello"));
table.insert(std::make_pair(222, "world"));
using T = std::map<int, string>;
using to_iterator_func = T::iterator(T::*)();
struct myiterator {
void* ptr;
};
using to_iterator_impl1 = myiterator*(*)(void *);
using to_iterator_impl2 = myiterator(*)(void*);
using to_iterator_impl3 = void*(*)(void*);
using to_iterator_impl4 = T::iterator(*)(T*);
auto it = table.begin();
auto t = &*it;
to_iterator_func func = &T::begin;
to_iterator_impl1 impl1 = *(to_iterator_impl1*) & func;
to_iterator_impl2 impl2 = *(to_iterator_impl2*)&func;
to_iterator_impl3 impl3 = *(to_iterator_impl3*)&func;
to_iterator_impl4 impl4 = *(to_iterator_impl4*)&func;
string rtable = YAML::Text_Serialize(table);
std::cout << rtable << std::endl;
auto table2 = YAML::Text_Unserialize<std::map<int, string>>(rtable);
@ -60,20 +45,8 @@ int main() {
constexpr bool m1 = refl::is_map_v<std::vector<int>>;
constexpr bool m2 = refl::is_sequence_v<std::map<int, float>>;
auto cls = &TypeInfo<Guid>::StaticClass;
std::vector<int> vi;
using T = std::vector<int>;
using iterator = T::iterator;
struct myiterator {
void* ptr;
};
using to_iterator_impl_func = myiterator*(*)(const void*);
using to_iterator_func = void(T::*)(T::value_type&&);
to_iterator_func to_iterator = &T::push_back;
to_iterator_impl_func to_iterator_impl = * (to_iterator_impl_func*) &to_iterator;
iterator it = vi.begin();
void* pptr = it._Ptr;
//testGuid();
//testMeta();
testGuid();
testMeta();
testTuple();
return 0;
}