260 lines
7.0 KiB
C++
260 lines
7.0 KiB
C++
#pragma once
|
|
#include "type.h"
|
|
#include "field.h"
|
|
#include "view.h"
|
|
namespace refl {
|
|
enum ClassFlag :uint32_t {
|
|
CLASS_NONE_FLAG = 0,
|
|
CLASS_MEMBER_FLAG = 1 << 0,
|
|
CLASS_ATTRIBUTE_FLAG = 1 << 1,
|
|
CLASS_METHOD_FLAG = 1 << 2,
|
|
};
|
|
class UClass{
|
|
using enum FieldFlag;
|
|
public:
|
|
Name name;
|
|
uint32_t size;
|
|
UClass* parent;
|
|
public:
|
|
constexpr UClass(Name name, uint32_t size, UClass* parent = nullptr)
|
|
:name(name),size(size), parent(parent){}
|
|
ObjectView New(void* ptr = nullptr) const{
|
|
if (ptr == nullptr) {
|
|
ptr = malloc(size);
|
|
InitObject(ptr);
|
|
}
|
|
return { ptr , this };
|
|
}
|
|
template<typename T>
|
|
T* New(T* ptr = nullptr) const{
|
|
if (!IsChildOf<T>()) {
|
|
return nullptr;
|
|
}
|
|
if (ptr == nullptr) {
|
|
ptr = (T*)malloc(size);
|
|
}
|
|
InitObject(ptr);
|
|
return ptr;
|
|
}
|
|
template<typename T>
|
|
bool IsChildOf(bool bthis = false) const {
|
|
constexpr UClass* cls = &TypeInfo<T>::StaticClass;
|
|
if (bthis) {
|
|
return cls == this;
|
|
}
|
|
const UClass* _parent = this;
|
|
while (_parent != nullptr) {
|
|
if (_parent == cls) {
|
|
return true;
|
|
}
|
|
_parent = _parent->parent;
|
|
}
|
|
return false;
|
|
}
|
|
public:
|
|
//unsafe if called by other, need check class && size
|
|
virtual void InitObject(void* ptr)const {
|
|
memset(ptr, 0, size);
|
|
}
|
|
virtual const FieldPtr* GetField(const Name& name)const {
|
|
return nullptr;
|
|
}
|
|
virtual std::vector<UClass*> GetParams() const {
|
|
return{};
|
|
}
|
|
virtual void Call(const FieldPtr& field, std::vector<ArgsView>& ArgsList)const{}
|
|
virtual bool ConvertToValue(ArgsView& args)const{
|
|
return false;
|
|
}
|
|
protected:
|
|
template<typename T,Offset offset>
|
|
FieldPtr MakeMemberField(Name name) {
|
|
FieldPtr::Data member = { offset };
|
|
constexpr uint32_t flag = FIELD_MEMBER_FLAG | FIELD_ATTRIBUTE_FLAG;
|
|
return { name, &TypeInfo<T>::StaticClass, {member}, flag };
|
|
}
|
|
template<typename R, typename ...Args>
|
|
FieldPtr MakeMethodField(R (* ptr)(Args...), Name name) {
|
|
FieldPtr::Data member = { *(Method*)&ptr};
|
|
constexpr uint32_t flag = FIELD_METHOD_FLAG;
|
|
return { name, &TypeInfo<R(*)(Args...)>::StaticClass, {member},flag };
|
|
}
|
|
template<typename T, typename R, typename ...Args>
|
|
FieldPtr MakeMethodField(R(T::* ptr)(Args...), Name name) {
|
|
FieldPtr::Data member = { *(Method*)&ptr };
|
|
constexpr uint32_t flag = FIELD_MEMBER_FLAG | FIELD_METHOD_FLAG;
|
|
return { name, &TypeInfo<R(*)(const void*, Args...)>::StaticClass, {member},flag };
|
|
}
|
|
};
|
|
template<_ReflCheck_Ctor T>
|
|
class UClass_Auto : public UClass{
|
|
public:
|
|
using UClass::UClass;
|
|
bool ConvertToValue(ArgsView& args)const override {
|
|
if constexpr (std::is_same<T, int*>::value) {
|
|
using RawT = std::remove_pointer_t<T>;
|
|
args.val = (void*)*(RawT*)args.val;
|
|
args.cls = &TypeInfo<RawT>::StaticClass;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
protected:
|
|
void InitObject(void* ptr)const override {
|
|
constexpr bool is_shallow_copyable = std::is_trivially_copyable<T>::value;
|
|
if constexpr (!is_shallow_copyable){
|
|
T obj{};
|
|
std::construct_at((T*)ptr, obj);
|
|
}
|
|
else {
|
|
memset(ptr, 0, size);
|
|
}
|
|
}
|
|
public:
|
|
static UClass_Auto<T> BuildClass() {
|
|
auto cls = UClass_Auto<T>(type_name<T>().View(), sizeof(T));
|
|
return cls;
|
|
}
|
|
};
|
|
|
|
template<_ReflCheck_Ctor_NoUClass T>
|
|
struct TypeInfoImpl<T>{
|
|
using UClass = UClass_Auto<T>;
|
|
inline static UClass StaticClass = UClass::BuildClass();
|
|
};
|
|
|
|
template<typename R, typename... Args>
|
|
class UMethod_Auto : public UClass {
|
|
using UClass::UClass;
|
|
using MethodType = R(*)(Args...);
|
|
public:
|
|
std::array<UClass*, sizeof...(Args) + 1> UList;
|
|
|
|
std::vector<UClass*> GetParams()const override {
|
|
return { UList.data(), UList.data() + UList.size()};
|
|
}
|
|
void Call(const FieldPtr& field, std::vector<ArgsView>& ArgsList)const override {
|
|
Call<Args...>(field, ArgsList);
|
|
}
|
|
protected:
|
|
template<typename... Args>
|
|
inline void Call(const FieldPtr& field, std::vector<ArgsView>& ArgsList)const {
|
|
MethodType fptr = (MethodType)std::get<Method>(field.data);
|
|
int Indices = 0;
|
|
//fptr(ArgsList[1].val, Indices, Indices);
|
|
//fptr(std::forward<Args>((Args)Indices), ...);
|
|
int a = 1;
|
|
a = a + 1;
|
|
}
|
|
public:
|
|
static UMethod_Auto<R,Args...> BuildClass() {
|
|
auto cls = UMethod_Auto<R, Args...>(type_name<MethodType>().View(), sizeof(MethodType));
|
|
if constexpr(!std::is_same<R, void>::value) {
|
|
cls.UList[0] = &TypeInfo<R>::StaticClass;
|
|
}
|
|
if (sizeof...(Args) > 0) {
|
|
auto ptr = &cls.UList[1];
|
|
(...,(*ptr = &TypeInfo<Args>::StaticClass, ptr++));
|
|
}
|
|
return cls;
|
|
}
|
|
};
|
|
// 函数指针类型的偏特化
|
|
template<typename R, typename... Args>
|
|
struct TypeInfoImpl<R(*)(Args...)> {
|
|
using UClass = UMethod_Auto<R,Args...>;
|
|
inline static UClass StaticClass = UClass::BuildClass();
|
|
};
|
|
template<typename T>
|
|
inline bool ObjectView::Get(const Name& name, T& t)
|
|
{
|
|
if (cache && cache->name == name) {
|
|
_cache_get: bool isChild = cache->type->IsChildOf<T>(true);
|
|
if (isChild) {
|
|
t = *(T*)(ptr + std::get<uint32_t>(cache->data));
|
|
}
|
|
return isChild;
|
|
}
|
|
auto field = cls->GetField(name);
|
|
if (field) {
|
|
cache = field;
|
|
goto _cache_get;
|
|
}
|
|
return false;
|
|
}
|
|
template<typename T>
|
|
inline bool ObjectView::Set(const Name& name, const T& t)
|
|
{
|
|
if (cache && cache->name == name) {
|
|
|
|
_cache_set: bool isChild = cache->type->IsChildOf<T>(true);
|
|
if (isChild) {
|
|
*(T*)(ptr + std::get<uint32_t>(cache->data)) = t;
|
|
}
|
|
return isChild;
|
|
}
|
|
auto field = cls->GetField(name);
|
|
if (field) {
|
|
cache = field;
|
|
goto _cache_set;
|
|
}
|
|
return false;
|
|
}
|
|
template<typename ...Args>
|
|
bool ObjectView::Invoke(const Name& name, Args&&... args)
|
|
{
|
|
auto field = cls->GetField(name);
|
|
if (!field) {
|
|
return false;
|
|
}
|
|
constexpr int inputSize = sizeof...(Args);
|
|
auto params = field->type->GetParams();
|
|
int paramsSize = params.size();
|
|
bool member = field->flag & FIELD_MEMBER_FLAG;
|
|
if (inputSize + member >= paramsSize) {
|
|
return false;
|
|
}
|
|
std::vector<ArgsView> ArgsList;
|
|
ArgsList.reserve(paramsSize);
|
|
ArgsList.emplace_back();
|
|
if (member) {
|
|
ArgsList.emplace_back(ptr, cls );
|
|
}
|
|
(..., (ArgsList.emplace_back((void*)&args, &TypeInfo<Args>::StaticClass)));
|
|
for (int i = member + 1; i < paramsSize; i++) {
|
|
if (ArgsList[i].cls != params[i]) {
|
|
ArgsList[i].ConvertTo(params[i]);
|
|
}
|
|
}
|
|
field->type->Call(*field, ArgsList);
|
|
return false;
|
|
}
|
|
template<typename R, typename ...Args>
|
|
inline bool ObjectView::InvokeRet(const Name& name, R& ret, Args&& ...args)
|
|
{
|
|
auto field = cls->GetField(name);
|
|
if (!field) {
|
|
return false;
|
|
}
|
|
if (field->flag & FIELD_MEMBER_FLAG) {
|
|
using MemberMethodType = R(*)(const void*, Args...);
|
|
MemberMethodType fptr = (MemberMethodType)std::get<Method>(field->data);
|
|
ret = fptr(ptr, std::forward<Args>(args)...);
|
|
}
|
|
else {
|
|
using MethodType = R(*)(Args...);
|
|
MethodType fptr = (MethodType)std::get<Method>(field->data);
|
|
ret = fptr(std::forward<Args>(args)...);
|
|
}
|
|
return true;
|
|
}
|
|
bool ArgsView::ConvertTo(UClass* toClass) {
|
|
ArgsView args{val};
|
|
cls->ConvertToValue(args);
|
|
if (args.cls == toClass) {
|
|
*this = args;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
} |