zengine/engine/modules/engine/zlib/include/refl/detail/uclass.inl

#include "uclass.h"
#include "name.h"
#include "type.h"
namespace refl {
	template <class T>
	concept is_metas_v = requires(const Name & name) { Meta<T>::GetMeta(name); };
	template<typename T>
	class UClass_Auto : public UClass {
	public:
		UClass_Auto() : UClass(meta_name<T>().view(), sizeof(T)) {
			if constexpr (std::is_pointer_v<T>) {
				using RT = std::remove_pointer_t<T>;
				flag |= CLASS_POINTER_FLAG;
				if constexpr (!std::is_same_v<RT, void>) {
					parent = meta_info<RT>();
				}
			}
			else if constexpr (is_array_v<T>) {
				using RT = is_array_t<T>;
				flag = CLASS_ARRAY_FLAG;
				if constexpr (std::is_pointer_v<RT>) {
					flag |= CLASS_POINTER_FLAG;
				}
				parent = meta_info<RT>();
			}
			else {
				vtable.AddConstruct(&UClass::Construct<T>);
				vtable.AddDestruct(&UClass::Destruct<T>);
				if constexpr (is_metas_v<T>) {
					vtable.AddGetMeta(&Meta<T>::GetMeta);
				}
			}
		}
	};
	/*
	* 模板优化
	* 成员参数转化为const void*
	* 引用参数转化为指针
	* 返回引用转化为指针
	*/
	template<typename R, typename... Args>
	class UMethod_Auto : public UClass {
		using MethodType = R(*)(Args...);
	public:
		std::array<const UClass*, sizeof...(Args) + 1> UList{};
		UMethod_Auto() : UClass(meta_name<MethodType>().view(), sizeof(MethodType)) {
			flag = CLASS_TRIVIAL_FLAG;
			vtable.AddGetParams(&UMethod_Auto::GetParams);
			vtable.AddCall(&UMethod_Auto::Call);
			if constexpr (!std::is_same_v<R, void>) {
				UList[0] = meta_info<R>();
			}
			if constexpr (sizeof...(Args) > 0) {
				auto ptr = &UList[1];
				(..., (*ptr = meta_info<Args>(), ptr++));
			}
		}
		//这里顺序似乎是不确定的，但是我实际运用是对的
		//如果使用make_index_sequence,会多一次函数调用
		//为什么包裹一层迭代器，就不会出现警告了
		static void Call(const FieldPtr* field, span<Any> ArgsList) {
			assert(sizeof...(Args) < ArgsList.size());
			auto param = ArgsList.end() - 1;
			if constexpr (std::is_same_v<R, void>) {
				MethodType fptr = (MethodType)field->data.method.fptr;
				fptr((param--->CastTo<Args>())...);
			}
			else {
				MethodType fptr = (MethodType)field->data.method.fptr;
				auto ret = ArgsList.front();
				if (ret.cls == meta_info<R>()) {
					*(R*)ret.ptr = fptr((param--->CastTo<Args>())...);
				}
				else {
					fptr((param--->CastTo<Args>())...);
				}
			}
		}
		static span<const UClass*> GetParams(const UClass* cls) {
			auto& UList = ((UMethod_Auto*)cls)->UList;
			return span<const UClass*>{UList};
		}
	};
	class UClass_Container_Impl : public UClass {
	public:
		using UClass::UClass;
		struct iterator {
			void* ptr;
			void* val;
		};
		//container
		using size_impl = size_t(*)(const void*);
		using to_iterator_impl = void(*)(iterator&, const void*);
		using insert_impl = void (*)(const void*, const void*);
		//iterator
		using iterator_impl = void (*)(iterator*);
	public:
		size_impl vsize;
		to_iterator_impl vbegin;
		to_iterator_impl vend;
		insert_impl vinsert;
		iterator_impl viterator_add;
		iterator_impl viterator_sub;
		template<typename T>
		static void insert(const void* ptr, const void* obj) {
			using value_type = typename T::value_type;
			if constexpr (is_sequence_v<T>) {
				((T*)ptr)->push_back(*(value_type*)obj);
			}
			else if constexpr (is_map_v<T>) {
				((T*)ptr)->insert(*(value_type*)obj);
			}
		}
	};
	template<is_container_v T, typename value_type>
	class UClass_Container : public UClass_Container_Impl {
	public:
		static bool construct(void* ptr, const UClass* cls, span<Any> ArgsList) {
			new(ptr)T();
			return true;
		}
		static void destruct(void* ptr) {
			((T*)ptr)->~T();
		}
		static void begin(iterator& pit, const void* ptr) {
			auto it = ((T*)ptr)->begin();
			memcpy(&pit, &it, sizeof(it));
			pit.val = &*it;
		}
		static void end(iterator& pit, const void* ptr) {
			auto it = ((T*)ptr)->end();
			memcpy(&pit, &it, sizeof(it));
			pit.val = &*it;
		}
		static void add(iterator* pit) {
			auto it = ++(*(typename T::iterator*)pit);
			memcpy(pit, &it, sizeof(it));
			pit->val = &*it;
		}
		static void sub(iterator* pit) {
			auto it = --(*(typename T::iterator*)pit);
			memcpy(pit, &it, sizeof(it));
			pit->val = &*it;
		}
		UClass_Container() : UClass_Container_Impl(meta_name<T>().view(), sizeof(T)) {
			parent = meta_info<value_type>();
			flag = CLASS_CONTAINER_FLAG;
			vtable.AddConstruct(&UClass_Container::construct);
			vtable.AddDestruct(&UClass_Container::destruct);
			if constexpr (is_sequence_v<T>) {
				flag |= CLASS_SEQUENCE_FLAG;
			}
			else if constexpr (is_map_v<T>)
			{
				flag |= CLASS_MAP_FLAG;
			}
			auto p_size = &T::size;
			vsize = *(size_impl*)&p_size;
			vbegin = &UClass_Container::begin;
			vend = &UClass_Container::end;
			vinsert = &UClass_Container::insert<T>;

			viterator_add = &UClass_Container::add;
			viterator_sub = &UClass_Container::sub;
		};
	};
	template<typename T, typename MetaImpl>
	class UClass_Meta : public UClass {
		using FieldsType = decltype(MetaImpl::MakeFields());
	public:
		FieldsType Fields{ MetaImpl::MakeFields() };
		UClass_Meta() : UClass(meta_name<T>().view(), sizeof(T)) {
			if constexpr (has_parent_v<T>) {
				parent = meta_info<parent_t<T>>();
			}
			if constexpr (is_metas_v<T>) {
				vtable.AddGetMeta(&Meta<T>::GetMeta);
			}
			vtable.AddGetFields(&UClass_Meta::GetFields);
			vtable.AddConstruct(&UClass::Construct<T>);
		}
		span<const FieldPtr> GetFields(EFieldFind find, const Name& name) const {
			constexpr int length = std::tuple_size<FieldsType>::value;
			constexpr int MemberCount = MetaImpl::MemberCount();
			constexpr int CtorCount = MetaImpl::CtorCount();
			switch (find) {
			case EFieldFind::FIND_ALL_FIELD:
				return span<const FieldPtr>(&Fields[0], length);
			case EFieldFind::FIND_ALL_MEMBER:
				return span<const FieldPtr>(&Fields[0], MemberCount);
			case EFieldFind::FIND_ALL_METHOD:
				return span<const FieldPtr>(&Fields[MemberCount + CtorCount], length - MemberCount - CtorCount);
			case EFieldFind::FIND_CTOR:
				return span<const FieldPtr>(&Fields[MemberCount], CtorCount);
			case EFieldFind::FIND_FIELD:
				for (int i = 0; i < length; i++) {
					if (name == Fields[i].name) {
						return span<const FieldPtr>(&Fields[i], 1);
					}
				}
				return {};
			case EFieldFind::FIND_MEMBER:
				for (int i = 0; i < MemberCount; i++) {
					if (name == Fields[i].name) {
						return span<const FieldPtr>(&Fields[i], 1);
					}
				}
				return {};
			case EFieldFind::FIND_METHOD:
				for (int i = MemberCount + CtorCount; i < length; i++) {
					if (name == Fields[i].name) {
						return span<const FieldPtr>(&Fields[i], 1);
					}
				}
				return {};
			case EFieldFind::FIND_METHODS:
			{
				int first = 0, count = 0;
				for (int i = MemberCount + CtorCount; i < length; i++) {
					if (name == Fields[i].name) {
						if (!count) {
							first = i;
						}
						count++;
					}
					else if (count) {
						return span<const FieldPtr>(&Fields[first], count);
					}
				}
				return {};
			}
			default:
				return {};
			}
		}
		static span<const FieldPtr> GetFields(const UClass* _cls, EFieldFind find, Name name) {
			auto cls = static_cast<const UClass_Meta*>(_cls);
			return cls->GetFields(find, name);
		}
	};
	template<typename T>
	struct meta_info_impl {
		static UClass* create() {
			return new(MetaGlobalPool()) UClass_Auto<T>{};
		}
	};
	template<typename R, typename... Args>
	struct meta_info_impl<R(*)(Args...)> {
		static UClass* create() {
			return new(MetaGlobalPool()) UMethod_Auto<R, Args...>{};
		}
	};
	template<is_container_v T>
	struct meta_info_impl<T> {
		static UClass* create() {
			return new(MetaGlobalPool()) UClass_Container<T, typename T::value_type>{};
		}
	};
	using __tClassTable = table<Name, const UClass*>;
	UNIQUER_INLINE(__tClassTable, ClassTable, "refl::ClassTable")
	inline const UClass* find_info(Name name) {
		auto& ClassTable = UNIQUER_VAL(ClassTable);
		if (auto it = ClassTable.find(name); it != ClassTable.end()) {
			return it->second;
		}
		return nullptr;
	}
	template<typename Type>
	inline const UClass* meta_info()
	{
		using T = real_type_t<Type>;
		constexpr auto name = meta_name<T>();
		if (auto cls = find_info(name.view())) {
			return cls;
		}
		UClass* cls;
		if constexpr (is_meta_v<T>){
			cls = new(MetaGlobalPool()) UClass_Meta<T, meta_t<T>>{};
		}
		else if constexpr (std::is_same_v<T, void>) {
			cls = new(MetaGlobalPool()) UClass{ name.view(), 0 };
		}
		else {
			cls = meta_info_impl<T>::create();
		}
		auto& ClassTable = UNIQUER_VAL(ClassTable);
		ClassTable[name.view()] = cls;
		return cls;
	}
}