定义基类
#ifndef JOBJECT_H
#define JOBJECT_H
#include <functional>
#include <map>
#include <list>
#include <any>
class JObject
{
public:
virtual ~JObject() {};
virtual std::string className()
{
return m_className;
}
virtual void setclassName(std::string name)
{
m_className = name;
}
std::string m_className;
};
class JMeMberFunction
{
public:
JMeMberFunction() = default;
template<typename Class, typename... Args>
explicit JMeMberFunction(void (Class::* func)(Args...))
{
function = [this, func](JObject* obj, void* arry)->std::any
{
Class* _cobj = dynamic_cast<Class*>(obj);
auto tupe = (std::tuple<Args...>*)(arry);
std::apply(func, std::tuple_cat(std::tuple<Class*>(_cobj), *tupe));
return std::any{};
};
}
template<typename Class, typename... Args>
explicit JMeMberFunction(void (Class::* func)(Args...) const)
{
function = [this, func](JObject* obj, void* arry)->std::any
{
Class* _cobj = dynamic_cast<Class*>(obj);
auto tupe = (std::tuple<Args...>*)(arry);
std::apply(func, std::tuple_cat(std::tuple<Class*>(_cobj), *tupe));
return std::any{};
};
}
template<typename Class, typename Return, typename...Args>
explicit JMeMberFunction(Return(Class::* func)(Args...))
{
function = [this, func](JObject* obj, void* arry)->std::any
{
Class* _cobj = dynamic_cast<Class*>(obj);
auto tupe = (std::tuple<Args...>*)(arry);
return std::apply(func, std::tuple_cat(std::tuple<Class*>(_cobj), *tupe));
};
}
template<typename Class, typename Return, typename...Args>
explicit JMeMberFunction(Return(Class::* func)(Args...) const)
{
function = [this, func](JObject* obj, void* arry)->std::any
{
Class* _cobj = dynamic_cast<Class*>(obj);
auto tupe = (std::tuple<Args...>*)(arry);
return std::apply(func, std::tuple_cat(std::tuple<Class*>(_cobj), *tupe));
};
}
std::function<std::any(JObject* obj, void*)> function = nullptr;
};
class JMeMberVariable
{
public:
JMeMberVariable() = default;
explicit JMeMberVariable(std::string cdataType,std::any v)
{
variable = v;
dataType = cdataType;
}
std::any variable;
std::string dataType;
};
class JMetaObject
{
public:
void registerFuction(std::string fucName, JMeMberFunction jMeMberFunction)
{
if (fucName.size() > 0)
{
if (fucName[0] == '&')
{
int i = fucName.rfind(":");
if (i != std::string::npos) {
std::string s = fucName.substr(i + 1);
fucName = s;
}
}
m_JMemberFucs[fucName] = jMeMberFunction;
m_JMemberFucNames.push_back(fucName);
}
}
void registerVariable(std::string varName,JMeMberVariable jMeMberVariable)
{
if (varName.size() > 0)
{
if (varName[0] == '&')
{
int i = varName.rfind(":");
if (i != std::string::npos) {
std::string s = varName.substr(i + 1);
int j = s.rfind(")");
if (j != std::string::npos)
{
s = s.substr(0,j);
}
varName = s;
}
}
m_JMembers[varName] = jMeMberVariable;
m_JMemberMemberNames.push_back(varName);
}
}
void getFuctionNames(std::vector<std::string>& fuctionNames)
{
fuctionNames = m_JMemberFucNames;
}
void getVariableNames(std::vector<std::string>& variables)
{
variables = m_JMemberMemberNames;
}
std::vector<std::string> getFuctionNames()
{
return m_JMemberFucNames;
}
std::vector<std::string> getVariableNames()
{
return m_JMemberMemberNames;
}
template<typename... Args>
std::any invoke(JObject* obj, std::string funcName, Args&&...args)
{
if (m_JMemberFucs.count(funcName) != 0)
{
auto tupe = std::make_tuple(std::forward<Args>(args)...);
return m_JMemberFucs[funcName].function(obj, &tupe);
}
return std::any{};
}
std::any invokeGet(std::string varName)
{
if (m_JMembers.count(varName) != 0)
{
return m_JMembers[varName].variable;
}
return nullptr;
}
template<typename T>
void invokeSet(std::string varName,T var)
{
if (m_JMembers.count(varName) != 0)
{
*std::any_cast<T*>(m_JMembers[varName].variable) = var;
}
}
std::string getMemberDataType(std::string variableName)
{
if(m_JMembers.count(variableName)==1)
{
return m_JMembers[variableName].dataType;
}
return "unknown";
}
std::string getMemberFuctionReturnDataType(std::string variableName)
{
if(m_JMembers.count(variableName)==1)
{
return m_JMembers[variableName].dataType;
}
return "unknown";
}
private:
std::map<std::string, JMeMberFunction> m_JMemberFucs;
std::map<std::string, JMeMberVariable> m_JMembers;
std::vector<std::string>m_JMemberFucNames;
std::vector<std::string>m_JMemberMemberNames;
};
class JReflectObject :public JObject
{
public:
JReflectObject()
{
}
virtual std::string className()
{
return m_className;
}
virtual void setclassName(std::string name)
{
m_className = name;
}
#define REGIST_FUNCTION(function)\
metaObject.registerFuction(#function,JMeMberFunction(function));
#define REGIST_VARIABLE(dataType,variable)\
metaObject.registerVariable(#variable,JMeMberVariable(#dataType,variable));
JMetaObject metaObject;
};
//int data = *(int*)(obj->metaObject.invokeGet(variables[i]));
//必须实现的接口
//extern "C" __declspec(dllexport) JObject * getInstance();
//extern "C" __declspec(dllexport) void uninstallInstance();
#endif // JOBJECT_H
实现类继承插件类
//.h中
class xxx:public JPluginObject
{
xxx();
bool a(int b,std::vector<int> &vec);
std::string s;
}
//cpp中
//构造函数中
xxx::xxx()
{
REGIST_FUNCTION(&xxx::a);//注册成员函数
REGIST_VARIABLE(string,&(xxx::s));//注册变量
}
//如果需要使用插件模式暴露给插件调用接口，需要放开c导出宏
JObject* obj = nullptr;
JObject* getInstance()
{
obj = new XXX;
return obj;
}
void uninstallInstance()
{
if(obj)
{
delete obj;
obj = nullptr;
}
}
使用
//插件模式时用法
typedef JObject* (*Instance)();
typedef void (*UninstallInstance)();
std::string dllName;
HINSTANCE handle;
JObject* obj;
handle= LoadLibraryA(dllName.c_str());
if (handle== NULL)
{
//
}
Instance instance = (Instance)GetProcAddress(handle, "getInstance");
if (!instance)
{
//
}
obj= instance();
//正常使用
int y = 5;
std::vector<int> vec；
vec.resize(4);
if (obj)
{
JPluginObject* plginObj = dynamic_cast<JPluginObject*>(obj);
plginObj->metaObject()->invoke(object, "XXX", y,vec); Call the function, pass parameters, and if there is a return value, you can catch and convert the result returned by type invoke
std::string s = *std::any_cast<std::string*> (plginObj->metaObject()->invokeGet("s"));
plginObj->metaObject()->invokeSet<std::string>("s","hello")
}
//卸载，插件模式时使用
UninstallInstance uninstallInstance = (UninstallInstance)GetProcAddress(handle, "uninstallInstance");
uninstallInstance();
FreeLibrary(m_handle);
适用于数据库填充和插件式开发等
网友评论