308 lines
9.0 KiB
C++
308 lines
9.0 KiB
C++
#ifndef HX_CLASS_H
|
|
#define HX_CLASS_H
|
|
|
|
|
|
namespace hx
|
|
{
|
|
// --- hxClassOf --------------------------------------------------------------
|
|
//
|
|
// Gets the class definition that relates to a specific type.
|
|
// Most classes have their own class data, but the standard types (non-classes)
|
|
// use the template traits to get the class
|
|
|
|
|
|
template<typename T>
|
|
inline hx::Class &ClassOf() { typedef typename T::Obj Obj; return Obj::__SGetClass(); }
|
|
|
|
template<>
|
|
inline hx::Class &ClassOf<int>() { return GetIntClass(); }
|
|
|
|
template<>
|
|
inline hx::Class &ClassOf<double>() { return GetFloatClass(); }
|
|
|
|
template<>
|
|
inline hx::Class &ClassOf<float>() { return GetFloatClass(); }
|
|
|
|
template<>
|
|
inline hx::Class &ClassOf<bool>() { return GetBoolClass(); }
|
|
|
|
template<>
|
|
inline hx::Class &ClassOf<null>() { return GetVoidClass(); }
|
|
|
|
template<>
|
|
inline hx::Class &ClassOf<String>() { return GetStringClass(); }
|
|
|
|
template<>
|
|
inline hx::Class &ClassOf< ::cpp::Int64>() { return GetInt64Class(); }
|
|
|
|
|
|
template<typename T>
|
|
struct hxBaseType { typedef T type; };
|
|
template<typename T>
|
|
struct hxBaseType< hx::ObjectPtr<T> > { typedef T type; };
|
|
|
|
template<typename T> inline int ClassSizeOf() { return sizeof( typename hx::hxBaseType<T>::type ); }
|
|
|
|
} // end namespace hx
|
|
|
|
|
|
// --- Class_obj --------------------------------------------------------------------
|
|
//
|
|
// The Class_obj provides the type information required by the Reflect and type APIs.
|
|
|
|
namespace hx
|
|
{
|
|
typedef Dynamic (*ConstructEmptyFunc)();
|
|
typedef Dynamic (*ConstructArgsFunc)(DynamicArray inArgs);
|
|
typedef Dynamic (*ConstructEnumFunc)(String inName,DynamicArray inArgs);
|
|
typedef void (*MarkFunc)(hx::MarkContext *__inCtx);
|
|
typedef bool (*CanCastFunc)(hx::Object *inPtr);
|
|
#ifdef HXCPP_VISIT_ALLOCS
|
|
typedef void (*VisitFunc)(hx::VisitContext *__inCtx);
|
|
#endif
|
|
typedef bool (*GetStaticFieldFunc)(const String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
|
|
typedef bool (*SetStaticFieldFunc)(const String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
|
|
}
|
|
|
|
inline bool operator!=(hx::ConstructEnumFunc inFunc,const null &inNull) { return inFunc!=0; }
|
|
|
|
#ifdef HXCPP_SCRIPTABLE
|
|
namespace hx
|
|
{
|
|
enum FieldStorage
|
|
{
|
|
fsUnknown = 0,
|
|
fsBool,
|
|
fsInt,
|
|
fsFloat,
|
|
fsString,
|
|
fsByte,
|
|
fsObject,
|
|
};
|
|
struct StorageInfo
|
|
{
|
|
FieldStorage type;
|
|
int offset;
|
|
String name;
|
|
};
|
|
struct StaticInfo
|
|
{
|
|
FieldStorage type;
|
|
void *address;
|
|
String name;
|
|
};
|
|
|
|
}
|
|
#endif
|
|
|
|
namespace hx
|
|
{
|
|
|
|
class HXCPP_EXTERN_CLASS_ATTRIBUTES Class_obj : public hx::Object
|
|
{
|
|
public:
|
|
HX_IS_INSTANCE_OF enum { _hx_ClassId = hx::clsIdClass };
|
|
|
|
|
|
inline void *operator new( size_t inSize )
|
|
{
|
|
return hx::InternalCreateConstBuffer(0,(int)inSize);
|
|
}
|
|
void operator delete( void *) { }
|
|
|
|
|
|
Class_obj() : mSuper(0) { };
|
|
Class_obj(const String &inClassName, String inStatics[], String inMembers[],
|
|
hx::ConstructEmptyFunc inConstructEmpty, hx::ConstructArgsFunc inConstructArgs,
|
|
hx::Class *inSuperClass, hx::ConstructEnumFunc inConstructEnum,
|
|
hx::CanCastFunc inCanCast, hx::MarkFunc inMarkFunc
|
|
#ifdef HXCPP_VISIT_ALLOCS
|
|
, hx::VisitFunc inVisitFunc
|
|
#endif
|
|
#ifdef HXCPP_SCRIPTABLE
|
|
,const hx::StorageInfo *inStorageInfo
|
|
,const hx::StaticInfo *inStaticInfo
|
|
#endif
|
|
);
|
|
|
|
String __ToString() const;
|
|
|
|
void MarkStatics(hx::MarkContext *__inCtx);
|
|
|
|
#ifdef HXCPP_VISIT_ALLOCS
|
|
void VisitStatics(hx::VisitContext *__inCtx);
|
|
#endif
|
|
|
|
static ::Array< ::String > dupFunctions(String inStatics[]);
|
|
|
|
// the "Class class"
|
|
hx::Class __GetClass() const;
|
|
static hx::Class & __SGetClass();
|
|
static void __boot();
|
|
|
|
hx::Val __Field(const String &inString ,hx::PropertyAccess inCallProp);
|
|
|
|
hx::Val __SetField(const String &inString,const hx::Val &inValue ,hx::PropertyAccess inCallProp);
|
|
|
|
bool __HasField(const String &inString);
|
|
|
|
virtual Dynamic ConstructEmpty();
|
|
virtual Dynamic ConstructArgs(hx::DynamicArray inArgs);
|
|
virtual Dynamic ConstructEnum(String inName,hx::DynamicArray inArgs);
|
|
virtual bool VCanCast(hx::Object *inPtr) { return false; }
|
|
|
|
int __GetType() const { return vtObject; }
|
|
|
|
virtual bool __IsEnum();
|
|
|
|
inline bool CanCast(hx::Object *inPtr) { return mCanCast ? mCanCast(inPtr) : VCanCast(inPtr); }
|
|
static bool GetNoStaticField(const String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
|
|
static bool SetNoStaticField(const String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
|
|
|
|
void registerScriptable(bool inOverwrite);
|
|
|
|
hx::CanCastFunc mCanCast;
|
|
|
|
|
|
|
|
virtual Array<String> GetInstanceFields();
|
|
virtual Array<String> GetClassFields();
|
|
hx::Class GetSuper();
|
|
#ifdef HXCPP_SCRIPTABLE
|
|
const hx::StorageInfo* GetMemberStorage(String inName);
|
|
const hx::StaticInfo* GetStaticStorage(String inName);
|
|
#endif
|
|
|
|
static hx::Class Resolve(String inName);
|
|
|
|
|
|
hx::Class *mSuper;
|
|
String mName;
|
|
Dynamic __meta__;
|
|
String __rtti__;
|
|
|
|
hx::ConstructArgsFunc mConstructArgs;
|
|
hx::ConstructEmptyFunc mConstructEmpty;
|
|
hx::ConstructEnumFunc mConstructEnum;
|
|
hx::GetStaticFieldFunc mGetStaticField;
|
|
hx::SetStaticFieldFunc mSetStaticField;
|
|
|
|
hx::MarkFunc mMarkFunc;
|
|
#ifdef HXCPP_VISIT_ALLOCS
|
|
hx::VisitFunc mVisitFunc;
|
|
#endif
|
|
Array<String> mStatics;
|
|
Array<String> mMembers;
|
|
|
|
#ifdef HXCPP_SCRIPTABLE
|
|
const hx::StorageInfo* mMemberStorageInfo;
|
|
const hx::StaticInfo* mStaticStorageInfo;
|
|
#endif
|
|
};
|
|
|
|
} // end namespace hx
|
|
|
|
void __hxcpp_boot_std_classes();
|
|
|
|
|
|
// --- All classes should be registered with this function via the "__boot" method
|
|
#ifdef RegisterClass
|
|
#undef RegisterClass
|
|
#endif
|
|
|
|
namespace hx
|
|
{
|
|
|
|
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
|
hx::Class _hx_RegisterClass(const String &inClassName, CanCastFunc inCanCast,
|
|
String inStatics[], String inMembers[],
|
|
ConstructEmptyFunc inConstructEmpty, ConstructArgsFunc inConstructArgs,
|
|
hx::Class *inSuperClass, ConstructEnumFunc inConst=0, MarkFunc inMarkFunc=0
|
|
#ifdef HXCPP_VISIT_ALLOCS
|
|
, VisitFunc inVisitFunc=0
|
|
#endif
|
|
#ifdef HXCPP_SCRIPTABLE
|
|
,const hx::StorageInfo *inStorageInfo=0
|
|
,const hx::StaticInfo *inStaticInfo=0
|
|
#endif
|
|
);
|
|
|
|
// For older versions
|
|
inline hx::Class RegisterClass(
|
|
const String &inClassName, CanCastFunc inCanCast,
|
|
String inStatics[], String inMembers[],
|
|
ConstructEmptyFunc inConstructEmpty, ConstructArgsFunc inConstructArgs,
|
|
hx::Class *inSuperClass, ConstructEnumFunc inConst=0, MarkFunc inMarkFunc=0
|
|
#ifdef HXCPP_VISIT_ALLOCS
|
|
, VisitFunc inVisitFunc=0
|
|
#endif
|
|
#ifdef HXCPP_SCRIPTABLE
|
|
,const hx::StorageInfo *inStorageInfo=0
|
|
,const hx::StaticInfo *inStaticInfo=0
|
|
#endif
|
|
)
|
|
{
|
|
return _hx_RegisterClass(inClassName, inCanCast, inStatics, inMembers,
|
|
inConstructEmpty, inConstructArgs, inSuperClass, inConst, inMarkFunc
|
|
#ifdef HXCPP_VISIT_ALLOCS
|
|
, inVisitFunc
|
|
#endif
|
|
#ifdef HXCPP_SCRIPTABLE
|
|
,inStorageInfo ,inStaticInfo
|
|
#endif
|
|
);
|
|
}
|
|
|
|
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES
|
|
void _hx_RegisterClass(const String &inClassName, hx::Class inClass);
|
|
|
|
inline void RegisterClass(const String &inClassName, hx::Class inClass)
|
|
{
|
|
_hx_RegisterClass(inClassName, inClass);
|
|
}
|
|
|
|
template<typename T>
|
|
inline bool TCanCast(hx::Object *inPtr)
|
|
{
|
|
return inPtr && (
|
|
#if (HXCPP_API_LEVEL >= 332)
|
|
inPtr->_hx_isInstanceOf(T::_hx_ClassId)
|
|
#elif (HXCPP_API_LEVEL==331)
|
|
dynamic_cast<T *>(inPtr)
|
|
#else
|
|
dynamic_cast<T *>(inPtr->__GetRealObject())
|
|
#if (HXCPP_API_LEVEL < 330)
|
|
|| inPtr->__ToInterface(typeid(T))
|
|
#endif
|
|
#endif
|
|
);
|
|
}
|
|
|
|
|
|
#if (HXCPP_API_LEVEL >= 330)
|
|
template<int HASH>
|
|
inline bool TIsInterface(hx::Object *inPtr)
|
|
{
|
|
return inPtr && inPtr->_hx_getInterface(HASH);
|
|
}
|
|
#endif
|
|
|
|
|
|
HXCPP_EXTERN_CLASS_ATTRIBUTES void RegisterVTableOffset(int inOffset);
|
|
|
|
#define HX_REGISTER_VTABLE_OFFSET( CLASS, INTERFACE ) \
|
|
{ \
|
|
CLASS *dummy = (CLASS *)0; \
|
|
INTERFACE *intf = dummy; \
|
|
hx::RegisterVTableOffset( (int)( (size_t)((char *)intf - (char *)dummy)) ); \
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
#endif
|