Welcome to libclay projectThe Clay library (libclay) is a simple framework for multi-module integration. It also supports dynamic plugins with DLL files (in Win32) or SO files (in Linux).
Find project
details please see http://sourceforge.net/projects/libclay
Download
source files please see http://sourceforge.net/projects/libclay/files Get user guide please see Quick Start and Document
|
||
1.What is clay library ? The Clay library (libclay) is a simple framework for multi-module integration. It also supports dynamic plugins with DLL files (in Win32) or SO files (in Linux).
2.What can libclay do?
Before use libclay:
#include "ModuleA.h" #include "ModuleB.h" #include "ModuleC.h"
int main() { Function1InModuleA(); Function2InModuleB(); Function3InModuleC(); return 0; }
After use libclay:
// #include "ModuleA.h" // #include "ModuleB.h" // #include "ModuleC.h"
#include "clay.h"
int main() { // Function1InModuleA(); // Function2InModuleB(); // Function3InModuleC();
clay::lib::CallService("ModuleA", "Function1"); clay::lib::CallService("ModuleB", "Function2"); clay::lib::CallService("ModuleC", "Function3");
return 0; }
3.How to use libclay to do module integration? StepA: First, you have to create a new class as an interface class to wrap the module you want to integrate. The interface class must inherit from the class clay::core::ClayServiceProvider. Here is a sample (HelloModule is wrapped, the function SayFunctionInHelloModule() is defined in HelloModule.h file):
Hello.h
class HelloServiceProvider: public clay::core::ClayServiceProvider { private: protected: virtual void SetupServices(); int SayHello(void* pParam); public: explicit HelloServiceProvider(const std::string& sName); virtual ~HelloServiceProvider(); };
Hello.cpp
#include "Hello.h" #include "HelloModule.h" // the module you need to wrap ¡
static HelloServiceProvider* g_pHelloServiceProvider = new HelloServiceProvider("Hello");
HelloServiceProvider::HelloServiceProvider(const std::string& sName) : clay::core::ClayServiceProvider(sName) { // Register the interface functions of the provider
SetupServices(); // Register current provider
clay::lib::RegisterSp(this);
// After the register, the framework will own the life of the provider's pointer, // So from now on, developers should not try to delete it themselves. }
HelloServiceProvider::~HelloServiceProvider() { return; }
void HelloServiceProvider::SetupServices() { RegisterService("SayHello", CLAY_SVC_FUNC(HelloServiceProvider::SayHello)); }
int HelloServiceProvider::SayHello(void* pParam) { return SayFunctionInHelloModule(pParam); // the function you want to wrap ¡ }
StepB: Then, use clay::lib::CallService(sModuleName, sFunctionName, pParam); to replace the original function called in main.cpp.
main.cpp
// #include "HelloModule.h" #include "clay.h"
int main() { char* sSomebody = "Somebody";
// SayFunctionInHelloModule(sSomebody); clay::lib::CallService("Hello", "SayHello", (void*)sSomebody);
return 0; }
4.How to use libclay to implement the plug-in function?
For example, we assume we are going to plug-in a DLL(Hello.dll) into a Win32 program, we need to do :
(StepA and StepB are implemented in DLL project)
StepA: First, we still need to create an inteface class, please refer to the StepA in point 3. StepB: In main.h and main.cpp files of the DLL project, we need to write two interface functions:
main.h
#include <windows.h> int DLL_EXPORT InitAgent(void* pParam);
main.cpp
#include "main.h" #include "Hello.h" int DLL_EXPORT InitAgent(void* pParam)
(StepC is implemented in the main project which will call some functions of the DLL project) StepC: In main.cpp of the main program, which the DLL would attached to, we need to use the function clay::lib::Plugin(sModuleName, sModuleFile); to plug in the external module from the DLL file, and then we would still be able to use the function clay::lib::CallService(sModuleName, sFunctionName, pParam); to call the functions in the external module:
main.cpp
#include "clay.h" #include "clay_plugin.h" int main() { char* sSomebody = "Somebody";
clay::lib::Plugin("Hello", "Hello.dll");
clay::lib::CallService("Hello", "SayHello", (void*)sSomebody); ¡¡ return 0; }
5.Is libclay a cross-platform library? Yes. Currently, libclay can work with/without SDL & wxWidgets. If you are going to use libclay with SDL or wxWidgets, libclay will support all the platforms SDL/wxWidgets supports. If you want libclay to work without SDL & wxWidgets, please note that: in current version, the plug-in function of libclay only supports the raw API of Windows & Linux. You should define the right switch to build the proper version you want:
Use define
"__WIN32__" to compile the library in Windows.
6.Is libclay an open source library? What is the license of libclay? Yes. The Clay library (libclay) is licensed under the terms of the MIT license.
7.How can I get more help about libclay? Please see http://libclay.sourceforge.net . ¡¡ |
||
¡¡