ZFFramework
 
Loading...
Searching...
No Matches
ZFExport.h
Go to the documentation of this file.
1
5
6#ifndef _ZFI_ZFExport_h_
7#define _ZFI_ZFExport_h_
8
9#include "ZFMethodFuncDeclare.h"
10#include "ZFMethodFuncUserRegister.h"
11ZF_NAMESPACE_GLOBAL_BEGIN
12
13#define _ZFP_ZFEXPORT_VAR_DEFINE(Type, Name) \
14 ZF_STATIC_REGISTER_INIT(ExportV_##Name) { \
15 ZFMethodFuncUserRegister_1(setterMethod, { \
16 (Name)(v); \
17 }, ZF_NAMESPACE_CURRENT(), \
18 void, zftext(#Name) \
19 , ZFMP_IN(Type const &, v) \
20 ); \
21 ZFMethodFuncUserRegister_0(getterMethod, { \
22 return (Name)(); \
23 }, ZF_NAMESPACE_CURRENT(), \
24 Type &, zftext(#Name) \
25 ); \
26 } \
27 ZF_STATIC_REGISTER_DESTROY(ExportV_##Name) { \
28 ZFMethodFuncUserUnregister(ZFMethodFuncForName(ZF_NAMESPACE_CURRENT(), zftext(#Name), ZFTypeId<Type>::TypeId())); \
29 ZFMethodFuncUserUnregister(ZFMethodFuncForName(ZF_NAMESPACE_CURRENT(), zftext(#Name), zfnull)); \
30 } \
31 ZF_STATIC_REGISTER_END(ExportV_##Name)
32#define _ZFP_ZFEXPORT_VAR_DEFINE_READONLY(Type, Name) \
33 ZF_STATIC_REGISTER_INIT(ExportV_##Name) { \
34 ZFMethodFuncUserRegister_0(getterMethod, { \
35 return (Name)(); \
36 }, ZF_NAMESPACE_CURRENT(), \
37 Type const &, zftext(#Name) \
38 ); \
39 } \
40 ZF_STATIC_REGISTER_DESTROY(ExportV_##Name) { \
41 ZFMethodFuncUserUnregister(ZFMethodFuncForName(ZF_NAMESPACE_CURRENT(), zftext(#Name), zfnull)); \
42 } \
43 ZF_STATIC_REGISTER_END(ExportV_##Name)
44
45// ============================================================
68#define ZFEXPORT_VAR_DECLARE(ZFLIB_, Type, Name) \
69 \
70 extern ZFLIB_ Type _ZFP_v_##Name; \
71 \
72 inline Type &_ZFP_ZFMETHOD_FUNC_NAME(Name)(void) { \
73 return _ZFP_v_##Name; \
74 } \
75 \
76 inline void _ZFP_ZFMETHOD_FUNC_NAME(Name)(ZF_IN Type const &v) { \
77 _ZFP_v_##Name = v; \
78 }
79
81#define ZFEXPORT_VAR_DEFINE(Type, Name, initValue) \
82 Type _ZFP_v_##Name = (initValue); \
83 _ZFP_ZFEXPORT_VAR_DEFINE(Type, Name)
84
86#define ZFEXPORT_VAR_ALIAS_DECLARE(ZFLIB_, Type, Name, AliasName) \
87 inline Type &_ZFP_ZFMETHOD_FUNC_NAME(Name)(void) { \
88 return (AliasName)(); \
89 } \
90 \
91 inline void _ZFP_ZFMETHOD_FUNC_NAME(Name)(ZF_IN Type const &v) { \
92 AliasName(v); \
93 }
94
96#define ZFEXPORT_VAR_ALIAS_DEFINE(Type, Name) \
97 _ZFP_ZFEXPORT_VAR_DEFINE(Type, Name)
98
100#define ZFEXPORT_VAR_VALUEREF_DECLARE(ZFLIB_, Type, Name, ValueRef) \
101 inline Type &_ZFP_ZFMETHOD_FUNC_NAME(Name)(void) { \
102 return ValueRef; \
103 } \
104 \
105 inline void _ZFP_ZFMETHOD_FUNC_NAME(Name)(ZF_IN Type const &v) { \
106 ValueRef = v; \
107 }
108
110#define ZFEXPORT_VAR_VALUEREF_DEFINE(Type, Name) \
111 _ZFP_ZFEXPORT_VAR_DEFINE(Type, Name)
112
113// ============================================================
115#define ZFEXPORT_VAR_READONLY_DECLARE(ZFLIB_, Type, Name) \
116 \
117 extern ZFLIB_ Type _ZFP_v_##Name; \
118 \
119 inline Type const &_ZFP_ZFMETHOD_FUNC_NAME(Name)(void) { \
120 return _ZFP_v_##Name; \
121 }
122
124#define ZFEXPORT_VAR_READONLY_DEFINE(Type, Name, initValue) \
125 Type _ZFP_v_##Name = (initValue); \
126 _ZFP_ZFEXPORT_VAR_DEFINE_READONLY(Type, Name)
127
129#define ZFEXPORT_VAR_READONLY_ALIAS_DECLARE(ZFLIB_, Type, Name, AliasName) \
130 inline Type const &_ZFP_ZFMETHOD_FUNC_NAME(Name)(void) { \
131 return (AliasName)(); \
132 }
133
135#define ZFEXPORT_VAR_READONLY_ALIAS_DEFINE(Type, Name) \
136 _ZFP_ZFEXPORT_VAR_DEFINE_READONLY(Type, Name)
137
139#define ZFEXPORT_VAR_READONLY_VALUEREF_DECLARE(ZFLIB_, Type, Name, ValueRef) \
140 inline Type const &_ZFP_ZFMETHOD_FUNC_NAME(Name)(void) { \
141 return ValueRef; \
142 }
143
145#define ZFEXPORT_VAR_READONLY_VALUEREF_DEFINE(Type, Name) \
146 _ZFP_ZFEXPORT_VAR_DEFINE_READONLY(Type, Name)
147
148// ============================================================
150#define ZFEXPORT_VAR_USER_REGISTER(Type, Name) \
151 ZF_STATIC_REGISTER_INIT(ExportVar_##Name) { \
152 ZFMethodFuncUserRegister_1(setterMethod, { \
153 Name = v; \
154 }, ZF_NAMESPACE_CURRENT(), void, zftext(#Name) \
155 , ZFMP_IN(Type const &, v) \
156 ); \
157 ZFMethodFuncUserRegister_0(getterMethod, { \
158 return Name; \
159 }, ZF_NAMESPACE_CURRENT(), Type const &, zftext(#Name) \
160 ); \
161 } \
162 ZF_STATIC_REGISTER_DESTROY(ExportVar_##Name) { \
163 ZFMethodFuncUserUnregister(ZFMethodFuncForName( \
164 ZF_NAMESPACE_CURRENT() \
165 , zftext(#Name) \
166 , ZFTypeId<Type>::TypeId() \
167 )); \
168 ZFMethodFuncUserUnregister(ZFMethodFuncForName( \
169 ZF_NAMESPACE_CURRENT() \
170 , zftext(#Name) \
171 , zfnull \
172 )); \
173 } \
174 ZF_STATIC_REGISTER_END(ExportVar_##Name)
175
176#define ZFEXPORT_VAR_READONLY_USER_REGISTER(Type, Name) \
177 ZF_STATIC_REGISTER_INIT(ExportVar_##Name) { \
178 ZFMethodFuncUserRegister_0(getterMethod, { \
179 return Name; \
180 }, ZF_NAMESPACE_CURRENT(), Type const &, zftext(#Name) \
181 ); \
182 } \
183 ZF_STATIC_REGISTER_DESTROY(ExportVar_##Name) { \
184 ZFMethodFuncUserUnregister(ZFMethodFuncForName( \
185 ZF_NAMESPACE_CURRENT() \
186 , zftext(#Name) \
187 , zfnull \
188 )); \
189 } \
190 ZF_STATIC_REGISTER_END(ExportVar_##Name)
191
192// ============================================================
194#define ZFEXPORT_VAR_USER_REGISTER_FOR_FUNC(Type, Name) \
195 ZF_STATIC_REGISTER_INIT(ExportVar_##Name) { \
196 ZFMethodFuncUserRegister_1(setterMethod, { \
197 Name(v); \
198 }, ZF_NAMESPACE_CURRENT(), void, zftext(#Name) \
199 , ZFMP_IN(Type const &, v) \
200 ); \
201 ZFMethodFuncUserRegister_0(getterMethod, { \
202 return Name(); \
203 }, ZF_NAMESPACE_CURRENT(), Type const &, zftext(#Name) \
204 ); \
205 } \
206 ZF_STATIC_REGISTER_DESTROY(ExportVar_##Name) { \
207 ZFMethodFuncUserUnregister(ZFMethodFuncForName( \
208 ZF_NAMESPACE_CURRENT() \
209 , zftext(#Name) \
210 , ZFTypeId<Type>::TypeId() \
211 )); \
212 ZFMethodFuncUserUnregister(ZFMethodFuncForName( \
213 ZF_NAMESPACE_CURRENT() \
214 , zftext(#Name) \
215 , zfnull \
216 )); \
217 } \
218 ZF_STATIC_REGISTER_END(ExportVar_##Name)
219
220#define ZFEXPORT_VAR_READONLY_USER_REGISTER_FOR_FUNC(Type, Name) \
221 ZF_STATIC_REGISTER_INIT(ExportVar_##Name) { \
222 ZFMethodFuncUserRegister_0(getterMethod, { \
223 return Name(); \
224 }, ZF_NAMESPACE_CURRENT(), Type const &, zftext(#Name) \
225 ); \
226 } \
227 ZF_STATIC_REGISTER_DESTROY(ExportVar_##Name) { \
228 ZFMethodFuncUserUnregister(ZFMethodFuncForName( \
229 ZF_NAMESPACE_CURRENT() \
230 , zftext(#Name) \
231 , zfnull \
232 )); \
233 } \
234 ZF_STATIC_REGISTER_END(ExportVar_##Name)
235
236// ============================================================
247#define ZFEXPORT_RAW_ENUM_DEFINE(EnumName, enumValues, ...) \
248 _ZFP_ZFEXPORT_RAW_ENUM_DEFINE(EnumName, enumValues, ##__VA_ARGS__)
249
250#define _ZFP_ZFEXPORT_RAW_ENUM_DEFINE_EXPAND(...) __VA_ARGS__
251#define _ZFP_ZFEXPORT_RAW_ENUM_DEFINE(...) \
252 _ZFP_ZFEXPORT_RAW_ENUM_DEFINE_EXPAND(_ZFP_ZFEXPORT_RAW_ENUM_DEFINE_(__VA_ARGS__))
253#define _ZFP_ZFEXPORT_RAW_ENUM_DEFINE_(EnumName, enumValues, ...) \
254 ZF_STATIC_REGISTER_INIT(ExportEnum_##EnumName) { \
255 typedef EnumName _EnumName; \
256 ZFM_FIX_PARAM(_ZFP_ZFEXPORT_RAW_ENUM_DEFINE_ITEM_EXPAND, ZFM_EMPTY, enumValues, ##__VA_ARGS__) \
257 } \
258 ZF_STATIC_REGISTER_DESTROY(ExportEnum_##EnumName) { \
259 for(zfindex i = 0; i < m.count(); ++i) { \
260 ZFMethodFuncUserUnregister(m[i]); \
261 } \
262 } \
263 ZFCoreArray<const ZFMethod *> m; \
264 ZF_STATIC_REGISTER_END(ExportEnum_##EnumName)
265#define _ZFP_ZFEXPORT_RAW_ENUM_DEFINE_ITEM_EXPAND(v) \
266 { \
267 ZFMethodFuncUserRegister_0(resultMethod, { \
268 return v; \
269 }, ZF_NAMESPACE_CURRENT(), _EnumName, zftext(#v)); \
270 m.add(resultMethod); \
271 }
272
273ZF_NAMESPACE_GLOBAL_END
274#endif // #ifndef _ZFI_ZFExport_h_
275
ZFMethodFuncDeclare.h
ZFMethod declaration.
ZFMethodFuncUserRegister.h
user registered ZFMethod
ZF_NAMESPACE_GLOBAL_BEGIN
#define ZF_NAMESPACE_GLOBAL_BEGIN
begin namespace ZFFramework
Definition ZFNamespace.h:97
ZF_NAMESPACE_GLOBAL_END
#define ZF_NAMESPACE_GLOBAL_END
end namespace ZFFramework
Definition ZFNamespace.h:98