blob: 0382324ce435774e1cfe3eebff1666495033507e (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
|
#ifndef __DLL_H
#define __DLL_H
//
// class DLLManager is the simple ELF C++ Library manager.
//
// It tries to dynamically load the specified shared library
// when it is construted.
//
// You should call LastError() before doing anything. If it
// returns NULL there is no error.
//
class DLLManager
{
public:
DLLManager( const char *fname );
virtual ~DLLManager();
bool GetSymbol( void **, const char *sym_name );
const char *LastError()
{
return err;
}
protected:
void *h;
const char *err;
};
//
// class DLLFactoryBase is the base class used for the DLLFactory
// template class.
//
// It inherits from the DLLManager class and must be constructed with
// the file name of the shared library and the function name within that
// library which will create the desired C++ factory class.
// If you do not provide func_name to the constructor, it defaults to
// the undecorated "C" symbol "factory0"
//
// factory_func will be set to a pointer to the requested factory creator
// function. If there was an error linking to the shared library,
// factory_func will be 0.
//
// You can call 'LastError()' to find the error message that occurred.
//
//
class DLLFactoryBase : public DLLManager
{
public:
DLLFactoryBase(const char *fname, const char *func_name = 0);
virtual ~DLLFactoryBase();
void * (*factory_func)(void);
};
//
// The DLLFactory template class inherits from DLLFactoryBase.
// The constructor takes the file name of the shared library
// and the undecorated "C" symbol name of the factory creator
// function. The factory creator function in your shared library
// MUST either return a pointer to an object that is a subclass
// of 'T' or it must return 0.
//
// If everything is cool, then 'factory' will point to the
// requested factory class. If not, it will be 0.
//
// Since the DLLFactory template ultimately inherits DLLManager,
// you can call LastError() to get any error code information
//
// The created factory is OWNED by the DLLFactory class.
// The created factory will get deleted when the DLLFactory class
// is deleted, because the DLL will get unloaded as well.
//
template <class T> class DLLFactory : public DLLFactoryBase
{
public:
DLLFactory(const char *fname, const char *func_name=0) : DLLFactoryBase(fname,func_name)
{
if (factory_func)
factory = (T*)factory_func();
else
factory = 0;
}
~DLLFactory()
{
delete factory;
}
T *factory;
};
#endif
|
