7 #ifndef _QI_TYPE_OBJECTTYPEBUILDER_HPP_
8 #define _QI_TYPE_OBJECTTYPEBUILDER_HPP_
13 #include <boost/function.hpp>
25 struct ObjectTypeData;
31 class ObjectTypeInterface;
33 template<
typename T>
class SignalF;
34 class ObjectTypeBuilderPrivate;
46 void setDescription(
const std::string& description);
51 template<
typename T>
void buildFor(
bool autoRegister =
true);
53 template <
typename FUNCTION_TYPE>
56 template <
typename FUNCTION_TYPE>
60 unsigned int advertiseSignal(
const std::string& eventName, A accessor,
int id = -1,
bool isSignalProperty =
false);
63 inline unsigned int advertiseSignal(
const std::string&
name,
SignalMemberGetter getter,
int id = -1,
bool isSignalProperty =
false);
66 inline unsigned int advertiseProperty(
const std::string& propertyName, A accessor);
69 inline unsigned int advertiseProperty(
const std::string& eventName,
PropertyMemberGetter getter);
74 template<
typename T,
typename... Args>
77 return advertiseMethod(name, &constructObject<T, Args...>);
81 void inherits(std::ptrdiff_t offset);
88 unsigned int advertiseId(
const std::string&
name, T element);
92 unsigned int xAdvertiseSignal(
const std::string &
name,
const qi::Signature& signature, SignalMemberGetter getter,
int id = -1,
bool isSignalProperty =
false);
93 unsigned int xAdvertiseProperty(
const std::string&
name,
const qi::Signature& signature, PropertyMemberGetter getter,
int id = -1);
95 void inherits(
TypeInterface* parentType, std::ptrdiff_t offset);
111 ObjectTypeBuilderPrivate* _p;
120 buildFor<T>(autoRegister);
128 template<
typename U>
void inherits();
130 template <
typename FUNCTION_TYPE>
132 FUNCTION_TYPE
function,
136 template <
typename FUNCTION_TYPE>
138 FUNCTION_TYPE
function,
158 #define QI_OBJECT_BUILDER_ADVERTISE(builder, cls, name) \
159 builder.advertise(BOOST_PP_STRINGIZE(name), &cls::name)
171 #define QI_OBJECT_BUILDER_ADVERTISE_OVERLOAD(builder, cls, name, ret, args) \
172 builder.advertiseMethod(BOOST_PP_STRINGIZE(name), static_cast<ret (cls::*)args>(&cls::name))
174 #define __QI_REGISTER_ELEMENT(_, name, field) \
175 b.advertise(BOOST_PP_STRINGIZE(field), & name::field); // do not remove the space
184 #define QI_REGISTER_OBJECT(name, ...) \
185 static bool BOOST_PP_CAT(__qi_registration, __LINE__) QI_ATTR_UNUSED = [] \
187 ::qi::ObjectTypeBuilder<name> b; \
188 QI_VAARGS_APPLY(__QI_REGISTER_ELEMENT, name, __VA_ARGS__) \
193 #define QI_REGISTER_MT_OBJECT(name, ...) \
194 static bool BOOST_PP_CAT(__qi_registration, __LINE__) QI_ATTR_UNUSED = [] \
196 ::qi::ObjectTypeBuilder<name> b; \
197 b.setThreadingModel(qi::ObjectThreadingModel_MultiThread); \
198 QI_VAARGS_APPLY(__QI_REGISTER_ELEMENT, name, __VA_ARGS__) \
209 #define QI_REGISTER_IMPLEMENTATION(parent, name) \
210 static bool BOOST_PP_CAT(__qi_registration_func, __LINE__)() \
212 qi::detail::ForceProxyInclusion<parent>().dummyCall(); \
213 qi::registerType(qi::typeId<name>(), qi::typeOf<parent>()); \
214 name* ptr = static_cast<name*>(reinterpret_cast<void*>(0x10000)); \
215 parent* pptr = ptr; \
216 intptr_t offset = reinterpret_cast<intptr_t>(pptr) - reinterpret_cast<intptr_t>(ptr); \
219 qiLogError("qitype.register") << "non-zero offset for implementation " << #name << " of " << #parent \
220 << ", call will fail at runtime"; \
221 throw std::runtime_error("non-zero offset between implementation and interface"); \
225 static bool BOOST_PP_CAT(__qi_registration, __LINE__) = BOOST_PP_CAT(__qi_registration_func, __LINE__)();
227 #define _QI_REGISTER_TEMPLATE_OBJECT(name, model, ...) \
231 class QI_API TypeOfTemplate<name> : public detail::StaticObjectTypeBase \
234 virtual TypeInterface* templateArgument() = 0; \
236 template <typename T> \
237 class TypeOfTemplateImpl<name, T> : public TypeOfTemplate<name> \
240 TypeOfTemplateImpl() \
243 ::qi::registerType(qi::typeId<name<T>>(), this); \
244 ObjectTypeBuilder<name<T> > b(false); \
245 b.setThreadingModel(model); \
246 QI_VAARGS_APPLY(__QI_REGISTER_ELEMENT, name<T>, __VA_ARGS__) \
247 this->initialize(b.metaObject(), b.typeData()); \
249 TypeInterface* templateArgument() override { return typeOf<T>(); } \
250 using Methods = DefaultTypeImplMethods<name<T>>; \
251 _QI_BOUNCE_TYPE_METHODS(Methods); \
254 QI_TEMPLATE_TYPE_DECLARE(name)
260 #define QI_TEMPLATE_OBJECT(name, ...) \
261 _QI_REGISTER_TEMPLATE_OBJECT(name, ObjectThreadingModel_SingleThread, \
266 #define QI_REGISTER_TEMPLATE_OBJECT(name, ...) \
267 QI_TEMPLATE_OBJECT(name, __VA_ARGS__)
271 #define QI_MT_TEMPLATE_OBJECT(name, ...) \
272 _QI_REGISTER_TEMPLATE_OBJECT(name, ObjectThreadingModel_MultiThread, \
291 template <
template<
typename>
class FutT,
typename T>
301 #define ADVERTISE(meth) \
302 b.advertiseMethod(#meth, &FutT<T>::meth)
309 (
const typename FutT<T>::ValueType& (FutT<T>::*)(
int)
const) &FutT<T>::value);
332 template <
typename T>
334 template <
typename T>
342 namespace qi {
namespace detail {
348 #endif // _QITYPE_OBJECTTYPEBUILDER_HPP_
void setValue(qi::Promise< R > &p, const boost::function< R()> &f)
const detail::ObjectTypeData & typeData()
bool registerType(const TypeIndex &typeId, TypeInterface *type)
Runtime Type factory setter.
boost::function< SignalBase *(void *)> SignalMemberGetter
AnyObject object(T *ptr, boost::function< void(GenericObject *)> onDestroy=boost::function< void(GenericObject *)>())
Honor the default behavior.
virtual void registerType()
Register type to typeof. Called by type()
class QITYPE_TEMPLATE_API TypeOfTemplate
dll import/export and compiler message
virtual void registerType()
Register type to typeOf<T>, to avoid both TypeImpl<T> and type() being present.
Object is thread safe, multiple calls can occur in different threads in parallel. ...
boost::function< PropertyBase *(void *)> PropertyMemberGetter
ObjectTypeBuilder(bool autoRegister=true)
#define QI_MT_TEMPLATE_OBJECT(name,...)
_QI_BOUNCE_TYPE_METHODS(Methods)
void setThreadingModel(ObjectThreadingModel model)
unsigned int advertiseMethod(const std::string &name, FUNCTION_TYPE function, MetaCallType threadingModel=MetaCallType_Auto, int id=-1)
TypeInterface * templateArgument() override
const MetaObject & metaObject()
unsigned int advertiseFactory(const std::string &name)
unsigned int advertise(ObjectTypeBuilderBase *builder, const std::string &name, A accessor, Dummy< 0 >)
ObjectThreadingModel
Possible thread models for an object.
QI_TEMPLATE_TYPE_DECLARE(qi::Promise)