blob: b34f2358b53f28805d373fe35ba605e7cc126988 (
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
106
107
108
109
110
111
112
113
114
|
#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
|
